Updated bucket service to use decorators

cloudbridge/cloud/base/services.py

@@ -4,6 +4,7 @@ Base implementation for services available through a provider
 import logging
 
 import cloudbridge.cloud.base.helpers as cb_helpers
+from cloudbridge.cloud.base.events import execute
 from cloudbridge.cloud.base.middleware import observe
 from cloudbridge.cloud.base.resources import BaseBucket
 from cloudbridge.cloud.base.resources import BaseNetwork
@@ -40,33 +41,19 @@ log = logging.getLogger(__name__)
 
 class BaseCloudService(CloudService):
 
+    STANDARD_EVENT_PRIORITY = 2500
+
     def __init__(self, provider):
         self._provider = provider
-        self._service_event_pattern = "provider"
+        # discover and register all middleware
+        provider.middleware.add(self)
 
     @property
     def provider(self):
         return self._provider
 
-    def _generate_event_pattern(self, func_name):
-        return ".".join((self._service_event_pattern, func_name))
-
-    def observe(self, func_name, priority, callback):
-        event_pattern = self._generate_event_pattern(func_name)
-        self.provider.events.observe(event_pattern, priority, callback)
-
-    def check_initialized(self, func_name):
-        event_pattern = self._generate_event_pattern(func_name)
-        return self.provider.events.check_initialized(event_pattern)
-
-    def mark_initialized(self, func_name):
-        event_pattern = self._generate_event_pattern(func_name)
-        self.provider.events.mark_initialized(event_pattern)
-
-    def call(self, func_name, priority, callback, **kwargs):
-        event_pattern = self._generate_event_pattern(func_name)
-        return self.provider.events.call(event_pattern, priority, callback,
-                                         **kwargs)
+    def emit(self, sender, event, *args, **kwargs):
+        return self._provider.events.emit(sender, event, *args, **kwargs)
 
 
 class BaseSecurityService(SecurityService, BaseCloudService):
