import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
public RouteTableDTO(final RouteTable routeTable) {
    this.routeTableId = routeTable.getRouteTableId();
    this.vpcId = routeTable.getVpcId();
    this.routes.addAll(
        routeTable.getRoutes()
            .stream()
            .map(RouteDTO::new)
            .collect(Collectors.toList()));
    this.tags.addAll(
        routeTable.getTags()
            .stream()
            .map(TagDTO::new)
            .collect(Collectors.toList()));
    this.associations.addAll(
        routeTable.getAssociations()
            .stream()
            .map(RouteTableAssociationDTO::new)
            .collect(Collectors.toList()));
    this.propagatingVgws.addAll(
        routeTable.getPropagatingVgws()
            .stream()
            .map(PropagatingVgwDTO::new)
            .collect(Collectors.toList()));
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Get the main route table for a given VPC
 */
public RouteTable getMainRouteTable(String vpcId) {
    // build filter list
    List<Filter> filters = new ArrayList<>();
    filters.add(AWSUtils.getFilter(AWSUtils.AWS_FILTER_VPC_ID, vpcId));
    filters.add(AWSUtils.getFilter(AWS_MAIN_ROUTE_ASSOCIATION, "true"));

    DescribeRouteTablesRequest req = new DescribeRouteTablesRequest()
            .withFilters(filters);
    DescribeRouteTablesResult res = this.client.describeRouteTables(req);
    List<RouteTable> routeTables = res.getRouteTables();
    return routeTables.isEmpty() ? null : routeTables.get(0);
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Create a route table
 */
public DeferredResult<String> createRouteTable(String vpcId) {
    CreateRouteTableRequest req = new CreateRouteTableRequest()
            .withVpcId(vpcId);

    String message = "Create AWS Route Table on VPC [" + vpcId + "].";

    AWSDeferredResultAsyncHandler<CreateRouteTableRequest, CreateRouteTableResult> handler = new
            AWSDeferredResultAsyncHandler<>(this.service, message);
    this.client.createRouteTableAsync(req, handler);
    return handler.toDeferredResult()
            .thenApply(CreateRouteTableResult::getRouteTable)
            .thenApply(RouteTable::getRouteTableId);
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Update the main route table information for the VPC that is being mapped to a network
 * state. Query AWS for the main route tables with a list of VPCs. From the result set find
 * the relevant route table Id and upda
 */
@Override
protected void consumeSuccess(DescribeRouteTablesRequest request,
        DescribeRouteTablesResult result) {
    for (RouteTable routeTable : result.getRouteTables()) {
        if (this.context.vpcs.containsKey(routeTable.getVpcId())) {
            NetworkState networkStateToUpdate = this.context.vpcs
                    .get(routeTable.getVpcId());
            networkStateToUpdate.customProperties.put(AWS_VPC_ROUTE_TABLE_ID,
                    routeTable.getRouteTableId());
            this.context.vpcs.put(routeTable.getVpcId(),
                    networkStateToUpdate);
        }
    }
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
@Test
public void testGetMainRouteTable() throws Throwable {
    Vpc defVPC = this.netClient.getDefaultVPC();
    assertTrue(defVPC != null);
    RouteTable routeTable = this.netClient.getMainRouteTable(defVPC.getVpcId());
    assertTrue(routeTable != null);
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
@Test
public void testEnvironmentCreation() throws Throwable {
    boolean attached = false;

    String gatewayID = this.netClient.createInternetGateway();
    assertTrue(gatewayID != null);
    String vpcID = this.netClient.createVPC(AWS_DEFAULT_SUBNET_CIDR);
    assertTrue(vpcID != null);
    String subnetID = this.netClient.createSubnet(AWS_DEFAULT_SUBNET_CIDR, vpcID).getSubnetId();

    this.netClient.attachInternetGateway(vpcID, gatewayID);
    InternetGateway gw = this.netClient.getInternetGateway(gatewayID);
    List<InternetGatewayAttachment> attachments = gw.getAttachments();
    // ensure we are attached to newly created vpc
    for (InternetGatewayAttachment attachment : attachments) {
        if (attachment.getVpcId().equalsIgnoreCase(vpcID)) {
            attached = true;
            break;
        }
    }
    assertTrue(attached);
    RouteTable routeTable = this.netClient.getMainRouteTable(vpcID);
    this.netClient.createInternetRoute(gatewayID, routeTable.getRouteTableId(), "0.0.0.0/0");

    //remove resources
    this.netClient.detachInternetGateway(vpcID, gatewayID);
    this.netClient.deleteInternetGateway(gatewayID);
    this.netClient.deleteSubnet(subnetID);
    this.netClient.deleteVPC(vpcID);
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
public VpcDetailDTO(final Vpc vpc, final List<Subnet> subnets, final List<RouteTable> routeTables) {
    super(vpc);

    final Map<String, SubnetDetailDTO> subnetDetails = new HashMap<>();
    subnetDetails.putAll(
        subnets.stream()
            .map(SubnetDetailDTO::new)
            .collect(Collectors.toMap(s -> s.getSubnetId(), identity())));

    LOG.trace("Details map: {}", subnetDetails);

    routeTables.stream()
        .map(RouteTableDTO::new)
        .forEach(rt ->
            rt.getAssociations().forEach(assoc -> {
                SubnetDetailDTO dto = subnetDetails.get(assoc.getSubnetId());

                if (dto == null) {
                    if (LOG.isTraceEnabled()) {
                        LOG.trace("RT: {}, Assoc.SubnetID: {}, Assocs: {}",
                            rt.getRouteTableId(),
                            assoc.getSubnetId(),
                            rt.getAssociations());
                    }

                    return;
                }

                dto.setRouteTableId(rt.getRouteTableId());
                dto.getRoutes().addAll(rt.getRoutes());
            }));

    this.subnets.addAll(subnetDetails.values());
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
public SubnetDetailDTO(final Subnet subnet, final RouteTable routeTable) {
    super(subnet);

    routeTableId = routeTable.getRouteTableId();
    routes.addAll(
        routeTable.getRoutes()
            .stream()
            .map(RouteDTO::new)
            .collect(Collectors.toList()));
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
@Override
@Cacheable(value = CachingConfiguration.ROUTE_TABLE_CACHE, key = "#vpcId", condition = "#bypassCache == false")
public List<RouteTable> getRouteTablesForVpcInRegion(final String vpcId, final String region, boolean bypassCache) {
    LOG.info("Retrieving route tables for VPC {} in region {} ({})", vpcId, region, bypassCache);
    DescribeRouteTablesRequest request = new DescribeRouteTablesRequest()
        .withFilters(new Filter()
            .withName("vpc-id")
            .withValues(vpcId));
    DescribeRouteTablesResult result = getClientForRegion(region).describeRouteTables(request);
    return result.getRouteTables();
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
public List<AbstractResource<?>> toVpcRouteTables(List<RouteTable> routeTables, String accountId, Region region, DateTime dt) {
    List<AbstractResource<?>> resources = new ArrayList<>();
    for (RouteTable routeTable : routeTables) {
        VpcRouteTable vpcRouteTable = new VpcRouteTable();
        conf(vpcRouteTable, accountId, region, dt);
        vpcRouteTable.setResource(routeTable);
        resources.add(vpcRouteTable);
    }
    log.debug("{} route tables found via api and converted to VpcRouteTable", resources.size());
    return resources;
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Checks if routes between the selected VPCs already exist
 *
 * @param vpnEndpoints
 * @return
 */
private boolean checkIfRoutesExist(List<VPNEndpoint> vpnEndpoints) {
  boolean routesExist = false;

  for (VPNEndpoint vpnEndpoint : vpnEndpoints) {
    ec2Client.setEndpoint(vpnEndpoint.getRegion().getEndpoint());
    DescribeRouteTablesResult descRouteTableResult = ec2Client.describeRouteTables();
    List<RouteTable> routeTables = descRouteTableResult.getRouteTables();

    for (RouteTable routeTable : routeTables) {
      if (routeTable.getVpcId().equals(vpnEndpoint.getVpc().getVpcId())) {
        List<Route> routes = routeTable.getRoutes();
        for (Route route : routes) {
          for (VPNEndpoint extVpnEndpoint : vpnEndpoints) {
            if (!vpnEndpoint.equals(extVpnEndpoint)) {
              LOG.debug("Checking if route allows requested traffic: " + route);
              if (route.getDestinationCidrBlock().endsWith(extVpnEndpoint.getVpc().getCidrBlock())) {
                routesExist = true;
                LOG.error("A route already exists between " + vpnEndpoint.getVpc().getCidrBlock() + " and " + extVpnEndpoint.getVpc().getCidrBlock());
              }
            }
          }
        }
      }
    }

  }

  return routesExist;
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Create routes
 *
 * @param vpnEndpoints
 */
private void createAndAssociateRoutes(List<VPNEndpoint> vpnEndpoints) {

  for (VPNEndpoint vpnEndpoint : vpnEndpoints) {
    ec2Client.setEndpoint(vpnEndpoint.getRegion().getEndpoint());

    for (VPNEndpoint extVpnEndpoint : vpnEndpoints) {
      if (!vpnEndpoint.equals(extVpnEndpoint)) {

        // Get route tables
        DescribeRouteTablesResult descRouteTablesResult = ec2Client.describeRouteTables();
        List<RouteTable> routeTables = descRouteTablesResult.getRouteTables();
        for (RouteTable routeTable : routeTables) {
          if (routeTable.getVpcId().equals(vpnEndpoint.getVpc().getVpcId())) {
            // Create the route
            CreateRouteRequest createRouteReq = new CreateRouteRequest();
            createRouteReq.setDestinationCidrBlock(extVpnEndpoint.getVpc().getCidrBlock());
            createRouteReq.setInstanceId(vpnEndpoint.getInstance().getInstanceId());
            createRouteReq.setRouteTableId(routeTable.getRouteTableId());
            LOG.debug("About to create a route in " + vpnEndpoint.getVpc().getVpcId() + " to " + extVpnEndpoint.getVpc().getVpcId() + " in route table: " + routeTable.getRouteTableId());
            ec2Client.createRoute(createRouteReq);
            LOG.debug("Created route in " + vpnEndpoint.getVpc().getVpcId() + " to " + extVpnEndpoint.getVpc().getVpcId() + " in route table: " + routeTable.getRouteTableId());
          }
        }
      }
    }

  }

}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
public HashMap<Region, List> listRegionRouteTables(AWSCredentials awsCreds) {
  AmazonEC2Client ec2Client = new AmazonEC2Client(awsCreds);
  List<Region> regions = new ArrayList();

  DescribeRegionsResult descRegionsResult = ec2Client.describeRegions();
  if (descRegionsResult != null) {
    regions = descRegionsResult.getRegions();
  }

  HashMap<Region, List> regionRouteTablesMap = new HashMap();

  ExecutorService listRouteTablesExecutor = Executors.newFixedThreadPool(8);
  for (Region region : regions) {
    List<RouteTable> routeTables = new ArrayList();
    regionRouteTablesMap.put(region, routeTables);

    Runnable worker = new ListRouteTableRunnable(awsCreds, region, routeTables);
    listRouteTablesExecutor.execute(worker);
  }

  listRouteTablesExecutor.shutdown();
  try {
    listRouteTablesExecutor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
  } catch (InterruptedException e) {
    LOG.error("Caught InterruptedException: " + e.getMessage());
  }

  return regionRouteTablesMap;
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
public ListRouteTableRunnable(AWSCredentials awsCreds, Region region, List<RouteTable> routeTables) {
  this.region = region;
  this.routeTables = routeTables;
  ec2Client = new AmazonEC2Client(awsCreds);
  ec2Client.setEndpoint(region.getEndpoint());
  LOG.debug("Set endpoint to " + region.getEndpoint());
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
private void visitRouteTable(VPCDiagramBuilder vpcDiagram, RouteTable routeTable) throws CfnAssistException {
logger.debug("visit routetable " + routeTable.getRouteTableId());
List<Route> routes = routeTable.getRoutes();
List<RouteTableAssociation> usersOfTable = routeTable.getAssociations();
for (RouteTableAssociation usedBy : usersOfTable) {
	String subnetId = usedBy.getSubnetId(); // can subnet ever be null in an association?
	
	if (subnetId!=null) {
		vpcDiagram.addAsssociatedRouteTable(routeTable, subnetId); // possible duplication if route table reused?
		for (Route route : routes) {
			vpcDiagram.addRoute(routeTable.getRouteTableId(), subnetId, route);
		}
	} 
}
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
public void addRouteTable(RouteTable routeTable) throws CfnAssistException {
	String name = AmazonVPCFacade.getNameFromTags(routeTable.getTags());
	String routeTableId = routeTable.getRouteTableId();
	String label = AmazonVPCFacade.createLabelFromNameAndID(routeTableId, name);
	
	String diagramIdForTable = formRouteTableIdForDiagram(id, routeTableId);
	networkChildDiagram.addRouteTable(diagramIdForTable, label);
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Test describing route table.
 */
@Test(timeout = TIMEOUT_LEVEL1)
public final void describeRouteTableTest() {
    log.info("Start describing route table test");
    createRouteTableTest();
    
    RouteTable routeTable = getRouteTable();

    Assert.assertNotNull("route table should not be null", routeTable);
    Assert.assertNotNull("route table id should not be null", routeTable.getRouteTableId());
    
    Assert.assertTrue("route table should be deleted", deleteRouteTable(routeTable.getRouteTableId()));
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Test create route table.
 */
@Test(timeout = TIMEOUT_LEVEL1)
public final void createRouteTableTest() {
    log.info("Start create route table test");
    Vpc vpc = createVpc(MOCK_CIDR_BLOCK, PROPERTY_TENANCY);
    
    RouteTable routeTable = createRouteTable(vpc.getVpcId());
    
    Assert.assertNotNull("route table should not be null", routeTable);
    Assert.assertNotNull("route table id should not be null", routeTable.getRouteTableId());
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Test Delete route table.
 */
@Test(timeout = TIMEOUT_LEVEL1)
public final void deleteRouteTableTest() {
    log.info("Start delete route table test");
    Vpc vpc = createVpc(MOCK_CIDR_BLOCK, PROPERTY_TENANCY);

    RouteTable routeTable = createRouteTable(vpc.getVpcId());

    Assert.assertNotNull("route table should not be null", routeTable);
    Assert.assertNotNull("route table id should not be null", routeTable.getRouteTableId());

    Assert.assertTrue("route table should be deleted", deleteRouteTable(routeTable.getRouteTableId()));
}
 

import com.amazonaws.services.ec2.model.RouteTable; //导入依赖的package包/类
/**
 * Test create Volumes.
 */
@Test(timeout = TIMEOUT_LEVEL1)
public final void createNetworkResourcesTest() {
    
    //Create VPCs
    for(int i =0 ; i < 2 ; i++)
    {
        createVpcTest(); 
    }
    
    List<Vpc> vpcs = describeVpcs();
    
    // Create Subnet
    for(Vpc vpc : vpcs) {
        
        for(int j=0; j<2; j++)
        {
            Subnet subnet = createSubnet(MOCK_CIDR_BLOCK, vpc.getVpcId());
            RouteTable routeTable = createRouteTable(vpc.getVpcId());
            InternetGateway internetGateway = createInternetGateway();

            createRoute(routeTable.getRouteTableId(), internetGateway.getInternetGatewayId(), MOCK_CIDR_BLOCK);
            
            attachInternetGateway(internetGateway.getInternetGatewayId(), vpc.getVpcId());
        }
    }
}