Merge pull request #137 from matburt/openstack_inventory_support

Openstack inventory support

awx/lib/site-packages/README

@@ -26,35 +26,51 @@ django-split-settings==0.1.1 (split_settings/*)
 django-taggit==0.11.2 (taggit/*)
 djangorestframework==2.3.13 (rest_framework/*)
 django-qsstats-magic==0.7.2 (django-qsstats-magic/*, minor fix in qsstats/__init__.py)
+dogpile.cache==0.5.6 (dogpile/* into our dogpile/ along with dogpile.core)
+dogpile.core==0.4.1 (dogpile/* into our dogpile/ along with dogpile.cache)
 gevent-socketio==0.3.6 (socketio/*)
 gevent-websocket==0.9.3 (geventwebsocket/*)
 httplib2==0.9 (httplib2/*)
 importlib==1.0.3 (importlib/*, needed for Python 2.6 support)
 iso8601==0.1.10 (iso8601/*)
 keyring==4.1 (keyring/*, excluded bin/keyring)
+keystoneclient==1.3.0 (keystone/*)
 kombu==3.0.21 (kombu/*)
 Markdown==2.4.1 (markdown/*, excluded bin/markdown_py)
 mock==1.0.1 (mock.py)
+netaddr==0.7.14 (netaddr/*)
+os_client_config==0.6.0 (os_client_config/*)
 ordereddict==1.1 (ordereddict.py, needed for Python 2.6 support)
 os_diskconfig_python_novaclient_ext==0.1.2 (os_diskconfig_python_novaclient_ext/*)
-os_networksv2_python_novaclient_ext==0.21 (os_networksv2_python_novaclient_ext.py)
-os_virtual_interfacesv2_python_novaclient_ext==0.15 (os_virtual_interfacesv2_python_novaclient_ext.py)
+os_networksv2_python_novaclient_ext==0.25 (os_networksv2_python_novaclient_ext.py)
+os_virtual_interfacesv2_python_novaclient_ext==0.19 (os_virtual_interfacesv2_python_novaclient_ext.py)
+oslo.i18n==1.5.0 (oslo_i18n/*  oslo.i18n/* which goes in oslo/i18n... created empty __init__.py at oslo/)
+oslo.config==1.9.3 (oslo_config/* oslo/config/* but not __init__.py from oslo/ used empty one instead)
+oslo.serialization==1.4.0 (oslo_serialization/* oslo/serialization/* but not __init__.py from oslo/ used empty one instead)
+oslo.utils==1.4.0 (oslo_utils/* oslo/utils/* but not __init__.py from oslo/ used empty one instead)
 pbr==0.10.0 (pbr/*)
 pexpect==3.1 (pexpect/*, excluded pxssh.py, fdpexpect.py, FSM.py, screen.py,
               ANSI.py)
 pip==1.5.4 (pip/*, excluded bin/pip*)
 prettytable==0.7.2 (prettytable.py)
-pyrax==1.9.0 (pyrax/*)
+pyrax==1.9.3 (pyrax/*)
+python-cinderclient==1.1.1 (cinderclient/*)
 python-dateutil==2.4.0 (dateutil/*)
-python-novaclient==2.18.1 (novaclient/*, excluded bin/nova)
+python-glanceclient==0.17.0 (glanceclient/*)
+python-ironicclient==0.5.0 (ironicclient/*)
+python-neutronclient==2.3.11 (neutronclient/*)
+python-novaclient==2.20.0 (novaclient/*, excluded bin/nova)
 python-swiftclient==2.2.0 (swiftclient/*, excluded bin/swift)
+python-troveclient==1.0.9 (troveclient/*)
 pytz==2014.10 (pytz/*)
 rackspace-auth-openstack==1.3 (rackspace_auth_openstack/*)
 rackspace-novaclient==1.4 (no files)
 rax_default_network_flags_python_novaclient_ext==0.2.3 (rax_default_network_flags_python_novaclient_ext/*)
 rax_scheduled_images_python_novaclient_ext==0.2.1 (rax_scheduled_images_python_novaclient_ext/*)
 requests==2.5.1 (requests/*)
+shade==0.5.0 (shade/*)
 setuptools==12.0.5 (setuptools/*, _markerlib/*, pkg_resources/*, easy_install.py)
 simplejson==3.6.0 (simplejson/*, excluded simplejson/_speedups.so)
 six==1.9.0 (six.py)
 South==0.8.4 (south/*)
+stevedor==1.3.0 (stevedor/*)

awx/lib/site-packages/cinderclient/__init__.py

@@ -0,0 +1,25 @@
+#    Copyright (c) 2012 OpenStack Foundation
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+__all__ = ['__version__']
+
+import pbr.version
+
+version_info = pbr.version.VersionInfo('python-cinderclient')
+# We have a circular import problem when we first run python setup.py sdist
+# It's harmless, so deflect it.
+try:
+    __version__ = version_info.version_string()
+except AttributeError:
+    __version__ = None

awx/lib/site-packages/cinderclient/auth_plugin.py

@@ -0,0 +1,143 @@
+# Copyright 2013 OpenStack Foundation
+# Copyright 2013 Spanish National Research Council.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import logging
+import pkg_resources
+
+import six
+
+from cinderclient import exceptions
+from cinderclient import utils
+
+
+logger = logging.getLogger(__name__)
+
+
+_discovered_plugins = {}
+
+
+def discover_auth_systems():
+    """Discover the available auth-systems.
+
+    This won't take into account the old style auth-systems.
+    """
+    ep_name = 'openstack.client.auth_plugin'
+    for ep in pkg_resources.iter_entry_points(ep_name):
+        try:
+            auth_plugin = ep.load()
+        except (ImportError, pkg_resources.UnknownExtra, AttributeError) as e:
+            logger.debug("ERROR: Cannot load auth plugin %s" % ep.name)
+            logger.debug(e, exc_info=1)
+        else:
+            _discovered_plugins[ep.name] = auth_plugin
+
+
+def load_auth_system_opts(parser):
+    """Load options needed by the available auth-systems into a parser.
+
+    This function will try to populate the parser with options from the
+    available plugins.
+    """
+    for name, auth_plugin in six.iteritems(_discovered_plugins):
+        add_opts_fn = getattr(auth_plugin, "add_opts", None)
+        if add_opts_fn:
+            group = parser.add_argument_group("Auth-system '%s' options" %
+                                              name)
+            add_opts_fn(group)
+
+
+def load_plugin(auth_system):
+    if auth_system in _discovered_plugins:
+        return _discovered_plugins[auth_system]()
+
+    # NOTE(aloga): If we arrive here, the plugin will be an old-style one,
+    # so we have to create a fake AuthPlugin for it.
+    return DeprecatedAuthPlugin(auth_system)
+
+
+class BaseAuthPlugin(object):
+    """Base class for authentication plugins.
+
+    An authentication plugin needs to override at least the authenticate
+    method to be a valid plugin.
+    """
+    def __init__(self):
+        self.opts = {}
+
+    def get_auth_url(self):
+        """Return the auth url for the plugin (if any)."""
+        return None
+
+    @staticmethod
+    def add_opts(parser):
+        """Populate and return the parser with the options for this plugin.
+
+        If the plugin does not need any options, it should return the same
+        parser untouched.
+        """
+        return parser
+
+    def parse_opts(self, args):
+        """Parse the actual auth-system options if any.
+
+        This method is expected to populate the attribute self.opts with a
+        dict containing the options and values needed to make authentication.
+        If the dict is empty, the client should assume that it needs the same
+        options as the 'keystone' auth system (i.e. os_username and
+        os_password).
+
+        Returns the self.opts dict.
+        """
+        return self.opts
+
+    def authenticate(self, cls, auth_url):
+        """Authenticate using plugin defined method."""
+        raise exceptions.AuthSystemNotFound(self.auth_system)
+
+
+class DeprecatedAuthPlugin(object):
+    """Class to mimic the AuthPlugin class for deprecated auth systems.
+
+    Old auth systems only define two entry points: openstack.client.auth_url
+    and openstack.client.authenticate. This class will load those entry points
+    into a class similar to a valid AuthPlugin.
+    """
+    def __init__(self, auth_system):
+        self.auth_system = auth_system
+
+        def authenticate(cls, auth_url):
+            raise exceptions.AuthSystemNotFound(self.auth_system)
+
+        self.opts = {}
+
+        self.get_auth_url = lambda: None
+        self.authenticate = authenticate
+
+        self._load_endpoints()
+
+    def _load_endpoints(self):
+        ep_name = 'openstack.client.auth_url'
+        fn = utils._load_entry_point(ep_name, name=self.auth_system)
+        if fn:
+            self.get_auth_url = fn
+
+        ep_name = 'openstack.client.authenticate'
+        fn = utils._load_entry_point(ep_name, name=self.auth_system)
+        if fn:
+            self.authenticate = fn
+
+    def parse_opts(self, args):
+        return self.opts

awx/lib/site-packages/cinderclient/base.py

@@ -0,0 +1,221 @@
+# Copyright 2010 Jacob Kaplan-Moss
+
+# Copyright (c) 2011 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Base utilities to build API operation managers and objects on top of.
+"""
+import abc
+import contextlib
+import hashlib
+import os
+
+import six
+
+from cinderclient import exceptions
+from cinderclient.openstack.common.apiclient import base as common_base
+from cinderclient import utils
+
+
+Resource = common_base.Resource
+
+
+# Python 2.4 compat
+try:
+    all
+except NameError:
+    def all(iterable):
+        return True not in (not x for x in iterable)
+
+
+def getid(obj):
+    """
+    Abstracts the common pattern of allowing both an object or an object's ID
+    as a parameter when dealing with relationships.
+    """
+    try:
+        return obj.id
+    except AttributeError:
+        return obj
+
+
+class Manager(utils.HookableMixin):
+    """
+    Managers interact with a particular type of API (servers, flavors, images,
+    etc.) and provide CRUD operations for them.
+    """
+    resource_class = None
+
+    def __init__(self, api):
+        self.api = api
+
+    def _list(self, url, response_key, obj_class=None, body=None):
+        resp = None
+        if body:
+            resp, body = self.api.client.post(url, body=body)
+        else:
+            resp, body = self.api.client.get(url)
+
+        if obj_class is None:
+            obj_class = self.resource_class
+
+        data = body[response_key]
+        # NOTE(ja): keystone returns values as list as {'values': [ ... ]}
+        #           unlike other services which just return the list...
+        if isinstance(data, dict):
+            try:
+                data = data['values']
+            except KeyError:
+                pass
+
+        with self.completion_cache('human_id', obj_class, mode="w"):
+            with self.completion_cache('uuid', obj_class, mode="w"):
+                return [obj_class(self, res, loaded=True)
+                        for res in data if res]
+
+    @contextlib.contextmanager
+    def completion_cache(self, cache_type, obj_class, mode):
+        """
+        The completion cache store items that can be used for bash
+        autocompletion, like UUIDs or human-friendly IDs.
+
+        A resource listing will clear and repopulate the cache.
+
+        A resource create will append to the cache.
+
+        Delete is not handled because listings are assumed to be performed
+        often enough to keep the cache reasonably up-to-date.
+        """
+        base_dir = utils.env('CINDERCLIENT_UUID_CACHE_DIR',
+                             default="~/.cinderclient")
+
+        # NOTE(sirp): Keep separate UUID caches for each username + endpoint
+        # pair
+        username = utils.env('OS_USERNAME', 'CINDER_USERNAME')
+        url = utils.env('OS_URL', 'CINDER_URL')
+        uniqifier = hashlib.md5(username.encode('utf-8') +
+                                url.encode('utf-8')).hexdigest()
+
+        cache_dir = os.path.expanduser(os.path.join(base_dir, uniqifier))
+
+        try:
+            os.makedirs(cache_dir, 0o755)
+        except OSError:
+            # NOTE(kiall): This is typically either permission denied while
+            #              attempting to create the directory, or the directory
+            #              already exists. Either way, don't fail.
+            pass
+
+        resource = obj_class.__name__.lower()
+        filename = "%s-%s-cache" % (resource, cache_type.replace('_', '-'))
+        path = os.path.join(cache_dir, filename)
+
+        cache_attr = "_%s_cache" % cache_type
+
+        try:
+            setattr(self, cache_attr, open(path, mode))
+        except IOError:
+            # NOTE(kiall): This is typically a permission denied while
+            #              attempting to write the cache file.
+            pass
+
+        try:
+            yield
+        finally:
+            cache = getattr(self, cache_attr, None)
+            if cache:
+                cache.close()
+                delattr(self, cache_attr)
+
+    def write_to_completion_cache(self, cache_type, val):
+        cache = getattr(self, "_%s_cache" % cache_type, None)
+        if cache:
+            cache.write("%s\n" % val)
+
+    def _get(self, url, response_key=None):
+        resp, body = self.api.client.get(url)
+        if response_key:
+            return self.resource_class(self, body[response_key], loaded=True)
+        else:
+            return self.resource_class(self, body, loaded=True)
+
+    def _create(self, url, body, response_key, return_raw=False, **kwargs):
+        self.run_hooks('modify_body_for_create', body, **kwargs)
+        resp, body = self.api.client.post(url, body=body)
+        if return_raw:
+            return body[response_key]
+
+        with self.completion_cache('human_id', self.resource_class, mode="a"):
+            with self.completion_cache('uuid', self.resource_class, mode="a"):
+                return self.resource_class(self, body[response_key])
+
+    def _delete(self, url):
+        resp, body = self.api.client.delete(url)
+
+    def _update(self, url, body, **kwargs):
+        self.run_hooks('modify_body_for_update', body, **kwargs)
+        resp, body = self.api.client.put(url, body=body)
+        return body
+
+
+class ManagerWithFind(six.with_metaclass(abc.ABCMeta, Manager)):
+    """
+    Like a `Manager`, but with additional `find()`/`findall()` methods.
+    """
+
+    @abc.abstractmethod
+    def list(self):
+        pass
+
+    def find(self, **kwargs):
+        """
+        Find a single item with attributes matching ``**kwargs``.
+
+        This isn't very efficient: it loads the entire list then filters on
+        the Python side.
+        """
+        matches = self.findall(**kwargs)
+        num_matches = len(matches)
+        if num_matches == 0:
+            msg = "No %s matching %s." % (self.resource_class.__name__, kwargs)
+            raise exceptions.NotFound(404, msg)
+        elif num_matches > 1:
+            raise exceptions.NoUniqueMatch
+        else:
+            return matches[0]
+
+    def findall(self, **kwargs):
+        """
+        Find all items with attributes matching ``**kwargs``.
+
+        This isn't very efficient: it loads the entire list then filters on
+        the Python side.
+        """
+        found = []
+        searches = list(kwargs.items())
+
+        # Want to search for all tenants here so that when attempting to delete
+        # that a user like admin doesn't get a failure when trying to delete
+        # another tenant's volume by name.
+        for obj in self.list(search_opts={'all_tenants': 1}):
+            try:
+                if all(getattr(obj, attr) == value
+                       for (attr, value) in searches):
+                    found.append(obj)
+            except AttributeError:
+                continue
+
+        return found

awx/lib/site-packages/cinderclient/client.py

@@ -0,0 +1,537 @@
+# Copyright (c) 2011 OpenStack Foundation
+# Copyright 2010 Jacob Kaplan-Moss
+# Copyright 2011 Piston Cloud Computing, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""
+OpenStack Client interface. Handles the REST calls and responses.
+"""
+
+from __future__ import print_function
+
+import logging
+
+from keystoneclient import access
+from keystoneclient import adapter
+from keystoneclient.auth.identity import base
+import requests
+
+from cinderclient import exceptions
+from cinderclient.openstack.common import strutils
+from cinderclient import utils
+
+
+try:
+    import urlparse
+except ImportError:
+    import urllib.parse as urlparse
+
+try:
+    from eventlet import sleep
+except ImportError:
+    from time import sleep
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+# Python 2.5 compat fix
+if not hasattr(urlparse, 'parse_qsl'):
+    import cgi
+    urlparse.parse_qsl = cgi.parse_qsl
+
+_VALID_VERSIONS = ['v1', 'v2']
+
+
+def get_volume_api_from_url(url):
+    scheme, netloc, path, query, frag = urlparse.urlsplit(url)
+    components = path.split("/")
+
+    for version in _VALID_VERSIONS:
+        if version in components:
+            return version[1:]
+
+    msg = "Invalid client version '%s'. must be one of: %s" % (
+        (version, ', '.join(valid_versions)))
+    raise exceptions.UnsupportedVersion(msg)
+
+
+class SessionClient(adapter.LegacyJsonAdapter):
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault('user_agent', 'python-cinderclient')
+        kwargs.setdefault('service_type', 'volume')
+        super(SessionClient, self).__init__(**kwargs)
+
+    def request(self, *args, **kwargs):
+        kwargs.setdefault('authenticated', False)
+        return super(SessionClient, self).request(*args, **kwargs)
+
+    def _cs_request(self, url, method, **kwargs):
+        # this function is mostly redundant but makes compatibility easier
+        kwargs.setdefault('authenticated', True)
+        return self.request(url, method, **kwargs)
+
+    def get(self, url, **kwargs):
+        return self._cs_request(url, 'GET', **kwargs)
+
+    def post(self, url, **kwargs):
+        return self._cs_request(url, 'POST', **kwargs)
+
+    def put(self, url, **kwargs):
+        return self._cs_request(url, 'PUT', **kwargs)
+
+    def delete(self, url, **kwargs):
+        return self._cs_request(url, 'DELETE', **kwargs)
+
+    def _invalidate(self, auth=None):
+        # NOTE(jamielennox): This is being implemented in keystoneclient
+        return self.session.invalidate(auth or self.auth)
+
+    def _get_token(self, auth=None):
+        # NOTE(jamielennox): This is being implemented in keystoneclient
+        return self.session.get_token(auth or self.auth)
+
+    def _get_endpoint(self, auth=None, **kwargs):
+        # NOTE(jamielennox): This is being implemented in keystoneclient
+        if self.service_type:
+            kwargs.setdefault('service_type', self.service_type)
+        if self.service_name:
+            kwargs.setdefault('service_name', self.service_name)
+        if self.interface:
+            kwargs.setdefault('interface', self.interface)
+        if self.region_name:
+            kwargs.setdefault('region_name', self.region_name)
+        return self.session.get_endpoint(auth or self.auth, **kwargs)
+
+    def get_volume_api_version_from_endpoint(self):
+        return get_volume_api_from_url(self._get_endpoint())
+
+    def authenticate(self, auth=None):
+        self._invalidate(auth)
+        return self._get_token(auth)
+
+    @property
+    def service_catalog(self):
+        # NOTE(jamielennox): This is ugly and should be deprecated.
+        auth = self.auth or self.session.auth
+
+        if isinstance(auth, base.BaseIdentityPlugin):
+            return auth.get_access(self.session).service_catalog
+
+        raise AttributeError('There is no service catalog for this type of '
+                             'auth plugin.')
+
+
+class HTTPClient(object):
+
+    USER_AGENT = 'python-cinderclient'
+
+    def __init__(self, user, password, projectid, auth_url=None,
+                 insecure=False, timeout=None, tenant_id=None,
+                 proxy_tenant_id=None, proxy_token=None, region_name=None,
+                 endpoint_type='publicURL', service_type=None,
+                 service_name=None, volume_service_name=None, retries=None,
+                 http_log_debug=False, cacert=None,
+                 auth_system='keystone', auth_plugin=None):
+        self.user = user
+        self.password = password
+        self.projectid = projectid
+        self.tenant_id = tenant_id
+
+        if auth_system and auth_system != 'keystone' and not auth_plugin:
+            raise exceptions.AuthSystemNotFound(auth_system)
+
+        if not auth_url and auth_system and auth_system != 'keystone':
+            auth_url = auth_plugin.get_auth_url()
+            if not auth_url:
+                raise exceptions.EndpointNotFound()
+
+        self.auth_url = auth_url.rstrip('/')
+        self.version = 'v1'
+        self.region_name = region_name
+        self.endpoint_type = endpoint_type
+        self.service_type = service_type
+        self.service_name = service_name
+        self.volume_service_name = volume_service_name
+        self.retries = int(retries or 0)
+        self.http_log_debug = http_log_debug
+
+        self.management_url = None
+        self.auth_token = None
+        self.proxy_token = proxy_token
+        self.proxy_tenant_id = proxy_tenant_id
+        self.timeout = timeout
+
+        if insecure:
+            self.verify_cert = False
+        else:
+            if cacert:
+                self.verify_cert = cacert
+            else:
+                self.verify_cert = True
+
+        self.auth_system = auth_system
+        self.auth_plugin = auth_plugin
+
+        self._logger = logging.getLogger(__name__)
+
+    def http_log_req(self, args, kwargs):
+        if not self.http_log_debug:
+            return
+
+        string_parts = ['curl -i']
+        for element in args:
+            if element in ('GET', 'POST', 'DELETE', 'PUT'):
+                string_parts.append(' -X %s' % element)
+            else:
+                string_parts.append(' %s' % element)
+
+        for element in kwargs['headers']:
+            header = ' -H "%s: %s"' % (element, kwargs['headers'][element])
+            string_parts.append(header)
+
+        if 'data' in kwargs:
+            if "password" in kwargs['data']:
+                data = strutils.mask_password(kwargs['data'])
+            else:
+                data = kwargs['data']
+            string_parts.append(" -d '%s'" % (data))
+        self._logger.debug("\nREQ: %s\n" % "".join(string_parts))
+
+    def http_log_resp(self, resp):
+        if not self.http_log_debug:
+            return
+        self._logger.debug(
+            "RESP: [%s] %s\nRESP BODY: %s\n",
+            resp.status_code,
+            resp.headers,
+            resp.text)
+
+    def request(self, url, method, **kwargs):
+        kwargs.setdefault('headers', kwargs.get('headers', {}))
+        kwargs['headers']['User-Agent'] = self.USER_AGENT
+        kwargs['headers']['Accept'] = 'application/json'
+        if 'body' in kwargs:
+            kwargs['headers']['Content-Type'] = 'application/json'
+            kwargs['data'] = json.dumps(kwargs['body'])
+            del kwargs['body']
+
+        if self.timeout:
+            kwargs.setdefault('timeout', self.timeout)
+        self.http_log_req((url, method,), kwargs)
+        resp = requests.request(
+            method,
+            url,
+            verify=self.verify_cert,
+            **kwargs)
+        self.http_log_resp(resp)
+
+        if resp.text:
+            try:
+                body = json.loads(resp.text)
+            except ValueError:
+                pass
+                body = None
+        else:
+            body = None
+
+        if resp.status_code >= 400:
+            raise exceptions.from_response(resp, body)
+
+        return resp, body
+
+    def _cs_request(self, url, method, **kwargs):
+        auth_attempts = 0
+        attempts = 0
+        backoff = 1
+        while True:
+            attempts += 1
+            if not self.management_url or not self.auth_token:
+                self.authenticate()
+            kwargs.setdefault('headers', {})['X-Auth-Token'] = self.auth_token
+            if self.projectid:
+                kwargs['headers']['X-Auth-Project-Id'] = self.projectid
+            try:
+                resp, body = self.request(self.management_url + url, method,
+                                          **kwargs)
+                return resp, body
+            except exceptions.BadRequest as e:
+                if attempts > self.retries:
+                    raise
+            except exceptions.Unauthorized:
+                if auth_attempts > 0:
+                    raise
+                self._logger.debug("Unauthorized, reauthenticating.")
+                self.management_url = self.auth_token = None
+                # First reauth. Discount this attempt.
+                attempts -= 1
+                auth_attempts += 1
+                continue
+            except exceptions.ClientException as e:
+                if attempts > self.retries:
+                    raise
+                if 500 <= e.code <= 599:
+                    pass
+                else:
+                    raise
+            except requests.exceptions.ConnectionError as e:
+                self._logger.debug("Connection error: %s" % e)
+                if attempts > self.retries:
+                    msg = 'Unable to establish connection: %s' % e
+                    raise exceptions.ConnectionError(msg)
+            self._logger.debug(
+                "Failed attempt(%s of %s), retrying in %s seconds" %
+                (attempts, self.retries, backoff))
+            sleep(backoff)
+            backoff *= 2
+
+    def get(self, url, **kwargs):
+        return self._cs_request(url, 'GET', **kwargs)
+
+    def post(self, url, **kwargs):
+        return self._cs_request(url, 'POST', **kwargs)
+
+    def put(self, url, **kwargs):
+        return self._cs_request(url, 'PUT', **kwargs)
+
+    def delete(self, url, **kwargs):
+        return self._cs_request(url, 'DELETE', **kwargs)
+
+    def get_volume_api_version_from_endpoint(self):
+        return get_volume_api_from_url(self.management_url)
+
+    def _extract_service_catalog(self, url, resp, body, extract_token=True):
+        """See what the auth service told us and process the response.
+        We may get redirected to another site, fail or actually get
+        back a service catalog with a token and our endpoints.
+        """
+
+        if resp.status_code == 200:  # content must always present
+            try:
+                self.auth_url = url
+                self.auth_ref = access.AccessInfo.factory(resp, body)
+                self.service_catalog = self.auth_ref.service_catalog
+
+                if extract_token:
+                    self.auth_token = self.auth_ref.auth_token
+
+                management_url = self.service_catalog.url_for(
+                    region_name=self.region_name,
+                    endpoint_type=self.endpoint_type,
+                    service_type=self.service_type)
+                self.management_url = management_url.rstrip('/')
+                return None
+            except exceptions.AmbiguousEndpoints:
+                print("Found more than one valid endpoint. Use a more "
+                      "restrictive filter")
+                raise
+            except KeyError:
+                raise exceptions.AuthorizationFailure()
+            except exceptions.EndpointNotFound:
+                print("Could not find any suitable endpoint. Correct region?")
+                raise
+
+        elif resp.status_code == 305:
+            return resp['location']
+        else:
+            raise exceptions.from_response(resp, body)
+
+    def _fetch_endpoints_from_auth(self, url):
+        """We have a token, but don't know the final endpoint for
+        the region. We have to go back to the auth service and
+        ask again. This request requires an admin-level token
+        to work. The proxy token supplied could be from a low-level enduser.
+
+        We can't get this from the keystone service endpoint, we have to use
+        the admin endpoint.
+
+        This will overwrite our admin token with the user token.
+        """
+
+        # GET ...:5001/v2.0/tokens/#####/endpoints
+        url = '/'.join([url, 'tokens', '%s?belongsTo=%s'
+                        % (self.proxy_token, self.proxy_tenant_id)])
+        self._logger.debug("Using Endpoint URL: %s" % url)
+        resp, body = self.request(url, "GET",
+                                  headers={'X-Auth-Token': self.auth_token})
+        return self._extract_service_catalog(url, resp, body,
+                                             extract_token=False)
+
+    def authenticate(self):
+        magic_tuple = urlparse.urlsplit(self.auth_url)
+        scheme, netloc, path, query, frag = magic_tuple
+        port = magic_tuple.port
+        if port is None:
+            port = 80
+        path_parts = path.split('/')
+        for part in path_parts:
+            if len(part) > 0 and part[0] == 'v':
+                self.version = part
+                break
+
+        # TODO(sandy): Assume admin endpoint is 35357 for now.
+        # Ideally this is going to have to be provided by the service catalog.
+        new_netloc = netloc.replace(':%d' % port, ':%d' % (35357,))
+        admin_url = urlparse.urlunsplit((scheme, new_netloc,
+                                         path, query, frag))
+
+        auth_url = self.auth_url
+        if self.version == "v2.0":
+            while auth_url:
+                if not self.auth_system or self.auth_system == 'keystone':
+                    auth_url = self._v2_auth(auth_url)
+                else:
+                    auth_url = self._plugin_auth(auth_url)
+
+            # Are we acting on behalf of another user via an
+            # existing token? If so, our actual endpoints may
+            # be different than that of the admin token.
+            if self.proxy_token:
+                self._fetch_endpoints_from_auth(admin_url)
+                # Since keystone no longer returns the user token
+                # with the endpoints any more, we need to replace
+                # our service account token with the user token.
+                self.auth_token = self.proxy_token
+        else:
+            try:
+                while auth_url:
+                    auth_url = self._v1_auth(auth_url)
+            # In some configurations cinder makes redirection to
+            # v2.0 keystone endpoint. Also, new location does not contain
+            # real endpoint, only hostname and port.
+            except exceptions.AuthorizationFailure:
+                if auth_url.find('v2.0') < 0:
+                    auth_url = auth_url + '/v2.0'
+                self._v2_auth(auth_url)
+
+    def _v1_auth(self, url):
+        if self.proxy_token:
+            raise exceptions.NoTokenLookupException()
+
+        headers = {'X-Auth-User': self.user,
+                   'X-Auth-Key': self.password}
+        if self.projectid:
+            headers['X-Auth-Project-Id'] = self.projectid
+
+        resp, body = self.request(url, 'GET', headers=headers)
+        if resp.status_code in (200, 204):  # in some cases we get No Content
+            try:
+                mgmt_header = 'x-server-management-url'
+                self.management_url = resp.headers[mgmt_header].rstrip('/')
+                self.auth_token = resp.headers['x-auth-token']
+                self.auth_url = url
+            except (KeyError, TypeError):
+                raise exceptions.AuthorizationFailure()
+        elif resp.status_code == 305:
+            return resp.headers['location']
+        else:
+            raise exceptions.from_response(resp, body)
+
+    def _plugin_auth(self, auth_url):
+        return self.auth_plugin.authenticate(self, auth_url)
+
+    def _v2_auth(self, url):
+        """Authenticate against a v2.0 auth service."""
+        body = {"auth": {
+            "passwordCredentials": {"username": self.user,
+                                    "password": self.password}}}
+
+        if self.projectid:
+            body['auth']['tenantName'] = self.projectid
+        elif self.tenant_id:
+            body['auth']['tenantId'] = self.tenant_id
+
+        self._authenticate(url, body)
+
+    def _authenticate(self, url, body):
+        """Authenticate and extract the service catalog."""
+        token_url = url + "/tokens"
+
+        # Make sure we follow redirects when trying to reach Keystone
+        resp, body = self.request(
+            token_url,
+            "POST",
+            body=body,
+            allow_redirects=True)
+
+        return self._extract_service_catalog(url, resp, body)
+
+
+def _construct_http_client(username=None, password=None, project_id=None,
+                           auth_url=None, insecure=False, timeout=None,
+                           proxy_tenant_id=None, proxy_token=None,
+                           region_name=None, endpoint_type='publicURL',
+                           service_type='volume',
+                           service_name=None, volume_service_name=None,
+                           retries=None,
+                           http_log_debug=False,
+                           auth_system='keystone', auth_plugin=None,
+                           cacert=None, tenant_id=None,
+                           session=None,
+                           auth=None,
+                           **kwargs):
+
+    if session:
+        kwargs.setdefault('interface', endpoint_type)
+        return SessionClient(session=session,
+                             auth=auth,
+                             service_type=service_type,
+                             service_name=service_name,
+                             region_name=region_name,
+                             **kwargs)
+    else:
+        # FIXME(jamielennox): username and password are now optional. Need
+        # to test that they were provided in this mode.
+        return HTTPClient(username,
+                          password,
+                          projectid=project_id,
+                          auth_url=auth_url,
+                          insecure=insecure,
+                          timeout=timeout,
+                          tenant_id=tenant_id,
+                          proxy_token=proxy_token,
+                          proxy_tenant_id=proxy_tenant_id,
+                          region_name=region_name,
+                          endpoint_type=endpoint_type,
+                          service_type=service_type,
+                          service_name=service_name,
+                          volume_service_name=volume_service_name,
+                          retries=retries,
+                          http_log_debug=http_log_debug,
+                          cacert=cacert,
+                          auth_system=auth_system,
+                          auth_plugin=auth_plugin,
+                          )
+
+
+def get_client_class(version):
+    version_map = {
+        '1': 'cinderclient.v1.client.Client',
+        '2': 'cinderclient.v2.client.Client',
+    }
+    try:
+        client_path = version_map[str(version)]
+    except (KeyError, ValueError):
+        msg = "Invalid client version '%s'. must be one of: %s" % (
+            (version, ', '.join(version_map)))
+        raise exceptions.UnsupportedVersion(msg)
+
+    return utils.import_class(client_path)
+
+
+def Client(version, *args, **kwargs):
+    client_class = get_client_class(version)
+    return client_class(*args, **kwargs)

awx/lib/site-packages/cinderclient/exceptions.py

@@ -0,0 +1,185 @@
+# Copyright 2010 Jacob Kaplan-Moss
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Exception definitions.
+"""
+
+
+class UnsupportedVersion(Exception):
+    """Indicates that the user is trying to use an unsupported
+    version of the API.
+    """
+    pass
+
+
+class InvalidAPIVersion(Exception):
+    pass
+
+
+class CommandError(Exception):
+    pass
+
+
+class AuthorizationFailure(Exception):
+    pass
+
+
+class NoUniqueMatch(Exception):
+    pass
+
+
+class AuthSystemNotFound(Exception):
+    """When the user specify a AuthSystem but not installed."""
+    def __init__(self, auth_system):
+        self.auth_system = auth_system
+
+    def __str__(self):
+        return "AuthSystemNotFound: %s" % repr(self.auth_system)
+
+
+class NoTokenLookupException(Exception):
+    """This form of authentication does not support looking up
+       endpoints from an existing token.
+    """
+    pass
+
+
+class EndpointNotFound(Exception):
+    """Could not find Service or Region in Service Catalog."""
+    pass
+
+
+class ConnectionError(Exception):
+    """Could not open a connection to the API service."""
+    pass
+
+
+class AmbiguousEndpoints(Exception):
+    """Found more than one matching endpoint in Service Catalog."""
+    def __init__(self, endpoints=None):
+        self.endpoints = endpoints
+
+    def __str__(self):
+        return "AmbiguousEndpoints: %s" % repr(self.endpoints)
+
+
+class ClientException(Exception):
+    """
+    The base exception class for all exceptions this library raises.
+    """
+    def __init__(self, code, message=None, details=None, request_id=None):
+        self.code = code
+        self.message = message or self.__class__.message
+        self.details = details
+        self.request_id = request_id
+
+    def __str__(self):
+        formatted_string = "%s (HTTP %s)" % (self.message, self.code)
+        if self.request_id:
+            formatted_string += " (Request-ID: %s)" % self.request_id
+
+        return formatted_string
+
+
+class BadRequest(ClientException):
+    """
+    HTTP 400 - Bad request: you sent some malformed data.
+    """
+    http_status = 400
+    message = "Bad request"
+
+
+class Unauthorized(ClientException):
+    """
+    HTTP 401 - Unauthorized: bad credentials.
+    """
+    http_status = 401
+    message = "Unauthorized"
+
+
+class Forbidden(ClientException):
+    """
+    HTTP 403 - Forbidden: your credentials don't give you access to this
+    resource.
+    """
+    http_status = 403
+    message = "Forbidden"
+
+
+class NotFound(ClientException):
+    """
+    HTTP 404 - Not found
+    """
+    http_status = 404
+    message = "Not found"
+
+
+class OverLimit(ClientException):
+    """
+    HTTP 413 - Over limit: you're over the API limits for this time period.
+    """
+    http_status = 413
+    message = "Over limit"
+
+
+# NotImplemented is a python keyword.
+class HTTPNotImplemented(ClientException):
+    """
+    HTTP 501 - Not Implemented: the server does not support this operation.
+    """
+    http_status = 501
+    message = "Not Implemented"
+
+
+# In Python 2.4 Exception is old-style and thus doesn't have a __subclasses__()
+# so we can do this:
+#     _code_map = dict((c.http_status, c)
+#                      for c in ClientException.__subclasses__())
+#
+# Instead, we have to hardcode it:
+_code_map = dict((c.http_status, c) for c in [BadRequest, Unauthorized,
+                                              Forbidden, NotFound,
+                                              OverLimit, HTTPNotImplemented])
+
+
+def from_response(response, body):
+    """
+    Return an instance of an ClientException or subclass
+    based on an requests response.
+
+    Usage::
+
+        resp, body = requests.request(...)
+        if resp.status_code != 200:
+            raise exception_from_response(resp, rest.text)
+    """
+    cls = _code_map.get(response.status_code, ClientException)
+    if response.headers:
+        request_id = response.headers.get('x-compute-request-id')
+    else:
+        request_id = None
+    if body:
+        message = "n/a"
+        details = "n/a"
+        if hasattr(body, 'keys'):
+            error = body[list(body)[0]]
+            message = error.get('message', None)
+            details = error.get('details', None)
+        return cls(code=response.status_code, message=message, details=details,
+                   request_id=request_id)
+    else:
+        return cls(code=response.status_code, request_id=request_id,
+                   message=response.reason)

awx/lib/site-packages/cinderclient/extension.py

@@ -0,0 +1,39 @@
+# Copyright (c) 2011 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient import base
+from cinderclient import utils
+
+
+class Extension(utils.HookableMixin):
+    """Extension descriptor."""
+
+    SUPPORTED_HOOKS = ('__pre_parse_args__', '__post_parse_args__')
+
+    def __init__(self, name, module):
+        self.name = name
+        self.module = module
+        self._parse_extension_module()
+
+    def _parse_extension_module(self):
+        self.manager_class = None
+        for attr_name, attr_value in list(self.module.__dict__.items()):
+            if attr_name in self.SUPPORTED_HOOKS:
+                self.add_hook(attr_name, attr_value)
+            elif utils.safe_issubclass(attr_value, base.Manager):
+                self.manager_class = attr_value
+
+    def __repr__(self):
+        return "<Extension '%s'>" % self.name

awx/lib/site-packages/cinderclient/openstack/common/__init__.py

@@ -0,0 +1,17 @@
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import six
+
+
+six.add_move(six.MovedModule('mox', 'mox', 'mox3.mox'))

awx/lib/site-packages/cinderclient/openstack/common/apiclient/auth.py

@@ -0,0 +1,221 @@
+# Copyright 2013 OpenStack Foundation
+# Copyright 2013 Spanish National Research Council.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+# E0202: An attribute inherited from %s hide this method
+# pylint: disable=E0202
+
+import abc
+import argparse
+import os
+
+import six
+from stevedore import extension
+
+from cinderclient.openstack.common.apiclient import exceptions
+
+
+_discovered_plugins = {}
+
+
+def discover_auth_systems():
+    """Discover the available auth-systems.
+
+    This won't take into account the old style auth-systems.
+    """
+    global _discovered_plugins
+    _discovered_plugins = {}
+
+    def add_plugin(ext):
+        _discovered_plugins[ext.name] = ext.plugin
+
+    ep_namespace = "cinderclient.openstack.common.apiclient.auth"
+    mgr = extension.ExtensionManager(ep_namespace)
+    mgr.map(add_plugin)
+
+
+def load_auth_system_opts(parser):
+    """Load options needed by the available auth-systems into a parser.
+
+    This function will try to populate the parser with options from the
+    available plugins.
+    """
+    group = parser.add_argument_group("Common auth options")
+    BaseAuthPlugin.add_common_opts(group)
+    for name, auth_plugin in six.iteritems(_discovered_plugins):
+        group = parser.add_argument_group(
+            "Auth-system '%s' options" % name,
+            conflict_handler="resolve")
+        auth_plugin.add_opts(group)
+
+
+def load_plugin(auth_system):
+    try:
+        plugin_class = _discovered_plugins[auth_system]
+    except KeyError:
+        raise exceptions.AuthSystemNotFound(auth_system)
+    return plugin_class(auth_system=auth_system)
+
+
+def load_plugin_from_args(args):
+    """Load required plugin and populate it with options.
+
+    Try to guess auth system if it is not specified. Systems are tried in
+    alphabetical order.
+
+    :type args: argparse.Namespace
+    :raises: AuthorizationFailure
+    """
+    auth_system = args.os_auth_system
+    if auth_system:
+        plugin = load_plugin(auth_system)
+        plugin.parse_opts(args)
+        plugin.sufficient_options()
+        return plugin
+
+    for plugin_auth_system in sorted(six.iterkeys(_discovered_plugins)):
+        plugin_class = _discovered_plugins[plugin_auth_system]
+        plugin = plugin_class()
+        plugin.parse_opts(args)
+        try:
+            plugin.sufficient_options()
+        except exceptions.AuthPluginOptionsMissing:
+            continue
+        return plugin
+    raise exceptions.AuthPluginOptionsMissing(["auth_system"])
+
+
+@six.add_metaclass(abc.ABCMeta)
+class BaseAuthPlugin(object):
+    """Base class for authentication plugins.
+
+    An authentication plugin needs to override at least the authenticate
+    method to be a valid plugin.
+    """
+
+    auth_system = None
+    opt_names = []
+    common_opt_names = [
+        "auth_system",
+        "username",
+        "password",
+        "tenant_name",
+        "token",
+        "auth_url",
+    ]
+
+    def __init__(self, auth_system=None, **kwargs):
+        self.auth_system = auth_system or self.auth_system
+        self.opts = dict((name, kwargs.get(name))
+                         for name in self.opt_names)
+
+    @staticmethod
+    def _parser_add_opt(parser, opt):
+        """Add an option to parser in two variants.
+
+        :param opt: option name (with underscores)
+        """
+        dashed_opt = opt.replace("_", "-")
+        env_var = "OS_%s" % opt.upper()
+        arg_default = os.environ.get(env_var, "")
+        arg_help = "Defaults to env[%s]." % env_var
+        parser.add_argument(
+            "--os-%s" % dashed_opt,
+            metavar="<%s>" % dashed_opt,
+            default=arg_default,
+            help=arg_help)
+        parser.add_argument(
+            "--os_%s" % opt,
+            metavar="<%s>" % dashed_opt,
+            help=argparse.SUPPRESS)
+
+    @classmethod
+    def add_opts(cls, parser):
+        """Populate the parser with the options for this plugin.
+        """
+        for opt in cls.opt_names:
+            # use `BaseAuthPlugin.common_opt_names` since it is never
+            # changed in child classes
+            if opt not in BaseAuthPlugin.common_opt_names:
+                cls._parser_add_opt(parser, opt)
+
+    @classmethod
+    def add_common_opts(cls, parser):
+        """Add options that are common for several plugins.
+        """
+        for opt in cls.common_opt_names:
+            cls._parser_add_opt(parser, opt)
+
+    @staticmethod
+    def get_opt(opt_name, args):
+        """Return option name and value.
+
+        :param opt_name: name of the option, e.g., "username"
+        :param args: parsed arguments
+        """
+        return (opt_name, getattr(args, "os_%s" % opt_name, None))
+
+    def parse_opts(self, args):
+        """Parse the actual auth-system options if any.
+
+        This method is expected to populate the attribute `self.opts` with a
+        dict containing the options and values needed to make authentication.
+        """
+        self.opts.update(dict(self.get_opt(opt_name, args)
+                              for opt_name in self.opt_names))
+
+    def authenticate(self, http_client):
+        """Authenticate using plugin defined method.
+
+        The method usually analyses `self.opts` and performs
+        a request to authentication server.
+
+        :param http_client: client object that needs authentication
+        :type http_client: HTTPClient
+        :raises: AuthorizationFailure
+        """
+        self.sufficient_options()
+        self._do_authenticate(http_client)
+
+    @abc.abstractmethod
+    def _do_authenticate(self, http_client):
+        """Protected method for authentication.
+        """
+
+    def sufficient_options(self):
+        """Check if all required options are present.
+
+        :raises: AuthPluginOptionsMissing
+        """
+        missing = [opt
+                   for opt in self.opt_names
+                   if not self.opts.get(opt)]
+        if missing:
+            raise exceptions.AuthPluginOptionsMissing(missing)
+
+    @abc.abstractmethod
+    def token_and_endpoint(self, endpoint_type, service_type):
+        """Return token and endpoint.
+
+        :param service_type: Service type of the endpoint
+        :type service_type: string
+        :param endpoint_type: Type of endpoint.
+                              Possible values: public or publicURL,
+                                  internal or internalURL,
+                                  admin or adminURL
+        :type endpoint_type: string
+        :returns: tuple of token and endpoint strings
+        :raises: EndpointException
+        """

awx/lib/site-packages/cinderclient/openstack/common/apiclient/base.py

@@ -0,0 +1,491 @@
+# Copyright 2010 Jacob Kaplan-Moss
+# Copyright 2011 OpenStack Foundation
+# Copyright 2012 Grid Dynamics
+# Copyright 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Base utilities to build API operation managers and objects on top of.
+"""
+
+# E1102: %s is not callable
+# pylint: disable=E1102
+
+import abc
+
+import six
+from six.moves.urllib import parse
+
+from cinderclient.openstack.common.apiclient import exceptions
+from cinderclient.openstack.common import strutils
+
+
+def getid(obj):
+    """Return id if argument is a Resource.
+
+    Abstracts the common pattern of allowing both an object or an object's ID
+    (UUID) as a parameter when dealing with relationships.
+    """
+    try:
+        if obj.uuid:
+            return obj.uuid
+    except AttributeError:
+        pass
+    try:
+        return obj.id
+    except AttributeError:
+        return obj
+
+
+# TODO(aababilov): call run_hooks() in HookableMixin's child classes
+class HookableMixin(object):
+    """Mixin so classes can register and run hooks."""
+    _hooks_map = {}
+
+    @classmethod
+    def add_hook(cls, hook_type, hook_func):
+        """Add a new hook of specified type.
+
+        :param cls: class that registers hooks
+        :param hook_type: hook type, e.g., '__pre_parse_args__'
+        :param hook_func: hook function
+        """
+        if hook_type not in cls._hooks_map:
+            cls._hooks_map[hook_type] = []
+
+        cls._hooks_map[hook_type].append(hook_func)
+
+    @classmethod
+    def run_hooks(cls, hook_type, *args, **kwargs):
+        """Run all hooks of specified type.
+
+        :param cls: class that registers hooks
+        :param hook_type: hook type, e.g., '__pre_parse_args__'
+        :param **args: args to be passed to every hook function
+        :param **kwargs: kwargs to be passed to every hook function
+        """
+        hook_funcs = cls._hooks_map.get(hook_type) or []
+        for hook_func in hook_funcs:
+            hook_func(*args, **kwargs)
+
+
+class BaseManager(HookableMixin):
+    """Basic manager type providing common operations.
+
+    Managers interact with a particular type of API (servers, flavors, images,
+    etc.) and provide CRUD operations for them.
+    """
+    resource_class = None
+
+    def __init__(self, client):
+        """Initializes BaseManager with `client`.
+
+        :param client: instance of BaseClient descendant for HTTP requests
+        """
+        super(BaseManager, self).__init__()
+        self.client = client
+
+    def _list(self, url, response_key, obj_class=None, json=None):
+        """List the collection.
+
+        :param url: a partial URL, e.g., '/servers'
+        :param response_key: the key to be looked up in response dictionary,
+            e.g., 'servers'
+        :param obj_class: class for constructing the returned objects
+            (self.resource_class will be used by default)
+        :param json: data that will be encoded as JSON and passed in POST
+            request (GET will be sent by default)
+        """
+        if json:
+            body = self.client.post(url, json=json).json()
+        else:
+            body = self.client.get(url).json()
+
+        if obj_class is None:
+            obj_class = self.resource_class
+
+        data = body[response_key]
+        # NOTE(ja): keystone returns values as list as {'values': [ ... ]}
+        #           unlike other services which just return the list...
+        try:
+            data = data['values']
+        except (KeyError, TypeError):
+            pass
+
+        return [obj_class(self, res, loaded=True) for res in data if res]
+
+    def _get(self, url, response_key):
+        """Get an object from collection.
+
+        :param url: a partial URL, e.g., '/servers'
+        :param response_key: the key to be looked up in response dictionary,
+            e.g., 'server'
+        """
+        body = self.client.get(url).json()
+        return self.resource_class(self, body[response_key], loaded=True)
+
+    def _head(self, url):
+        """Retrieve request headers for an object.
+
+        :param url: a partial URL, e.g., '/servers'
+        """
+        resp = self.client.head(url)
+        return resp.status_code == 204
+
+    def _post(self, url, json, response_key, return_raw=False):
+        """Create an object.
+
+        :param url: a partial URL, e.g., '/servers'
+        :param json: data that will be encoded as JSON and passed in POST
+            request (GET will be sent by default)
+        :param response_key: the key to be looked up in response dictionary,
+            e.g., 'servers'
+        :param return_raw: flag to force returning raw JSON instead of
+            Python object of self.resource_class
+        """
+        body = self.client.post(url, json=json).json()
+        if return_raw:
+            return body[response_key]
+        return self.resource_class(self, body[response_key])
+
+    def _put(self, url, json=None, response_key=None):
+        """Update an object with PUT method.
+
+        :param url: a partial URL, e.g., '/servers'
+        :param json: data that will be encoded as JSON and passed in POST
+            request (GET will be sent by default)
+        :param response_key: the key to be looked up in response dictionary,
+            e.g., 'servers'
+        """
+        resp = self.client.put(url, json=json)
+        # PUT requests may not return a body
+        if resp.content:
+            body = resp.json()
+            if response_key is not None:
+                return self.resource_class(self, body[response_key])
+            else:
+                return self.resource_class(self, body)
+
+    def _patch(self, url, json=None, response_key=None):
+        """Update an object with PATCH method.
+
+        :param url: a partial URL, e.g., '/servers'
+        :param json: data that will be encoded as JSON and passed in POST
+            request (GET will be sent by default)
+        :param response_key: the key to be looked up in response dictionary,
+            e.g., 'servers'
+        """
+        body = self.client.patch(url, json=json).json()
+        if response_key is not None:
+            return self.resource_class(self, body[response_key])
+        else:
+            return self.resource_class(self, body)
+
+    def _delete(self, url):
+        """Delete an object.
+
+        :param url: a partial URL, e.g., '/servers/my-server'
+        """
+        return self.client.delete(url)
+
+
+@six.add_metaclass(abc.ABCMeta)
+class ManagerWithFind(BaseManager):
+    """Manager with additional `find()`/`findall()` methods."""
+
+    @abc.abstractmethod
+    def list(self):
+        pass
+
+    def find(self, **kwargs):
+        """Find a single item with attributes matching ``**kwargs``.
+
+        This isn't very efficient: it loads the entire list then filters on
+        the Python side.
+        """
+        matches = self.findall(**kwargs)
+        num_matches = len(matches)
+        if num_matches == 0:
+            msg = "No %s matching %s." % (self.resource_class.__name__, kwargs)
+            raise exceptions.NotFound(msg)
+        elif num_matches > 1:
+            raise exceptions.NoUniqueMatch()
+        else:
+            return matches[0]
+
+    def findall(self, **kwargs):
+        """Find all items with attributes matching ``**kwargs``.
+
+        This isn't very efficient: it loads the entire list then filters on
+        the Python side.
+        """
+        found = []
+        searches = kwargs.items()
+
+        for obj in self.list():
+            try:
+                if all(getattr(obj, attr) == value
+                       for (attr, value) in searches):
+                    found.append(obj)
+            except AttributeError:
+                continue
+
+        return found
+
+
+class CrudManager(BaseManager):
+    """Base manager class for manipulating entities.
+
+    Children of this class are expected to define a `collection_key` and `key`.
+
+    - `collection_key`: Usually a plural noun by convention (e.g. `entities`);
+      used to refer collections in both URL's (e.g.  `/v3/entities`) and JSON
+      objects containing a list of member resources (e.g. `{'entities': [{},
+      {}, {}]}`).
+    - `key`: Usually a singular noun by convention (e.g. `entity`); used to
+      refer to an individual member of the collection.
+
+    """
+    collection_key = None
+    key = None
+
+    def build_url(self, base_url=None, **kwargs):
+        """Builds a resource URL for the given kwargs.
+
+        Given an example collection where `collection_key = 'entities'` and
+        `key = 'entity'`, the following URL's could be generated.
+
+        By default, the URL will represent a collection of entities, e.g.::
+
+            /entities
+
+        If kwargs contains an `entity_id`, then the URL will represent a
+        specific member, e.g.::
+
+            /entities/{entity_id}
+
+        :param base_url: if provided, the generated URL will be appended to it
+        """
+        url = base_url if base_url is not None else ''
+
+        url += '/%s' % self.collection_key
+
+        # do we have a specific entity?
+        entity_id = kwargs.get('%s_id' % self.key)
+        if entity_id is not None:
+            url += '/%s' % entity_id
+
+        return url
+
+    def _filter_kwargs(self, kwargs):
+        """Drop null values and handle ids."""
+        for key, ref in six.iteritems(kwargs.copy()):
+            if ref is None:
+                kwargs.pop(key)
+            else:
+                if isinstance(ref, Resource):
+                    kwargs.pop(key)
+                    kwargs['%s_id' % key] = getid(ref)
+        return kwargs
+
+    def create(self, **kwargs):
+        kwargs = self._filter_kwargs(kwargs)
+        return self._post(
+            self.build_url(**kwargs),
+            {self.key: kwargs},
+            self.key)
+
+    def get(self, **kwargs):
+        kwargs = self._filter_kwargs(kwargs)
+        return self._get(
+            self.build_url(**kwargs),
+            self.key)
+
+    def head(self, **kwargs):
+        kwargs = self._filter_kwargs(kwargs)
+        return self._head(self.build_url(**kwargs))
+
+    def list(self, base_url=None, **kwargs):
+        """List the collection.
+
+        :param base_url: if provided, the generated URL will be appended to it
+        """
+        kwargs = self._filter_kwargs(kwargs)
+
+        return self._list(
+            '%(base_url)s%(query)s' % {
+                'base_url': self.build_url(base_url=base_url, **kwargs),
+                'query': '?%s' % parse.urlencode(kwargs) if kwargs else '',
+            },
+            self.collection_key)
+
+    def put(self, base_url=None, **kwargs):
+        """Update an element.
+
+        :param base_url: if provided, the generated URL will be appended to it
+        """
+        kwargs = self._filter_kwargs(kwargs)
+
+        return self._put(self.build_url(base_url=base_url, **kwargs))
+
+    def update(self, **kwargs):
+        kwargs = self._filter_kwargs(kwargs)
+        params = kwargs.copy()
+        params.pop('%s_id' % self.key)
+
+        return self._patch(
+            self.build_url(**kwargs),
+            {self.key: params},
+            self.key)
+
+    def delete(self, **kwargs):
+        kwargs = self._filter_kwargs(kwargs)
+
+        return self._delete(
+            self.build_url(**kwargs))
+
+    def find(self, base_url=None, **kwargs):
+        """Find a single item with attributes matching ``**kwargs``.
+
+        :param base_url: if provided, the generated URL will be appended to it
+        """
+        kwargs = self._filter_kwargs(kwargs)
+
+        rl = self._list(
+            '%(base_url)s%(query)s' % {
+                'base_url': self.build_url(base_url=base_url, **kwargs),
+                'query': '?%s' % parse.urlencode(kwargs) if kwargs else '',
+            },
+            self.collection_key)
+        num = len(rl)
+
+        if num == 0:
+            msg = "No %s matching %s." % (self.resource_class.__name__, kwargs)
+            raise exceptions.NotFound(404, msg)
+        elif num > 1:
+            raise exceptions.NoUniqueMatch
+        else:
+            return rl[0]
+
+
+class Extension(HookableMixin):
+    """Extension descriptor."""
+
+    SUPPORTED_HOOKS = ('__pre_parse_args__', '__post_parse_args__')
+    manager_class = None
+
+    def __init__(self, name, module):
+        super(Extension, self).__init__()
+        self.name = name
+        self.module = module
+        self._parse_extension_module()
+
+    def _parse_extension_module(self):
+        self.manager_class = None
+        for attr_name, attr_value in self.module.__dict__.items():
+            if attr_name in self.SUPPORTED_HOOKS:
+                self.add_hook(attr_name, attr_value)
+            else:
+                try:
+                    if issubclass(attr_value, BaseManager):
+                        self.manager_class = attr_value
+                except TypeError:
+                    pass
+
+    def __repr__(self):
+        return "<Extension '%s'>" % self.name
+
+
+class Resource(object):
+    """Base class for OpenStack resources (tenant, user, etc.).
+
+    This is pretty much just a bag for attributes.
+    """
+
+    HUMAN_ID = False
+    NAME_ATTR = 'name'
+
+    def __init__(self, manager, info, loaded=False):
+        """Populate and bind to a manager.
+
+        :param manager: BaseManager object
+        :param info: dictionary representing resource attributes
+        :param loaded: prevent lazy-loading if set to True
+        """
+        self.manager = manager
+        self._info = info
+        self._add_details(info)
+        self._loaded = loaded
+
+    def __repr__(self):
+        reprkeys = sorted(k
+                          for k in self.__dict__.keys()
+                          if k[0] != '_' and k != 'manager')
+        info = ", ".join("%s=%s" % (k, getattr(self, k)) for k in reprkeys)
+        return "<%s %s>" % (self.__class__.__name__, info)
+
+    @property
+    def human_id(self):
+        """Human-readable ID which can be used for bash completion.
+        """
+        if self.NAME_ATTR in self.__dict__ and self.HUMAN_ID:
+            return strutils.to_slug(getattr(self, self.NAME_ATTR))
+        return None
+
+    def _add_details(self, info):
+        for (k, v) in six.iteritems(info):
+            try:
+                setattr(self, k, v)
+                self._info[k] = v
+            except AttributeError:
+                # In this case we already defined the attribute on the class
+                pass
+
+    def __getattr__(self, k):
+        if k not in self.__dict__:
+            #NOTE(bcwaldon): disallow lazy-loading if already loaded once
+            if not self.is_loaded():
+                self.get()
+                return self.__getattr__(k)
+
+            raise AttributeError(k)
+        else:
+            return self.__dict__[k]
+
+    def get(self):
+        # set_loaded() first ... so if we have to bail, we know we tried.
+        self.set_loaded(True)
+        if not hasattr(self.manager, 'get'):
+            return
+
+        new = self.manager.get(self.id)
+        if new:
+            self._add_details(new._info)
+
+    def __eq__(self, other):
+        if not isinstance(other, Resource):
+            return NotImplemented
+        # two resources of different types are not equal
+        if not isinstance(other, self.__class__):
+            return False
+        if hasattr(self, 'id') and hasattr(other, 'id'):
+            return self.id == other.id
+        return self._info == other._info
+
+    def is_loaded(self):
+        return self._loaded
+
+    def set_loaded(self, val):
+        self._loaded = val

awx/lib/site-packages/cinderclient/openstack/common/apiclient/client.py

@@ -0,0 +1,358 @@
+# Copyright 2010 Jacob Kaplan-Moss
+# Copyright 2011 OpenStack Foundation
+# Copyright 2011 Piston Cloud Computing, Inc.
+# Copyright 2013 Alessio Ababilov
+# Copyright 2013 Grid Dynamics
+# Copyright 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+OpenStack Client interface. Handles the REST calls and responses.
+"""
+
+# E0202: An attribute inherited from %s hide this method
+# pylint: disable=E0202
+
+import logging
+import time
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+import requests
+
+from cinderclient.openstack.common.apiclient import exceptions
+from cinderclient.openstack.common import importutils
+
+
+_logger = logging.getLogger(__name__)
+
+
+class HTTPClient(object):
+    """This client handles sending HTTP requests to OpenStack servers.
+
+    Features:
+    - share authentication information between several clients to different
+      services (e.g., for compute and image clients);
+    - reissue authentication request for expired tokens;
+    - encode/decode JSON bodies;
+    - raise exceptions on HTTP errors;
+    - pluggable authentication;
+    - store authentication information in a keyring;
+    - store time spent for requests;
+    - register clients for particular services, so one can use
+      `http_client.identity` or `http_client.compute`;
+    - log requests and responses in a format that is easy to copy-and-paste
+      into terminal and send the same request with curl.
+    """
+
+    user_agent = "cinderclient.openstack.common.apiclient"
+
+    def __init__(self,
+                 auth_plugin,
+                 region_name=None,
+                 endpoint_type="publicURL",
+                 original_ip=None,
+                 verify=True,
+                 cert=None,
+                 timeout=None,
+                 timings=False,
+                 keyring_saver=None,
+                 debug=False,
+                 user_agent=None,
+                 http=None):
+        self.auth_plugin = auth_plugin
+
+        self.endpoint_type = endpoint_type
+        self.region_name = region_name
+
+        self.original_ip = original_ip
+        self.timeout = timeout
+        self.verify = verify
+        self.cert = cert
+
+        self.keyring_saver = keyring_saver
+        self.debug = debug
+        self.user_agent = user_agent or self.user_agent
+
+        self.times = []  # [("item", starttime, endtime), ...]
+        self.timings = timings
+
+        # requests within the same session can reuse TCP connections from pool
+        self.http = http or requests.Session()
+
+        self.cached_token = None
+
+    def _http_log_req(self, method, url, kwargs):
+        if not self.debug:
+            return
+
+        string_parts = [
+            "curl -i",
+            "-X '%s'" % method,
+            "'%s'" % url,
+        ]
+
+        for element in kwargs['headers']:
+            header = "-H '%s: %s'" % (element, kwargs['headers'][element])
+            string_parts.append(header)
+
+        _logger.debug("REQ: %s" % " ".join(string_parts))
+        if 'data' in kwargs:
+            _logger.debug("REQ BODY: %s\n" % (kwargs['data']))
+
+    def _http_log_resp(self, resp):
+        if not self.debug:
+            return
+        _logger.debug(
+            "RESP: [%s] %s\n",
+            resp.status_code,
+            resp.headers)
+        if resp._content_consumed:
+            _logger.debug(
+                "RESP BODY: %s\n",
+                resp.text)
+
+    def serialize(self, kwargs):
+        if kwargs.get('json') is not None:
+            kwargs['headers']['Content-Type'] = 'application/json'
+            kwargs['data'] = json.dumps(kwargs['json'])
+        try:
+            del kwargs['json']
+        except KeyError:
+            pass
+
+    def get_timings(self):
+        return self.times
+
+    def reset_timings(self):
+        self.times = []
+
+    def request(self, method, url, **kwargs):
+        """Send an http request with the specified characteristics.
+
+        Wrapper around `requests.Session.request` to handle tasks such as
+        setting headers, JSON encoding/decoding, and error handling.
+
+        :param method: method of HTTP request
+        :param url: URL of HTTP request
+        :param kwargs: any other parameter that can be passed to
+'            requests.Session.request (such as `headers`) or `json`
+             that will be encoded as JSON and used as `data` argument
+        """
+        kwargs.setdefault("headers", kwargs.get("headers", {}))
+        kwargs["headers"]["User-Agent"] = self.user_agent
+        if self.original_ip:
+            kwargs["headers"]["Forwarded"] = "for=%s;by=%s" % (
+                self.original_ip, self.user_agent)
+        if self.timeout is not None:
+            kwargs.setdefault("timeout", self.timeout)
+        kwargs.setdefault("verify", self.verify)
+        if self.cert is not None:
+            kwargs.setdefault("cert", self.cert)
+        self.serialize(kwargs)
+
+        self._http_log_req(method, url, kwargs)
+        if self.timings:
+            start_time = time.time()
+        resp = self.http.request(method, url, **kwargs)
+        if self.timings:
+            self.times.append(("%s %s" % (method, url),
+                               start_time, time.time()))
+        self._http_log_resp(resp)
+
+        if resp.status_code >= 400:
+            _logger.debug(
+                "Request returned failure status: %s",
+                resp.status_code)
+            raise exceptions.from_response(resp, method, url)
+
+        return resp
+
+    @staticmethod
+    def concat_url(endpoint, url):
+        """Concatenate endpoint and final URL.
+
+        E.g., "http://keystone/v2.0/" and "/tokens" are concatenated to
+        "http://keystone/v2.0/tokens".
+
+        :param endpoint: the base URL
+        :param url: the final URL
+        """
+        return "%s/%s" % (endpoint.rstrip("/"), url.strip("/"))
+
+    def client_request(self, client, method, url, **kwargs):
+        """Send an http request using `client`'s endpoint and specified `url`.
+
+        If request was rejected as unauthorized (possibly because the token is
+        expired), issue one authorization attempt and send the request once
+        again.
+
+        :param client: instance of BaseClient descendant
+        :param method: method of HTTP request
+        :param url: URL of HTTP request
+        :param kwargs: any other parameter that can be passed to
+'            `HTTPClient.request`
+        """
+
+        filter_args = {
+            "endpoint_type": client.endpoint_type or self.endpoint_type,
+            "service_type": client.service_type,
+        }
+        token, endpoint = (self.cached_token, client.cached_endpoint)
+        just_authenticated = False
+        if not (token and endpoint):
+            try:
+                token, endpoint = self.auth_plugin.token_and_endpoint(
+                    **filter_args)
+            except exceptions.EndpointException:
+                pass
+            if not (token and endpoint):
+                self.authenticate()
+                just_authenticated = True
+                token, endpoint = self.auth_plugin.token_and_endpoint(
+                    **filter_args)
+                if not (token and endpoint):
+                    raise exceptions.AuthorizationFailure(
+                        "Cannot find endpoint or token for request")
+
+        old_token_endpoint = (token, endpoint)
+        kwargs.setdefault("headers", {})["X-Auth-Token"] = token
+        self.cached_token = token
+        client.cached_endpoint = endpoint
+        # Perform the request once. If we get Unauthorized, then it
+        # might be because the auth token expired, so try to
+        # re-authenticate and try again. If it still fails, bail.
+        try:
+            return self.request(
+                method, self.concat_url(endpoint, url), **kwargs)
+        except exceptions.Unauthorized as unauth_ex:
+            if just_authenticated:
+                raise
+            self.cached_token = None
+            client.cached_endpoint = None
+            self.authenticate()
+            try:
+                token, endpoint = self.auth_plugin.token_and_endpoint(
+                    **filter_args)
+            except exceptions.EndpointException:
+                raise unauth_ex
+            if (not (token and endpoint) or
+                    old_token_endpoint == (token, endpoint)):
+                raise unauth_ex
+            self.cached_token = token
+            client.cached_endpoint = endpoint
+            kwargs["headers"]["X-Auth-Token"] = token
+            return self.request(
+                method, self.concat_url(endpoint, url), **kwargs)
+
+    def add_client(self, base_client_instance):
+        """Add a new instance of :class:`BaseClient` descendant.
+
+        `self` will store a reference to `base_client_instance`.
+
+        Example:
+
+        >>> def test_clients():
+        ...     from keystoneclient.auth import keystone
+        ...     from openstack.common.apiclient import client
+        ...     auth = keystone.KeystoneAuthPlugin(
+        ...         username="user", password="pass", tenant_name="tenant",
+        ...         auth_url="http://auth:5000/v2.0")
+        ...     openstack_client = client.HTTPClient(auth)
+        ...     # create nova client
+        ...     from novaclient.v1_1 import client
+        ...     client.Client(openstack_client)
+        ...     # create keystone client
+        ...     from keystoneclient.v2_0 import client
+        ...     client.Client(openstack_client)
+        ...     # use them
+        ...     openstack_client.identity.tenants.list()
+        ...     openstack_client.compute.servers.list()
+        """
+        service_type = base_client_instance.service_type
+        if service_type and not hasattr(self, service_type):
+            setattr(self, service_type, base_client_instance)
+
+    def authenticate(self):
+        self.auth_plugin.authenticate(self)
+        # Store the authentication results in the keyring for later requests
+        if self.keyring_saver:
+            self.keyring_saver.save(self)
+
+
+class BaseClient(object):
+    """Top-level object to access the OpenStack API.
+
+    This client uses :class:`HTTPClient` to send requests. :class:`HTTPClient`
+    will handle a bunch of issues such as authentication.
+    """
+
+    service_type = None
+    endpoint_type = None  # "publicURL" will be used
+    cached_endpoint = None
+
+    def __init__(self, http_client, extensions=None):
+        self.http_client = http_client
+        http_client.add_client(self)
+
+        # Add in any extensions...
+        if extensions:
+            for extension in extensions:
+                if extension.manager_class:
+                    setattr(self, extension.name,
+                            extension.manager_class(self))
+
+    def client_request(self, method, url, **kwargs):
+        return self.http_client.client_request(
+            self, method, url, **kwargs)
+
+    def head(self, url, **kwargs):
+        return self.client_request("HEAD", url, **kwargs)
+
+    def get(self, url, **kwargs):
+        return self.client_request("GET", url, **kwargs)
+
+    def post(self, url, **kwargs):
+        return self.client_request("POST", url, **kwargs)
+
+    def put(self, url, **kwargs):
+        return self.client_request("PUT", url, **kwargs)
+
+    def delete(self, url, **kwargs):
+        return self.client_request("DELETE", url, **kwargs)
+
+    def patch(self, url, **kwargs):
+        return self.client_request("PATCH", url, **kwargs)
+
+    @staticmethod
+    def get_class(api_name, version, version_map):
+        """Returns the client class for the requested API version
+
+        :param api_name: the name of the API, e.g. 'compute', 'image', etc
+        :param version: the requested API version
+        :param version_map: a dict of client classes keyed by version
+        :rtype: a client class for the requested API version
+        """
+        try:
+            client_path = version_map[str(version)]
+        except (KeyError, ValueError):
+            msg = "Invalid %s client version '%s'. must be one of: %s" % (
+                  (api_name, version, ', '.join(version_map.keys())))
+            raise exceptions.UnsupportedVersion(msg)
+
+        return importutils.import_class(client_path)

awx/lib/site-packages/cinderclient/openstack/common/apiclient/exceptions.py

@@ -0,0 +1,444 @@
+# Copyright 2010 Jacob Kaplan-Moss
+# Copyright 2011 Nebula, Inc.
+# Copyright 2013 Alessio Ababilov
+# Copyright 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Exception definitions.
+"""
+
+import inspect
+import sys
+
+import six
+
+
+class ClientException(Exception):
+    """The base exception class for all exceptions this library raises.
+    """
+    pass
+
+
+class MissingArgs(ClientException):
+    """Supplied arguments are not sufficient for calling a function."""
+    def __init__(self, missing):
+        self.missing = missing
+        msg = "Missing argument(s): %s" % ", ".join(missing)
+        super(MissingArgs, self).__init__(msg)
+
+
+class ValidationError(ClientException):
+    """Error in validation on API client side."""
+    pass
+
+
+class UnsupportedVersion(ClientException):
+    """User is trying to use an unsupported version of the API."""
+    pass
+
+
+class CommandError(ClientException):
+    """Error in CLI tool."""
+    pass
+
+
+class AuthorizationFailure(ClientException):
+    """Cannot authorize API client."""
+    pass
+
+
+class ConnectionRefused(ClientException):
+    """Cannot connect to API service."""
+    pass
+
+
+class AuthPluginOptionsMissing(AuthorizationFailure):
+    """Auth plugin misses some options."""
+    def __init__(self, opt_names):
+        super(AuthPluginOptionsMissing, self).__init__(
+            "Authentication failed. Missing options: %s" %
+            ", ".join(opt_names))
+        self.opt_names = opt_names
+
+
+class AuthSystemNotFound(AuthorizationFailure):
+    """User has specified a AuthSystem that is not installed."""
+    def __init__(self, auth_system):
+        super(AuthSystemNotFound, self).__init__(
+            "AuthSystemNotFound: %s" % repr(auth_system))
+        self.auth_system = auth_system
+
+
+class NoUniqueMatch(ClientException):
+    """Multiple entities found instead of one."""
+    pass
+
+
+class EndpointException(ClientException):
+    """Something is rotten in Service Catalog."""
+    pass
+
+
+class EndpointNotFound(EndpointException):
+    """Could not find requested endpoint in Service Catalog."""
+    pass
+
+
+class AmbiguousEndpoints(EndpointException):
+    """Found more than one matching endpoint in Service Catalog."""
+    def __init__(self, endpoints=None):
+        super(AmbiguousEndpoints, self).__init__(
+            "AmbiguousEndpoints: %s" % repr(endpoints))
+        self.endpoints = endpoints
+
+
+class HttpError(ClientException):
+    """The base exception class for all HTTP exceptions.
+    """
+    http_status = 0
+    message = "HTTP Error"
+
+    def __init__(self, message=None, details=None,
+                 response=None, request_id=None,
+                 url=None, method=None, http_status=None):
+        self.http_status = http_status or self.http_status
+        self.message = message or self.message
+        self.details = details
+        self.request_id = request_id
+        self.response = response
+        self.url = url
+        self.method = method
+        formatted_string = "%s (HTTP %s)" % (self.message, self.http_status)
+        if request_id:
+            formatted_string += " (Request-ID: %s)" % request_id
+        super(HttpError, self).__init__(formatted_string)
+
+
+class HTTPClientError(HttpError):
+    """Client-side HTTP error.
+
+    Exception for cases in which the client seems to have erred.
+    """
+    message = "HTTP Client Error"
+
+
+class HttpServerError(HttpError):
+    """Server-side HTTP error.
+
+    Exception for cases in which the server is aware that it has
+    erred or is incapable of performing the request.
+    """
+    message = "HTTP Server Error"
+
+
+class BadRequest(HTTPClientError):
+    """HTTP 400 - Bad Request.
+
+    The request cannot be fulfilled due to bad syntax.
+    """
+    http_status = 400
+    message = "Bad Request"
+
+
+class Unauthorized(HTTPClientError):
+    """HTTP 401 - Unauthorized.
+
+    Similar to 403 Forbidden, but specifically for use when authentication
+    is required and has failed or has not yet been provided.
+    """
+    http_status = 401
+    message = "Unauthorized"
+
+
+class PaymentRequired(HTTPClientError):
+    """HTTP 402 - Payment Required.
+
+    Reserved for future use.
+    """
+    http_status = 402
+    message = "Payment Required"
+
+
+class Forbidden(HTTPClientError):
+    """HTTP 403 - Forbidden.
+
+    The request was a valid request, but the server is refusing to respond
+    to it.
+    """
+    http_status = 403
+    message = "Forbidden"
+
+
+class NotFound(HTTPClientError):
+    """HTTP 404 - Not Found.
+
+    The requested resource could not be found but may be available again
+    in the future.
+    """
+    http_status = 404
+    message = "Not Found"
+
+
+class MethodNotAllowed(HTTPClientError):
+    """HTTP 405 - Method Not Allowed.
+
+    A request was made of a resource using a request method not supported
+    by that resource.
+    """
+    http_status = 405
+    message = "Method Not Allowed"
+
+
+class NotAcceptable(HTTPClientError):
+    """HTTP 406 - Not Acceptable.
+
+    The requested resource is only capable of generating content not
+    acceptable according to the Accept headers sent in the request.
+    """
+    http_status = 406
+    message = "Not Acceptable"
+
+
+class ProxyAuthenticationRequired(HTTPClientError):
+    """HTTP 407 - Proxy Authentication Required.
+
+    The client must first authenticate itself with the proxy.
+    """
+    http_status = 407
+    message = "Proxy Authentication Required"
+
+
+class RequestTimeout(HTTPClientError):
+    """HTTP 408 - Request Timeout.
+
+    The server timed out waiting for the request.
+    """
+    http_status = 408
+    message = "Request Timeout"
+
+
+class Conflict(HTTPClientError):
+    """HTTP 409 - Conflict.
+
+    Indicates that the request could not be processed because of conflict
+    in the request, such as an edit conflict.
+    """
+    http_status = 409
+    message = "Conflict"
+
+
+class Gone(HTTPClientError):
+    """HTTP 410 - Gone.
+
+    Indicates that the resource requested is no longer available and will
+    not be available again.
+    """
+    http_status = 410
+    message = "Gone"
+
+
+class LengthRequired(HTTPClientError):
+    """HTTP 411 - Length Required.
+
+    The request did not specify the length of its content, which is
+    required by the requested resource.
+    """
+    http_status = 411
+    message = "Length Required"
+
+
+class PreconditionFailed(HTTPClientError):
+    """HTTP 412 - Precondition Failed.
+
+    The server does not meet one of the preconditions that the requester
+    put on the request.
+    """
+    http_status = 412
+    message = "Precondition Failed"
+
+
+class RequestEntityTooLarge(HTTPClientError):
+    """HTTP 413 - Request Entity Too Large.
+
+    The request is larger than the server is willing or able to process.
+    """
+    http_status = 413
+    message = "Request Entity Too Large"
+
+    def __init__(self, *args, **kwargs):
+        try:
+            self.retry_after = int(kwargs.pop('retry_after'))
+        except (KeyError, ValueError):
+            self.retry_after = 0
+
+        super(RequestEntityTooLarge, self).__init__(*args, **kwargs)
+
+
+class RequestUriTooLong(HTTPClientError):
+    """HTTP 414 - Request-URI Too Long.
+
+    The URI provided was too long for the server to process.
+    """
+    http_status = 414
+    message = "Request-URI Too Long"
+
+
+class UnsupportedMediaType(HTTPClientError):
+    """HTTP 415 - Unsupported Media Type.
+
+    The request entity has a media type which the server or resource does
+    not support.
+    """
+    http_status = 415
+    message = "Unsupported Media Type"
+
+
+class RequestedRangeNotSatisfiable(HTTPClientError):
+    """HTTP 416 - Requested Range Not Satisfiable.
+
+    The client has asked for a portion of the file, but the server cannot
+    supply that portion.
+    """
+    http_status = 416
+    message = "Requested Range Not Satisfiable"
+
+
+class ExpectationFailed(HTTPClientError):
+    """HTTP 417 - Expectation Failed.
+
+    The server cannot meet the requirements of the Expect request-header field.
+    """
+    http_status = 417
+    message = "Expectation Failed"
+
+
+class UnprocessableEntity(HTTPClientError):
+    """HTTP 422 - Unprocessable Entity.
+
+    The request was well-formed but was unable to be followed due to semantic
+    errors.
+    """
+    http_status = 422
+    message = "Unprocessable Entity"
+
+
+class InternalServerError(HttpServerError):
+    """HTTP 500 - Internal Server Error.
+
+    A generic error message, given when no more specific message is suitable.
+    """
+    http_status = 500
+    message = "Internal Server Error"
+
+
+# NotImplemented is a python keyword.
+class HttpNotImplemented(HttpServerError):
+    """HTTP 501 - Not Implemented.
+
+    The server either does not recognize the request method, or it lacks
+    the ability to fulfill the request.
+    """
+    http_status = 501
+    message = "Not Implemented"
+
+
+class BadGateway(HttpServerError):
+    """HTTP 502 - Bad Gateway.
+
+    The server was acting as a gateway or proxy and received an invalid
+    response from the upstream server.
+    """
+    http_status = 502
+    message = "Bad Gateway"
+
+
+class ServiceUnavailable(HttpServerError):
+    """HTTP 503 - Service Unavailable.
+
+    The server is currently unavailable.
+    """
+    http_status = 503
+    message = "Service Unavailable"
+
+
+class GatewayTimeout(HttpServerError):
+    """HTTP 504 - Gateway Timeout.
+
+    The server was acting as a gateway or proxy and did not receive a timely
+    response from the upstream server.
+    """
+    http_status = 504
+    message = "Gateway Timeout"
+
+
+class HttpVersionNotSupported(HttpServerError):
+    """HTTP 505 - HttpVersion Not Supported.
+
+    The server does not support the HTTP protocol version used in the request.
+    """
+    http_status = 505
+    message = "HTTP Version Not Supported"
+
+
+# _code_map contains all the classes that have http_status attribute.
+_code_map = dict(
+    (getattr(obj, 'http_status', None), obj)
+    for name, obj in six.iteritems(vars(sys.modules[__name__]))
+    if inspect.isclass(obj) and getattr(obj, 'http_status', False)
+)
+
+
+def from_response(response, method, url):
+    """Returns an instance of :class:`HttpError` or subclass based on response.
+
+    :param response: instance of `requests.Response` class
+    :param method: HTTP method used for request
+    :param url: URL used for request
+    """
+    kwargs = {
+        "http_status": response.status_code,
+        "response": response,
+        "method": method,
+        "url": url,
+        "request_id": response.headers.get("x-compute-request-id"),
+    }
+    if "retry-after" in response.headers:
+        kwargs["retry_after"] = response.headers["retry-after"]
+
+    content_type = response.headers.get("Content-Type", "")
+    if content_type.startswith("application/json"):
+        try:
+            body = response.json()
+        except ValueError:
+            pass
+        else:
+            if hasattr(body, "keys"):
+                error = body[body.keys()[0]]
+                kwargs["message"] = error.get("message", None)
+                kwargs["details"] = error.get("details", None)
+    elif content_type.startswith("text/"):
+        kwargs["details"] = response.text
+
+    try:
+        cls = _code_map[response.status_code]
+    except KeyError:
+        if 500 <= response.status_code < 600:
+            cls = HttpServerError
+        elif 400 <= response.status_code < 500:
+            cls = HTTPClientError
+        else:
+            cls = HttpError
+    return cls(**kwargs)

awx/lib/site-packages/cinderclient/openstack/common/apiclient/fake_client.py

@@ -0,0 +1,173 @@
+# Copyright 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+A fake server that "responds" to API methods with pre-canned responses.
+
+All of these responses come from the spec, so if for some reason the spec's
+wrong the tests might raise AssertionError. I've indicated in comments the
+places where actual behavior differs from the spec.
+"""
+
+# W0102: Dangerous default value %s as argument
+# pylint: disable=W0102
+
+import json
+
+import requests
+import six
+from six.moves.urllib import parse
+
+from cinderclient.openstack.common.apiclient import client
+
+
+def assert_has_keys(dct, required=[], optional=[]):
+    for k in required:
+        try:
+            assert k in dct
+        except AssertionError:
+            extra_keys = set(dct.keys()).difference(set(required + optional))
+            raise AssertionError("found unexpected keys: %s" %
+                                 list(extra_keys))
+
+
+class TestResponse(requests.Response):
+    """Wrap requests.Response and provide a convenient initialization.
+    """
+
+    def __init__(self, data):
+        super(TestResponse, self).__init__()
+        self._content_consumed = True
+        if isinstance(data, dict):
+            self.status_code = data.get('status_code', 200)
+            # Fake the text attribute to streamline Response creation
+            text = data.get('text', "")
+            if isinstance(text, (dict, list)):
+                self._content = json.dumps(text)
+                default_headers = {
+                    "Content-Type": "application/json",
+                }
+            else:
+                self._content = text
+                default_headers = {}
+            if six.PY3 and isinstance(self._content, six.string_types):
+                self._content = self._content.encode('utf-8', 'strict')
+            self.headers = data.get('headers') or default_headers
+        else:
+            self.status_code = data
+
+    def __eq__(self, other):
+        return (self.status_code == other.status_code and
+                self.headers == other.headers and
+                self._content == other._content)
+
+
+class FakeHTTPClient(client.HTTPClient):
+
+    def __init__(self, *args, **kwargs):
+        self.callstack = []
+        self.fixtures = kwargs.pop("fixtures", None) or {}
+        if not args and not "auth_plugin" in kwargs:
+            args = (None, )
+        super(FakeHTTPClient, self).__init__(*args, **kwargs)
+
+    def assert_called(self, method, url, body=None, pos=-1):
+        """Assert than an API method was just called.
+        """
+        expected = (method, url)
+        called = self.callstack[pos][0:2]
+        assert self.callstack, \
+            "Expected %s %s but no calls were made." % expected
+
+        assert expected == called, 'Expected %s %s; got %s %s' % \
+            (expected + called)
+
+        if body is not None:
+            if self.callstack[pos][3] != body:
+                raise AssertionError('%r != %r' %
+                                     (self.callstack[pos][3], body))
+
+    def assert_called_anytime(self, method, url, body=None):
+        """Assert than an API method was called anytime in the test.
+        """
+        expected = (method, url)
+
+        assert self.callstack, \
+            "Expected %s %s but no calls were made." % expected
+
+        found = False
+        entry = None
+        for entry in self.callstack:
+            if expected == entry[0:2]:
+                found = True
+                break
+
+        assert found, 'Expected %s %s; got %s' % \
+            (method, url, self.callstack)
+        if body is not None:
+            assert entry[3] == body, "%s != %s" % (entry[3], body)
+
+        self.callstack = []
+
+    def clear_callstack(self):
+        self.callstack = []
+
+    def authenticate(self):
+        pass
+
+    def client_request(self, client, method, url, **kwargs):
+        # Check that certain things are called correctly
+        if method in ["GET", "DELETE"]:
+            assert "json" not in kwargs
+
+        # Note the call
+        self.callstack.append(
+            (method,
+             url,
+             kwargs.get("headers") or {},
+             kwargs.get("json") or kwargs.get("data")))
+        try:
+            fixture = self.fixtures[url][method]
+        except KeyError:
+            pass
+        else:
+            return TestResponse({"headers": fixture[0],
+                                 "text": fixture[1]})
+
+        # Call the method
+        args = parse.parse_qsl(parse.urlparse(url)[4])
+        kwargs.update(args)
+        munged_url = url.rsplit('?', 1)[0]
+        munged_url = munged_url.strip('/').replace('/', '_').replace('.', '_')
+        munged_url = munged_url.replace('-', '_')
+
+        callback = "%s_%s" % (method.lower(), munged_url)
+
+        if not hasattr(self, callback):
+            raise AssertionError('Called unknown API method: %s %s, '
+                                 'expected fakes method name: %s' %
+                                 (method, url, callback))
+
+        resp = getattr(self, callback)(**kwargs)
+        if len(resp) == 3:
+            status, headers, body = resp
+        else:
+            status, body = resp
+            headers = {}
+        return TestResponse({
+            "status_code": status,
+            "text": body,
+            "headers": headers,
+        })

awx/lib/site-packages/cinderclient/openstack/common/gettextutils.py

@@ -0,0 +1,479 @@
+# Copyright 2012 Red Hat, Inc.
+# Copyright 2013 IBM Corp.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+gettext for openstack-common modules.
+
+Usual usage in an openstack.common module:
+
+    from openstack.common.gettextutils import _
+"""
+
+import copy
+import gettext
+import locale
+from logging import handlers
+import os
+
+from babel import localedata
+import six
+
+_AVAILABLE_LANGUAGES = {}
+
+# FIXME(dhellmann): Remove this when moving to oslo.i18n.
+USE_LAZY = False
+
+
+class TranslatorFactory(object):
+    """Create translator functions
+    """
+
+    def __init__(self, domain, localedir=None):
+        """Establish a set of translation functions for the domain.
+
+        :param domain: Name of translation domain,
+                       specifying a message catalog.
+        :type domain: str
+        :param lazy: Delays translation until a message is emitted.
+                     Defaults to False.
+        :type lazy: Boolean
+        :param localedir: Directory with translation catalogs.
+        :type localedir: str
+        """
+        self.domain = domain
+        if localedir is None:
+            localedir = os.environ.get(domain.upper() + '_LOCALEDIR')
+        self.localedir = localedir
+
+    def _make_translation_func(self, domain=None):
+        """Return a new translation function ready for use.
+
+        Takes into account whether or not lazy translation is being
+        done.
+
+        The domain can be specified to override the default from the
+        factory, but the localedir from the factory is always used
+        because we assume the log-level translation catalogs are
+        installed in the same directory as the main application
+        catalog.
+
+        """
+        if domain is None:
+            domain = self.domain
+        t = gettext.translation(domain,
+                                localedir=self.localedir,
+                                fallback=True)
+        # Use the appropriate method of the translation object based
+        # on the python version.
+        m = t.gettext if six.PY3 else t.ugettext
+
+        def f(msg):
+            """oslo.i18n.gettextutils translation function."""
+            if USE_LAZY:
+                return Message(msg, domain=domain)
+            return m(msg)
+        return f
+
+    @property
+    def primary(self):
+        "The default translation function."
+        return self._make_translation_func()
+
+    def _make_log_translation_func(self, level):
+        return self._make_translation_func(self.domain + '-log-' + level)
+
+    @property
+    def log_info(self):
+        "Translate info-level log messages."
+        return self._make_log_translation_func('info')
+
+    @property
+    def log_warning(self):
+        "Translate warning-level log messages."
+        return self._make_log_translation_func('warning')
+
+    @property
+    def log_error(self):
+        "Translate error-level log messages."
+        return self._make_log_translation_func('error')
+
+    @property
+    def log_critical(self):
+        "Translate critical-level log messages."
+        return self._make_log_translation_func('critical')
+
+
+# NOTE(dhellmann): When this module moves out of the incubator into
+# oslo.i18n, these global variables can be moved to an integration
+# module within each application.
+
+# Create the global translation functions.
+_translators = TranslatorFactory('cinderclient')
+
+# The primary translation function using the well-known name "_"
+_ = _translators.primary
+
+# Translators for log levels.
+#
+# The abbreviated names are meant to reflect the usual use of a short
+# name like '_'. The "L" is for "log" and the other letter comes from
+# the level.
+_LI = _translators.log_info
+_LW = _translators.log_warning
+_LE = _translators.log_error
+_LC = _translators.log_critical
+
+# NOTE(dhellmann): End of globals that will move to the application's
+# integration module.
+
+
+def enable_lazy():
+    """Convenience function for configuring _() to use lazy gettext
+
+    Call this at the start of execution to enable the gettextutils._
+    function to use lazy gettext functionality. This is useful if
+    your project is importing _ directly instead of using the
+    gettextutils.install() way of importing the _ function.
+    """
+    global USE_LAZY
+    USE_LAZY = True
+
+
+def install(domain):
+    """Install a _() function using the given translation domain.
+
+    Given a translation domain, install a _() function using gettext's
+    install() function.
+
+    The main difference from gettext.install() is that we allow
+    overriding the default localedir (e.g. /usr/share/locale) using
+    a translation-domain-specific environment variable (e.g.
+    NOVA_LOCALEDIR).
+
+    Note that to enable lazy translation, enable_lazy must be
+    called.
+
+    :param domain: the translation domain
+    """
+    from six import moves
+    tf = TranslatorFactory(domain)
+    moves.builtins.__dict__['_'] = tf.primary
+
+
+class Message(six.text_type):
+    """A Message object is a unicode object that can be translated.
+
+    Translation of Message is done explicitly using the translate() method.
+    For all non-translation intents and purposes, a Message is simply unicode,
+    and can be treated as such.
+    """
+
+    def __new__(cls, msgid, msgtext=None, params=None,
+                domain='cinderclient', *args):
+        """Create a new Message object.
+
+        In order for translation to work gettext requires a message ID, this
+        msgid will be used as the base unicode text. It is also possible
+        for the msgid and the base unicode text to be different by passing
+        the msgtext parameter.
+        """
+        # If the base msgtext is not given, we use the default translation
+        # of the msgid (which is in English) just in case the system locale is
+        # not English, so that the base text will be in that locale by default.
+        if not msgtext:
+            msgtext = Message._translate_msgid(msgid, domain)
+        # We want to initialize the parent unicode with the actual object that
+        # would have been plain unicode if 'Message' was not enabled.
+        msg = super(Message, cls).__new__(cls, msgtext)
+        msg.msgid = msgid
+        msg.domain = domain
+        msg.params = params
+        return msg
+
+    def translate(self, desired_locale=None):
+        """Translate this message to the desired locale.
+
+        :param desired_locale: The desired locale to translate the message to,
+                               if no locale is provided the message will be
+                               translated to the system's default locale.
+
+        :returns: the translated message in unicode
+        """
+
+        translated_message = Message._translate_msgid(self.msgid,
+                                                      self.domain,
+                                                      desired_locale)
+        if self.params is None:
+            # No need for more translation
+            return translated_message
+
+        # This Message object may have been formatted with one or more
+        # Message objects as substitution arguments, given either as a single
+        # argument, part of a tuple, or as one or more values in a dictionary.
+        # When translating this Message we need to translate those Messages too
+        translated_params = _translate_args(self.params, desired_locale)
+
+        translated_message = translated_message % translated_params
+
+        return translated_message
+
+    @staticmethod
+    def _translate_msgid(msgid, domain, desired_locale=None):
+        if not desired_locale:
+            system_locale = locale.getdefaultlocale()
+            # If the system locale is not available to the runtime use English
+            if not system_locale[0]:
+                desired_locale = 'en_US'
+            else:
+                desired_locale = system_locale[0]
+
+        locale_dir = os.environ.get(domain.upper() + '_LOCALEDIR')
+        lang = gettext.translation(domain,
+                                   localedir=locale_dir,
+                                   languages=[desired_locale],
+                                   fallback=True)
+        if six.PY3:
+            translator = lang.gettext
+        else:
+            translator = lang.ugettext
+
+        translated_message = translator(msgid)
+        return translated_message
+
+    def __mod__(self, other):
+        # When we mod a Message we want the actual operation to be performed
+        # by the parent class (i.e. unicode()), the only thing  we do here is
+        # save the original msgid and the parameters in case of a translation
+        params = self._sanitize_mod_params(other)
+        unicode_mod = super(Message, self).__mod__(params)
+        modded = Message(self.msgid,
+                         msgtext=unicode_mod,
+                         params=params,
+                         domain=self.domain)
+        return modded
+
+    def _sanitize_mod_params(self, other):
+        """Sanitize the object being modded with this Message.
+
+        - Add support for modding 'None' so translation supports it
+        - Trim the modded object, which can be a large dictionary, to only
+        those keys that would actually be used in a translation
+        - Snapshot the object being modded, in case the message is
+        translated, it will be used as it was when the Message was created
+        """
+        if other is None:
+            params = (other,)
+        elif isinstance(other, dict):
+            # Merge the dictionaries
+            # Copy each item in case one does not support deep copy.
+            params = {}
+            if isinstance(self.params, dict):
+                for key, val in self.params.items():
+                    params[key] = self._copy_param(val)
+            for key, val in other.items():
+                params[key] = self._copy_param(val)
+        else:
+            params = self._copy_param(other)
+        return params
+
+    def _copy_param(self, param):
+        try:
+            return copy.deepcopy(param)
+        except Exception:
+            # Fallback to casting to unicode this will handle the
+            # python code-like objects that can't be deep-copied
+            return six.text_type(param)
+
+    def __add__(self, other):
+        msg = _('Message objects do not support addition.')
+        raise TypeError(msg)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    if six.PY2:
+        def __str__(self):
+            # NOTE(luisg): Logging in python 2.6 tries to str() log records,
+            # and it expects specifically a UnicodeError in order to proceed.
+            msg = _('Message objects do not support str() because they may '
+                    'contain non-ascii characters. '
+                    'Please use unicode() or translate() instead.')
+            raise UnicodeError(msg)
+
+
+def get_available_languages(domain):
+    """Lists the available languages for the given translation domain.
+
+    :param domain: the domain to get languages for
+    """
+    if domain in _AVAILABLE_LANGUAGES:
+        return copy.copy(_AVAILABLE_LANGUAGES[domain])
+
+    localedir = '%s_LOCALEDIR' % domain.upper()
+    find = lambda x: gettext.find(domain,
+                                  localedir=os.environ.get(localedir),
+                                  languages=[x])
+
+    # NOTE(mrodden): en_US should always be available (and first in case
+    # order matters) since our in-line message strings are en_US
+    language_list = ['en_US']
+    # NOTE(luisg): Babel <1.0 used a function called list(), which was
+    # renamed to locale_identifiers() in >=1.0, the requirements master list
+    # requires >=0.9.6, uncapped, so defensively work with both. We can remove
+    # this check when the master list updates to >=1.0, and update all projects
+    list_identifiers = (getattr(localedata, 'list', None) or
+                        getattr(localedata, 'locale_identifiers'))
+    locale_identifiers = list_identifiers()
+
+    for i in locale_identifiers:
+        if find(i) is not None:
+            language_list.append(i)
+
+    # NOTE(luisg): Babel>=1.0,<1.3 has a bug where some OpenStack supported
+    # locales (e.g. 'zh_CN', and 'zh_TW') aren't supported even though they
+    # are perfectly legitimate locales:
+    #     https://github.com/mitsuhiko/babel/issues/37
+    # In Babel 1.3 they fixed the bug and they support these locales, but
+    # they are still not explicitly "listed" by locale_identifiers().
+    # That is  why we add the locales here explicitly if necessary so that
+    # they are listed as supported.
+    aliases = {'zh': 'zh_CN',
+               'zh_Hant_HK': 'zh_HK',
+               'zh_Hant': 'zh_TW',
+               'fil': 'tl_PH'}
+    for (locale_, alias) in six.iteritems(aliases):
+        if locale_ in language_list and alias not in language_list:
+            language_list.append(alias)
+
+    _AVAILABLE_LANGUAGES[domain] = language_list
+    return copy.copy(language_list)
+
+
+def translate(obj, desired_locale=None):
+    """Gets the translated unicode representation of the given object.
+
+    If the object is not translatable it is returned as-is.
+    If the locale is None the object is translated to the system locale.
+
+    :param obj: the object to translate
+    :param desired_locale: the locale to translate the message to, if None the
+                           default system locale will be used
+    :returns: the translated object in unicode, or the original object if
+              it could not be translated
+    """
+    message = obj
+    if not isinstance(message, Message):
+        # If the object to translate is not already translatable,
+        # let's first get its unicode representation
+        message = six.text_type(obj)
+    if isinstance(message, Message):
+        # Even after unicoding() we still need to check if we are
+        # running with translatable unicode before translating
+        return message.translate(desired_locale)
+    return obj
+
+
+def _translate_args(args, desired_locale=None):
+    """Translates all the translatable elements of the given arguments object.
+
+    This method is used for translating the translatable values in method
+    arguments which include values of tuples or dictionaries.
+    If the object is not a tuple or a dictionary the object itself is
+    translated if it is translatable.
+
+    If the locale is None the object is translated to the system locale.
+
+    :param args: the args to translate
+    :param desired_locale: the locale to translate the args to, if None the
+                           default system locale will be used
+    :returns: a new args object with the translated contents of the original
+    """
+    if isinstance(args, tuple):
+        return tuple(translate(v, desired_locale) for v in args)
+    if isinstance(args, dict):
+        translated_dict = {}
+        for (k, v) in six.iteritems(args):
+            translated_v = translate(v, desired_locale)
+            translated_dict[k] = translated_v
+        return translated_dict
+    return translate(args, desired_locale)
+
+
+class TranslationHandler(handlers.MemoryHandler):
+    """Handler that translates records before logging them.
+
+    The TranslationHandler takes a locale and a target logging.Handler object
+    to forward LogRecord objects to after translating them. This handler
+    depends on Message objects being logged, instead of regular strings.
+
+    The handler can be configured declaratively in the logging.conf as follows:
+
+        [handlers]
+        keys = translatedlog, translator
+
+        [handler_translatedlog]
+        class = handlers.WatchedFileHandler
+        args = ('/var/log/api-localized.log',)
+        formatter = context
+
+        [handler_translator]
+        class = openstack.common.log.TranslationHandler
+        target = translatedlog
+        args = ('zh_CN',)
+
+    If the specified locale is not available in the system, the handler will
+    log in the default locale.
+    """
+
+    def __init__(self, locale=None, target=None):
+        """Initialize a TranslationHandler
+
+        :param locale: locale to use for translating messages
+        :param target: logging.Handler object to forward
+                       LogRecord objects to after translation
+        """
+        # NOTE(luisg): In order to allow this handler to be a wrapper for
+        # other handlers, such as a FileHandler, and still be able to
+        # configure it using logging.conf, this handler has to extend
+        # MemoryHandler because only the MemoryHandlers' logging.conf
+        # parsing is implemented such that it accepts a target handler.
+        handlers.MemoryHandler.__init__(self, capacity=0, target=target)
+        self.locale = locale
+
+    def setFormatter(self, fmt):
+        self.target.setFormatter(fmt)
+
+    def emit(self, record):
+        # We save the message from the original record to restore it
+        # after translation, so other handlers are not affected by this
+        original_msg = record.msg
+        original_args = record.args
+
+        try:
+            self._translate_and_log_record(record)
+        finally:
+            record.msg = original_msg
+            record.args = original_args
+
+    def _translate_and_log_record(self, record):
+        record.msg = translate(record.msg, self.locale)
+
+        # In addition to translating the message, we also need to translate
+        # arguments that were passed to the log method that were not part
+        # of the main message e.g., log.info(_('Some message %s'), this_one))
+        record.args = _translate_args(record.args, self.locale)
+
+        self.target.emit(record)

awx/lib/site-packages/cinderclient/openstack/common/importutils.py

@@ -0,0 +1,66 @@
+# Copyright 2011 OpenStack Foundation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Import related utilities and helper functions.
+"""
+
+import sys
+import traceback
+
+
+def import_class(import_str):
+    """Returns a class from a string including module and class."""
+    mod_str, _sep, class_str = import_str.rpartition('.')
+    try:
+        __import__(mod_str)
+        return getattr(sys.modules[mod_str], class_str)
+    except (ValueError, AttributeError):
+        raise ImportError('Class %s cannot be found (%s)' %
+                          (class_str,
+                           traceback.format_exception(*sys.exc_info())))
+
+
+def import_object(import_str, *args, **kwargs):
+    """Import a class and return an instance of it."""
+    return import_class(import_str)(*args, **kwargs)
+
+
+def import_object_ns(name_space, import_str, *args, **kwargs):
+    """Tries to import object from default namespace.
+
+    Imports a class and return an instance of it, first by trying
+    to find the class in a default namespace, then failing back to
+    a full path if not found in the default namespace.
+    """
+    import_value = "%s.%s" % (name_space, import_str)
+    try:
+        return import_class(import_value)(*args, **kwargs)
+    except ImportError:
+        return import_class(import_str)(*args, **kwargs)
+
+
+def import_module(import_str):
+    """Import a module."""
+    __import__(import_str)
+    return sys.modules[import_str]
+
+
+def try_import(import_str, default=None):
+    """Try to import a module and if it fails return default."""
+    try:
+        return import_module(import_str)
+    except ImportError:
+        return default

awx/lib/site-packages/cinderclient/openstack/common/strutils.py

@@ -0,0 +1,295 @@
+# Copyright 2011 OpenStack Foundation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+System-level utilities and helper functions.
+"""
+
+import math
+import re
+import sys
+import unicodedata
+
+import six
+
+from cinderclient.openstack.common.gettextutils import _
+
+
+UNIT_PREFIX_EXPONENT = {
+    'k': 1,
+    'K': 1,
+    'Ki': 1,
+    'M': 2,
+    'Mi': 2,
+    'G': 3,
+    'Gi': 3,
+    'T': 4,
+    'Ti': 4,
+}
+UNIT_SYSTEM_INFO = {
+    'IEC': (1024, re.compile(r'(^[-+]?\d*\.?\d+)([KMGT]i?)?(b|bit|B)$')),
+    'SI': (1000, re.compile(r'(^[-+]?\d*\.?\d+)([kMGT])?(b|bit|B)$')),
+}
+
+TRUE_STRINGS = ('1', 't', 'true', 'on', 'y', 'yes')
+FALSE_STRINGS = ('0', 'f', 'false', 'off', 'n', 'no')
+
+SLUGIFY_STRIP_RE = re.compile(r"[^\w\s-]")
+SLUGIFY_HYPHENATE_RE = re.compile(r"[-\s]+")
+
+
+# NOTE(flaper87): The following 3 globals are used by `mask_password`
+_SANITIZE_KEYS = ['adminPass', 'admin_pass', 'password', 'admin_password']
+
+# NOTE(ldbragst): Let's build a list of regex objects using the list of
+# _SANITIZE_KEYS we already have. This way, we only have to add the new key
+# to the list of _SANITIZE_KEYS and we can generate regular expressions
+# for XML and JSON automatically.
+_SANITIZE_PATTERNS = []
+_FORMAT_PATTERNS = [r'(%(key)s\s*[=]\s*[\"\']).*?([\"\'])',
+                    r'(<%(key)s>).*?(</%(key)s>)',
+                    r'([\"\']%(key)s[\"\']\s*:\s*[\"\']).*?([\"\'])',
+                    r'([\'"].*?%(key)s[\'"]\s*:\s*u?[\'"]).*?([\'"])',
+                    r'([\'"].*?%(key)s[\'"]\s*,\s*\'--?[A-z]+\'\s*,\s*u?[\'"])'
+                    '.*?([\'"])',
+                    r'(%(key)s\s*--?[A-z]+\s*)\S+(\s*)']
+
+for key in _SANITIZE_KEYS:
+    for pattern in _FORMAT_PATTERNS:
+        reg_ex = re.compile(pattern % {'key': key}, re.DOTALL)
+        _SANITIZE_PATTERNS.append(reg_ex)
+
+
+def int_from_bool_as_string(subject):
+    """Interpret a string as a boolean and return either 1 or 0.
+
+    Any string value in:
+
+        ('True', 'true', 'On', 'on', '1')
+
+    is interpreted as a boolean True.
+
+    Useful for JSON-decoded stuff and config file parsing
+    """
+    return bool_from_string(subject) and 1 or 0
+
+
+def bool_from_string(subject, strict=False, default=False):
+    """Interpret a string as a boolean.
+
+    A case-insensitive match is performed such that strings matching 't',
+    'true', 'on', 'y', 'yes', or '1' are considered True and, when
+    `strict=False`, anything else returns the value specified by 'default'.
+
+    Useful for JSON-decoded stuff and config file parsing.
+
+    If `strict=True`, unrecognized values, including None, will raise a
+    ValueError which is useful when parsing values passed in from an API call.
+    Strings yielding False are 'f', 'false', 'off', 'n', 'no', or '0'.
+    """
+    if not isinstance(subject, six.string_types):
+        subject = six.text_type(subject)
+
+    lowered = subject.strip().lower()
+
+    if lowered in TRUE_STRINGS:
+        return True
+    elif lowered in FALSE_STRINGS:
+        return False
+    elif strict:
+        acceptable = ', '.join(
+            "'%s'" % s for s in sorted(TRUE_STRINGS + FALSE_STRINGS))
+        msg = _("Unrecognized value '%(val)s', acceptable values are:"
+                " %(acceptable)s") % {'val': subject,
+                                      'acceptable': acceptable}
+        raise ValueError(msg)
+    else:
+        return default
+
+
+def safe_decode(text, incoming=None, errors='strict'):
+    """Decodes incoming text/bytes string using `incoming` if they're not
+       already unicode.
+
+    :param incoming: Text's current encoding
+    :param errors: Errors handling policy. See here for valid
+        values http://docs.python.org/2/library/codecs.html
+    :returns: text or a unicode `incoming` encoded
+                representation of it.
+    :raises TypeError: If text is not an instance of str
+    """
+    if not isinstance(text, (six.string_types, six.binary_type)):
+        raise TypeError("%s can't be decoded" % type(text))
+
+    if isinstance(text, six.text_type):
+        return text
+
+    if not incoming:
+        incoming = (sys.stdin.encoding or
+                    sys.getdefaultencoding())
+
+    try:
+        return text.decode(incoming, errors)
+    except UnicodeDecodeError:
+        # Note(flaper87) If we get here, it means that
+        # sys.stdin.encoding / sys.getdefaultencoding
+        # didn't return a suitable encoding to decode
+        # text. This happens mostly when global LANG
+        # var is not set correctly and there's no
+        # default encoding. In this case, most likely
+        # python will use ASCII or ANSI encoders as
+        # default encodings but they won't be capable
+        # of decoding non-ASCII characters.
+        #
+        # Also, UTF-8 is being used since it's an ASCII
+        # extension.
+        return text.decode('utf-8', errors)
+
+
+def safe_encode(text, incoming=None,
+                encoding='utf-8', errors='strict'):
+    """Encodes incoming text/bytes string using `encoding`.
+
+    If incoming is not specified, text is expected to be encoded with
+    current python's default encoding. (`sys.getdefaultencoding`)
+
+    :param incoming: Text's current encoding
+    :param encoding: Expected encoding for text (Default UTF-8)
+    :param errors: Errors handling policy. See here for valid
+        values http://docs.python.org/2/library/codecs.html
+    :returns: text or a bytestring `encoding` encoded
+                representation of it.
+    :raises TypeError: If text is not an instance of str
+    """
+    if not isinstance(text, (six.string_types, six.binary_type)):
+        raise TypeError("%s can't be encoded" % type(text))
+
+    if not incoming:
+        incoming = (sys.stdin.encoding or
+                    sys.getdefaultencoding())
+
+    if isinstance(text, six.text_type):
+        return text.encode(encoding, errors)
+    elif text and encoding != incoming:
+        # Decode text before encoding it with `encoding`
+        text = safe_decode(text, incoming, errors)
+        return text.encode(encoding, errors)
+    else:
+        return text
+
+
+def string_to_bytes(text, unit_system='IEC', return_int=False):
+    """Converts a string into an float representation of bytes.
+
+    The units supported for IEC ::
+
+        Kb(it), Kib(it), Mb(it), Mib(it), Gb(it), Gib(it), Tb(it), Tib(it)
+        KB, KiB, MB, MiB, GB, GiB, TB, TiB
+
+    The units supported for SI ::
+
+        kb(it), Mb(it), Gb(it), Tb(it)
+        kB, MB, GB, TB
+
+    Note that the SI unit system does not support capital letter 'K'
+
+    :param text: String input for bytes size conversion.
+    :param unit_system: Unit system for byte size conversion.
+    :param return_int: If True, returns integer representation of text
+                       in bytes. (default: decimal)
+    :returns: Numerical representation of text in bytes.
+    :raises ValueError: If text has an invalid value.
+
+    """
+    try:
+        base, reg_ex = UNIT_SYSTEM_INFO[unit_system]
+    except KeyError:
+        msg = _('Invalid unit system: "%s"') % unit_system
+        raise ValueError(msg)
+    match = reg_ex.match(text)
+    if match:
+        magnitude = float(match.group(1))
+        unit_prefix = match.group(2)
+        if match.group(3) in ['b', 'bit']:
+            magnitude /= 8
+    else:
+        msg = _('Invalid string format: %s') % text
+        raise ValueError(msg)
+    if not unit_prefix:
+        res = magnitude
+    else:
+        res = magnitude * pow(base, UNIT_PREFIX_EXPONENT[unit_prefix])
+    if return_int:
+        return int(math.ceil(res))
+    return res
+
+
+def to_slug(value, incoming=None, errors="strict"):
+    """Normalize string.
+
+    Convert to lowercase, remove non-word characters, and convert spaces
+    to hyphens.
+
+    Inspired by Django's `slugify` filter.
+
+    :param value: Text to slugify
+    :param incoming: Text's current encoding
+    :param errors: Errors handling policy. See here for valid
+        values http://docs.python.org/2/library/codecs.html
+    :returns: slugified unicode representation of `value`
+    :raises TypeError: If text is not an instance of str
+    """
+    value = safe_decode(value, incoming, errors)
+    # NOTE(aababilov): no need to use safe_(encode|decode) here:
+    # encodings are always "ascii", error handling is always "ignore"
+    # and types are always known (first: unicode; second: str)
+    value = unicodedata.normalize("NFKD", value).encode(
+        "ascii", "ignore").decode("ascii")
+    value = SLUGIFY_STRIP_RE.sub("", value).strip().lower()
+    return SLUGIFY_HYPHENATE_RE.sub("-", value)
+
+
+def mask_password(message, secret="***"):
+    """Replace password with 'secret' in message.
+
+    :param message: The string which includes security information.
+    :param secret: value with which to replace passwords.
+    :returns: The unicode value of message with the password fields masked.
+
+    For example:
+
+    >>> mask_password("'adminPass' : 'aaaaa'")
+    "'adminPass' : '***'"
+    >>> mask_password("'admin_pass' : 'aaaaa'")
+    "'admin_pass' : '***'"
+    >>> mask_password('"password" : "aaaaa"')
+    '"password" : "***"'
+    >>> mask_password("'original_password' : 'aaaaa'")
+    "'original_password' : '***'"
+    >>> mask_password("u'original_password' :   u'aaaaa'")
+    "u'original_password' :   u'***'"
+    """
+    message = six.text_type(message)
+
+    # NOTE(ldbragst): Check to see if anything in message contains any key
+    # specified in _SANITIZE_KEYS, if not then just return the message since
+    # we don't have to mask any passwords.
+    if not any(key in message for key in _SANITIZE_KEYS):
+        return message
+
+    secret = r'\g<1>' + secret + r'\g<2>'
+    for pattern in _SANITIZE_PATTERNS:
+        message = re.sub(pattern, secret, message)
+    return message

awx/lib/site-packages/cinderclient/service_catalog.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2011 OpenStack Foundation
+# Copyright 2011, Piston Cloud Computing, Inc.
+#
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import cinderclient.exceptions
+
+
+class ServiceCatalog(object):
+    """Helper methods for dealing with a Keystone Service Catalog."""
+
+    def __init__(self, resource_dict):
+        self.catalog = resource_dict
+
+    def get_token(self):
+        return self.catalog['access']['token']['id']
+
+    def url_for(self, attr=None, filter_value=None,
+                service_type=None, endpoint_type='publicURL',
+                service_name=None, volume_service_name=None):
+        """Fetch the public URL from the Compute service for
+        a particular endpoint attribute. If none given, return
+        the first. See tests for sample service catalog.
+        """
+        matching_endpoints = []
+        if 'endpoints' in self.catalog:
+            # We have a bastardized service catalog. Treat it special. :/
+            for endpoint in self.catalog['endpoints']:
+                if not filter_value or endpoint[attr] == filter_value:
+                    matching_endpoints.append(endpoint)
+            if not matching_endpoints:
+                raise cinderclient.exceptions.EndpointNotFound()
+
+        # We don't always get a service catalog back ...
+        if 'serviceCatalog' not in self.catalog['access']:
+            return None
+
+        # Full catalog ...
+        catalog = self.catalog['access']['serviceCatalog']
+
+        for service in catalog:
+
+            # NOTE(thingee): For backwards compatibility, if they have v2
+            # enabled and the service_type is set to 'volume', go ahead and
+            # accept that.
+            skip_service_type_check = False
+            if service_type == 'volumev2' and service['type'] == 'volume':
+                version = service['endpoints'][0]['publicURL'].split('/')[3]
+                if version == 'v2':
+                    skip_service_type_check = True
+
+            if (not skip_service_type_check
+                    and service.get("type") != service_type):
+                continue
+
+            if (volume_service_name and service_type in ('volume', 'volumev2')
+                    and service.get('name') != volume_service_name):
+                continue
+
+            endpoints = service['endpoints']
+            for endpoint in endpoints:
+                if not filter_value or endpoint.get(attr) == filter_value:
+                    endpoint["serviceName"] = service.get("name")
+                    matching_endpoints.append(endpoint)
+
+        if not matching_endpoints:
+            raise cinderclient.exceptions.EndpointNotFound()
+        elif len(matching_endpoints) > 1:
+            try:
+                eplist = [ep[attr] for ep in matching_endpoints]
+            except KeyError:
+                eplist = matching_endpoints
+            raise cinderclient.exceptions.AmbiguousEndpoints(endpoints=eplist)
+        else:
+            return matching_endpoints[0][endpoint_type]

awx/lib/site-packages/cinderclient/shell.py

@@ -0,0 +1,858 @@
+
+# Copyright 2011-2014 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Command-line interface to the OpenStack Cinder API.
+"""
+
+from __future__ import print_function
+
+import argparse
+import glob
+import imp
+import itertools
+import logging
+import os
+import pkgutil
+import sys
+
+import requests
+
+from cinderclient import client
+from cinderclient import exceptions as exc
+from cinderclient import utils
+import cinderclient.auth_plugin
+import cinderclient.extension
+from cinderclient.openstack.common import strutils
+from cinderclient.openstack.common.gettextutils import _
+from cinderclient.v1 import shell as shell_v1
+from cinderclient.v2 import shell as shell_v2
+
+from keystoneclient import discover
+from keystoneclient import session
+from keystoneclient.auth.identity import v2 as v2_auth
+from keystoneclient.auth.identity import v3 as v3_auth
+from keystoneclient.exceptions import DiscoveryFailure
+import six.moves.urllib.parse as urlparse
+
+
+DEFAULT_OS_VOLUME_API_VERSION = "1"
+DEFAULT_CINDER_ENDPOINT_TYPE = 'publicURL'
+DEFAULT_CINDER_SERVICE_TYPE = 'volume'
+
+logging.basicConfig()
+logger = logging.getLogger(__name__)
+
+
+class CinderClientArgumentParser(argparse.ArgumentParser):
+
+    def __init__(self, *args, **kwargs):
+        super(CinderClientArgumentParser, self).__init__(*args, **kwargs)
+
+    def error(self, message):
+        """error(message: string)
+
+        Prints a usage message incorporating the message to stderr and
+        exits.
+        """
+        self.print_usage(sys.stderr)
+        # FIXME(lzyeval): if changes occur in argparse.ArgParser._check_value
+        choose_from = ' (choose from'
+        progparts = self.prog.partition(' ')
+        self.exit(2, "error: %(errmsg)s\nTry '%(mainp)s help %(subp)s'"
+                     " for more information.\n" %
+                     {'errmsg': message.split(choose_from)[0],
+                      'mainp': progparts[0],
+                      'subp': progparts[2]})
+
+    def _get_option_tuples(self, option_string):
+        """Avoid ambiguity in argument abbreviation.
+
+        The idea of this method is to override the default behaviour to
+        avoid ambiguity in the abbreviation feature of argparse.
+        In the case that the ambiguity is generated by 2 or more parameters
+        and only one is visible in the help and the others are with
+        help=argparse.SUPPRESS, the ambiguity is solved by taking the visible
+        one.
+        The use case is for parameters that are left hidden for backward
+        compatibility.
+        """
+
+        result = super(CinderClientArgumentParser, self)._get_option_tuples(
+            option_string)
+
+        if len(result) > 1:
+            aux = [x for x in result if x[0].help != argparse.SUPPRESS]
+            if len(aux) == 1:
+                result = aux
+
+        return result
+
+
+class OpenStackCinderShell(object):
+
+    def get_base_parser(self):
+        parser = CinderClientArgumentParser(
+            prog='cinder',
+            description=__doc__.strip(),
+            epilog='Run "cinder help SUBCOMMAND" for help on a subcommand.',
+            add_help=False,
+            formatter_class=OpenStackHelpFormatter,
+        )
+
+        # Global arguments
+        parser.add_argument('-h', '--help',
+                            action='store_true',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--version',
+                            action='version',
+                            version=cinderclient.__version__)
+
+        parser.add_argument('--debug',
+                            action='store_true',
+                            default=utils.env('CINDERCLIENT_DEBUG',
+                                              default=False),
+                            help="Shows debugging output.")
+
+        parser.add_argument('--os-auth-system',
+                            metavar='<auth-system>',
+                            default=utils.env('OS_AUTH_SYSTEM'),
+                            help='Defaults to env[OS_AUTH_SYSTEM].')
+        parser.add_argument('--os_auth_system',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--service-type',
+                            metavar='<service-type>',
+                            help='Service type. '
+                            'For most actions, default is volume.')
+        parser.add_argument('--service_type',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--service-name',
+                            metavar='<service-name>',
+                            default=utils.env('CINDER_SERVICE_NAME'),
+                            help='Service name. '
+                            'Default=env[CINDER_SERVICE_NAME].')
+        parser.add_argument('--service_name',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--volume-service-name',
+                            metavar='<volume-service-name>',
+                            default=utils.env('CINDER_VOLUME_SERVICE_NAME'),
+                            help='Volume service name. '
+                            'Default=env[CINDER_VOLUME_SERVICE_NAME].')
+        parser.add_argument('--volume_service_name',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--endpoint-type',
+                            metavar='<endpoint-type>',
+                            default=utils.env('CINDER_ENDPOINT_TYPE',
+                            default=DEFAULT_CINDER_ENDPOINT_TYPE),
+                            help='Endpoint type, which is publicURL or '
+                            'internalURL. '
+                            'Default=nova env[CINDER_ENDPOINT_TYPE] or '
+                            + DEFAULT_CINDER_ENDPOINT_TYPE + '.')
+
+        parser.add_argument('--endpoint_type',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-volume-api-version',
+                            metavar='<volume-api-ver>',
+                            default=utils.env('OS_VOLUME_API_VERSION',
+                                              default=None),
+                            help='Block Storage API version. '
+                            'Valid values are 1 or 2. '
+                            'Default=env[OS_VOLUME_API_VERSION].')
+        parser.add_argument('--os_volume_api_version',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--retries',
+                            metavar='<retries>',
+                            type=int,
+                            default=0,
+                            help='Number of retries.')
+
+        self._append_global_identity_args(parser)
+
+        # The auth-system-plugins might require some extra options
+        cinderclient.auth_plugin.discover_auth_systems()
+        cinderclient.auth_plugin.load_auth_system_opts(parser)
+
+        return parser
+
+    def _append_global_identity_args(self, parser):
+        # FIXME(bklei): these are global identity (Keystone) arguments which
+        # should be consistent and shared by all service clients. Therefore,
+        # they should be provided by python-keystoneclient. We will need to
+        # refactor this code once this functionality is available in
+        # python-keystoneclient.
+
+        parser.add_argument(
+            '--os-auth-strategy', metavar='<auth-strategy>',
+            default=utils.env('OS_AUTH_STRATEGY', default='keystone'),
+            help=_('Authentication strategy (Env: OS_AUTH_STRATEGY'
+                   ', default keystone). For now, any other value will'
+                   ' disable the authentication'))
+        parser.add_argument(
+            '--os_auth_strategy',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-username',
+                            metavar='<auth-user-name>',
+                            default=utils.env('OS_USERNAME',
+                                              'CINDER_USERNAME'),
+                            help='OpenStack user name. '
+                            'Default=env[OS_USERNAME].')
+        parser.add_argument('--os_username',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-password',
+                            metavar='<auth-password>',
+                            default=utils.env('OS_PASSWORD',
+                                              'CINDER_PASSWORD'),
+                            help='Password for OpenStack user. '
+                            'Default=env[OS_PASSWORD].')
+        parser.add_argument('--os_password',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-tenant-name',
+                            metavar='<auth-tenant-name>',
+                            default=utils.env('OS_TENANT_NAME',
+                                              'CINDER_PROJECT_ID'),
+                            help='Tenant name. '
+                            'Default=env[OS_TENANT_NAME].')
+        parser.add_argument('--os_tenant_name',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-tenant-id',
+                            metavar='<auth-tenant-id>',
+                            default=utils.env('OS_TENANT_ID',
+                                              'CINDER_TENANT_ID'),
+                            help='ID for the tenant. '
+                            'Default=env[OS_TENANT_ID].')
+        parser.add_argument('--os_tenant_id',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument('--os-auth-url',
+                            metavar='<auth-url>',
+                            default=utils.env('OS_AUTH_URL',
+                                              'CINDER_URL'),
+                            help='URL for the authentication service. '
+                            'Default=env[OS_AUTH_URL].')
+        parser.add_argument('--os_auth_url',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-user-id', metavar='<auth-user-id>',
+            default=utils.env('OS_USER_ID'),
+            help=_('Authentication user ID (Env: OS_USER_ID)'))
+
+        parser.add_argument(
+            '--os_user_id',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-user-domain-id',
+            metavar='<auth-user-domain-id>',
+            default=utils.env('OS_USER_DOMAIN_ID'),
+            help='OpenStack user domain ID. '
+            'Defaults to env[OS_USER_DOMAIN_ID].')
+
+        parser.add_argument(
+            '--os_user_domain_id',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-user-domain-name',
+            metavar='<auth-user-domain-name>',
+            default=utils.env('OS_USER_DOMAIN_NAME'),
+            help='OpenStack user domain name. '
+                 'Defaults to env[OS_USER_DOMAIN_NAME].')
+
+        parser.add_argument(
+            '--os_user_domain_name',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-project-id',
+            metavar='<auth-project-id>',
+            default=utils.env('OS_PROJECT_ID'),
+            help='Another way to specify tenant ID. '
+            'This option is mutually exclusive with '
+            ' --os-tenant-id. '
+            'Defaults to env[OS_PROJECT_ID].')
+
+        parser.add_argument(
+            '--os_project_id',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-project-name',
+            metavar='<auth-project-name>',
+            default=utils.env('OS_PROJECT_NAME'),
+            help='Another way to specify tenant name. '
+                 'This option is mutually exclusive with '
+                 ' --os-tenant-name. '
+                 'Defaults to env[OS_PROJECT_NAME].')
+
+        parser.add_argument(
+            '--os_project_name',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-project-domain-id',
+            metavar='<auth-project-domain-id>',
+            default=utils.env('OS_PROJECT_DOMAIN_ID'),
+            help='Defaults to env[OS_PROJECT_DOMAIN_ID].')
+
+        parser.add_argument(
+            '--os-project-domain-name',
+            metavar='<auth-project-domain-name>',
+            default=utils.env('OS_PROJECT_DOMAIN_NAME'),
+            help='Defaults to env[OS_PROJECT_DOMAIN_NAME].')
+
+        parser.add_argument(
+            '--os-cert',
+            metavar='<certificate>',
+            default=utils.env('OS_CERT'),
+            help='Defaults to env[OS_CERT].')
+
+        parser.add_argument(
+            '--os-key',
+            metavar='<key>',
+            default=utils.env('OS_KEY'),
+            help='Defaults to env[OS_KEY].')
+
+        parser.add_argument('--os-region-name',
+                            metavar='<region-name>',
+                            default=utils.env('OS_REGION_NAME',
+                                              'CINDER_REGION_NAME'),
+                            help='Region name. '
+                            'Default=env[OS_REGION_NAME].')
+        parser.add_argument('--os_region_name',
+                            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-token', metavar='<token>',
+            default=utils.env('OS_TOKEN'),
+            help=_('Defaults to env[OS_TOKEN]'))
+        parser.add_argument(
+            '--os_token',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-url', metavar='<url>',
+            default=utils.env('OS_URL'),
+            help=_('Defaults to env[OS_URL]'))
+        parser.add_argument(
+            '--os_url',
+            help=argparse.SUPPRESS)
+
+        parser.add_argument(
+            '--os-cacert',
+            metavar='<ca-certificate>',
+            default=utils.env('OS_CACERT', default=None),
+            help=_("Specify a CA bundle file to use in "
+                   "verifying a TLS (https) server certificate. "
+                   "Defaults to env[OS_CACERT]"))
+
+        parser.add_argument('--insecure',
+                            default=utils.env('CINDERCLIENT_INSECURE',
+                                              default=False),
+                            action='store_true',
+                            help=argparse.SUPPRESS)
+
+    def get_subcommand_parser(self, version):
+        parser = self.get_base_parser()
+
+        self.subcommands = {}
+        subparsers = parser.add_subparsers(metavar='<subcommand>')
+
+        try:
+            actions_module = {
+                '1.1': shell_v1,
+                '2': shell_v2,
+            }[version]
+        except KeyError:
+            actions_module = shell_v1
+
+        self._find_actions(subparsers, actions_module)
+        self._find_actions(subparsers, self)
+
+        for extension in self.extensions:
+            self._find_actions(subparsers, extension.module)
+
+        self._add_bash_completion_subparser(subparsers)
+
+        return parser
+
+    def _discover_extensions(self, version):
+        extensions = []
+        for name, module in itertools.chain(
+                self._discover_via_python_path(version),
+                self._discover_via_contrib_path(version)):
+
+            extension = cinderclient.extension.Extension(name, module)
+            extensions.append(extension)
+
+        return extensions
+
+    def _discover_via_python_path(self, version):
+        for (module_loader, name, ispkg) in pkgutil.iter_modules():
+            if name.endswith('python_cinderclient_ext'):
+                if not hasattr(module_loader, 'load_module'):
+                    # Python 2.6 compat: actually get an ImpImporter obj
+                    module_loader = module_loader.find_module(name)
+
+                module = module_loader.load_module(name)
+                yield name, module
+
+    def _discover_via_contrib_path(self, version):
+        module_path = os.path.dirname(os.path.abspath(__file__))
+        version_str = "v%s" % version.replace('.', '_')
+        ext_path = os.path.join(module_path, version_str, 'contrib')
+        ext_glob = os.path.join(ext_path, "*.py")
+
+        for ext_path in glob.iglob(ext_glob):
+            name = os.path.basename(ext_path)[:-3]
+
+            if name == "__init__":
+                continue
+
+            module = imp.load_source(name, ext_path)
+            yield name, module
+
+    def _add_bash_completion_subparser(self, subparsers):
+        subparser = subparsers.add_parser(
+            'bash_completion',
+            add_help=False,
+            formatter_class=OpenStackHelpFormatter)
+
+        self.subcommands['bash_completion'] = subparser
+        subparser.set_defaults(func=self.do_bash_completion)
+
+    def _find_actions(self, subparsers, actions_module):
+        for attr in (a for a in dir(actions_module) if a.startswith('do_')):
+            # I prefer to be hyphen-separated instead of underscores.
+            command = attr[3:].replace('_', '-')
+            callback = getattr(actions_module, attr)
+            desc = callback.__doc__ or ''
+            help = desc.strip().split('\n')[0]
+            arguments = getattr(callback, 'arguments', [])
+
+            subparser = subparsers.add_parser(
+                command,
+                help=help,
+                description=desc,
+                add_help=False,
+                formatter_class=OpenStackHelpFormatter)
+
+            subparser.add_argument('-h', '--help',
+                                   action='help',
+                                   help=argparse.SUPPRESS,)
+
+            self.subcommands[command] = subparser
+            for (args, kwargs) in arguments:
+                subparser.add_argument(*args, **kwargs)
+            subparser.set_defaults(func=callback)
+
+    def setup_debugging(self, debug):
+        if not debug:
+            return
+
+        streamhandler = logging.StreamHandler()
+        streamformat = "%(levelname)s (%(module)s:%(lineno)d) %(message)s"
+        streamhandler.setFormatter(logging.Formatter(streamformat))
+        logger.setLevel(logging.WARNING)
+        logger.addHandler(streamhandler)
+
+        client_logger = logging.getLogger(client.__name__)
+        ch = logging.StreamHandler()
+        client_logger.setLevel(logging.DEBUG)
+        client_logger.addHandler(ch)
+        if hasattr(requests, 'logging'):
+            requests.logging.getLogger(requests.__name__).addHandler(ch)
+        # required for logging when using a keystone session
+        ks_logger = logging.getLogger("keystoneclient")
+        ks_logger.setLevel(logging.DEBUG)
+
+    def main(self, argv):
+
+        # Parse args once to find version and debug settings
+        parser = self.get_base_parser()
+        (options, args) = parser.parse_known_args(argv)
+        self.setup_debugging(options.debug)
+        api_version_input = True
+        self.options = options
+
+        if not options.os_volume_api_version:
+            # Environment variable OS_VOLUME_API_VERSION was
+            # not set and '--os-volume-api-version' option doesn't
+            # specify a value.  Fall back to default.
+            options.os_volume_api_version = DEFAULT_OS_VOLUME_API_VERSION
+            api_version_input = False
+
+        # build available subcommands based on version
+        self.extensions = self._discover_extensions(
+            options.os_volume_api_version)
+        self._run_extension_hooks('__pre_parse_args__')
+
+        subcommand_parser = self.get_subcommand_parser(
+            options.os_volume_api_version)
+        self.parser = subcommand_parser
+
+        if options.help or not argv:
+            subcommand_parser.print_help()
+            return 0
+
+        args = subcommand_parser.parse_args(argv)
+        self._run_extension_hooks('__post_parse_args__', args)
+
+        # Short-circuit and deal with help right away.
+        if args.func == self.do_help:
+            self.do_help(args)
+            return 0
+        elif args.func == self.do_bash_completion:
+            self.do_bash_completion(args)
+            return 0
+
+        (os_username, os_password, os_tenant_name, os_auth_url,
+         os_region_name, os_tenant_id, endpoint_type, insecure,
+         service_type, service_name, volume_service_name,
+         cacert, os_auth_system) = (
+             args.os_username, args.os_password,
+             args.os_tenant_name, args.os_auth_url,
+             args.os_region_name, args.os_tenant_id,
+             args.endpoint_type, args.insecure,
+             args.service_type, args.service_name,
+             args.volume_service_name, args.os_cacert,
+             args.os_auth_system)
+
+        if os_auth_system and os_auth_system != "keystone":
+            auth_plugin = cinderclient.auth_plugin.load_plugin(os_auth_system)
+        else:
+            auth_plugin = None
+
+        if not endpoint_type:
+            endpoint_type = DEFAULT_CINDER_ENDPOINT_TYPE
+
+        if not service_type:
+            service_type = DEFAULT_CINDER_SERVICE_TYPE
+            service_type = utils.get_service_type(args.func) or service_type
+
+        # FIXME(usrleon): Here should be restrict for project id same as
+        # for os_username or os_password but for compatibility it is not.
+
+        if not utils.isunauthenticated(args.func):
+            if auth_plugin:
+                auth_plugin.parse_opts(args)
+
+            if not auth_plugin or not auth_plugin.opts:
+                if not os_username:
+                    raise exc.CommandError("You must provide a user name "
+                                           "through --os-username or "
+                                           "env[OS_USERNAME].")
+
+            if not os_password:
+                raise exc.CommandError("You must provide a password "
+                                       "through --os-password or "
+                                       "env[OS_PASSWORD].")
+
+            if not (os_tenant_name or os_tenant_id):
+                raise exc.CommandError("You must provide a tenant ID "
+                                       "through --os-tenant-id or "
+                                       "env[OS_TENANT_ID].")
+
+            # V3 stuff
+            project_info_provided = self.options.os_tenant_name or \
+                self.options.os_tenant_id or \
+                (self.options.os_project_name and
+                 (self.options.project_domain_name or
+                  self.options.project_domain_id)) or \
+                self.options.os_project_id
+
+            if (not project_info_provided):
+                raise exc.CommandError(
+                    _("You must provide a tenant_name, tenant_id, "
+                      "project_id or project_name (with "
+                      "project_domain_name or project_domain_id) via "
+                      "  --os-tenant-name (env[OS_TENANT_NAME]),"
+                      "  --os-tenant-id (env[OS_TENANT_ID]),"
+                      "  --os-project-id (env[OS_PROJECT_ID])"
+                      "  --os-project-name (env[OS_PROJECT_NAME]),"
+                      "  --os-project-domain-id "
+                      "(env[OS_PROJECT_DOMAIN_ID])"
+                      "  --os-project-domain-name "
+                      "(env[OS_PROJECT_DOMAIN_NAME])"))
+
+            if not os_auth_url:
+                if os_auth_system and os_auth_system != 'keystone':
+                    os_auth_url = auth_plugin.get_auth_url()
+
+            if not os_auth_url:
+                raise exc.CommandError(
+                    "You must provide an authentication URL "
+                    "through --os-auth-url or env[OS_AUTH_URL].")
+
+        if not (os_tenant_name or os_tenant_id):
+            raise exc.CommandError(
+                "You must provide a tenant ID "
+                "through --os-tenant-id or env[OS_TENANT_ID].")
+
+        if not os_auth_url:
+            raise exc.CommandError(
+                "You must provide an authentication URL "
+                "through --os-auth-url or env[OS_AUTH_URL].")
+
+        auth_session = self._get_keystone_session()
+
+        self.cs = client.Client(options.os_volume_api_version, os_username,
+                                os_password, os_tenant_name, os_auth_url,
+                                insecure, region_name=os_region_name,
+                                tenant_id=os_tenant_id,
+                                endpoint_type=endpoint_type,
+                                extensions=self.extensions,
+                                service_type=service_type,
+                                service_name=service_name,
+                                volume_service_name=volume_service_name,
+                                retries=options.retries,
+                                http_log_debug=args.debug,
+                                cacert=cacert, auth_system=os_auth_system,
+                                auth_plugin=auth_plugin,
+                                session=auth_session)
+
+        try:
+            if not utils.isunauthenticated(args.func):
+                self.cs.authenticate()
+        except exc.Unauthorized:
+            raise exc.CommandError("OpenStack credentials are not valid.")
+        except exc.AuthorizationFailure:
+            raise exc.CommandError("Unable to authorize user.")
+
+        endpoint_api_version = None
+        # Try to get the API version from the endpoint URL.  If that fails fall
+        # back to trying to use what the user specified via
+        # --os-volume-api-version or with the OS_VOLUME_API_VERSION environment
+        # variable.  Fail safe is to use the default API setting.
+        try:
+            endpoint_api_version = \
+                self.cs.get_volume_api_version_from_endpoint()
+            if endpoint_api_version != options.os_volume_api_version:
+                msg = (("OpenStack Block Storage API version is set to %s "
+                        "but you are accessing a %s endpoint. "
+                        "Change its value through --os-volume-api-version "
+                        "or env[OS_VOLUME_API_VERSION].")
+                       % (options.os_volume_api_version, endpoint_api_version))
+                raise exc.InvalidAPIVersion(msg)
+        except exc.UnsupportedVersion:
+            endpoint_api_version = options.os_volume_api_version
+            if api_version_input:
+                logger.warning("Cannot determine the API version from "
+                               "the endpoint URL. Falling back to the "
+                               "user-specified version: %s" %
+                               endpoint_api_version)
+            else:
+                logger.warning("Cannot determine the API version from the "
+                               "endpoint URL or user input. Falling back "
+                               "to the default API version: %s" %
+                               endpoint_api_version)
+
+        args.func(self.cs, args)
+
+    def _run_extension_hooks(self, hook_type, *args, **kwargs):
+        """Runs hooks for all registered extensions."""
+        for extension in self.extensions:
+            extension.run_hooks(hook_type, *args, **kwargs)
+
+    def do_bash_completion(self, args):
+        """Prints arguments for bash_completion.
+
+        Prints all commands and options to stdout so that the
+        cinder.bash_completion script does not have to hard code them.
+        """
+        commands = set()
+        options = set()
+        for sc_str, sc in list(self.subcommands.items()):
+            commands.add(sc_str)
+            for option in sc._optionals._option_string_actions:
+                options.add(option)
+
+        commands.remove('bash-completion')
+        commands.remove('bash_completion')
+        print(' '.join(commands | options))
+
+    @utils.arg('command', metavar='<subcommand>', nargs='?',
+               help='Shows help for <subcommand>.')
+    def do_help(self, args):
+        """
+        Shows help about this program or one of its subcommands.
+        """
+        if args.command:
+            if args.command in self.subcommands:
+                self.subcommands[args.command].print_help()
+            else:
+                raise exc.CommandError("'%s' is not a valid subcommand" %
+                                       args.command)
+        else:
+            self.parser.print_help()
+
+    def get_v2_auth(self, v2_auth_url):
+
+        username = self.options.os_username
+        password = self.options.os_password
+        tenant_id = self.options.os_tenant_id
+        tenant_name = self.options.os_tenant_name
+
+        return v2_auth.Password(
+            v2_auth_url,
+            username=username,
+            password=password,
+            tenant_id=tenant_id,
+            tenant_name=tenant_name)
+
+    def get_v3_auth(self, v3_auth_url):
+
+        username = self.options.os_username
+        user_id = self.options.os_user_id
+        user_domain_name = self.options.os_user_domain_name
+        user_domain_id = self.options.os_user_domain_id
+        password = self.options.os_password
+        project_id = self.options.os_project_id or self.options.os_tenant_id
+        project_name = (self.options.os_project_name
+                        or self.options.os_tenant_name)
+        project_domain_name = self.options.os_project_domain_name
+        project_domain_id = self.options.os_project_domain_id
+
+        return v3_auth.Password(
+            v3_auth_url,
+            username=username,
+            password=password,
+            user_id=user_id,
+            user_domain_name=user_domain_name,
+            user_domain_id=user_domain_id,
+            project_id=project_id,
+            project_name=project_name,
+            project_domain_name=project_domain_name,
+            project_domain_id=project_domain_id,
+        )
+
+    def _discover_auth_versions(self, session, auth_url):
+        # discover the API versions the server is supporting based on the
+        # given URL
+        v2_auth_url = None
+        v3_auth_url = None
+        try:
+            ks_discover = discover.Discover(session=session, auth_url=auth_url)
+            v2_auth_url = ks_discover.url_for('2.0')
+            v3_auth_url = ks_discover.url_for('3.0')
+        except DiscoveryFailure:
+            # Discovery response mismatch. Raise the error
+            raise
+        except Exception:
+            # Some public clouds throw some other exception or doesn't support
+            # discovery. In that case try to determine version from auth_url
+            # API version from the original URL
+            url_parts = urlparse.urlparse(auth_url)
+            (scheme, netloc, path, params, query, fragment) = url_parts
+            path = path.lower()
+            if path.startswith('/v3'):
+                v3_auth_url = auth_url
+            elif path.startswith('/v2'):
+                v2_auth_url = auth_url
+            else:
+                raise exc.CommandError('Unable to determine the Keystone'
+                                       ' version to authenticate with '
+                                       'using the given auth_url.')
+
+        return (v2_auth_url, v3_auth_url)
+
+    def _get_keystone_session(self, **kwargs):
+        # first create a Keystone session
+        cacert = self.options.os_cacert or None
+        cert = self.options.os_cert or None
+        insecure = self.options.insecure or False
+
+        if insecure:
+            verify = False
+        else:
+            verify = cacert or True
+
+        ks_session = session.Session(verify=verify, cert=cert)
+        # discover the supported keystone versions using the given url
+        (v2_auth_url, v3_auth_url) = self._discover_auth_versions(
+            session=ks_session,
+            auth_url=self.options.os_auth_url)
+
+        username = self.options.os_username or None
+        user_domain_name = self.options.os_user_domain_name or None
+        user_domain_id = self.options.os_user_domain_id or None
+
+        auth = None
+        if v3_auth_url and v2_auth_url:
+            # support both v2 and v3 auth. Use v3 if possible.
+            if username:
+                if user_domain_name or user_domain_id:
+                    # use v3 auth
+                    auth = self.get_v3_auth(v3_auth_url)
+                else:
+                    # use v2 auth
+                    auth = self.get_v2_auth(v2_auth_url)
+
+        elif v3_auth_url:
+            # support only v3
+            auth = self.get_v3_auth(v3_auth_url)
+        elif v2_auth_url:
+            # support only v2
+            auth = self.get_v2_auth(v2_auth_url)
+        else:
+            raise exc.CommandError('Unable to determine the Keystone version '
+                                   'to authenticate with using the given '
+                                   'auth_url.')
+
+        ks_session.auth = auth
+        return ks_session
+
+# I'm picky about my shell help.
+
+
+class OpenStackHelpFormatter(argparse.HelpFormatter):
+
+    def start_section(self, heading):
+        # Title-case the headings
+        heading = '%s%s' % (heading[0].upper(), heading[1:])
+        super(OpenStackHelpFormatter, self).start_section(heading)
+
+
+def main():
+    try:
+        if sys.version_info >= (3, 0):
+            OpenStackCinderShell().main(sys.argv[1:])
+        else:
+            OpenStackCinderShell().main(map(strutils.safe_decode,
+                                            sys.argv[1:]))
+    except KeyboardInterrupt:
+        print("... terminating cinder client", file=sys.stderr)
+        sys.exit(130)
+    except Exception as e:
+        logger.debug(e, exc_info=1)
+        print("ERROR: %s" % strutils.six.text_type(e), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+
+    main()

awx/lib/site-packages/cinderclient/tests/fakes.py

@@ -0,0 +1,118 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+A fake server that "responds" to API methods with pre-canned responses.
+
+All of these responses come from the spec, so if for some reason the spec's
+wrong the tests might raise AssertionError. I've indicated in comments the
+places where actual behavior differs from the spec.
+"""
+
+from __future__ import print_function
+
+
+def assert_has_keys(dict, required=[], optional=[]):
+    for k in required:
+        try:
+            assert k in dict
+        except AssertionError:
+            extra_keys = set(dict).difference(set(required + optional))
+            raise AssertionError("found unexpected keys: %s" %
+                                 list(extra_keys))
+
+
+class FakeClient(object):
+
+    def _dict_match(self, partial, real):
+
+        result = True
+        try:
+            for key, value in partial.items():
+                if type(value) is dict:
+                    result = self._dict_match(value, real[key])
+                else:
+                    assert real[key] == value
+                    result = True
+        except (AssertionError, KeyError):
+            result = False
+        return result
+
+    def assert_called(self, method, url, body=None,
+                      partial_body=None, pos=-1, **kwargs):
+        """
+        Assert than an API method was just called.
+        """
+        expected = (method, url)
+        called = self.client.callstack[pos][0:2]
+
+        assert self.client.callstack, ("Expected %s %s but no calls "
+                                       "were made." % expected)
+
+        assert expected == called, 'Expected %s %s; got %s %s' % (
+            expected + called)
+
+        if body is not None:
+            assert self.client.callstack[pos][2] == body
+
+        if partial_body is not None:
+            try:
+                assert self._dict_match(partial_body,
+                                        self.client.callstack[pos][2])
+            except AssertionError:
+                print(self.client.callstack[pos][2])
+                print("does not contain")
+                print(partial_body)
+                raise
+
+    def assert_called_anytime(self, method, url, body=None, partial_body=None):
+        """
+        Assert than an API method was called anytime in the test.
+        """
+        expected = (method, url)
+
+        assert self.client.callstack, ("Expected %s %s but no calls "
+                                       "were made." % expected)
+
+        found = False
+        for entry in self.client.callstack:
+            if expected == entry[0:2]:
+                found = True
+                break
+
+        assert found, 'Expected %s %s; got %s' % (
+            expected + (self.client.callstack, ))
+
+        if body is not None:
+            try:
+                assert entry[2] == body
+            except AssertionError:
+                print(entry[2])
+                print("!=")
+                print(body)
+                raise
+
+        if partial_body is not None:
+            try:
+                assert self._dict_match(partial_body, entry[2])
+            except AssertionError:
+                print(entry[2])
+                print("does not contain")
+                print(partial_body)
+                raise
+
+    def clear_callstack(self):
+        self.client.callstack = []
+
+    def authenticate(self):
+        pass

awx/lib/site-packages/cinderclient/tests/fixture_data/availability_zones.py

@@ -0,0 +1,80 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from datetime import datetime
+from cinderclient.tests.fixture_data import base
+
+# FIXME(jamielennox): use timeutils from oslo
+FORMAT = '%Y-%m-%d %H:%M:%S'
+
+
+class Fixture(base.Fixture):
+
+    base_url = 'os-availability-zone'
+
+    def setUp(self):
+        super(Fixture, self).setUp()
+
+        get_availability = {
+            "availabilityZoneInfo": [
+                {
+                    "zoneName": "zone-1",
+                    "zoneState": {"available": True},
+                    "hosts": None,
+                },
+                {
+                    "zoneName": "zone-2",
+                    "zoneState": {"available": False},
+                    "hosts": None,
+                },
+            ]
+        }
+        self.requests.register_uri('GET', self.url(), json=get_availability)
+
+        updated_1 = datetime(2012, 12, 26, 14, 45, 25, 0).strftime(FORMAT)
+        updated_2 = datetime(2012, 12, 26, 14, 45, 24, 0).strftime(FORMAT)
+        get_detail = {
+            "availabilityZoneInfo": [
+                {
+                    "zoneName": "zone-1",
+                    "zoneState": {"available": True},
+                    "hosts": {
+                        "fake_host-1": {
+                            "cinder-volume": {
+                                "active": True,
+                                "available": True,
+                                "updated_at": updated_1,
+                            }
+                        }
+                    }
+                },
+                {
+                    "zoneName": "internal",
+                    "zoneState": {"available": True},
+                    "hosts": {
+                        "fake_host-1": {
+                            "cinder-sched": {
+                                "active": True,
+                                "available": True,
+                                "updated_at": updated_2,
+                            }
+                        }
+                    }
+                },
+                {
+                    "zoneName": "zone-2",
+                    "zoneState": {"available": False},
+                    "hosts": None,
+                },
+            ]
+        }
+        self.requests.register_uri('GET', self.url('detail'), json=get_detail)

awx/lib/site-packages/cinderclient/tests/fixture_data/base.py

@@ -0,0 +1,38 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import fixtures
+
+IDENTITY_URL = 'http://identityserver:5000/v2.0'
+VOLUME_URL = 'http://volume.host'
+
+
+class Fixture(fixtures.Fixture):
+
+    base_url = None
+    json_headers = {'Content-Type': 'application/json'}
+
+    def __init__(self, requests,
+                 volume_url=VOLUME_URL,
+                 identity_url=IDENTITY_URL):
+        super(Fixture, self).__init__()
+        self.requests = requests
+        self.volume_url = volume_url
+        self.identity_url = identity_url
+
+    def url(self, *args):
+        url_args = [self.volume_url]
+
+        if self.base_url:
+            url_args.append(self.base_url)
+
+        return '/'.join(str(a).strip('/') for a in tuple(url_args) + args)

awx/lib/site-packages/cinderclient/tests/fixture_data/client.py

@@ -0,0 +1,64 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from keystoneclient import fixture
+
+from cinderclient.tests.fixture_data import base
+from cinderclient.v1 import client as v1client
+from cinderclient.v2 import client as v2client
+
+
+class Base(base.Fixture):
+
+    def __init__(self, *args, **kwargs):
+        super(Base, self).__init__(*args, **kwargs)
+
+        self.token = fixture.V2Token()
+        self.token.set_scope()
+
+    def setUp(self):
+        super(Base, self).setUp()
+
+        auth_url = '%s/tokens' % self.identity_url
+        self.requests.register_uri('POST', auth_url,
+                                   json=self.token,
+                                   headers=self.json_headers)
+
+
+class V1(Base):
+
+    def __init__(self, *args, **kwargs):
+        super(V1, self).__init__(*args, **kwargs)
+
+        svc = self.token.add_service('volume')
+        svc.add_endpoint(self.volume_url)
+
+    def new_client(self):
+        return v1client.Client(username='xx',
+                               api_key='xx',
+                               project_id='xx',
+                               auth_url=self.identity_url)
+
+
+class V2(Base):
+
+    def __init__(self, *args, **kwargs):
+        super(V2, self).__init__(*args, **kwargs)
+
+        svc = self.token.add_service('volumev2')
+        svc.add_endpoint(self.volume_url)
+
+    def new_client(self):
+        return v2client.Client(username='xx',
+                               api_key='xx',
+                               project_id='xx',
+                               auth_url=self.identity_url)

awx/lib/site-packages/cinderclient/tests/fixture_data/keystone_client.py

@@ -0,0 +1,230 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import copy
+import json
+import uuid
+
+
+# these are copied from python-keystoneclient tests
+BASE_HOST = 'http://keystone.example.com'
+BASE_URL = "%s:5000/" % BASE_HOST
+UPDATED = '2013-03-06T00:00:00Z'
+
+V2_URL = "%sv2.0" % BASE_URL
+V2_DESCRIBED_BY_HTML = {'href': 'http://docs.openstack.org/api/'
+                                'openstack-identity-service/2.0/content/',
+                        'rel': 'describedby',
+                        'type': 'text/html'}
+
+V2_DESCRIBED_BY_PDF = {'href': 'http://docs.openstack.org/api/openstack-ident'
+                               'ity-service/2.0/identity-dev-guide-2.0.pdf',
+                       'rel': 'describedby',
+                       'type': 'application/pdf'}
+
+V2_VERSION = {'id': 'v2.0',
+              'links': [{'href': V2_URL, 'rel': 'self'},
+                        V2_DESCRIBED_BY_HTML, V2_DESCRIBED_BY_PDF],
+              'status': 'stable',
+              'updated': UPDATED}
+
+V3_URL = "%sv3" % BASE_URL
+V3_MEDIA_TYPES = [{'base': 'application/json',
+                   'type': 'application/vnd.openstack.identity-v3+json'},
+                  {'base': 'application/xml',
+                   'type': 'application/vnd.openstack.identity-v3+xml'}]
+
+V3_VERSION = {'id': 'v3.0',
+              'links': [{'href': V3_URL, 'rel': 'self'}],
+              'media-types': V3_MEDIA_TYPES,
+              'status': 'stable',
+              'updated': UPDATED}
+
+WRONG_VERSION_RESPONSE = {'id': 'v2.0',
+                          'links': [V2_DESCRIBED_BY_HTML, V2_DESCRIBED_BY_PDF],
+                          'status': 'stable',
+                          'updated': UPDATED}
+
+
+def _create_version_list(versions):
+    return json.dumps({'versions': {'values': versions}})
+
+
+def _create_single_version(version):
+    return json.dumps({'version': version})
+
+
+V3_VERSION_LIST = _create_version_list([V3_VERSION, V2_VERSION])
+V2_VERSION_LIST = _create_version_list([V2_VERSION])
+
+V3_VERSION_ENTRY = _create_single_version(V3_VERSION)
+V2_VERSION_ENTRY = _create_single_version(V2_VERSION)
+
+CINDER_ENDPOINT = 'http://www.cinder.com/v1'
+
+
+def _get_normalized_token_data(**kwargs):
+    ref = copy.deepcopy(kwargs)
+    # normalized token data
+    ref['user_id'] = ref.get('user_id', uuid.uuid4().hex)
+    ref['username'] = ref.get('username', uuid.uuid4().hex)
+    ref['project_id'] = ref.get('project_id',
+                                ref.get('tenant_id', uuid.uuid4().hex))
+    ref['project_name'] = ref.get('tenant_name',
+                                  ref.get('tenant_name', uuid.uuid4().hex))
+    ref['user_domain_id'] = ref.get('user_domain_id', uuid.uuid4().hex)
+    ref['user_domain_name'] = ref.get('user_domain_name', uuid.uuid4().hex)
+    ref['project_domain_id'] = ref.get('project_domain_id', uuid.uuid4().hex)
+    ref['project_domain_name'] = ref.get('project_domain_name',
+                                         uuid.uuid4().hex)
+    ref['roles'] = ref.get('roles', [{'name': uuid.uuid4().hex,
+                                      'id': uuid.uuid4().hex}])
+    ref['roles_link'] = ref.get('roles_link', [])
+    ref['cinder_url'] = ref.get('cinder_url', CINDER_ENDPOINT)
+
+    return ref
+
+
+def generate_v2_project_scoped_token(**kwargs):
+    """Generate a Keystone V2 token based on auth request."""
+    ref = _get_normalized_token_data(**kwargs)
+    token = uuid.uuid4().hex
+
+    o = {'access': {'token': {'id': token,
+                              'expires': '2099-05-22T00:02:43.941430Z',
+                              'issued_at': '2013-05-21T00:02:43.941473Z',
+                              'tenant': {'enabled': True,
+                                         'id': ref.get('project_id'),
+                                         'name': ref.get('project_id')
+                                         }
+                              },
+                    'user': {'id': ref.get('user_id'),
+                             'name': uuid.uuid4().hex,
+                             'username': ref.get('username'),
+                             'roles': ref.get('roles'),
+                             'roles_links': ref.get('roles_links')
+                             }
+                    }}
+
+    # we only care about Neutron and Keystone endpoints
+    o['access']['serviceCatalog'] = [
+        {'endpoints': [
+            {'publicURL': 'public_' + ref.get('cinder_url'),
+             'internalURL': 'internal_' + ref.get('cinder_url'),
+             'adminURL': 'admin_' + (ref.get('auth_url') or ""),
+             'id': uuid.uuid4().hex,
+             'region': 'RegionOne'
+             }],
+         'endpoints_links': [],
+         'name': 'Neutron',
+         'type': 'network'},
+        {'endpoints': [
+            {'publicURL': ref.get('auth_url'),
+             'adminURL': ref.get('auth_url'),
+             'internalURL': ref.get('auth_url'),
+             'id': uuid.uuid4().hex,
+             'region': 'RegionOne'
+             }],
+         'endpoint_links': [],
+         'name': 'keystone',
+         'type': 'identity'}]
+
+    return token, o
+
+
+def generate_v3_project_scoped_token(**kwargs):
+    """Generate a Keystone V3 token based on auth request."""
+    ref = _get_normalized_token_data(**kwargs)
+
+    o = {'token': {'expires_at': '2099-05-22T00:02:43.941430Z',
+                   'issued_at': '2013-05-21T00:02:43.941473Z',
+                   'methods': ['password'],
+                   'project': {'id': ref.get('project_id'),
+                               'name': ref.get('project_name'),
+                               'domain': {'id': ref.get('project_domain_id'),
+                                          'name': ref.get(
+                                              'project_domain_name')
+                                          }
+                               },
+                   'user': {'id': ref.get('user_id'),
+                            'name': ref.get('username'),
+                            'domain': {'id': ref.get('user_domain_id'),
+                                       'name': ref.get('user_domain_name')
+                                       }
+                            },
+                   'roles': ref.get('roles')
+                   }}
+
+    # we only care about Neutron and Keystone endpoints
+    o['token']['catalog'] = [
+        {'endpoints': [
+            {
+                'id': uuid.uuid4().hex,
+                'interface': 'public',
+                'region': 'RegionOne',
+                'url': 'public_' + ref.get('cinder_url')
+            },
+            {
+                'id': uuid.uuid4().hex,
+                'interface': 'internal',
+                'region': 'RegionOne',
+                'url': 'internal_' + ref.get('cinder_url')
+            },
+            {
+                'id': uuid.uuid4().hex,
+                'interface': 'admin',
+                'region': 'RegionOne',
+                'url': 'admin_' + ref.get('cinder_url')
+            }],
+         'id': uuid.uuid4().hex,
+         'type': 'network'},
+        {'endpoints': [
+            {
+                'id': uuid.uuid4().hex,
+                'interface': 'public',
+                'region': 'RegionOne',
+                'url': ref.get('auth_url')
+            },
+            {
+                'id': uuid.uuid4().hex,
+                'interface': 'admin',
+                'region': 'RegionOne',
+                'url': ref.get('auth_url')
+            }],
+         'id': uuid.uuid4().hex,
+         'type': 'identity'}]
+
+    # token ID is conveyed via the X-Subject-Token header so we are generating
+    # one to stash there
+    token_id = uuid.uuid4().hex
+
+    return token_id, o
+
+
+def keystone_request_callback(request, context):
+    context.headers['Content-Type'] = 'application/json'
+
+    if request.url == BASE_URL:
+        return V3_VERSION_LIST
+    elif request.url == BASE_URL + "/v2.0":
+        token_id, token_data = generate_v2_project_scoped_token()
+        return token_data
+    elif request.url == BASE_URL + "/v3":
+        token_id, token_data = generate_v3_project_scoped_token()
+        context.headers["X-Subject-Token"] = token_id
+        context.status_code = 201
+        return token_data
+    elif "WrongDiscoveryResponse.discovery.com" in request.url:
+        return str(WRONG_VERSION_RESPONSE)
+    else:
+        context.status_code = 500
+        return str(WRONG_VERSION_RESPONSE)

awx/lib/site-packages/cinderclient/tests/fixture_data/snapshots.py

@@ -0,0 +1,56 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import json
+
+from cinderclient.tests.fixture_data import base
+
+
+def _stub_snapshot(**kwargs):
+    snapshot = {
+        "created_at": "2012-08-28T16:30:31.000000",
+        "display_description": None,
+        "display_name": None,
+        "id": '11111111-1111-1111-1111-111111111111',
+        "size": 1,
+        "status": "available",
+        "volume_id": '00000000-0000-0000-0000-000000000000',
+    }
+    snapshot.update(kwargs)
+    return snapshot
+
+
+class Fixture(base.Fixture):
+
+    base_url = 'snapshots'
+
+    def setUp(self):
+        super(Fixture, self).setUp()
+
+        snapshot_1234 = _stub_snapshot(id='1234')
+        self.requests.register_uri('GET', self.url('1234'),
+                                   json={'snapshot': snapshot_1234})
+
+        def action_1234(request, context):
+            return ''
+            body = json.loads(request.body.decode('utf-8'))
+            assert len(list(body)) == 1
+            action = list(body)[0]
+            if action == 'os-reset_status':
+                assert 'status' in body['os-reset_status']
+            elif action == 'os-update_snapshot_status':
+                assert 'status' in body['os-update_snapshot_status']
+            else:
+                raise AssertionError("Unexpected action: %s" % action)
+            return ''
+        self.requests.register_uri('POST', self.url('1234', 'action'),
+                                   text=action_1234, status_code=202)

awx/lib/site-packages/cinderclient/tests/test_auth_plugins.py

@@ -0,0 +1,346 @@
+# Copyright 2012 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import argparse
+import mock
+import pkg_resources
+import requests
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+from cinderclient import auth_plugin
+from cinderclient import exceptions
+from cinderclient.tests import utils
+from cinderclient.v1 import client
+
+
+def mock_http_request(resp=None):
+    """Mock an HTTP Request."""
+    if not resp:
+        resp = {
+            "access": {
+                "token": {
+                    "expires": "12345",
+                    "id": "FAKE_ID",
+                    "tenant": {
+                        "id": "FAKE_TENANT_ID",
+                    }
+                },
+                "serviceCatalog": [
+                    {
+                        "type": "volume",
+                        "endpoints": [
+                            {
+                                "region": "RegionOne",
+                                "adminURL": "http://localhost:8774/v1.1",
+                                "internalURL": "http://localhost:8774/v1.1",
+                                "publicURL": "http://localhost:8774/v1.1/",
+                            },
+                        ],
+                    },
+                ],
+            },
+        }
+
+    auth_response = utils.TestResponse({
+        "status_code": 200,
+        "text": json.dumps(resp),
+    })
+    return mock.Mock(return_value=(auth_response))
+
+
+def requested_headers(cs):
+    """Return requested passed headers."""
+    return {
+        'User-Agent': cs.client.USER_AGENT,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+    }
+
+
+class DeprecatedAuthPluginTest(utils.TestCase):
+    def test_auth_system_success(self):
+        class MockEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return self.authenticate
+
+            def authenticate(self, cls, auth_url):
+                cls._authenticate(auth_url, {"fake": "me"})
+
+        def mock_iter_entry_points(_type, name):
+            if _type == 'openstack.client.authenticate':
+                return [MockEntrypoint("fake", "fake", ["fake"])]
+            else:
+                return []
+
+        mock_request = mock_http_request()
+
+        @mock.patch.object(pkg_resources, "iter_entry_points",
+                           mock_iter_entry_points)
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            plugin = auth_plugin.DeprecatedAuthPlugin("fake")
+            cs = client.Client("username", "password", "project_id",
+                               "auth_url/v2.0", auth_system="fake",
+                               auth_plugin=plugin)
+            cs.client.authenticate()
+
+            headers = requested_headers(cs)
+            token_url = cs.client.auth_url + "/tokens"
+
+            mock_request.assert_called_with(
+                "POST",
+                token_url,
+                headers=headers,
+                data='{"fake": "me"}',
+                allow_redirects=True,
+                **self.TEST_REQUEST_BASE)
+
+        test_auth_call()
+
+    def test_auth_system_not_exists(self):
+        def mock_iter_entry_points(_t, name=None):
+            return [pkg_resources.EntryPoint("fake", "fake", ["fake"])]
+
+        mock_request = mock_http_request()
+
+        @mock.patch.object(pkg_resources, "iter_entry_points",
+                           mock_iter_entry_points)
+        @mock.patch.object(requests.Session, "request", mock_request)
+        def test_auth_call():
+            auth_plugin.discover_auth_systems()
+            plugin = auth_plugin.DeprecatedAuthPlugin("notexists")
+            cs = client.Client("username", "password", "project_id",
+                               "auth_url/v2.0", auth_system="notexists",
+                               auth_plugin=plugin)
+            self.assertRaises(exceptions.AuthSystemNotFound,
+                              cs.client.authenticate)
+
+        test_auth_call()
+
+    def test_auth_system_defining_auth_url(self):
+        class MockAuthUrlEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return self.auth_url
+
+            def auth_url(self):
+                return "http://faked/v2.0"
+
+        class MockAuthenticateEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return self.authenticate
+
+            def authenticate(self, cls, auth_url):
+                cls._authenticate(auth_url, {"fake": "me"})
+
+        def mock_iter_entry_points(_type, name):
+            if _type == 'openstack.client.auth_url':
+                return [MockAuthUrlEntrypoint("fakewithauthurl",
+                                              "fakewithauthurl",
+                                              ["auth_url"])]
+            elif _type == 'openstack.client.authenticate':
+                return [MockAuthenticateEntrypoint("fakewithauthurl",
+                                                   "fakewithauthurl",
+                                                   ["authenticate"])]
+            else:
+                return []
+
+        mock_request = mock_http_request()
+
+        @mock.patch.object(pkg_resources, "iter_entry_points",
+                           mock_iter_entry_points)
+        @mock.patch.object(requests.Session, "request", mock_request)
+        def test_auth_call():
+            plugin = auth_plugin.DeprecatedAuthPlugin("fakewithauthurl")
+            cs = client.Client("username", "password", "project_id",
+                               auth_system="fakewithauthurl",
+                               auth_plugin=plugin)
+            cs.client.authenticate()
+            self.assertEqual(cs.client.auth_url, "http://faked/v2.0")
+
+        test_auth_call()
+
+    @mock.patch.object(pkg_resources, "iter_entry_points")
+    def test_client_raises_exc_without_auth_url(self, mock_iter_entry_points):
+        class MockAuthUrlEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return self.auth_url
+
+            def auth_url(self):
+                return None
+
+        mock_iter_entry_points.side_effect = lambda _t, name: [
+            MockAuthUrlEntrypoint("fakewithauthurl",
+                                  "fakewithauthurl",
+                                  ["auth_url"])]
+
+        plugin = auth_plugin.DeprecatedAuthPlugin("fakewithauthurl")
+        self.assertRaises(
+            exceptions.EndpointNotFound,
+            client.Client, "username", "password", "project_id",
+            auth_system="fakewithauthurl", auth_plugin=plugin)
+
+
+class AuthPluginTest(utils.TestCase):
+    @mock.patch.object(requests, "request")
+    @mock.patch.object(pkg_resources, "iter_entry_points")
+    def test_auth_system_success(self, mock_iter_entry_points, mock_request):
+        """Test that we can authenticate using the auth system."""
+        class MockEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return FakePlugin
+
+        class FakePlugin(auth_plugin.BaseAuthPlugin):
+            def authenticate(self, cls, auth_url):
+                cls._authenticate(auth_url, {"fake": "me"})
+
+        mock_iter_entry_points.side_effect = lambda _t: [
+            MockEntrypoint("fake", "fake", ["FakePlugin"])]
+
+        mock_request.side_effect = mock_http_request()
+
+        auth_plugin.discover_auth_systems()
+        plugin = auth_plugin.load_plugin("fake")
+        cs = client.Client("username", "password", "project_id",
+                           "auth_url/v2.0", auth_system="fake",
+                           auth_plugin=plugin)
+        cs.client.authenticate()
+
+        headers = requested_headers(cs)
+        token_url = cs.client.auth_url + "/tokens"
+
+        mock_request.assert_called_with(
+            "POST",
+            token_url,
+            headers=headers,
+            data='{"fake": "me"}',
+            allow_redirects=True,
+            **self.TEST_REQUEST_BASE)
+
+    @mock.patch.object(pkg_resources, "iter_entry_points")
+    def test_discover_auth_system_options(self, mock_iter_entry_points):
+        """Test that we can load the auth system options."""
+        class FakePlugin(auth_plugin.BaseAuthPlugin):
+            @staticmethod
+            def add_opts(parser):
+                parser.add_argument('--auth_system_opt',
+                                    default=False,
+                                    action='store_true',
+                                    help="Fake option")
+                return parser
+
+        class MockEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return FakePlugin
+
+        mock_iter_entry_points.side_effect = lambda _t: [
+            MockEntrypoint("fake", "fake", ["FakePlugin"])]
+
+        parser = argparse.ArgumentParser()
+        auth_plugin.discover_auth_systems()
+        auth_plugin.load_auth_system_opts(parser)
+        opts, args = parser.parse_known_args(['--auth_system_opt'])
+
+        self.assertTrue(opts.auth_system_opt)
+
+    @mock.patch.object(pkg_resources, "iter_entry_points")
+    def test_parse_auth_system_options(self, mock_iter_entry_points):
+        """Test that we can parse the auth system options."""
+        class MockEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return FakePlugin
+
+        class FakePlugin(auth_plugin.BaseAuthPlugin):
+            def __init__(self):
+                self.opts = {"fake_argument": True}
+
+            def parse_opts(self, args):
+                return self.opts
+
+        mock_iter_entry_points.side_effect = lambda _t: [
+            MockEntrypoint("fake", "fake", ["FakePlugin"])]
+
+        auth_plugin.discover_auth_systems()
+        plugin = auth_plugin.load_plugin("fake")
+
+        plugin.parse_opts([])
+        self.assertIn("fake_argument", plugin.opts)
+
+    @mock.patch.object(pkg_resources, "iter_entry_points")
+    def test_auth_system_defining_url(self, mock_iter_entry_points):
+        """Test the auth_system defining an url."""
+        class MockEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return FakePlugin
+
+        class FakePlugin(auth_plugin.BaseAuthPlugin):
+            def get_auth_url(self):
+                return "http://faked/v2.0"
+
+        mock_iter_entry_points.side_effect = lambda _t: [
+            MockEntrypoint("fake", "fake", ["FakePlugin"])]
+
+        auth_plugin.discover_auth_systems()
+        plugin = auth_plugin.load_plugin("fake")
+
+        cs = client.Client("username", "password", "project_id",
+                           auth_system="fakewithauthurl",
+                           auth_plugin=plugin)
+        self.assertEqual(cs.client.auth_url, "http://faked/v2.0")
+
+    @mock.patch.object(pkg_resources, "iter_entry_points")
+    def test_exception_if_no_authenticate(self, mock_iter_entry_points):
+        """Test that no authenticate raises a proper exception."""
+        class MockEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return FakePlugin
+
+        class FakePlugin(auth_plugin.BaseAuthPlugin):
+            pass
+
+        mock_iter_entry_points.side_effect = lambda _t: [
+            MockEntrypoint("fake", "fake", ["FakePlugin"])]
+
+        auth_plugin.discover_auth_systems()
+        plugin = auth_plugin.load_plugin("fake")
+
+        self.assertRaises(
+            exceptions.EndpointNotFound,
+            client.Client, "username", "password", "project_id",
+            auth_system="fake", auth_plugin=plugin)
+
+    @mock.patch.object(pkg_resources, "iter_entry_points")
+    def test_exception_if_no_url(self, mock_iter_entry_points):
+        """Test that no auth_url at all raises exception."""
+        class MockEntrypoint(pkg_resources.EntryPoint):
+            def load(self):
+                return FakePlugin
+
+        class FakePlugin(auth_plugin.BaseAuthPlugin):
+            pass
+
+        mock_iter_entry_points.side_effect = lambda _t: [
+            MockEntrypoint("fake", "fake", ["FakePlugin"])]
+
+        auth_plugin.discover_auth_systems()
+        plugin = auth_plugin.load_plugin("fake")
+
+        self.assertRaises(
+            exceptions.EndpointNotFound,
+            client.Client, "username", "password", "project_id",
+            auth_system="fake", auth_plugin=plugin)

awx/lib/site-packages/cinderclient/tests/test_base.py

@@ -0,0 +1,61 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cinderclient import base
+from cinderclient import exceptions
+from cinderclient.v1 import volumes
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class BaseTest(utils.TestCase):
+
+    def test_resource_repr(self):
+        r = base.Resource(None, dict(foo="bar", baz="spam"))
+        self.assertEqual("<Resource baz=spam, foo=bar>", repr(r))
+
+    def test_getid(self):
+        self.assertEqual(4, base.getid(4))
+
+        class TmpObject(object):
+            id = 4
+        self.assertEqual(4, base.getid(TmpObject))
+
+    def test_eq(self):
+        # Two resources of the same type with the same id: equal
+        r1 = base.Resource(None, {'id': 1, 'name': 'hi'})
+        r2 = base.Resource(None, {'id': 1, 'name': 'hello'})
+        self.assertEqual(r1, r2)
+
+        # Two resoruces of different types: never equal
+        r1 = base.Resource(None, {'id': 1})
+        r2 = volumes.Volume(None, {'id': 1})
+        self.assertNotEqual(r1, r2)
+
+        # Two resources with no ID: equal if their info is equal
+        r1 = base.Resource(None, {'name': 'joe', 'age': 12})
+        r2 = base.Resource(None, {'name': 'joe', 'age': 12})
+        self.assertEqual(r1, r2)
+
+    def test_findall_invalid_attribute(self):
+        # Make sure findall with an invalid attribute doesn't cause errors.
+        # The following should not raise an exception.
+        cs.volumes.findall(vegetable='carrot')
+
+        # However, find() should raise an error
+        self.assertRaises(exceptions.NotFound,
+                          cs.volumes.find,
+                          vegetable='carrot')

awx/lib/site-packages/cinderclient/tests/test_client.py

@@ -0,0 +1,63 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import fixtures
+
+import cinderclient.client
+import cinderclient.v1.client
+import cinderclient.v2.client
+from cinderclient.tests import utils
+
+
+class ClientTest(utils.TestCase):
+
+    def test_get_client_class_v1(self):
+        output = cinderclient.client.get_client_class('1')
+        self.assertEqual(cinderclient.v1.client.Client, output)
+
+    def test_get_client_class_v2(self):
+        output = cinderclient.client.get_client_class('2')
+        self.assertEqual(cinderclient.v2.client.Client, output)
+
+    def test_get_client_class_unknown(self):
+        self.assertRaises(cinderclient.exceptions.UnsupportedVersion,
+                          cinderclient.client.get_client_class, '0')
+
+    def test_log_req(self):
+        self.logger = self.useFixture(
+            fixtures.FakeLogger(
+                format="%(message)s",
+                level=logging.DEBUG,
+                nuke_handlers=True
+            )
+        )
+
+        kwargs = {}
+        kwargs['headers'] = {"X-Foo": "bar"}
+        kwargs['data'] = ('{"auth": {"tenantName": "fakeService",'
+                          ' "passwordCredentials": {"username": "fakeUser",'
+                          ' "password": "fakePassword"}}}')
+
+        cs = cinderclient.client.HTTPClient("user", None, None,
+                                            "http://127.0.0.1:5000")
+        cs.http_log_debug = True
+        cs.http_log_req('PUT', kwargs)
+
+        output = self.logger.output.split('\n')
+
+        print("JSBRYANT: output is", output)
+
+        self.assertNotIn("fakePassword", output[1])
+        self.assertIn("fakeUser", output[1])

awx/lib/site-packages/cinderclient/tests/test_http.py

@@ -0,0 +1,243 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import mock
+
+import requests
+
+from cinderclient import client
+from cinderclient import exceptions
+from cinderclient.tests import utils
+
+
+fake_response = utils.TestResponse({
+    "status_code": 200,
+    "text": '{"hi": "there"}',
+})
+
+fake_response_empty = utils.TestResponse({
+    "status_code": 200,
+    "text": '{"access": {}}'
+})
+
+mock_request = mock.Mock(return_value=(fake_response))
+mock_request_empty = mock.Mock(return_value=(fake_response_empty))
+
+bad_400_response = utils.TestResponse({
+    "status_code": 400,
+    "text": '{"error": {"message": "n/a", "details": "Terrible!"}}',
+})
+bad_400_request = mock.Mock(return_value=(bad_400_response))
+
+bad_401_response = utils.TestResponse({
+    "status_code": 401,
+    "text": '{"error": {"message": "FAILED!", "details": "DETAILS!"}}',
+})
+bad_401_request = mock.Mock(return_value=(bad_401_response))
+
+bad_500_response = utils.TestResponse({
+    "status_code": 500,
+    "text": '{"error": {"message": "FAILED!", "details": "DETAILS!"}}',
+})
+bad_500_request = mock.Mock(return_value=(bad_500_response))
+
+connection_error_request = mock.Mock(
+    side_effect=requests.exceptions.ConnectionError)
+
+
+def get_client(retries=0):
+    cl = client.HTTPClient("username", "password",
+                           "project_id", "auth_test", retries=retries)
+    return cl
+
+
+def get_authed_client(retries=0):
+    cl = get_client(retries=retries)
+    cl.management_url = "http://example.com"
+    cl.auth_token = "token"
+    return cl
+
+
+class ClientTest(utils.TestCase):
+
+    def test_get(self):
+        cl = get_authed_client()
+
+        @mock.patch.object(requests, "request", mock_request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+            headers = {"X-Auth-Token": "token",
+                       "X-Auth-Project-Id": "project_id",
+                       "User-Agent": cl.USER_AGENT,
+                       'Accept': 'application/json', }
+            mock_request.assert_called_with(
+                "GET",
+                "http://example.com/hi",
+                headers=headers,
+                **self.TEST_REQUEST_BASE)
+            # Automatic JSON parsing
+            self.assertEqual({"hi": "there"}, body)
+
+        test_get_call()
+
+    def test_get_reauth_0_retries(self):
+        cl = get_authed_client(retries=0)
+
+        self.requests = [bad_401_request, mock_request]
+
+        def request(*args, **kwargs):
+            next_request = self.requests.pop(0)
+            return next_request(*args, **kwargs)
+
+        def reauth():
+            cl.management_url = "http://example.com"
+            cl.auth_token = "token"
+
+        @mock.patch.object(cl, 'authenticate', reauth)
+        @mock.patch.object(requests, "request", request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+
+        test_get_call()
+        self.assertEqual([], self.requests)
+
+    def test_get_retry_500(self):
+        cl = get_authed_client(retries=1)
+
+        self.requests = [bad_500_request, mock_request]
+
+        def request(*args, **kwargs):
+            next_request = self.requests.pop(0)
+            return next_request(*args, **kwargs)
+
+        @mock.patch.object(requests, "request", request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+
+        test_get_call()
+        self.assertEqual([], self.requests)
+
+    def test_get_retry_connection_error(self):
+        cl = get_authed_client(retries=1)
+
+        self.requests = [connection_error_request, mock_request]
+
+        def request(*args, **kwargs):
+            next_request = self.requests.pop(0)
+            return next_request(*args, **kwargs)
+
+        @mock.patch.object(requests, "request", request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+
+        test_get_call()
+        self.assertEqual(self.requests, [])
+
+    def test_retry_limit(self):
+        cl = get_authed_client(retries=1)
+
+        self.requests = [bad_500_request, bad_500_request, mock_request]
+
+        def request(*args, **kwargs):
+            next_request = self.requests.pop(0)
+            return next_request(*args, **kwargs)
+
+        @mock.patch.object(requests, "request", request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+
+        self.assertRaises(exceptions.ClientException, test_get_call)
+        self.assertEqual([mock_request], self.requests)
+
+    def test_get_no_retry_400(self):
+        cl = get_authed_client(retries=0)
+
+        self.requests = [bad_400_request, mock_request]
+
+        def request(*args, **kwargs):
+            next_request = self.requests.pop(0)
+            return next_request(*args, **kwargs)
+
+        @mock.patch.object(requests, "request", request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+
+        self.assertRaises(exceptions.BadRequest, test_get_call)
+        self.assertEqual([mock_request], self.requests)
+
+    def test_get_retry_400_socket(self):
+        cl = get_authed_client(retries=1)
+
+        self.requests = [bad_400_request, mock_request]
+
+        def request(*args, **kwargs):
+            next_request = self.requests.pop(0)
+            return next_request(*args, **kwargs)
+
+        @mock.patch.object(requests, "request", request)
+        @mock.patch('time.time', mock.Mock(return_value=1234))
+        def test_get_call():
+            resp, body = cl.get("/hi")
+
+        test_get_call()
+        self.assertEqual([], self.requests)
+
+    def test_post(self):
+        cl = get_authed_client()
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_post_call():
+            cl.post("/hi", body=[1, 2, 3])
+            headers = {
+                "X-Auth-Token": "token",
+                "X-Auth-Project-Id": "project_id",
+                "Content-Type": "application/json",
+                'Accept': 'application/json',
+                "User-Agent": cl.USER_AGENT
+            }
+            mock_request.assert_called_with(
+                "POST",
+                "http://example.com/hi",
+                headers=headers,
+                data='[1, 2, 3]',
+                **self.TEST_REQUEST_BASE)
+
+        test_post_call()
+
+    def test_auth_failure(self):
+        cl = get_client()
+
+        # response must not have x-server-management-url header
+        @mock.patch.object(requests, "request", mock_request_empty)
+        def test_auth_call():
+            self.assertRaises(exceptions.AuthorizationFailure,
+                              cl.authenticate)
+
+        test_auth_call()
+
+    def test_auth_not_implemented(self):
+        cl = get_client()
+
+        # response must not have x-server-management-url header
+        # {'hi': 'there'} is neither V2 or V3
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            self.assertRaises(NotImplementedError, cl.authenticate)
+
+        test_auth_call()

awx/lib/site-packages/cinderclient/tests/test_service_catalog.py

@@ -0,0 +1,275 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cinderclient import exceptions
+from cinderclient import service_catalog
+from cinderclient.tests import utils
+
+
+# Taken directly from keystone/content/common/samples/auth.json
+# Do not edit this structure. Instead, grab the latest from there.
+
+SERVICE_CATALOG = {
+    "access": {
+        "token": {
+            "id": "ab48a9efdfedb23ty3494",
+            "expires": "2010-11-01T03:32:15-05:00",
+            "tenant": {
+                "id": "345",
+                "name": "My Project"
+            }
+        },
+        "user": {
+            "id": "123",
+            "name": "jqsmith",
+            "roles": [
+                {
+                    "id": "234",
+                    "name": "compute:admin",
+                },
+                {
+                    "id": "235",
+                    "name": "object-store:admin",
+                    "tenantId": "1",
+                }
+            ],
+            "roles_links": [],
+        },
+        "serviceCatalog": [
+            {
+                "name": "Cloud Servers",
+                "type": "compute",
+                "endpoints": [
+                    {
+                        "tenantId": "1",
+                        "publicURL": "https://compute1.host/v1/1234",
+                        "internalURL": "https://compute1.host/v1/1234",
+                        "region": "North",
+                        "versionId": "1.0",
+                        "versionInfo": "https://compute1.host/v1/",
+                        "versionList": "https://compute1.host/"
+                    },
+                    {
+                        "tenantId": "2",
+                        "publicURL": "https://compute1.host/v1/3456",
+                        "internalURL": "https://compute1.host/v1/3456",
+                        "region": "North",
+                        "versionId": "1.1",
+                        "versionInfo": "https://compute1.host/v1/",
+                        "versionList": "https://compute1.host/"
+                    },
+                ],
+                "endpoints_links": [],
+            },
+            {
+                "name": "Cinder Volume Service",
+                "type": "volume",
+                "endpoints": [
+                    {
+                        "tenantId": "1",
+                        "publicURL": "https://volume1.host/v1/1234",
+                        "internalURL": "https://volume1.host/v1/1234",
+                        "region": "South",
+                        "versionId": "1.0",
+                        "versionInfo": "uri",
+                        "versionList": "uri"
+                    },
+                    {
+                        "tenantId": "2",
+                        "publicURL": "https://volume1.host/v1/3456",
+                        "internalURL": "https://volume1.host/v1/3456",
+                        "region": "South",
+                        "versionId": "1.1",
+                        "versionInfo": "https://volume1.host/v1/",
+                        "versionList": "https://volume1.host/"
+                    },
+                ],
+                "endpoints_links": [
+                    {
+                        "rel": "next",
+                        "href": "https://identity1.host/v2.0/endpoints"
+                    },
+                ],
+            },
+            {
+                "name": "Cinder Volume Service V2",
+                "type": "volumev2",
+                "endpoints": [
+                    {
+                        "tenantId": "1",
+                        "publicURL": "https://volume1.host/v2/1234",
+                        "internalURL": "https://volume1.host/v2/1234",
+                        "region": "South",
+                        "versionId": "2.0",
+                        "versionInfo": "uri",
+                        "versionList": "uri"
+                    },
+                    {
+                        "tenantId": "2",
+                        "publicURL": "https://volume1.host/v2/3456",
+                        "internalURL": "https://volume1.host/v2/3456",
+                        "region": "South",
+                        "versionId": "1.1",
+                        "versionInfo": "https://volume1.host/v2/",
+                        "versionList": "https://volume1.host/"
+                    },
+                ],
+                "endpoints_links": [
+                    {
+                        "rel": "next",
+                        "href": "https://identity1.host/v2.0/endpoints"
+                    },
+                ],
+            },
+        ],
+        "serviceCatalog_links": [
+            {
+                "rel": "next",
+                "href": "https://identity.host/v2.0/endpoints?session=2hfh8Ar",
+            },
+        ],
+    },
+}
+
+SERVICE_COMPATIBILITY_CATALOG = {
+    "access": {
+        "token": {
+            "id": "ab48a9efdfedb23ty3494",
+            "expires": "2010-11-01T03:32:15-05:00",
+            "tenant": {
+                "id": "345",
+                "name": "My Project"
+            }
+        },
+        "user": {
+            "id": "123",
+            "name": "jqsmith",
+            "roles": [
+                {
+                    "id": "234",
+                    "name": "compute:admin",
+                },
+                {
+                    "id": "235",
+                    "name": "object-store:admin",
+                    "tenantId": "1",
+                }
+            ],
+            "roles_links": [],
+        },
+        "serviceCatalog": [
+            {
+                "name": "Cloud Servers",
+                "type": "compute",
+                "endpoints": [
+                    {
+                        "tenantId": "1",
+                        "publicURL": "https://compute1.host/v1/1234",
+                        "internalURL": "https://compute1.host/v1/1234",
+                        "region": "North",
+                        "versionId": "1.0",
+                        "versionInfo": "https://compute1.host/v1/",
+                        "versionList": "https://compute1.host/"
+                    },
+                    {
+                        "tenantId": "2",
+                        "publicURL": "https://compute1.host/v1/3456",
+                        "internalURL": "https://compute1.host/v1/3456",
+                        "region": "North",
+                        "versionId": "1.1",
+                        "versionInfo": "https://compute1.host/v1/",
+                        "versionList": "https://compute1.host/"
+                    },
+                ],
+                "endpoints_links": [],
+            },
+            {
+                "name": "Cinder Volume Service V2",
+                "type": "volume",
+                "endpoints": [
+                    {
+                        "tenantId": "1",
+                        "publicURL": "https://volume1.host/v2/1234",
+                        "internalURL": "https://volume1.host/v2/1234",
+                        "region": "South",
+                        "versionId": "2.0",
+                        "versionInfo": "uri",
+                        "versionList": "uri"
+                    },
+                    {
+                        "tenantId": "2",
+                        "publicURL": "https://volume1.host/v2/3456",
+                        "internalURL": "https://volume1.host/v2/3456",
+                        "region": "South",
+                        "versionId": "1.1",
+                        "versionInfo": "https://volume1.host/v2/",
+                        "versionList": "https://volume1.host/"
+                    },
+                ],
+                "endpoints_links": [
+                    {
+                        "rel": "next",
+                        "href": "https://identity1.host/v2.0/endpoints"
+                    },
+                ],
+            },
+        ],
+        "serviceCatalog_links": [
+            {
+                "rel": "next",
+                "href": "https://identity.host/v2.0/endpoints?session=2hfh8Ar",
+            },
+        ],
+    },
+}
+
+
+class ServiceCatalogTest(utils.TestCase):
+    def test_building_a_service_catalog(self):
+        sc = service_catalog.ServiceCatalog(SERVICE_CATALOG)
+
+        self.assertRaises(exceptions.AmbiguousEndpoints, sc.url_for,
+                          service_type='compute')
+        self.assertEqual("https://compute1.host/v1/1234",
+                         sc.url_for('tenantId', '1', service_type='compute'))
+        self.assertEqual("https://compute1.host/v1/3456",
+                         sc.url_for('tenantId', '2', service_type='compute'))
+
+        self.assertRaises(exceptions.EndpointNotFound, sc.url_for,
+                          "region", "South", service_type='compute')
+
+    def test_alternate_service_type(self):
+        sc = service_catalog.ServiceCatalog(SERVICE_CATALOG)
+
+        self.assertRaises(exceptions.AmbiguousEndpoints, sc.url_for,
+                          service_type='volume')
+        self.assertEqual("https://volume1.host/v1/1234",
+                         sc.url_for('tenantId', '1', service_type='volume'))
+        self.assertEqual("https://volume1.host/v1/3456",
+                         sc.url_for('tenantId', '2', service_type='volume'))
+
+        self.assertEqual("https://volume1.host/v2/3456",
+                         sc.url_for('tenantId', '2', service_type='volumev2'))
+        self.assertEqual("https://volume1.host/v2/3456",
+                         sc.url_for('tenantId', '2', service_type='volumev2'))
+
+        self.assertRaises(exceptions.EndpointNotFound, sc.url_for,
+                          "region", "North", service_type='volume')
+
+    def test_compatibility_service_type(self):
+        sc = service_catalog.ServiceCatalog(SERVICE_COMPATIBILITY_CATALOG)
+
+        self.assertEqual("https://volume1.host/v2/1234",
+                         sc.url_for('tenantId', '1', service_type='volume'))
+        self.assertEqual("https://volume1.host/v2/3456",
+                         sc.url_for('tenantId', '2', service_type='volume'))

awx/lib/site-packages/cinderclient/tests/test_shell.py

@@ -0,0 +1,154 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import argparse
+import re
+import sys
+
+import fixtures
+import requests_mock
+from six import moves
+from testtools import matchers
+
+from cinderclient import exceptions
+from cinderclient import shell
+from cinderclient.tests import utils
+from cinderclient.tests.fixture_data import keystone_client
+from keystoneclient.exceptions import DiscoveryFailure
+
+
+class ShellTest(utils.TestCase):
+
+    FAKE_ENV = {
+        'OS_USERNAME': 'username',
+        'OS_PASSWORD': 'password',
+        'OS_TENANT_NAME': 'tenant_name',
+        'OS_AUTH_URL': 'http://no.where',
+    }
+
+    # Patch os.environ to avoid required auth info.
+    def setUp(self):
+        super(ShellTest, self).setUp()
+        for var in self.FAKE_ENV:
+            self.useFixture(fixtures.EnvironmentVariable(var,
+                                                         self.FAKE_ENV[var]))
+
+    def shell(self, argstr):
+        orig = sys.stdout
+        try:
+            sys.stdout = moves.StringIO()
+            _shell = shell.OpenStackCinderShell()
+            _shell.main(argstr.split())
+        except SystemExit:
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            self.assertEqual(0, exc_value.code)
+        finally:
+            out = sys.stdout.getvalue()
+            sys.stdout.close()
+            sys.stdout = orig
+
+        return out
+
+    def test_help_unknown_command(self):
+        self.assertRaises(exceptions.CommandError, self.shell, 'help foofoo')
+
+    def test_help(self):
+        required = [
+            '.*?^usage: ',
+            '.*?(?m)^\s+create\s+Creates a volume.',
+            '.*?(?m)^Run "cinder help SUBCOMMAND" for help on a subcommand.',
+        ]
+        help_text = self.shell('help')
+        for r in required:
+            self.assertThat(help_text,
+                            matchers.MatchesRegex(r, re.DOTALL | re.MULTILINE))
+
+    def test_help_on_subcommand(self):
+        required = [
+            '.*?^usage: cinder list',
+            '.*?(?m)^Lists all volumes.',
+        ]
+        help_text = self.shell('help list')
+        for r in required:
+            self.assertThat(help_text,
+                            matchers.MatchesRegex(r, re.DOTALL | re.MULTILINE))
+
+    def register_keystone_auth_fixture(self, mocker, url):
+        mocker.register_uri('GET', url,
+                            text=keystone_client.keystone_request_callback)
+
+    @requests_mock.Mocker()
+    def test_version_discovery(self, mocker):
+        _shell = shell.OpenStackCinderShell()
+
+        os_auth_url = "https://WrongDiscoveryResponse.discovery.com:35357/v2.0"
+        self.register_keystone_auth_fixture(mocker, os_auth_url)
+        self.assertRaises(DiscoveryFailure, _shell._discover_auth_versions,
+                          None, auth_url=os_auth_url)
+
+        os_auth_url = "https://DiscoveryNotSupported.discovery.com:35357/v2.0"
+        self.register_keystone_auth_fixture(mocker, os_auth_url)
+        v2_url, v3_url = _shell._discover_auth_versions(
+            None, auth_url=os_auth_url)
+        self.assertEqual(v2_url, os_auth_url, "Expected v2 url")
+        self.assertEqual(v3_url, None, "Expected no v3 url")
+
+        os_auth_url = "https://DiscoveryNotSupported.discovery.com:35357/v3.0"
+        self.register_keystone_auth_fixture(mocker, os_auth_url)
+        v2_url, v3_url = _shell._discover_auth_versions(
+            None, auth_url=os_auth_url)
+        self.assertEqual(v3_url, os_auth_url, "Expected v3 url")
+        self.assertEqual(v2_url, None, "Expected no v2 url")
+
+
+class CinderClientArgumentParserTest(utils.TestCase):
+
+    def test_ambiguity_solved_for_one_visible_argument(self):
+        parser = shell.CinderClientArgumentParser(add_help=False)
+        parser.add_argument('--test-parameter',
+                            dest='visible_param',
+                            action='store_true')
+        parser.add_argument('--test_parameter',
+                            dest='hidden_param',
+                            action='store_true',
+                            help=argparse.SUPPRESS)
+
+        opts = parser.parse_args(['--test'])
+
+        # visible argument must be set
+        self.assertTrue(opts.visible_param)
+        self.assertFalse(opts.hidden_param)
+
+    def test_raise_ambiguity_error_two_visible_argument(self):
+        parser = shell.CinderClientArgumentParser(add_help=False)
+        parser.add_argument('--test-parameter',
+                            dest="visible_param1",
+                            action='store_true')
+        parser.add_argument('--test_parameter',
+                            dest="visible_param2",
+                            action='store_true')
+
+        self.assertRaises(SystemExit, parser.parse_args, ['--test'])
+
+    def test_raise_ambiguity_error_two_hidden_argument(self):
+        parser = shell.CinderClientArgumentParser(add_help=False)
+        parser.add_argument('--test-parameter',
+                            dest="hidden_param1",
+                            action='store_true',
+                            help=argparse.SUPPRESS)
+        parser.add_argument('--test_parameter',
+                            dest="hidden_param2",
+                            action='store_true',
+                            help=argparse.SUPPRESS)
+
+        self.assertRaises(SystemExit, parser.parse_args, ['--test'])

awx/lib/site-packages/cinderclient/tests/test_utils.py

@@ -0,0 +1,140 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import collections
+import sys
+
+from six import moves
+
+from cinderclient import exceptions
+from cinderclient import utils
+from cinderclient import base
+from cinderclient.tests import utils as test_utils
+
+UUID = '8e8ec658-c7b0-4243-bdf8-6f7f2952c0d0'
+
+
+class FakeResource(object):
+
+    def __init__(self, _id, properties):
+        self.id = _id
+        try:
+            self.name = properties['name']
+        except KeyError:
+            pass
+        try:
+            self.display_name = properties['display_name']
+        except KeyError:
+            pass
+
+
+class FakeManager(base.ManagerWithFind):
+
+    resource_class = FakeResource
+
+    resources = [
+        FakeResource('1234', {'name': 'entity_one'}),
+        FakeResource(UUID, {'name': 'entity_two'}),
+        FakeResource('4242', {'display_name': 'entity_three'}),
+        FakeResource('5678', {'name': '9876'})
+    ]
+
+    def get(self, resource_id):
+        for resource in self.resources:
+            if resource.id == str(resource_id):
+                return resource
+        raise exceptions.NotFound(resource_id)
+
+    def list(self, search_opts):
+        return self.resources
+
+
+class FindResourceTestCase(test_utils.TestCase):
+
+    def setUp(self):
+        super(FindResourceTestCase, self).setUp()
+        self.manager = FakeManager(None)
+
+    def test_find_none(self):
+        self.assertRaises(exceptions.CommandError,
+                          utils.find_resource,
+                          self.manager,
+                          'asdf')
+
+    def test_find_by_integer_id(self):
+        output = utils.find_resource(self.manager, 1234)
+        self.assertEqual(self.manager.get('1234'), output)
+
+    def test_find_by_str_id(self):
+        output = utils.find_resource(self.manager, '1234')
+        self.assertEqual(self.manager.get('1234'), output)
+
+    def test_find_by_uuid(self):
+        output = utils.find_resource(self.manager, UUID)
+        self.assertEqual(self.manager.get(UUID), output)
+
+    def test_find_by_str_name(self):
+        output = utils.find_resource(self.manager, 'entity_one')
+        self.assertEqual(self.manager.get('1234'), output)
+
+    def test_find_by_str_displayname(self):
+        output = utils.find_resource(self.manager, 'entity_three')
+        self.assertEqual(self.manager.get('4242'), output)
+
+
+class CaptureStdout(object):
+    """Context manager for capturing stdout from statments in its's block."""
+    def __enter__(self):
+        self.real_stdout = sys.stdout
+        self.stringio = moves.StringIO()
+        sys.stdout = self.stringio
+        return self
+
+    def __exit__(self, *args):
+        sys.stdout = self.real_stdout
+        self.stringio.seek(0)
+        self.read = self.stringio.read
+
+
+class PrintListTestCase(test_utils.TestCase):
+
+    def test_print_list_with_list(self):
+        Row = collections.namedtuple('Row', ['a', 'b'])
+        to_print = [Row(a=1, b=2), Row(a=3, b=4)]
+        with CaptureStdout() as cso:
+            utils.print_list(to_print, ['a', 'b'])
+        self.assertEqual("""\
++---+---+
+| a | b |
++---+---+
+| 1 | 2 |
+| 3 | 4 |
++---+---+
+""", cso.read())
+
+    def test_print_list_with_generator(self):
+        Row = collections.namedtuple('Row', ['a', 'b'])
+
+        def gen_rows():
+            for row in [Row(a=1, b=2), Row(a=3, b=4)]:
+                yield row
+        with CaptureStdout() as cso:
+            utils.print_list(gen_rows(), ['a', 'b'])
+        self.assertEqual("""\
++---+---+
+| a | b |
++---+---+
+| 1 | 2 |
+| 3 | 4 |
++---+---+
+""", cso.read())

awx/lib/site-packages/cinderclient/tests/utils.py

@@ -0,0 +1,99 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+
+import fixtures
+import requests
+from requests_mock.contrib import fixture as requests_mock_fixture
+import six
+import testtools
+
+
+class TestCase(testtools.TestCase):
+    TEST_REQUEST_BASE = {
+        'verify': True,
+    }
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+        if (os.environ.get('OS_STDOUT_CAPTURE') == 'True' or
+                os.environ.get('OS_STDOUT_CAPTURE') == '1'):
+            stdout = self.useFixture(fixtures.StringStream('stdout')).stream
+            self.useFixture(fixtures.MonkeyPatch('sys.stdout', stdout))
+        if (os.environ.get('OS_STDERR_CAPTURE') == 'True' or
+                os.environ.get('OS_STDERR_CAPTURE') == '1'):
+            stderr = self.useFixture(fixtures.StringStream('stderr')).stream
+            self.useFixture(fixtures.MonkeyPatch('sys.stderr', stderr))
+
+
+class FixturedTestCase(TestCase):
+
+    client_fixture_class = None
+    data_fixture_class = None
+
+    def setUp(self):
+        super(FixturedTestCase, self).setUp()
+
+        self.requests = self.useFixture(requests_mock_fixture.Fixture())
+        self.data_fixture = None
+        self.client_fixture = None
+        self.cs = None
+
+        if self.client_fixture_class:
+            fix = self.client_fixture_class(self.requests)
+            self.client_fixture = self.useFixture(fix)
+            self.cs = self.client_fixture.new_client()
+
+        if self.data_fixture_class:
+            fix = self.data_fixture_class(self.requests)
+            self.data_fixture = self.useFixture(fix)
+
+    def assert_called(self, method, path, body=None):
+        self.assertEqual(self.requests.last_request.method, method)
+        self.assertEqual(self.requests.last_request.path_url, path)
+
+        if body:
+            req_data = self.requests.last_request.body
+            if isinstance(req_data, six.binary_type):
+                req_data = req_data.decode('utf-8')
+            if not isinstance(body, six.string_types):
+                # json load if the input body to match against is not a string
+                req_data = json.loads(req_data)
+            self.assertEqual(req_data, body)
+
+
+class TestResponse(requests.Response):
+    """Class used to wrap requests.Response and provide some
+       convenience to initialize with a dict.
+    """
+
+    def __init__(self, data):
+        self._text = None
+        super(TestResponse, self)
+        if isinstance(data, dict):
+            self.status_code = data.get('status_code', None)
+            self.headers = data.get('headers', None)
+            self.reason = data.get('reason', '')
+            # Fake the text attribute to streamline Response creation
+            self._text = data.get('text', None)
+        else:
+            self.status_code = data
+
+    def __eq__(self, other):
+        return self.__dict__ == other.__dict__
+
+    @property
+    def text(self):
+        return self._text

awx/lib/site-packages/cinderclient/tests/v1/contrib/test_list_extensions.py

@@ -0,0 +1,34 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cinderclient import extension
+from cinderclient.v1.contrib import list_extensions
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+extensions = [
+    extension.Extension(list_extensions.__name__.split(".")[-1],
+                        list_extensions),
+]
+cs = fakes.FakeClient(extensions=extensions)
+
+
+class ListExtensionsTests(utils.TestCase):
+    def test_list_extensions(self):
+        all_exts = cs.list_extensions.show_all()
+        cs.assert_called('GET', '/extensions')
+        self.assertTrue(len(all_exts) > 0)
+        for r in all_exts:
+            self.assertTrue(len(r.summary) > 0)

awx/lib/site-packages/cinderclient/tests/v1/fakes.py

@@ -0,0 +1,795 @@
+# Copyright (c) 2011 X.commerce, a business unit of eBay Inc.
+# Copyright (c) 2011 OpenStack Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime
+
+try:
+    import urlparse
+except ImportError:
+    import urllib.parse as urlparse
+
+from cinderclient import client as base_client
+from cinderclient.tests import fakes
+import cinderclient.tests.utils as utils
+from cinderclient.v1 import client
+
+
+def _stub_volume(**kwargs):
+    volume = {
+        'id': '1234',
+        'display_name': None,
+        'display_description': None,
+        "attachments": [],
+        "bootable": "false",
+        "availability_zone": "cinder",
+        "created_at": "2012-08-27T00:00:00.000000",
+        "id": '00000000-0000-0000-0000-000000000000',
+        "metadata": {},
+        "size": 1,
+        "snapshot_id": None,
+        "status": "available",
+        "volume_type": "None",
+    }
+    volume.update(kwargs)
+    return volume
+
+
+def _stub_snapshot(**kwargs):
+    snapshot = {
+        "created_at": "2012-08-28T16:30:31.000000",
+        "display_description": None,
+        "display_name": None,
+        "id": '11111111-1111-1111-1111-111111111111',
+        "size": 1,
+        "status": "available",
+        "volume_id": '00000000-0000-0000-0000-000000000000',
+    }
+    snapshot.update(kwargs)
+    return snapshot
+
+
+def _self_href(base_uri, tenant_id, backup_id):
+    return '%s/v1/%s/backups/%s' % (base_uri, tenant_id, backup_id)
+
+
+def _bookmark_href(base_uri, tenant_id, backup_id):
+    return '%s/%s/backups/%s' % (base_uri, tenant_id, backup_id)
+
+
+def _stub_backup_full(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'backup',
+        'description': 'nightly backup',
+        'volume_id': '712f4980-5ac1-41e5-9383-390aa7c9f58b',
+        'container': 'volumebackups',
+        'object_count': 220,
+        'size': 10,
+        'availability_zone': 'az1',
+        'created_at': '2013-04-12T08:16:37.000000',
+        'status': 'available',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_backup(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'backup',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_restore():
+    return {'volume_id': '712f4980-5ac1-41e5-9383-390aa7c9f58b'}
+
+
+def _stub_qos_full(id, base_uri, tenant_id, name=None, specs=None):
+    if not name:
+        name = 'fake-name'
+    if not specs:
+        specs = {}
+
+    return {
+        'qos_specs': {
+            'id': id,
+            'name': name,
+            'consumer': 'back-end',
+            'specs': specs,
+        },
+        'links': {
+            'href': _bookmark_href(base_uri, tenant_id, id),
+            'rel': 'bookmark'
+        }
+    }
+
+
+def _stub_qos_associates(id, name):
+    return {
+        'assoications_type': 'volume_type',
+        'name': name,
+        'id': id,
+    }
+
+
+def _stub_transfer_full(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'transfer',
+        'volume_id': '8c05f861-6052-4df6-b3e0-0aebfbe686cc',
+        'created_at': '2013-04-12T08:16:37.000000',
+        'auth_key': '123456',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_transfer(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'transfer',
+        'volume_id': '8c05f861-6052-4df6-b3e0-0aebfbe686cc',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_extend(id, new_size):
+    return {'volume_id': '712f4980-5ac1-41e5-9383-390aa7c9f58b'}
+
+
+class FakeClient(fakes.FakeClient, client.Client):
+
+    def __init__(self, *args, **kwargs):
+        client.Client.__init__(self, 'username', 'password',
+                               'project_id', 'auth_url',
+                               extensions=kwargs.get('extensions'))
+        self.client = FakeHTTPClient(**kwargs)
+
+    def get_volume_api_version_from_endpoint(self):
+        return self.client.get_volume_api_version_from_endpoint()
+
+
+class FakeHTTPClient(base_client.HTTPClient):
+
+    def __init__(self, **kwargs):
+        self.username = 'username'
+        self.password = 'password'
+        self.auth_url = 'auth_url'
+        self.callstack = []
+        self.management_url = 'http://10.0.2.15:8776/v1/fake'
+
+    def _cs_request(self, url, method, **kwargs):
+        # Check that certain things are called correctly
+        if method in ['GET', 'DELETE']:
+            assert 'body' not in kwargs
+        elif method == 'PUT':
+            assert 'body' in kwargs
+
+        # Call the method
+        args = urlparse.parse_qsl(urlparse.urlparse(url)[4])
+        kwargs.update(args)
+        munged_url = url.rsplit('?', 1)[0]
+        munged_url = munged_url.strip('/').replace('/', '_').replace('.', '_')
+        munged_url = munged_url.replace('-', '_')
+
+        callback = "%s_%s" % (method.lower(), munged_url)
+
+        if not hasattr(self, callback):
+            raise AssertionError('Called unknown API method: %s %s, '
+                                 'expected fakes method name: %s' %
+                                 (method, url, callback))
+
+        # Note the call
+        self.callstack.append((method, url, kwargs.get('body', None)))
+        status, headers, body = getattr(self, callback)(**kwargs)
+        r = utils.TestResponse({
+            "status_code": status,
+            "text": body,
+            "headers": headers,
+        })
+        return r, body
+
+        if hasattr(status, 'items'):
+            return utils.TestResponse(status), body
+        else:
+            return utils.TestResponse({"status": status}), body
+
+    def get_volume_api_version_from_endpoint(self):
+        magic_tuple = urlparse.urlsplit(self.management_url)
+        scheme, netloc, path, query, frag = magic_tuple
+        return path.lstrip('/').split('/')[0][1:]
+
+    #
+    # Snapshots
+    #
+
+    def get_snapshots_detail(self, **kw):
+        return (200, {}, {'snapshots': [
+            _stub_snapshot(),
+        ]})
+
+    def get_snapshots_1234(self, **kw):
+        return (200, {}, {'snapshot': _stub_snapshot(id='1234')})
+
+    def get_snapshots_5678(self, **kw):
+        return (200, {}, {'snapshot': _stub_snapshot(id='5678')})
+
+    def put_snapshots_1234(self, **kw):
+        snapshot = _stub_snapshot(id='1234')
+        snapshot.update(kw['body']['snapshot'])
+        return (200, {}, {'snapshot': snapshot})
+
+    def post_snapshots_1234_action(self, body, **kw):
+        _body = None
+        resp = 202
+        assert len(list(body)) == 1
+        action = list(body)[0]
+        if action == 'os-reset_status':
+            assert 'status' in body['os-reset_status']
+        elif action == 'os-update_snapshot_status':
+            assert 'status' in body['os-update_snapshot_status']
+        else:
+            raise AssertionError("Unexpected action: %s" % action)
+        return (resp, {}, _body)
+
+    def post_snapshots_5678_action(self, body, **kw):
+        return self.post_snapshots_1234_action(body, **kw)
+
+    def delete_snapshots_1234(self, **kw):
+        return (202, {}, {})
+
+    def delete_snapshots_5678(self, **kw):
+        return (202, {}, {})
+
+    #
+    # Volumes
+    #
+
+    def put_volumes_1234(self, **kw):
+        volume = _stub_volume(id='1234')
+        volume.update(kw['body']['volume'])
+        return (200, {}, {'volume': volume})
+
+    def get_volumes(self, **kw):
+        return (200, {}, {"volumes": [
+            {'id': 1234, 'name': 'sample-volume'},
+            {'id': 5678, 'name': 'sample-volume2'}
+        ]})
+
+    # TODO(jdg): This will need to change
+    # at the very least it's not complete
+    def get_volumes_detail(self, **kw):
+        return (200, {}, {"volumes": [
+            {'id': kw.get('id', 1234),
+             'name': 'sample-volume',
+             'attachments': [{'server_id': 1234}]},
+        ]})
+
+    def get_volumes_1234(self, **kw):
+        r = {'volume': self.get_volumes_detail(id=1234)[2]['volumes'][0]}
+        return (200, {}, r)
+
+    def get_volumes_5678(self, **kw):
+        r = {'volume': self.get_volumes_detail(id=5678)[2]['volumes'][0]}
+        return (200, {}, r)
+
+    def get_volumes_1234_encryption(self, **kw):
+        r = {'encryption_key_id': 'id'}
+        return (200, {}, r)
+
+    def post_volumes_1234_action(self, body, **kw):
+        _body = None
+        resp = 202
+        assert len(list(body)) == 1
+        action = list(body)[0]
+        if action == 'os-attach':
+            assert sorted(list(body[action])) == ['instance_uuid',
+                                                  'mode',
+                                                  'mountpoint']
+        elif action == 'os-detach':
+            assert body[action] is None
+        elif action == 'os-reserve':
+            assert body[action] is None
+        elif action == 'os-unreserve':
+            assert body[action] is None
+        elif action == 'os-initialize_connection':
+            assert list(body[action]) == ['connector']
+            return (202, {}, {'connection_info': 'foos'})
+        elif action == 'os-terminate_connection':
+            assert list(body[action]) == ['connector']
+        elif action == 'os-begin_detaching':
+            assert body[action] is None
+        elif action == 'os-roll_detaching':
+            assert body[action] is None
+        elif action == 'os-reset_status':
+            assert 'status' in body[action]
+        elif action == 'os-extend':
+            assert list(body[action]) == ['new_size']
+        elif action == 'os-migrate_volume':
+            assert 'host' in body[action]
+            assert 'force_host_copy' in body[action]
+        elif action == 'os-update_readonly_flag':
+            assert list(body[action]) == ['readonly']
+        elif action == 'os-set_bootable':
+            assert list(body[action]) == ['bootable']
+        else:
+            raise AssertionError("Unexpected action: %s" % action)
+        return (resp, {}, _body)
+
+    def post_volumes_5678_action(self, body, **kw):
+        return self.post_volumes_1234_action(body, **kw)
+
+    def post_volumes(self, **kw):
+        return (202, {}, {'volume': {}})
+
+    def delete_volumes_1234(self, **kw):
+        return (202, {}, None)
+
+    def delete_volumes_5678(self, **kw):
+        return (202, {}, None)
+
+    #
+    # Quotas
+    #
+
+    def get_os_quota_sets_test(self, **kw):
+        return (200, {}, {'quota_set': {
+                          'tenant_id': 'test',
+                          'metadata_items': [],
+                          'volumes': 1,
+                          'snapshots': 1,
+                          'gigabytes': 1}})
+
+    def get_os_quota_sets_test_defaults(self):
+        return (200, {}, {'quota_set': {
+                          'tenant_id': 'test',
+                          'metadata_items': [],
+                          'volumes': 1,
+                          'snapshots': 1,
+                          'gigabytes': 1}})
+
+    def put_os_quota_sets_test(self, body, **kw):
+        assert list(body) == ['quota_set']
+        fakes.assert_has_keys(body['quota_set'],
+                              required=['tenant_id'])
+        return (200, {}, {'quota_set': {
+                          'tenant_id': 'test',
+                          'metadata_items': [],
+                          'volumes': 2,
+                          'snapshots': 2,
+                          'gigabytes': 1}})
+
+    def delete_os_quota_sets_1234(self, **kw):
+        return (200, {}, {})
+
+    def delete_os_quota_sets_test(self, **kw):
+        return (200, {}, {})
+
+    #
+    # Quota Classes
+    #
+
+    def get_os_quota_class_sets_test(self, **kw):
+        return (200, {}, {'quota_class_set': {
+                          'class_name': 'test',
+                          'metadata_items': [],
+                          'volumes': 1,
+                          'snapshots': 1,
+                          'gigabytes': 1}})
+
+    def put_os_quota_class_sets_test(self, body, **kw):
+        assert list(body) == ['quota_class_set']
+        fakes.assert_has_keys(body['quota_class_set'],
+                              required=['class_name'])
+        return (200, {}, {'quota_class_set': {
+                          'class_name': 'test',
+                          'metadata_items': [],
+                          'volumes': 2,
+                          'snapshots': 2,
+                          'gigabytes': 1}})
+
+    #
+    # VolumeTypes
+    #
+    def get_types(self, **kw):
+        return (200, {}, {
+            'volume_types': [{'id': 1,
+                              'name': 'test-type-1',
+                              'extra_specs': {}},
+                             {'id': 2,
+                              'name': 'test-type-2',
+                              'extra_specs': {}}]})
+
+    def get_types_1(self, **kw):
+        return (200, {}, {'volume_type': {'id': 1,
+                          'name': 'test-type-1',
+                          'extra_specs': {}}})
+
+    def get_types_2(self, **kw):
+        return (200, {}, {'volume_type': {'id': 2,
+                          'name': 'test-type-2',
+                          'extra_specs': {}}})
+
+    def post_types(self, body, **kw):
+        return (202, {}, {'volume_type': {'id': 3,
+                          'name': 'test-type-3',
+                          'extra_specs': {}}})
+
+    def post_types_1_extra_specs(self, body, **kw):
+        assert list(body) == ['extra_specs']
+        return (200, {}, {'extra_specs': {'k': 'v'}})
+
+    def delete_types_1_extra_specs_k(self, **kw):
+        return(204, {}, None)
+
+    def delete_types_1(self, **kw):
+        return (202, {}, None)
+
+    #
+    # VolumeEncryptionTypes
+    #
+    def get_types_1_encryption(self, **kw):
+        return (200, {}, {'id': 1, 'volume_type_id': 1, 'provider': 'test',
+                          'cipher': 'test', 'key_size': 1,
+                          'control_location': 'front-end'})
+
+    def get_types_2_encryption(self, **kw):
+        return (200, {}, {})
+
+    def post_types_2_encryption(self, body, **kw):
+        return (200, {}, {'encryption': body})
+
+    def put_types_1_encryption_1(self, body, **kw):
+        return (200, {}, {})
+
+    def delete_types_1_encryption_provider(self, **kw):
+        return (202, {}, None)
+
+    #
+    # Set/Unset metadata
+    #
+    def delete_volumes_1234_metadata_test_key(self, **kw):
+        return (204, {}, None)
+
+    def delete_volumes_1234_metadata_key1(self, **kw):
+        return (204, {}, None)
+
+    def delete_volumes_1234_metadata_key2(self, **kw):
+        return (204, {}, None)
+
+    def post_volumes_1234_metadata(self, **kw):
+        return (204, {}, {'metadata': {'test_key': 'test_value'}})
+
+    #
+    # List all extensions
+    #
+    def get_extensions(self, **kw):
+        exts = [
+            {
+                "alias": "FAKE-1",
+                "description": "Fake extension number 1",
+                "links": [],
+                "name": "Fake1",
+                "namespace": ("http://docs.openstack.org/"
+                              "/ext/fake1/api/v1.1"),
+                "updated": "2011-06-09T00:00:00+00:00"
+            },
+            {
+                "alias": "FAKE-2",
+                "description": "Fake extension number 2",
+                "links": [],
+                "name": "Fake2",
+                "namespace": ("http://docs.openstack.org/"
+                              "/ext/fake1/api/v1.1"),
+                "updated": "2011-06-09T00:00:00+00:00"
+            },
+        ]
+        return (200, {}, {"extensions": exts, })
+
+    #
+    # VolumeBackups
+    #
+
+    def get_backups_76a17945_3c6f_435c_975b_b5685db10b62(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        backup1 = '76a17945-3c6f-435c-975b-b5685db10b62'
+        return (200, {},
+                {'backup': _stub_backup_full(backup1, base_uri, tenant_id)})
+
+    def get_backups_detail(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        backup1 = '76a17945-3c6f-435c-975b-b5685db10b62'
+        backup2 = 'd09534c6-08b8-4441-9e87-8976f3a8f699'
+        return (200, {},
+                {'backups': [
+                    _stub_backup_full(backup1, base_uri, tenant_id),
+                    _stub_backup_full(backup2, base_uri, tenant_id)]})
+
+    def delete_backups_76a17945_3c6f_435c_975b_b5685db10b62(self, **kw):
+        return (202, {}, None)
+
+    def post_backups(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        backup1 = '76a17945-3c6f-435c-975b-b5685db10b62'
+        return (202, {},
+                {'backup': _stub_backup(backup1, base_uri, tenant_id)})
+
+    def post_backups_76a17945_3c6f_435c_975b_b5685db10b62_restore(self, **kw):
+        return (200, {},
+                {'restore': _stub_restore()})
+
+    def post_backups_1234_restore(self, **kw):
+        return (200, {},
+                {'restore': _stub_restore()})
+
+    #
+    # QoSSpecs
+    #
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        qos_id1 = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        return (200, {},
+                _stub_qos_full(qos_id1, base_uri, tenant_id))
+
+    def get_qos_specs(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        qos_id1 = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        qos_id2 = '0FD8DD14-A396-4E55-9573-1FE59042E95B'
+        return (200, {},
+                {'qos_specs': [
+                    _stub_qos_full(qos_id1, base_uri, tenant_id, 'name-1'),
+                    _stub_qos_full(qos_id2, base_uri, tenant_id)]})
+
+    def post_qos_specs(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        qos_name = 'qos-name'
+        return (202, {},
+                _stub_qos_full(qos_id, base_uri, tenant_id, qos_name))
+
+    def put_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C(self, **kw):
+        return (202, {}, None)
+
+    def put_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_delete_keys(
+            self, **kw):
+        return (202, {}, None)
+
+    def delete_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C(self, **kw):
+        return (202, {}, None)
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_associations(
+            self, **kw):
+        type_id1 = '4230B13A-7A37-4E84-B777-EFBA6FCEE4FF'
+        type_id2 = '4230B13A-AB37-4E84-B777-EFBA6FCEE4FF'
+        type_name1 = 'type1'
+        type_name2 = 'type2'
+        return (202, {},
+                {'qos_associations': [
+                    _stub_qos_associates(type_id1, type_name1),
+                    _stub_qos_associates(type_id2, type_name2)]})
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_associate(
+            self, **kw):
+        return (202, {}, None)
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_disassociate(
+            self, **kw):
+        return (202, {}, None)
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_disassociate_all(
+            self, **kw):
+        return (202, {}, None)
+
+    #
+    # VolumeTransfers
+    #
+
+    def get_os_volume_transfer_5678(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        return (200, {},
+                {'transfer':
+                 _stub_transfer_full(transfer1, base_uri, tenant_id)})
+
+    def get_os_volume_transfer_detail(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        transfer2 = 'f625ec3e-13dd-4498-a22a-50afd534cc41'
+        return (200, {},
+                {'transfers': [
+                    _stub_transfer_full(transfer1, base_uri, tenant_id),
+                    _stub_transfer_full(transfer2, base_uri, tenant_id)]})
+
+    def delete_os_volume_transfer_5678(self, **kw):
+        return (202, {}, None)
+
+    def post_os_volume_transfer(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        return (202, {},
+                {'transfer': _stub_transfer(transfer1, base_uri, tenant_id)})
+
+    def post_os_volume_transfer_5678_accept(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        return (200, {},
+                {'transfer': _stub_transfer(transfer1, base_uri, tenant_id)})
+
+    #
+    # Services
+    #
+    def get_os_services(self, **kw):
+        host = kw.get('host', None)
+        binary = kw.get('binary', None)
+        services = [
+            {
+                'binary': 'cinder-volume',
+                'host': 'host1',
+                'zone': 'cinder',
+                'status': 'enabled',
+                'state': 'up',
+                'updated_at': datetime(2012, 10, 29, 13, 42, 2)
+            },
+            {
+                'binary': 'cinder-volume',
+                'host': 'host2',
+                'zone': 'cinder',
+                'status': 'disabled',
+                'state': 'down',
+                'updated_at': datetime(2012, 9, 18, 8, 3, 38)
+            },
+            {
+                'binary': 'cinder-scheduler',
+                'host': 'host2',
+                'zone': 'cinder',
+                'status': 'disabled',
+                'state': 'down',
+                'updated_at': datetime(2012, 9, 18, 8, 3, 38)
+            },
+        ]
+        if host:
+            services = filter(lambda i: i['host'] == host, services)
+        if binary:
+            services = filter(lambda i: i['binary'] == binary, services)
+        return (200, {}, {'services': services})
+
+    def put_os_services_enable(self, body, **kw):
+        return (200, {}, {'host': body['host'], 'binary': body['binary'],
+                'status': 'enabled'})
+
+    def put_os_services_disable(self, body, **kw):
+        return (200, {}, {'host': body['host'], 'binary': body['binary'],
+                'status': 'disabled'})
+
+    def put_os_services_disable_log_reason(self, body, **kw):
+        return (200, {}, {'host': body['host'], 'binary': body['binary'],
+                'status': 'disabled',
+                'disabled_reason': body['disabled_reason']})
+
+    def get_os_availability_zone(self, **kw):
+        return (200, {}, {
+            "availabilityZoneInfo": [
+                {
+                    "zoneName": "zone-1",
+                    "zoneState": {"available": True},
+                    "hosts": None,
+                },
+                {
+                    "zoneName": "zone-2",
+                    "zoneState": {"available": False},
+                    "hosts": None,
+                },
+                ]
+        })
+
+    def get_os_availability_zone_detail(self, **kw):
+        return (200, {}, {
+            "availabilityZoneInfo": [
+                {
+                    "zoneName": "zone-1",
+                    "zoneState": {"available": True},
+                    "hosts": {
+                        "fake_host-1": {
+                            "cinder-volume": {
+                                "active": True,
+                                "available": True,
+                                "updated_at":
+                                datetime(2012, 12, 26, 14, 45, 25, 0)
+                            }
+                        }
+                    }
+                },
+                {
+                    "zoneName": "internal",
+                    "zoneState": {"available": True},
+                    "hosts": {
+                        "fake_host-1": {
+                            "cinder-sched": {
+                                "active": True,
+                                "available": True,
+                                "updated_at":
+                                datetime(2012, 12, 26, 14, 45, 24, 0)
+                            }
+                        }
+                    }
+                },
+                {
+                    "zoneName": "zone-2",
+                    "zoneState": {"available": False},
+                    "hosts": None,
+                },
+                ]
+        })
+
+    def post_snapshots_1234_metadata(self, **kw):
+        return (200, {}, {"metadata": {"key1": "val1", "key2": "val2"}})
+
+    def delete_snapshots_1234_metadata_key1(self, **kw):
+        return (200, {}, None)
+
+    def delete_snapshots_1234_metadata_key2(self, **kw):
+        return (200, {}, None)
+
+    def put_volumes_1234_metadata(self, **kw):
+        return (200, {}, {"metadata": {"key1": "val1", "key2": "val2"}})
+
+    def put_snapshots_1234_metadata(self, **kw):
+        return (200, {}, {"metadata": {"key1": "val1", "key2": "val2"}})

awx/lib/site-packages/cinderclient/tests/v1/test_auth.py

@@ -0,0 +1,338 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import mock
+
+import requests
+
+from cinderclient.v1 import client
+from cinderclient import exceptions
+from cinderclient.tests import utils
+
+
+class AuthenticateAgainstKeystoneTests(utils.TestCase):
+    def test_authenticate_success(self):
+        cs = client.Client("username", "password", "project_id",
+                           "http://localhost:8776/v1", service_type='volume')
+        resp = {
+            "access": {
+                "token": {
+                    "expires": "2014-11-01T03:32:15-05:00",
+                    "id": "FAKE_ID",
+                },
+                "serviceCatalog": [
+                    {
+                        "type": "volume",
+                        "endpoints": [
+                            {
+                                "region": "RegionOne",
+                                "adminURL": "http://localhost:8776/v1",
+                                "internalURL": "http://localhost:8776/v1",
+                                "publicURL": "http://localhost:8776/v1",
+                            },
+                        ],
+                    },
+                ],
+            },
+        }
+        auth_response = utils.TestResponse({
+            "status_code": 200,
+            "text": json.dumps(resp),
+        })
+
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'User-Agent': cs.client.USER_AGENT,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            }
+            body = {
+                'auth': {
+                    'passwordCredentials': {
+                        'username': cs.client.user,
+                        'password': cs.client.password,
+                    },
+                    'tenantName': cs.client.projectid,
+                },
+            }
+
+            token_url = cs.client.auth_url + "/tokens"
+            mock_request.assert_called_with(
+                "POST",
+                token_url,
+                headers=headers,
+                data=json.dumps(body),
+                allow_redirects=True,
+                **self.TEST_REQUEST_BASE)
+
+            endpoints = resp["access"]["serviceCatalog"][0]['endpoints']
+            public_url = endpoints[0]["publicURL"].rstrip('/')
+            self.assertEqual(public_url, cs.client.management_url)
+            token_id = resp["access"]["token"]["id"]
+            self.assertEqual(token_id, cs.client.auth_token)
+
+        test_auth_call()
+
+    def test_authenticate_tenant_id(self):
+        cs = client.Client("username", "password",
+                           auth_url="http://localhost:8776/v1",
+                           tenant_id='tenant_id', service_type='volume')
+        resp = {
+            "access": {
+                "token": {
+                    "expires": "2014-11-01T03:32:15-05:00",
+                    "id": "FAKE_ID",
+                    "tenant": {
+                        "description": None,
+                        "enabled": True,
+                        "id": "tenant_id",
+                        "name": "demo"
+                    }  # tenant associated with token
+                },
+                "serviceCatalog": [
+                    {
+                        "type": "volume",
+                        "endpoints": [
+                            {
+                                "region": "RegionOne",
+                                "adminURL": "http://localhost:8776/v1",
+                                "internalURL": "http://localhost:8776/v1",
+                                "publicURL": "http://localhost:8776/v1",
+                            },
+                        ],
+                    },
+                ],
+            },
+        }
+        auth_response = utils.TestResponse({
+            "status_code": 200,
+            "text": json.dumps(resp),
+        })
+
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'User-Agent': cs.client.USER_AGENT,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            }
+            body = {
+                'auth': {
+                    'passwordCredentials': {
+                        'username': cs.client.user,
+                        'password': cs.client.password,
+                    },
+                    'tenantId': cs.client.tenant_id,
+                },
+            }
+
+            token_url = cs.client.auth_url + "/tokens"
+            mock_request.assert_called_with(
+                "POST",
+                token_url,
+                headers=headers,
+                data=json.dumps(body),
+                allow_redirects=True,
+                **self.TEST_REQUEST_BASE)
+
+            endpoints = resp["access"]["serviceCatalog"][0]['endpoints']
+            public_url = endpoints[0]["publicURL"].rstrip('/')
+            self.assertEqual(public_url, cs.client.management_url)
+            token_id = resp["access"]["token"]["id"]
+            self.assertEqual(token_id, cs.client.auth_token)
+            tenant_id = resp["access"]["token"]["tenant"]["id"]
+            self.assertEqual(tenant_id, cs.client.tenant_id)
+
+        test_auth_call()
+
+    def test_authenticate_failure(self):
+        cs = client.Client("username", "password", "project_id",
+                           "http://localhost:8776/v1")
+        resp = {"unauthorized": {"message": "Unauthorized", "code": "401"}}
+        auth_response = utils.TestResponse({
+            "status_code": 401,
+            "text": json.dumps(resp),
+        })
+
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            self.assertRaises(exceptions.Unauthorized, cs.client.authenticate)
+
+        test_auth_call()
+
+    def test_auth_redirect(self):
+        cs = client.Client("username", "password", "project_id",
+                           "http://localhost:8776/v1", service_type='volume')
+        dict_correct_response = {
+            "access": {
+                "token": {
+                    "expires": "2014-11-01T03:32:15-05:00",
+                    "id": "FAKE_ID",
+                },
+                "serviceCatalog": [
+                    {
+                        "type": "volume",
+                        "endpoints": [
+                            {
+                                "adminURL": "http://localhost:8776/v1",
+                                "region": "RegionOne",
+                                "internalURL": "http://localhost:8776/v1",
+                                "publicURL": "http://localhost:8776/v1/",
+                            },
+                        ],
+                    },
+                ],
+            },
+        }
+        correct_response = json.dumps(dict_correct_response)
+        dict_responses = [
+            {"headers": {'location': 'http://127.0.0.1:5001'},
+             "status_code": 305,
+             "text": "Use proxy"},
+            # Configured on admin port, cinder redirects to v2.0 port.
+            # When trying to connect on it, keystone auth succeed by v1.0
+            # protocol (through headers) but tokens are being returned in
+            # body (looks like keystone bug). Leaved for compatibility.
+            {"headers": {},
+             "status_code": 200,
+             "text": correct_response},
+            {"headers": {},
+             "status_code": 200,
+             "text": correct_response}
+        ]
+
+        responses = [(utils.TestResponse(resp)) for resp in dict_responses]
+
+        def side_effect(*args, **kwargs):
+            return responses.pop(0)
+
+        mock_request = mock.Mock(side_effect=side_effect)
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'User-Agent': cs.client.USER_AGENT,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            }
+            body = {
+                'auth': {
+                    'passwordCredentials': {
+                        'username': cs.client.user,
+                        'password': cs.client.password,
+                    },
+                    'tenantName': cs.client.projectid,
+                },
+            }
+
+            token_url = cs.client.auth_url + "/tokens"
+            mock_request.assert_called_with(
+                "POST",
+                token_url,
+                headers=headers,
+                data=json.dumps(body),
+                allow_redirects=True,
+                **self.TEST_REQUEST_BASE)
+
+            resp = dict_correct_response
+            endpoints = resp["access"]["serviceCatalog"][0]['endpoints']
+            public_url = endpoints[0]["publicURL"].rstrip('/')
+            self.assertEqual(public_url, cs.client.management_url)
+            token_id = resp["access"]["token"]["id"]
+            self.assertEqual(token_id, cs.client.auth_token)
+
+        test_auth_call()
+
+
+class AuthenticationTests(utils.TestCase):
+    def test_authenticate_success(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+        management_url = 'https://localhost/v1.1/443470'
+        auth_response = utils.TestResponse({
+            'status_code': 204,
+            'headers': {
+                'x-server-management-url': management_url,
+                'x-auth-token': '1b751d74-de0c-46ae-84f0-915744b582d1',
+            },
+        })
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'Accept': 'application/json',
+                'X-Auth-User': 'username',
+                'X-Auth-Key': 'password',
+                'X-Auth-Project-Id': 'project_id',
+                'User-Agent': cs.client.USER_AGENT
+            }
+            mock_request.assert_called_with(
+                "GET",
+                cs.client.auth_url,
+                headers=headers,
+                **self.TEST_REQUEST_BASE)
+
+            self.assertEqual(auth_response.headers['x-server-management-url'],
+                             cs.client.management_url)
+            self.assertEqual(auth_response.headers['x-auth-token'],
+                             cs.client.auth_token)
+
+        test_auth_call()
+
+    def test_authenticate_failure(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+        auth_response = utils.TestResponse({"status_code": 401})
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            self.assertRaises(exceptions.Unauthorized, cs.client.authenticate)
+
+        test_auth_call()
+
+    def test_auth_automatic(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+        http_client = cs.client
+        http_client.management_url = ''
+        mock_request = mock.Mock(return_value=(None, None))
+
+        @mock.patch.object(http_client, 'request', mock_request)
+        @mock.patch.object(http_client, 'authenticate')
+        def test_auth_call(m):
+            http_client.get('/')
+            m.assert_called()
+            mock_request.assert_called()
+
+        test_auth_call()
+
+    def test_auth_manual(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+
+        @mock.patch.object(cs.client, 'authenticate')
+        def test_auth_call(m):
+            cs.authenticate()
+            m.assert_called()
+
+        test_auth_call()

awx/lib/site-packages/cinderclient/tests/v1/test_availability_zone.py

@@ -0,0 +1,88 @@
+# Copyright 2011-2013 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import six
+
+from cinderclient.v1 import availability_zones
+from cinderclient.v1 import shell
+from cinderclient.tests.fixture_data import client
+from cinderclient.tests.fixture_data import availability_zones as azfixture
+from cinderclient.tests import utils
+
+
+class AvailabilityZoneTest(utils.FixturedTestCase):
+
+    client_fixture_class = client.V1
+    data_fixture_class = azfixture.Fixture
+
+    def _assertZone(self, zone, name, status):
+        self.assertEqual(name, zone.zoneName)
+        self.assertEqual(status, zone.zoneState)
+
+    def test_list_availability_zone(self):
+        zones = self.cs.availability_zones.list(detailed=False)
+        self.assert_called('GET', '/os-availability-zone')
+
+        for zone in zones:
+            self.assertIsInstance(zone,
+                                  availability_zones.AvailabilityZone)
+
+        self.assertEqual(2, len(zones))
+
+        l0 = [six.u('zone-1'), six.u('available')]
+        l1 = [six.u('zone-2'), six.u('not available')]
+
+        z0 = shell._treeizeAvailabilityZone(zones[0])
+        z1 = shell._treeizeAvailabilityZone(zones[1])
+
+        self.assertEqual((1, 1), (len(z0), len(z1)))
+
+        self._assertZone(z0[0], l0[0], l0[1])
+        self._assertZone(z1[0], l1[0], l1[1])
+
+    def test_detail_availability_zone(self):
+        zones = self.cs.availability_zones.list(detailed=True)
+        self.assert_called('GET', '/os-availability-zone/detail')
+
+        for zone in zones:
+            self.assertIsInstance(zone,
+                                  availability_zones.AvailabilityZone)
+
+        self.assertEqual(3, len(zones))
+
+        l0 = [six.u('zone-1'), six.u('available')]
+        l1 = [six.u('|- fake_host-1'), six.u('')]
+        l2 = [six.u('| |- cinder-volume'),
+              six.u('enabled :-) 2012-12-26 14:45:25')]
+        l3 = [six.u('internal'), six.u('available')]
+        l4 = [six.u('|- fake_host-1'), six.u('')]
+        l5 = [six.u('| |- cinder-sched'),
+              six.u('enabled :-) 2012-12-26 14:45:24')]
+        l6 = [six.u('zone-2'), six.u('not available')]
+
+        z0 = shell._treeizeAvailabilityZone(zones[0])
+        z1 = shell._treeizeAvailabilityZone(zones[1])
+        z2 = shell._treeizeAvailabilityZone(zones[2])
+
+        self.assertEqual((3, 3, 1), (len(z0), len(z1), len(z2)))
+
+        self._assertZone(z0[0], l0[0], l0[1])
+        self._assertZone(z0[1], l1[0], l1[1])
+        self._assertZone(z0[2], l2[0], l2[1])
+        self._assertZone(z1[0], l3[0], l3[1])
+        self._assertZone(z1[1], l4[0], l4[1])
+        self._assertZone(z1[2], l5[0], l5[1])
+        self._assertZone(z2[0], l6[0], l6[1])

awx/lib/site-packages/cinderclient/tests/v1/test_limits.py

@@ -0,0 +1,164 @@
+# Copyright 2014 OpenStack Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import mock
+
+from cinderclient.tests import utils
+from cinderclient.v1 import limits
+
+
+def _get_default_RateLimit(verb="verb1", uri="uri1", regex="regex1",
+                           value="value1",
+                           remain="remain1", unit="unit1",
+                           next_available="next1"):
+    return limits.RateLimit(verb, uri, regex, value, remain, unit,
+                            next_available)
+
+
+class TestLimits(utils.TestCase):
+    def test_repr(self):
+        l = limits.Limits(None, {"foo": "bar"})
+        self.assertEqual("<Limits>", repr(l))
+
+    def test_absolute(self):
+        l = limits.Limits(None,
+                          {"absolute": {"name1": "value1", "name2": "value2"}})
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name2", "value2")
+        for item in l.absolute:
+            self.assertIn(item, [l1, l2])
+
+    def test_rate(self):
+        l = limits.Limits(None,
+                          {
+                              "rate": [
+                                  {
+                                      "uri": "uri1",
+                                      "regex": "regex1",
+                                      "limit": [
+                                          {
+                                              "verb": "verb1",
+                                              "value": "value1",
+                                              "remaining": "remain1",
+                                              "unit": "unit1",
+                                              "next-available": "next1",
+                                          },
+                                      ],
+                                  },
+                                  {
+                                      "uri": "uri2",
+                                      "regex": "regex2",
+                                      "limit": [
+                                          {
+                                              "verb": "verb2",
+                                              "value": "value2",
+                                              "remaining": "remain2",
+                                              "unit": "unit2",
+                                              "next-available": "next2",
+                                          },
+                                      ],
+                                  },
+                              ],
+                          })
+        l1 = limits.RateLimit("verb1", "uri1", "regex1", "value1", "remain1",
+                              "unit1", "next1")
+        l2 = limits.RateLimit("verb2", "uri2", "regex2", "value2", "remain2",
+                              "unit2", "next2")
+        for item in l.rate:
+            self.assertIn(item, [l1, l2])
+
+
+class TestRateLimit(utils.TestCase):
+    def test_equal(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit()
+        self.assertEqual(l1, l2)
+
+    def test_not_equal_verbs(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(verb="verb2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_uris(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(uri="uri2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_regexps(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(regex="regex2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_values(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(value="value2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_remains(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(remain="remain2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_units(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(unit="unit2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_next_available(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(next_available="next2")
+        self.assertNotEqual(l1, l2)
+
+    def test_repr(self):
+        l1 = _get_default_RateLimit()
+        self.assertEqual("<RateLimit: method=verb1 uri=uri1>", repr(l1))
+
+
+class TestAbsoluteLimit(utils.TestCase):
+    def test_equal(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name1", "value1")
+        self.assertEqual(l1, l2)
+
+    def test_not_equal_values(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name1", "value2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_names(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name2", "value1")
+        self.assertNotEqual(l1, l2)
+
+    def test_repr(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        self.assertEqual("<AbsoluteLimit: name=name1>", repr(l1))
+
+
+class TestLimitsManager(utils.TestCase):
+    def test_get(self):
+        api = mock.Mock()
+        api.client.get.return_value = (
+            None,
+            {"limits": {"absolute": {"name1": "value1", }},
+             "no-limits": {"absolute": {"name2": "value2", }}})
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        limitsManager = limits.LimitsManager(api)
+
+        lim = limitsManager.get()
+
+        self.assertIsInstance(lim, limits.Limits)
+        for l in lim.absolute:
+            self.assertEqual(l1, l)

awx/lib/site-packages/cinderclient/tests/v1/test_qos.py

@@ -0,0 +1,79 @@
+# Copyright (C) 2013 eBay Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class QoSSpecsTest(utils.TestCase):
+
+    def test_create(self):
+        specs = dict(k1='v1', k2='v2')
+        cs.qos_specs.create('qos-name', specs)
+        cs.assert_called('POST', '/qos-specs')
+
+    def test_get(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.get(qos_id)
+        cs.assert_called('GET', '/qos-specs/%s' % qos_id)
+
+    def test_list(self):
+        cs.qos_specs.list()
+        cs.assert_called('GET', '/qos-specs')
+
+    def test_delete(self):
+        cs.qos_specs.delete('1B6B6A04-A927-4AEB-810B-B7BAAD49F57C')
+        cs.assert_called('DELETE',
+                         '/qos-specs/1B6B6A04-A927-4AEB-810B-B7BAAD49F57C?'
+                         'force=False')
+
+    def test_set_keys(self):
+        body = {'qos_specs': dict(k1='v1')}
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.set_keys(qos_id, body)
+        cs.assert_called('PUT', '/qos-specs/%s' % qos_id)
+
+    def test_unset_keys(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        body = {'keys': ['k1']}
+        cs.qos_specs.unset_keys(qos_id, body)
+        cs.assert_called('PUT', '/qos-specs/%s/delete_keys' % qos_id)
+
+    def test_get_associations(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.get_associations(qos_id)
+        cs.assert_called('GET', '/qos-specs/%s/associations' % qos_id)
+
+    def test_associate(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        type_id = '4230B13A-7A37-4E84-B777-EFBA6FCEE4FF'
+        cs.qos_specs.associate(qos_id, type_id)
+        cs.assert_called('GET', '/qos-specs/%s/associate?vol_type_id=%s'
+                         % (qos_id, type_id))
+
+    def test_disassociate(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        type_id = '4230B13A-7A37-4E84-B777-EFBA6FCEE4FF'
+        cs.qos_specs.disassociate(qos_id, type_id)
+        cs.assert_called('GET', '/qos-specs/%s/disassociate?vol_type_id=%s'
+                         % (qos_id, type_id))
+
+    def test_disassociate_all(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.disassociate_all(qos_id)
+        cs.assert_called('GET', '/qos-specs/%s/disassociate_all' % qos_id)

awx/lib/site-packages/cinderclient/tests/v1/test_quota_classes.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2011 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class QuotaClassSetsTest(utils.TestCase):
+
+    def test_class_quotas_get(self):
+        class_name = 'test'
+        cs.quota_classes.get(class_name)
+        cs.assert_called('GET', '/os-quota-class-sets/%s' % class_name)
+
+    def test_update_quota(self):
+        q = cs.quota_classes.get('test')
+        q.update(volumes=2, snapshots=2)
+        cs.assert_called('PUT', '/os-quota-class-sets/test')
+
+    def test_refresh_quota(self):
+        q = cs.quota_classes.get('test')
+        q2 = cs.quota_classes.get('test')
+        self.assertEqual(q.volumes, q2.volumes)
+        q2.volumes = 0
+        self.assertNotEqual(q.volumes, q2.volumes)
+        q2.get()
+        self.assertEqual(q.volumes, q2.volumes)

awx/lib/site-packages/cinderclient/tests/v1/test_quotas.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2011 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class QuotaSetsTest(utils.TestCase):
+
+    def test_tenant_quotas_get(self):
+        tenant_id = 'test'
+        cs.quotas.get(tenant_id)
+        cs.assert_called('GET', '/os-quota-sets/%s?usage=False' % tenant_id)
+
+    def test_tenant_quotas_defaults(self):
+        tenant_id = 'test'
+        cs.quotas.defaults(tenant_id)
+        cs.assert_called('GET', '/os-quota-sets/%s/defaults' % tenant_id)
+
+    def test_update_quota(self):
+        q = cs.quotas.get('test')
+        q.update(volumes=2)
+        q.update(snapshots=2)
+        cs.assert_called('PUT', '/os-quota-sets/test')
+
+    def test_refresh_quota(self):
+        q = cs.quotas.get('test')
+        q2 = cs.quotas.get('test')
+        self.assertEqual(q.volumes, q2.volumes)
+        self.assertEqual(q.snapshots, q2.snapshots)
+        q2.volumes = 0
+        self.assertNotEqual(q.volumes, q2.volumes)
+        q2.snapshots = 0
+        self.assertNotEqual(q.snapshots, q2.snapshots)
+        q2.get()
+        self.assertEqual(q.volumes, q2.volumes)
+        self.assertEqual(q.snapshots, q2.snapshots)
+
+    def test_delete_quota(self):
+        tenant_id = 'test'
+        cs.quotas.delete(tenant_id)
+        cs.assert_called('DELETE', '/os-quota-sets/test')

awx/lib/site-packages/cinderclient/tests/v1/test_services.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+from cinderclient.v1 import services
+
+
+cs = fakes.FakeClient()
+
+
+class ServicesTest(utils.TestCase):
+
+    def test_list_services(self):
+        svs = cs.services.list()
+        cs.assert_called('GET', '/os-services')
+        self.assertEqual(3, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+
+    def test_list_services_with_hostname(self):
+        svs = cs.services.list(host='host2')
+        cs.assert_called('GET', '/os-services?host=host2')
+        self.assertEqual(2, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+        [self.assertEqual('host2', s.host) for s in svs]
+
+    def test_list_services_with_binary(self):
+        svs = cs.services.list(binary='cinder-volume')
+        cs.assert_called('GET', '/os-services?binary=cinder-volume')
+        self.assertEqual(2, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+        [self.assertEqual('cinder-volume', s.binary) for s in svs]
+
+    def test_list_services_with_host_binary(self):
+        svs = cs.services.list('host2', 'cinder-volume')
+        cs.assert_called('GET', '/os-services?host=host2&binary=cinder-volume')
+        self.assertEqual(1, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+        [self.assertEqual('host2', s.host) for s in svs]
+        [self.assertEqual('cinder-volume', s.binary) for s in svs]
+
+    def test_services_enable(self):
+        s = cs.services.enable('host1', 'cinder-volume')
+        values = {"host": "host1", 'binary': 'cinder-volume'}
+        cs.assert_called('PUT', '/os-services/enable', values)
+        self.assertIsInstance(s, services.Service)
+        self.assertEqual('enabled', s.status)
+
+    def test_services_disable(self):
+        s = cs.services.disable('host1', 'cinder-volume')
+        values = {"host": "host1", 'binary': 'cinder-volume'}
+        cs.assert_called('PUT', '/os-services/disable', values)
+        self.assertIsInstance(s, services.Service)
+        self.assertEqual('disabled', s.status)
+
+    def test_services_disable_log_reason(self):
+        s = cs.services.disable_log_reason(
+            'host1', 'cinder-volume', 'disable bad host')
+        values = {"host": "host1", 'binary': 'cinder-volume',
+                  "disabled_reason": "disable bad host"}
+        cs.assert_called('PUT', '/os-services/disable-log-reason', values)
+        self.assertIsInstance(s, services.Service)
+        self.assertEqual('disabled', s.status)

awx/lib/site-packages/cinderclient/tests/v1/test_shell.py

@@ -0,0 +1,402 @@
+# Copyright 2010 Jacob Kaplan-Moss
+
+# Copyright (c) 2011 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import fixtures
+from requests_mock.contrib import fixture as requests_mock_fixture
+
+from cinderclient import client
+from cinderclient import exceptions
+from cinderclient import shell
+from cinderclient.v1 import shell as shell_v1
+from cinderclient.tests.v1 import fakes
+from cinderclient.tests import utils
+from cinderclient.tests.fixture_data import keystone_client
+
+
+class ShellTest(utils.TestCase):
+
+    FAKE_ENV = {
+        'CINDER_USERNAME': 'username',
+        'CINDER_PASSWORD': 'password',
+        'CINDER_PROJECT_ID': 'project_id',
+        'OS_VOLUME_API_VERSION': '1',
+        'CINDER_URL': keystone_client.BASE_URL,
+    }
+
+    # Patch os.environ to avoid required auth info.
+    def setUp(self):
+        """Run before each test."""
+        super(ShellTest, self).setUp()
+        for var in self.FAKE_ENV:
+            self.useFixture(fixtures.EnvironmentVariable(var,
+                                                         self.FAKE_ENV[var]))
+
+        self.shell = shell.OpenStackCinderShell()
+
+        # HACK(bcwaldon): replace this when we start using stubs
+        self.old_get_client_class = client.get_client_class
+        client.get_client_class = lambda *_: fakes.FakeClient
+
+        self.requests = self.useFixture(requests_mock_fixture.Fixture())
+        self.requests.register_uri(
+            'GET', keystone_client.BASE_URL,
+            text=keystone_client.keystone_request_callback)
+
+    def tearDown(self):
+        # For some method like test_image_meta_bad_action we are
+        # testing a SystemExit to be thrown and object self.shell has
+        # no time to get instantatiated which is OK in this case, so
+        # we make sure the method is there before launching it.
+        if hasattr(self.shell, 'cs'):
+            self.shell.cs.clear_callstack()
+
+        # HACK(bcwaldon): replace this when we start using stubs
+        client.get_client_class = self.old_get_client_class
+        super(ShellTest, self).tearDown()
+
+    def run_command(self, cmd):
+        self.shell.main(cmd.split())
+
+    def assert_called(self, method, url, body=None, **kwargs):
+        return self.shell.cs.assert_called(method, url, body, **kwargs)
+
+    def assert_called_anytime(self, method, url, body=None):
+        return self.shell.cs.assert_called_anytime(method, url, body)
+
+    def test_extract_metadata(self):
+        # mimic the result of argparse's parse_args() method
+        class Arguments:
+
+            def __init__(self, metadata=[]):
+                self.metadata = metadata
+
+        inputs = [
+            ([], {}),
+            (["key=value"], {"key": "value"}),
+            (["key"], {"key": None}),
+            (["k1=v1", "k2=v2"], {"k1": "v1", "k2": "v2"}),
+            (["k1=v1", "k2"], {"k1": "v1", "k2": None}),
+            (["k1", "k2=v2"], {"k1": None, "k2": "v2"})
+        ]
+
+        for input in inputs:
+            args = Arguments(metadata=input[0])
+            self.assertEqual(input[1], shell_v1._extract_metadata(args))
+
+    def test_translate_volume_keys(self):
+        cs = fakes.FakeClient()
+        v = cs.volumes.list()[0]
+        setattr(v, 'os-vol-tenant-attr:tenant_id', 'fake_tenant')
+        setattr(v, '_info', {'attachments': [{'server_id': 1234}],
+                'id': 1234, 'name': 'sample-volume',
+                'os-vol-tenant-attr:tenant_id': 'fake_tenant'})
+        shell_v1._translate_volume_keys([v])
+        self.assertEqual(v.tenant_id, 'fake_tenant')
+
+    def test_list(self):
+        self.run_command('list')
+        # NOTE(jdg): we default to detail currently
+        self.assert_called('GET', '/volumes/detail')
+
+    def test_list_filter_status(self):
+        self.run_command('list --status=available')
+        self.assert_called('GET', '/volumes/detail?status=available')
+
+    def test_list_filter_display_name(self):
+        self.run_command('list --display-name=1234')
+        self.assert_called('GET', '/volumes/detail?display_name=1234')
+
+    def test_list_all_tenants(self):
+        self.run_command('list --all-tenants=1')
+        self.assert_called('GET', '/volumes/detail?all_tenants=1')
+
+    def test_list_availability_zone(self):
+        self.run_command('availability-zone-list')
+        self.assert_called('GET', '/os-availability-zone')
+
+    def test_show(self):
+        self.run_command('show 1234')
+        self.assert_called('GET', '/volumes/1234')
+
+    def test_delete(self):
+        self.run_command('delete 1234')
+        self.assert_called('DELETE', '/volumes/1234')
+
+    def test_delete_by_name(self):
+        self.run_command('delete sample-volume')
+        self.assert_called_anytime('GET', '/volumes/detail?all_tenants=1')
+        self.assert_called('DELETE', '/volumes/1234')
+
+    def test_delete_multiple(self):
+        self.run_command('delete 1234 5678')
+        self.assert_called_anytime('DELETE', '/volumes/1234')
+        self.assert_called('DELETE', '/volumes/5678')
+
+    def test_backup(self):
+        self.run_command('backup-create 1234')
+        self.assert_called('POST', '/backups')
+
+    def test_restore(self):
+        self.run_command('backup-restore 1234')
+        self.assert_called('POST', '/backups/1234/restore')
+
+    def test_snapshot_list_filter_volume_id(self):
+        self.run_command('snapshot-list --volume-id=1234')
+        self.assert_called('GET', '/snapshots/detail?volume_id=1234')
+
+    def test_snapshot_list_filter_status_and_volume_id(self):
+        self.run_command('snapshot-list --status=available --volume-id=1234')
+        self.assert_called('GET', '/snapshots/detail?'
+                           'status=available&volume_id=1234')
+
+    def test_rename(self):
+        # basic rename with positional arguments
+        self.run_command('rename 1234 new-name')
+        expected = {'volume': {'display_name': 'new-name'}}
+        self.assert_called('PUT', '/volumes/1234', body=expected)
+        # change description only
+        self.run_command('rename 1234 --display-description=new-description')
+        expected = {'volume': {'display_description': 'new-description'}}
+        self.assert_called('PUT', '/volumes/1234', body=expected)
+        # rename and change description
+        self.run_command('rename 1234 new-name '
+                         '--display-description=new-description')
+        expected = {'volume': {
+            'display_name': 'new-name',
+            'display_description': 'new-description',
+        }}
+        self.assert_called('PUT', '/volumes/1234', body=expected)
+
+        # Call rename with no arguments
+        self.assertRaises(SystemExit, self.run_command, 'rename')
+
+    def test_rename_snapshot(self):
+        # basic rename with positional arguments
+        self.run_command('snapshot-rename 1234 new-name')
+        expected = {'snapshot': {'display_name': 'new-name'}}
+        self.assert_called('PUT', '/snapshots/1234', body=expected)
+        # change description only
+        self.run_command('snapshot-rename 1234 '
+                         '--display-description=new-description')
+        expected = {'snapshot': {'display_description': 'new-description'}}
+        self.assert_called('PUT', '/snapshots/1234', body=expected)
+        # snapshot-rename and change description
+        self.run_command('snapshot-rename 1234 new-name '
+                         '--display-description=new-description')
+        expected = {'snapshot': {
+            'display_name': 'new-name',
+            'display_description': 'new-description',
+        }}
+        self.assert_called('PUT', '/snapshots/1234', body=expected)
+
+        # Call snapshot-rename with no arguments
+        self.assertRaises(SystemExit, self.run_command, 'snapshot-rename')
+
+    def test_set_metadata_set(self):
+        self.run_command('metadata 1234 set key1=val1 key2=val2')
+        self.assert_called('POST', '/volumes/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_set_metadata_delete_dict(self):
+        self.run_command('metadata 1234 unset key1=val1 key2=val2')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key1')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key2', pos=-2)
+
+    def test_set_metadata_delete_keys(self):
+        self.run_command('metadata 1234 unset key1 key2')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key1')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key2', pos=-2)
+
+    def test_reset_state(self):
+        self.run_command('reset-state 1234')
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_reset_state_with_flag(self):
+        self.run_command('reset-state --state error 1234')
+        expected = {'os-reset_status': {'status': 'error'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_reset_state_multiple(self):
+        self.run_command('reset-state 1234 5678 --state error')
+        expected = {'os-reset_status': {'status': 'error'}}
+        self.assert_called_anytime('POST', '/volumes/1234/action',
+                                   body=expected)
+        self.assert_called_anytime('POST', '/volumes/5678/action',
+                                   body=expected)
+
+    def test_reset_state_two_with_one_nonexistent(self):
+        cmd = 'reset-state 1234 123456789'
+        self.assertRaises(exceptions.CommandError, self.run_command, cmd)
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called_anytime('POST', '/volumes/1234/action',
+                                   body=expected)
+
+    def test_reset_state_one_with_one_nonexistent(self):
+        cmd = 'reset-state 123456789'
+        self.assertRaises(exceptions.CommandError, self.run_command, cmd)
+
+    def test_snapshot_reset_state(self):
+        self.run_command('snapshot-reset-state 1234')
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called('POST', '/snapshots/1234/action', body=expected)
+
+    def test_snapshot_reset_state_with_flag(self):
+        self.run_command('snapshot-reset-state --state error 1234')
+        expected = {'os-reset_status': {'status': 'error'}}
+        self.assert_called('POST', '/snapshots/1234/action', body=expected)
+
+    def test_snapshot_reset_state_multiple(self):
+        self.run_command('snapshot-reset-state 1234 5678')
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called_anytime('POST', '/snapshots/1234/action',
+                                   body=expected)
+        self.assert_called_anytime('POST', '/snapshots/5678/action',
+                                   body=expected)
+
+    def test_encryption_type_list(self):
+        """
+        Test encryption-type-list shell command.
+
+        Verify a series of GET requests are made:
+        - one to get the volume type list information
+        - one per volume type to retrieve the encryption type information
+        """
+        self.run_command('encryption-type-list')
+        self.assert_called_anytime('GET', '/types')
+        self.assert_called_anytime('GET', '/types/1/encryption')
+        self.assert_called_anytime('GET', '/types/2/encryption')
+
+    def test_encryption_type_show(self):
+        """
+        Test encryption-type-show shell command.
+
+        Verify two GET requests are made per command invocation:
+        - one to get the volume type information
+        - one to get the encryption type information
+        """
+        self.run_command('encryption-type-show 1')
+        self.assert_called('GET', '/types/1/encryption')
+        self.assert_called_anytime('GET', '/types/1')
+
+    def test_encryption_type_create(self):
+        """
+        Test encryption-type-create shell command.
+
+        Verify GET and POST requests are made per command invocation:
+        - one GET request to retrieve the relevant volume type information
+        - one POST request to create the new encryption type
+        """
+        expected = {'encryption': {'cipher': None, 'key_size': None,
+                                   'provider': 'TestProvider',
+                                   'control_location': 'front-end'}}
+        self.run_command('encryption-type-create 2 TestProvider')
+        self.assert_called('POST', '/types/2/encryption', body=expected)
+        self.assert_called_anytime('GET', '/types/2')
+
+    def test_encryption_type_update(self):
+        """
+        Test encryption-type-update shell command.
+
+        Verify two GETs/one PUT requests are made per command invocation:
+        - one GET request to retrieve the relevant volume type information
+        - one GET request to retrieve the relevant encryption type information
+        - one PUT request to update the encryption type information
+        """
+        self.skipTest("Not implemented")
+
+    def test_encryption_type_delete(self):
+        """
+        Test encryption-type-delete shell command.
+
+        Verify one GET/one DELETE requests are made per command invocation:
+        - one GET request to retrieve the relevant volume type information
+        - one DELETE request to delete the encryption type information
+        """
+        self.run_command('encryption-type-delete 1')
+        self.assert_called('DELETE', '/types/1/encryption/provider')
+        self.assert_called_anytime('GET', '/types/1')
+
+    def test_migrate_volume(self):
+        self.run_command('migrate 1234 fakehost --force-host-copy=True')
+        expected = {'os-migrate_volume': {'force_host_copy': 'True',
+                                          'host': 'fakehost'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_snapshot_metadata_set(self):
+        self.run_command('snapshot-metadata 1234 set key1=val1 key2=val2')
+        self.assert_called('POST', '/snapshots/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_snapshot_metadata_unset_dict(self):
+        self.run_command('snapshot-metadata 1234 unset key1=val1 key2=val2')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key1')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key2')
+
+    def test_snapshot_metadata_unset_keys(self):
+        self.run_command('snapshot-metadata 1234 unset key1 key2')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key1')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key2')
+
+    def test_volume_metadata_update_all(self):
+        self.run_command('metadata-update-all 1234 key1=val1 key2=val2')
+        self.assert_called('PUT', '/volumes/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_snapshot_metadata_update_all(self):
+        self.run_command('snapshot-metadata-update-all\
+                         1234 key1=val1 key2=val2')
+        self.assert_called('PUT', '/snapshots/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_readonly_mode_update(self):
+        self.run_command('readonly-mode-update 1234 True')
+        expected = {'os-update_readonly_flag': {'readonly': True}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+        self.run_command('readonly-mode-update 1234 False')
+        expected = {'os-update_readonly_flag': {'readonly': False}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_service_disable(self):
+        self.run_command('service-disable host cinder-volume')
+        self.assert_called('PUT', '/os-services/disable',
+                           {"binary": "cinder-volume", "host": "host"})
+
+    def test_services_disable_with_reason(self):
+        cmd = 'service-disable host cinder-volume --reason no_reason'
+        self.run_command(cmd)
+        body = {'host': 'host', 'binary': 'cinder-volume',
+                'disabled_reason': 'no_reason'}
+        self.assert_called('PUT', '/os-services/disable-log-reason', body)
+
+    def test_service_enable(self):
+        self.run_command('service-enable host cinder-volume')
+        self.assert_called('PUT', '/os-services/enable',
+                           {"binary": "cinder-volume", "host": "host"})
+
+    def test_snapshot_delete(self):
+        self.run_command('snapshot-delete 1234')
+        self.assert_called('DELETE', '/snapshots/1234')
+
+    def test_quota_delete(self):
+        self.run_command('quota-delete 1234')
+        self.assert_called('DELETE', '/os-quota-sets/1234')
+
+    def test_snapshot_delete_multiple(self):
+        self.run_command('snapshot-delete 1234 5678')
+        self.assert_called('DELETE', '/snapshots/5678')

awx/lib/site-packages/cinderclient/tests/v1/test_snapshot_actions.py

@@ -0,0 +1,36 @@
+# Copyright 2013 Red Hat, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.fixture_data import client
+from cinderclient.tests.fixture_data import snapshots
+
+
+class SnapshotActionsTest(utils.FixturedTestCase):
+
+    client_fixture_class = client.V1
+    data_fixture_class = snapshots.Fixture
+
+    def test_update_snapshot_status(self):
+        s = self.cs.volume_snapshots.get('1234')
+        stat = {'status': 'available'}
+        self.cs.volume_snapshots.update_snapshot_status(s, stat)
+        self.assert_called('POST', '/snapshots/1234/action')
+
+    def test_update_snapshot_status_with_progress(self):
+        s = self.cs.volume_snapshots.get('1234')
+        stat = {'status': 'available', 'progress': '73%'}
+        self.cs.volume_snapshots.update_snapshot_status(s, stat)
+        self.assert_called('POST', '/snapshots/1234/action')

awx/lib/site-packages/cinderclient/tests/v1/test_types.py

@@ -0,0 +1,47 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cinderclient.v1 import volume_types
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+cs = fakes.FakeClient()
+
+
+class TypesTest(utils.TestCase):
+    def test_list_types(self):
+        tl = cs.volume_types.list()
+        cs.assert_called('GET', '/types')
+        for t in tl:
+            self.assertIsInstance(t, volume_types.VolumeType)
+
+    def test_create(self):
+        t = cs.volume_types.create('test-type-3')
+        cs.assert_called('POST', '/types')
+        self.assertIsInstance(t, volume_types.VolumeType)
+
+    def test_set_key(self):
+        t = cs.volume_types.get(1)
+        t.set_keys({'k': 'v'})
+        cs.assert_called('POST',
+                         '/types/1/extra_specs',
+                         {'extra_specs': {'k': 'v'}})
+
+    def test_unsset_keys(self):
+        t = cs.volume_types.get(1)
+        t.unset_keys(['k'])
+        cs.assert_called('DELETE', '/types/1/extra_specs/k')
+
+    def test_delete(self):
+        cs.volume_types.delete(1)
+        cs.assert_called('DELETE', '/types/1')

awx/lib/site-packages/cinderclient/tests/v1/test_volume_backups.py

@@ -0,0 +1,53 @@
+# Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class VolumeBackupsTest(utils.TestCase):
+
+    def test_create(self):
+        cs.backups.create('2b695faf-b963-40c8-8464-274008fbcef4')
+        cs.assert_called('POST', '/backups')
+
+    def test_get(self):
+        backup_id = '76a17945-3c6f-435c-975b-b5685db10b62'
+        cs.backups.get(backup_id)
+        cs.assert_called('GET', '/backups/%s' % backup_id)
+
+    def test_list(self):
+        cs.backups.list()
+        cs.assert_called('GET', '/backups/detail')
+
+    def test_delete(self):
+        b = cs.backups.list()[0]
+        b.delete()
+        cs.assert_called('DELETE',
+                         '/backups/76a17945-3c6f-435c-975b-b5685db10b62')
+        cs.backups.delete('76a17945-3c6f-435c-975b-b5685db10b62')
+        cs.assert_called('DELETE',
+                         '/backups/76a17945-3c6f-435c-975b-b5685db10b62')
+        cs.backups.delete(b)
+        cs.assert_called('DELETE',
+                         '/backups/76a17945-3c6f-435c-975b-b5685db10b62')
+
+    def test_restore(self):
+        backup_id = '76a17945-3c6f-435c-975b-b5685db10b62'
+        cs.restores.restore(backup_id)
+        cs.assert_called('POST', '/backups/%s/restore' % backup_id)

awx/lib/site-packages/cinderclient/tests/v1/test_volume_encryption_types.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2013 The Johns Hopkins University/Applied Physics Laboratory
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.v1.volume_encryption_types import VolumeEncryptionType
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+cs = fakes.FakeClient()
+
+
+class VolumeEncryptionTypesTest(utils.TestCase):
+    """
+    Test suite for the Volume Encryption Types Resource and Manager.
+    """
+
+    def test_list(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.list
+
+        Verify that a series of GET requests are made:
+        - one GET request for the list of volume types
+        - one GET request per volume type for encryption type information
+
+        Verify that all returned information is :class: VolumeEncryptionType
+        """
+        encryption_types = cs.volume_encryption_types.list()
+        cs.assert_called_anytime('GET', '/types')
+        cs.assert_called_anytime('GET', '/types/2/encryption')
+        cs.assert_called_anytime('GET', '/types/1/encryption')
+        for encryption_type in encryption_types:
+            self.assertIsInstance(encryption_type, VolumeEncryptionType)
+
+    def test_get(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.get
+
+        Verify that one GET request is made for the volume type encryption
+        type information. Verify that returned information is :class:
+        VolumeEncryptionType
+        """
+        encryption_type = cs.volume_encryption_types.get(1)
+        cs.assert_called('GET', '/types/1/encryption')
+        self.assertIsInstance(encryption_type, VolumeEncryptionType)
+
+    def test_get_no_encryption(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.get
+
+        Verify that a request on a volume type with no associated encryption
+        type information returns a VolumeEncryptionType with no attributes.
+        """
+        encryption_type = cs.volume_encryption_types.get(2)
+        self.assertIsInstance(encryption_type, VolumeEncryptionType)
+        self.assertFalse(hasattr(encryption_type, 'id'),
+                         'encryption type has an id')
+
+    def test_create(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.create
+
+        Verify that one POST request is made for the encryption type creation.
+        Verify that encryption type creation returns a VolumeEncryptionType.
+        """
+        result = cs.volume_encryption_types.create(2, {'provider': 'Test',
+                                                       'key_size': None,
+                                                       'cipher': None,
+                                                       'control_location':
+                                                       None})
+        cs.assert_called('POST', '/types/2/encryption')
+        self.assertIsInstance(result, VolumeEncryptionType)
+
+    def test_update(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.update
+        """
+        self.skipTest("Not implemented")
+
+    def test_delete(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.delete
+
+        Verify that one DELETE request is made for encryption type deletion
+        Verify that encryption type deletion returns None
+        """
+        result = cs.volume_encryption_types.delete(1)
+        cs.assert_called('DELETE', '/types/1/encryption/provider')
+        self.assertIsNone(result, "delete result must be None")

awx/lib/site-packages/cinderclient/tests/v1/test_volume_transfers.py

@@ -0,0 +1,51 @@
+# Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class VolumeTransfersTest(utils.TestCase):
+
+    def test_create(self):
+        cs.transfers.create('1234')
+        cs.assert_called('POST', '/os-volume-transfer')
+
+    def test_get(self):
+        transfer_id = '5678'
+        cs.transfers.get(transfer_id)
+        cs.assert_called('GET', '/os-volume-transfer/%s' % transfer_id)
+
+    def test_list(self):
+        cs.transfers.list()
+        cs.assert_called('GET', '/os-volume-transfer/detail')
+
+    def test_delete(self):
+        b = cs.transfers.list()[0]
+        b.delete()
+        cs.assert_called('DELETE', '/os-volume-transfer/5678')
+        cs.transfers.delete('5678')
+        cs.assert_called('DELETE', '/os-volume-transfer/5678')
+        cs.transfers.delete(b)
+        cs.assert_called('DELETE', '/os-volume-transfer/5678')
+
+    def test_accept(self):
+        transfer_id = '5678'
+        auth_key = '12345'
+        cs.transfers.accept(transfer_id, auth_key)
+        cs.assert_called('POST', '/os-volume-transfer/%s/accept' % transfer_id)

awx/lib/site-packages/cinderclient/tests/v1/test_volumes.py

@@ -0,0 +1,113 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class VolumesTest(utils.TestCase):
+
+    def test_delete_volume(self):
+        v = cs.volumes.list()[0]
+        v.delete()
+        cs.assert_called('DELETE', '/volumes/1234')
+        cs.volumes.delete('1234')
+        cs.assert_called('DELETE', '/volumes/1234')
+        cs.volumes.delete(v)
+        cs.assert_called('DELETE', '/volumes/1234')
+
+    def test_create_volume(self):
+        cs.volumes.create(1)
+        cs.assert_called('POST', '/volumes')
+
+    def test_attach(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.attach(v, 1, '/dev/vdc', mode='rw')
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_detach(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.detach(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_reserve(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.reserve(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_unreserve(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.unreserve(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_begin_detaching(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.begin_detaching(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_roll_detaching(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.roll_detaching(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_initialize_connection(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.initialize_connection(v, {})
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_terminate_connection(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.terminate_connection(v, {})
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_set_metadata(self):
+        cs.volumes.set_metadata(1234, {'k1': 'v1'})
+        cs.assert_called('POST', '/volumes/1234/metadata',
+                         {'metadata': {'k1': 'v1'}})
+
+    def test_delete_metadata(self):
+        keys = ['key1']
+        cs.volumes.delete_metadata(1234, keys)
+        cs.assert_called('DELETE', '/volumes/1234/metadata/key1')
+
+    def test_extend(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.extend(v, 2)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_get_encryption_metadata(self):
+        cs.volumes.get_encryption_metadata('1234')
+        cs.assert_called('GET', '/volumes/1234/encryption')
+
+    def test_migrate(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.migrate_volume(v, 'dest', False)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_metadata_update_all(self):
+        cs.volumes.update_all_metadata(1234, {'k1': 'v1'})
+        cs.assert_called('PUT', '/volumes/1234/metadata',
+                         {'metadata': {'k1': 'v1'}})
+
+    def test_readonly_mode_update(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.update_readonly_flag(v, True)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_set_bootable(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.set_bootable(v, True)
+        cs.assert_called('POST', '/volumes/1234/action')

awx/lib/site-packages/cinderclient/tests/v1/testfile.txt

@@ -0,0 +1 @@
+BLAH

awx/lib/site-packages/cinderclient/tests/v2/contrib/test_list_extensions.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2013 OpenStack Foundation
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient import extension
+from cinderclient.v2.contrib import list_extensions
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+extensions = [
+    extension.Extension(list_extensions.__name__.split(".")[-1],
+                        list_extensions),
+]
+cs = fakes.FakeClient(extensions=extensions)
+
+
+class ListExtensionsTests(utils.TestCase):
+    def test_list_extensions(self):
+        all_exts = cs.list_extensions.show_all()
+        cs.assert_called('GET', '/extensions')
+        self.assertTrue(len(all_exts) > 0)
+        for r in all_exts:
+            self.assertTrue(len(r.summary) > 0)

awx/lib/site-packages/cinderclient/tests/v2/fakes.py

@@ -0,0 +1,910 @@
+# Copyright (c) 2013 OpenStack Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime
+
+try:
+    import urlparse
+except ImportError:
+    import urllib.parse as urlparse
+
+from cinderclient import client as base_client
+from cinderclient.tests import fakes
+import cinderclient.tests.utils as utils
+from cinderclient.v2 import client
+
+
+def _stub_volume(**kwargs):
+    volume = {
+        'id': '1234',
+        'name': None,
+        'description': None,
+        "attachments": [],
+        "bootable": "false",
+        "availability_zone": "cinder",
+        "created_at": "2012-08-27T00:00:00.000000",
+        "id": '00000000-0000-0000-0000-000000000000',
+        "metadata": {},
+        "size": 1,
+        "snapshot_id": None,
+        "status": "available",
+        "volume_type": "None",
+        "links": [
+            {
+                "href": "http://localhost/v2/fake/volumes/1234",
+                "rel": "self"
+            },
+            {
+                "href": "http://localhost/fake/volumes/1234",
+                "rel": "bookmark"
+            }
+        ],
+    }
+    volume.update(kwargs)
+    return volume
+
+
+def _stub_snapshot(**kwargs):
+    snapshot = {
+        "created_at": "2012-08-28T16:30:31.000000",
+        "display_description": None,
+        "display_name": None,
+        "id": '11111111-1111-1111-1111-111111111111',
+        "size": 1,
+        "status": "available",
+        "volume_id": '00000000-0000-0000-0000-000000000000',
+    }
+    snapshot.update(kwargs)
+    return snapshot
+
+
+def _stub_consistencygroup(**kwargs):
+    consistencygroup = {
+        "created_at": "2012-08-28T16:30:31.000000",
+        "description": None,
+        "name": "cg",
+        "id": "11111111-1111-1111-1111-111111111111",
+        "availability_zone": "myzone",
+        "status": "available",
+    }
+    consistencygroup.update(kwargs)
+    return consistencygroup
+
+
+def _stub_cgsnapshot(**kwargs):
+    cgsnapshot = {
+        "created_at": "2012-08-28T16:30:31.000000",
+        "description": None,
+        "name": None,
+        "id": "11111111-1111-1111-1111-111111111111",
+        "status": "available",
+        "consistencygroup_id": "00000000-0000-0000-0000-000000000000",
+    }
+    cgsnapshot.update(kwargs)
+    return cgsnapshot
+
+
+def _self_href(base_uri, tenant_id, backup_id):
+    return '%s/v2/%s/backups/%s' % (base_uri, tenant_id, backup_id)
+
+
+def _bookmark_href(base_uri, tenant_id, backup_id):
+    return '%s/%s/backups/%s' % (base_uri, tenant_id, backup_id)
+
+
+def _stub_backup_full(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'backup',
+        'description': 'nightly backup',
+        'volume_id': '712f4980-5ac1-41e5-9383-390aa7c9f58b',
+        'container': 'volumebackups',
+        'object_count': 220,
+        'size': 10,
+        'availability_zone': 'az1',
+        'created_at': '2013-04-12T08:16:37.000000',
+        'status': 'available',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_backup(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'backup',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_qos_full(id, base_uri, tenant_id, name=None, specs=None):
+    if not name:
+        name = 'fake-name'
+    if not specs:
+        specs = {}
+
+    return {
+        'qos_specs': {
+            'id': id,
+            'name': name,
+            'consumer': 'back-end',
+            'specs': specs,
+        },
+        'links': {
+            'href': _bookmark_href(base_uri, tenant_id, id),
+            'rel': 'bookmark'
+        }
+    }
+
+
+def _stub_qos_associates(id, name):
+    return {
+        'assoications_type': 'volume_type',
+        'name': name,
+        'id': id,
+    }
+
+
+def _stub_restore():
+    return {'volume_id': '712f4980-5ac1-41e5-9383-390aa7c9f58b'}
+
+
+def _stub_transfer_full(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'transfer',
+        'volume_id': '8c05f861-6052-4df6-b3e0-0aebfbe686cc',
+        'created_at': '2013-04-12T08:16:37.000000',
+        'auth_key': '123456',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_transfer(id, base_uri, tenant_id):
+    return {
+        'id': id,
+        'name': 'transfer',
+        'volume_id': '8c05f861-6052-4df6-b3e0-0aebfbe686cc',
+        'links': [
+            {
+                'href': _self_href(base_uri, tenant_id, id),
+                'rel': 'self'
+            },
+            {
+                'href': _bookmark_href(base_uri, tenant_id, id),
+                'rel': 'bookmark'
+            }
+        ]
+    }
+
+
+def _stub_extend(id, new_size):
+    return {'volume_id': '712f4980-5ac1-41e5-9383-390aa7c9f58b'}
+
+
+class FakeClient(fakes.FakeClient, client.Client):
+
+    def __init__(self, *args, **kwargs):
+        client.Client.__init__(self, 'username', 'password',
+                               'project_id', 'auth_url',
+                               extensions=kwargs.get('extensions'))
+        self.client = FakeHTTPClient(**kwargs)
+
+    def get_volume_api_version_from_endpoint(self):
+        return self.client.get_volume_api_version_from_endpoint()
+
+
+class FakeHTTPClient(base_client.HTTPClient):
+
+    def __init__(self, **kwargs):
+        self.username = 'username'
+        self.password = 'password'
+        self.auth_url = 'auth_url'
+        self.callstack = []
+        self.management_url = 'http://10.0.2.15:8776/v2/fake'
+
+    def _cs_request(self, url, method, **kwargs):
+        # Check that certain things are called correctly
+        if method in ['GET', 'DELETE']:
+            assert 'body' not in kwargs
+        elif method == 'PUT':
+            assert 'body' in kwargs
+
+        # Call the method
+        args = urlparse.parse_qsl(urlparse.urlparse(url)[4])
+        kwargs.update(args)
+        munged_url = url.rsplit('?', 1)[0]
+        munged_url = munged_url.strip('/').replace('/', '_').replace('.', '_')
+        munged_url = munged_url.replace('-', '_')
+
+        callback = "%s_%s" % (method.lower(), munged_url)
+
+        if not hasattr(self, callback):
+            raise AssertionError('Called unknown API method: %s %s, '
+                                 'expected fakes method name: %s' %
+                                 (method, url, callback))
+
+        # Note the call
+        self.callstack.append((method, url, kwargs.get('body', None)))
+        status, headers, body = getattr(self, callback)(**kwargs)
+        r = utils.TestResponse({
+            "status_code": status,
+            "text": body,
+            "headers": headers,
+        })
+        return r, body
+
+        if hasattr(status, 'items'):
+            return utils.TestResponse(status), body
+        else:
+            return utils.TestResponse({"status": status}), body
+
+    def get_volume_api_version_from_endpoint(self):
+        magic_tuple = urlparse.urlsplit(self.management_url)
+        scheme, netloc, path, query, frag = magic_tuple
+        return path.lstrip('/').split('/')[0][1:]
+
+    #
+    # Snapshots
+    #
+
+    def get_snapshots_detail(self, **kw):
+        return (200, {}, {'snapshots': [
+            _stub_snapshot(),
+        ]})
+
+    def get_snapshots_1234(self, **kw):
+        return (200, {}, {'snapshot': _stub_snapshot(id='1234')})
+
+    def get_snapshots_5678(self, **kw):
+        return (200, {}, {'snapshot': _stub_snapshot(id='5678')})
+
+    def put_snapshots_1234(self, **kw):
+        snapshot = _stub_snapshot(id='1234')
+        snapshot.update(kw['body']['snapshot'])
+        return (200, {}, {'snapshot': snapshot})
+
+    def post_snapshots_1234_action(self, body, **kw):
+        _body = None
+        resp = 202
+        assert len(list(body)) == 1
+        action = list(body)[0]
+        if action == 'os-reset_status':
+            assert 'status' in body['os-reset_status']
+        elif action == 'os-update_snapshot_status':
+            assert 'status' in body['os-update_snapshot_status']
+        else:
+            raise AssertionError('Unexpected action: %s' % action)
+        return (resp, {}, _body)
+
+    def post_snapshots_5678_action(self, body, **kw):
+        return self.post_snapshots_1234_action(body, **kw)
+
+    def delete_snapshots_1234(self, **kw):
+        return (202, {}, {})
+
+    def delete_snapshots_5678(self, **kw):
+        return (202, {}, {})
+
+    #
+    # Volumes
+    #
+
+    def put_volumes_1234(self, **kw):
+        volume = _stub_volume(id='1234')
+        volume.update(kw['body']['volume'])
+        return (200, {}, {'volume': volume})
+
+    def get_volumes(self, **kw):
+        return (200, {}, {"volumes": [
+            {'id': 1234, 'name': 'sample-volume'},
+            {'id': 5678, 'name': 'sample-volume2'}
+        ]})
+
+    # TODO(jdg): This will need to change
+    # at the very least it's not complete
+    def get_volumes_detail(self, **kw):
+        return (200, {}, {"volumes": [
+            {'id': kw.get('id', 1234),
+             'name': 'sample-volume',
+             'attachments': [{'server_id': 1234}]},
+        ]})
+
+    def get_volumes_1234(self, **kw):
+        r = {'volume': self.get_volumes_detail(id=1234)[2]['volumes'][0]}
+        return (200, {}, r)
+
+    def get_volumes_5678(self, **kw):
+        r = {'volume': self.get_volumes_detail(id=5678)[2]['volumes'][0]}
+        return (200, {}, r)
+
+    def get_volumes_1234_encryption(self, **kw):
+        r = {'encryption_key_id': 'id'}
+        return (200, {}, r)
+
+    def post_volumes_1234_action(self, body, **kw):
+        _body = None
+        resp = 202
+        assert len(list(body)) == 1
+        action = list(body)[0]
+        if action == 'os-attach':
+            assert sorted(list(body[action])) == ['instance_uuid',
+                                                  'mode',
+                                                  'mountpoint']
+        elif action == 'os-detach':
+            assert body[action] is None
+        elif action == 'os-reserve':
+            assert body[action] is None
+        elif action == 'os-unreserve':
+            assert body[action] is None
+        elif action == 'os-initialize_connection':
+            assert list(body[action]) == ['connector']
+            return (202, {}, {'connection_info': 'foos'})
+        elif action == 'os-terminate_connection':
+            assert list(body[action]) == ['connector']
+        elif action == 'os-begin_detaching':
+            assert body[action] is None
+        elif action == 'os-roll_detaching':
+            assert body[action] is None
+        elif action == 'os-reset_status':
+            assert 'status' in body[action]
+        elif action == 'os-extend':
+            assert list(body[action]) == ['new_size']
+        elif action == 'os-migrate_volume':
+            assert 'host' in body[action]
+            assert 'force_host_copy' in body[action]
+        elif action == 'os-update_readonly_flag':
+            assert list(body[action]) == ['readonly']
+        elif action == 'os-retype':
+            assert 'new_type' in body[action]
+        elif action == 'os-set_bootable':
+            assert list(body[action]) == ['bootable']
+        elif action == 'os-unmanage':
+            assert body[action] is None
+        elif action == 'os-promote-replica':
+            assert body[action] is None
+        elif action == 'os-reenable-replica':
+            assert body[action] is None
+        else:
+            raise AssertionError("Unexpected action: %s" % action)
+        return (resp, {}, _body)
+
+    def post_volumes_5678_action(self, body, **kw):
+        return self.post_volumes_1234_action(body, **kw)
+
+    def post_volumes(self, **kw):
+        size = kw['body']['volume'].get('size', 1)
+        volume = _stub_volume(id='1234', size=size)
+        return (202, {}, {'volume': volume})
+
+    def delete_volumes_1234(self, **kw):
+        return (202, {}, None)
+
+    def delete_volumes_5678(self, **kw):
+        return (202, {}, None)
+
+    #
+    # Consistencygroups
+    #
+
+    def get_consistencygroups_detail(self, **kw):
+        return (200, {}, {"consistencygroups": [
+            _stub_consistencygroup(id='1234'),
+            _stub_consistencygroup(id='4567')]})
+
+    def get_consistencygroups_1234(self, **kw):
+        return (200, {}, {'consistencygroup':
+                          _stub_consistencygroup(id='1234')})
+
+    def post_consistencygroups(self, **kw):
+        return (202, {}, {'consistencygroup': {}})
+
+    def post_consistencygroups_1234_delete(self, **kw):
+        return (202, {}, {})
+
+    #
+    # Cgsnapshots
+    #
+
+    def get_cgsnapshots_detail(self, **kw):
+        return (200, {}, {"cgsnapshots": [
+            _stub_cgsnapshot(id='1234'),
+            _stub_cgsnapshot(id='4567')]})
+
+    def get_cgsnapshots_1234(self, **kw):
+        return (200, {}, {'cgsnapshot': _stub_cgsnapshot(id='1234')})
+
+    def post_cgsnapshots(self, **kw):
+        return (202, {}, {'cgsnapshot': {}})
+
+    def delete_cgsnapshots_1234(self, **kw):
+        return (202, {}, {})
+
+    #
+    # Quotas
+    #
+
+    def get_os_quota_sets_test(self, **kw):
+        return (200, {}, {'quota_set': {
+                          'tenant_id': 'test',
+                          'metadata_items': [],
+                          'volumes': 1,
+                          'snapshots': 1,
+                          'gigabytes': 1}})
+
+    def get_os_quota_sets_test_defaults(self):
+        return (200, {}, {'quota_set': {
+                          'tenant_id': 'test',
+                          'metadata_items': [],
+                          'volumes': 1,
+                          'snapshots': 1,
+                          'gigabytes': 1}})
+
+    def put_os_quota_sets_test(self, body, **kw):
+        assert list(body) == ['quota_set']
+        fakes.assert_has_keys(body['quota_set'],
+                              required=['tenant_id'])
+        return (200, {}, {'quota_set': {
+                          'tenant_id': 'test',
+                          'metadata_items': [],
+                          'volumes': 2,
+                          'snapshots': 2,
+                          'gigabytes': 1}})
+
+    def delete_os_quota_sets_1234(self, **kw):
+        return (200, {}, {})
+
+    def delete_os_quota_sets_test(self, **kw):
+        return (200, {}, {})
+
+    #
+    # Quota Classes
+    #
+
+    def get_os_quota_class_sets_test(self, **kw):
+        return (200, {}, {'quota_class_set': {
+                          'class_name': 'test',
+                          'metadata_items': [],
+                          'volumes': 1,
+                          'snapshots': 1,
+                          'gigabytes': 1}})
+
+    def put_os_quota_class_sets_test(self, body, **kw):
+        assert list(body) == ['quota_class_set']
+        fakes.assert_has_keys(body['quota_class_set'],
+                              required=['class_name'])
+        return (200, {}, {'quota_class_set': {
+                          'class_name': 'test',
+                          'metadata_items': [],
+                          'volumes': 2,
+                          'snapshots': 2,
+                          'gigabytes': 1}})
+
+    #
+    # VolumeTypes
+    #
+    def get_types(self, **kw):
+        return (200, {}, {
+            'volume_types': [{'id': 1,
+                              'name': 'test-type-1',
+                              'extra_specs': {}},
+                             {'id': 2,
+                              'name': 'test-type-2',
+                              'extra_specs': {}}]})
+
+    def get_types_1(self, **kw):
+        return (200, {}, {'volume_type': {'id': 1,
+                          'name': 'test-type-1',
+                          'extra_specs': {}}})
+
+    def get_types_2(self, **kw):
+        return (200, {}, {'volume_type': {'id': 2,
+                          'name': 'test-type-2',
+                          'extra_specs': {}}})
+
+    def post_types(self, body, **kw):
+        return (202, {}, {'volume_type': {'id': 3,
+                          'name': 'test-type-3',
+                          'extra_specs': {}}})
+
+    def post_types_1_extra_specs(self, body, **kw):
+        assert list(body) == ['extra_specs']
+        return (200, {}, {'extra_specs': {'k': 'v'}})
+
+    def delete_types_1_extra_specs_k(self, **kw):
+        return(204, {}, None)
+
+    def delete_types_1(self, **kw):
+        return (202, {}, None)
+
+    #
+    # VolumeEncryptionTypes
+    #
+    def get_types_1_encryption(self, **kw):
+        return (200, {}, {'id': 1, 'volume_type_id': 1, 'provider': 'test',
+                          'cipher': 'test', 'key_size': 1,
+                          'control_location': 'front-end'})
+
+    def get_types_2_encryption(self, **kw):
+        return (200, {}, {})
+
+    def post_types_2_encryption(self, body, **kw):
+        return (200, {}, {'encryption': body})
+
+    def put_types_1_encryption_1(self, body, **kw):
+        return (200, {}, {})
+
+    def delete_types_1_encryption_provider(self, **kw):
+        return (202, {}, None)
+
+    #
+    # Set/Unset metadata
+    #
+    def delete_volumes_1234_metadata_test_key(self, **kw):
+        return (204, {}, None)
+
+    def delete_volumes_1234_metadata_key1(self, **kw):
+        return (204, {}, None)
+
+    def delete_volumes_1234_metadata_key2(self, **kw):
+        return (204, {}, None)
+
+    def post_volumes_1234_metadata(self, **kw):
+        return (204, {}, {'metadata': {'test_key': 'test_value'}})
+
+    #
+    # List all extensions
+    #
+    def get_extensions(self, **kw):
+        exts = [
+            {
+                "alias": "FAKE-1",
+                "description": "Fake extension number 1",
+                "links": [],
+                "name": "Fake1",
+                "namespace": ("http://docs.openstack.org/"
+                              "/ext/fake1/api/v1.1"),
+                "updated": "2011-06-09T00:00:00+00:00"
+            },
+            {
+                "alias": "FAKE-2",
+                "description": "Fake extension number 2",
+                "links": [],
+                "name": "Fake2",
+                "namespace": ("http://docs.openstack.org/"
+                              "/ext/fake1/api/v1.1"),
+                "updated": "2011-06-09T00:00:00+00:00"
+            },
+        ]
+        return (200, {}, {"extensions": exts, })
+
+    #
+    # VolumeBackups
+    #
+
+    def get_backups_76a17945_3c6f_435c_975b_b5685db10b62(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        backup1 = '76a17945-3c6f-435c-975b-b5685db10b62'
+        return (200, {},
+                {'backup': _stub_backup_full(backup1, base_uri, tenant_id)})
+
+    def get_backups_detail(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        backup1 = '76a17945-3c6f-435c-975b-b5685db10b62'
+        backup2 = 'd09534c6-08b8-4441-9e87-8976f3a8f699'
+        return (200, {},
+                {'backups': [
+                    _stub_backup_full(backup1, base_uri, tenant_id),
+                    _stub_backup_full(backup2, base_uri, tenant_id)]})
+
+    def delete_backups_76a17945_3c6f_435c_975b_b5685db10b62(self, **kw):
+        return (202, {}, None)
+
+    def post_backups(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        backup1 = '76a17945-3c6f-435c-975b-b5685db10b62'
+        return (202, {},
+                {'backup': _stub_backup(backup1, base_uri, tenant_id)})
+
+    def post_backups_76a17945_3c6f_435c_975b_b5685db10b62_restore(self, **kw):
+        return (200, {},
+                {'restore': _stub_restore()})
+
+    def post_backups_1234_restore(self, **kw):
+        return (200, {},
+                {'restore': _stub_restore()})
+
+    def get_backups_76a17945_3c6f_435c_975b_b5685db10b62_export_record(self,
+                                                                       **kw):
+        return (200,
+                {},
+                {'backup-record': {'backup_service': 'fake-backup-service',
+                                   'backup_url': 'fake-backup-url'}})
+
+    def get_backups_1234_export_record(self, **kw):
+        return (200,
+                {},
+                {'backup-record': {'backup_service': 'fake-backup-service',
+                                   'backup_url': 'fake-backup-url'}})
+
+    def post_backups_import_record(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        backup1 = '76a17945-3c6f-435c-975b-b5685db10b62'
+        return (200,
+                {},
+                {'backup': _stub_backup(backup1, base_uri, tenant_id)})
+
+    #
+    # QoSSpecs
+    #
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        qos_id1 = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        return (200, {},
+                _stub_qos_full(qos_id1, base_uri, tenant_id))
+
+    def get_qos_specs(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        qos_id1 = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        qos_id2 = '0FD8DD14-A396-4E55-9573-1FE59042E95B'
+        return (200, {},
+                {'qos_specs': [
+                    _stub_qos_full(qos_id1, base_uri, tenant_id, 'name-1'),
+                    _stub_qos_full(qos_id2, base_uri, tenant_id)]})
+
+    def post_qos_specs(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        qos_name = 'qos-name'
+        return (202, {},
+                _stub_qos_full(qos_id, base_uri, tenant_id, qos_name))
+
+    def put_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C(self, **kw):
+        return (202, {}, None)
+
+    def put_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_delete_keys(
+            self, **kw):
+        return (202, {}, None)
+
+    def delete_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C(self, **kw):
+        return (202, {}, None)
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_associations(
+            self, **kw):
+        type_id1 = '4230B13A-7A37-4E84-B777-EFBA6FCEE4FF'
+        type_id2 = '4230B13A-AB37-4E84-B777-EFBA6FCEE4FF'
+        type_name1 = 'type1'
+        type_name2 = 'type2'
+        return (202, {},
+                {'qos_associations': [
+                    _stub_qos_associates(type_id1, type_name1),
+                    _stub_qos_associates(type_id2, type_name2)]})
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_associate(
+            self, **kw):
+        return (202, {}, None)
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_disassociate(
+            self, **kw):
+        return (202, {}, None)
+
+    def get_qos_specs_1B6B6A04_A927_4AEB_810B_B7BAAD49F57C_disassociate_all(
+            self, **kw):
+        return (202, {}, None)
+
+    #
+    #
+    # VolumeTransfers
+    #
+
+    def get_os_volume_transfer_5678(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        return (200, {},
+                {'transfer':
+                 _stub_transfer_full(transfer1, base_uri, tenant_id)})
+
+    def get_os_volume_transfer_detail(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        transfer2 = 'f625ec3e-13dd-4498-a22a-50afd534cc41'
+        return (200, {},
+                {'transfers': [
+                    _stub_transfer_full(transfer1, base_uri, tenant_id),
+                    _stub_transfer_full(transfer2, base_uri, tenant_id)]})
+
+    def delete_os_volume_transfer_5678(self, **kw):
+        return (202, {}, None)
+
+    def post_os_volume_transfer(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        return (202, {},
+                {'transfer': _stub_transfer(transfer1, base_uri, tenant_id)})
+
+    def post_os_volume_transfer_5678_accept(self, **kw):
+        base_uri = 'http://localhost:8776'
+        tenant_id = '0fa851f6668144cf9cd8c8419c1646c1'
+        transfer1 = '5678'
+        return (200, {},
+                {'transfer': _stub_transfer(transfer1, base_uri, tenant_id)})
+
+    #
+    # Services
+    #
+    def get_os_services(self, **kw):
+        host = kw.get('host', None)
+        binary = kw.get('binary', None)
+        services = [
+            {
+                'binary': 'cinder-volume',
+                'host': 'host1',
+                'zone': 'cinder',
+                'status': 'enabled',
+                'state': 'up',
+                'updated_at': datetime(2012, 10, 29, 13, 42, 2)
+            },
+            {
+                'binary': 'cinder-volume',
+                'host': 'host2',
+                'zone': 'cinder',
+                'status': 'disabled',
+                'state': 'down',
+                'updated_at': datetime(2012, 9, 18, 8, 3, 38)
+            },
+            {
+                'binary': 'cinder-scheduler',
+                'host': 'host2',
+                'zone': 'cinder',
+                'status': 'disabled',
+                'state': 'down',
+                'updated_at': datetime(2012, 9, 18, 8, 3, 38)
+            },
+        ]
+        if host:
+            services = filter(lambda i: i['host'] == host, services)
+        if binary:
+            services = filter(lambda i: i['binary'] == binary, services)
+        return (200, {}, {'services': services})
+
+    def put_os_services_enable(self, body, **kw):
+        return (200, {}, {'host': body['host'], 'binary': body['binary'],
+                'status': 'enabled'})
+
+    def put_os_services_disable(self, body, **kw):
+        return (200, {}, {'host': body['host'], 'binary': body['binary'],
+                'status': 'disabled'})
+
+    def put_os_services_disable_log_reason(self, body, **kw):
+        return (200, {}, {'host': body['host'], 'binary': body['binary'],
+                'status': 'disabled',
+                'disabled_reason': body['disabled_reason']})
+
+    def get_os_availability_zone(self, **kw):
+        return (200, {}, {
+            "availabilityZoneInfo": [
+                {
+                    "zoneName": "zone-1",
+                    "zoneState": {"available": True},
+                    "hosts": None,
+                },
+                {
+                    "zoneName": "zone-2",
+                    "zoneState": {"available": False},
+                    "hosts": None,
+                },
+                ]
+        })
+
+    def get_os_availability_zone_detail(self, **kw):
+        return (200, {}, {
+            "availabilityZoneInfo": [
+                {
+                    "zoneName": "zone-1",
+                    "zoneState": {"available": True},
+                    "hosts": {
+                        "fake_host-1": {
+                            "cinder-volume": {
+                                "active": True,
+                                "available": True,
+                                "updated_at":
+                                datetime(2012, 12, 26, 14, 45, 25, 0)
+                            }
+                        }
+                    }
+                },
+                {
+                    "zoneName": "internal",
+                    "zoneState": {"available": True},
+                    "hosts": {
+                        "fake_host-1": {
+                            "cinder-sched": {
+                                "active": True,
+                                "available": True,
+                                "updated_at":
+                                datetime(2012, 12, 26, 14, 45, 24, 0)
+                            }
+                        }
+                    }
+                },
+                {
+                    "zoneName": "zone-2",
+                    "zoneState": {"available": False},
+                    "hosts": None,
+                },
+                ]
+        })
+
+    def post_snapshots_1234_metadata(self, **kw):
+        return (200, {}, {"metadata": {"key1": "val1", "key2": "val2"}})
+
+    def delete_snapshots_1234_metadata_key1(self, **kw):
+        return (200, {}, None)
+
+    def delete_snapshots_1234_metadata_key2(self, **kw):
+        return (200, {}, None)
+
+    def put_volumes_1234_metadata(self, **kw):
+        return (200, {}, {"metadata": {"key1": "val1", "key2": "val2"}})
+
+    def put_snapshots_1234_metadata(self, **kw):
+        return (200, {}, {"metadata": {"key1": "val1", "key2": "val2"}})
+
+    def post_os_volume_manage(self, **kw):
+        volume = _stub_volume(id='1234')
+        volume.update(kw['body']['volume'])
+        return (202, {}, {'volume': volume})
+
+    def post_os_promote_replica_1234(self, **kw):
+        return (202, {}, {})
+
+    def post_os_reenable_replica_1234(self, **kw):
+        return (202, {}, {})

awx/lib/site-packages/cinderclient/tests/v2/test_auth.py

@@ -0,0 +1,341 @@
+# Copyright (c) 2013 OpenStack Foundation
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import json
+
+import mock
+import requests
+
+from cinderclient import exceptions
+from cinderclient.v2 import client
+from cinderclient.tests import utils
+
+
+class AuthenticateAgainstKeystoneTests(utils.TestCase):
+    def test_authenticate_success(self):
+        cs = client.Client("username", "password", "project_id",
+                           "http://localhost:8776/v2", service_type='volumev2')
+        resp = {
+            "access": {
+                "token": {
+                    "expires": "2014-11-01T03:32:15-05:00",
+                    "id": "FAKE_ID",
+                },
+                "serviceCatalog": [
+                    {
+                        "type": "volumev2",
+                        "endpoints": [
+                            {
+                                "region": "RegionOne",
+                                "adminURL": "http://localhost:8776/v2",
+                                "internalURL": "http://localhost:8776/v2",
+                                "publicURL": "http://localhost:8776/v2",
+                            },
+                        ],
+                    },
+                ],
+            },
+        }
+        auth_response = utils.TestResponse({
+            "status_code": 200,
+            "text": json.dumps(resp),
+        })
+
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'User-Agent': cs.client.USER_AGENT,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            }
+            body = {
+                'auth': {
+                    'passwordCredentials': {
+                        'username': cs.client.user,
+                        'password': cs.client.password,
+                    },
+                    'tenantName': cs.client.projectid,
+                },
+            }
+
+            token_url = cs.client.auth_url + "/tokens"
+            mock_request.assert_called_with(
+                "POST",
+                token_url,
+                headers=headers,
+                data=json.dumps(body),
+                allow_redirects=True,
+                **self.TEST_REQUEST_BASE)
+
+            endpoints = resp["access"]["serviceCatalog"][0]['endpoints']
+            public_url = endpoints[0]["publicURL"].rstrip('/')
+            self.assertEqual(public_url, cs.client.management_url)
+            token_id = resp["access"]["token"]["id"]
+            self.assertEqual(token_id, cs.client.auth_token)
+
+        test_auth_call()
+
+    def test_authenticate_tenant_id(self):
+        cs = client.Client("username", "password",
+                           auth_url="http://localhost:8776/v2",
+                           tenant_id='tenant_id', service_type='volumev2')
+        resp = {
+            "access": {
+                "token": {
+                    "expires": "2014-11-01T03:32:15-05:00",
+                    "id": "FAKE_ID",
+                    "tenant": {
+                        "description": None,
+                        "enabled": True,
+                        "id": "tenant_id",
+                        "name": "demo"
+                    }  # tenant associated with token
+                },
+                "serviceCatalog": [
+                    {
+                        "type": 'volumev2',
+                        "endpoints": [
+                            {
+                                "region": "RegionOne",
+                                "adminURL": "http://localhost:8776/v2",
+                                "internalURL": "http://localhost:8776/v2",
+                                "publicURL": "http://localhost:8776/v2",
+                            },
+                        ],
+                    },
+                ],
+            },
+        }
+        auth_response = utils.TestResponse({
+            "status_code": 200,
+            "text": json.dumps(resp),
+        })
+
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'User-Agent': cs.client.USER_AGENT,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            }
+            body = {
+                'auth': {
+                    'passwordCredentials': {
+                        'username': cs.client.user,
+                        'password': cs.client.password,
+                    },
+                    'tenantId': cs.client.tenant_id,
+                },
+            }
+
+            token_url = cs.client.auth_url + "/tokens"
+            mock_request.assert_called_with(
+                "POST",
+                token_url,
+                headers=headers,
+                data=json.dumps(body),
+                allow_redirects=True,
+                **self.TEST_REQUEST_BASE)
+
+            endpoints = resp["access"]["serviceCatalog"][0]['endpoints']
+            public_url = endpoints[0]["publicURL"].rstrip('/')
+            self.assertEqual(public_url, cs.client.management_url)
+            token_id = resp["access"]["token"]["id"]
+            self.assertEqual(token_id, cs.client.auth_token)
+            tenant_id = resp["access"]["token"]["tenant"]["id"]
+            self.assertEqual(tenant_id, cs.client.tenant_id)
+
+        test_auth_call()
+
+    def test_authenticate_failure(self):
+        cs = client.Client("username", "password", "project_id",
+                           "http://localhost:8776/v2")
+        resp = {"unauthorized": {"message": "Unauthorized", "code": "401"}}
+        auth_response = utils.TestResponse({
+            "status_code": 401,
+            "text": json.dumps(resp),
+        })
+
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            self.assertRaises(exceptions.Unauthorized, cs.client.authenticate)
+
+        test_auth_call()
+
+    def test_auth_redirect(self):
+        cs = client.Client("username", "password", "project_id",
+                           "http://localhost:8776/v2", service_type='volumev2')
+        dict_correct_response = {
+            "access": {
+                "token": {
+                    "expires": "2014-11-01T03:32:15-05:00",
+                    "id": "FAKE_ID",
+                },
+                "serviceCatalog": [
+                    {
+                        "type": "volumev2",
+                        "endpoints": [
+                            {
+                                "adminURL": "http://localhost:8776/v2",
+                                "region": "RegionOne",
+                                "internalURL": "http://localhost:8776/v2",
+                                "publicURL": "http://localhost:8776/v2/",
+                            },
+                        ],
+                    },
+                ],
+            },
+        }
+        correct_response = json.dumps(dict_correct_response)
+        dict_responses = [
+            {"headers": {'location': 'http://127.0.0.1:5001'},
+             "status_code": 305,
+             "text": "Use proxy"},
+            # Configured on admin port, cinder redirects to v2.0 port.
+            # When trying to connect on it, keystone auth succeed by v1.0
+            # protocol (through headers) but tokens are being returned in
+            # body (looks like keystone bug). Leaved for compatibility.
+            {"headers": {},
+             "status_code": 200,
+             "text": correct_response},
+            {"headers": {},
+             "status_code": 200,
+             "text": correct_response}
+        ]
+
+        responses = [(utils.TestResponse(resp)) for resp in dict_responses]
+
+        def side_effect(*args, **kwargs):
+            return responses.pop(0)
+
+        mock_request = mock.Mock(side_effect=side_effect)
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'User-Agent': cs.client.USER_AGENT,
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+            }
+            body = {
+                'auth': {
+                    'passwordCredentials': {
+                        'username': cs.client.user,
+                        'password': cs.client.password,
+                    },
+                    'tenantName': cs.client.projectid,
+                },
+            }
+
+            token_url = cs.client.auth_url + "/tokens"
+            mock_request.assert_called_with(
+                "POST",
+                token_url,
+                headers=headers,
+                data=json.dumps(body),
+                allow_redirects=True,
+                **self.TEST_REQUEST_BASE)
+
+            resp = dict_correct_response
+            endpoints = resp["access"]["serviceCatalog"][0]['endpoints']
+            public_url = endpoints[0]["publicURL"].rstrip('/')
+            self.assertEqual(public_url, cs.client.management_url)
+            token_id = resp["access"]["token"]["id"]
+            self.assertEqual(token_id, cs.client.auth_token)
+
+        test_auth_call()
+
+
+class AuthenticationTests(utils.TestCase):
+    def test_authenticate_success(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+        management_url = 'https://localhost/v2.1/443470'
+        auth_response = utils.TestResponse({
+            'status_code': 204,
+            'headers': {
+                'x-server-management-url': management_url,
+                'x-auth-token': '1b751d74-de0c-46ae-84f0-915744b582d1',
+            },
+        })
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            cs.client.authenticate()
+            headers = {
+                'Accept': 'application/json',
+                'X-Auth-User': 'username',
+                'X-Auth-Key': 'password',
+                'X-Auth-Project-Id': 'project_id',
+                'User-Agent': cs.client.USER_AGENT
+            }
+            mock_request.assert_called_with(
+                "GET",
+                cs.client.auth_url,
+                headers=headers,
+                **self.TEST_REQUEST_BASE)
+
+            self.assertEqual(auth_response.headers['x-server-management-url'],
+                             cs.client.management_url)
+            self.assertEqual(auth_response.headers['x-auth-token'],
+                             cs.client.auth_token)
+
+        test_auth_call()
+
+    def test_authenticate_failure(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+        auth_response = utils.TestResponse({"status_code": 401})
+        mock_request = mock.Mock(return_value=(auth_response))
+
+        @mock.patch.object(requests, "request", mock_request)
+        def test_auth_call():
+            self.assertRaises(exceptions.Unauthorized, cs.client.authenticate)
+
+        test_auth_call()
+
+    def test_auth_automatic(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+        http_client = cs.client
+        http_client.management_url = ''
+        mock_request = mock.Mock(return_value=(None, None))
+
+        @mock.patch.object(http_client, 'request', mock_request)
+        @mock.patch.object(http_client, 'authenticate')
+        def test_auth_call(m):
+            http_client.get('/')
+            m.assert_called()
+            mock_request.assert_called()
+
+        test_auth_call()
+
+    def test_auth_manual(self):
+        cs = client.Client("username", "password", "project_id", "auth_url")
+
+        @mock.patch.object(cs.client, 'authenticate')
+        def test_auth_call(m):
+            cs.authenticate()
+            m.assert_called()
+
+        test_auth_call()

awx/lib/site-packages/cinderclient/tests/v2/test_availability_zone.py

@@ -0,0 +1,88 @@
+# Copyright 2011-2013 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import six
+
+from cinderclient.v2 import availability_zones
+from cinderclient.v2 import shell
+from cinderclient.tests.fixture_data import client
+from cinderclient.tests.fixture_data import availability_zones as azfixture
+from cinderclient.tests import utils
+
+
+class AvailabilityZoneTest(utils.FixturedTestCase):
+
+    client_fixture_class = client.V2
+    data_fixture_class = azfixture.Fixture
+
+    def _assertZone(self, zone, name, status):
+        self.assertEqual(name, zone.zoneName)
+        self.assertEqual(status, zone.zoneState)
+
+    def test_list_availability_zone(self):
+        zones = self.cs.availability_zones.list(detailed=False)
+        self.assert_called('GET', '/os-availability-zone')
+
+        for zone in zones:
+            self.assertIsInstance(zone,
+                                  availability_zones.AvailabilityZone)
+
+        self.assertEqual(2, len(zones))
+
+        l0 = [six.u('zone-1'), six.u('available')]
+        l1 = [six.u('zone-2'), six.u('not available')]
+
+        z0 = shell._treeizeAvailabilityZone(zones[0])
+        z1 = shell._treeizeAvailabilityZone(zones[1])
+
+        self.assertEqual((1, 1), (len(z0), len(z1)))
+
+        self._assertZone(z0[0], l0[0], l0[1])
+        self._assertZone(z1[0], l1[0], l1[1])
+
+    def test_detail_availability_zone(self):
+        zones = self.cs.availability_zones.list(detailed=True)
+        self.assert_called('GET', '/os-availability-zone/detail')
+
+        for zone in zones:
+            self.assertIsInstance(zone,
+                                  availability_zones.AvailabilityZone)
+
+        self.assertEqual(3, len(zones))
+
+        l0 = [six.u('zone-1'), six.u('available')]
+        l1 = [six.u('|- fake_host-1'), six.u('')]
+        l2 = [six.u('| |- cinder-volume'),
+              six.u('enabled :-) 2012-12-26 14:45:25')]
+        l3 = [six.u('internal'), six.u('available')]
+        l4 = [six.u('|- fake_host-1'), six.u('')]
+        l5 = [six.u('| |- cinder-sched'),
+              six.u('enabled :-) 2012-12-26 14:45:24')]
+        l6 = [six.u('zone-2'), six.u('not available')]
+
+        z0 = shell._treeizeAvailabilityZone(zones[0])
+        z1 = shell._treeizeAvailabilityZone(zones[1])
+        z2 = shell._treeizeAvailabilityZone(zones[2])
+
+        self.assertEqual((3, 3, 1), (len(z0), len(z1), len(z2)))
+
+        self._assertZone(z0[0], l0[0], l0[1])
+        self._assertZone(z0[1], l1[0], l1[1])
+        self._assertZone(z0[2], l2[0], l2[1])
+        self._assertZone(z1[0], l3[0], l3[1])
+        self._assertZone(z1[1], l4[0], l4[1])
+        self._assertZone(z1[2], l5[0], l5[1])
+        self._assertZone(z2[0], l6[0], l6[1])

awx/lib/site-packages/cinderclient/tests/v2/test_cgsnapshots.py

@@ -0,0 +1,56 @@
+# Copyright (C) 2012 - 2014 EMC Corporation.
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class cgsnapshotsTest(utils.TestCase):
+
+    def test_delete_cgsnapshot(self):
+        v = cs.cgsnapshots.list()[0]
+        v.delete()
+        cs.assert_called('DELETE', '/cgsnapshots/1234')
+        cs.cgsnapshots.delete('1234')
+        cs.assert_called('DELETE', '/cgsnapshots/1234')
+        cs.cgsnapshots.delete(v)
+        cs.assert_called('DELETE', '/cgsnapshots/1234')
+
+    def test_create_cgsnapshot(self):
+        cs.cgsnapshots.create('cgsnap')
+        cs.assert_called('POST', '/cgsnapshots')
+
+    def test_create_cgsnapshot_with_cg_id(self):
+        cs.cgsnapshots.create('1234')
+        expected = {'cgsnapshot': {'status': 'creating',
+                                   'description': None,
+                                   'user_id': None,
+                                   'name': None,
+                                   'consistencygroup_id': '1234',
+                                   'project_id': None}}
+        cs.assert_called('POST', '/cgsnapshots', body=expected)
+
+    def test_list_cgsnapshot(self):
+        cs.cgsnapshots.list()
+        cs.assert_called('GET', '/cgsnapshots/detail')
+
+    def test_get_cgsnapshot(self):
+        cgsnapshot_id = '1234'
+        cs.cgsnapshots.get(cgsnapshot_id)
+        cs.assert_called('GET', '/cgsnapshots/%s' % cgsnapshot_id)

awx/lib/site-packages/cinderclient/tests/v2/test_consistencygroups.py

@@ -0,0 +1,52 @@
+# Copyright (C) 2012 - 2014 EMC Corporation.
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class ConsistencygroupsTest(utils.TestCase):
+
+    def test_delete_consistencygroup(self):
+        v = cs.consistencygroups.list()[0]
+        v.delete(force='True')
+        cs.assert_called('POST', '/consistencygroups/1234/delete')
+        cs.consistencygroups.delete('1234', force=True)
+        cs.assert_called('POST', '/consistencygroups/1234/delete')
+        cs.consistencygroups.delete(v, force=True)
+        cs.assert_called('POST', '/consistencygroups/1234/delete')
+
+    def test_create_consistencygroup(self):
+        cs.consistencygroups.create('type1,type2', 'cg')
+        cs.assert_called('POST', '/consistencygroups')
+
+    def test_create_consistencygroup_with_volume_types(self):
+        cs.consistencygroups.create('type1,type2', 'cg')
+        expected = {'consistencygroup': {'status': 'creating',
+                                         'description': None,
+                                         'availability_zone': None,
+                                         'user_id': None,
+                                         'name': 'cg',
+                                         'volume_types': 'type1,type2',
+                                         'project_id': None}}
+        cs.assert_called('POST', '/consistencygroups', body=expected)
+
+    def test_list_consistencygroup(self):
+        cs.consistencygroups.list()
+        cs.assert_called('GET', '/consistencygroups/detail')

awx/lib/site-packages/cinderclient/tests/v2/test_limits.py

@@ -0,0 +1,164 @@
+# Copyright 2014 OpenStack Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import mock
+
+from cinderclient.tests import utils
+from cinderclient.v2 import limits
+
+
+def _get_default_RateLimit(verb="verb1", uri="uri1", regex="regex1",
+                           value="value1",
+                           remain="remain1", unit="unit1",
+                           next_available="next1"):
+    return limits.RateLimit(verb, uri, regex, value, remain, unit,
+                            next_available)
+
+
+class TestLimits(utils.TestCase):
+    def test_repr(self):
+        l = limits.Limits(None, {"foo": "bar"})
+        self.assertEqual("<Limits>", repr(l))
+
+    def test_absolute(self):
+        l = limits.Limits(None,
+                          {"absolute": {"name1": "value1", "name2": "value2"}})
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name2", "value2")
+        for item in l.absolute:
+            self.assertIn(item, [l1, l2])
+
+    def test_rate(self):
+        l = limits.Limits(None,
+                          {
+                              "rate": [
+                                  {
+                                      "uri": "uri1",
+                                      "regex": "regex1",
+                                      "limit": [
+                                          {
+                                              "verb": "verb1",
+                                              "value": "value1",
+                                              "remaining": "remain1",
+                                              "unit": "unit1",
+                                              "next-available": "next1",
+                                          },
+                                      ],
+                                  },
+                                  {
+                                      "uri": "uri2",
+                                      "regex": "regex2",
+                                      "limit": [
+                                          {
+                                              "verb": "verb2",
+                                              "value": "value2",
+                                              "remaining": "remain2",
+                                              "unit": "unit2",
+                                              "next-available": "next2",
+                                          },
+                                      ],
+                                  },
+                              ],
+                          })
+        l1 = limits.RateLimit("verb1", "uri1", "regex1", "value1", "remain1",
+                              "unit1", "next1")
+        l2 = limits.RateLimit("verb2", "uri2", "regex2", "value2", "remain2",
+                              "unit2", "next2")
+        for item in l.rate:
+            self.assertIn(item, [l1, l2])
+
+
+class TestRateLimit(utils.TestCase):
+    def test_equal(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit()
+        self.assertEqual(l1, l2)
+
+    def test_not_equal_verbs(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(verb="verb2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_uris(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(uri="uri2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_regexps(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(regex="regex2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_values(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(value="value2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_remains(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(remain="remain2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_units(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(unit="unit2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_next_available(self):
+        l1 = _get_default_RateLimit()
+        l2 = _get_default_RateLimit(next_available="next2")
+        self.assertNotEqual(l1, l2)
+
+    def test_repr(self):
+        l1 = _get_default_RateLimit()
+        self.assertEqual("<RateLimit: method=verb1 uri=uri1>", repr(l1))
+
+
+class TestAbsoluteLimit(utils.TestCase):
+    def test_equal(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name1", "value1")
+        self.assertEqual(l1, l2)
+
+    def test_not_equal_values(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name1", "value2")
+        self.assertNotEqual(l1, l2)
+
+    def test_not_equal_names(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        l2 = limits.AbsoluteLimit("name2", "value1")
+        self.assertNotEqual(l1, l2)
+
+    def test_repr(self):
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        self.assertEqual("<AbsoluteLimit: name=name1>", repr(l1))
+
+
+class TestLimitsManager(utils.TestCase):
+    def test_get(self):
+        api = mock.Mock()
+        api.client.get.return_value = (
+            None,
+            {"limits": {"absolute": {"name1": "value1", }},
+             "no-limits": {"absolute": {"name2": "value2", }}})
+        l1 = limits.AbsoluteLimit("name1", "value1")
+        limitsManager = limits.LimitsManager(api)
+
+        lim = limitsManager.get()
+
+        self.assertIsInstance(lim, limits.Limits)
+        for l in lim.absolute:
+            self.assertEqual(l1, l)

awx/lib/site-packages/cinderclient/tests/v2/test_qos.py

@@ -0,0 +1,79 @@
+# Copyright (C) 2013 eBay Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class QoSSpecsTest(utils.TestCase):
+
+    def test_create(self):
+        specs = dict(k1='v1', k2='v2')
+        cs.qos_specs.create('qos-name', specs)
+        cs.assert_called('POST', '/qos-specs')
+
+    def test_get(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.get(qos_id)
+        cs.assert_called('GET', '/qos-specs/%s' % qos_id)
+
+    def test_list(self):
+        cs.qos_specs.list()
+        cs.assert_called('GET', '/qos-specs')
+
+    def test_delete(self):
+        cs.qos_specs.delete('1B6B6A04-A927-4AEB-810B-B7BAAD49F57C')
+        cs.assert_called('DELETE',
+                         '/qos-specs/1B6B6A04-A927-4AEB-810B-B7BAAD49F57C?'
+                         'force=False')
+
+    def test_set_keys(self):
+        body = {'qos_specs': dict(k1='v1')}
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.set_keys(qos_id, body)
+        cs.assert_called('PUT', '/qos-specs/%s' % qos_id)
+
+    def test_unset_keys(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        body = {'keys': ['k1']}
+        cs.qos_specs.unset_keys(qos_id, body)
+        cs.assert_called('PUT', '/qos-specs/%s/delete_keys' % qos_id)
+
+    def test_get_associations(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.get_associations(qos_id)
+        cs.assert_called('GET', '/qos-specs/%s/associations' % qos_id)
+
+    def test_associate(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        type_id = '4230B13A-7A37-4E84-B777-EFBA6FCEE4FF'
+        cs.qos_specs.associate(qos_id, type_id)
+        cs.assert_called('GET', '/qos-specs/%s/associate?vol_type_id=%s'
+                         % (qos_id, type_id))
+
+    def test_disassociate(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        type_id = '4230B13A-7A37-4E84-B777-EFBA6FCEE4FF'
+        cs.qos_specs.disassociate(qos_id, type_id)
+        cs.assert_called('GET', '/qos-specs/%s/disassociate?vol_type_id=%s'
+                         % (qos_id, type_id))
+
+    def test_disassociate_all(self):
+        qos_id = '1B6B6A04-A927-4AEB-810B-B7BAAD49F57C'
+        cs.qos_specs.disassociate_all(qos_id)
+        cs.assert_called('GET', '/qos-specs/%s/disassociate_all' % qos_id)

awx/lib/site-packages/cinderclient/tests/v2/test_quota_classes.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class QuotaClassSetsTest(utils.TestCase):
+
+    def test_class_quotas_get(self):
+        class_name = 'test'
+        cs.quota_classes.get(class_name)
+        cs.assert_called('GET', '/os-quota-class-sets/%s' % class_name)
+
+    def test_update_quota(self):
+        q = cs.quota_classes.get('test')
+        q.update(volumes=2, snapshots=2)
+        cs.assert_called('PUT', '/os-quota-class-sets/test')
+
+    def test_refresh_quota(self):
+        q = cs.quota_classes.get('test')
+        q2 = cs.quota_classes.get('test')
+        self.assertEqual(q.volumes, q2.volumes)
+        q2.volumes = 0
+        self.assertNotEqual(q.volumes, q2.volumes)
+        q2.get()
+        self.assertEqual(q.volumes, q2.volumes)

awx/lib/site-packages/cinderclient/tests/v2/test_quotas.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class QuotaSetsTest(utils.TestCase):
+
+    def test_tenant_quotas_get(self):
+        tenant_id = 'test'
+        cs.quotas.get(tenant_id)
+        cs.assert_called('GET', '/os-quota-sets/%s?usage=False' % tenant_id)
+
+    def test_tenant_quotas_defaults(self):
+        tenant_id = 'test'
+        cs.quotas.defaults(tenant_id)
+        cs.assert_called('GET', '/os-quota-sets/%s/defaults' % tenant_id)
+
+    def test_update_quota(self):
+        q = cs.quotas.get('test')
+        q.update(volumes=2)
+        q.update(snapshots=2)
+        cs.assert_called('PUT', '/os-quota-sets/test')
+
+    def test_refresh_quota(self):
+        q = cs.quotas.get('test')
+        q2 = cs.quotas.get('test')
+        self.assertEqual(q.volumes, q2.volumes)
+        self.assertEqual(q.snapshots, q2.snapshots)
+        q2.volumes = 0
+        self.assertNotEqual(q.volumes, q2.volumes)
+        q2.snapshots = 0
+        self.assertNotEqual(q.snapshots, q2.snapshots)
+        q2.get()
+        self.assertEqual(q.volumes, q2.volumes)
+        self.assertEqual(q.snapshots, q2.snapshots)
+
+    def test_delete_quota(self):
+        tenant_id = 'test'
+        cs.quotas.delete(tenant_id)
+        cs.assert_called('DELETE', '/os-quota-sets/test')

awx/lib/site-packages/cinderclient/tests/v2/test_services.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+from cinderclient.v2 import services
+
+
+cs = fakes.FakeClient()
+
+
+class ServicesTest(utils.TestCase):
+
+    def test_list_services(self):
+        svs = cs.services.list()
+        cs.assert_called('GET', '/os-services')
+        self.assertEqual(3, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+
+    def test_list_services_with_hostname(self):
+        svs = cs.services.list(host='host2')
+        cs.assert_called('GET', '/os-services?host=host2')
+        self.assertEqual(2, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+        [self.assertEqual('host2', s.host) for s in svs]
+
+    def test_list_services_with_binary(self):
+        svs = cs.services.list(binary='cinder-volume')
+        cs.assert_called('GET', '/os-services?binary=cinder-volume')
+        self.assertEqual(2, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+        [self.assertEqual('cinder-volume', s.binary) for s in svs]
+
+    def test_list_services_with_host_binary(self):
+        svs = cs.services.list('host2', 'cinder-volume')
+        cs.assert_called('GET', '/os-services?host=host2&binary=cinder-volume')
+        self.assertEqual(1, len(svs))
+        [self.assertIsInstance(s, services.Service) for s in svs]
+        [self.assertEqual('host2', s.host) for s in svs]
+        [self.assertEqual('cinder-volume', s.binary) for s in svs]
+
+    def test_services_enable(self):
+        s = cs.services.enable('host1', 'cinder-volume')
+        values = {"host": "host1", 'binary': 'cinder-volume'}
+        cs.assert_called('PUT', '/os-services/enable', values)
+        self.assertIsInstance(s, services.Service)
+        self.assertEqual('enabled', s.status)
+
+    def test_services_disable(self):
+        s = cs.services.disable('host1', 'cinder-volume')
+        values = {"host": "host1", 'binary': 'cinder-volume'}
+        cs.assert_called('PUT', '/os-services/disable', values)
+        self.assertIsInstance(s, services.Service)
+        self.assertEqual('disabled', s.status)
+
+    def test_services_disable_log_reason(self):
+        s = cs.services.disable_log_reason(
+            'host1', 'cinder-volume', 'disable bad host')
+        values = {"host": "host1", 'binary': 'cinder-volume',
+                  "disabled_reason": "disable bad host"}
+        cs.assert_called('PUT', '/os-services/disable-log-reason', values)
+        self.assertIsInstance(s, services.Service)
+        self.assertEqual('disabled', s.status)

awx/lib/site-packages/cinderclient/tests/v2/test_shell.py

@@ -0,0 +1,542 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import fixtures
+from requests_mock.contrib import fixture as requests_mock_fixture
+
+from cinderclient import client
+from cinderclient import exceptions
+from cinderclient import shell
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+from cinderclient.tests.fixture_data import keystone_client
+
+
+class ShellTest(utils.TestCase):
+
+    FAKE_ENV = {
+        'CINDER_USERNAME': 'username',
+        'CINDER_PASSWORD': 'password',
+        'CINDER_PROJECT_ID': 'project_id',
+        'OS_VOLUME_API_VERSION': '2',
+        'CINDER_URL': keystone_client.BASE_URL,
+    }
+
+    # Patch os.environ to avoid required auth info.
+    def setUp(self):
+        """Run before each test."""
+        super(ShellTest, self).setUp()
+        for var in self.FAKE_ENV:
+            self.useFixture(fixtures.EnvironmentVariable(var,
+                                                         self.FAKE_ENV[var]))
+
+        self.shell = shell.OpenStackCinderShell()
+
+        # HACK(bcwaldon): replace this when we start using stubs
+        self.old_get_client_class = client.get_client_class
+        client.get_client_class = lambda *_: fakes.FakeClient
+
+        self.requests = self.useFixture(requests_mock_fixture.Fixture())
+        self.requests.register_uri(
+            'GET', keystone_client.BASE_URL,
+            text=keystone_client.keystone_request_callback)
+
+    def tearDown(self):
+        # For some method like test_image_meta_bad_action we are
+        # testing a SystemExit to be thrown and object self.shell has
+        # no time to get instantatiated which is OK in this case, so
+        # we make sure the method is there before launching it.
+        if hasattr(self.shell, 'cs'):
+            self.shell.cs.clear_callstack()
+
+        # HACK(bcwaldon): replace this when we start using stubs
+        client.get_client_class = self.old_get_client_class
+        super(ShellTest, self).tearDown()
+
+    def run_command(self, cmd):
+        self.shell.main(cmd.split())
+
+    def assert_called(self, method, url, body=None,
+                      partial_body=None, **kwargs):
+        return self.shell.cs.assert_called(method, url, body,
+                                           partial_body, **kwargs)
+
+    def assert_called_anytime(self, method, url, body=None,
+                              partial_body=None):
+        return self.shell.cs.assert_called_anytime(method, url, body,
+                                                   partial_body)
+
+    def test_list(self):
+        self.run_command('list')
+        # NOTE(jdg): we default to detail currently
+        self.assert_called('GET', '/volumes/detail')
+
+    def test_list_filter_status(self):
+        self.run_command('list --status=available')
+        self.assert_called('GET', '/volumes/detail?status=available')
+
+    def test_list_filter_name(self):
+        self.run_command('list --name=1234')
+        self.assert_called('GET', '/volumes/detail?name=1234')
+
+    def test_list_all_tenants(self):
+        self.run_command('list --all-tenants=1')
+        self.assert_called('GET', '/volumes/detail?all_tenants=1')
+
+    def test_list_marker(self):
+        self.run_command('list --marker=1234')
+        self.assert_called('GET', '/volumes/detail?marker=1234')
+
+    def test_list_limit(self):
+        self.run_command('list --limit=10')
+        self.assert_called('GET', '/volumes/detail?limit=10')
+
+    def test_list_sort(self):
+        self.run_command('list --sort_key=name --sort_dir=asc')
+        self.assert_called('GET', '/volumes/detail?sort_dir=asc&sort_key=name')
+
+    def test_list_availability_zone(self):
+        self.run_command('availability-zone-list')
+        self.assert_called('GET', '/os-availability-zone')
+
+    def test_create_volume_from_snapshot(self):
+        expected = {'volume': {'size': None}}
+
+        expected['volume']['snapshot_id'] = '1234'
+        self.run_command('create --snapshot-id=1234')
+        self.assert_called_anytime('POST', '/volumes', partial_body=expected)
+        self.assert_called('GET', '/volumes/1234')
+
+        expected['volume']['size'] = 2
+        self.run_command('create --snapshot-id=1234 2')
+        self.assert_called_anytime('POST', '/volumes', partial_body=expected)
+        self.assert_called('GET', '/volumes/1234')
+
+    def test_create_volume_from_volume(self):
+        expected = {'volume': {'size': None}}
+
+        expected['volume']['source_volid'] = '1234'
+        self.run_command('create --source-volid=1234')
+        self.assert_called_anytime('POST', '/volumes', partial_body=expected)
+        self.assert_called('GET', '/volumes/1234')
+
+        expected['volume']['size'] = 2
+        self.run_command('create --source-volid=1234 2')
+        self.assert_called_anytime('POST', '/volumes', partial_body=expected)
+        self.assert_called('GET', '/volumes/1234')
+
+    def test_create_volume_from_replica(self):
+        expected = {'volume': {'size': None}}
+
+        expected['volume']['source_replica'] = '1234'
+        self.run_command('create --source-replica=1234')
+        self.assert_called_anytime('POST', '/volumes', partial_body=expected)
+        self.assert_called('GET', '/volumes/1234')
+
+    def test_create_size_required_if_not_snapshot_or_clone(self):
+        self.assertRaises(SystemExit, self.run_command, 'create')
+
+    def test_show(self):
+        self.run_command('show 1234')
+        self.assert_called('GET', '/volumes/1234')
+
+    def test_delete(self):
+        self.run_command('delete 1234')
+        self.assert_called('DELETE', '/volumes/1234')
+
+    def test_delete_by_name(self):
+        self.run_command('delete sample-volume')
+        self.assert_called_anytime('GET', '/volumes/detail?all_tenants=1')
+        self.assert_called('DELETE', '/volumes/1234')
+
+    def test_delete_multiple(self):
+        self.run_command('delete 1234 5678')
+        self.assert_called_anytime('DELETE', '/volumes/1234')
+        self.assert_called('DELETE', '/volumes/5678')
+
+    def test_backup(self):
+        self.run_command('backup-create 1234')
+        self.assert_called('POST', '/backups')
+
+    def test_restore(self):
+        self.run_command('backup-restore 1234')
+        self.assert_called('POST', '/backups/1234/restore')
+
+    def test_record_export(self):
+        self.run_command('backup-export 1234')
+        self.assert_called('GET', '/backups/1234/export_record')
+
+    def test_record_import(self):
+        self.run_command('backup-import fake.driver URL_STRING')
+        expected = {'backup-record': {'backup_service': 'fake.driver',
+                                      'backup_url': 'URL_STRING'}}
+        self.assert_called('POST', '/backups/import_record', expected)
+
+    def test_snapshot_list_filter_volume_id(self):
+        self.run_command('snapshot-list --volume-id=1234')
+        self.assert_called('GET', '/snapshots/detail?volume_id=1234')
+
+    def test_snapshot_list_filter_status_and_volume_id(self):
+        self.run_command('snapshot-list --status=available --volume-id=1234')
+        self.assert_called('GET', '/snapshots/detail?'
+                           'status=available&volume_id=1234')
+
+    def test_rename(self):
+        # basic rename with positional arguments
+        self.run_command('rename 1234 new-name')
+        expected = {'volume': {'name': 'new-name'}}
+        self.assert_called('PUT', '/volumes/1234', body=expected)
+        # change description only
+        self.run_command('rename 1234 --description=new-description')
+        expected = {'volume': {'description': 'new-description'}}
+        self.assert_called('PUT', '/volumes/1234', body=expected)
+        # rename and change description
+        self.run_command('rename 1234 new-name '
+                         '--description=new-description')
+        expected = {'volume': {
+            'name': 'new-name',
+            'description': 'new-description',
+        }}
+        self.assert_called('PUT', '/volumes/1234', body=expected)
+
+        # Call rename with no arguments
+        self.assertRaises(SystemExit, self.run_command, 'rename')
+
+    def test_rename_snapshot(self):
+        # basic rename with positional arguments
+        self.run_command('snapshot-rename 1234 new-name')
+        expected = {'snapshot': {'name': 'new-name'}}
+        self.assert_called('PUT', '/snapshots/1234', body=expected)
+        # change description only
+        self.run_command('snapshot-rename 1234 '
+                         '--description=new-description')
+        expected = {'snapshot': {'description': 'new-description'}}
+        self.assert_called('PUT', '/snapshots/1234', body=expected)
+        # snapshot-rename and change description
+        self.run_command('snapshot-rename 1234 new-name '
+                         '--description=new-description')
+        expected = {'snapshot': {
+            'name': 'new-name',
+            'description': 'new-description',
+        }}
+        self.assert_called('PUT', '/snapshots/1234', body=expected)
+
+        # Call snapshot-rename with no arguments
+        self.assertRaises(SystemExit, self.run_command, 'snapshot-rename')
+
+    def test_set_metadata_set(self):
+        self.run_command('metadata 1234 set key1=val1 key2=val2')
+        self.assert_called('POST', '/volumes/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_set_metadata_delete_dict(self):
+        self.run_command('metadata 1234 unset key1=val1 key2=val2')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key1')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key2', pos=-2)
+
+    def test_set_metadata_delete_keys(self):
+        self.run_command('metadata 1234 unset key1 key2')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key1')
+        self.assert_called('DELETE', '/volumes/1234/metadata/key2', pos=-2)
+
+    def test_reset_state(self):
+        self.run_command('reset-state 1234')
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_reset_state_with_flag(self):
+        self.run_command('reset-state --state error 1234')
+        expected = {'os-reset_status': {'status': 'error'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_reset_state_multiple(self):
+        self.run_command('reset-state 1234 5678 --state error')
+        expected = {'os-reset_status': {'status': 'error'}}
+        self.assert_called_anytime('POST', '/volumes/1234/action',
+                                   body=expected)
+        self.assert_called_anytime('POST', '/volumes/5678/action',
+                                   body=expected)
+
+    def test_reset_state_two_with_one_nonexistent(self):
+        cmd = 'reset-state 1234 123456789'
+        self.assertRaises(exceptions.CommandError, self.run_command, cmd)
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called_anytime('POST', '/volumes/1234/action',
+                                   body=expected)
+
+    def test_reset_state_one_with_one_nonexistent(self):
+        cmd = 'reset-state 123456789'
+        self.assertRaises(exceptions.CommandError, self.run_command, cmd)
+
+    def test_snapshot_reset_state(self):
+        self.run_command('snapshot-reset-state 1234')
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called('POST', '/snapshots/1234/action', body=expected)
+
+    def test_snapshot_reset_state_with_flag(self):
+        self.run_command('snapshot-reset-state --state error 1234')
+        expected = {'os-reset_status': {'status': 'error'}}
+        self.assert_called('POST', '/snapshots/1234/action', body=expected)
+
+    def test_snapshot_reset_state_multiple(self):
+        self.run_command('snapshot-reset-state 1234 5678')
+        expected = {'os-reset_status': {'status': 'available'}}
+        self.assert_called_anytime('POST', '/snapshots/1234/action',
+                                   body=expected)
+        self.assert_called_anytime('POST', '/snapshots/5678/action',
+                                   body=expected)
+
+    def test_encryption_type_list(self):
+        """
+        Test encryption-type-list shell command.
+
+        Verify a series of GET requests are made:
+        - one to get the volume type list information
+        - one per volume type to retrieve the encryption type information
+        """
+        self.run_command('encryption-type-list')
+        self.assert_called_anytime('GET', '/types')
+        self.assert_called_anytime('GET', '/types/1/encryption')
+        self.assert_called_anytime('GET', '/types/2/encryption')
+
+    def test_encryption_type_show(self):
+        """
+        Test encryption-type-show shell command.
+
+        Verify two GET requests are made per command invocation:
+        - one to get the volume type information
+        - one to get the encryption type information
+        """
+        self.run_command('encryption-type-show 1')
+        self.assert_called('GET', '/types/1/encryption')
+        self.assert_called_anytime('GET', '/types/1')
+
+    def test_encryption_type_create(self):
+        """
+        Test encryption-type-create shell command.
+
+        Verify GET and POST requests are made per command invocation:
+        - one GET request to retrieve the relevant volume type information
+        - one POST request to create the new encryption type
+        """
+
+        expected = {'encryption': {'cipher': None, 'key_size': None,
+                                   'provider': 'TestProvider',
+                                   'control_location': 'front-end'}}
+        self.run_command('encryption-type-create 2 TestProvider')
+        self.assert_called('POST', '/types/2/encryption', body=expected)
+        self.assert_called_anytime('GET', '/types/2')
+
+    def test_encryption_type_update(self):
+        """
+        Test encryption-type-update shell command.
+
+        Verify two GETs/one PUT requests are made per command invocation:
+        - one GET request to retrieve the relevant volume type information
+        - one GET request to retrieve the relevant encryption type information
+        - one PUT request to update the encryption type information
+        """
+        self.skipTest("Not implemented")
+
+    def test_encryption_type_delete(self):
+        """
+        Test encryption-type-delete shell command.
+
+        Verify one GET/one DELETE requests are made per command invocation:
+        - one GET request to retrieve the relevant volume type information
+        - one DELETE request to delete the encryption type information
+        """
+        self.run_command('encryption-type-delete 1')
+        self.assert_called('DELETE', '/types/1/encryption/provider')
+        self.assert_called_anytime('GET', '/types/1')
+
+    def test_migrate_volume(self):
+        self.run_command('migrate 1234 fakehost --force-host-copy=True')
+        expected = {'os-migrate_volume': {'force_host_copy': 'True',
+                                          'host': 'fakehost'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_snapshot_metadata_set(self):
+        self.run_command('snapshot-metadata 1234 set key1=val1 key2=val2')
+        self.assert_called('POST', '/snapshots/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_snapshot_metadata_unset_dict(self):
+        self.run_command('snapshot-metadata 1234 unset key1=val1 key2=val2')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key1')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key2')
+
+    def test_snapshot_metadata_unset_keys(self):
+        self.run_command('snapshot-metadata 1234 unset key1 key2')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key1')
+        self.assert_called_anytime('DELETE', '/snapshots/1234/metadata/key2')
+
+    def test_volume_metadata_update_all(self):
+        self.run_command('metadata-update-all 1234  key1=val1 key2=val2')
+        self.assert_called('PUT', '/volumes/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_snapshot_metadata_update_all(self):
+        self.run_command('snapshot-metadata-update-all\
+                         1234 key1=val1 key2=val2')
+        self.assert_called('PUT', '/snapshots/1234/metadata',
+                           {'metadata': {'key1': 'val1', 'key2': 'val2'}})
+
+    def test_readonly_mode_update(self):
+        self.run_command('readonly-mode-update 1234 True')
+        expected = {'os-update_readonly_flag': {'readonly': True}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+        self.run_command('readonly-mode-update 1234 False')
+        expected = {'os-update_readonly_flag': {'readonly': False}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_service_disable(self):
+        self.run_command('service-disable host cinder-volume')
+        self.assert_called('PUT', '/os-services/disable',
+                           {"binary": "cinder-volume", "host": "host"})
+
+    def test_services_disable_with_reason(self):
+        cmd = 'service-disable host cinder-volume --reason no_reason'
+        self.run_command(cmd)
+        body = {'host': 'host', 'binary': 'cinder-volume',
+                'disabled_reason': 'no_reason'}
+        self.assert_called('PUT', '/os-services/disable-log-reason', body)
+
+    def test_service_enable(self):
+        self.run_command('service-enable host cinder-volume')
+        self.assert_called('PUT', '/os-services/enable',
+                           {"binary": "cinder-volume", "host": "host"})
+
+    def test_retype_with_policy(self):
+        self.run_command('retype 1234 foo --migration-policy=on-demand')
+        expected = {'os-retype': {'new_type': 'foo',
+                                  'migration_policy': 'on-demand'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_retype_default_policy(self):
+        self.run_command('retype 1234 foo')
+        expected = {'os-retype': {'new_type': 'foo',
+                                  'migration_policy': 'never'}}
+        self.assert_called('POST', '/volumes/1234/action', body=expected)
+
+    def test_snapshot_delete(self):
+        self.run_command('snapshot-delete 1234')
+        self.assert_called('DELETE', '/snapshots/1234')
+
+    def test_quota_delete(self):
+        self.run_command('quota-delete 1234')
+        self.assert_called('DELETE', '/os-quota-sets/1234')
+
+    def test_snapshot_delete_multiple(self):
+        self.run_command('snapshot-delete 5678')
+        self.assert_called('DELETE', '/snapshots/5678')
+
+    def test_volume_manage(self):
+        self.run_command('manage host1 key1=val1 key2=val2 '
+                         '--name foo --description bar '
+                         '--volume-type baz --availability-zone az '
+                         '--metadata k1=v1 k2=v2')
+        expected = {'volume': {'host': 'host1',
+                               'ref': {'key1': 'val1', 'key2': 'val2'},
+                               'name': 'foo',
+                               'description': 'bar',
+                               'volume_type': 'baz',
+                               'availability_zone': 'az',
+                               'metadata': {'k1': 'v1', 'k2': 'v2'},
+                               'bootable': False}}
+        self.assert_called_anytime('POST', '/os-volume-manage', body=expected)
+
+    def test_volume_manage_bootable(self):
+        """
+        Tests the --bootable option
+
+        If this flag is specified, then the resulting POST should contain
+        bootable: True.
+        """
+        self.run_command('manage host1 key1=val1 key2=val2 '
+                         '--name foo --description bar --bootable '
+                         '--volume-type baz --availability-zone az '
+                         '--metadata k1=v1 k2=v2')
+        expected = {'volume': {'host': 'host1',
+                               'ref': {'key1': 'val1', 'key2': 'val2'},
+                               'name': 'foo',
+                               'description': 'bar',
+                               'volume_type': 'baz',
+                               'availability_zone': 'az',
+                               'metadata': {'k1': 'v1', 'k2': 'v2'},
+                               'bootable': True}}
+        self.assert_called_anytime('POST', '/os-volume-manage', body=expected)
+
+    def test_volume_manage_source_name(self):
+        """
+        Tests the --source-name option.
+
+        Checks that the --source-name option correctly updates the
+        ref structure that is passed in the HTTP POST
+        """
+        self.run_command('manage host1 key1=val1 key2=val2 '
+                         '--source-name VolName '
+                         '--name foo --description bar '
+                         '--volume-type baz --availability-zone az '
+                         '--metadata k1=v1 k2=v2')
+        expected = {'volume': {'host': 'host1',
+                               'ref': {'source-name': 'VolName',
+                                       'key1': 'val1', 'key2': 'val2'},
+                               'name': 'foo',
+                               'description': 'bar',
+                               'volume_type': 'baz',
+                               'availability_zone': 'az',
+                               'metadata': {'k1': 'v1', 'k2': 'v2'},
+                               'bootable': False}}
+        self.assert_called_anytime('POST', '/os-volume-manage', body=expected)
+
+    def test_volume_manage_source_id(self):
+        """
+        Tests the --source-id option.
+
+        Checks that the --source-id option correctly updates the
+        ref structure that is passed in the HTTP POST
+        """
+        self.run_command('manage host1 key1=val1 key2=val2 '
+                         '--source-id 1234 '
+                         '--name foo --description bar '
+                         '--volume-type baz --availability-zone az '
+                         '--metadata k1=v1 k2=v2')
+        expected = {'volume': {'host': 'host1',
+                               'ref': {'source-id': '1234',
+                                       'key1': 'val1', 'key2': 'val2'},
+                               'name': 'foo',
+                               'description': 'bar',
+                               'volume_type': 'baz',
+                               'availability_zone': 'az',
+                               'metadata': {'k1': 'v1', 'k2': 'v2'},
+                               'bootable': False}}
+        self.assert_called_anytime('POST', '/os-volume-manage', body=expected)
+
+    def test_volume_unmanage(self):
+        self.run_command('unmanage 1234')
+        self.assert_called('POST', '/volumes/1234/action',
+                           body={'os-unmanage': None})
+
+    def test_replication_promote(self):
+        self.run_command('replication-promote 1234')
+        self.assert_called('POST', '/volumes/1234/action',
+                           body={'os-promote-replica': None})
+
+    def test_replication_reenable(self):
+        self.run_command('replication-reenable 1234')
+        self.assert_called('POST', '/volumes/1234/action',
+                           body={'os-reenable-replica': None})

awx/lib/site-packages/cinderclient/tests/v2/test_snapshot_actions.py

@@ -0,0 +1,36 @@
+# Copyright 2013 Red Hat, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.fixture_data import client
+from cinderclient.tests.fixture_data import snapshots
+
+
+class SnapshotActionsTest(utils.FixturedTestCase):
+
+    client_fixture_class = client.V2
+    data_fixture_class = snapshots.Fixture
+
+    def test_update_snapshot_status(self):
+        s = self.cs.volume_snapshots.get('1234')
+        stat = {'status': 'available'}
+        self.cs.volume_snapshots.update_snapshot_status(s, stat)
+        self.assert_called('POST', '/snapshots/1234/action')
+
+    def test_update_snapshot_status_with_progress(self):
+        s = self.cs.volume_snapshots.get('1234')
+        stat = {'status': 'available', 'progress': '73%'}
+        self.cs.volume_snapshots.update_snapshot_status(s, stat)
+        self.assert_called('POST', '/snapshots/1234/action')

awx/lib/site-packages/cinderclient/tests/v2/test_types.py

@@ -0,0 +1,50 @@
+# Copyright (c) 2013 OpenStack Foundation
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.v2 import volume_types
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+cs = fakes.FakeClient()
+
+
+class TypesTest(utils.TestCase):
+    def test_list_types(self):
+        tl = cs.volume_types.list()
+        cs.assert_called('GET', '/types')
+        for t in tl:
+            self.assertIsInstance(t, volume_types.VolumeType)
+
+    def test_create(self):
+        t = cs.volume_types.create('test-type-3')
+        cs.assert_called('POST', '/types')
+        self.assertIsInstance(t, volume_types.VolumeType)
+
+    def test_set_key(self):
+        t = cs.volume_types.get(1)
+        t.set_keys({'k': 'v'})
+        cs.assert_called('POST',
+                         '/types/1/extra_specs',
+                         {'extra_specs': {'k': 'v'}})
+
+    def test_unsset_keys(self):
+        t = cs.volume_types.get(1)
+        t.unset_keys(['k'])
+        cs.assert_called('DELETE', '/types/1/extra_specs/k')
+
+    def test_delete(self):
+        cs.volume_types.delete(1)
+        cs.assert_called('DELETE', '/types/1')

awx/lib/site-packages/cinderclient/tests/v2/test_volume_backups.py

@@ -0,0 +1,67 @@
+# Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class VolumeBackupsTest(utils.TestCase):
+
+    def test_create(self):
+        cs.backups.create('2b695faf-b963-40c8-8464-274008fbcef4')
+        cs.assert_called('POST', '/backups')
+
+    def test_get(self):
+        backup_id = '76a17945-3c6f-435c-975b-b5685db10b62'
+        cs.backups.get(backup_id)
+        cs.assert_called('GET', '/backups/%s' % backup_id)
+
+    def test_list(self):
+        cs.backups.list()
+        cs.assert_called('GET', '/backups/detail')
+
+    def test_delete(self):
+        b = cs.backups.list()[0]
+        b.delete()
+        cs.assert_called('DELETE',
+                         '/backups/76a17945-3c6f-435c-975b-b5685db10b62')
+        cs.backups.delete('76a17945-3c6f-435c-975b-b5685db10b62')
+        cs.assert_called('DELETE',
+                         '/backups/76a17945-3c6f-435c-975b-b5685db10b62')
+        cs.backups.delete(b)
+        cs.assert_called('DELETE',
+                         '/backups/76a17945-3c6f-435c-975b-b5685db10b62')
+
+    def test_restore(self):
+        backup_id = '76a17945-3c6f-435c-975b-b5685db10b62'
+        cs.restores.restore(backup_id)
+        cs.assert_called('POST', '/backups/%s/restore' % backup_id)
+
+    def test_record_export(self):
+        backup_id = '76a17945-3c6f-435c-975b-b5685db10b62'
+        cs.backups.export_record(backup_id)
+        cs.assert_called('GET',
+                         '/backups/%s/export_record' % backup_id)
+
+    def test_record_import(self):
+        backup_service = 'fake-backup-service'
+        backup_url = 'fake-backup-url'
+        expected_body = {'backup-record': {'backup_service': backup_service,
+                                           'backup_url': backup_url}}
+        cs.backups.import_record(backup_service, backup_url)
+        cs.assert_called('POST', '/backups/import_record', expected_body)

awx/lib/site-packages/cinderclient/tests/v2/test_volume_encryption_types.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2013 The Johns Hopkins University/Applied Physics Laboratory
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.v2.volume_encryption_types import VolumeEncryptionType
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+cs = fakes.FakeClient()
+
+
+class VolumeEncryptionTypesTest(utils.TestCase):
+    """
+    Test suite for the Volume Encryption Types Resource and Manager.
+    """
+
+    def test_list(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.list
+
+        Verify that a series of GET requests are made:
+        - one GET request for the list of volume types
+        - one GET request per volume type for encryption type information
+
+        Verify that all returned information is :class: VolumeEncryptionType
+        """
+        encryption_types = cs.volume_encryption_types.list()
+        cs.assert_called_anytime('GET', '/types')
+        cs.assert_called_anytime('GET', '/types/2/encryption')
+        cs.assert_called_anytime('GET', '/types/1/encryption')
+        for encryption_type in encryption_types:
+            self.assertIsInstance(encryption_type, VolumeEncryptionType)
+
+    def test_get(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.get
+
+        Verify that one GET request is made for the volume type encryption
+        type information. Verify that returned information is :class:
+        VolumeEncryptionType
+        """
+        encryption_type = cs.volume_encryption_types.get(1)
+        cs.assert_called('GET', '/types/1/encryption')
+        self.assertIsInstance(encryption_type, VolumeEncryptionType)
+
+    def test_get_no_encryption(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.get
+
+        Verify that a request on a volume type with no associated encryption
+        type information returns a VolumeEncryptionType with no attributes.
+        """
+        encryption_type = cs.volume_encryption_types.get(2)
+        self.assertIsInstance(encryption_type, VolumeEncryptionType)
+        self.assertFalse(hasattr(encryption_type, 'id'),
+                         'encryption type has an id')
+
+    def test_create(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.create
+
+        Verify that one POST request is made for the encryption type creation.
+        Verify that encryption type creation returns a VolumeEncryptionType.
+        """
+        result = cs.volume_encryption_types.create(2, {'provider': 'Test',
+                                                       'key_size': None,
+                                                       'cipher': None,
+                                                       'control_location':
+                                                       None})
+        cs.assert_called('POST', '/types/2/encryption')
+        self.assertIsInstance(result, VolumeEncryptionType)
+
+    def test_update(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.update
+        """
+        self.skipTest("Not implemented")
+
+    def test_delete(self):
+        """
+        Unit test for VolumeEncryptionTypesManager.delete
+
+        Verify that one DELETE request is made for encryption type deletion
+        Verify that encryption type deletion returns None
+        """
+        result = cs.volume_encryption_types.delete(1)
+        cs.assert_called('DELETE', '/types/1/encryption/provider')
+        self.assertIsNone(result, "delete result must be None")

awx/lib/site-packages/cinderclient/tests/v2/test_volume_transfers.py

@@ -0,0 +1,51 @@
+# Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v1 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class VolumeTransfersTest(utils.TestCase):
+
+    def test_create(self):
+        cs.transfers.create('1234')
+        cs.assert_called('POST', '/os-volume-transfer')
+
+    def test_get(self):
+        transfer_id = '5678'
+        cs.transfers.get(transfer_id)
+        cs.assert_called('GET', '/os-volume-transfer/%s' % transfer_id)
+
+    def test_list(self):
+        cs.transfers.list()
+        cs.assert_called('GET', '/os-volume-transfer/detail')
+
+    def test_delete(self):
+        b = cs.transfers.list()[0]
+        b.delete()
+        cs.assert_called('DELETE', '/os-volume-transfer/5678')
+        cs.transfers.delete('5678')
+        cs.assert_called('DELETE', '/os-volume-transfer/5678')
+        cs.transfers.delete(b)
+        cs.assert_called('DELETE', '/os-volume-transfer/5678')
+
+    def test_accept(self):
+        transfer_id = '5678'
+        auth_key = '12345'
+        cs.transfers.accept(transfer_id, auth_key)
+        cs.assert_called('POST', '/os-volume-transfer/%s/accept' % transfer_id)

awx/lib/site-packages/cinderclient/tests/v2/test_volumes.py

@@ -0,0 +1,178 @@
+# Copyright (c) 2013 OpenStack Foundation
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.tests import utils
+from cinderclient.tests.v2 import fakes
+
+
+cs = fakes.FakeClient()
+
+
+class VolumesTest(utils.TestCase):
+
+    def test_list_volumes_with_marker_limit(self):
+        cs.volumes.list(marker=1234, limit=2)
+        cs.assert_called('GET', '/volumes/detail?limit=2&marker=1234')
+
+    def test_list_volumes_with_sort_key_dir(self):
+        cs.volumes.list(sort_key='id', sort_dir='asc')
+        cs.assert_called('GET', '/volumes/detail?sort_dir=asc&sort_key=id')
+
+    def test_list_volumes_with_invalid_sort_key(self):
+        self.assertRaises(ValueError,
+                          cs.volumes.list, sort_key='invalid', sort_dir='asc')
+
+    def test_list_volumes_with_invalid_sort_dir(self):
+        self.assertRaises(ValueError,
+                          cs.volumes.list, sort_key='id', sort_dir='invalid')
+
+    def test_delete_volume(self):
+        v = cs.volumes.list()[0]
+        v.delete()
+        cs.assert_called('DELETE', '/volumes/1234')
+        cs.volumes.delete('1234')
+        cs.assert_called('DELETE', '/volumes/1234')
+        cs.volumes.delete(v)
+        cs.assert_called('DELETE', '/volumes/1234')
+
+    def test_create_volume(self):
+        cs.volumes.create(1)
+        cs.assert_called('POST', '/volumes')
+
+    def test_create_volume_with_hint(self):
+        cs.volumes.create(1, scheduler_hints='uuid')
+        expected = {'volume': {'status': 'creating',
+                               'description': None,
+                               'availability_zone': None,
+                               'source_volid': None,
+                               'snapshot_id': None,
+                               'size': 1,
+                               'user_id': None,
+                               'name': None,
+                               'imageRef': None,
+                               'attach_status': 'detached',
+                               'volume_type': None,
+                               'project_id': None,
+                               'metadata': {},
+                               'source_replica': None,
+                               'consistencygroup_id': None},
+                    'OS-SCH-HNT:scheduler_hints': 'uuid'}
+        cs.assert_called('POST', '/volumes', body=expected)
+
+    def test_attach(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.attach(v, 1, '/dev/vdc', mode='ro')
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_detach(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.detach(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_reserve(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.reserve(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_unreserve(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.unreserve(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_begin_detaching(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.begin_detaching(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_roll_detaching(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.roll_detaching(v)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_initialize_connection(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.initialize_connection(v, {})
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_terminate_connection(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.terminate_connection(v, {})
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_set_metadata(self):
+        cs.volumes.set_metadata(1234, {'k1': 'v2'})
+        cs.assert_called('POST', '/volumes/1234/metadata',
+                         {'metadata': {'k1': 'v2'}})
+
+    def test_delete_metadata(self):
+        keys = ['key1']
+        cs.volumes.delete_metadata(1234, keys)
+        cs.assert_called('DELETE', '/volumes/1234/metadata/key1')
+
+    def test_extend(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.extend(v, 2)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_get_encryption_metadata(self):
+        cs.volumes.get_encryption_metadata('1234')
+        cs.assert_called('GET', '/volumes/1234/encryption')
+
+    def test_migrate(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.migrate_volume(v, 'dest', False)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_metadata_update_all(self):
+        cs.volumes.update_all_metadata(1234, {'k1': 'v1'})
+        cs.assert_called('PUT', '/volumes/1234/metadata',
+                         {'metadata': {'k1': 'v1'}})
+
+    def test_readonly_mode_update(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.update_readonly_flag(v, True)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_retype(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.retype(v, 'foo', 'on-demand')
+        cs.assert_called('POST', '/volumes/1234/action',
+                         {'os-retype': {'new_type': 'foo',
+                                        'migration_policy': 'on-demand'}})
+
+    def test_set_bootable(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.set_bootable(v, True)
+        cs.assert_called('POST', '/volumes/1234/action')
+
+    def test_volume_manage(self):
+        cs.volumes.manage('host1', {'k': 'v'})
+        expected = {'host': 'host1', 'name': None, 'availability_zone': None,
+                    'description': None, 'metadata': None, 'ref': {'k': 'v'},
+                    'volume_type': None, 'bootable': False}
+        cs.assert_called('POST', '/os-volume-manage', {'volume': expected})
+
+    def test_volume_manage_bootable(self):
+        cs.volumes.manage('host1', {'k': 'v'}, bootable=True)
+        expected = {'host': 'host1', 'name': None, 'availability_zone': None,
+                    'description': None, 'metadata': None, 'ref': {'k': 'v'},
+                    'volume_type': None, 'bootable': True}
+        cs.assert_called('POST', '/os-volume-manage', {'volume': expected})
+
+    def test_volume_unmanage(self):
+        v = cs.volumes.get('1234')
+        cs.volumes.unmanage(v)
+        cs.assert_called('POST', '/volumes/1234/action', {'os-unmanage': None})

awx/lib/site-packages/cinderclient/utils.py

@@ -0,0 +1,317 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from __future__ import print_function
+
+import os
+import pkg_resources
+import re
+import sys
+import uuid
+
+import six
+import prettytable
+
+from cinderclient import exceptions
+from cinderclient.openstack.common import strutils
+
+
+def arg(*args, **kwargs):
+    """Decorator for CLI args."""
+    def _decorator(func):
+        add_arg(func, *args, **kwargs)
+        return func
+    return _decorator
+
+
+def env(*vars, **kwargs):
+    """
+    returns the first environment variable set
+    if none are non-empty, defaults to '' or keyword arg default
+    """
+    for v in vars:
+        value = os.environ.get(v, None)
+        if value:
+            return value
+    return kwargs.get('default', '')
+
+
+def add_arg(f, *args, **kwargs):
+    """Bind CLI arguments to a shell.py `do_foo` function."""
+
+    if not hasattr(f, 'arguments'):
+        f.arguments = []
+
+    # NOTE(sirp): avoid dups that can occur when the module is shared across
+    # tests.
+    if (args, kwargs) not in f.arguments:
+        # Because of the semantics of decorator composition if we just append
+        # to the options list positional options will appear to be backwards.
+        f.arguments.insert(0, (args, kwargs))
+
+
+def add_resource_manager_extra_kwargs_hook(f, hook):
+    """Adds hook to bind CLI arguments to ResourceManager calls.
+
+    The `do_foo` calls in shell.py will receive CLI args and then in turn pass
+    them through to the ResourceManager. Before passing through the args, the
+    hooks registered here will be called, giving us a chance to add extra
+    kwargs (taken from the command-line) to what's passed to the
+    ResourceManager.
+    """
+    if not hasattr(f, 'resource_manager_kwargs_hooks'):
+        f.resource_manager_kwargs_hooks = []
+
+    names = [h.__name__ for h in f.resource_manager_kwargs_hooks]
+    if hook.__name__ not in names:
+        f.resource_manager_kwargs_hooks.append(hook)
+
+
+def get_resource_manager_extra_kwargs(f, args, allow_conflicts=False):
+    """Return extra_kwargs by calling resource manager kwargs hooks."""
+    hooks = getattr(f, "resource_manager_kwargs_hooks", [])
+    extra_kwargs = {}
+    for hook in hooks:
+        hook_name = hook.__name__
+        hook_kwargs = hook(args)
+
+        conflicting_keys = set(hook_kwargs.keys()) & set(extra_kwargs.keys())
+        if conflicting_keys and not allow_conflicts:
+            msg = ("Hook '%(hook_name)s' is attempting to redefine attributes "
+                   "'%(conflicting_keys)s'" % {
+                       'hook_name': hook_name,
+                       'conflicting_keys': conflicting_keys
+                   })
+            raise Exception(msg)
+
+        extra_kwargs.update(hook_kwargs)
+
+    return extra_kwargs
+
+
+def unauthenticated(f):
+    """
+    Adds 'unauthenticated' attribute to decorated function.
+    Usage:
+        @unauthenticated
+        def mymethod(f):
+            ...
+    """
+    f.unauthenticated = True
+    return f
+
+
+def isunauthenticated(f):
+    """
+    Checks to see if the function is marked as not requiring authentication
+    with the @unauthenticated decorator. Returns True if decorator is
+    set to True, False otherwise.
+    """
+    return getattr(f, 'unauthenticated', False)
+
+
+def service_type(stype):
+    """
+    Adds 'service_type' attribute to decorated function.
+    Usage:
+        @service_type('volume')
+        def mymethod(f):
+            ...
+    """
+    def inner(f):
+        f.service_type = stype
+        return f
+    return inner
+
+
+def get_service_type(f):
+    """
+    Retrieves service type from function
+    """
+    return getattr(f, 'service_type', None)
+
+
+def pretty_choice_list(l):
+    return ', '.join("'%s'" % i for i in l)
+
+
+def _print(pt, order):
+    if sys.version_info >= (3, 0):
+        print(pt.get_string(sortby=order))
+    else:
+        print(strutils.safe_encode(pt.get_string(sortby=order)))
+
+
+def print_list(objs, fields, formatters={}, order_by=None):
+    mixed_case_fields = ['serverId']
+    pt = prettytable.PrettyTable([f for f in fields], caching=False)
+    pt.aligns = ['l' for f in fields]
+
+    for o in objs:
+        row = []
+        for field in fields:
+            if field in formatters:
+                row.append(formatters[field](o))
+            else:
+                if field in mixed_case_fields:
+                    field_name = field.replace(' ', '_')
+                else:
+                    field_name = field.lower().replace(' ', '_')
+                if type(o) == dict and field in o:
+                    data = o[field]
+                else:
+                    data = getattr(o, field_name, '')
+                row.append(data)
+        pt.add_row(row)
+
+    if order_by is None:
+        order_by = fields[0]
+    _print(pt, order_by)
+
+
+def print_dict(d, property="Property"):
+    pt = prettytable.PrettyTable([property, 'Value'], caching=False)
+    pt.aligns = ['l', 'l']
+    [pt.add_row(list(r)) for r in six.iteritems(d)]
+    _print(pt, property)
+
+
+def find_resource(manager, name_or_id):
+    """Helper for the _find_* methods."""
+    # first try to get entity as integer id
+    try:
+        if isinstance(name_or_id, int) or name_or_id.isdigit():
+            return manager.get(int(name_or_id))
+    except exceptions.NotFound:
+        pass
+
+    if sys.version_info <= (3, 0):
+        name_or_id = strutils.safe_decode(name_or_id)
+
+    # now try to get entity as uuid
+    try:
+        uuid.UUID(name_or_id)
+        return manager.get(name_or_id)
+    except (ValueError, exceptions.NotFound):
+        pass
+
+    try:
+        try:
+            return manager.find(human_id=name_or_id)
+        except exceptions.NotFound:
+            pass
+
+        # finally try to find entity by name
+        try:
+            return manager.find(name=name_or_id)
+        except exceptions.NotFound:
+            try:
+                return manager.find(display_name=name_or_id)
+            except (UnicodeDecodeError, exceptions.NotFound):
+                try:
+                    # Volumes does not have name, but display_name
+                    return manager.find(display_name=name_or_id)
+                except exceptions.NotFound:
+                    msg = "No %s with a name or ID of '%s' exists." % \
+                        (manager.resource_class.__name__.lower(), name_or_id)
+                    raise exceptions.CommandError(msg)
+    except exceptions.NoUniqueMatch:
+        msg = ("Multiple %s matches found for '%s', use an ID to be more"
+               " specific." % (manager.resource_class.__name__.lower(),
+                               name_or_id))
+        raise exceptions.CommandError(msg)
+
+
+def find_volume(cs, volume):
+    """Get a volume by name or ID."""
+    return find_resource(cs.volumes, volume)
+
+
+def _format_servers_list_networks(server):
+    output = []
+    for (network, addresses) in list(server.networks.items()):
+        if len(addresses) == 0:
+            continue
+        addresses_csv = ', '.join(addresses)
+        group = "%s=%s" % (network, addresses_csv)
+        output.append(group)
+
+    return '; '.join(output)
+
+
+class HookableMixin(object):
+    """Mixin so classes can register and run hooks."""
+    _hooks_map = {}
+
+    @classmethod
+    def add_hook(cls, hook_type, hook_func):
+        if hook_type not in cls._hooks_map:
+            cls._hooks_map[hook_type] = []
+
+        cls._hooks_map[hook_type].append(hook_func)
+
+    @classmethod
+    def run_hooks(cls, hook_type, *args, **kwargs):
+        hook_funcs = cls._hooks_map.get(hook_type) or []
+        for hook_func in hook_funcs:
+            hook_func(*args, **kwargs)
+
+
+def safe_issubclass(*args):
+    """Like issubclass, but will just return False if not a class."""
+
+    try:
+        if issubclass(*args):
+            return True
+    except TypeError:
+        pass
+
+    return False
+
+
+def import_class(import_str):
+    """Returns a class from a string including module and class."""
+    mod_str, _sep, class_str = import_str.rpartition('.')
+    __import__(mod_str)
+    return getattr(sys.modules[mod_str], class_str)
+
+
+def _load_entry_point(ep_name, name=None):
+    """Try to load the entry point ep_name that matches name."""
+    for ep in pkg_resources.iter_entry_points(ep_name, name=name):
+        try:
+            return ep.load()
+        except (ImportError, pkg_resources.UnknownExtra, AttributeError):
+            continue
+
+_slugify_strip_re = re.compile(r'[^\w\s-]')
+_slugify_hyphenate_re = re.compile(r'[-\s]+')
+
+
+# http://code.activestate.com/recipes/
+#   577257-slugify-make-a-string-usable-in-a-url-or-filename/
+def slugify(value):
+    """
+    Normalizes string, converts to lowercase, removes non-alpha characters,
+    and converts spaces to hyphens.
+
+    From Django's "django/template/defaultfilters.py".
+    """
+    import unicodedata
+    if not isinstance(value, six.text_type):
+        value = six.text_type(value)
+    value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')
+    value = six.text_type(_slugify_strip_re.sub('', value).strip().lower())
+    return _slugify_hyphenate_re.sub('-', value)

awx/lib/site-packages/cinderclient/v1/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2012 OpenStack Foundation
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.v1.client import Client     # noqa

awx/lib/site-packages/cinderclient/v1/availability_zones.py

@@ -0,0 +1,42 @@
+# Copyright 2011-2013 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""Availability Zone interface (v1 extension)"""
+
+from cinderclient import base
+
+
+class AvailabilityZone(base.Resource):
+    NAME_ATTR = 'display_name'
+
+    def __repr__(self):
+        return "<AvailabilityZone: %s>" % self.zoneName
+
+
+class AvailabilityZoneManager(base.ManagerWithFind):
+    """Manage :class:`AvailabilityZone` resources."""
+    resource_class = AvailabilityZone
+
+    def list(self, detailed=False):
+        """Lists all availability zones.
+
+        :rtype: list of :class:`AvailabilityZone`
+        """
+        if detailed is True:
+            return self._list("/os-availability-zone/detail",
+                              "availabilityZoneInfo")
+        else:
+            return self._list("/os-availability-zone", "availabilityZoneInfo")

awx/lib/site-packages/cinderclient/v1/client.py

@@ -0,0 +1,119 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient import client
+from cinderclient.v1 import availability_zones
+from cinderclient.v1 import limits
+from cinderclient.v1 import qos_specs
+from cinderclient.v1 import quota_classes
+from cinderclient.v1 import quotas
+from cinderclient.v1 import services
+from cinderclient.v1 import volumes
+from cinderclient.v1 import volume_snapshots
+from cinderclient.v1 import volume_types
+from cinderclient.v1 import volume_encryption_types
+from cinderclient.v1 import volume_backups
+from cinderclient.v1 import volume_backups_restore
+from cinderclient.v1 import volume_transfers
+
+
+class Client(object):
+    """
+    Top-level object to access the OpenStack Volume API.
+
+    Create an instance with your creds::
+
+        >>> client = Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL)
+
+    Then call methods on its managers::
+
+        >>> client.volumes.list()
+        ...
+
+    """
+
+    def __init__(self, username=None, api_key=None, project_id=None,
+                 auth_url='', insecure=False, timeout=None, tenant_id=None,
+                 proxy_tenant_id=None, proxy_token=None, region_name=None,
+                 endpoint_type='publicURL', extensions=None,
+                 service_type='volume', service_name=None,
+                 volume_service_name=None, retries=None, http_log_debug=False,
+                 cacert=None, auth_system='keystone', auth_plugin=None,
+                 session=None, **kwargs):
+        # FIXME(comstud): Rename the api_key argument above when we
+        # know it's not being used as keyword argument
+        password = api_key
+        self.limits = limits.LimitsManager(self)
+
+        # extensions
+        self.volumes = volumes.VolumeManager(self)
+        self.volume_snapshots = volume_snapshots.SnapshotManager(self)
+        self.volume_types = volume_types.VolumeTypeManager(self)
+        self.volume_encryption_types = \
+            volume_encryption_types.VolumeEncryptionTypeManager(self)
+        self.qos_specs = qos_specs.QoSSpecsManager(self)
+        self.quota_classes = quota_classes.QuotaClassSetManager(self)
+        self.quotas = quotas.QuotaSetManager(self)
+        self.backups = volume_backups.VolumeBackupManager(self)
+        self.restores = volume_backups_restore.VolumeBackupRestoreManager(self)
+        self.transfers = volume_transfers.VolumeTransferManager(self)
+        self.services = services.ServiceManager(self)
+        self.availability_zones = \
+            availability_zones.AvailabilityZoneManager(self)
+
+        # Add in any extensions...
+        if extensions:
+            for extension in extensions:
+                if extension.manager_class:
+                    setattr(self, extension.name,
+                            extension.manager_class(self))
+
+        self.client = client._construct_http_client(
+            username=username,
+            password=password,
+            project_id=project_id,
+            auth_url=auth_url,
+            insecure=insecure,
+            timeout=timeout,
+            tenant_id=tenant_id,
+            proxy_tenant_id=tenant_id,
+            proxy_token=proxy_token,
+            region_name=region_name,
+            endpoint_type=endpoint_type,
+            service_type=service_type,
+            service_name=service_name,
+            volume_service_name=volume_service_name,
+            retries=retries,
+            http_log_debug=http_log_debug,
+            cacert=cacert,
+            auth_system=auth_system,
+            auth_plugin=auth_plugin,
+            session=session,
+            **kwargs)
+
+    def authenticate(self):
+        """
+        Authenticate against the server.
+
+        Normally this is called automatically when you first access the API,
+        but you can call this method to force authentication right now.
+
+        Returns on success; raises :exc:`exceptions.Unauthorized` if the
+        credentials are wrong.
+        """
+        self.client.authenticate()
+
+    def get_volume_api_version_from_endpoint(self):
+        return self.client.get_volume_api_version_from_endpoint()

awx/lib/site-packages/cinderclient/v1/contrib/list_extensions.py

@@ -0,0 +1,47 @@
+# Copyright (c) 2011 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient import base
+from cinderclient import utils
+
+
+class ListExtResource(base.Resource):
+    @property
+    def summary(self):
+        descr = self.description.strip()
+        if not descr:
+            return '??'
+        lines = descr.split("\n")
+        if len(lines) == 1:
+            return lines[0]
+        else:
+            return lines[0] + "..."
+
+
+class ListExtManager(base.Manager):
+    resource_class = ListExtResource
+
+    def show_all(self):
+        return self._list("/extensions", 'extensions')
+
+
+@utils.service_type('volume')
+def do_list_extensions(client, _args):
+    """
+    Lists all available os-api extensions.
+    """
+    extensions = client.list_extensions.show_all()
+    fields = ["Name", "Summary", "Alias", "Updated"]
+    utils.print_list(extensions, fields)

awx/lib/site-packages/cinderclient/v1/limits.py

@@ -0,0 +1,92 @@
+# Copyright 2011 OpenStack Foundation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from cinderclient import base
+
+
+class Limits(base.Resource):
+    """A collection of RateLimit and AbsoluteLimit objects."""
+
+    def __repr__(self):
+        return "<Limits>"
+
+    @property
+    def absolute(self):
+        for (name, value) in list(self._info['absolute'].items()):
+            yield AbsoluteLimit(name, value)
+
+    @property
+    def rate(self):
+        for group in self._info['rate']:
+            uri = group['uri']
+            regex = group['regex']
+            for rate in group['limit']:
+                yield RateLimit(rate['verb'], uri, regex, rate['value'],
+                                rate['remaining'], rate['unit'],
+                                rate['next-available'])
+
+
+class RateLimit(object):
+    """Data model that represents a flattened view of a single rate limit."""
+
+    def __init__(self, verb, uri, regex, value, remain,
+                 unit, next_available):
+        self.verb = verb
+        self.uri = uri
+        self.regex = regex
+        self.value = value
+        self.remain = remain
+        self.unit = unit
+        self.next_available = next_available
+
+    def __eq__(self, other):
+        return self.uri == other.uri \
+            and self.regex == other.regex \
+            and self.value == other.value \
+            and self.verb == other.verb \
+            and self.remain == other.remain \
+            and self.unit == other.unit \
+            and self.next_available == other.next_available
+
+    def __repr__(self):
+        return "<RateLimit: method=%s uri=%s>" % (self.verb, self.uri)
+
+
+class AbsoluteLimit(object):
+    """Data model that represents a single absolute limit."""
+
+    def __init__(self, name, value):
+        self.name = name
+        self.value = value
+
+    def __eq__(self, other):
+        return self.value == other.value and self.name == other.name
+
+    def __repr__(self):
+        return "<AbsoluteLimit: name=%s>" % (self.name)
+
+
+class LimitsManager(base.Manager):
+    """Manager object used to interact with limits resource."""
+
+    resource_class = Limits
+
+    def get(self):
+        """
+        Get a specific extension.
+
+        :rtype: :class:`Limits`
+        """
+        return self._get("/limits", "limits")

awx/lib/site-packages/cinderclient/v1/qos_specs.py

@@ -0,0 +1,149 @@
+# Copyright (c) 2013 eBay Inc.
+# Copyright (c) OpenStack LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+QoS Specs interface.
+"""
+
+from cinderclient import base
+
+
+class QoSSpecs(base.Resource):
+    """QoS specs entity represents quality-of-service parameters/requirements.
+
+    A QoS specs is a set of parameters or requirements for quality-of-service
+    purpose, which can be associated with volume types (for now).  In future,
+    QoS specs may be extended to be associated other entities, such as single
+    volume.
+    """
+    def __repr__(self):
+        return "<QoSSpecs: %s>" % self.name
+
+    def delete(self):
+        return self.manager.delete(self)
+
+
+class QoSSpecsManager(base.ManagerWithFind):
+    """
+    Manage :class:`QoSSpecs` resources.
+    """
+    resource_class = QoSSpecs
+
+    def list(self):
+        """Get a list of all qos specs.
+
+        :rtype: list of :class:`QoSSpecs`.
+        """
+        return self._list("/qos-specs", "qos_specs")
+
+    def get(self, qos_specs):
+        """Get a specific qos specs.
+
+        :param qos_specs: The ID of the :class:`QoSSpecs` to get.
+        :rtype: :class:`QoSSpecs`
+        """
+        return self._get("/qos-specs/%s" % base.getid(qos_specs), "qos_specs")
+
+    def delete(self, qos_specs, force=False):
+        """Delete a specific qos specs.
+
+        :param qos_specs: The ID of the :class:`QoSSpecs` to be removed.
+        :param force: Flag that indicates whether to delete target qos specs
+                      if it was in-use.
+        """
+        self._delete("/qos-specs/%s?force=%s" %
+                     (base.getid(qos_specs), force))
+
+    def create(self, name, specs):
+        """Create a qos specs.
+
+        :param name: Descriptive name of the qos specs, must be unique
+        :param specs: A dict of key/value pairs to be set
+        :rtype: :class:`QoSSpecs`
+        """
+
+        body = {
+            "qos_specs": {
+                "name": name,
+            }
+        }
+
+        body["qos_specs"].update(specs)
+        return self._create("/qos-specs", body, "qos_specs")
+
+    def set_keys(self, qos_specs, specs):
+        """Update a qos specs with new specifications.
+
+        :param qos_specs: The ID of qos specs
+        :param specs: A dict of key/value pairs to be set
+        :rtype: :class:`QoSSpecs`
+        """
+
+        body = {
+            "qos_specs": {}
+        }
+
+        body["qos_specs"].update(specs)
+        return self._update("/qos-specs/%s" % qos_specs, body)
+
+    def unset_keys(self, qos_specs, specs):
+        """Update a qos specs with new specifications.
+
+        :param qos_specs: The ID of qos specs
+        :param specs: A list of key to be unset
+        :rtype: :class:`QoSSpecs`
+        """
+
+        body = {'keys': specs}
+
+        return self._update("/qos-specs/%s/delete_keys" % qos_specs,
+                            body)
+
+    def get_associations(self, qos_specs):
+        """Get associated entities of a qos specs.
+
+        :param qos_specs: The id of the :class: `QoSSpecs`
+        :return: a list of entities that associated with specific qos specs.
+        """
+        return self._list("/qos-specs/%s/associations" % base.getid(qos_specs),
+                          "qos_associations")
+
+    def associate(self, qos_specs, vol_type_id):
+        """Associate a volume type with specific qos specs.
+
+        :param qos_specs: The qos specs to be associated with
+        :param vol_type_id: The volume type id to be associated with
+        """
+        self.api.client.get("/qos-specs/%s/associate?vol_type_id=%s" %
+                            (base.getid(qos_specs), vol_type_id))
+
+    def disassociate(self, qos_specs, vol_type_id):
+        """Disassociate qos specs from volume type.
+
+        :param qos_specs: The qos specs to be associated with
+        :param vol_type_id: The volume type id to be associated with
+        """
+        self.api.client.get("/qos-specs/%s/disassociate?vol_type_id=%s" %
+                            (base.getid(qos_specs), vol_type_id))
+
+    def disassociate_all(self, qos_specs):
+        """Disassociate all entities from specific qos specs.
+
+        :param qos_specs: The qos specs to be associated with
+        """
+        self.api.client.get("/qos-specs/%s/disassociate_all" %
+                            base.getid(qos_specs))

awx/lib/site-packages/cinderclient/v1/quota_classes.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2012 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient import base
+
+
+class QuotaClassSet(base.Resource):
+
+    @property
+    def id(self):
+        """QuotaClassSet does not have a 'id' attribute but base.Resource
+        needs it to self-refresh and QuotaSet is indexed by class_name.
+        """
+        return self.class_name
+
+    def update(self, *args, **kwargs):
+        self.manager.update(self.class_name, *args, **kwargs)
+
+
+class QuotaClassSetManager(base.Manager):
+    resource_class = QuotaClassSet
+
+    def get(self, class_name):
+        return self._get("/os-quota-class-sets/%s" % (class_name),
+                         "quota_class_set")
+
+    def update(self, class_name, **updates):
+        body = {'quota_class_set': {'class_name': class_name}}
+
+        for update in updates:
+            body['quota_class_set'][update] = updates[update]
+
+        self._update('/os-quota-class-sets/%s' % (class_name), body)

awx/lib/site-packages/cinderclient/v1/quotas.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2011 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient import base
+
+
+class QuotaSet(base.Resource):
+
+    @property
+    def id(self):
+        """QuotaSet does not have a 'id' attribute but base. Resource needs it
+        to self-refresh and QuotaSet is indexed by tenant_id.
+        """
+        return self.tenant_id
+
+    def update(self, *args, **kwargs):
+        return self.manager.update(self.tenant_id, *args, **kwargs)
+
+
+class QuotaSetManager(base.Manager):
+    resource_class = QuotaSet
+
+    def get(self, tenant_id, usage=False):
+        if hasattr(tenant_id, 'tenant_id'):
+            tenant_id = tenant_id.tenant_id
+        return self._get("/os-quota-sets/%s?usage=%s" % (tenant_id, usage),
+                         "quota_set")
+
+    def update(self, tenant_id, **updates):
+        body = {'quota_set': {'tenant_id': tenant_id}}
+
+        for update in updates:
+            body['quota_set'][update] = updates[update]
+
+        result = self._update('/os-quota-sets/%s' % (tenant_id), body)
+        return self.resource_class(self, result['quota_set'], loaded=True)
+
+    def defaults(self, tenant_id):
+        return self._get('/os-quota-sets/%s/defaults' % tenant_id,
+                         'quota_set')
+
+    def delete(self, tenant_id):
+        if hasattr(tenant_id, 'tenant_id'):
+            tenant_id = tenant_id.tenant_id
+        return self._delete("/os-quota-sets/%s" % tenant_id)

awx/lib/site-packages/cinderclient/v1/services.py

@@ -0,0 +1,64 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+service interface
+"""
+from cinderclient import base
+
+
+class Service(base.Resource):
+
+    def __repr__(self):
+        return "<Service: %s>" % self.service
+
+
+class ServiceManager(base.ManagerWithFind):
+    resource_class = Service
+
+    def list(self, host=None, binary=None):
+        """
+        Describes service list for host.
+
+        :param host: destination host name.
+        :param binary: service binary.
+        """
+        url = "/os-services"
+        filters = []
+        if host:
+            filters.append("host=%s" % host)
+        if binary:
+            filters.append("binary=%s" % binary)
+        if filters:
+            url = "%s?%s" % (url, "&".join(filters))
+        return self._list(url, "services")
+
+    def enable(self, host, binary):
+        """Enable the service specified by hostname and binary."""
+        body = {"host": host, "binary": binary}
+        result = self._update("/os-services/enable", body)
+        return self.resource_class(self, result)
+
+    def disable(self, host, binary):
+        """Disable the service specified by hostname and binary."""
+        body = {"host": host, "binary": binary}
+        result = self._update("/os-services/disable", body)
+        return self.resource_class(self, result)
+
+    def disable_log_reason(self, host, binary, reason):
+        """Disable the service with reason."""
+        body = {"host": host, "binary": binary, "disabled_reason": reason}
+        result = self._update("/os-services/disable-log-reason", body)
+        return self.resource_class(self, result)

awx/lib/site-packages/cinderclient/v1/volume_backups.py

@@ -0,0 +1,76 @@
+# Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Volume Backups interface (1.1 extension).
+"""
+
+from cinderclient import base
+
+
+class VolumeBackup(base.Resource):
+    """A volume backup is a block level backup of a volume."""
+    def __repr__(self):
+        return "<VolumeBackup: %s>" % self.id
+
+    def delete(self):
+        """Delete this volume backup."""
+        return self.manager.delete(self)
+
+
+class VolumeBackupManager(base.ManagerWithFind):
+    """Manage :class:`VolumeBackup` resources."""
+    resource_class = VolumeBackup
+
+    def create(self, volume_id, container=None,
+               name=None, description=None):
+        """Creates a volume backup.
+
+        :param volume_id: The ID of the volume to backup.
+        :param container: The name of the backup service container.
+        :param name: The name of the backup.
+        :param description: The description of the backup.
+        :rtype: :class:`VolumeBackup`
+        """
+        body = {'backup': {'volume_id': volume_id,
+                           'container': container,
+                           'name': name,
+                           'description': description}}
+        return self._create('/backups', body, 'backup')
+
+    def get(self, backup_id):
+        """Show details of a volume backup.
+
+        :param backup_id: The ID of the backup to display.
+        :rtype: :class:`VolumeBackup`
+        """
+        return self._get("/backups/%s" % backup_id, "backup")
+
+    def list(self, detailed=True):
+        """Get a list of all volume backups.
+
+        :rtype: list of :class:`VolumeBackup`
+        """
+        if detailed is True:
+            return self._list("/backups/detail", "backups")
+        else:
+            return self._list("/backups", "backups")
+
+    def delete(self, backup):
+        """Delete a volume backup.
+
+        :param backup: The :class:`VolumeBackup` to delete.
+        """
+        self._delete("/backups/%s" % base.getid(backup))

awx/lib/site-packages/cinderclient/v1/volume_backups_restore.py

@@ -0,0 +1,43 @@
+# Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""Volume Backups Restore interface (1.1 extension).
+
+This is part of the Volume Backups interface.
+"""
+
+from cinderclient import base
+
+
+class VolumeBackupsRestore(base.Resource):
+    """A Volume Backups Restore represents a restore operation."""
+    def __repr__(self):
+        return "<VolumeBackupsRestore: %s>" % self.volume_id
+
+
+class VolumeBackupRestoreManager(base.Manager):
+    """Manage :class:`VolumeBackupsRestore` resources."""
+    resource_class = VolumeBackupsRestore
+
+    def restore(self, backup_id, volume_id=None):
+        """Restore a backup to a volume.
+
+        :param backup_id: The ID of the backup to restore.
+        :param volume_id: The ID of the volume to restore the backup to.
+        :rtype: :class:`Restore`
+        """
+        body = {'restore': {'volume_id': volume_id}}
+        return self._create("/backups/%s/restore" % backup_id,
+                            body, "restore")

awx/lib/site-packages/cinderclient/v1/volume_encryption_types.py

@@ -0,0 +1,97 @@
+# Copyright (c) 2013 The Johns Hopkins University/Applied Physics Laboratory
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+
+"""
+Volume Encryption Type interface
+"""
+
+from cinderclient import base
+
+
+class VolumeEncryptionType(base.Resource):
+    """
+    A Volume Encryption Type is a collection of settings used to conduct
+    encryption for a specific volume type.
+    """
+    def __repr__(self):
+        return "<VolumeEncryptionType: %s>" % self.name
+
+
+class VolumeEncryptionTypeManager(base.ManagerWithFind):
+    """
+    Manage :class: `VolumeEncryptionType` resources.
+    """
+    resource_class = VolumeEncryptionType
+
+    def list(self, search_opts=None):
+        """
+        List all volume encryption types.
+
+        :param volume_types: a list of volume types
+        :return: a list of :class: VolumeEncryptionType instances
+        """
+        # Since the encryption type is a volume type extension, we cannot get
+        # all encryption types without going through all volume types.
+        volume_types = self.api.volume_types.list()
+        encryption_types = []
+        for volume_type in volume_types:
+            encryption_type = self._get("/types/%s/encryption"
+                                        % base.getid(volume_type))
+            if hasattr(encryption_type, 'volume_type_id'):
+                encryption_types.append(encryption_type)
+        return encryption_types
+
+    def get(self, volume_type):
+        """
+        Get the volume encryption type for the specified volume type.
+
+        :param volume_type: the volume type to query
+        :return: an instance of :class: VolumeEncryptionType
+        """
+        return self._get("/types/%s/encryption" % base.getid(volume_type))
+
+    def create(self, volume_type, specs):
+        """
+        Creates encryption type for a volume type. Default: admin only.
+
+        :param volume_type: the volume type on which to add an encryption type
+        :param specs: the encryption type specifications to add
+        :return: an instance of :class: VolumeEncryptionType
+        """
+        body = {'encryption': specs}
+        return self._create("/types/%s/encryption" % base.getid(volume_type),
+                            body, "encryption")
+
+    def update(self, volume_type, specs):
+        """
+        Update the encryption type information for the specified volume type.
+
+        :param volume_type: the volume type whose encryption type information
+                            must be updated
+        :param specs: the encryption type specifications to update
+        :return: an instance of :class: VolumeEncryptionType
+        """
+        raise NotImplementedError()
+
+    def delete(self, volume_type):
+        """
+        Delete the encryption type information for the specified volume type.
+
+        :param volume_type: the volume type whose encryption type information
+                            must be deleted
+        """
+        return self._delete("/types/%s/encryption/provider" %
+                            base.getid(volume_type))

awx/lib/site-packages/cinderclient/v1/volume_snapshots.py

@@ -0,0 +1,202 @@
+# Copyright 2011 Denali Systems, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Volume snapshot interface (1.1 extension).
+"""
+
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+
+from cinderclient import base
+import six
+
+
+class Snapshot(base.Resource):
+    """
+    A Snapshot is a point-in-time snapshot of an openstack volume.
+    """
+    def __repr__(self):
+        return "<Snapshot: %s>" % self.id
+
+    def delete(self):
+        """
+        Delete this snapshot.
+        """
+        self.manager.delete(self)
+
+    def update(self, **kwargs):
+        """
+        Update the display_name or display_description for this snapshot.
+        """
+        self.manager.update(self, **kwargs)
+
+    @property
+    def progress(self):
+        return self._info.get('os-extended-snapshot-attributes:progress')
+
+    @property
+    def project_id(self):
+        return self._info.get('os-extended-snapshot-attributes:project_id')
+
+    def reset_state(self, state):
+        """Update the snapshot with the privided state."""
+        self.manager.reset_state(self, state)
+
+    def set_metadata(self, metadata):
+        """Set metadata of this snapshot."""
+        return self.manager.set_metadata(self, metadata)
+
+    def delete_metadata(self, keys):
+        """Delete metadata of this snapshot."""
+        return self.manager.delete_metadata(self, keys)
+
+    def update_all_metadata(self, metadata):
+        """Update_all metadata of this snapshot."""
+        return self.manager.update_all_metadata(self, metadata)
+
+
+class SnapshotManager(base.ManagerWithFind):
+    """
+    Manage :class:`Snapshot` resources.
+    """
+    resource_class = Snapshot
+
+    def create(self, volume_id, force=False,
+               display_name=None, display_description=None):
+
+        """
+        Create a snapshot of the given volume.
+
+        :param volume_id: The ID of the volume to snapshot.
+        :param force: If force is True, create a snapshot even if the volume is
+        attached to an instance. Default is False.
+        :param display_name: Name of the snapshot
+        :param display_description: Description of the snapshot
+        :rtype: :class:`Snapshot`
+        """
+        body = {'snapshot': {'volume_id': volume_id,
+                             'force': force,
+                             'display_name': display_name,
+                             'display_description': display_description}}
+        return self._create('/snapshots', body, 'snapshot')
+
+    def get(self, snapshot_id):
+        """
+        Get a snapshot.
+
+        :param snapshot_id: The ID of the snapshot to get.
+        :rtype: :class:`Snapshot`
+        """
+        return self._get("/snapshots/%s" % snapshot_id, "snapshot")
+
+    def list(self, detailed=True, search_opts=None):
+        """
+        Get a list of all snapshots.
+
+        :rtype: list of :class:`Snapshot`
+        """
+
+        if search_opts is None:
+            search_opts = {}
+
+        qparams = {}
+
+        for opt, val in six.iteritems(search_opts):
+            if val:
+                qparams[opt] = val
+
+        # Transform the dict to a sequence of two-element tuples in fixed
+        # order, then the encoded string will be consistent in Python 2&3.
+        if qparams:
+            new_qparams = sorted(qparams.items(), key=lambda x: x[0])
+            query_string = "?%s" % urlencode(new_qparams)
+        else:
+            query_string = ""
+
+        detail = ""
+        if detailed:
+            detail = "/detail"
+
+        return self._list("/snapshots%s%s" % (detail, query_string),
+                          "snapshots")
+
+    def delete(self, snapshot):
+        """
+        Delete a snapshot.
+
+        :param snapshot: The :class:`Snapshot` to delete.
+        """
+        self._delete("/snapshots/%s" % base.getid(snapshot))
+
+    def update(self, snapshot, **kwargs):
+        """
+        Update the display_name or display_description for a snapshot.
+
+        :param snapshot: The :class:`Snapshot` to update.
+        """
+        if not kwargs:
+            return
+
+        body = {"snapshot": kwargs}
+
+        self._update("/snapshots/%s" % base.getid(snapshot), body)
+
+    def reset_state(self, snapshot, state):
+        """Update the specified volume with the provided state."""
+        return self._action('os-reset_status', snapshot, {'status': state})
+
+    def _action(self, action, snapshot, info=None, **kwargs):
+        """Perform a snapshot action."""
+        body = {action: info}
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/snapshots/%s/action' % base.getid(snapshot)
+        return self.api.client.post(url, body=body)
+
+    def update_snapshot_status(self, snapshot, update_dict):
+        return self._action('os-update_snapshot_status',
+                            base.getid(snapshot), update_dict)
+
+    def set_metadata(self, snapshot, metadata):
+        """Update/Set a snapshots metadata.
+
+        :param snapshot: The :class:`Snapshot`.
+        :param metadata: A list of keys to be set.
+        """
+        body = {'metadata': metadata}
+        return self._create("/snapshots/%s/metadata" % base.getid(snapshot),
+                            body, "metadata")
+
+    def delete_metadata(self, snapshot, keys):
+        """Delete specified keys from snapshot metadata.
+
+        :param snapshot: The :class:`Snapshot`.
+        :param keys: A list of keys to be removed.
+        """
+        snapshot_id = base.getid(snapshot)
+        for k in keys:
+            self._delete("/snapshots/%s/metadata/%s" % (snapshot_id, k))
+
+    def update_all_metadata(self, snapshot, metadata):
+        """Update_all snapshot metadata.
+
+        :param snapshot: The :class:`Snapshot`.
+        :param metadata: A list of keys to be updated.
+        """
+        body = {'metadata': metadata}
+        return self._update("/snapshots/%s/metadata" % base.getid(snapshot),
+                            body)

awx/lib/site-packages/cinderclient/v1/volume_transfers.py

@@ -0,0 +1,82 @@
+# Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Volume transfer interface (1.1 extension).
+"""
+
+from cinderclient import base
+
+
+class VolumeTransfer(base.Resource):
+    """Transfer a volume from one tenant to another"""
+    def __repr__(self):
+        return "<VolumeTransfer: %s>" % self.id
+
+    def delete(self):
+        """Delete this volume transfer."""
+        return self.manager.delete(self)
+
+
+class VolumeTransferManager(base.ManagerWithFind):
+    """Manage :class:`VolumeTransfer` resources."""
+    resource_class = VolumeTransfer
+
+    def create(self, volume_id, name=None):
+        """Creates a volume transfer.
+
+        :param volume_id: The ID of the volume to transfer.
+        :param name: The name of the transfer.
+        :rtype: :class:`VolumeTransfer`
+        """
+        body = {'transfer': {'volume_id': volume_id,
+                             'name': name}}
+        return self._create('/os-volume-transfer', body, 'transfer')
+
+    def accept(self, transfer_id, auth_key):
+        """Accept a volume transfer.
+
+        :param transfer_id: The ID of the transfer to accept.
+        :param auth_key: The auth_key of the transfer.
+        :rtype: :class:`VolumeTransfer`
+        """
+        body = {'accept': {'auth_key': auth_key}}
+        return self._create('/os-volume-transfer/%s/accept' % transfer_id,
+                            body, 'transfer')
+
+    def get(self, transfer_id):
+        """Show details of a volume transfer.
+
+        :param transfer_id: The ID of the volume transfer to display.
+        :rtype: :class:`VolumeTransfer`
+        """
+        return self._get("/os-volume-transfer/%s" % transfer_id, "transfer")
+
+    def list(self, detailed=True, search_opts=None):
+        """Get a list of all volume transfer.
+
+        :rtype: list of :class:`VolumeTransfer`
+        """
+        if detailed is True:
+            return self._list("/os-volume-transfer/detail", "transfers")
+        else:
+            return self._list("/os-volume-transfer", "transfers")
+
+    def delete(self, transfer_id):
+        """Delete a volume transfer.
+
+        :param transfer_id: The :class:`VolumeTransfer` to delete.
+        """
+        self._delete("/os-volume-transfer/%s" % base.getid(transfer_id))

awx/lib/site-packages/cinderclient/v1/volume_types.py

@@ -0,0 +1,122 @@
+# Copyright (c) 2011 Rackspace US, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+Volume Type interface.
+"""
+
+from cinderclient import base
+
+
+class VolumeType(base.Resource):
+    """
+    A Volume Type is the type of volume to be created
+    """
+    def __repr__(self):
+        return "<VolumeType: %s>" % self.name
+
+    def get_keys(self):
+        """
+        Get extra specs from a volume type.
+
+        :param vol_type: The :class:`VolumeType` to get extra specs from
+        """
+        _resp, body = self.manager.api.client.get(
+            "/types/%s/extra_specs" %
+            base.getid(self))
+        return body["extra_specs"]
+
+    def set_keys(self, metadata):
+        """
+        Set extra specs on a volume type.
+
+        :param type : The :class:`VolumeType` to set extra spec on
+        :param metadata: A dict of key/value pairs to be set
+        """
+        body = {'extra_specs': metadata}
+        return self.manager._create(
+            "/types/%s/extra_specs" % base.getid(self),
+            body,
+            "extra_specs",
+            return_raw=True)
+
+    def unset_keys(self, keys):
+        """
+        Unset extra specs on a volume type.
+
+        :param type_id: The :class:`VolumeType` to unset extra spec on
+        :param keys: A list of keys to be unset
+        """
+
+        # NOTE(jdg): This wasn't actually doing all of the keys before
+        # the return in the loop resulted in ony ONE key being unset.
+        # since on success the return was NONE, we'll only interrupt the loop
+        # and return if there's an error
+        resp = None
+        for k in keys:
+            resp = self.manager._delete(
+                "/types/%s/extra_specs/%s" % (
+                base.getid(self), k))
+            if resp is not None:
+                return resp
+
+
+class VolumeTypeManager(base.ManagerWithFind):
+    """
+    Manage :class:`VolumeType` resources.
+    """
+    resource_class = VolumeType
+
+    def list(self, search_opts=None):
+        """
+        Get a list of all volume types.
+
+        :rtype: list of :class:`VolumeType`.
+        """
+        return self._list("/types", "volume_types")
+
+    def get(self, volume_type):
+        """
+        Get a specific volume type.
+
+        :param volume_type: The ID of the :class:`VolumeType` to get.
+        :rtype: :class:`VolumeType`
+        """
+        return self._get("/types/%s" % base.getid(volume_type), "volume_type")
+
+    def delete(self, volume_type):
+        """
+        Delete a specific volume_type.
+
+        :param volume_type: The name or ID of the :class:`VolumeType` to get.
+        """
+        self._delete("/types/%s" % base.getid(volume_type))
+
+    def create(self, name):
+        """
+        Creates a volume type.
+
+        :param name: Descriptive name of the volume type
+        :rtype: :class:`VolumeType`
+        """
+
+        body = {
+            "volume_type": {
+                "name": name,
+            }
+        }
+
+        return self._create("/types", body, "volume_type")

awx/lib/site-packages/cinderclient/v1/volumes.py

@@ -0,0 +1,432 @@
+# Copyright 2011 Denali Systems, Inc.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Volume interface (1.1 extension).
+"""
+
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+import six
+from cinderclient import base
+
+
+class Volume(base.Resource):
+    """A volume is an extra block level storage to the OpenStack instances."""
+    def __repr__(self):
+        return "<Volume: %s>" % self.id
+
+    def delete(self):
+        """Delete this volume."""
+        self.manager.delete(self)
+
+    def update(self, **kwargs):
+        """Update the display_name or display_description for this volume."""
+        self.manager.update(self, **kwargs)
+
+    def attach(self, instance_uuid, mountpoint, mode='rw'):
+        """Set attachment metadata.
+
+        :param instance_uuid: uuid of the attaching instance.
+        :param mountpoint: mountpoint on the attaching instance.
+        :param mode: the access mode
+        """
+        return self.manager.attach(self, instance_uuid, mountpoint, mode)
+
+    def detach(self):
+        """Clear attachment metadata."""
+        return self.manager.detach(self)
+
+    def reserve(self, volume):
+        """Reserve this volume."""
+        return self.manager.reserve(self)
+
+    def unreserve(self, volume):
+        """Unreserve this volume."""
+        return self.manager.unreserve(self)
+
+    def begin_detaching(self, volume):
+        """Begin detaching volume."""
+        return self.manager.begin_detaching(self)
+
+    def roll_detaching(self, volume):
+        """Roll detaching volume."""
+        return self.manager.roll_detaching(self)
+
+    def initialize_connection(self, volume, connector):
+        """Initialize a volume connection.
+
+        :param connector: connector dict from nova.
+        """
+        return self.manager.initialize_connection(self, connector)
+
+    def terminate_connection(self, volume, connector):
+        """Terminate a volume connection.
+
+        :param connector: connector dict from nova.
+        """
+        return self.manager.terminate_connection(self, connector)
+
+    def set_metadata(self, volume, metadata):
+        """Set or Append metadata to a volume.
+
+        :param volume : The :class: `Volume` to set metadata on
+        :param metadata: A dict of key/value pairs to set
+        """
+        return self.manager.set_metadata(self, metadata)
+
+    def upload_to_image(self, force, image_name, container_format,
+                        disk_format):
+        """Upload a volume to image service as an image."""
+        return self.manager.upload_to_image(self, force, image_name,
+                                            container_format, disk_format)
+
+    def force_delete(self):
+        """Delete the specified volume ignoring its current state.
+
+        :param volume: The UUID of the volume to force-delete.
+        """
+        self.manager.force_delete(self)
+
+    def reset_state(self, state):
+        """Update the volume with the provided state."""
+        self.manager.reset_state(self, state)
+
+    def extend(self, volume, new_size):
+        """Extend the size of the specified volume.
+
+        :param volume: The UUID of the volume to extend.
+        :param new_size: The desired size to extend volume to.
+        """
+        self.manager.extend(self, new_size)
+
+    def migrate_volume(self, host, force_host_copy):
+        """Migrate the volume to a new host."""
+        self.manager.migrate_volume(self, host, force_host_copy)
+
+#    def migrate_volume_completion(self, old_volume, new_volume, error):
+#        """Complete the migration of the volume."""
+#        self.manager.migrate_volume_completion(self, old_volume,
+#                                               new_volume, error)
+
+    def update_all_metadata(self, metadata):
+        """Update all metadata of this volume."""
+        return self.manager.update_all_metadata(self, metadata)
+
+    def update_readonly_flag(self, volume, read_only):
+        """Update the read-only access mode flag of the specified volume.
+
+        :param volume: The UUID of the volume to update.
+        :param read_only: The value to indicate whether to update volume to
+            read-only access mode.
+        """
+        self.manager.update_readonly_flag(self, read_only)
+
+
+class VolumeManager(base.ManagerWithFind):
+    """
+    Manage :class:`Volume` resources.
+    """
+    resource_class = Volume
+
+    def create(self, size, snapshot_id=None, source_volid=None,
+               display_name=None, display_description=None,
+               volume_type=None, user_id=None,
+               project_id=None, availability_zone=None,
+               metadata=None, imageRef=None):
+        """
+        Creates a volume.
+
+        :param size: Size of volume in GB
+        :param snapshot_id: ID of the snapshot
+        :param display_name: Name of the volume
+        :param display_description: Description of the volume
+        :param volume_type: Type of volume
+        :param user_id: User id derived from context
+        :param project_id: Project id derived from context
+        :param availability_zone: Availability Zone to use
+        :param metadata: Optional metadata to set on volume creation
+        :param imageRef: reference to an image stored in glance
+        :param source_volid: ID of source volume to clone from
+        :rtype: :class:`Volume`
+        """
+
+        if metadata is None:
+            volume_metadata = {}
+        else:
+            volume_metadata = metadata
+
+        body = {'volume': {'size': size,
+                           'snapshot_id': snapshot_id,
+                           'display_name': display_name,
+                           'display_description': display_description,
+                           'volume_type': volume_type,
+                           'user_id': user_id,
+                           'project_id': project_id,
+                           'availability_zone': availability_zone,
+                           'status': "creating",
+                           'attach_status': "detached",
+                           'metadata': volume_metadata,
+                           'imageRef': imageRef,
+                           'source_volid': source_volid,
+                           }}
+        return self._create('/volumes', body, 'volume')
+
+    def get(self, volume_id):
+        """
+        Get a volume.
+
+        :param volume_id: The ID of the volume to get.
+        :rtype: :class:`Volume`
+        """
+        return self._get("/volumes/%s" % volume_id, "volume")
+
+    def list(self, detailed=True, search_opts=None):
+        """
+        Get a list of all volumes.
+
+        :rtype: list of :class:`Volume`
+        """
+        if search_opts is None:
+            search_opts = {}
+
+        qparams = {}
+
+        for opt, val in six.iteritems(search_opts):
+            if val:
+                qparams[opt] = val
+
+        query_string = "?%s" % urlencode(qparams) if qparams else ""
+
+        detail = ""
+        if detailed:
+            detail = "/detail"
+
+        return self._list("/volumes%s%s" % (detail, query_string),
+                          "volumes")
+
+    def delete(self, volume):
+        """
+        Delete a volume.
+
+        :param volume: The :class:`Volume` to delete.
+        """
+        self._delete("/volumes/%s" % base.getid(volume))
+
+    def update(self, volume, **kwargs):
+        """
+        Update the display_name or display_description for a volume.
+
+        :param volume: The :class:`Volume` to update.
+        """
+        if not kwargs:
+            return
+
+        body = {"volume": kwargs}
+
+        self._update("/volumes/%s" % base.getid(volume), body)
+
+    def _action(self, action, volume, info=None, **kwargs):
+        """
+        Perform a volume "action."
+        """
+        body = {action: info}
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/volumes/%s/action' % base.getid(volume)
+        return self.api.client.post(url, body=body)
+
+    def attach(self, volume, instance_uuid, mountpoint, mode='rw'):
+        """
+        Set attachment metadata.
+
+        :param volume: The :class:`Volume` (or its ID)
+                       you would like to attach.
+        :param instance_uuid: uuid of the attaching instance.
+        :param mountpoint: mountpoint on the attaching instance.
+        :param mode: the access mode.
+        """
+        return self._action('os-attach',
+                            volume,
+                            {'instance_uuid': instance_uuid,
+                             'mountpoint': mountpoint,
+                             'mode': mode})
+
+    def detach(self, volume):
+        """
+        Clear attachment metadata.
+
+        :param volume: The :class:`Volume` (or its ID)
+                       you would like to detach.
+        """
+        return self._action('os-detach', volume)
+
+    def reserve(self, volume):
+        """
+        Reserve this volume.
+
+        :param volume: The :class:`Volume` (or its ID)
+                       you would like to reserve.
+        """
+        return self._action('os-reserve', volume)
+
+    def unreserve(self, volume):
+        """
+        Unreserve this volume.
+
+        :param volume: The :class:`Volume` (or its ID)
+                       you would like to unreserve.
+        """
+        return self._action('os-unreserve', volume)
+
+    def begin_detaching(self, volume):
+        """
+        Begin detaching this volume.
+
+        :param volume: The :class:`Volume` (or its ID)
+                       you would like to detach.
+        """
+        return self._action('os-begin_detaching', volume)
+
+    def roll_detaching(self, volume):
+        """
+        Roll detaching this volume.
+
+        :param volume: The :class:`Volume` (or its ID)
+                       you would like to roll detaching.
+        """
+        return self._action('os-roll_detaching', volume)
+
+    def initialize_connection(self, volume, connector):
+        """
+        Initialize a volume connection.
+
+        :param volume: The :class:`Volume` (or its ID).
+        :param connector: connector dict from nova.
+        """
+        return self._action('os-initialize_connection', volume,
+                            {'connector': connector})[1]['connection_info']
+
+    def terminate_connection(self, volume, connector):
+        """
+        Terminate a volume connection.
+
+        :param volume: The :class:`Volume` (or its ID).
+        :param connector: connector dict from nova.
+        """
+        self._action('os-terminate_connection', volume,
+                     {'connector': connector})
+
+    def set_metadata(self, volume, metadata):
+        """
+        Update/Set a volumes metadata.
+
+        :param volume: The :class:`Volume`.
+        :param metadata: A list of keys to be set.
+        """
+        body = {'metadata': metadata}
+        return self._create("/volumes/%s/metadata" % base.getid(volume),
+                            body, "metadata")
+
+    def delete_metadata(self, volume, keys):
+        """
+        Delete specified keys from volumes metadata.
+
+        :param volume: The :class:`Volume`.
+        :param keys: A list of keys to be removed.
+        """
+        for k in keys:
+            self._delete("/volumes/%s/metadata/%s" % (base.getid(volume), k))
+
+    def upload_to_image(self, volume, force, image_name, container_format,
+                        disk_format):
+        """
+        Upload volume to image service as image.
+
+        :param volume: The :class:`Volume` to upload.
+        """
+        return self._action('os-volume_upload_image',
+                            volume,
+                            {'force': force,
+                            'image_name': image_name,
+                            'container_format': container_format,
+                            'disk_format': disk_format})
+
+    def force_delete(self, volume):
+        return self._action('os-force_delete', base.getid(volume))
+
+    def reset_state(self, volume, state):
+        """Update the provided volume with the provided state."""
+        return self._action('os-reset_status', volume, {'status': state})
+
+    def extend(self, volume, new_size):
+        return self._action('os-extend',
+                            base.getid(volume),
+                            {'new_size': new_size})
+
+    def get_encryption_metadata(self, volume_id):
+        """
+        Retrieve the encryption metadata from the desired volume.
+
+        :param volume_id: the id of the volume to query
+        :return: a dictionary of volume encryption metadata
+        """
+        return self._get("/volumes/%s/encryption" % volume_id)._info
+
+    def migrate_volume(self, volume, host, force_host_copy):
+        """Migrate volume to new host.
+
+        :param volume: The :class:`Volume` to migrate
+        :param host: The destination host
+        :param force_host_copy: Skip driver optimizations
+        """
+
+        return self._action('os-migrate_volume',
+                            volume,
+                            {'host': host, 'force_host_copy': force_host_copy})
+
+    def migrate_volume_completion(self, old_volume, new_volume, error):
+        """Complete the migration from the old volume to the temp new one.
+
+        :param old_volume: The original :class:`Volume` in the migration
+        :param new_volume: The new temporary :class:`Volume` in the migration
+        :param error: Inform of an error to cause migration cleanup
+        """
+
+        new_volume_id = base.getid(new_volume)
+        return self._action('os-migrate_volume_completion',
+                            old_volume,
+                            {'new_volume': new_volume_id, 'error': error})[1]
+
+    def update_all_metadata(self, volume, metadata):
+        """Update all metadata of a volume.
+
+        :param volume: The :class:`Volume`.
+        :param metadata: A list of keys to be updated.
+        """
+        body = {'metadata': metadata}
+        return self._update("/volumes/%s/metadata" % base.getid(volume),
+                            body)
+
+    def update_readonly_flag(self, volume, flag):
+        return self._action('os-update_readonly_flag',
+                            base.getid(volume),
+                            {'readonly': flag})
+
+    def set_bootable(self, volume, flag):
+        return self._action('os-set_bootable',
+                            base.getid(volume),
+                            {'bootable': flag})

awx/lib/site-packages/cinderclient/v2/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2013 OpenStack Foundation
+#
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient.v2.client import Client    # noqa

awx/lib/site-packages/cinderclient/v2/availability_zones.py

@@ -0,0 +1,42 @@
+# Copyright 2011-2013 OpenStack Foundation
+# Copyright 2013 IBM Corp.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""Availability Zone interface (v2 extension)"""
+
+from cinderclient import base
+
+
+class AvailabilityZone(base.Resource):
+    NAME_ATTR = 'display_name'
+
+    def __repr__(self):
+        return "<AvailabilityZone: %s>" % self.zoneName
+
+
+class AvailabilityZoneManager(base.ManagerWithFind):
+    """Manage :class:`AvailabilityZone` resources."""
+    resource_class = AvailabilityZone
+
+    def list(self, detailed=False):
+        """Lists all availability zones.
+
+        :rtype: list of :class:`AvailabilityZone`
+        """
+        if detailed is True:
+            return self._list("/os-availability-zone/detail",
+                              "availabilityZoneInfo")
+        else:
+            return self._list("/os-availability-zone", "availabilityZoneInfo")

awx/lib/site-packages/cinderclient/v2/cgsnapshots.py

@@ -0,0 +1,124 @@
+# Copyright (C) 2012 - 2014 EMC Corporation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""cgsnapshot interface (v2 extension)."""
+
+import six
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+
+from cinderclient import base
+
+
+class Cgsnapshot(base.Resource):
+    """A cgsnapshot is snapshot of a consistency group."""
+    def __repr__(self):
+        return "<cgsnapshot: %s>" % self.id
+
+    def delete(self):
+        """Delete this cgsnapshot."""
+        self.manager.delete(self)
+
+    def update(self, **kwargs):
+        """Update the name or description for this cgsnapshot."""
+        self.manager.update(self, **kwargs)
+
+
+class CgsnapshotManager(base.ManagerWithFind):
+    """Manage :class:`Cgsnapshot` resources."""
+    resource_class = Cgsnapshot
+
+    def create(self, consistencygroup_id, name=None, description=None,
+               user_id=None,
+               project_id=None):
+        """Creates a cgsnapshot.
+
+        :param consistencygroup: Name or uuid of a consistencygroup
+        :param name: Name of the cgsnapshot
+        :param description: Description of the cgsnapshot
+        :param user_id: User id derived from context
+        :param project_id: Project id derived from context
+        :rtype: :class:`Cgsnapshot`
+       """
+
+        body = {'cgsnapshot': {'consistencygroup_id': consistencygroup_id,
+                               'name': name,
+                               'description': description,
+                               'user_id': user_id,
+                               'project_id': project_id,
+                               'status': "creating",
+                               }}
+
+        return self._create('/cgsnapshots', body, 'cgsnapshot')
+
+    def get(self, cgsnapshot_id):
+        """Get a cgsnapshot.
+
+        :param cgsnapshot_id: The ID of the cgsnapshot to get.
+        :rtype: :class:`Cgsnapshot`
+        """
+        return self._get("/cgsnapshots/%s" % cgsnapshot_id, "cgsnapshot")
+
+    def list(self, detailed=True, search_opts=None):
+        """Lists all cgsnapshots.
+
+        :rtype: list of :class:`Cgsnapshot`
+        """
+        if search_opts is None:
+            search_opts = {}
+
+        qparams = {}
+
+        for opt, val in six.iteritems(search_opts):
+            if val:
+                qparams[opt] = val
+
+        query_string = "?%s" % urlencode(qparams) if qparams else ""
+
+        detail = ""
+        if detailed:
+            detail = "/detail"
+
+        return self._list("/cgsnapshots%s%s" % (detail, query_string),
+                          "cgsnapshots")
+
+    def delete(self, cgsnapshot):
+        """Delete a cgsnapshot.
+
+        :param cgsnapshot: The :class:`Cgsnapshot` to delete.
+        """
+        self._delete("/cgsnapshots/%s" % base.getid(cgsnapshot))
+
+    def update(self, cgsnapshot, **kwargs):
+        """Update the name or description for a cgsnapshot.
+
+        :param cgsnapshot: The :class:`Cgsnapshot` to update.
+        """
+        if not kwargs:
+            return
+
+        body = {"cgsnapshot": kwargs}
+
+        self._update("/cgsnapshots/%s" % base.getid(cgsnapshot), body)
+
+    def _action(self, action, cgsnapshot, info=None, **kwargs):
+        """Perform a cgsnapshot "action."
+        """
+        body = {action: info}
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/cgsnapshots/%s/action' % base.getid(cgsnapshot)
+        return self.api.client.post(url, body=body)

awx/lib/site-packages/cinderclient/v2/client.py

@@ -0,0 +1,121 @@
+# Copyright (c) 2013 OpenStack Foundation
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from cinderclient import client
+from cinderclient.v2 import availability_zones
+from cinderclient.v2 import cgsnapshots
+from cinderclient.v2 import consistencygroups
+from cinderclient.v2 import limits
+from cinderclient.v2 import qos_specs
+from cinderclient.v2 import quota_classes
+from cinderclient.v2 import quotas
+from cinderclient.v2 import services
+from cinderclient.v2 import volumes
+from cinderclient.v2 import volume_snapshots
+from cinderclient.v2 import volume_types
+from cinderclient.v2 import volume_encryption_types
+from cinderclient.v2 import volume_backups
+from cinderclient.v2 import volume_backups_restore
+from cinderclient.v1 import volume_transfers
+
+
+class Client(object):
+    """Top-level object to access the OpenStack Volume API.
+
+    Create an instance with your creds::
+
+        >>> client = Client(USERNAME, PASSWORD, PROJECT_ID, AUTH_URL)
+
+    Then call methods on its managers::
+
+        >>> client.volumes.list()
+        ...
+    """
+
+    def __init__(self, username=None, api_key=None, project_id=None,
+                 auth_url='', insecure=False, timeout=None, tenant_id=None,
+                 proxy_tenant_id=None, proxy_token=None, region_name=None,
+                 endpoint_type='publicURL', extensions=None,
+                 service_type='volumev2', service_name=None,
+                 volume_service_name=None, retries=None, http_log_debug=False,
+                 cacert=None, auth_system='keystone', auth_plugin=None,
+                 session=None, **kwargs):
+        # FIXME(comstud): Rename the api_key argument above when we
+        # know it's not being used as keyword argument
+        password = api_key
+        self.limits = limits.LimitsManager(self)
+
+        # extensions
+        self.volumes = volumes.VolumeManager(self)
+        self.volume_snapshots = volume_snapshots.SnapshotManager(self)
+        self.volume_types = volume_types.VolumeTypeManager(self)
+        self.volume_encryption_types = \
+            volume_encryption_types.VolumeEncryptionTypeManager(self)
+        self.qos_specs = qos_specs.QoSSpecsManager(self)
+        self.quota_classes = quota_classes.QuotaClassSetManager(self)
+        self.quotas = quotas.QuotaSetManager(self)
+        self.backups = volume_backups.VolumeBackupManager(self)
+        self.restores = volume_backups_restore.VolumeBackupRestoreManager(self)
+        self.transfers = volume_transfers.VolumeTransferManager(self)
+        self.services = services.ServiceManager(self)
+        self.consistencygroups = consistencygroups.\
+            ConsistencygroupManager(self)
+        self.cgsnapshots = cgsnapshots.CgsnapshotManager(self)
+        self.availability_zones = \
+            availability_zones.AvailabilityZoneManager(self)
+
+        # Add in any extensions...
+        if extensions:
+            for extension in extensions:
+                if extension.manager_class:
+                    setattr(self, extension.name,
+                            extension.manager_class(self))
+
+        self.client = client._construct_http_client(
+            username=username,
+            password=password,
+            project_id=project_id,
+            auth_url=auth_url,
+            insecure=insecure,
+            timeout=timeout,
+            tenant_id=tenant_id,
+            proxy_tenant_id=tenant_id,
+            proxy_token=proxy_token,
+            region_name=region_name,
+            endpoint_type=endpoint_type,
+            service_type=service_type,
+            service_name=service_name,
+            volume_service_name=volume_service_name,
+            retries=retries,
+            http_log_debug=http_log_debug,
+            cacert=cacert,
+            auth_system=auth_system,
+            auth_plugin=auth_plugin,
+            session=session,
+            **kwargs)
+
+    def authenticate(self):
+        """Authenticate against the server.
+
+        Normally this is called automatically when you first access the API,
+        but you can call this method to force authentication right now.
+
+        Returns on success; raises :exc:`exceptions.Unauthorized` if the
+        credentials are wrong.
+        """
+        self.client.authenticate()
+
+    def get_volume_api_version_from_endpoint(self):
+        return self.client.get_volume_api_version_from_endpoint()

awx/lib/site-packages/cinderclient/v2/consistencygroups.py

@@ -0,0 +1,131 @@
+# Copyright (C) 2012 - 2014 EMC Corporation.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""Consistencygroup interface (v2 extension)."""
+
+import six
+try:
+    from urllib import urlencode
+except ImportError:
+    from urllib.parse import urlencode
+
+from cinderclient import base
+
+
+class Consistencygroup(base.Resource):
+    """A Consistencygroup of volumes."""
+    def __repr__(self):
+        return "<Consistencygroup: %s>" % self.id
+
+    def delete(self, force='False'):
+        """Delete this consistencygroup."""
+        self.manager.delete(self, force)
+
+    def update(self, **kwargs):
+        """Update the name or description for this consistencygroup."""
+        self.manager.update(self, **kwargs)
+
+
+class ConsistencygroupManager(base.ManagerWithFind):
+    """Manage :class:`Consistencygroup` resources."""
+    resource_class = Consistencygroup
+
+    def create(self, volume_types, name=None,
+               description=None, user_id=None,
+               project_id=None, availability_zone=None):
+        """Creates a consistencygroup.
+
+        :param name: Name of the ConsistencyGroup
+        :param description: Description of the ConsistencyGroup
+        :param volume_types: Types of volume
+        :param user_id: User id derived from context
+        :param project_id: Project id derived from context
+        :param availability_zone: Availability Zone to use
+        :rtype: :class:`Consistencygroup`
+       """
+
+        body = {'consistencygroup': {'name': name,
+                                     'description': description,
+                                     'volume_types': volume_types,
+                                     'user_id': user_id,
+                                     'project_id': project_id,
+                                     'availability_zone': availability_zone,
+                                     'status': "creating",
+                                     }}
+
+        return self._create('/consistencygroups', body, 'consistencygroup')
+
+    def get(self, group_id):
+        """Get a consistencygroup.
+
+        :param group_id: The ID of the consistencygroup to get.
+        :rtype: :class:`Consistencygroup`
+        """
+        return self._get("/consistencygroups/%s" % group_id,
+                         "consistencygroup")
+
+    def list(self, detailed=True, search_opts=None):
+        """Lists all consistencygroups.
+
+        :rtype: list of :class:`Consistencygroup`
+        """
+        if search_opts is None:
+            search_opts = {}
+
+        qparams = {}
+
+        for opt, val in six.iteritems(search_opts):
+            if val:
+                qparams[opt] = val
+
+        query_string = "?%s" % urlencode(qparams) if qparams else ""
+
+        detail = ""
+        if detailed:
+            detail = "/detail"
+
+        return self._list("/consistencygroups%s%s" % (detail, query_string),
+                          "consistencygroups")
+
+    def delete(self, consistencygroup, force=False):
+        """Delete a consistencygroup.
+
+        :param Consistencygroup: The :class:`Consistencygroup` to delete.
+        """
+        body = {'consistencygroup': {'force': force}}
+        self.run_hooks('modify_body_for_action', body, 'consistencygroup')
+        url = '/consistencygroups/%s/delete' % base.getid(consistencygroup)
+        return self.api.client.post(url, body=body)
+
+    def update(self, consistencygroup, **kwargs):
+        """Update the name or description for a consistencygroup.
+
+        :param Consistencygroup: The :class:`Consistencygroup` to update.
+        """
+        if not kwargs:
+            return
+
+        body = {"consistencygroup": kwargs}
+
+        self._update("/consistencygroups/%s" % base.getid(consistencygroup),
+                     body)
+
+    def _action(self, action, consistencygroup, info=None, **kwargs):
+        """Perform a consistencygroup "action."
+        """
+        body = {action: info}
+        self.run_hooks('modify_body_for_action', body, **kwargs)
+        url = '/consistencygroups/%s/action' % base.getid(consistencygroup)
+        return self.api.client.post(url, body=body)