Update Keystone code from official Github repository with branch Master on 09/01/2015.

Change-Id: I0ff6099e6e2580f87f502002a998bbfe12673498

1 files changed, 4 insertions, 85 deletions

diff --git a/keystone-moon/keystone/common/dependency.py b/keystone-moon/keystone/common/dependency.py
index 14a68f19..e19f705f 100644
--- a/keystone-moon/keystone/common/dependency.py
+++ b/keystone-moon/keystone/common/dependency.py
@@ -15,9 +15,9 @@
 """This module provides support for dependency injection.
 
 Providers are registered via the ``@provider()`` decorator, and dependencies on
-them are registered with ``@requires()`` or ``@optional()``. Providers are
-available to their consumers via an attribute. See the documentation for the
-individual functions for more detail.
+them are registered with ``@requires()``. Providers are available to their
+consumers via an attribute. See the documentation for the individual functions
+for more detail.
 
 See also:
 
@@ -27,16 +27,12 @@ See also:
 
 import traceback
 
-import six
-
 from keystone.i18n import _
-from keystone import notifications
 
 
 _REGISTRY = {}
 
 _future_dependencies = {}
-_future_optionals = {}
 _factories = {}
 
 
@@ -94,44 +90,10 @@ def provider(name):
     """
     def wrapper(cls):
         def wrapped(init):
-            def register_event_callbacks(self):
-                # NOTE(morganfainberg): A provider who has an implicit
-                # dependency on other providers may utilize the event callback
-                # mechanism to react to any changes in those providers. This is
-                # performed at the .provider() mechanism so that we can ensure
-                # that the callback is only ever called once and guaranteed
-                # to be on the properly configured and instantiated backend.
-                if not hasattr(self, 'event_callbacks'):
-                    return
-
-                if not isinstance(self.event_callbacks, dict):
-                    msg = _('event_callbacks must be a dict')
-                    raise ValueError(msg)
-
-                for event in self.event_callbacks:
-                    if not isinstance(self.event_callbacks[event], dict):
-                        msg = _('event_callbacks[%s] must be a dict') % event
-                        raise ValueError(msg)
-                    for resource_type in self.event_callbacks[event]:
-                        # Make sure we register the provider for each event it
-                        # cares to call back.
-                        callbacks = self.event_callbacks[event][resource_type]
-                        if not callbacks:
-                            continue
-                        if not hasattr(callbacks, '__iter__'):
-                            # ensure the callback information is a list
-                            # allowing multiple callbacks to exist
-                            callbacks = [callbacks]
-                        notifications.register_event_callback(event,
-                                                              resource_type,
-                                                              callbacks)
-
             def __wrapped_init__(self, *args, **kwargs):
                 """Initialize the wrapped object and add it to the registry."""
                 init(self, *args, **kwargs)
                 _set_provider(name, self)
-                register_event_callbacks(self)
-
                 resolve_future_dependencies(__provider_name=name)
 
             return __wrapped_init__
@@ -157,7 +119,6 @@ def _process_dependencies(obj):
             setattr(obj, dependency, get_provider(dependency))
 
     process(obj, '_dependencies', _future_dependencies)
-    process(obj, '_optionals', _future_optionals)
 
 
 def requires(*dependencies):
@@ -210,34 +171,6 @@ def requires(*dependencies):
     return wrapped
 
 
-def optional(*dependencies):
-    """Similar to ``@requires()``, except that the dependencies are optional.
-
-    If no provider is available, the attributes will be set to ``None``.
-
-    """
-    def wrapper(self, *args, **kwargs):
-        """Inject each dependency from the registry."""
-        self.__wrapped_init__(*args, **kwargs)
-        _process_dependencies(self)
-
-    def wrapped(cls):
-        """Note the optional dependencies on the object for later injection.
-
-        The dependencies of the parent class are combined with that of the
-        child class to create a new set of dependencies.
-
-        """
-        existing_optionals = getattr(cls, '_optionals', set())
-        cls._optionals = existing_optionals.union(dependencies)
-        if not hasattr(cls, '__wrapped_init__'):
-            cls.__wrapped_init__ = cls.__init__
-            cls.__init__ = wrapper
-        return cls
-
-    return wrapped
-
-
 def resolve_future_dependencies(__provider_name=None):
     """Forces injection of all dependencies.
 
@@ -259,29 +192,16 @@ def resolve_future_dependencies(__provider_name=None):
         # A provider was registered, so take care of any objects depending on
         # it.
         targets = _future_dependencies.pop(__provider_name, [])
-        targets.extend(_future_optionals.pop(__provider_name, []))
 
         for target in targets:
             setattr(target, __provider_name, get_provider(__provider_name))
 
         return
 
-    # Resolve optional dependencies, sets the attribute to None if there's no
-    # provider registered.
-    for dependency, targets in six.iteritems(_future_optionals.copy()):
-        provider = get_provider(dependency, optional=GET_OPTIONAL)
-        if provider is None:
-            factory = _factories.get(dependency)
-            if factory:
-                provider = factory()
-                new_providers[dependency] = provider
-        for target in targets:
-            setattr(target, dependency, provider)
-
     # Resolve future dependencies, raises UnresolvableDependencyException if
     # there's no provider registered.
     try:
-        for dependency, targets in six.iteritems(_future_dependencies.copy()):
+        for dependency, targets in _future_dependencies.copy().items():
             if dependency not in _REGISTRY:
                 # a Class was registered that could fulfill the dependency, but
                 # it has not yet been initialized.
@@ -308,4 +228,3 @@ def reset():
 
     _REGISTRY.clear()
     _future_dependencies.clear()
-    _future_optionals.clear()