Yasuke/moto
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Route Tables: Added support for associate/disassociate subnets.

Browse Source
This commit is contained in:
dreadpirateshawn 2014-10-13 16:19:54 -07:00
parent 68d2db55d4
commit 5d046c76e5
4 changed files with 164 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
moto/ec2/models.py
View File

@ -73,6 +73,7 @@ from .utils import (
random_snapshot_id,
random_spot_request_id,
random_subnet_id,
random_subnet_association_id,
random_volume_id,
random_vpc_id,
random_vpc_peering_connection_id,
@ -1560,8 +1561,7 @@ class RouteTable(TaggedEC2Resource):
self.id = route_table_id
self.vpc_id = vpc_id
self.main = main
self.association_id = None
self.subnet_id = None
self.associations = {}
self.routes = {}
@classmethod
@ -1588,6 +1588,12 @@ class RouteTable(TaggedEC2Resource):
return 'false'
elif filter_name == "vpc-id":
return self.vpc_id
elif filter_name == "association.route-table-id":
return self.id
elif filter_name == "association.route-table-association-id":
return self.associations.keys()
elif filter_name == "association.subnet-id":
return self.associations.values()
filter_value = super(RouteTable, self).get_filter_value(filter_name)
@ -1631,10 +1637,27 @@ class RouteTableBackend(object):
return generic_filter(filters, route_tables)
def delete_route_table(self, route_table_id):
deleted = self.route_tables.pop(route_table_id, None)
if not deleted:
raise InvalidRouteTableIdError(route_table_id)
return deleted
route_table = self.get_route_table(route_table_id)
if route_table.associations:
raise DependencyViolationError(
"The routeTable '{0}' has dependencies and cannot be deleted."
.format(route_table_id)
)
self.route_tables.pop(route_table_id)
return True
def associate_route_table(self, route_table_id, subnet_id):
route_table = self.get_route_table(route_table_id)
subnet = self.get_subnet(subnet_id) # Validate subnet exists
association_id = random_subnet_association_id()
route_table.associations[association_id] = subnet_id
return association_id
def disassociate_route_table(self, association_id):
for route_table in self.route_tables.values():
if association_id in route_table.associations:
return route_table.associations.pop(association_id, None)
raise InvalidAssociationIdError(association_id)
class Route(object):

41
moto/ec2/responses/route_tables.py
View File

@ -8,7 +8,11 @@ from moto.ec2.utils import route_table_ids_from_querystring, filters_from_querys
class RouteTables(BaseResponse):
def associate_route_table(self):
raise NotImplementedError('RouteTables(AmazonVPC).associate_route_table is not yet implemented')
route_table_id = self.querystring.get('RouteTableId')[0]
subnet_id = self.querystring.get('SubnetId')[0]
association_id = ec2_backend.associate_route_table(route_table_id, subnet_id)
template = Template(ASSOCIATE_ROUTE_TABLE_RESPONSE)
return template.render(association_id=association_id)
def create_route(self):
route_table_id = self.querystring.get('RouteTableId')[0]
@ -55,7 +59,10 @@ class RouteTables(BaseResponse):
return template.render(route_tables=route_tables)
def disassociate_route_table(self):
raise NotImplementedError('RouteTables(AmazonVPC).disassociate_route_table is not yet implemented')
association_id = self.querystring.get('AssociationId')[0]
ec2_backend.disassociate_route_table(association_id)
template = Template(DISASSOCIATE_ROUTE_TABLE_RESPONSE)
return template.render()
def replace_route(self):
route_table_id = self.querystring.get('RouteTableId')[0]
@ -151,18 +158,14 @@ DESCRIBE_ROUTE_TABLES_RESPONSE = """
{% endfor %}
</routeSet>
<associationSet>
{% if route_table.association_id %}
{% for association_id,subnet_id in route_table.associations.items() %}
<item>
<routeTableAssociationId>{{ route_table.association_id }}</routeTableAssociationId>
<routeTableId>{{ route_table.id }}</routeTableId>
{% if not route_table.subnet_id %}
<main>true</main>
{% endif %}
{% if route_table.subnet_id %}
<subnetId>{{ route_table.subnet_id }}</subnetId>
{% endif %}
<routeTableAssociationId>{{ association_id }}</routeTableAssociationId>
<routeTableId>{{ route_table.id }}</routeTableId>
<main>false</main>
<subnetId>{{ subnet_id }}</subnetId>
</item>
{% endif %}
{% endfor %}
</associationSet>
<tagSet/>
</item>
@ -184,3 +187,17 @@ DELETE_ROUTE_TABLE_RESPONSE = """
<return>true</return>
</DeleteRouteTableResponse>
"""
ASSOCIATE_ROUTE_TABLE_RESPONSE = """
<AssociateRouteTableResponse xmlns="http://ec2.amazonaws.com/doc/2014-06-15/">
<requestId>59dbff89-35bd-4eac-99ed-be587EXAMPLE</requestId>
<associationId>{{ association_id }}</associationId>
</AssociateRouteTableResponse>
"""
DISASSOCIATE_ROUTE_TABLE_RESPONSE = """
<DisassociateRouteTableResponse xmlns="http://ec2.amazonaws.com/doc/2014-06-15/">
<requestId>59dbff89-35bd-4eac-99ed-be587EXAMPLE</requestId>
<return>true</return>
</DisassociateRouteTableResponse>
"""

5
moto/ec2/utils.py
View File

@ -14,6 +14,7 @@ EC2_RESOURCE_TO_PREFIX = {
'network-interface-attachment': 'eni-attach',
'reserved-instance': 'uuid4',
'route-table': 'rtb',
'route-table-association': 'rtbassoc',
'security-group': 'sg',
'snapshot': 'snap',
'spot-instance-request': 'sir',
@ -67,6 +68,10 @@ def random_subnet_id():
return random_id(prefix=EC2_RESOURCE_TO_PREFIX['subnet'])
def random_subnet_association_id():
return random_id(prefix=EC2_RESOURCE_TO_PREFIX['route-table-association'])
def random_volume_id():
return random_id(prefix=EC2_RESOURCE_TO_PREFIX['volume'])

102
tests/test_ec2/test_route_tables.py
View File

@ -77,7 +77,7 @@ def test_route_tables_additional():
@mock_ec2
def test_route_tables_filters():
def test_route_tables_filters_standard():
conn = boto.connect_vpc('the_key', 'the_secret')
vpc1 = conn.create_vpc("10.0.0.0/16")
@ -114,6 +114,106 @@ def test_route_tables_filters():
conn.get_all_route_tables.when.called_with(filters={'not-implemented-filter': 'foobar'}).should.throw(NotImplementedError)
@mock_ec2
def test_route_tables_filters_associations():
conn = boto.connect_vpc('the_key', 'the_secret')
vpc = conn.create_vpc("10.0.0.0/16")
subnet1 = conn.create_subnet(vpc.id, "10.0.0.0/18")
subnet2 = conn.create_subnet(vpc.id, "10.0.1.0/18")
subnet3 = conn.create_subnet(vpc.id, "10.0.2.0/18")
route_table1 = conn.create_route_table(vpc.id)
route_table2 = conn.create_route_table(vpc.id)
association_id1 = conn.associate_route_table(route_table1.id, subnet1.id)
association_id2 = conn.associate_route_table(route_table1.id, subnet2.id)
association_id3 = conn.associate_route_table(route_table2.id, subnet3.id)
all_route_tables = conn.get_all_route_tables()
all_route_tables.should.have.length_of(3)
# Filter by association ID
association1_route_tables = conn.get_all_route_tables(filters={'association.route-table-association-id':association_id1})
association1_route_tables.should.have.length_of(1)
association1_route_tables[0].id.should.equal(route_table1.id)
association1_route_tables[0].associations.should.have.length_of(2)
# Filter by route table ID
route_table2_route_tables = conn.get_all_route_tables(filters={'association.route-table-id':route_table2.id})
route_table2_route_tables.should.have.length_of(1)
route_table2_route_tables[0].id.should.equal(route_table2.id)
route_table2_route_tables[0].associations.should.have.length_of(1)
# Filter by subnet ID
subnet_route_tables = conn.get_all_route_tables(filters={'association.subnet-id':subnet1.id})
subnet_route_tables.should.have.length_of(1)
subnet_route_tables[0].id.should.equal(route_table1.id)
association1_route_tables[0].associations.should.have.length_of(2)
@mock_ec2
def test_route_table_associations():
conn = boto.connect_vpc('the_key', 'the_secret')
vpc = conn.create_vpc("10.0.0.0/16")
subnet = conn.create_subnet(vpc.id, "10.0.0.0/18")
route_table = conn.create_route_table(vpc.id)
all_route_tables = conn.get_all_route_tables()
all_route_tables.should.have.length_of(2)
# Refresh
route_table = conn.get_all_route_tables(route_table.id)[0]
print route_table.__dict__
route_table.associations.should.have.length_of(0)
# Associate
association_id = conn.associate_route_table(route_table.id, subnet.id)
# Refresh
route_table = conn.get_all_route_tables(route_table.id)[0]
route_table.associations.should.have.length_of(1)
route_table.associations[0].id.should.equal(association_id)
route_table.associations[0].main.should.equal(False)
route_table.associations[0].route_table_id.should.equal(route_table.id)
route_table.associations[0].subnet_id.should.equal(subnet.id)
# Error: Attempt delete associated route table.
with assert_raises(EC2ResponseError) as cm:
conn.delete_route_table(route_table.id)
cm.exception.code.should.equal('DependencyViolation')
cm.exception.status.should.equal(400)
cm.exception.request_id.should_not.be.none
# Disassociate
conn.disassociate_route_table(association_id)
# Refresh
route_table = conn.get_all_route_tables(route_table.id)[0]
route_table.associations.should.have.length_of(0)
# Error: Disassociate with invalid association ID
with assert_raises(EC2ResponseError) as cm:
conn.disassociate_route_table(association_id)
cm.exception.code.should.equal('InvalidAssociationID.NotFound')
cm.exception.status.should.equal(400)
cm.exception.request_id.should_not.be.none
# Error: Associate with invalid subnet ID
with assert_raises(EC2ResponseError) as cm:
conn.associate_route_table(route_table.id, "subnet-1234abcd")
cm.exception.code.should.equal('InvalidSubnetID.NotFound')
cm.exception.status.should.equal(400)
cm.exception.request_id.should_not.be.none
# Error: Associate with invalid route table ID
with assert_raises(EC2ResponseError) as cm:
conn.associate_route_table("rtb-1234abcd", subnet.id)
cm.exception.code.should.equal('InvalidRouteTableID.NotFound')
cm.exception.status.should.equal(400)
cm.exception.request_id.should_not.be.none
@mock_ec2
def test_routes_additional():
conn = boto.connect_vpc('the_key', 'the_secret')