Removed version number from factory

cloudbridge/cloud/factory.py

@@ -26,31 +26,22 @@ class CloudProviderFactory(object):
         """
         return [
             {"name": ProviderList.OPENSTACK,
-             "implementations":
-                [{"class":
-                  "cloudbridge.cloud.providers.openstack.OpenStackCloud"
-                  "ProviderV1",
-                  "version": 1}]},
+             "class": "cloudbridge.cloud.providers.openstack.OpenStackCloud"
+                      "Provider"
+             },
             {"name": ProviderList.AWS,
-             "implementations":
-                [{"class": "cloudbridge.cloud.providers.aws.AWSCloudProvider"
-                  "V1",
-                  "mock_class":
-                  "cloudbridge.cloud.providers.aws.MockAWSCloudProvider",
-                  "version": 1}]}]
-
-    def find_provider_impl(self, name, version=None, get_mock=False):
+             "class": "cloudbridge.cloud.providers.aws.AWSCloudProvider",
+             "mock_class": "cloudbridge.cloud.providers.aws.MockAWSCloud"
+                           "Provider"
+             }]
+
+    def find_provider_impl(self, name, get_mock=False):
         """
         Finds a provider implementation class given its name.
 
         :type name: str
         :param name: A name of the provider whose implementation to look for.
 
-        :type version: inst
-        :param version: A specific version of the provider to look for. If the
-                        version is not specified, return the latest available
-                        version.
-
         :type get_mock: ``bool``
         :param get_mock: If True, returns a mock version of the provider
         if available, or the real version if not.
@@ -61,28 +52,13 @@ class CloudProviderFactory(object):
         """
         for provider in self.list_providers():
             if provider['name'] == name:
-                if version:
-                    match = [item for item in provider["implementations"]
-                             if item["version"] == version]
-                    if match:
-                        if get_mock and match[0].get("mock_class"):
-                            return match[0]["mock_class"]
-                        else:
-                            return match[0]["class"]
-                    else:
-                        return None
+                if get_mock and provider.get("mock_class"):
+                    return provider["mock_class"]
                 else:
-                    # Return latest available version
-                    latest_version = sorted(
-                        (item for item in provider["implementations"]),
-                        key=lambda x: x["version"])[-1]
-                    if get_mock and latest_version.get("mock_class"):
-                        return latest_version["mock_class"]
-                    else:
-                        return latest_version["class"]
+                    return provider["class"]
         return None
 
-    def create_provider(self, name, config, version=None):
+    def create_provider(self, name, config):
         """
         Searches all available providers for a CloudProvider interface with the
         given name, and instantiates it based on the given config dictionary,
@@ -100,10 +76,10 @@ class CloudProviderFactory(object):
         :return:  a concrete provider instance
         :rtype: ``object`` of :class:`.CloudProvider`
         """
-        impl = self.find_provider_impl(name, version=version)
+        impl = self.find_provider_impl(name)
         if impl is None:
             raise NotImplementedError(
-                'A provider by name {0} implementing interface v1 could not be'
+                'A provider with name {0} could not be'
                 ' found'.format(name))
         provider_class = self._get_provider_class(impl)
         return provider_class(config)
@@ -114,7 +90,7 @@ class CloudProviderFactory(object):
                                  class_name)
         return provider_class
 
-    def get_provider_class(self, name, version=None, get_mock=False):
+    def get_provider_class(self, name, get_mock=False):
         """
         Return a class for the requested provider.
 
@@ -128,7 +104,6 @@ class CloudProviderFactory(object):
         """
         provider_class = self.find_provider_impl(
             name,
-            version,
             get_mock=get_mock)
         if provider_class:
             return self._get_provider_class(provider_class)
@@ -148,13 +123,12 @@ class CloudProviderFactory(object):
         """
         all_providers = []
         for provider in self.list_providers():
-            for impl in provider["implementations"]:
-                if get_mock and impl.get("mock_class"):
-                    all_providers.append(
-                        self._get_provider_class(
-                            impl["mock_class"]))
-                else:
-                    all_providers.append(
-                        self._get_provider_class(
-                            impl["class"]))
+            if get_mock and provider.get("mock_class"):
+                all_providers.append(
+                    self._get_provider_class(
+                        provider["mock_class"]))
+            else:
+                all_providers.append(
+                    self._get_provider_class(
+                        provider["class"]))
         return all_providers

cloudbridge/cloud/providers/aws/__init__.py

@@ -2,5 +2,5 @@
 Exports from this provider
 """
 
-from .impl import AWSCloudProviderV1
+from .impl import AWSCloudProvider
 from .impl import MockAWSCloudProvider

cloudbridge/cloud/providers/aws/impl.py

@@ -20,10 +20,10 @@ from .services import AWSObjectStoreService
 from .services import AWSSecurityService
 
 
-class AWSCloudProviderV1(BaseCloudProvider):
+class AWSCloudProvider(BaseCloudProvider):
 
     def __init__(self, config):
-        super(AWSCloudProviderV1, self).__init__(config)
+        super(AWSCloudProvider, self).__init__(config)
         self.cloud_type = 'aws'
 
         # Initialize cloud connection fields
@@ -101,7 +101,7 @@ class AWSCloudProviderV1(BaseCloudProvider):
         return s3_conn
 
 
-class MockAWSCloudProvider(AWSCloudProviderV1, TestMockHelperMixin):
+class MockAWSCloudProvider(AWSCloudProvider, TestMockHelperMixin):
 
     def __init__(self, config):
         super(MockAWSCloudProvider, self).__init__(config)

cloudbridge/cloud/providers/openstack/__init__.py

@@ -2,4 +2,4 @@
 Exports from this provider
 """
 
