Merge pull request #178 from CloudVE/middleware-alex

Middleware

cloudbridge/cloud/base/events.py

@@ -32,7 +32,7 @@ def observe(event_pattern, priority):
     return deco
 
 
-def execute(event_pattern, priority):
+def implement(event_pattern, priority):
     def deco(f):
         # Mark function as having an event_handler so we can discover it
         # The callback cannot be set to f as it is not bound yet and will be
@@ -207,12 +207,12 @@ class SimpleEventDispatcher(EventDispatcher):
         self.subscribe(handler)
         return handler
 
-    def execute(self, event_pattern, priority, callback):
+    def implement(self, event_pattern, priority, callback):
         handler = ExecutingEventHandler(event_pattern, priority, callback)
         self.subscribe(handler)
         return handler
 
-    def emit(self, sender, event, *args, **kwargs):
+    def dispatch(self, sender, event, *args, **kwargs):
         handlers = self.get_handlers_for_event(event)
 
         if handlers:

cloudbridge/cloud/base/middleware.py

@@ -1,11 +1,12 @@
-import inspect
 import logging
 import sys
+from inspect import ismethod
 
 import six
 
 from ..base.events import intercept
 from ..base.events import observe
+from ..interfaces.events import EventHandler
 from ..interfaces.exceptions import CloudBridgeBaseException
 from ..interfaces.middleware import Middleware
 from ..interfaces.middleware import MiddlewareManager
@@ -37,6 +38,7 @@ class BaseMiddleware(Middleware):
 
     def __init__(self):
         self.event_handlers = []
+        self.events = None
 
     def install(self, event_manager):
         self.events = event_manager
@@ -53,12 +55,19 @@ class BaseMiddleware(Middleware):
 
     def discover_handlers(self, class_or_obj):
         discovered_handlers = []
-        for _, func in inspect.getmembers(class_or_obj, inspect.ismethod):
-            handler = getattr(func, "__event_handler", None)
-            if handler:
-                # Set the properly bound method as the callback
-                handler.callback = func
-                discovered_handlers.append(handler)
+        for key in dir(class_or_obj):
+            try:
+                func = getattr(class_or_obj, key)
+            # Properties can sometimes cause various exceptions (e.g. during
+            # auth failure testing)
+            except Exception:
+                continue
+            if ismethod(func):
+                handler = getattr(func, "__event_handler", None)
+                if handler and isinstance(handler, EventHandler):
+                    # Set the properly bound method as the callback
+                    handler.callback = func
+                    discovered_handlers.append(handler)
         return discovered_handlers
 
     def uninstall(self):

cloudbridge/cloud/base/resources.py

@@ -752,6 +752,14 @@ class BaseBucket(BaseCloudResource, Bucket):
                 # check from most to least likely mutables
                 self.name == other.name)
 
+    def delete(self):
+        """
+        Delete this bucket.
+        """
+        self._provider.storage.buckets.delete(self.id)
+
+    # TODO: Discuss creating `create_object` method, or change docs
+
 
 class BaseBucketContainer(BasePageableObjectMixin, BucketContainer):
 

cloudbridge/cloud/base/services.py

@@ -4,8 +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.events import implement
 from cloudbridge.cloud.base.resources import BaseBucket
 from cloudbridge.cloud.base.resources import BaseNetwork
 from cloudbridge.cloud.base.resources import BaseRouter
@@ -44,6 +43,7 @@ class BaseCloudService(CloudService):
     STANDARD_EVENT_PRIORITY = 2500
 
     def __init__(self, provider):
+        self._service_event_pattern = "provider"
         self._provider = provider
         # discover and register all middleware
         provider.middleware.add(self)
@@ -52,8 +52,8 @@ class BaseCloudService(CloudService):
     def provider(self):
         return self._provider
 
-    def emit(self, sender, event, *args, **kwargs):
-        return self._provider.events.emit(sender, event, *args, **kwargs)
+    def dispatch(self, sender, event, *args, **kwargs):
+        return self._provider.events.dispatch(sender, event, *args, **kwargs)
 
     def _generate_event_pattern(self, func_name):
         return ".".join((self._service_event_pattern, func_name))
@@ -66,24 +66,40 @@ class BaseCloudService(CloudService):
         event_pattern = self._generate_event_pattern(func_name)
         self.provider.events.intercept(event_pattern, priority, callback)
 
-    def execute_function(self, func_name, priority, callback):
+    def implement_function(self, func_name, priority, callback):
         event_pattern = self._generate_event_pattern(func_name)
-        self.provider.events.execute(event_pattern, priority, callback)
+        self.provider.events.implement(event_pattern, priority, callback)
+
+    def dispatch_function(self, sender, func_name, *args, **kwargs):
+        """
+        Emits the event corresponding to the given function name for the
+        current service
+
+        :type sender: CloudService
+        :param sender: The CloudBridge Service object sending the emit signal
+        :type func_name: str
+        :param func_name: The name of the function to be emitted. e.g.: 'get'
+        :type args: CloudService
+
+        :return:  The return value resulting from the handler chain invocations
+        """
+        full_event_name = self._generate_event_pattern(func_name)
+        return self._provider.events.dispatch(sender, full_event_name,
+                                              *args, **kwargs)
 
 
 class BaseSecurityService(SecurityService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseSecurityService, self).__init__(provider)