@@ -146,73 +133,50 @@ class BaseBucketService(
 
     def __init__(self, provider):
         super(BaseBucketService, self).__init__(provider)
-        self._service_event_pattern = "provider.storage.buckets"
 
     @observe(event_pattern="provider.storage.buckets.get", priority=2000)
-    def _get_pre_log(self, bucket_id):
+    def _pre_log_get(self, event_args, bucket_id):
         log.debug("Getting {} bucket with the id: {}".format(
             self.provider.name, bucket_id))
 
     @observe(event_pattern="provider.storage.buckets.get", priority=3000)
-    def _get_post_log(self, callback_result, bucket_id):
+    def _post_log_get(self, event_args, bucket_id):
+        log.debug("Returned bucket obj: {}".format(event_args.get('result')))
+
+    @observe(event_pattern="provider.storage.buckets.find", priority=2000)
+    def _pre_log_find(self, *args, **kwargs):
+        log.debug("Finding {} buckets with the following arguments: {}"
+                  .format(self.provider.name, kwargs))
+
+    @observe(event_pattern="provider.storage.buckets.find", priority=3000)
+    def _post_log_find(self, event_args, *args, **kwargs):
+        log.debug("Returned bucket obj: {}".format(event_args.get('result')))
+
+    def _list_pre_log(self, limit, marker):
+        message = "Listing {} buckets".format(self.provider.name)
+        if limit:
+            message += " with limit: {}".format(limit)
+        if marker:
+            message += " with marker: {}".format(marker)
+        log.debug(message)
+
+    def _list_post_log(self, callback_result, limit, marker):
+        log.debug("Returned bucket objects: {}".format(callback_result))
+
+    def _create_pre_log(self, name, location):
+        message = "Creating {} bucket with name '{}'".format(
+            self.provider.name, name)
+        if location:
+            message += " in location: {}".format(location)
+        log.debug(message)
+
+    def _create_post_log(self, callback_result, name, location):
         log.debug("Returned bucket object: {}".format(callback_result))
 
-    def _init_find(self):
-        def _find_pre_log(**kwargs):
-            log.debug("Finding {} buckets with the following arguments: {}"
-                      .format(self.provider.name, kwargs))
-
-        def _find_post_log(callback_result, **kwargs):
-            log.debug("Returned bucket objects: {}".format(callback_result))
-
-        self.observe("find", 2000, _find_pre_log)
-        self.observe("find", 3000, _find_post_log)
-        self.mark_initialized("find")
-
-    def _init_list(self):
-            def _list_pre_log(limit, marker):
-                message = "Listing {} buckets".format(self.provider.name)
-                if limit:
-                    message += " with limit: {}".format(limit)
-                if marker:
-                    message += " with marker: {}".format(marker)
-                log.debug(message)
-
-            def _list_post_log(callback_result, limit, marker):
-                log.debug(
-                    "Returned bucket objects: {}".format(callback_result))
-
-            self.observe("list", 2000, _list_pre_log)
-            self.observe("list", 3000, _list_post_log)
-            self.mark_initialized("list")
-
-    def _init_create(self):
-        def _create_pre_log(name, location):
-            message = "Creating {} bucket with name '{}'".format(
-                self.provider.name, name)
-            if location:
-                message += " in location: {}".format(location)
-            log.debug(message)
-
-        def _create_post_log(callback_result, name, location):
-            log.debug("Returned bucket object: {}".format(callback_result))
-
-        self.observe("create", 2000, _create_pre_log)
-        self.observe("create", 3000, _create_post_log)
-        self.mark_initialized("create")
-
-    def get(self, bucket_id):
-        """
-        Returns a bucket given its ID. Returns ``None`` if the bucket
-        does not exist.
-        """
-        if not self.check_initialized("get"):
-            self._init_get()
-        return self.call("get", priority=2500, callback=self._get,
-                         bucket_id=bucket_id)
-
     # Generic find will be used for providers where we have not implemented
     # provider-specific querying for find method
+    @execute(event_pattern="provider.storage.buckets.find",
+             priority=BaseCloudService.STANDARD_EVENT_PRIORITY)
     def _find(self, **kwargs):
         obj_list = self
         filters = ['name']
@@ -227,34 +191,32 @@ class BaseBucketService(
         return ClientPagedResultList(self.provider,
                                      matches if matches else [])
 
+    def get(self, bucket_id):
+        """
+        Returns a bucket given its ID. Returns ``None`` if the bucket
+        does not exist.
+        """
+        return self.emit(self, "provider.storage.buckets.get", bucket_id)
+
     def find(self, **kwargs):
         """
         Returns a list of buckets filtered by the given keyword arguments.
         """
-        if not self.check_initialized("find"):
-            self._init_find()
-        return self.call("find", priority=2500, callback=self._find,
-                         **kwargs)
+        return self.emit(self, "provider.storage.buckets.find", **kwargs)
 
     def list(self, limit=None, marker=None):
         """
         List all buckets.
         """
-        if not self.check_initialized("list"):
-            self._init_list()
-        return self.call("list", priority=2500, callback=self._list,
+        return self.emit(self, "provider.storage.buckets.list",
                          limit=limit, marker=marker)
 
     def create(self, name, location=None):
         """
         Create a new bucket.
         """
-        if not self.check_initialized("create"):
-            self._init_create()
-        BaseBucket.assert_valid_resource_name(name)
-        location = location or self.provider.region_name
-        return self.call("create", priority=2500, callback=self._create,
-                         name=name, location=location)
+        return self.emit(self, "provider.storage.buckets.create",
+                         name, location=location)
 
 
 class BaseBucketObjectService(
@@ -262,7 +224,6 @@ class BaseBucketObjectService(
 
     def __init__(self, provider):
         super(BaseBucketObjectService, self).__init__(provider)
-        self._service_event_pattern = "provider.storage.bucket_objects"
         self._bucket = None
 
     def set_bucket(self, bucket):

cloudbridge/cloud/providers/aws/services.py

@@ -10,6 +10,7 @@ import cachetools
 import requests
 
 import cloudbridge.cloud.base.helpers as cb_helpers
+from cloudbridge.cloud.base.events import execute
 from cloudbridge.cloud.base.resources import ClientPagedResultList
 from cloudbridge.cloud.base.services import BaseBucketObjectService
 from cloudbridge.cloud.base.services import BaseBucketService
@@ -307,6 +308,8 @@ class AWSBucketService(BaseBucketService):
                                  cb_resource=AWSBucket,
                                  boto_collection_name='buckets')
 
+    @execute(event_pattern="provider.storage.buckets.get",
+             priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _get(self, bucket_id):
         """
         Returns a bucket given its ID. Returns ``None`` if the bucket
@@ -335,10 +338,16 @@ class AWSBucketService(BaseBucketService):
         # For all other responses, it's assumed that the bucket does not exist.
         return None
 
+    @execute(event_pattern="provider.storage.buckets.list",
+             priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _list(self, limit, marker):
         return self.svc.list(limit=limit, marker=marker)
 
+    @execute(event_pattern="provider.storage.buckets.create",
+             priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _create(self, name, location):
+        AWSBucket.assert_valid_resource_name(name)
+        location = location or self.provider.region_name
         # Due to an API issue in S3, specifying us-east-1 as a
         # LocationConstraint results in an InvalidLocationConstraint.
         # Therefore, it must be special-cased and omitted altogether.

cloudbridge/cloud/providers/azure/services.py

@@ -392,6 +392,7 @@ class AzureBucketService(BaseBucketService):
         """
         Create a new bucket.
         """
+        AzureBucket.assert_valid_resource_name(name)
         bucket = self.provider.azure_client.create_container(name)
         return AzureBucket(self.provider, bucket)
 

cloudbridge/cloud/providers/openstack/services.py

@@ -447,6 +447,8 @@ class OpenStackBucketService(BaseBucketService):
         return oshelpers.to_server_paged_list(self.provider, cb_buckets, limit)
 
     def _create(self, name, location):
+        OpenStackBucket.assert_valid_resource_name(name)
+        location = location or self.provider.region_name
         try:
             self.provider.swift.head_container(name)
             raise DuplicateResourceException(