Add GCEInstanceTypesService. Fix some related tests.

cloudbridge/cloud/providers/gce/provider.py

@@ -13,6 +13,7 @@ from googleapiclient import discovery
 import httplib2
 from oauth2client.client import GoogleCredentials
 
+from .services import GCEComputeService
 from .services import GCESecurityService
 
 
@@ -39,12 +40,12 @@ class GCECloudProvider(BaseCloudProvider):
         self._gce_compute = None
 
         # Initialize provider services
+        self._compute = GCEComputeService(self)
         self._security = GCESecurityService(self)
 
     @property
     def compute(self):
-        raise NotImplementedError(
-            "GCECloudProvider does not implement this service")
+        return self._compute
 
     @property
     def network(self):

cloudbridge/cloud/providers/gce/resources.py

@@ -1,6 +1,7 @@
 """
 DataTypes used by this provider
 """
+from cloudbridge.cloud.base.resources import BaseInstanceType
 from cloudbridge.cloud.base.resources import BaseKeyPair
 
 
@@ -42,3 +43,48 @@ class GCEKeyPair(BaseKeyPair):
     @material.setter
     def material(self, value):
         self._kp_material = value
+
+
+class GCEInstanceType(BaseInstanceType):
+    def __init__(self, provider, instance_dict):
+        super(GCEInstanceType, self).__init__(provider)
+        self._inst_dict = instance_dict
+
+    @property
+    def id(self):
+        return str(self._inst_dict.get('id'))
+
+    @property
+    def name(self):
+        return self._inst_dict.get('name')
+
+    @property
+    def family(self):
+        return self._inst_dict.get('kind')
+
+    @property
+    def vcpus(self):
+        return self._inst_dict.get('guestCpus')
+
+    @property
+    def ram(self):
+        return self._inst_dict.get('memoryMb')
+
+    @property
+    def size_root_disk(self):
+        return 0
+
+    @property
+    def size_ephemeral_disks(self):
+        return int(self._inst_dict.get('maximumPersistentDisksSizeGb'))
+
+    @property
+    def num_ephemeral_disks(self):
+        return self._inst_dict.get('maximumPersistentDisks')
+
+    @property
+    def extra_data(self):
+        return {key: val for key, val in enumerate(self._inst_dict)
+                if key not in ['guestCpus', 'maximumPersistentDisksSizeGb',
+                               'kind', 'maximumPersistentDisks', 'memoryMb',
+                               'id']}

cloudbridge/cloud/providers/gce/services.py

@@ -1,7 +1,10 @@
 from cloudbridge.cloud.base.resources import ClientPagedResultList
+from cloudbridge.cloud.base.services import BaseComputeService
+from cloudbridge.cloud.base.services import BaseInstanceTypesService
 from cloudbridge.cloud.base.services import BaseKeyPairService
 from cloudbridge.cloud.base.services import BaseSecurityGroupService
 from cloudbridge.cloud.base.services import BaseSecurityService
+from cloudbridge.cloud.interfaces.resources import InstanceType
 from cloudbridge.cloud.providers.gce import helpers
 from collections import namedtuple
 import hashlib
@@ -9,6 +12,7 @@ import hashlib
 
 from retrying import retry
 
+from .resources import GCEInstanceType
 from .resources import GCEKeyPair
 
 
@@ -185,3 +189,66 @@ class GCESecurityGroupService(BaseSecurityGroupService):
 
     def __init__(self, provider):
         super(GCESecurityGroupService, self).__init__(provider)
+
+
+class GCEInstanceTypesService(BaseInstanceTypesService):
+
+    def __init__(self, provider):
+        super(GCEInstanceTypesService, self).__init__(provider)
+
+    @property
+    def instance_data(self):
+        response = self.provider.gce_compute \
+                                .machineTypes() \
+                                .list(project=self.provider.project_name,
+                                      zone=self.provider.default_zone) \
+                                .execute()
+        return response['items']
+
+    def get(self, instance_type_id):
+        for inst_type in self.instance_data:
+            if inst_type.get('id') == instance_type_id:
+                return GCEInstanceType(self.provider, inst_type)
+        return None
+
+    def find(self, **kwargs):
+        for inst_type in self.instance_data:
+            is_match = True
+            for key, value in kwargs.iteritems():
+                if key not in inst_type:
+                    raise TypeError("The attribute key is not valid.")
+                if inst_type.get(key) != value:
+                    is_match = False
+                    break
+            if is_match:
+                return GCEInstanceType(self.provider, inst_type)
+        return None
+
+    def list(self, limit=None, marker=None):
+        inst_types = [GCEInstanceType(self.provider, inst_type)
+                      for inst_type in self.instance_data]
+        return ClientPagedResultList(self.provider, inst_types,
+                                     limit=limit, marker=marker)
+
+
+class GCEComputeService(BaseComputeService):
+    # TODO: implement GCEComputeService
+    def __init__(self, provider):
+        super(GCEComputeService, self).__init__(provider)
+        self._instance_type_svc = GCEInstanceTypesService(self.provider)
+
+    @property
+    def images(self):
+        raise NotImplementedError("To be implemented")
+
+    @property
+    def instance_types(self):
+        return self._instance_type_svc
+
+    @property
+    def instances(self):
+        raise NotImplementedError("To be implemented")
+
+    @property
+    def regions(self):
+        raise NotImplementedError("To be implemented")

test/helpers.py

@@ -58,6 +58,9 @@ TEST_DATA_CONFIG = {
                                 'a471339a-bd0e-41e2-9406-4f308267ed0f'),
         "instance_type": os.environ.get('CB_INSTANCE_TYPE_OS', 'm1.tiny'),
         "placement": os.environ.get('CB_PLACEMENT_OS', 'nova'),
+    },
+    "GCECloudProvider": {
+        "instance_type": os.environ.get('CB_INSTANCE_TYPE_OS', 'f1-micro'),
     }
 }
 
@@ -67,6 +70,8 @@ def get_provider_test_data(provider, key):
         return TEST_DATA_CONFIG.get("AWSCloudProvider").get(key)
     elif "OpenStackCloudProvider" in provider.name:
         return TEST_DATA_CONFIG.get("OpenStackCloudProvider").get(key)
+    elif "GCECloudProvider" in provider.name:
+        return TEST_DATA_CONFIG.get("GCECloudProvider").get(key)
     return None
 
 

test/test_instance_types_service.py

@@ -79,13 +79,13 @@ class CloudInstanceTypesServiceTestCase(ProviderTestBase):
             self.provider,
             "instance_type")
         inst_type = self.provider.compute.instance_types.find(
-            name=instance_type_name)[0]
+            name=instance_type_name)
         self.assertTrue(isinstance(inst_type, InstanceType),
                         "Find must return an InstanceType object")
 
-        self.assertFalse(self.provider.compute.instance_types.find(
+        self.assertIsNone(self.provider.compute.instance_types.find(
             name="non_existent_instance_type"), "Searching for a non-existent"
-            " instance type must return an empty list")
+            " instance type must return None")
 
         with self.assertRaises(TypeError):
             self.provider.compute.instance_types.find(
@@ -102,7 +102,7 @@ class CloudInstanceTypesServiceTestCase(ProviderTestBase):
             self.provider,
             "instance_type")
         inst_type = self.provider.compute.instance_types.find(
-            name=instance_type_name)[0]
+            name=instance_type_name)
         self.assertEqual(inst_type,
                          compute_svc.instance_types.get(inst_type.id))
         self.assertIsNone(compute_svc.instance_types.get("non_existent_id"),