Moved remaining providers to use default zone

cloudbridge/cloud/providers/azure/provider.py

@@ -30,17 +30,19 @@ class AzureCloudProvider(BaseCloudProvider):
         self.subscription_id = self._get_config_value(
             'azure_subscription_id', get_env('AZURE_SUBSCRIPTION_ID'))
         self.client_id = self._get_config_value(
-            'azure_client_id', get_env('AZURE_CLIENT_ID', None))
+            'azure_client_id', get_env('AZURE_CLIENT_ID'))
         self.secret = self._get_config_value(
-            'azure_secret', get_env('AZURE_SECRET', None))
+            'azure_secret', get_env('AZURE_SECRET'))
         self.tenant = self._get_config_value(
-            'azure_tenant', get_env('AZURE_TENANT', None))
+            'azure_tenant', get_env('AZURE_TENANT'))
 
         # optional config values
         self.access_token = self._get_config_value(
-            'azure_access_token', get_env('AZURE_ACCESS_TOKEN', None))
-        self.region_name = self._get_config_value(
+            'azure_access_token', get_env('AZURE_ACCESS_TOKEN'))
+        self._region_name = self._get_config_value(
             'azure_region_name', get_env('AZURE_REGION_NAME', 'eastus'))
+        self._zone_name = self._get_config_value(
+            'azure_zone_name', get_env('AZURE_ZONE_NAME'))
         self.resource_group = self._get_config_value(
             'azure_resource_group', get_env('AZURE_RESOURCE_GROUP',
                                             'cloudbridge'))