-from .impl import OpenStackCloudProviderV1
+from .impl import OpenStackCloudProvider

cloudbridge/cloud/providers/openstack/impl.py

@@ -21,10 +21,10 @@ from .services import OpenStackObjectStoreService
 from .services import OpenStackSecurityService
 
 
-class OpenStackCloudProviderV1(BaseCloudProvider):
+class OpenStackCloudProvider(BaseCloudProvider):
 
     def __init__(self, config):
-        super(OpenStackCloudProviderV1, self).__init__(config)
+        super(OpenStackCloudProvider, self).__init__(config)
 
         self.username = self._get_config_value(
             'username', os.environ.get('OS_USERNAME', None))

test/test_provider_factory.py

@@ -3,7 +3,7 @@ import unittest
 from cloudbridge.cloud import factory
 from cloudbridge.cloud import interfaces
 from cloudbridge.cloud.factory import CloudProviderFactory
-from cloudbridge.cloud.providers.aws import AWSCloudProviderV1
+from cloudbridge.cloud.providers.aws import AWSCloudProvider
 import test.helpers as helpers
 
 
@@ -15,7 +15,7 @@ class ProviderFactoryTestCase(unittest.TestCase):
         a valid implementation
         """
         self.assertIsInstance(CloudProviderFactory().create_provider(
-            factory.ProviderList.AWS, {}, version=1),
+            factory.ProviderList.AWS, {}),
             interfaces.CloudProvider,
             "create_provider did not return a valid instance type")
 
@@ -26,47 +26,29 @@ class ProviderFactoryTestCase(unittest.TestCase):
         """
         with self.assertRaises(NotImplementedError):
             CloudProviderFactory().create_provider("ec23", {})
-        with self.assertRaises(NotImplementedError):
-            CloudProviderFactory().create_provider(
-                factory.ProviderList.AWS,
-                {},
-                version=100)
 
     def test_find_provider_impl_valid(self):
         """
-        Searching for a provider with a known name or version should return a
+        Searching for a provider with a known name should return a
         valid implementation
         """
-        self.assertTrue(
-            CloudProviderFactory().find_provider_impl(
-                factory.ProviderList.AWS))
         self.assertEqual(CloudProviderFactory().find_provider_impl(
-            factory.ProviderList.AWS, version=1),
-            "cloudbridge.cloud.providers.aws.AWSCloudProviderV1")
+            factory.ProviderList.AWS),
+            "cloudbridge.cloud.providers.aws.AWSCloudProvider")
 
     def test_find_provider_impl_invalid(self):
         """
-        Searching for a provider with an invalid name or version should return
+        Searching for a provider with an invalid name should return
         None
         """
         self.assertIsNone(
             CloudProviderFactory().find_provider_impl("openstack1"))
-        self.assertIsNone(CloudProviderFactory().find_provider_impl(
-            factory.ProviderList.AWS, version=100))
 
     def test_find_provider_mock_valid(self):
         """
         Searching for a provider with a known mock driver should return
         an implementation implementing helpers.TestMockHelperMixin
         """
-        mock = CloudProviderFactory().get_provider_class(
-            factory.ProviderList.AWS, version=1,
-            get_mock=True)
-        self.assertTrue(
-            issubclass(
-                mock,
-                helpers.TestMockHelperMixin),
-            "Expected mock for AWS but class does not implement mock provider")
         mock = CloudProviderFactory().get_provider_class(
             factory.ProviderList.AWS, get_mock=True)
         self.assertTrue(
@@ -74,35 +56,26 @@ class ProviderFactoryTestCase(unittest.TestCase):
                 mock,
                 helpers.TestMockHelperMixin),
             "Expected mock for AWS but class does not implement mock provider")
-        mock = CloudProviderFactory().get_provider_class(
-            factory.ProviderList.AWS, version=1,
-            get_mock=False)
         for cls in CloudProviderFactory().get_all_provider_classes(
                 get_mock=False):
             self.assertTrue(
                 not issubclass(
-                    mock,
+                    cls,
                     helpers.TestMockHelperMixin),
-                "Did not expect mock but class implements mock provider")
+                "Did not expect mock but %s implements mock provider" %
+                cls)
 
     def test_get_provider_class_valid(self):
         """
         Searching for a provider class with a known name should return a valid
         class
         """
-        self.assertTrue(
-            CloudProviderFactory().get_provider_class(
-                factory.ProviderList.AWS))
         self.assertEqual(CloudProviderFactory().get_provider_class(
-            factory.ProviderList.AWS, version=1),
-            AWSCloudProviderV1)
+            factory.ProviderList.AWS), AWSCloudProvider)
 
     def test_get_provider_class_invalid(self):
         """
-        Searching for a provider class with an invalid name or version should
+        Searching for a provider class with an invalid name should
         return None
         """
         self.assertIsNone(CloudProviderFactory().get_provider_class("aws1"))
-        self.assertIsNone(CloudProviderFactory().get_provider_class(
-            factory.ProviderList.AWS,
-            version=100))