Merge pull request #24 from chiniforooshan/network_service

Network service

cloudbridge/cloud/providers/gce/provider.py

@@ -14,6 +14,7 @@ from oauth2client.client import GoogleCredentials
 from oauth2client.service_account import ServiceAccountCredentials
 
 from .services import GCEComputeService
+from .services import GCENetworkService
 from .services import GCESecurityService
 
 
@@ -50,6 +51,7 @@ class GCECloudProvider(BaseCloudProvider):
         # Initialize provider services
         self._compute = GCEComputeService(self)
         self._security = GCESecurityService(self)
+        self._network = GCENetworkService(self)
 
     @property
     def compute(self):
@@ -57,8 +59,7 @@ class GCECloudProvider(BaseCloudProvider):
 
     @property
     def network(self):
-        raise NotImplementedError(
-            "GCECloudProvider does not implement this service")
+        return self._network
 
     @property
     def security(self):

cloudbridge/cloud/providers/gce/resources.py

@@ -4,10 +4,12 @@ DataTypes used by this provider
 from cloudbridge.cloud.base.resources import BaseInstanceType
 from cloudbridge.cloud.base.resources import BaseKeyPair
 from cloudbridge.cloud.base.resources import BaseMachineImage
+from cloudbridge.cloud.base.resources import BaseNetwork
 from cloudbridge.cloud.base.resources import BasePlacementZone
 from cloudbridge.cloud.base.resources import BaseRegion
 from cloudbridge.cloud.base.resources import BaseSecurityGroup
 from cloudbridge.cloud.base.resources import BaseSecurityGroupRule
+from cloudbridge.cloud.interfaces.resources import MachineImageState
 
 # Older versions of Python do not have a built-in set data-structure.
 try:
@@ -680,4 +682,55 @@ class GCEMachineImage(BaseMachineImage):
             # image no longer exists
             cb.log.warning(
                 "googleapiclient.errors.HttpError: {0}".format(http_error))
-            self._gce_image['status'] = "unknown"
+            self._gce_image['status'] = "unknown"
+
+
+class GCENetwork(BaseNetwork):
+
+    def __init__(self, provider, network):
+        super(GCENetwork, self).__init__(provider)
+        self._network = network
+
+    @property
+    def id(self):
+        return self._network['id']
+
+    @property
+    def name(self):
+        return self._network['name']
+
+    @property
+    def external(self):
+        raise NotImplementedError("To be implemented")
+
+    @property
+    def state(self):
+        raise NotImplementedError("To be implemented")
+
+    @property
+    def cidr_block(self):
+        return self._network['IPv4Range']
+
+    def delete(self):
+        try:
+            response = (self._provider
+                    .gce_compute
+                    .networks()
+                    .delete(project=self._provider.project_name,
+                            network=self.name)
+                    .execute())
+            if 'error' in response:
+                return False
+            self._provider.wait_for_global_operation(response)
+            return True
+        except:
+            return False
+
+    def subnets(self):
+        raise NotImplementedError("To be implemented")
+
+    def create_subnet(self, cidr_block, name=None):
+        raise NotImplementedError("To be implemented")
+
+    def refresh(self):
+        return self.state

cloudbridge/cloud/providers/gce/services.py

@@ -3,6 +3,7 @@ from cloudbridge.cloud.base.services import BaseComputeService
 from cloudbridge.cloud.base.services import BaseImageService
 from cloudbridge.cloud.base.services import BaseInstanceTypesService
 from cloudbridge.cloud.base.services import BaseKeyPairService
+from cloudbridge.cloud.base.services import BaseNetworkService
 from cloudbridge.cloud.base.services import BaseRegionService
 from cloudbridge.cloud.base.services import BaseSecurityGroupService
 from cloudbridge.cloud.base.services import BaseSecurityService
@@ -16,11 +17,12 @@ import googleapiclient
 from retrying import retry
 import sys
 
+from .resources import GCEFirewallsDelegate
 from .resources import GCEMachineImage
+from .resources import GCENetwork
 from .resources import GCEInstanceType
 from .resources import GCEKeyPair
 from .resources import GCERegion
