Floating IP changes.

azure_integration_test/test_integration_azure_network_service.py

@@ -0,0 +1,63 @@
+import uuid
+
+import azure_integration_test.helpers as helpers
+
+from azure_integration_test.helpers import ProviderTestBase
+
+
+class AzureIntegrationNetworkServiceTestCase(ProviderTestBase):
+    @helpers.skipIfNoService(['network'])
+    def test_crud_network_service(self):
+        name = 'intgtestnetworkservice-{0}'.format(uuid.uuid4())
+        net = self.provider.network.create(name=name)
+        with helpers.cleanup_action(
+            lambda:
+                self.provider.network.delete(network_id=net.id)
+        ):
+            # test list method
+            netl = self.provider.network.list()
+            list_netl = [n for n in netl if n.name == name]
+            self.assertTrue(
+                len(list_netl) == 1,
+                "List networks does not return the expected network %s" %
+                name)
+
+            # check get
+            get_net = self.provider.network.get(network_id=net.id)
+            self.assertTrue(
+                get_net == net,
+                "Get network did not return the expected network {0}."
+                .format(name))
+
+            # Check floating IP address
+            ip = self.provider.network.create_floating_ip()
+            ip_id = ip.id
+            with helpers.cleanup_action(lambda: ip.delete()):
+                ipl = self.provider.network.floating_ips()
+                self.assertTrue(
+                    ip in ipl,
+                    "Floating IP address {0} should exist in the list {1}"
+                    .format(ip.id, ipl))
+                self.assertIn(
+                    ip.public_ip, repr(ip),
+                    "repr(obj) should contain the address public IP value.")
+                self.assertFalse(
+                    ip.private_ip,
+                    "Floating IP should not have a private IP value ({0})."
+                    .format(ip.private_ip))
+                self.assertFalse(
+                    ip.in_use(),
+                    "Newly created floating IP address should not be in use.")
+            ipl = self.provider.network.floating_ips()
+            found_ip = [a for a in ipl if a.id == ip_id]
+            self.assertTrue(
+                len(found_ip) == 0,
+                "Floating IP {0} should have been deleted but still exists."
+                .format(ip_id))
+
+        netl = self.provider.network.list()
+        found_net = [n for n in netl if n.name == name]
+        self.assertEqual(
+            len(found_net), 0,
+            "Network {0} should have been deleted but still exists."
+            .format(name))

azure_test/test_azure_network_service.py

@@ -135,14 +135,6 @@ class AzureNetworkServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['network'])
     def test_network_methods(self):
-        with self.assertRaises(NotImplementedError):
-            floating_ips = self.provider.network.floating_ips()
-            self.assertIsNotNone(floating_ips)
-
-        with self.assertRaises(NotImplementedError):
-            floating_ip = self.provider.network.create_floating_ip()
-            self.assertIsNotNone(floating_ip)
-
         with self.assertRaises(NotImplementedError):
             routers = self.provider.network.routers()
             self.assertIsNotNone(routers)
@@ -162,3 +154,15 @@ class AzureNetworkServiceTestCase(ProviderTestBase):
         subnets = network.subnets()
         self.assertTrue(len(subnets) > 0)
         subnet.delete()
+
+    @helpers.skipIfNoService(['network'])
+    def test_azure_network_service_create_floating_ip(self):
+        floating_ip = self.provider.network.create_floating_ip()
+        print("create: " + str(floating_ip))
+        self.assertEqual(floating_ip.id,
+                         '/subscriptions'
+                         '/7904d702-e01c-4826-8519-f5a25c866a96'
+                         '/resourceGroups/cloudbridge-azure/providers'
+                         '/Microsoft.Network/publicIPAddresses/public_ip_test')
+        self.assertEqual(floating_ip.public_ip, '13.82.104.38')
+        self.assertEqual(floating_ip.private_ip, None)

cloudbridge/cloud/providers/azure/azure_client.py

