[WIP] Adding middleware support in factory

cloudbridge/cloud/base/provider.py

@@ -83,11 +83,11 @@ def debug_mode(self):
 
 
 class BaseCloudProvider(CloudProvider):
-    def __init__(self, config):
+    def __init__(self, config, middleware_manager=None):
         self._config = BaseConfiguration(config)
         self._config_parser = ConfigParser()
         self._config_parser.read(CloudBridgeConfigLocations)
-        self._middleware = SimpleMiddlewareManager()
+        self._middleware = middleware_manager or SimpleMiddlewareManager()
         self.add_required_middleware()
 
     @property

cloudbridge/cloud/factory.py

@@ -4,6 +4,10 @@
 import pkgutil
 from collections import defaultdict
 
+from pyeventsystem.interfaces import Middleware
+from pyeventsystem.middleware import AutoDiscoveredMiddleware
+from pyeventsystem.middleware import SimpleMiddlewareManager
+
 from cloudbridge.cloud import providers
 from cloudbridge.cloud.interfaces import CloudProvider
 from cloudbridge.cloud.interfaces import TestMockHelperMixin
@@ -12,6 +16,54 @@
 log = logging.getLogger(__name__)
 
 
+# Todo: Move to pyeventsystem if we're keeping this logic
+class ParentMiddlewareManager(SimpleMiddlewareManager):
+
+    def __init__(self, event_manager=None):
+        super(ParentMiddlewareManager, self).__init__(event_manager)
+        self.middleware_constructors = []
+
+    def add_constructor(self, middleware_class, *args):
+        self.middleware_constructors.append((middleware_class, args))
+
+    def remove_constructor(self, middleware_class, *args):
+        self.middleware_constructors.remove((middleware_class, args))
+
+    def generate_simple_manager(self):
+        new_manager = SimpleMiddlewareManager()
+        for middleware in self.middleware_list:
+            new_manager.add(middleware)
+        for constructor, args in self.middleware_constructors:
+            m = constructor(*args)
+            new_manager.add(m)
+        for handler in self.get_subscribed_handlers():
+            new_handler = handler.__class__(handler.event_pattern,
+                                            handler.priority,
+                                            handler.callback)
+            new_manager.events.subscribe(new_handler)
+        return new_manager
+
+    # Removing install step from add. Since this manager is meant to create
+    # other managers rather than run. This will also simplify separating
+    # handlers added through middleware from those subscribed directly
+    def add(self, middleware):
+        if isinstance(middleware, Middleware):
+            m = middleware
+        else:
+            m = AutoDiscoveredMiddleware(middleware)
+        self.middleware_list.append(m)
+        return m
+
+    def get_subscribed_handlers(self):
+        handlers = []
+        # Todo: Expose this better in pyeventsystem library
+        event_dict = self.events._SimpleEventDispatcher__events
+        for key in event_dict.keys():
+            for handler in event_dict[key]:
+                handlers.append(handler)
+        return handlers
+
+
 class ProviderList(object):
     AWS = 'aws'
     AZURE = 'azure'
@@ -27,9 +79,14 @@ class CloudProviderFactory(object):
     """
 
     def __init__(self):
+        self._middleware = ParentMiddlewareManager()
         self.provider_list = defaultdict(dict)
         log.debug("Providers List: %s", self.provider_list)
 
+    @property
+    def middleware(self):
+        return self._middleware
+
     def register_provider_class(self, cls):
         """
         Registers a provider class with the factory. The class must
@@ -136,7 +193,8 @@ def create_provider(self, name, config):
                 'A provider with name {0} could not be'
                 ' found'.format(name))
         log.debug("Created '%s' provider", name)
-        return provider_class(config)
+        return provider_class(config,
+                              self.middleware.generate_simple_manager())
 
     def get_provider_class(self, name):
         """

cloudbridge/cloud/providers/aws/provider.py

@@ -17,8 +17,8 @@ class AWSCloudProvider(BaseCloudProvider):
     PROVIDER_ID = 'aws'
     AWS_INSTANCE_DATA_DEFAULT_URL = "http://cloudve.org/cb-aws-vmtypes.json"
 
-    def __init__(self, config):
-        super(AWSCloudProvider, self).__init__(config)
+    def __init__(self, config, middleware_manager=None):
+        super(AWSCloudProvider, self).__init__(config, middleware_manager)
 
         # Initialize cloud connection fields
         # These are passed as-is to Boto

cloudbridge/cloud/providers/azure/provider.py

@@ -23,8 +23,8 @@
 class AzureCloudProvider(BaseCloudProvider):
     PROVIDER_ID = 'azure'
 
-    def __init__(self, config):
-        super(AzureCloudProvider, self).__init__(config)
+    def __init__(self, config, middleware_manager=None):
+        super(AzureCloudProvider, self).__init__(config, middleware_manager)
 
         # mandatory config values
         self.subscription_id = self._get_config_value(

cloudbridge/cloud/providers/gcp/provider.py

@@ -196,8 +196,8 @@ class GCPCloudProvider(BaseCloudProvider):
 
     PROVIDER_ID = 'gcp'
 
-    def __init__(self, config):
-        super(GCPCloudProvider, self).__init__(config)
+    def __init__(self, config, middleware_manager=None):
+        super(GCPCloudProvider, self).__init__(config, middleware_manager)
 
         # Disable warnings about file_cache not being available when using
         # oauth2client >= 4.0.0.

cloudbridge/cloud/providers/mock/provider.py

@@ -25,9 +25,9 @@ class MockAWSCloudProvider(AWSCloudProvider, TestMockHelperMixin):
     """
     PROVIDER_ID = 'mock'
 
