FloatingIP constructor no gateway

cloudbridge/cloud/base/resources.py

@@ -814,9 +814,8 @@ class BaseSubnet(BaseCloudResource, BaseObjectLifeCycleMixin, Subnet):
 
 class BaseFloatingIP(BaseCloudResource, BaseObjectLifeCycleMixin, FloatingIP):
 
-    def __init__(self, provider, gateway):
+    def __init__(self, provider):
         super(BaseFloatingIP, self).__init__(provider)
-        self._gateway = gateway
 
     @property
     def name(self):
@@ -841,7 +840,10 @@ class BaseFloatingIP(BaseCloudResource, BaseObjectLifeCycleMixin, FloatingIP):
                 self.id == other.id)
 
     def delete(self):
-        self._provider.networking._floating_ips.delete(self._gateway, self)
+        # For OS where the gateway is necessary, we pass the gateway when
+        # deleting, for all others we pass None and it will be ignored
+        gw = getattr(self, '_gateway_id', None)
+        self._provider.networking._floating_ips.delete(gw, self.id)
 
 
 class BaseRouter(BaseCloudResource, Router):

cloudbridge/cloud/providers/aws/helpers.py

@@ -130,21 +130,7 @@ class BotoGenericService(object):
 
         :returns A CloudBridge wrapped resource
         """
-        try:
-            log.debug("Retrieving resource: %s with id: %s",
-                      self.boto_collection_model.name, resource_id)
-            obj = self.boto_resource(resource_id)
-            obj.load()
-            log.debug("Successfully Retrieved: %s", obj)
-            return self.cb_resource(self.provider, obj)
-        except ClientError as exc:
-            error_code = exc.response['Error']['Code']
-            if any(status in error_code for status in
-                   ('NotFound', 'InvalidParameterValue', 'Malformed', '404')):
-                log.debug("Object not found: %s", resource_id)
-                return None
-            else:
-                raise exc
+        return self.cb_resource(self.provider, self.get_raw(resource_id))
 
     def _get_list_operation(self):
         """

cloudbridge/cloud/providers/aws/resources.py

@@ -981,8 +981,8 @@ class AWSSubnet(BaseSubnet):
 
 class AWSFloatingIP(BaseFloatingIP):
 
-    def __init__(self, provider, gateway, floating_ip):
-        super(AWSFloatingIP, self).__init__(provider, gateway)
+    def __init__(self, provider, floating_ip):
+        super(AWSFloatingIP, self).__init__(provider)
         self._ip = floating_ip
 
     @property

cloudbridge/cloud/providers/aws/services.py

@@ -12,7 +12,6 @@ import requests
 import cloudbridge.cloud.base.helpers as cb_helpers
 from cloudbridge.cloud.base.middleware import dispatch
 from cloudbridge.cloud.base.resources import ClientPagedResultList
-from cloudbridge.cloud.base.resources import ServerPagedResultList
 from cloudbridge.cloud.base.services import BaseBucketObjectService
 from cloudbridge.cloud.base.services import BaseBucketService
 from cloudbridge.cloud.base.services import BaseComputeService
@@ -1226,34 +1225,12 @@ class AWSFloatingIPService(BaseFloatingIPService):
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def get(self, gateway, fip_id):
         log.debug("Getting AWS Floating IP Service with the id: %s", fip_id)