-from .resources import GCEFirewallsDelegate
 from .resources import GCESecurityGroup
 from .resources import GCESecurityGroupRule
 
@@ -417,3 +419,59 @@ class GCEComputeService(BaseComputeService):
     @property
     def regions(self):
         return self._region_svc
+
+
+class GCENetworkService(BaseNetworkService):
+
+    def __init__(self, provider):
+        super(GCENetworkService, self).__init__(provider)
+
+    def get(self, network_id):
+        networks = self.list(filter='id eq %s' % network_id)
+        return None if len(networks) == 0 else networks[0]
+
+    def list(self, limit=None, marker=None, filter=None):
+        try:
+            response = (self.provider.gce_compute
+                                     .networks()
+                                     .list(project=self.provider.project_name,
+                                           filter=filter)
+                                     .execute())
+            networks = []
+            if 'items' in response:
+                for network in response['items']:
+                    networks.append(GCENetwork(self.provider, network))
+            return networks
+        except:
+            return []
+
+    def create(self, name):
+        try:
+            response = (self.provider.gce_compute
+                                     .networks()
+                                     .insert(project=self.provider.project_name,
+                                             body={'name': name})
+                                     .execute())
+            if 'error' in response:
+                return None
+            self.provider.wait_for_global_operation(response)
+            networks = self.list(filter='name eq %s' % name)
+            return None if len(networks) == 0 else networks[0]
+        except Exception as e:
+            return None
+
+    @property
+    def subnets(self):
+        raise NotImplementedError('To be implemented')
+
+    def floating_ips(self, network_id=None):
+        raise NotImplementedError('To be implemented')
+
+    def create_floating_ip(self):
+        raise NotImplementedError('To be implemented')
+
+    def routers(self):
+        raise NotImplementedError('To be implemented')
+
+    def create_router(self, name=None):
+        raise NotImplementedError('To be implemented')

test/test_network_service.py

@@ -12,7 +12,6 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
 
     def test_crud_network_service(self):
         name = 'cbtestnetworkservice-{0}'.format(uuid.uuid4())
-        subnet_name = 'cbtestsubnetservice-{0}'.format(uuid.uuid4())
         net = self.provider.network.create(name=name)
         with helpers.cleanup_action(
             lambda:
@@ -33,7 +32,21 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
                 "Get network did not return the expected network {0}."
                 .format(name))
 
-            # check subnet
+        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))
+
+    def test_crud_subnet_service(self):
+        name = 'cbtestnetworkservice-{0}'.format(uuid.uuid4())
+        subnet_name = 'cbtestsubnetservice-{0}'.format(uuid.uuid4())
+        net = self.provider.network.create(name=name)
+        with helpers.cleanup_action(
+            lambda:
+                self.provider.network.delete(network_id=net.id)
+        ):
             subnet = self.provider.network.subnets.create(
                 network=net, cidr_block="10.0.0.1/24", name=subnet_name)
             with helpers.cleanup_action(
@@ -60,38 +73,6 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
                 "Subnet {0} should have been deleted but still exists."
                 .format(subnet_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))
-                # 2016-08: address filtering not implemented in moto
-                # empty_ipl = self.provider.network.floating_ips('dummy-net')
-                # self.assertFalse(
-                #     empty_ipl,
-                #     "Bogus network should not have any floating IPs: {0}"
-                #     .format(empty_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(
@@ -99,6 +80,38 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
             "Network {0} should have been deleted but still exists."
             .format(name))
 
+    def test_crud_ip(self):
+        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))
+            # 2016-08: address filtering not implemented in moto
+            # empty_ipl = self.provider.network.floating_ips('dummy-net')
+            # self.assertFalse(
+            #     empty_ipl,
+            #     "Bogus network should not have any floating IPs: {0}"
+            #     .format(empty_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))
+
     def test_crud_network(self):
         name = 'cbtestnetwork-{0}'.format(uuid.uuid4())
         subnet_name = 'cbtestsubnet-{0}'.format(uuid.uuid4())