-    def __init__(self, config):
+    def __init__(self, config, middleware_manager=None):
         self.setUpMock()
-        super(MockAWSCloudProvider, self).__init__(config)
+        super(MockAWSCloudProvider, self).__init__(config, middleware_manager)
 
     def setUpMock(self):
         """

cloudbridge/cloud/providers/openstack/provider.py

@@ -31,8 +31,9 @@ class OpenStackCloudProvider(BaseCloudProvider):
 
     PROVIDER_ID = 'openstack'
 
-    def __init__(self, config):
-        super(OpenStackCloudProvider, self).__init__(config)
+    def __init__(self, config, middleware_manager=None):
+        super(OpenStackCloudProvider, self).__init__(config,
+                                                     middleware_manager)
 
         # Initialize cloud connection fields
         self.username = self._get_config_value(

test/test_cloud_factory.py

@@ -1,7 +1,10 @@
 import unittest
 
+from pyeventsystem.middleware import intercept
+
 from cloudbridge.cloud import factory
 from cloudbridge.cloud import interfaces
+from cloudbridge.cloud.base import helpers as cb_helpers
 from cloudbridge.cloud.factory import CloudProviderFactory
 from cloudbridge.cloud.interfaces import TestMockHelperMixin
 from cloudbridge.cloud.interfaces.provider import CloudProvider
@@ -85,3 +88,97 @@ class DummyClass(CloudProvider):
         factory.register_provider_class(DummyClass)
         self.assertTrue(DummyClass not in
                         factory.get_all_provider_classes())
+
+    def test_middleware_inherited(self):
+        start_count = 10
+
+        class SomeDummyClass(object):
+            count = start_count
+
+            @intercept(event_pattern="*", priority=2499)
+            def return_incremented(self, event_args, *args, **kwargs):
+                self.count += 1
+                return self.count
+
+        factory = CloudProviderFactory()
+        some_obj = SomeDummyClass()
+        factory.middleware.add(some_obj)
+        provider_name = cb_helpers.get_env("CB_TEST_PROVIDER", "aws")
+        first_prov = factory.create_provider(provider_name, {})
+        # Any dispatched event should be intercepted and increment the count
+        first_prov.storage.volumes.get("anything")
+        self.assertEqual(first_prov.networking.networks.get("anything"),
+                         start_count + 2)
+        second_prov = factory.create_provider(provider_name, {})
+        # This count should be independent of the previous one
+        self.assertEqual(second_prov.networking.networks.get("anything"),
+                         start_count + 3)
+
+    def test_middleware_inherited_constructor(self):
+        start_count = 10
+        increment = 2
+
+        class SomeDummyClass(object):
+            count = start_count
+
+            @intercept(event_pattern="*", priority=2499)
+            def return_incremented(self, event_args, *args, **kwargs):
+                self.count += 1
+                return self.count
+
+        factory = CloudProviderFactory()
+        factory.middleware.add_constructor(SomeDummyClass)
+        provider_name = cb_helpers.get_env("CB_TEST_PROVIDER", "aws")
+        first_prov = factory.create_provider(provider_name, {})
+        # Any dispatched event should be intercepted and increment the count
+        first_prov.storage.volumes.get("anything")
+        self.assertEqual(first_prov.networking.networks.get("anything"),
+                         start_count + 2)
+        second_prov = factory.create_provider(provider_name, {})
+        # This count should be independent of the previous one
+        self.assertEqual(second_prov.networking.networks.get("anything"),
+                         start_count + 1)
+
+        class SomeDummyClassWithArgs(object):
+            def __init__(self, start, increment):
+                self.count = start
+                self.increment = increment
+
+            @intercept(event_pattern="*", priority=2499)
+            def return_incremented(self, event_args, *args, **kwargs):
+                self.count += self.increment
+                return self.count
+
+        factory = CloudProviderFactory()
+        factory.middleware.add_constructor(SomeDummyClassWithArgs,
+                                           start_count, increment)
+        provider_name = cb_helpers.get_env("CB_TEST_PROVIDER", "aws")
+        first_prov = factory.create_provider(provider_name, {})
+        # Any dispatched event should be intercepted and increment the count
+        first_prov.storage.volumes.get("anything")
+        self.assertEqual(first_prov.networking.networks.get("anything"),
+                         start_count + 2*increment)
+        second_prov = factory.create_provider(provider_name, {})
+        # This count should be independent of the previous one
+        self.assertEqual(second_prov.networking.networks.get("anything"),
+                         start_count + increment)
+
+    def test_middleware_inherited_events(self):
+
+        class SomeDummyClass(object):
+
+            @intercept(event_pattern="*", priority=2499)
+            def return_goodbye(self, event_args, *args, **kwargs):
+                return "goodbye"
+
+        def return_hello(event_args, *args, **kwargs):
+            return "hello"
+
+        factory = CloudProviderFactory()
+        factory.middleware.add(SomeDummyClass())
+        factory.middleware.events.intercept("*", 2490, return_hello)
+        provider_name = cb_helpers.get_env("CB_TEST_PROVIDER", "aws")
+        prov = factory.create_provider(provider_name, {})
+        # Any dispatched event should be intercepted and return "hello" instead
+        self.assertEqual(prov.networking.networks.get("anything"),
+                         "hello")