AwsSubnet: create in specific availability zone

* AwsSubnet.do_create: support aws_availability_zone

* AwsVpc: support creation with name and vpc_cidr in the class.

* AwsVpc.delete: make async.  Could be better about what is handled in
executor context.

* Add tests for vpc and subnet creation

carthage_aws/network.py

@@ -32,9 +32,10 @@ class AwsVirtualPrivateCloud(AwsManaged):
     stamp_type = "vpc"
     resource_type = 'vpc'
 
+    vpc_cidr:str = None #: String representation of the v4 CIDR block for the VPC
 
 
-    def __init__(self,  **kwargs):
+    def __init__(self,  vpc_cidr=None, **kwargs):
         super().__init__( **kwargs)
         config = self.config_layout
         if self.name is None:
@@ -45,6 +46,9 @@ def __init__(self,  **kwargs):
             if config.aws.vpc_id == None:
                 self.id = ''
             else: self.id = config.aws.vpc_id
+        if vpc_cidr: self.vpc_cidr = vpc_cidr
+        if self.vpc_cidr is None:
+            self.vpc_cidr = str(config.aws.vpc_cidr)
         self.vms = []
 
 
@@ -64,7 +68,7 @@ def do_create(self):
         try:
             r = self.connection.client.create_vpc(
                     InstanceTenancy='default',
-                                                      CidrBlock=str(self.config_layout.aws.vpc_cidr),
+                                                      CidrBlock=self.vpc_cidr,
                     TagSpecifications=[self.resource_tags])
             self.id = r['Vpc']['VpcId']
 
@@ -105,19 +109,19 @@ def groups(self):
         self.groups = list( groups['SecurityGroups'])
         return self.groups
 
-    def delete(self):
+    async def delete(self):
         for sn in self.mob.subnets.all():
-            sn.delete()
+            await run_in_executor(sn.delete)
         for g in self.mob.security_groups.all():
-            try: g.delete()
+            try: await run_in_executor(g.delete)
             except: pass
         for gw in self.mob.internet_gateways.all():
             gw.detach_from_vpc(VpcId=self.id)
             gw.delete()
         for rt in self.mob.route_tables.all():
             try: rt.delete()
             except: pass
-        self.mob.delete()
+        await run_in_executor(self.mob.delete)
 
 
 @dataclasses.dataclass(frozen=True)
@@ -340,10 +344,15 @@ async def find(self):
 
 
     def do_create(self):
+        availability_zone = self._gfi("aws_availability_zone", default=None)
+        extra_args = {}
+        if availability_zone:
+            extra_args['AvailabilityZone'] = availability_zone
         try:
             r = self.connection.client.create_subnet(VpcId=self.vpc.id,
                                                      CidrBlock=str(self.network.v4_config.network),
-                                                     TagSpecifications=[self.resource_tags]
+                                                     TagSpecifications=[self.resource_tags],
+                                                     **extra_args
                                                      )
             self.id = r['Subnet']['SubnetId']
             # No need to associate subnet with main route table

tests/test_aws.py

@@ -123,3 +123,29 @@ async def test_elastic_ip(carthage_layout):
             await layout.ip_test.machine.delete()
         await layout.ip_1.delete()
 
+@async_test
+async def test_aws_subnet_create(ainjector):
+    '''
+    Test creation of a VPC and a subnet
+    '''
+    class creation_vpc(AwsVirtualPrivateCloud, InjectableModel):
+        name = 'creation_vpc'
+        vpc_cidr = '10.1.0.0/16'
+
+        class created_subnet(NetworkModel):
+            v4_config = V4Config(network='10.1.0.0/24')
+            aws_availability_zone = 'us-east-1c'
+    try:
+        ainjector.add_provider(creation_vpc)
+        vpc = None
+        vpc = await ainjector.get_instance_async(creation_vpc)
+        with instantiation_not_ready():
+            subnet = await vpc.created_subnet.access_by(AwsSubnet)
+        await subnet.find()
+        assert not subnet.mob
+        await subnet.async_become_ready()
+        assert subnet.mob
+        assert subnet.mob.availability_zone == subnet._gfi("aws_availability_zone")
+    finally:
+        if vpc: await vpc.delete()
+