@@ -59,7 +61,7 @@ class AzureCloudProvider(BaseCloudProvider):
 
         self.vm_default_user_name = self._get_config_value(
                 'azure_vm_default_username', get_env(
-                    'AZURE_VM_DEFAULT_USERNAME', None)) \
+                    'AZURE_VM_DEFAULT_USERNAME')) \
             or self.__get_deprecated_username('cbuser')
 
         self.public_key_storage_table_name = self._get_config_value(

cloudbridge/cloud/providers/azure/resources.py

@@ -554,13 +554,12 @@ class AzureSnapshot(BaseSnapshot):
             # set the state to unknown
             self._state = 'unknown'
 
-    def create_volume(self, placement=None,
-                      size=None, volume_type=None, iops=None):
+    def create_volume(self, size=None, volume_type=None, iops=None):
         """
         Create a new Volume from this Snapshot.
         """
         return self._provider.storage.volumes. \
-            create(self.name, self.size, zone=placement, snapshot=self)
+            create(self.name, self.size, snapshot=self)
 
 
 class AzureMachineImage(BaseMachineImage):

cloudbridge/cloud/providers/azure/services.py

@@ -36,7 +36,6 @@ from cloudbridge.cloud.interfaces.exceptions import InvalidParamException
 from cloudbridge.cloud.interfaces.exceptions import InvalidValueException
 from cloudbridge.cloud.interfaces.resources import MachineImage
 from cloudbridge.cloud.interfaces.resources import Network
-from cloudbridge.cloud.interfaces.resources import PlacementZone
 from cloudbridge.cloud.interfaces.resources import Snapshot
 from cloudbridge.cloud.interfaces.resources import TrafficDirection
 from cloudbridge.cloud.interfaces.resources import VMFirewall
@@ -397,12 +396,12 @@ class AzureVolumeService(BaseVolumeService):
 
     @dispatch(event="provider.storage.volumes.create",
               priority=BaseVolumeService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, size, zone, snapshot=None, description=None):
+    def create(self, label, size, snapshot=None, description=None):
         AzureVolume.assert_valid_resource_label(label)
         disk_name = AzureVolume._generate_name_from_label(label, "cb-vol")
         tags = {'Label': label}
 
-        zone_id = zone.id if isinstance(zone, PlacementZone) else zone
+        zone_name = self.provider.zone_name
         snapshot = (self.provider.storage.snapshots.get(snapshot)
                     if snapshot and isinstance(snapshot, str) else snapshot)
 
@@ -411,8 +410,7 @@ class AzureVolumeService(BaseVolumeService):
 
         if snapshot:
             params = {
-                'location':
-                    zone_id or self.provider.azure_client.region_name,
+                'location': zone_name,
                 'creation_data': {
                     'create_option': DiskCreateOption.copy,
                     'source_uri': snapshot.resource_id
@@ -425,8 +423,7 @@ class AzureVolumeService(BaseVolumeService):
 
         else:
             params = {
-                'location':
-                    zone_id or self.provider.region_name,
+                'location': zone_name,
                 'disk_size_gb': size,
                 'creation_data': {
                     'create_option': DiskCreateOption.empty
@@ -718,8 +715,7 @@ class AzureInstanceService(BaseInstanceService):
 
         return subnet.resource_id, zone_id, vm_firewall_id
 
-    def _create_storage_profile(self, image, launch_config, instance_name,
-                                zone_id):
+    def _create_storage_profile(self, image, launch_config, instance_name):
 
         if image.is_gallery_image:
             # pylint:disable=protected-access
@@ -745,7 +741,7 @@ class AzureInstanceService(BaseInstanceService):
 
         if launch_config:
             data_disks, root_disk_size = self._process_block_device_mappings(
-                launch_config, instance_name, zone_id)
+                launch_config)
             if data_disks:
                 storage_profile['data_disks'] = data_disks
             if root_disk_size:
@@ -753,8 +749,7 @@ class AzureInstanceService(BaseInstanceService):
 
         return storage_profile
 
-    def _process_block_device_mappings(self, launch_config,
-                                       vm_name, zone=None):
+    def _process_block_device_mappings(self, launch_config):
         """
         Processes block device mapping information
         and returns a Data disk dictionary list. If new volumes
@@ -828,7 +823,7 @@ class AzureInstanceService(BaseInstanceService):
 
     @dispatch(event="provider.compute.instances.create",
               priority=BaseInstanceService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, image, vm_type, subnet, zone,
+    def create(self, label, image, vm_type, subnet,
                key_pair=None, vm_firewalls=None, user_data=None,
                launch_config=None, **kwargs):
         AzureInstance.assert_valid_resource_label(label)
@@ -844,24 +839,20 @@ class AzureInstanceService(BaseInstanceService):
         instance_size = vm_type.id if \
             isinstance(vm_type, VMType) else vm_type
 
-        if not subnet:
-            # Azure has only a single zone per region; use the current one
-            zone = self.provider.compute.regions.get(
-                self.provider.region_name).zones[0]
-            subnet = self.provider.networking.subnets.get_or_create_default(
-                zone)
+        if subnet:
+            subnet = (subnet if isinstance(subnet, AzureSubnet) else
+                      self.provider.networking.subnets.get(subnet))
         else:
-            subnet = (self.provider.networking.subnets.get(subnet)
-                      if isinstance(subnet, str) else subnet)
+            subnet = self.provider.networking.subnets.get_or_create_default()
 
-        zone_id = zone.id if isinstance(zone, PlacementZone) else zone
+        zone_name = self.provider.zone_name
 
         subnet_id, zone_id, vm_firewall_id = \
             self._resolve_launch_options(instance_name,
-                                         subnet, zone_id, vm_firewalls)
+                                         subnet, zone_name, vm_firewalls)
 
         storage_profile = self._create_storage_profile(image, launch_config,
-                                                       instance_name, zone_id)
+                                                       instance_name)
 
         nic_params = {
             'location': self.provider.region_name,
@@ -906,7 +897,7 @@ class AzureInstanceService(BaseInstanceService):
             temp_key_pair = key_pair
 
         params = {
-            'location': zone_id or self.provider.region_name,
+            'location': zone_id,
             'os_profile': {
                 'admin_username': self.provider.vm_default_user_name,
                 'computer_name': instance_name,
@@ -1233,7 +1224,7 @@ class AzureSubnetService(BaseSubnetService):
 
     @dispatch(event="provider.networking.subnets.create",
               priority=BaseSubnetService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, network, cidr_block, zone):
+    def create(self, label, network, cidr_block):
         AzureSubnet.assert_valid_resource_label(label)
         # Although Subnet doesn't support tags in Azure, we use the parent
         # Network's tags to track its subnets' labels

cloudbridge/cloud/providers/gcp/provider.py

@@ -221,12 +221,11 @@ class GCPCloudProvider(BaseCloudProvider):
         if self.credentials_file and not self.credentials_dict:
             with open(self.credentials_file) as creds_file:
                 self.credentials_dict = json.load(creds_file)
-        self.default_zone = self._get_config_value(
-            'gcp_default_zone',
-            os.environ.get('GCP_DEFAULT_ZONE') or 'us-central1-a')
-        self.region_name = self._get_config_value(
+        self._region_name = self._get_config_value(
             'gcp_region_name',
             os.environ.get('GCP_DEFAULT_REGION') or 'us-central1')
+        self._zone_name = self._get_config_value(
+            'gcp_zone_name', os.environ.get('GCP_ZONE_NAME'))
 
         if self.credentials_dict and 'project_id' in self.credentials_dict:
             self.project_name = self.credentials_dict['project_id']
@@ -281,7 +280,7 @@ class GCPCloudProvider(BaseCloudProvider):
                     self.gcp_compute,
                     project=self.project_name,
                     region=self.region_name,
-                    zone=self.default_zone)
+                    zone=self.zone_name)
         return self._compute_resources_cache
 
     @property

cloudbridge/cloud/providers/gcp/resources.py

@@ -1870,7 +1870,7 @@ class GCPSnapshot(BaseSnapshot):
             # snapshot no longer exists
             self._snapshot['status'] = SnapshotState.UNKNOWN
 
-    def create_volume(self, placement, size=None, volume_type=None, iops=None):
+    def create_volume(self, size=None, volume_type=None, iops=None):
         """
         Create a new Volume from this Snapshot.
 
@@ -1882,9 +1882,7 @@ class GCPSnapshot(BaseSnapshot):
                 'pd-ssd'.
             iops: Not supported by GCP.
         """
-        zone_name = placement
-        if isinstance(placement, GCPPlacementZone):
-            zone_name = placement.name
+        zone_name = self._provider.zone_name
         vol_type = 'zones/{0}/diskTypes/{1}'.format(
             zone_name,
             'pd-standard' if (volume_type != 'pd-standard' or

cloudbridge/cloud/providers/gcp/services.py

@@ -47,7 +47,6 @@ from .resources import GCPKeyPair
 from .resources import GCPLaunchConfig
 from .resources import GCPMachineImage
 from .resources import GCPNetwork
-from .resources import GCPPlacementZone
 from .resources import GCPRegion
 from .resources import GCPRouter
 from .resources import GCPSnapshot
@@ -320,7 +319,7 @@ class GCPVMTypeService(BaseVMTypeService):
                         .gcp_compute
                         .machineTypes()
                         .list(project=self.provider.project_name,
-                              zone=self.provider.default_zone)
+                              zone=self.provider.zone_name)
                         .execute())
         return response['items']
 
@@ -467,20 +466,14 @@ class GCPInstanceService(BaseInstanceService):
 
     @dispatch(event="provider.compute.instances.create",
               priority=BaseInstanceService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, image, vm_type, subnet, zone=None,
+    def create(self, label, image, vm_type, subnet,
                key_pair=None, vm_firewalls=None, user_data=None,
                launch_config=None, **kwargs):
         """
         Creates a new virtual machine instance.
         """
         GCPInstance.assert_valid_resource_name(label)
-        zone_name = self.provider.default_zone
-        if zone:
-            if not isinstance(zone, GCPPlacementZone):
-                zone = GCPPlacementZone(
-                    self.provider,
-                    self.provider.get_resource('zones', zone))
-            zone_name = zone.name
+        zone_name = self.provider.zone_name
         if not isinstance(vm_type, GCPVMType):
             vm_type = self.provider.compute.vm_types.get(vm_type)
 
@@ -500,7 +493,7 @@ class GCPInstanceService(BaseInstanceService):
                     volume_name = 'disk-{0}'.format(uuid.uuid4())
                     volume_size = disk.size if disk.size else 1
                     volume = self.provider.storage.volumes.create(
-                        volume_name, volume_size, zone)
+                        volume_name, volume_size)
                     volume.wait_till_ready()
                     source_field = 'source'
                     source_value = volume.id
@@ -516,7 +509,7 @@ class GCPInstanceService(BaseInstanceService):
                     source_field = 'source'
                     source_value = disk.source.id
                 elif isinstance(disk.source, GCPSnapshot):
-                    volume = disk.source.create_volume(zone, size=disk.size)
+                    volume = disk.source.create_volume(size=disk.size)
                     volume.wait_till_ready()
                     source_field = 'source'
                     source_value = volume.id
@@ -662,7 +655,7 @@ class GCPInstanceService(BaseInstanceService):
                         .gcp_compute
                         .instances()
                         .list(project=self.provider.project_name,
-                              zone=self.provider.default_zone,
+                              zone=self.provider.zone_name,
                               maxResults=max_result,
                               pageToken=marker)
                         .execute())
@@ -962,19 +955,13 @@ class GCPSubnetService(BaseSubnetService):
 
     @dispatch(event="provider.networking.subnets.list",
               priority=BaseSubnetService.STANDARD_EVENT_PRIORITY)
-    def list(self, network=None, zone=None, limit=None, marker=None):
-        """
-        If the zone is not given, we list all subnets in the default region.
-        """
+    def list(self, network=None, limit=None, marker=None):
         filter = None
         if network is not None:
             network = (network if isinstance(network, GCPNetwork)
                        else self.provider.networking.networks.get(network))
             filter = 'network eq %s' % network.resource_url
-        if zone:
-            region_name = self._zone_to_region(zone)
-        else:
-            region_name = self.provider.region_name
+        region_name = self.provider.region_name
         subnets = []
         response = (self.provider
                         .gcp_compute
@@ -990,19 +977,14 @@ class GCPSubnetService(BaseSubnetService):
 
     @dispatch(event="provider.networking.subnets.create",
               priority=BaseSubnetService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, network, cidr_block, zone):
+    def create(self, label, network, cidr_block):
         """
-        GCP subnets are regional. The region is inferred from the zone;
-        otherwise, the default region, as set in the
+        GCP subnets are regional. The default region, as set in the
         provider, is used.
-
-        If a subnet with overlapping IP range exists already, we return that
-        instead of creating a new subnet. In this case, other parameters, i.e.
-        the name and the zone, are ignored.
         """
         GCPSubnet.assert_valid_resource_label(label)
         name = GCPSubnet._generate_name_from_label(label, 'cbsubnet')
-        region_name = self._zone_to_region(zone)
+        region_name = self.provider.region_name
 #         for subnet in self.iter(network=network):
 #            if BaseNetwork.cidr_blocks_overlap(subnet.cidr_block, cidr_block):
 #                 if subnet.region_name != region_name:
@@ -1052,22 +1034,19 @@ class GCPSubnetService(BaseSubnetService):
             log.warning('No label was found associated with this subnet '
                         '"{}" when deleted.'.format(sn.name))
 
-    def get_or_create_default(self, zone):
+    def get_or_create_default(self):
         """
-        Return an existing or create a new subnet for the supplied zone.
+        Return an existing or create a new subnet in the provider default zone.
 
         In GCP, subnets are a regional resource so a single subnet can services
-        an entire region. The supplied zone parameter is used to derive the
-        parent region under which the default subnet then exists.
+        an entire region.
         """
-        # In case the supplied zone param is `None`, resort to the default one
-        region = self._zone_to_region(zone or self.provider.default_zone,
-                                      return_name_only=False)
+        region_name = self.provider.region_name
         # Check if a default subnet already exists for the given region/zone
         for sn in self.find(label=GCPSubnet.CB_DEFAULT_SUBNET_LABEL):
-            if sn.region == region.id:
+            if sn.region_name == region_name:
                 return sn
-        # No default subnet in the supplied zone. Look for a default network,
+        # No default subnet in the current zone. Look for a default network,
         # then create a subnet whose address space does not overlap with any
         # other existing subnets. If there are existing subnets, this process
         # largely assumes the subnet address spaces are contiguous when it
@@ -1089,32 +1068,13 @@ class GCPSubnetService(BaseSubnetService):
             cidr_block = "{}/{}".format(next_sn_address, max_sn_ipa.prefixlen)
         sn = self.provider.networking.subnets.create(
                 label=GCPSubnet.CB_DEFAULT_SUBNET_LABEL,
-                cidr_block=cidr_block, network=net, zone=zone)
+                cidr_block=cidr_block, network=net)
         router = self.provider.networking.routers.get_or_create_default(net)
         router.attach_subnet(sn)
         gateway = net.gateways.get_or_create()
         router.attach_gateway(gateway)
         return sn
 
-    def _zone_to_region(self, zone, return_name_only=True):
-        """
-        Given a GCP zone, return parent region.
-
-        Supplied `zone` param can be a `str` or `GCPPlacementZone`.
-
-        If ``return_name_only`` is set, return the region name as a string;
-        otherwise, return a GCPRegion object.
-        """
-        region_name = self.provider.region_name
-        if zone:
-            if isinstance(zone, GCPPlacementZone):
-                region_name = zone.region_name
-            else:
-                region_name = zone[:-2]
-        if return_name_only:
-            return region_name
-        return self.provider.compute.regions.get(region_name)
-
 
 class GCPStorageService(BaseStorageService):
 
@@ -1175,7 +1135,7 @@ class GCPVolumeService(BaseVolumeService):
                         .gcp_compute
                         .disks()
                         .list(project=self.provider.project_name,
-                              zone=self.provider.default_zone,
+                              zone=self.provider.zone_name,
                               filter=filtr,
                               maxResults=max_result,
                               pageToken=marker)
@@ -1206,7 +1166,7 @@ class GCPVolumeService(BaseVolumeService):
                         .gcp_compute
                         .disks()
                         .list(project=self.provider.project_name,
-                              zone=self.provider.default_zone,
+                              zone=self.provider.zone_name,
                               maxResults=max_result,
                               pageToken=marker)
                         .execute())
@@ -1221,14 +1181,10 @@ class GCPVolumeService(BaseVolumeService):
 
     @dispatch(event="provider.storage.volumes.create",
               priority=BaseVolumeService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, size, zone, snapshot=None, description=None):
+    def create(self, label, size, snapshot=None, description=None):
         GCPVolume.assert_valid_resource_label(label)
         name = GCPVolume._generate_name_from_label(label, 'cb-vol')
-        if not isinstance(zone, GCPPlacementZone):
-            zone = GCPPlacementZone(
-                self.provider,
-                self.provider.get_resource('zones', zone))
-        zone_name = zone.name
+        zone_name = self.provider.zone_name
         snapshot_id = snapshot.id if isinstance(
             snapshot, GCPSnapshot) and snapshot else snapshot
         labels = {'cblabel': label}
@@ -1344,13 +1300,13 @@ class GCPSnapshotService(BaseSnapshotService):
                          .disks()
                          .createSnapshot(
                              project=self.provider.project_name,
-                             zone=self.provider.default_zone,
+                             zone=self.provider.zone_name,
                              disk=volume_name, body=snapshot_body)
                          .execute())
         if 'zone' not in operation:
             return None
         self.provider.wait_for_operation(operation,
-                                         zone=self.provider.default_zone)
+                                         zone=self.provider.zone_name)
         cb_snap = self.get(name)
         return cb_snap
 

cloudbridge/cloud/providers/openstack/provider.py

@@ -36,22 +36,24 @@ class OpenStackCloudProvider(BaseCloudProvider):
 
         # Initialize cloud connection fields
         self.username = self._get_config_value(
-            'os_username', get_env('OS_USERNAME', None))
+            'os_username', get_env('OS_USERNAME'))
         self.password = self._get_config_value(
-            'os_password', get_env('OS_PASSWORD', None))
+            'os_password', get_env('OS_PASSWORD'))
         self.project_name = self._get_config_value(
-            'os_project_name', get_env('OS_PROJECT_NAME', None)
-            or get_env('OS_TENANT_NAME', None))
+            'os_project_name', get_env('OS_PROJECT_NAME')
+            or get_env('OS_TENANT_NAME'))
         self.auth_url = self._get_config_value(
-            'os_auth_url', get_env('OS_AUTH_URL', None))
-        self.region_name = self._get_config_value(
-            'os_region_name', get_env('OS_REGION_NAME', None))
+            'os_auth_url', get_env('OS_AUTH_URL'))
+        self._region_name = self._get_config_value(
+            'os_region_name', get_env('OS_REGION_NAME'))
+        self._zone_name = self._get_config_value(
+            'os_zone_name', get_env('OS_ZONE_NAME'))
         self.project_domain_name = self._get_config_value(
             'os_project_domain_name',
-            get_env('OS_PROJECT_DOMAIN_NAME', None))
+            get_env('OS_PROJECT_DOMAIN_NAME'))
         self.user_domain_name = self._get_config_value(
             'os_user_domain_name',
-            get_env('OS_USER_DOMAIN_NAME', None))
+            get_env('OS_USER_DOMAIN_NAME'))
 
         # Service connections, lazily initialized
         self._nova = None

cloudbridge/cloud/providers/openstack/resources.py

@@ -751,7 +751,7 @@ class OpenStackSnapshot(BaseSnapshot):
             # set the status to unknown
             self._snapshot.status = 'unknown'
 
-    def create_volume(self, placement, size=None, volume_type=None, iops=None):
+    def create_volume(self, size=None, volume_type=None, iops=None):
         """
         Create a new Volume from this Snapshot.
         """
@@ -759,7 +759,7 @@ class OpenStackSnapshot(BaseSnapshot):
         self.assert_valid_resource_label(vol_label)
         size = size if size else self._snapshot.size
         os_vol = self._provider.cinder.volumes.create(
-            size, name=vol_label, availability_zone=placement,
+            size, name=vol_label, availability_zone=self._provider.zone_name,
             snapshot_id=self._snapshot.id)
         cb_vol = OpenStackVolume(self._provider, os_vol)
         return cb_vol

cloudbridge/cloud/providers/openstack/services.py

@@ -47,7 +47,6 @@ from cloudbridge.cloud.interfaces.exceptions import InvalidValueException
 from cloudbridge.cloud.interfaces.resources import KeyPair
 from cloudbridge.cloud.interfaces.resources import MachineImage
 from cloudbridge.cloud.interfaces.resources import Network
-from cloudbridge.cloud.interfaces.resources import PlacementZone
 from cloudbridge.cloud.interfaces.resources import Snapshot
 from cloudbridge.cloud.interfaces.resources import Subnet
 from cloudbridge.cloud.interfaces.resources import TrafficDirection
@@ -409,15 +408,15 @@ class OpenStackVolumeService(BaseVolumeService):
 
     @dispatch(event="provider.storage.volumes.create",
               priority=BaseVolumeService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, size, zone, snapshot=None, description=None):
+    def create(self, label, size, snapshot=None, description=None):
         OpenStackVolume.assert_valid_resource_label(label)
-        zone_id = zone.id if isinstance(zone, PlacementZone) else zone
+        zone_name = self.provider.zone_name
         snapshot_id = snapshot.id if isinstance(
             snapshot, OpenStackSnapshot) and snapshot else snapshot
 
         os_vol = self.provider.cinder.volumes.create(
             size, name=label, description=description,
-            availability_zone=zone_id, snapshot_id=snapshot_id)
+            availability_zone=zone_name, snapshot_id=snapshot_id)
         return OpenStackVolume(self.provider, os_vol)
 
     @dispatch(event="provider.storage.volumes.delete",
@@ -749,7 +748,7 @@ class OpenStackInstanceService(BaseInstanceService):
 
     @dispatch(event="provider.compute.instances.create",
               priority=BaseInstanceService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, image, vm_type, subnet, zone,
+    def create(self, label, image, vm_type, subnet,
                key_pair=None, vm_firewalls=None, user_data=None,
                launch_config=None, **kwargs):
         OpenStackInstance.assert_valid_resource_label(label)
@@ -766,7 +765,7 @@ class OpenStackInstanceService(BaseInstanceService):
             net_id = (self.provider.networking.subnets
                       .get(subnet_id).network_id
                       if subnet_id else None)
-        zone_id = zone.id if isinstance(zone, PlacementZone) else zone
+        zone_name = self.provider.zone_name
         key_pair_name = key_pair.name if \
             isinstance(key_pair, KeyPair) else key_pair
         bdm = None
@@ -822,7 +821,7 @@ class OpenStackInstanceService(BaseInstanceService):
             vm_size,
             min_count=1,
             max_count=1,
-            availability_zone=zone_id,
+            availability_zone=zone_name,
             key_name=key_pair_name,
             security_groups=sg_name_list,
             userdata=str(user_data) or None,
@@ -1080,8 +1079,7 @@ class OpenStackSubnetService(BaseSubnetService):
 
     @dispatch(event="provider.networking.subnets.create",
               priority=BaseSubnetService.STANDARD_EVENT_PRIORITY)
-    def create(self, label, network, cidr_block, zone):
-        """zone param is ignored."""
+    def create(self, label, network, cidr_block):
         OpenStackSubnet.assert_valid_resource_label(label)
         network_id = (network.id if isinstance(network, OpenStackNetwork)
                       else network)
@@ -1098,10 +1096,7 @@ class OpenStackSubnetService(BaseSubnetService):
         sn_id = subnet.id if isinstance(subnet, OpenStackSubnet) else subnet
         self.provider.neutron.delete_subnet(sn_id)
 
-    def get_or_create_default(self, zone):
-        """
-        Subnet zone is not supported by OpenStack and is thus ignored.
-        """
+    def get_or_create_default(self):
         try:
             sn = self.find(label=OpenStackSubnet.CB_DEFAULT_SUBNET_LABEL)
             if sn:
@@ -1111,7 +1106,7 @@ class OpenStackSubnetService(BaseSubnetService):
             sn = self.provider.networking.subnets.create(
                 label=OpenStackSubnet.CB_DEFAULT_SUBNET_LABEL,
                 cidr_block=OpenStackSubnet.CB_DEFAULT_SUBNET_IPV4RANGE,
-                network=net, zone=zone)
+                network=net)
             router = self.provider.networking.routers.get_or_create_default(
                 net)
             router.attach_subnet(sn)