Rename subscribe to observe

cloudbridge/cloud/base/events.py

@@ -30,7 +30,7 @@ class SimpleEventDispatcher(EventDispatcher):
     def mark_initialized(self, event_name):
         self.__initialized[event_name] = True
 
-    def subscribe(self, event_name, priority, callback):
+    def observe(self, event_name, priority, callback):
         handler = EventHandler(HandlerType.SUBSCRIPTION, callback, priority)
         if not self.__events.get(event_name):
             self.__events[event_name] = list()

cloudbridge/cloud/base/services.py

@@ -50,9 +50,9 @@ class BaseCloudService(CloudService):
     def _generate_event_name(self, func_name):
         return ".".join((self._service_event_name, func_name))
 
-    def subscribe(self, func_name, priority, callback):
+    def observe(self, func_name, priority, callback):
         event_name = self._generate_event_name(func_name)
-        self.provider.events.subscribe(event_name, priority, callback)
+        self.provider.events.observe(event_name, priority, callback)
 
     def check_initialized(self, func_name):
         event_name = self._generate_event_name(func_name)
@@ -155,8 +155,8 @@ class BaseBucketService(
         def _get_post_log(callback_result, bucket_id):
             log.debug("Returned bucket object: {}".format(callback_result))
 
-        self.subscribe("get", 2000, _get_pre_log)
-        self.subscribe("get", 3000, _get_post_log)
+        self.observe("get", 2000, _get_pre_log)
+        self.observe("get", 3000, _get_post_log)
         self.mark_initialized("get")
 
     def _init_find(self):
@@ -167,8 +167,8 @@ class BaseBucketService(
         def _find_post_log(callback_result, **kwargs):
             log.debug("Returned bucket objects: {}".format(callback_result))
 
-        self.subscribe("find", 2000, _find_pre_log)
-        self.subscribe("find", 3000, _find_post_log)
+        self.observe("find", 2000, _find_pre_log)
+        self.observe("find", 3000, _find_post_log)
         self.mark_initialized("find")
 
     def _init_list(self):
@@ -184,8 +184,8 @@ class BaseBucketService(
                 log.debug(
                     "Returned bucket objects: {}".format(callback_result))
 
-            self.subscribe("list", 2000, _list_pre_log)
-            self.subscribe("list", 3000, _list_post_log)
+            self.observe("list", 2000, _list_pre_log)
+            self.observe("list", 3000, _list_post_log)
             self.mark_initialized("list")
 
     def _init_create(self):
@@ -199,8 +199,8 @@ class BaseBucketService(
         def _create_post_log(callback_result, name, location):
             log.debug("Returned bucket object: {}".format(callback_result))
 
-        self.subscribe("create", 2000, _create_pre_log)
-        self.subscribe("create", 3000, _create_post_log)
+        self.observe("create", 2000, _create_pre_log)
+        self.observe("create", 3000, _create_post_log)
         self.mark_initialized("create")
 
     def get(self, bucket_id):

cloudbridge/cloud/interfaces/events.py

@@ -6,12 +6,12 @@ class EventDispatcher(object):
     __metaclass__ = ABCMeta
 
     @abstractmethod
-    def subscribe(self, event_name, priority, callback):
+    def observe(self, event_name, priority, callback):
         """
-        Register a callback to be invoked when a given event occurs. Listen
-        will allow you to observe events as they occur, but not modify the
+        Register a callback to be invoked when a given event occurs. `observe`
+        will allow you to listen to events as they occur, but not modify the
         event chain or its parameters. If you need to modify an event, use
-        the intercept method. `listen` is a simplified case of `intercept`,
+        the `intercept` method. `observe` is a simplified case of `intercept`,
         and receives a simpler list of parameters in its callback.
 
         :type event_name: str
@@ -34,8 +34,8 @@ class EventDispatcher(object):
         """
         Register a callback to be invoked when a given event occurs. Intercept
         will allow you to both observe events and modify the event chain and
-        its parameters. If you only want to observe an event, use the listen
-        method. Intercept and listen only differ in what parameters the
+        its parameters. If you only want to observe an event, use the `observe`
+        method. Intercept and `observe` only differ in what parameters the
         callback receives, with intercept receiving additional parameters to
         allow controlling the event chain.