-        self._service_event_pattern += ".security"
 
 
 class BaseKeyPairService(
-        BasePageableObjectMixin, KeyPairService, BaseSecurityService):
+        BasePageableObjectMixin, KeyPairService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseKeyPairService, self).__init__(provider)
-        self._service_event_pattern += ".key_pairs"
+        self._service_event_pattern += ".security.key_pairs"
 
     def delete(self, key_pair_id):
         """
@@ -105,11 +121,11 @@ class BaseKeyPairService(
 
 
 class BaseVMFirewallService(
-        BasePageableObjectMixin, VMFirewallService, BaseSecurityService):
+        BasePageableObjectMixin, VMFirewallService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseVMFirewallService, self).__init__(provider)
-        self._service_event_pattern += ".vm_firewalls"
+        self._service_event_pattern += ".security.vm_firewalls"
 
     def find(self, **kwargs):
         obj_list = self
@@ -130,75 +146,35 @@ class BaseStorageService(StorageService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseStorageService, self).__init__(provider)
-        self._service_event_pattern += ".storage"
 
 
 class BaseVolumeService(
-        BasePageableObjectMixin, VolumeService, BaseStorageService):
+        BasePageableObjectMixin, VolumeService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseVolumeService, self).__init__(provider)
-        self._service_event_pattern += ".volumes"
+        self._service_event_pattern += ".storage.volumes"
 
 
 class BaseSnapshotService(
-        BasePageableObjectMixin, SnapshotService, BaseStorageService):
+        BasePageableObjectMixin, SnapshotService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseSnapshotService, self).__init__(provider)
-        self._service_event_pattern += ".snapshots"
+        self._service_event_pattern += ".storage.snapshots"
 
 
 class BaseBucketService(
-        BasePageableObjectMixin, BucketService, BaseStorageService):
+        BasePageableObjectMixin, BucketService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseBucketService, self).__init__(provider)
-        self._service_event_pattern += ".buckets"
-
-    @observe(event_pattern="provider.storage.buckets.get", priority=2000)
-    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 _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))
+        self._service_event_pattern += ".storage.buckets"
 
     # 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)
+    @implement(event_pattern="*.storage.buckets.find",
+               priority=BaseCloudService.STANDARD_EVENT_PRIORITY)
     def _find(self, **kwargs):
         obj_list = self
         filters = ['name']
@@ -217,39 +193,66 @@ class BaseBucketService(
         """
         Returns a bucket given its ID. Returns ``None`` if the bucket
         does not exist.
+
+        :type bucket_id: str
+        :param bucket_id: The id of the desired bucket.
+
+        :rtype: ``Bucket``
+        :return:  ``None`` is returned if the bucket does not exist, and
+                  the bucket's provider-specific CloudBridge object is
+                  returned if the bucket is found.
         """
-        return self.emit(self, "provider.storage.buckets.get", bucket_id)
+        return self.dispatch(self, "provider.storage.buckets.get", bucket_id)
 
     def find(self, **kwargs):
         """
         Returns a list of buckets filtered by the given keyword arguments.
+        Accepted search arguments are: 'name'
         """
-        return self.emit(self, "provider.storage.buckets.find", **kwargs)
+        return self.dispatch(self, "provider.storage.buckets.find", **kwargs)
 
     def list(self, limit=None, marker=None):
         """
         List all buckets.
         """
-        return self.emit(self, "provider.storage.buckets.list",
-                         limit=limit, marker=marker)
+        return self.dispatch(self, "provider.storage.buckets.list",
+                             limit=limit, marker=marker)
 
     def create(self, name, location=None):
         """
         Create a new bucket.
+
+        :type name: str
+        :param name: The name of the bucket to be created. Note that names
+                     must be unique, and are unchangeable.
+
+        :rtype: ``Bucket``
+        :return:  The created bucket's provider-specific CloudBridge object.
         """
         BaseBucket.assert_valid_resource_name(name)
-        return self.emit(self, "provider.storage.buckets.create",
-                         name, location=location)
+        return self.dispatch(self, "provider.storage.buckets.create",
+                             name, location=location)
+
+    def delete(self, bucket_id):
+        """
+        Delete an existing bucket.
+
+        :type bucket_id: str
+        :param bucket_id: The ID of the bucket to be deleted.
+        """
+        return self.dispatch(self, "provider.storage.buckets.delete",
+                             bucket_id)
 
 
 class BaseBucketObjectService(
-        BasePageableObjectMixin, BucketObjectService, BaseStorageService):
+        BasePageableObjectMixin, BucketObjectService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseBucketObjectService, self).__init__(provider)
-        self._service_event_pattern += ".bucket_objects"
+        self._service_event_pattern += ".storage.bucket_objects"
         self._bucket = None
 
+    # Default bucket needs to be set in order for the service to be iterable
     def set_bucket(self, bucket):
         bucket = bucket if isinstance(bucket, BaseBucket) \
                  else self.provider.storage.buckets.get(bucket)
@@ -280,31 +283,30 @@ class BaseComputeService(ComputeService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseComputeService, self).__init__(provider)
-        self._service_event_pattern += ".compute"
 
 
 class BaseImageService(
-        BasePageableObjectMixin, ImageService, BaseComputeService):
+        BasePageableObjectMixin, ImageService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseImageService, self).__init__(provider)
-        self._service_event_pattern += ".images"
+        self._service_event_pattern += ".compute.images"
 
 
 class BaseInstanceService(
-        BasePageableObjectMixin, InstanceService, BaseComputeService):
+        BasePageableObjectMixin, InstanceService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseInstanceService, self).__init__(provider)
-        self._service_event_pattern += ".instances"
+        self._service_event_pattern += ".compute.instances"
 
 
 class BaseVMTypeService(
-        BasePageableObjectMixin, VMTypeService, BaseComputeService):
+        BasePageableObjectMixin, VMTypeService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseVMTypeService, self).__init__(provider)
-        self._service_event_pattern += ".vm_types"
+        self._service_event_pattern += ".compute.vm_types"
 
     def get(self, vm_type_id):
         vm_type = (t for t in self if t.id == vm_type_id)
@@ -318,11 +320,11 @@ class BaseVMTypeService(
 
 
 class BaseRegionService(
-        BasePageableObjectMixin, RegionService, BaseComputeService):
+        BasePageableObjectMixin, RegionService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseRegionService, self).__init__(provider)
-        self._service_event_pattern += ".regions"
+        self._service_event_pattern += ".compute.regions"
 
     def find(self, **kwargs):
         obj_list = self
@@ -335,15 +337,14 @@ class BaseNetworkingService(NetworkingService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseNetworkingService, self).__init__(provider)
-        self._service_event_pattern += ".networking"
 
 
 class BaseNetworkService(
-        BasePageableObjectMixin, NetworkService, BaseNetworkingService):
+        BasePageableObjectMixin, NetworkService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseNetworkService, self).__init__(provider)
-        self._service_event_pattern += ".networks"
+        self._service_event_pattern += ".networking.networks"
 
     @property
     def subnets(self):
@@ -370,11 +371,11 @@ class BaseNetworkService(
 
 
 class BaseSubnetService(
-        BasePageableObjectMixin, SubnetService, BaseNetworkingService):
+        BasePageableObjectMixin, SubnetService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseSubnetService, self).__init__(provider)
-        self._service_event_pattern += ".subnets"
+        self._service_event_pattern += ".networking.subnets"
 
     def find(self, **kwargs):
         obj_list = self
@@ -396,11 +397,11 @@ class BaseSubnetService(
 
 
 class BaseRouterService(
-        BasePageableObjectMixin, RouterService, BaseNetworkingService):
+        BasePageableObjectMixin, RouterService, BaseCloudService):
 
     def __init__(self, provider):
         super(BaseRouterService, self).__init__(provider)
-        self._service_event_pattern += ".routers"
+        self._service_event_pattern += ".networking.routers"
 
     def delete(self, router):
         if isinstance(router, Router):

cloudbridge/cloud/interfaces/events.py

@@ -93,7 +93,7 @@ class EventDispatcher(object):
         pass
 
     @abstractmethod
-    def emit(self, sender, event, *args, **kwargs):
+    def dispatch(self, sender, event, *args, **kwargs):
         """
         Raises an event, which will trigger all handlers that are registered
         for this event. The return value of the emit function is the return

