cartography 0.102.0rc1__py3-none-any.whl → 0.102.0rc2__py3-none-any.whl

cartography/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.102.0rc1'
+__version__ = version = '0.102.0rc2'
 __version_tuple__ = version_tuple = (0, 102, 0)

cartography/intel/aws/ec2/route_tables.py

@@ -0,0 +1,287 @@
+import logging
+from typing import Any
+
+import boto3
+import neo4j
+
+from cartography.client.core.tx import load
+from cartography.graph.job import GraphJob
+from cartography.intel.aws.ec2.util import get_botocore_config
+from cartography.models.aws.ec2.route_table_associations import RouteTableAssociationSchema
+from cartography.models.aws.ec2.route_tables import RouteTableSchema
+from cartography.models.aws.ec2.routes import RouteSchema
+from cartography.util import aws_handle_regions
+from cartography.util import timeit
+
+logger = logging.getLogger(__name__)
+
+
+def _get_route_id_and_target(route_table_id: str, route: dict[str, Any]) -> tuple[str, str | None]:
+    """
+    Generate a unique identifier for an AWS EC2 route and return the target of the route
+    regardless of its type.
+
+    Args:
+        route_table_id: The ID of the route table this route belongs to
+        route: The route data from AWS API
+
+    Returns:
+        A tuple containing the unique identifier for the route and the target of the route
+    """
+    route_target_keys = [
+        'DestinationCidrBlock',
+        'DestinationIpv6CidrBlock',
+        'GatewayId',
+        'InstanceId',
+        'NatGatewayId',
+        'TransitGatewayId',
+        'LocalGatewayId',
+        'CarrierGatewayId',
+        'NetworkInterfaceId',
+        'VpcPeeringConnectionId',
+        'EgressOnlyInternetGatewayId',
+        'CoreNetworkArn',
+    ]
+
+    # Start with the route table ID
+    parts = [route_table_id]
+    target = None
+    found_target = False
+
+    for key in route_target_keys:
+        # Each route is a "union"-like data structure, so only one of the keys will be present.
+        if key in route:
+            parts.append(route[key])
+            target = route[key]
+            found_target = True
+            break
+
+    if not found_target:
+        logger.warning(
+            f"No target found for route in {route_table_id}. Please review the route and file an issue to "
+            "https://github.com/cartography-cncf/cartography/issues sharing what the route table looks like "
+            "so that we can update the available keys.",
+        )
+
+    return '|'.join(parts), target
+
+
+@timeit
+@aws_handle_regions
+def get_route_tables(boto3_session: boto3.session.Session, region: str) -> list[dict[str, Any]]:
+    client = boto3_session.client('ec2', region_name=region, config=get_botocore_config())
+    paginator = client.get_paginator('describe_route_tables')
+    route_tables: list[dict[str, Any]] = []
+    for page in paginator.paginate():
+        route_tables.extend(page['RouteTables'])
+    return route_tables
+
+
+def _transform_route_table_associations(
+        route_table_id: str,
+        associations: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], bool]:
+    """
+    Transform route table association data into a format suitable for cartography ingestion.
+
+    Args:
+        route_table_id: The ID of the route table
+        associations: List of association data from AWS API
+
+    Returns:
+        1. List of transformed association data
+        2. Boolean indicating if the association is the main association, meaning that the route table is the main
+        route table for the VPC
+    """
+    transformed = []
+    is_main = False
+    for association in associations:
+        if association.get('SubnetId'):
+            target = association['SubnetId']
+        elif association.get('GatewayId'):
+            target = association['GatewayId']
+        else:
+            is_main = True
+            target = 'main'
+
+        transformed_association = {
+            'id': association['RouteTableAssociationId'],
+            'route_table_id': route_table_id,
+            'subnet_id': association.get('SubnetId'),
+            'gateway_id': association.get('GatewayId'),
+            'main': association.get('Main', False),
+            'association_state': association.get('AssociationState', {}).get('State'),
+            'association_state_message': association.get('AssociationState', {}).get('Message'),
+            '_target': target,
+        }
+        transformed.append(transformed_association)
+    return transformed, is_main
+
+
+def _transform_route_table_routes(route_table_id: str, routes: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """
+    Transform route table route data into a format suitable for cartography ingestion.
+
+    Args:
+        route_table_id: The ID of the route table
+        routes: List of route data from AWS API
+
+    Returns:
+        List of transformed route data
+    """
+    transformed = []
+    for route in routes:
+        route_id, target = _get_route_id_and_target(route_table_id, route)
+
+        transformed_route = {
+            'id': route_id,
+            'route_table_id': route_table_id,
+            'destination_cidr_block': route.get('DestinationCidrBlock'),
+            'destination_ipv6_cidr_block': route.get('DestinationIpv6CidrBlock'),
+            'gateway_id': route.get('GatewayId'),
+            'instance_id': route.get('InstanceId'),
+            'instance_owner_id': route.get('InstanceOwnerId'),
+            'nat_gateway_id': route.get('NatGatewayId'),
+            'transit_gateway_id': route.get('TransitGatewayId'),
+            'local_gateway_id': route.get('LocalGatewayId'),
+            'carrier_gateway_id': route.get('CarrierGatewayId'),
+            'network_interface_id': route.get('NetworkInterfaceId'),
+            'vpc_peering_connection_id': route.get('VpcPeeringConnectionId'),
+            'state': route.get('State'),
+            'origin': route.get('Origin'),
+            'core_network_arn': route.get('CoreNetworkArn'),
+            'destination_prefix_list_id': route.get('DestinationPrefixListId'),
+            'egress_only_internet_gateway_id': route.get('EgressOnlyInternetGatewayId'),
+            '_target': target,
+        }
+        transformed.append(transformed_route)
+    return transformed
+
+
+def transform_route_table_data(
+        route_tables: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[dict[str, Any]]]:
+    """
+    Transform route table data into a format suitable for cartography ingestion.
+
+    Args:
+        route_tables: List of route table data from AWS API
+
+    Returns:
+        Tuple of (transformed route table data, transformed association data, transformed route data)
+    """
+    transformed_tables = []
+    association_data = []
+    route_data = []
+
+    for rt in route_tables:
+        route_table_id = rt['RouteTableId']
+
+        # Transform routes
+        current_routes = []
+        if rt.get('Routes'):
+            current_routes = _transform_route_table_routes(route_table_id, rt['Routes'])
+            route_data.extend(current_routes)
+
+        # If the rt has a association marked with main=True, then it is the main route table for the VPC.
+        is_main = False
+        # Transform associations
+        if rt.get('Associations'):
+            associations, is_main = _transform_route_table_associations(route_table_id, rt['Associations'])
+            association_data.extend(associations)
+
+        transformed_rt = {
+            'id': route_table_id,
+            'route_table_id': route_table_id,
+            'owner_id': rt.get('OwnerId'),
+            'vpc_id': rt.get('VpcId'),
+            'VpnGatewayIds': [vgw['GatewayId'] for vgw in rt.get('PropagatingVgws', [])],
+            'RouteTableAssociationIds': [assoc['RouteTableAssociationId'] for assoc in rt.get('Associations', [])],
+            'RouteIds': [route['id'] for route in current_routes],
+            'tags': rt.get('Tags', []),
+            'main': is_main,
+        }
+        transformed_tables.append(transformed_rt)
+
+    return transformed_tables, association_data, route_data
+
+
+@timeit
+def load_route_tables(
+        neo4j_session: neo4j.Session,
+        data: list[dict[str, Any]],
+        region: str,
+        current_aws_account_id: str,
+        update_tag: int,
+) -> None:
+    load(
+        neo4j_session,
+        RouteTableSchema(),
+        data,
+        Region=region,
+        AWS_ID=current_aws_account_id,
+        lastupdated=update_tag,
+    )
+
+
+@timeit
+def load_route_table_associations(
+        neo4j_session: neo4j.Session,
+        data: list[dict[str, Any]],
+        region: str,
+        current_aws_account_id: str,
+        update_tag: int,
+) -> None:
+    load(
+        neo4j_session,
+        RouteTableAssociationSchema(),
+        data,
+        Region=region,
+        AWS_ID=current_aws_account_id,
+        lastupdated=update_tag,
+    )
+
+
+@timeit
+def load_routes(
+        neo4j_session: neo4j.Session,
+        data: list[dict[str, Any]],
+        region: str,
+        current_aws_account_id: str,
+        update_tag: int,
+) -> None:
+    load(
+        neo4j_session,
+        RouteSchema(),
+        data,
+        Region=region,
+        AWS_ID=current_aws_account_id,
+        lastupdated=update_tag,
+    )
+
+
+@timeit
+def cleanup(neo4j_session: neo4j.Session, common_job_parameters: dict[str, Any]) -> None:
+    logger.debug("Running EC2 route tables cleanup")
+    GraphJob.from_node_schema(RouteTableSchema(), common_job_parameters).run(neo4j_session)
+    GraphJob.from_node_schema(RouteSchema(), common_job_parameters).run(neo4j_session)
+    GraphJob.from_node_schema(RouteTableAssociationSchema(), common_job_parameters).run(neo4j_session)
+
+
+@timeit
+def sync_route_tables(
+        neo4j_session: neo4j.Session,
+        boto3_session: boto3.session.Session,
+        regions: list[str],
+        current_aws_account_id: str,
+        update_tag: int,
+        common_job_parameters: dict[str, Any],
+) -> None:
+    for region in regions:
+        logger.info("Syncing EC2 route tables for region '%s' in account '%s'.", region, current_aws_account_id)
+        route_tables = get_route_tables(boto3_session, region)
+        transformed_tables, association_data, route_data = transform_route_table_data(route_tables)
+        load_routes(neo4j_session, route_data, region, current_aws_account_id, update_tag)
+        load_route_table_associations(neo4j_session, association_data, region, current_aws_account_id, update_tag)
+        load_route_tables(neo4j_session, transformed_tables, region, current_aws_account_id, update_tag)
+    cleanup(neo4j_session, common_job_parameters)

cartography/intel/aws/resources.py

@@ -45,6 +45,7 @@ from .ec2.volumes import sync_ebs_volumes
 from .ec2.vpc import sync_vpc
 from .ec2.vpc_peerings import sync_vpc_peerings
 from .iam_instance_profiles import sync_iam_instance_profiles
+from cartography.intel.aws.ec2.route_tables import sync_route_tables
 
 RESOURCE_FUNCTIONS: Dict[str, Callable[..., None]] = {
     'iam': iam.sync,
@@ -62,6 +63,7 @@ RESOURCE_FUNCTIONS: Dict[str, Callable[..., None]] = {
     'ec2:load_balancer_v2': sync_load_balancer_v2s,
     'ec2:network_acls': sync_network_acls,
     'ec2:network_interface': sync_network_interfaces,
+    'ec2:route_table': sync_route_tables,
     'ec2:security_group': sync_ec2_security_groupinfo,
     'ec2:subnet': sync_subnets,
     'ec2:tgw': sync_transit_gateways,

cartography/models/aws/ec2/route_table_associations.py

@@ -0,0 +1,87 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef('id')
+    route_table_association_id: PropertyRef = PropertyRef('id', extra_index=True)
+    target: PropertyRef = PropertyRef('_target')
+    gateway_id: PropertyRef = PropertyRef('gateway_id')
+    main: PropertyRef = PropertyRef('main')
+    route_table_id: PropertyRef = PropertyRef('route_table_id')
+    subnet_id: PropertyRef = PropertyRef('subnet_id')
+    association_state: PropertyRef = PropertyRef('association_state')
+    association_state_message: PropertyRef = PropertyRef('association_state_message')
+    region: PropertyRef = PropertyRef('Region', set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationToAwsAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationToAWSAccount(CartographyRelSchema):
+    target_node_label: str = 'AWSAccount'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('AWS_ID', set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: RouteTableAssociationToAwsAccountRelProperties = RouteTableAssociationToAwsAccountRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationToSubnetRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationToSubnet(CartographyRelSchema):
+    target_node_label: str = 'EC2Subnet'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'subnetid': PropertyRef('subnet_id')},
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "ASSOCIATED_SUBNET"
+    properties: RouteTableAssociationToSubnetRelProperties = RouteTableAssociationToSubnetRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationToIgwRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationToIgw(CartographyRelSchema):
+    target_node_label: str = 'AWSInternetGateway'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('gateway_id')},
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "ASSOCIATED_IGW_FOR_INGRESS"
+    properties: RouteTableAssociationToIgwRelProperties = RouteTableAssociationToIgwRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableAssociationSchema(CartographyNodeSchema):
+    label: str = 'EC2RouteTableAssociation'
+    properties: RouteTableAssociationNodeProperties = RouteTableAssociationNodeProperties()
+    sub_resource_relationship: RouteTableAssociationToAWSAccount = RouteTableAssociationToAWSAccount()
+    other_relationships: OtherRelationships = OtherRelationships(
+        [
+            RouteTableAssociationToSubnet(),
+            RouteTableAssociationToIgw(),
+        ],
+    )

cartography/models/aws/ec2/route_tables.py

@@ -0,0 +1,121 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class RouteTableNodeProperties(CartographyNodeProperties):
+    """
+    Schema describing a RouteTable.
+    """
+    id: PropertyRef = PropertyRef('id')
+    route_table_id: PropertyRef = PropertyRef('route_table_id', extra_index=True)
+    owner_id: PropertyRef = PropertyRef('owner_id')
+    vpc_id: PropertyRef = PropertyRef('VpcId')
+    region: PropertyRef = PropertyRef('Region', set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+    main: PropertyRef = PropertyRef('main')
+
+
+@dataclass(frozen=True)
+class RouteTableToAwsAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableToAWSAccount(CartographyRelSchema):
+    target_node_label: str = 'AWSAccount'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('AWS_ID', set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: RouteTableToAwsAccountRelProperties = RouteTableToAwsAccountRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableToVpcRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableToVpc(CartographyRelSchema):
+    target_node_label: str = 'AWSVpc'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('vpc_id')},
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "MEMBER_OF_AWS_VPC"
+    properties: RouteTableToVpcRelProperties = RouteTableToVpcRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableToRouteRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableToRoute(CartographyRelSchema):
+    target_node_label: str = 'EC2Route'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('RouteIds', one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "ROUTE"
+    properties: RouteTableToRouteRelProperties = RouteTableToRouteRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableToAssociationRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteTableToAssociation(CartographyRelSchema):
+    target_node_label: str = 'EC2RouteTableAssociation'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('RouteTableAssociationIds', one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "ASSOCIATION"
+    properties: RouteTableToAssociationRelProperties = RouteTableToAssociationRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableToVpnGatewayRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+# TODO implement AWSVpnGateways
+@dataclass(frozen=True)
+class RouteTableToVpnGateway(CartographyRelSchema):
+    target_node_label: str = 'AWSVpnGateway'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('VpnGatewayIds', one_to_many=True)},
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "CONNECTED_TO"
+    properties: RouteTableToVpnGatewayRelProperties = RouteTableToVpnGatewayRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteTableSchema(CartographyNodeSchema):
+    label: str = 'EC2RouteTable'
+    properties: RouteTableNodeProperties = RouteTableNodeProperties()
+    sub_resource_relationship: RouteTableToAWSAccount = RouteTableToAWSAccount()
+    other_relationships: OtherRelationships = OtherRelationships(
+        [
+            RouteTableToVpc(),
+            RouteTableToRoute(),
+            RouteTableToAssociation(),
+            RouteTableToVpnGateway(),
+        ],
+    )

cartography/models/aws/ec2/routes.py

@@ -0,0 +1,77 @@
+from dataclasses import dataclass
+
+from cartography.models.core.common import PropertyRef
+from cartography.models.core.nodes import CartographyNodeProperties
+from cartography.models.core.nodes import CartographyNodeSchema
+from cartography.models.core.relationships import CartographyRelProperties
+from cartography.models.core.relationships import CartographyRelSchema
+from cartography.models.core.relationships import LinkDirection
+from cartography.models.core.relationships import make_target_node_matcher
+from cartography.models.core.relationships import OtherRelationships
+from cartography.models.core.relationships import TargetNodeMatcher
+
+
+@dataclass(frozen=True)
+class RouteNodeProperties(CartographyNodeProperties):
+    id: PropertyRef = PropertyRef('id')
+    carrier_gateway_id: PropertyRef = PropertyRef('carrier_gateway_id')
+    core_network_arn: PropertyRef = PropertyRef('core_network_arn')
+    destination_cidr_block: PropertyRef = PropertyRef('destination_cidr_block')
+    destination_ipv6_cidr_block: PropertyRef = PropertyRef('destination_ipv6_cidr_block')
+    destination_prefix_list_id: PropertyRef = PropertyRef('destination_prefix_list_id')
+    egress_only_internet_gateway_id: PropertyRef = PropertyRef('egress_only_internet_gateway_id')
+    gateway_id: PropertyRef = PropertyRef('gateway_id')
+    instance_id: PropertyRef = PropertyRef('instance_id')
+    instance_owner_id: PropertyRef = PropertyRef('instance_owner_id')
+    local_gateway_id: PropertyRef = PropertyRef('local_gateway_id')
+    nat_gateway_id: PropertyRef = PropertyRef('nat_gateway_id')
+    network_interface_id: PropertyRef = PropertyRef('network_interface_id')
+    origin: PropertyRef = PropertyRef('origin')
+    state: PropertyRef = PropertyRef('state')
+    transit_gateway_id: PropertyRef = PropertyRef('transit_gateway_id')
+    vpc_peering_connection_id: PropertyRef = PropertyRef('vpc_peering_connection_id')
+    region: PropertyRef = PropertyRef('Region', set_in_kwargs=True)
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+    target: PropertyRef = PropertyRef('_target')
+
+
+@dataclass(frozen=True)
+class RouteToAwsAccountRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteToAWSAccount(CartographyRelSchema):
+    target_node_label: str = 'AWSAccount'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('AWS_ID', set_in_kwargs=True)},
+    )
+    direction: LinkDirection = LinkDirection.INWARD
+    rel_label: str = "RESOURCE"
+    properties: RouteToAwsAccountRelProperties = RouteToAwsAccountRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteToInternetGatewayRelProperties(CartographyRelProperties):
+    lastupdated: PropertyRef = PropertyRef('lastupdated', set_in_kwargs=True)
+
+
+@dataclass(frozen=True)
+class RouteToInternetGateway(CartographyRelSchema):
+    target_node_label: str = 'AWSInternetGateway'
+    target_node_matcher: TargetNodeMatcher = make_target_node_matcher(
+        {'id': PropertyRef('gateway_id')},
+    )
+    direction: LinkDirection = LinkDirection.OUTWARD
+    rel_label: str = "ROUTES_TO_GATEWAY"
+    properties: RouteToInternetGatewayRelProperties = RouteToInternetGatewayRelProperties()
+
+
+@dataclass(frozen=True)
+class RouteSchema(CartographyNodeSchema):
+    label: str = 'EC2Route'
+    properties: RouteNodeProperties = RouteNodeProperties()
+    sub_resource_relationship: RouteToAWSAccount = RouteToAWSAccount()
+    other_relationships: OtherRelationships = OtherRelationships([
+        RouteToInternetGateway(),
+    ])

{cartography-0.102.0rc1.dist-info → cartography-0.102.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cartography
-Version: 0.102.0rc1
+Version: 0.102.0rc2
 Summary: Explore assets and their relationships across your technical infrastructure.
 Maintainer: Cartography Contributors
 License: apache2

{cartography-0.102.0rc1.dist-info → cartography-0.102.0rc2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 cartography/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cartography/__main__.py,sha256=JftXT_nUPkqcEh8uxCCT4n-OyHYqbldEgrDS-4ygy0U,101
-cartography/_version.py,sha256=q6TYvfOuC2Uhe9vDriWNPGMCELT7yrGBm93mUcBnafo,518
+cartography/_version.py,sha256=OI9fh-YQyeutwYIFkGxdZOniCKb7_CUDhbEwgHnJdYI,518
 cartography/cli.py,sha256=-fGIdBx3IwauUeYojsb-NnQPma2wtS7mFRgOETyfCg4,34796
 cartography/config.py,sha256=xXM0OqsDl5Du55C-hr2LgjdtpU1_znPsmAgujrPGPgo,12553
 cartography/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -160,7 +160,7 @@ cartography/intel/aws/permission_relationships.py,sha256=IarV9gt5BaplZ5TPo_mfypt
 cartography/intel/aws/rds.py,sha256=vnlNYmrO2Cc0PNn31CeG2QwYhwjVosbQFE9Ol1vQyLE,25252
 cartography/intel/aws/redshift.py,sha256=KOqiXIllHmtPTeaNGl-cX4srY5pFE6o12j8MQ5-zWpc,6694
 cartography/intel/aws/resourcegroupstaggingapi.py,sha256=I2VrL-oplGj2Jyhbo312V6vnER_FXpJRrc6OBJ-_VmI,10375
-cartography/intel/aws/resources.py,sha256=lg5j0z6Iwj16Gv25yuAb3gHG6x4vOfRNm43FoOVRfqg,3541
+cartography/intel/aws/resources.py,sha256=jb2U6xsrwwp2AYirqHYc09ttOpIqYEsk-CR7He-qgzQ,3652
 cartography/intel/aws/route53.py,sha256=IYqeQud1HuHnf11A7T-Jeif5DWgjpaaU-Jfr2cLUc_o,14099
 cartography/intel/aws/s3.py,sha256=SVxUMtMSkbdjZv5qOSYIbYb8BQa-QTojbHG85-EFWLA,27034
 cartography/intel/aws/secretsmanager.py,sha256=YogwRPT6qZPVg5HrND71zI-nNn60oxoWaW7eUlhuTS0,3304
@@ -180,6 +180,7 @@ cartography/intel/aws/ec2/load_balancers.py,sha256=ah9-lXvipzVDjGFqfpNCrEyBfdu-B
 cartography/intel/aws/ec2/network_acls.py,sha256=_UiOx79OxcqH0ecRjcVMglAzz5XJ4aVYLlv6dl_ism4,6809
 cartography/intel/aws/ec2/network_interfaces.py,sha256=CzF8PooCYUQ2pk8DR8JDAhkWRUQSBj_27OsIfkL_-Cs,9199
 cartography/intel/aws/ec2/reserved_instances.py,sha256=jv8-VLI5KL8jN1QRI20yim8lzZ7I7wR8a5EF8DckahA,3122
+cartography/intel/aws/ec2/route_tables.py,sha256=h3oXZP1TCUeEbjmknIgSIDGHmmofXrqtBK45lXh06cQ,10182
 cartography/intel/aws/ec2/security_groups.py,sha256=vxLeaCpCowkbl-YpON1UdbjtPolMfj_reOEuKujN80Y,6060
 cartography/intel/aws/ec2/snapshots.py,sha256=R3U6ZwE4bQPy5yikLCRcUHyXN1dD7TzS-3jULQO-F0g,5432
 cartography/intel/aws/ec2/subnets.py,sha256=42KODMXswv4OCVnkWDHZbZDLUnc_ZAD-1TDMk88rWdo,3892
@@ -307,6 +308,9 @@ cartography/models/aws/ec2/networkinterface_instance.py,sha256=t3oqcQ4GjYf7dwqPU
 cartography/models/aws/ec2/networkinterfaces.py,sha256=z1-Dl6I79-TCxXKG8QBpSKga93lPCPaLR1XqKJZK3ME,4127
 cartography/models/aws/ec2/privateip_networkinterface.py,sha256=j8MyiZsiUCuzuGUH_4PBKV3rLTk1GkE-SZb6K11oSdM,3038
 cartography/models/aws/ec2/reservations.py,sha256=dE9uSB3Em-ca1dDbetbu79JXr4ZWHC3r5gA1S3mjhVU,1930
+cartography/models/aws/ec2/route_table_associations.py,sha256=MfP41U64XM86G0VMz_kbmlOc4cxMG6MbVWk1mfVoTaI,3846
+cartography/models/aws/ec2/route_tables.py,sha256=qFdfb1QExqJ8r3wCMUPaticWY_ppoLKEjyZx8Xs9etE,4725
+cartography/models/aws/ec2/routes.py,sha256=qmWkhvNavycKv422ih0b3jUYd02tOgHNAuIpivwj6XM,3626
 cartography/models/aws/ec2/securitygroup_instance.py,sha256=RZS9TzHHatTOESQgcs5_YHmF9sM7pRkUq2VPjk9FJlU,2876
 cartography/models/aws/ec2/securitygroup_networkinterface.py,sha256=PiaA8J82kybZyZ1wDsa-ACIDa88vt4NoA3smGNiwl14,2399
 cartography/models/aws/ec2/subnet_instance.py,sha256=ct_ibXiPN2C5ld06TczwSTXtsnlov5VCW6elphtbvPs,2752
@@ -369,9 +373,9 @@ cartography/models/snipeit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJ
 cartography/models/snipeit/asset.py,sha256=FyRAaeXuZjMy0eUQcSDFcgEAF5lbLMlvqp1Tv9d3Lv4,3238
 cartography/models/snipeit/tenant.py,sha256=p4rFnpNNuF1W5ilGBbexDaETWTwavfb38RcQGoImkQI,679
 cartography/models/snipeit/user.py,sha256=MsB4MiCVNTH6JpESime7cOkB89autZOXQpL6Z0l7L6o,2113
-cartography-0.102.0rc1.dist-info/licenses/LICENSE,sha256=kvLEBRYaQ1RvUni6y7Ti9uHeooqnjPoo6n_-0JO1ETc,11351
-cartography-0.102.0rc1.dist-info/METADATA,sha256=GkNEwQom09u69HGJrgQGXtYl7pBv1k6uTjsu9bmjUdQ,12087
-cartography-0.102.0rc1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-cartography-0.102.0rc1.dist-info/entry_points.txt,sha256=GVIAWD0o0_K077qMA_k1oZU4v-M0a8GLKGJR8tZ-qH8,112
-cartography-0.102.0rc1.dist-info/top_level.txt,sha256=BHqsNJQiI6Q72DeypC1IINQJE59SLhU4nllbQjgJi9g,12
-cartography-0.102.0rc1.dist-info/RECORD,,
+cartography-0.102.0rc2.dist-info/licenses/LICENSE,sha256=kvLEBRYaQ1RvUni6y7Ti9uHeooqnjPoo6n_-0JO1ETc,11351
+cartography-0.102.0rc2.dist-info/METADATA,sha256=n51HlV7I_bq7yGnIkU9rXzv-D7mOeJHXIU7HeQl3lO8,12087
+cartography-0.102.0rc2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+cartography-0.102.0rc2.dist-info/entry_points.txt,sha256=GVIAWD0o0_K077qMA_k1oZU4v-M0a8GLKGJR8tZ-qH8,112
+cartography-0.102.0rc2.dist-info/top_level.txt,sha256=BHqsNJQiI6Q72DeypC1IINQJE59SLhU4nllbQjgJi9g,12
+cartography-0.102.0rc2.dist-info/RECORD,,