@@ -244,6 +244,21 @@ class AzureClient(object):
         return self.network_management_client.virtual_networks. \
             delete(self.resource_group_name, network_name).wait()
 
+    def create_floating_ip(self, public_ip_name, public_ip_parameters):
+        return self.network_management_client.public_ip_addresses. \
+            create_or_update(self.resource_group_name,
+                             public_ip_name,
+                             public_ip_parameters).result()
+
+    def delete_floating_ip(self, public_ip_address_name):
+        return self.network_management_client.public_ip_addresses. \
+            delete(self.resource_group_name,
+                   public_ip_address_name).result()
+
+    def list_floating_ips(self):
+        return self.network_management_client.public_ip_addresses.list(
+            self.resource_group_name)
+
     def update_network_tags(self, network_name, tags):
         return self.network_management_client.virtual_networks. \
             create_or_update(self.resource_group_name,

cloudbridge/cloud/providers/azure/mock_azure_client.py

@@ -10,7 +10,7 @@ from azure.mgmt.compute.models import CreationData, DataDisk, \
     VirtualMachineSize
 
 from azure.mgmt.network.models import AddressSpace, NetworkInterface, \
-    NetworkSecurityGroup
+    NetworkSecurityGroup, PublicIPAddress
 from azure.mgmt.network.models import SecurityRule
 from azure.mgmt.network.models import Subnet, VirtualNetwork
 from azure.mgmt.resource.resources.models import ResourceGroup
@@ -131,6 +131,32 @@ class MockAzureClient:
 
     networks = [network1, network2, network3]
 
+    floating_ip1 = PublicIPAddress()
+    floating_ip1.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96' \
+                      '/resourceGroups/cloudbridge-azure/providers' \
+                      '/Microsoft.Network/publicIPAddresses/public_ip_1'
+    floating_ip1.name = 'public_ip_1'
+    floating_ip1.public_ip = '13.82.104.1'
+    floating_ip1.private_ip = None
+
+    floating_ip2 = PublicIPAddress()
+    floating_ip2.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96' \
+                      '/resourceGroups/cloudbridge-azure/providers' \
+                      '/Microsoft.Network/publicIPAddresses/public_ip_2'
+    floating_ip2.name = 'public_ip_2'
+    floating_ip2.public_ip = '13.82.104.2'
+    floating_ip2.private_ip = None
+
+    floating_ip3 = PublicIPAddress()
+    floating_ip3.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96' \
+                      '/resourceGroups/cloudbridge-azure/providers' \
+                      '/Microsoft.Network/publicIPAddresses/public_ip_3'
+    floating_ip3.name = 'public_ip_3'
+    floating_ip3.public_ip = '13.82.104.3'
+    floating_ip3.private_ip = None
+
+    floating_ips = [floating_ip1, floating_ip2, floating_ip3]
+
     volume1 = Disk(location='eastus', creation_data=None)
     volume1.id = '/subscriptions/7904d702-e01c-4826-8519-f5a25c866a96/' \
                  'resourceGroups/CLOUDBRIDGE-AZURE' \
@@ -439,6 +465,27 @@ class MockAzureClient:
         network = self.get_network(network_name)
         self.networks.remove(network)
 
+        return True
+
+    def create_floating_ip(self, public_ip_address_name, public_ip_parameters):
+        floating_ip = PublicIPAddress()
+        floating_ip.id = '/subscriptions' \
+                         '/7904d702-e01c-4826-8519-f5a25c866a96' \
+                         '/resourceGroups/cloudbridge-azure/providers' \
+                         '/Microsoft.Network/publicIPAddresses/public_ip_test'
+        floating_ip.ip_address = '13.82.104.38'
+        floating_ip.private_ip = None
+        return floating_ip
+
+    def list_floating_ips(self):
+        return self.floating_ips
+
+    def delete_floating_ip(self, public_ip_address_name):
+        for floating_ip in self.floating_ips:
+            if floating_ip.name == public_ip_address_name:
+                self.floating_ips.remove(floating_ip)
+        return True
+
     def create_resource_group(self, resource_group_name, params):
         rg = ResourceGroup(location='westus')
         rg.name = resource_group_name

cloudbridge/cloud/providers/azure/resources.py

@@ -12,8 +12,8 @@ from azure.common import AzureException
 from azure.mgmt.network.models import NetworkSecurityGroup
 
 from cloudbridge.cloud.base.resources import BaseAttachmentInfo, \
-    BaseBucket, BaseBucketObject, BaseInstance,\
-    BaseInstanceType, \
+    BaseBucket, BaseBucketObject, BaseFloatingIP, \
+    BaseInstance, BaseInstanceType, \
     BaseLaunchConfig, BaseMachineImage, BaseNetwork, \
     BasePlacementZone, BaseRegion, \
     BaseSecurityGroup, BaseSecurityGroupRule, BaseSnapshot, BaseSubnet, \
@@ -957,6 +957,40 @@ class AzureNetwork(BaseNetwork):
             create(network=self.id, cidr_block=cidr_block, name=name)
 
 
+class AzureFloatingIP(BaseFloatingIP):
+
+    def __init__(self, provider, floating_ip):
+        super(AzureFloatingIP, self).__init__(provider)
+        self._ip = floating_ip
+
+    @property
+    def id(self):
+        return self._ip.id
+
+    @property
+    def public_ip(self):
+        return self._ip.ip_address
+
+    @property
+    def private_ip(self):
+        return self._ip.ip_configuration.private_ip_address \
+            if self._ip.ip_configuration else None
+
+    def in_use(self):
+        return True if self._ip.ip_configuration else False
+
+    def delete(self):
+        """
+        Delete an existing floating ip.
+        """
+        try:
+            self._provider.azure_client.delete_floating_ip(self._ip.name)
+            return True
+        except CloudError as cloudError:
+            log.exception(cloudError.message)
+            return False
+
+
 class AzureRegion(BaseRegion):
     def __init__(self, provider, azure_region):
         super(AzureRegion, self).__init__(provider)

cloudbridge/cloud/providers/azure/services.py

@@ -22,7 +22,7 @@ from cloudbridge.cloud.providers.azure import helpers as azure_helpers
 
 from msrestazure.azure_exceptions import CloudError
 
-from .resources import AzureBucket, \
+from .resources import AzureBucket, AzureFloatingIP, \
     AzureInstance, AzureInstanceType, \
     AzureLaunchConfig, AzureMachineImage, \
     AzureNetwork, AzureRegion, AzureSecurityGroup, \
@@ -699,17 +699,31 @@ class AzureNetworkService(BaseNetworkService):
 
         return cb_network
 
+    def create_floating_ip(self):
+        public_ip_address_name = "{0}-{1}".format(
+            'public_ip', uuid.uuid4().hex[:6])
+        public_ip_parameters = {
+            'location': self.provider.azure_client.region_name,
+            'public_ip_allocation_method': 'Dynamic'
+        }
+
+        floating_ip = self.provider.azure_client.\
+            create_floating_ip(public_ip_address_name, public_ip_parameters)
+        return AzureFloatingIP(self.provider, floating_ip)
+
     @property
     def subnets(self):
         return self._subnet_svc
 
     def floating_ips(self, network_id=None):
-        raise NotImplementedError('AzureNetworkService '
-                                  'not implemented this method')
+        """
+               List all floating ips.
+        """
+        floating_ips = [AzureFloatingIP(self.provider, floating_ip)
+                        for floating_ip in self.provider.azure_client.
+                        list_floating_ips()]
 
-    def create_floating_ip(self):
-        raise NotImplementedError('AzureNetworkService '
-                                  'not implemented this method')
+        return ClientPagedResultList(self.provider, floating_ips)
 
     def routers(self):
         raise NotImplementedError('AzureNetworkService '