cloudbridge/cloud/providers/aws/resources.py

@@ -888,9 +888,6 @@ class AWSBucket(BaseBucket):
     def objects(self):
         return self._object_container
 
-    def delete(self, delete_contents=False):
-        self._bucket.delete()
-
 
 class AWSBucketContainer(BaseBucketContainer):
 

cloudbridge/cloud/providers/aws/services.py

@@ -10,7 +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.events import implement
 from cloudbridge.cloud.base.resources import ClientPagedResultList
 from cloudbridge.cloud.base.services import BaseBucketObjectService
 from cloudbridge.cloud.base.services import BaseBucketService
@@ -309,8 +309,8 @@ class AWSBucketService(BaseBucketService):
                                  cb_resource=AWSBucket,
                                  boto_collection_name='buckets')
 
-    @execute(event_pattern="provider.storage.buckets.get",
-             priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    @implement(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
@@ -339,13 +339,13 @@ 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)
+    @implement(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)
+    @implement(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
@@ -379,9 +379,19 @@ class AWSBucketService(BaseBucketService):
                 else:
                     raise
 
+    @implement(event_pattern="provider.storage.buckets.delete",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    def _delete(self, bucket_id):
+        bucket = self._get(bucket_id)
+        if bucket:
+            bucket._bucket.delete()
+
 
 class AWSBucketObjectService(BaseBucketObjectService):
 
+    def __init__(self, provider):
+        super(AWSBucketObjectService, self).__init__(provider)
+
     def get(self, bucket, object_id):
         try:
             # pylint:disable=protected-access
@@ -404,7 +414,8 @@ class AWSBucketObjectService(BaseBucketObjectService):
                                      limit=limit, marker=marker)
 
     def find(self, bucket, **kwargs):
-        obj_list = bucket._bucket.objects.all()
+        obj_list = [AWSBucketObject(self.provider, o)
+                    for o in bucket._bucket.objects.all()]
         filters = ['name']
         matches = cb_helpers.generic_find(filters, kwargs, obj_list)
         return ClientPagedResultList(self.provider, list(matches),

cloudbridge/cloud/providers/azure/resources.py

@@ -358,12 +358,6 @@ class AzureBucket(BaseBucket):
         """
         return self._bucket.name
 
-    def delete(self, delete_contents=True):
-        """
-        Delete this bucket.
-        """
-        self._provider.azure_client.delete_container(self.name)
-
     def exists(self, name):
         """
         Determine if an object with given name exists in this bucket.

cloudbridge/cloud/providers/azure/services.py

@@ -8,6 +8,7 @@ from azure.mgmt.compute.models import DiskCreateOption
 from msrestazure.azure_exceptions import CloudError
 
 import cloudbridge.cloud.base.helpers as cb_helpers
+from cloudbridge.cloud.base.events import implement
 from cloudbridge.cloud.base.resources import ClientPagedResultList
 from cloudbridge.cloud.base.resources import ServerPagedResultList
 from cloudbridge.cloud.base.services import BaseBucketObjectService
@@ -395,6 +396,8 @@ class AzureBucketService(BaseBucketService):
     def __init__(self, provider):
         super(AzureBucketService, self).__init__(provider)
 
+    @implement(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
@@ -407,12 +410,17 @@ class AzureBucketService(BaseBucketService):
             log.exception(error)
             return None
 
+    @implement(event_pattern="provider.storage.buckets.list",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _list(self, limit, marker):
         buckets = [AzureBucket(self.provider, bucket)
-                   for bucket in self.provider.azure_client.list_containers()]
+                   for bucket
+                   in self.provider.azure_client.list_containers()[0]]
         return ClientPagedResultList(self.provider, buckets,
                                      limit=limit, marker=marker)
 
+    @implement(event_pattern="provider.storage.buckets.create",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _create(self, name, location=None):
         """
         Create a new bucket.
@@ -421,6 +429,14 @@ class AzureBucketService(BaseBucketService):
         bucket = self.provider.azure_client.create_container(name)
         return AzureBucket(self.provider, bucket)
 
+    @implement(event_pattern="provider.storage.buckets.delete",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    def _delete(self, bucket_id):
+        """
+        Delete this bucket.
+        """
+        self.provider.azure_client.delete_container(bucket_id)
+
 
 class AzureBucketObjectService(BaseBucketObjectService):
     def __init__(self, provider):
@@ -463,7 +479,7 @@ class AzureBucketObjectService(BaseBucketObjectService):
     def create(self, bucket, name):
         self.provider.azure_client.create_blob_from_text(
             bucket.name, name, '')
-        return self.get(name)
+        return self.get(bucket, name)
 
 
 class AzureComputeService(BaseComputeService):

cloudbridge/cloud/providers/gce/resources.py

@@ -16,7 +16,6 @@ from collections import namedtuple
 import googleapiclient
 
 import cloudbridge as cb
-import cloudbridge.cloud.base.helpers as cb_helpers
 from cloudbridge.cloud.base.resources import BaseAttachmentInfo
 from cloudbridge.cloud.base.resources import BaseBucket
 from cloudbridge.cloud.base.resources import BaseBucketContainer
@@ -2150,8 +2149,11 @@ class GCSObject(BaseBucketObject):
             data = data.encode()
         media_body = googleapiclient.http.MediaIoBaseUpload(
                 io.BytesIO(data), mimetype='plain/text')
-        response = self._bucket.create_object_with_media_body(self.name,
-                                                              media_body)
+        response = (self._provider
+                        .storage.bucket_objects
+                        ._create_object_with_media_body(self._bucket,
+                                                        self.name,
+                                                        media_body))
         if response:
             self._obj = response
 
@@ -2162,8 +2164,11 @@ class GCSObject(BaseBucketObject):
         with open(path, 'rb') as f:
             media_body = googleapiclient.http.MediaIoBaseUpload(
                     f, 'application/octet-stream')
-            response = self._bucket.create_object_with_media_body(self.name,
-                                                                  media_body)
+            response = (self._provider
+                        .storage.bucket_objects
+                        ._create_object_with_media_body(self._bucket,
+                                                        self.name,
+                                                        media_body))
             if response:
                 self._obj = response
 
@@ -2201,47 +2206,6 @@ class GCSBucketContainer(BaseBucketContainer):
     def __init__(self, provider, bucket):
         super(GCSBucketContainer, self).__init__(provider, bucket)
 
-    def get(self, name):
-        """
-        Retrieve a given object from this bucket.
-        """
-        obj = self._provider.get_resource('objects', name,
-                                          bucket=self.bucket.name)
-        return GCSObject(self._provider, self.bucket, obj) if obj else None
-
-    def list(self, limit=None, marker=None, prefix=None):
-        """
-        List all objects within this bucket.
-        """
-        max_result = limit if limit is not None and limit < 500 else 500
-        response = (self._provider
-                        .gcs_storage
-                        .objects()
-                        .list(bucket=self.bucket.name,
-                              prefix=prefix if prefix else '',
-                              maxResults=max_result,
-                              pageToken=marker)
-                        .execute())
-        objects = []
-        for obj in response.get('items', []):
-            objects.append(GCSObject(self._provider, self.bucket, obj))
-        if len(objects) > max_result:
-            cb.log.warning('Expected at most %d results; got %d',
-                           max_result, len(objects))
-        return ServerPagedResultList('nextPageToken' in response,
-                                     response.get('nextPageToken'),
-                                     False, data=objects)
-
-    def find(self, **kwargs):
-        obj_list = self.list()
-        filters = ['name']
-        matches = cb_helpers.generic_find(filters, kwargs, obj_list)
-        return ClientPagedResultList(self._provider, list(matches),
-                                     limit=None, marker=None)
-
-    def create(self, name):
-        return self.bucket.create_object(name)
-
 
 class GCSBucket(BaseBucket):
 
@@ -2265,40 +2229,6 @@ class GCSBucket(BaseBucket):
     def objects(self):
         return self._object_container
 
-    def delete(self, delete_contents=False):
-        """
-        Delete this bucket.
-        """
-        (self._provider
-             .gcs_storage
-             .buckets()
-             .delete(bucket=self.name)
-             .execute())
-        # GCS has a rate limit of 1 operation per 2 seconds for bucket
-        # creation/deletion: https://cloud.google.com/storage/quotas.  Throttle
-        # here to avoid future failures.
-        time.sleep(2)
-
-    def create_object(self, name):
-        """
-        Create an empty plain text object.
-        """
-        response = self.create_object_with_media_body(
-            name,
-            googleapiclient.http.MediaIoBaseUpload(
-                    io.BytesIO(b''), mimetype='plain/text'))
-        return GCSObject(self._provider, self, response) if response else None
-
-    def create_object_with_media_body(self, name, media_body):
-        response = (self._provider
-                        .gcs_storage
-                        .objects()
-                        .insert(bucket=self.name,
-                                body={'name': name},
-                                media_body=media_body)
-                        .execute())
-        return response
-
 
 class GCELaunchConfig(BaseLaunchConfig):
 

cloudbridge/cloud/providers/gce/services.py

@@ -1,3 +1,4 @@
+import io
 import ipaddress
 import json
 import logging
@@ -8,8 +9,10 @@ import googleapiclient
 
 import cloudbridge as cb
 from cloudbridge.cloud.base import helpers as cb_helpers
+from cloudbridge.cloud.base.events import implement
 from cloudbridge.cloud.base.resources import ClientPagedResultList
 from cloudbridge.cloud.base.resources import ServerPagedResultList
+from cloudbridge.cloud.base.services import BaseBucketObjectService
 from cloudbridge.cloud.base.services import BaseBucketService
 from cloudbridge.cloud.base.services import BaseComputeService
 from cloudbridge.cloud.base.services import BaseImageService
@@ -46,6 +49,7 @@ from .resources import GCEVMFirewall
 from .resources import GCEVMType
 from .resources import GCEVolume
 from .resources import GCSBucket
+from .resources import GCSObject
 
 log = logging.getLogger(__name__)
 
@@ -919,6 +923,7 @@ class GCPStorageService(BaseStorageService):
         self._volume_svc = GCEVolumeService(self.provider)
         self._snapshot_svc = GCESnapshotService(self.provider)
         self._bucket_svc = GCSBucketService(self.provider)
+        self._bucket_obj_svc = GCSBucketObjectService(self.provider)
 
     @property
     def volumes(self):
@@ -932,6 +937,10 @@ class GCPStorageService(BaseStorageService):
     def buckets(self):
         return self._bucket_svc
 
+    @property
+    def bucket_objects(self):
+        return self._bucket_obj_svc
+
 
 class GCEVolumeService(BaseVolumeService):
 
@@ -1130,7 +1139,9 @@ class GCSBucketService(BaseBucketService):
     def __init__(self, provider):
         super(GCSBucketService, self).__init__(provider)
 
-    def get(self, bucket_id):
+    @implement(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
         does not exist or if the user does not have permission to access the
@@ -1139,7 +1150,9 @@ class GCSBucketService(BaseBucketService):
         bucket = self.provider.get_resource('buckets', bucket_id)
         return GCSBucket(self.provider, bucket) if bucket else None
 
-    def find(self, name, limit=None, marker=None):
+    @implement(event_pattern="provider.storage.buckets.find",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    def _find(self, name, limit=None, marker=None):
         """
         Searches in bucket names for a substring.
         """
@@ -1147,7 +1160,9 @@ class GCSBucketService(BaseBucketService):
         return ClientPagedResultList(self.provider, buckets, limit=limit,
                                      marker=marker)
 
-    def list(self, limit=None, marker=None):
+    @implement(event_pattern="provider.storage.buckets.list",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    def _list(self, limit=None, marker=None):
         """
         List all containers.
         """
@@ -1169,7 +1184,9 @@ class GCSBucketService(BaseBucketService):
                                      response.get('nextPageToken'),
                                      False, data=buckets)
 
-    def create(self, name, location=None):
+    @implement(event_pattern="provider.storage.buckets.create",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    def _create(self, name, location=None):
         GCSBucket.assert_valid_resource_name(name)
         body = {'name': name}
         if location:
@@ -1193,3 +1210,97 @@ class GCSBucketService(BaseBucketService):
                     'Bucket already exists with name {0}'.format(name))
             else:
                 raise
+
+    @implement(event_pattern="provider.storage.buckets.delete",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    def _delete(self, bucket_id):
+        """
+        Delete this bucket.
+        """
+        # GCE uses name rather than URL to identify resources
+        name = (self._provider._storage_resources
+                    .parse_url(bucket_id)
+                    .parameters.get("bucket"))
+        (self._provider
+             .gcs_storage
+             .buckets()
+             .delete(bucket=name)
+             .execute())
+        # GCS has a rate limit of 1 operation per 2 seconds for bucket
+        # creation/deletion: https://cloud.google.com/storage/quotas. Throttle
+        # here to avoid future failures.
+        time.sleep(2)
+
+
+class GCSBucketObjectService(BaseBucketObjectService):
+
+    def __init__(self, provider):
+        super(GCSBucketObjectService, self).__init__(provider)
+
+    def get(self, bucket, name):
+        """
+        Retrieve a given object from this bucket.
+        """
+        obj = self.provider.get_resource('objects', name,
+                                         bucket=bucket.name)
+        return GCSObject(self.provider, bucket, obj) if obj else None
+
+    def list(self, bucket, limit=None, marker=None, prefix=None):
+        """
+        List all objects within this bucket.
+        """
+        max_result = limit if limit is not None and limit < 500 else 500
+        response = (self.provider
+                        .gcs_storage
+                        .objects()
+                        .list(bucket=bucket.name,
+                              prefix=prefix if prefix else '',
+                              maxResults=max_result,
+                              pageToken=marker)
+                        .execute())
+        objects = []
+        for obj in response.get('items', []):
+            objects.append(GCSObject(self.provider, bucket, obj))
+        if len(objects) > max_result:
+            cb.log.warning('Expected at most %d results; got %d',
+                           max_result, len(objects))
+        return ServerPagedResultList('nextPageToken' in response,
+                                     response.get('nextPageToken'),
+                                     False, data=objects)
+
+    def find(self, bucket, **kwargs):
+        master_list = []
+        obj_list = self.list(bucket=bucket, limit=500)
+        if obj_list.supports_server_paging:
+            master_list.extend(obj_list)
+            while obj_list.is_truncated:
+                obj_list = self.list(marker=obj_list.marker,
+                                     **kwargs)
+                master_list.extend(obj_list)
+        else:
+            master_list.extend(obj_list.data)
+
+        filters = ['name']
+        matches = cb_helpers.generic_find(filters, kwargs, obj_list)
+        return ClientPagedResultList(self._provider, list(matches),
+                                     limit=None, marker=None)
+
+    def _create_object_with_media_body(self, bucket, name, media_body):
+        response = (self.provider
+                    .gcs_storage
+                    .objects()
+                    .insert(bucket=bucket.name,
+                            body={'name': name},
+                            media_body=media_body)
+                    .execute())
+        return response
+
+    def create(self, bucket, name):
+        response = self._create_object_with_media_body(
+                            bucket,
+                            name,
+                            googleapiclient.http.MediaIoBaseUpload(
+                                io.BytesIO(b''), mimetype='plain/text'))
+        return GCSObject(self._provider,
+                         bucket,
+                         response) if response else None

cloudbridge/cloud/providers/openstack/resources.py

@@ -1517,9 +1517,6 @@ class OpenStackBucket(BaseBucket):
     def objects(self):
         return self._object_container
 
-    def delete(self, delete_contents=False):
-        self._provider.swift.delete_container(self.name)
-
 
 class OpenStackBucketContainer(BaseBucketContainer):
 

cloudbridge/cloud/providers/openstack/services.py

@@ -15,6 +15,7 @@ from openstack.exceptions import ResourceNotFound
 from swiftclient import ClientException as SwiftClientException
 
 import cloudbridge.cloud.base.helpers as cb_helpers
+from cloudbridge.cloud.base.events import implement
 from cloudbridge.cloud.base.resources import BaseLaunchConfig
 from cloudbridge.cloud.base.resources import ClientPagedResultList
 from cloudbridge.cloud.base.services import BaseBucketObjectService
@@ -410,6 +411,8 @@ class OpenStackBucketService(BaseBucketService):
     def __init__(self, provider):
         super(OpenStackBucketService, self).__init__(provider)
 
+    @implement(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
@@ -425,6 +428,8 @@ class OpenStackBucketService(BaseBucketService):
             log.debug("Bucket %s was not found.", bucket_id)
             return None
 
+    @implement(event_pattern="provider.storage.buckets.find",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _find(self, **kwargs):
         name = kwargs.pop('name', None)
 
@@ -438,6 +443,8 @@ class OpenStackBucketService(BaseBucketService):
                       if name in c.get("name")]
         return oshelpers.to_server_paged_list(self.provider, cb_buckets)
 
+    @implement(event_pattern="provider.storage.buckets.list",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _list(self, limit, marker):
         _, container_list = self.provider.swift.get_account(
             limit=oshelpers.os_result_limit(self.provider, limit),
@@ -446,6 +453,8 @@ class OpenStackBucketService(BaseBucketService):
                       for c in container_list]
         return oshelpers.to_server_paged_list(self.provider, cb_buckets, limit)
 
+    @implement(event_pattern="provider.storage.buckets.create",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
     def _create(self, name, location):
         OpenStackBucket.assert_valid_resource_name(name)
         location = location or self.provider.region_name
@@ -457,6 +466,11 @@ class OpenStackBucketService(BaseBucketService):
             self.provider.swift.put_container(name)
             return self.get(name)
 
+    @implement(event_pattern="provider.storage.buckets.delete",
+               priority=BaseBucketService.STANDARD_EVENT_PRIORITY)
+    def _delete(self, bucket_id):
+        self.provider.swift.delete_container(bucket_id)
+
 
 class OpenStackBucketObjectService(BaseBucketObjectService):
 
@@ -508,7 +522,7 @@ class OpenStackBucketObjectService(BaseBucketObjectService):
 
     def create(self, bucket, object_name):
         self.provider.swift.put_object(bucket.name, object_name, None)
-        return self.get(object_name)
+        return self.get(bucket, object_name)
 
 
 class OpenStackComputeService(BaseComputeService):

test/test_block_store_service.py

@@ -21,13 +21,6 @@ class CloudBlockStoreServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['storage.volumes', 'storage.volumes'])
     def test_storage_services_event_pattern(self):
-        self.assertEqual(self.provider.storage._service_event_pattern,
-                         "provider.storage",
-                         "Event pattern for {} service should be '{}', "
-                         "but found '{}'.".format("storage",
-                                                  "provider.storage",
-                                                  self.provider.storage.
-                                                  _service_event_pattern))
         self.assertEqual(
             self.provider.storage.volumes._service_event_pattern,
             "provider.storage.volumes",

test/test_compute_service.py

@@ -22,13 +22,6 @@ class CloudComputeServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['compute.instances'])
     def test_storage_services_event_pattern(self):
-        self.assertEqual(self.provider.compute._service_event_pattern,
-                         "provider.compute",
-                         "Event pattern for {} service should be '{}', "
-                         "but found '{}'.".format("compute",
-                                                  "provider.compute",
-                                                  self.provider.compute.
-                                                  _service_event_pattern))
         self.assertEqual(
             self.provider.compute.instances._service_event_pattern,
             "provider.compute.instances",

test/test_event_system.py

@@ -9,7 +9,7 @@ class EventSystemTestCase(unittest.TestCase):
 
     def test_emit_event_no_handlers(self):
         dispatcher = SimpleEventDispatcher()
-        result = dispatcher.emit(self, "event.hello.world")
+        result = dispatcher.dispatch(self, "event.hello.world")
         self.assertIsNone(result, "Result should be none as there are no"
                           "registered handlers")
 
@@ -30,8 +30,8 @@ class EventSystemTestCase(unittest.TestCase):
         handler = dispatcher.observe(event_pattern=EVENT_NAME, priority=1000,
                                      callback=my_callback)
         self.assertIsInstance(handler, EventHandler)
-        result = dispatcher.emit(self, EVENT_NAME, 'first_pos_arg',
-                                 a_keyword_arg='another_thing')
+        result = dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                                     a_keyword_arg='another_thing')
         self.assertEqual(
             callback_tracker[0], "obs", "callback should have been invoked"
             "once and contain value `obs` but tracker value is {0}".format(
@@ -57,8 +57,8 @@ class EventSystemTestCase(unittest.TestCase):
         handler = dispatcher.intercept(event_pattern=EVENT_NAME, priority=1000,
                                        callback=my_callback)
         self.assertIsInstance(handler, EventHandler)
-        result = dispatcher.emit(self, EVENT_NAME, 'first_pos_arg',
-                                 a_keyword_arg='another_thing')
+        result = dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                                     a_keyword_arg='another_thing')
         self.assertEqual(
             callback_tracker[0], "intcpt", "callback should have been invoked"
             "once and contain value `intcpt` but tracker value is {0}".format(
@@ -92,8 +92,8 @@ class EventSystemTestCase(unittest.TestCase):
         dispatcher = SimpleEventDispatcher()
         dispatcher.observe(EVENT_NAME, 1000, my_callback_obs)
         dispatcher.intercept(EVENT_NAME, 1001, my_callback_intcpt)
-        result = dispatcher.emit(self, EVENT_NAME, 'first_pos_arg',
-                                 a_keyword_arg='another_thing')
+        result = dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                                     a_keyword_arg='another_thing')
         self.assertEqual(
             callback_tracker[0], "obs_intcpt_", "callback was not invoked in "
             "expected order. Should have been obs_intcpt_ but is {0}".format(
@@ -136,8 +136,8 @@ class EventSystemTestCase(unittest.TestCase):
         # register priorities out of order to test that too
         dispatcher.observe(EVENT_NAME, 1001, my_callback_obs)
         dispatcher.intercept(EVENT_NAME, 1000, my_callback_intcpt)
-        result = dispatcher.emit(self, EVENT_NAME, 'first_pos_arg',
-                                 a_keyword_arg='another_thing')
+        result = dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                                     a_keyword_arg='another_thing')
         self.assertEqual(
             callback_tracker[0], "intcpt_obs_", "callback was not invoked in "
             "expected order. Should have been intcpt_obs_ but is {0}".format(
@@ -170,7 +170,7 @@ class EventSystemTestCase(unittest.TestCase):
         dispatcher = SimpleEventDispatcher()
         dispatcher.intercept(EVENT_NAME, 2000, my_callback_intcpt1)
         dispatcher.intercept(EVENT_NAME, 2020, my_callback_intcpt2)
-        result = dispatcher.emit(self, EVENT_NAME)
+        result = dispatcher.dispatch(self, EVENT_NAME)
         self.assertEqual(
             callback_tracker[0], "intcpt1_intcpt2_", "callback was not invoked"
             " in expected order. Should have been intcpt1_intcpt2_ but is"
@@ -187,7 +187,7 @@ class EventSystemTestCase(unittest.TestCase):
         dispatcher.intercept("event.hello.world", 1000, my_callback)
         dispatcher.intercept("event.hello.world", 1000, my_callback)
         with self.assertRaises(HandlerException):
-            dispatcher.emit(self, "event.hello.world")
+            dispatcher.dispatch(self, "event.hello.world")
 
     def test_subscribe_event_duplicate_wildcard_priority(self):
 
@@ -198,7 +198,7 @@ class EventSystemTestCase(unittest.TestCase):
         dispatcher.intercept("event.hello.world", 1000, my_callback)
         dispatcher.intercept("event.hello.*", 1000, my_callback)
         with self.assertRaises(HandlerException):
-            dispatcher.emit(self, "event.hello.world")
+            dispatcher.dispatch(self, "event.hello.world")
 
     def test_subscribe_event_duplicate_wildcard_priority_allowed(self):
         # duplicate priorities for different wildcard namespaces allowed
@@ -209,7 +209,7 @@ class EventSystemTestCase(unittest.TestCase):
         dispatcher.intercept("event.hello.world", 1000, my_callback)
         dispatcher.intercept("someevent.hello.*", 1000, my_callback)
         # emit should work fine in this case with no exceptions
-        dispatcher.emit(self, "event.hello.world")
+        dispatcher.dispatch(self, "event.hello.world")
 
     def test_subscribe_multiple_events(self):
         EVENT_NAME = "event.hello.world"
@@ -241,7 +241,7 @@ class EventSystemTestCase(unittest.TestCase):
         # register to a different event with the same priority
         dispatcher.observe("event.hello.anotherworld", 2000, my_callback2)
         dispatcher.intercept("event.hello.anotherworld", 2020, my_callback3)
-        result = dispatcher.emit(self, EVENT_NAME)
+        result = dispatcher.dispatch(self, EVENT_NAME)
         self.assertEqual(
             callback_tracker[0], "event1_", "only `event.hello.world` handlers"
             " should have been  triggered but received {0}".format(
@@ -249,7 +249,7 @@ class EventSystemTestCase(unittest.TestCase):
         self.assertEqual(result, None, "Result should be `helloworld` "
                          "as this is the expected return value from the chain")
 
-        result = dispatcher.emit(self, "event.hello.anotherworld")
+        result = dispatcher.dispatch(self, "event.hello.anotherworld")
         self.assertEqual(
             callback_tracker[0], "event1_event2_event3_", "only handlers for"
             "  event `event.hello.anotherworld` should have been  triggered"
@@ -288,7 +288,7 @@ class EventSystemTestCase(unittest.TestCase):
         dispatcher.intercept("event.*.world", 2020, my_callback4)
         dispatcher.intercept("someevent.hello.there", 2030, my_callback3)
         # emit a series of events
-        result = dispatcher.emit(self, "event.hello.there")
+        result = dispatcher.dispatch(self, "event.hello.there")
 
         self.assertEqual(
             callback_tracker[0], "event1_event2_event3_event4_",
@@ -296,7 +296,7 @@ class EventSystemTestCase(unittest.TestCase):
                 callback_tracker[0]))
         self.assertEqual(result, "hellosomeotherworld")
 
-        result = dispatcher.emit(self, "event.test.hello.world")
+        result = dispatcher.dispatch(self, "event.test.hello.world")
         self.assertEqual(
             callback_tracker[0], "event1_event2_event3_event4_event1_event4_",
             "Event handlers executed in unexpected order {0}".format(
@@ -322,9 +322,9 @@ class EventSystemTestCase(unittest.TestCase):
 
         dispatcher = SimpleEventDispatcher()
         dispatcher.intercept("event.hello.world", 1000, my_callback1)
-        dispatcher.emit(self, "event.hello.world")
+        dispatcher.dispatch(self, "event.hello.world")
         dispatcher.intercept("event.hello.*", 1001, my_callback2)
-        result = dispatcher.emit(self, "event.hello.world")
+        result = dispatcher.dispatch(self, "event.hello.world")
 
         self.assertEqual(
             callback_tracker[0], "event1_event1_event2_",
@@ -351,7 +351,7 @@ class EventSystemTestCase(unittest.TestCase):
 
         dispatcher = SimpleEventDispatcher()
         hndlr1 = dispatcher.intercept(EVENT_NAME, 1000, my_callback1)
-        dispatcher.emit(self, EVENT_NAME)
+        dispatcher.dispatch(self, EVENT_NAME)
         hndlr2 = dispatcher.intercept("event.hello.*", 1001, my_callback2)
         # Both handlers should be registered
         self.assertListEqual(
@@ -366,7 +366,7 @@ class EventSystemTestCase(unittest.TestCase):
             [handler.callback for handler in
              dispatcher.get_handlers_for_event(EVENT_NAME)])
 
-        result = dispatcher.emit(self, EVENT_NAME)
+        result = dispatcher.dispatch(self, EVENT_NAME)
 
         self.assertEqual(
             callback_tracker[0], "event1_event2_",
@@ -375,5 +375,5 @@ class EventSystemTestCase(unittest.TestCase):
         self.assertEqual(result, "some")
 
         hndlr2.unsubscribe()
-        result = dispatcher.emit(self, "event.hello.world")
+        result = dispatcher.dispatch(self, "event.hello.world")
         self.assertEqual(result, None)

test/test_middleware_system.py

@@ -62,8 +62,8 @@ class MiddlewareSystemTestCase(unittest.TestCase):
         manager = SimpleMiddlewareManager(dispatcher)
         middleware = DummyMiddleWare()
         manager.add(middleware)
-        dispatcher.emit(self, EVENT_NAME, 'first_pos_arg',
-                        a_keyword_arg='something')
+        dispatcher.dispatch(self, EVENT_NAME, 'first_pos_arg',
+                            a_keyword_arg='something')
 
         self.assertEqual(middleware.invocation_order, "intercept_observe")
         self.assertListEqual(
@@ -106,7 +106,7 @@ class MiddlewareSystemTestCase(unittest.TestCase):
         middleware2 = DummyMiddleWare2()
         manager.add(middleware1)
         manager.add(middleware2)
-        dispatcher.emit(self, EVENT_NAME)
+        dispatcher.dispatch(self, EVENT_NAME)
 
         # Callbacks in both middleware classes should be registered
         self.assertListEqual(
@@ -157,7 +157,7 @@ class MiddlewareSystemTestCase(unittest.TestCase):
         manager = SimpleMiddlewareManager(dispatcher)
         some_obj = SomeDummyClass()
         middleware = manager.add(some_obj)
-        dispatcher.emit(self, EVENT_NAME)
+        dispatcher.dispatch(self, EVENT_NAME)
 
         # Middleware should be discovered even if class containing interceptors
         # doesn't inherit from Middleware

test/test_network_service.py

@@ -20,13 +20,6 @@ class CloudNetworkServiceTestCase(ProviderTestBase):
                               'networking.networks',
                               'networking.routers'])
     def test_storage_services_event_pattern(self):
-        self.assertEqual(self.provider.networking._service_event_pattern,
-                         "provider.networking",
-                         "Event pattern for {} service should be '{}', "
-                         "but found '{}'.".format("networking",
-                                                  "provider.networking",
-                                                  self.provider.networking.
-                                                  _service_event_pattern))
         self.assertEqual(
             self.provider.networking.networks._service_event_pattern,
             "provider.networking.networks",

test/test_object_store_service.py

@@ -23,13 +23,6 @@ class CloudObjectStoreServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['storage.bucket_objects', 'storage.buckets'])
     def test_storage_services_event_pattern(self):
-        self.assertEqual(self.provider.storage._service_event_pattern,
-                         "provider.storage",
-                         "Event pattern for {} service should be '{}', "
-                         "but found '{}'.".format("storage",
-                                                  "provider.storage",
-                                                  self.provider.storage.
-                                                  _service_event_pattern))
         self.assertEqual(
             self.provider.storage.buckets._service_event_pattern,
             "provider.storage.buckets",

test/test_security_service.py

@@ -17,13 +17,6 @@ class CloudSecurityServiceTestCase(ProviderTestBase):
 
     @helpers.skipIfNoService(['security.vm_firewalls'])
     def test_storage_services_event_pattern(self):
-        self.assertEqual(self.provider.security._service_event_pattern,
-                         "provider.security",
-                         "Event pattern for {} service should be '{}', "
-                         "but found '{}'.".format("security",
-                                                  "provider.security",
-                                                  self.provider.security.
-                                                  _service_event_pattern))
         self.assertEqual(
             self.provider.security.key_pairs.
             _service_event_pattern,