-        return AWSFloatingIP(self.provider, gateway, self.svc.get_raw(fip_id))
+        return self.svc.get(fip_id)
 
     @dispatch(event="provider.networking.floating_ips.list",
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def list(self, gateway, limit=None, marker=None):
-        log.debug("Listing all floating IPs under gateway %s", gateway)
-        limit = limit or self.provider.config.default_result_limit
-        collection = self.svc.boto_collection.filter()
-        pag_type, resume_token, boto_objs = self.svc._make_query(collection,
-                                                                 limit,
-                                                                 marker)
-        # Wrap in CB objects.
-        results = [AWSFloatingIP(self.provider, gateway, obj) for obj in
-                   boto_objs]
-
-        if pag_type == 'server':
-            log.debug("Using server pagination.")
-            return ServerPagedResultList(is_truncated=True if resume_token
-                                         else False,
-                                         marker=resume_token if resume_token
-                                         else None,
-                                         supports_total=False,
-                                         data=results)
-        else:
-            log.debug("Did not received a resume token, will page in client"
-                      " if necessary.")
-            return ClientPagedResultList(self.provider, results,
-                                         limit=limit, marker=marker)
+        self.svc.list(limit, marker)
 
     @dispatch(event="provider.networking.floating_ips.create",
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
@@ -1263,14 +1240,13 @@ class AWSFloatingIPService(BaseFloatingIPService):
             Domain='vpc')
         return AWSFloatingIP(
             self.provider,
-            gateway,
             self.provider.ec2_conn.VpcAddress(ip.get('AllocationId')))
 
     @dispatch(event="provider.networking.floating_ips.delete",
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def delete(self, gateway, fip):
         if isinstance(fip, AWSFloatingIP):
-            os_fip = fip._ip
+            aws_fip = fip._ip
         else:
-            os_fip = self.svc.get_raw(fip)
-        os_fip.release()
+            aws_fip = self.svc.get_raw(fip)
+        aws_fip.release()

cloudbridge/cloud/providers/azure/resources.py

@@ -819,10 +819,9 @@ class AzureNetwork(BaseNetwork):
 
 class AzureFloatingIP(BaseFloatingIP):
 
-    def __init__(self, provider, gateway, floating_ip):
-        super(AzureFloatingIP, self).__init__(provider, gateway)
+    def __init__(self, provider, floating_ip):
+        super(AzureFloatingIP, self).__init__(provider)
         self._ip = floating_ip
-        self._network_id = gateway.network_id
 
     @property
     def id(self):
@@ -850,10 +849,10 @@ class AzureFloatingIP(BaseFloatingIP):
         return True if self._ip.ip_configuration else False
 
     def refresh(self):
-        net = self._provider.networking.networks.get(self._network_id)
-        gw = net.gateways.get_or_create()
-        fip = gw.floating_ips.get(self.id)
-        self._ip = fip._ip
+        # Gateway is not needed as it doesn't exist in Azure, so just
+        # getting the Floating IP again from the client
+        # pylint:disable=protected-access
+        return self._provider.networking._floating_ips.get(None, self.id)
 
 
 class AzureRegion(BaseRegion):

cloudbridge/cloud/providers/azure/services.py

@@ -1332,15 +1332,18 @@ class AzureFloatingIPService(BaseFloatingIPService):
     @dispatch(event="provider.networking.floating_ips.get",
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def get(self, gateway, fip_id):
-        log.debug("Getting Azure Floating IP container with the id: %s",
-                  fip_id)
-        fip = [fip for fip in gateway.floating_ips if fip.id == fip_id]
-        return fip[0] if fip else None
+        try:
+            az_ip = self.provider.azure_client.get_floating_ip(fip_id)
+        except (CloudError, InvalidValueException) as cloud_error:
+            # Azure raises the cloud error if the resource not available
+            log.exception(cloud_error)
+            return None
+        return AzureFloatingIP(self.provider, az_ip)
 
     @dispatch(event="provider.networking.floating_ips.list",
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def list(self, gateway, limit=None, marker=None):
-        floating_ips = [AzureFloatingIP(self.provider, gateway, floating_ip)
+        floating_ips = [AzureFloatingIP(self.provider, floating_ip)
                         for floating_ip in self.provider.azure_client.
                         list_floating_ips()]
         return ClientPagedResultList(self.provider, floating_ips,
@@ -1359,10 +1362,10 @@ class AzureFloatingIPService(BaseFloatingIPService):
 
         floating_ip = self.provider.azure_client.\
             create_floating_ip(public_ip_name, public_ip_parameters)
-        return AzureFloatingIP(self.provider, gateway, floating_ip)
+        return AzureFloatingIP(self.provider, floating_ip)
 
     @dispatch(event="provider.networking.floating_ips.delete",
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def delete(self, gateway, fip):
-        fip_id = fip if isinstance(fip, AzureFloatingIP) else fip
+        fip_id = fip.id if isinstance(fip, AzureFloatingIP) else fip
         self.provider.azure_client.delete_floating_ip(fip_id)

cloudbridge/cloud/providers/gce/resources.py

@@ -1326,8 +1326,8 @@ class GCENetwork(BaseNetwork):
 class GCEFloatingIP(BaseFloatingIP):
     _DEAD_INSTANCE = 'dead instance'
 
-    def __init__(self, provider, gateway, floating_ip):
-        super(GCEFloatingIP, self).__init__(provider, gateway)
+    def __init__(self, provider, floating_ip):
+        super(GCEFloatingIP, self).__init__(provider)
         self._ip = floating_ip
         self._process_ip_users()
 

cloudbridge/cloud/providers/gce/services.py

@@ -1535,7 +1535,7 @@ class GCEFloatingIPService(BaseFloatingIPService):
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def get(self, gateway, floating_ip_id):
         fip = self.provider.get_resource('addresses', floating_ip_id)
-        return (GCEFloatingIP(self.provider, gateway, fip)
+        return (GCEFloatingIP(self.provider, fip)
                 if fip else None)
 
     @dispatch(event="provider.networking.floating_ips.list",
@@ -1550,7 +1550,7 @@ class GCEFloatingIPService(BaseFloatingIPService):
                               maxResults=max_result,
                               pageToken=marker)
                         .execute())
-        ips = [GCEFloatingIP(self.provider, gateway, ip)
+        ips = [GCEFloatingIP(self.provider, ip)
                for ip in response.get('items', [])]
         if len(ips) > max_result:
             log.warning('Expected at most %d results; got %d',
@@ -1578,7 +1578,7 @@ class GCEFloatingIPService(BaseFloatingIPService):
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def delete(self, gateway, fip):
         fip = (fip if isinstance(fip, GCEFloatingIP)
-               else gateway.floating_ips.get(fip))
+               else self.get(gateway, fip))
         project_name = self.provider.project_name
         # First, delete the forwarding rule, if there is any.
         if fip._rule:

cloudbridge/cloud/providers/openstack/resources.py

@@ -903,8 +903,8 @@ class OpenStackSubnet(BaseSubnet):
 
 class OpenStackFloatingIP(BaseFloatingIP):
 
-    def __init__(self, provider, gateway, floating_ip):
-        super(OpenStackFloatingIP, self).__init__(provider, gateway)
+    def __init__(self, provider, floating_ip):
+        super(OpenStackFloatingIP, self).__init__(provider)
         self._ip = floating_ip
 
     @property
@@ -931,6 +931,10 @@ class OpenStackFloatingIP(BaseFloatingIP):
         # pylint:disable=protected-access
         self._ip = fip._ip
 
+    @property
+    def _gateway_id(self):
+        return self._ip.floating_network_id
+
 
 class OpenStackRouter(BaseRouter):
 

cloudbridge/cloud/providers/openstack/services.py

@@ -1191,7 +1191,7 @@ class OpenStackFloatingIPService(BaseFloatingIPService):
     def get(self, gateway, fip_id):
         try:
             return OpenStackFloatingIP(
-                self.provider, gateway,
+                self.provider,
                 self.provider.os_conn.network.get_ip(fip_id))
         except (ResourceNotFound, NotFoundException):
             log.debug("Floating IP %s not found.", fip_id)
@@ -1200,7 +1200,7 @@ class OpenStackFloatingIPService(BaseFloatingIPService):
     @dispatch(event="provider.networking.floating_ips.list",
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def list(self, gateway, limit=None, marker=None):
-        fips = [OpenStackFloatingIP(self.provider, gateway, fip)
+        fips = [OpenStackFloatingIP(self.provider, fip)
                 for fip in self.provider.os_conn.network.ips(
                     floating_network_id=gateway.id
                 )]
@@ -1211,7 +1211,7 @@ class OpenStackFloatingIPService(BaseFloatingIPService):
               priority=BaseFloatingIPService.STANDARD_EVENT_PRIORITY)
     def create(self, gateway):
         return OpenStackFloatingIP(
-            self.provider, gateway, self.provider.os_conn.network.create_ip(
+            self.provider, self.provider.os_conn.network.create_ip(
                 floating_network_id=gateway.id))
 
     @dispatch(event="provider.networking.floating_ips.delete",