OpenDev Migration Patch

This commit was bulk generated and pushed by the OpenDev sysadmins
as a part of the Git hosting and code review systems migration
detailed in these mailing list posts:

http://lists.openstack.org/pipermail/openstack-discuss/2019-March/003603.html
http://lists.openstack.org/pipermail/openstack-discuss/2019-April/004920.html

Attempts have been made to correct repository namespaces and
hostnames based on simple pattern matching, but it's possible some
were updated incorrectly or missed entirely. Please reach out to us
via the contact information listed at https://opendev.org/ with any
questions you may have.

.gitreview

@@ -1,4 +1,5 @@
 [gerrit]
-host=review.openstack.org
+host=review.opendev.org
 port=29418
 project=openstack/python-karborclient.git
+defaultbranch=stable/ocata

.zuul.yaml

@@ -0,0 +1,12 @@
+- project:
+    templates:
+      - openstack-python-jobs
+      - openstack-python35-jobs
+      - check-requirements
+      - publish-openstack-sphinx-docs
+      - openstackclient-plugin-jobs
+    check:
+      jobs:
+        - openstack-tox-cover:
+            voting: false
+

README.rst

@@ -1,3 +1,12 @@
+========================
+Team and repository tags
+========================
+
+.. image:: http://governance.openstack.org/badges/python-karborclient.svg
+    :target: http://governance.openstack.org/reference/tags/index.html
+
+.. Change things from this point on
+
 Karbor
 ======
 
@@ -30,6 +39,7 @@ Karbor Mission Statement
 .. _Blueprints: https://blueprints.launchpad.net/python-karborclient
 .. _Bugs: https://bugs.launchpad.net/python-karborclient
 .. _Source: https://git.openstack.org/cgit/openstack/python-karborclient
+.. _Specs: http://docs.openstack.org/developer/karbor/specs/index.html
 .. _How to Contribute: http://docs.openstack.org/infra/manual/developers.html
 
 
@@ -38,6 +48,7 @@ Python Karborclient
 python-karborclient is a client library for karbor built on the karbor API.
 It provides a Python API (the ``karborclient`` module) and a command-line tool
 (``karbor``).
+
 Project Resources
 -----------------
 

karborclient/client.py

@@ -1,18 +1,20 @@
-#    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 karborclient.common import utils
-
-
-def Client(version, *args, **kwargs):
-    module = utils.import_versioned_module(version, 'client')
-    client_class = getattr(module, 'Client')
-    return client_class(*args, **kwargs)
+#    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 oslo_utils import importutils
+
+
+def Client(version, *args, **kwargs):
+    module = importutils.import_versioned_module(
+        'karborclient', version, 'client'
+    )
+    client_class = getattr(module, 'Client')
+    return client_class(*args, **kwargs)

karborclient/common/apiclient/auth.py

@@ -1,221 +1,218 @@
-# 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 karborclient.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 = "karborclient.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: AuthPluginOptionsMissing
-    """
-    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
-        """
+# 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 karborclient.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 = "karborclient.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: AuthPluginOptionsMissing
+    """
+    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
+        """

karborclient/common/apiclient/client.py

@@ -1,365 +1,363 @@
-# 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
-
-try:
-    import simplejson as json
-except ImportError:
-    import json
-
-import time
-
-from oslo_log import log as logging
-from oslo_utils import importutils
-import requests
-
-from karborclient.i18n import _
-from karborclient.openstack.common.apiclient import exceptions
-
-
-
-_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 = "karborclient.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 %(api_name)s client version '%(version)s'. "
-                    "Must be one of: %(version_map)s") % {
-                        'api_name': api_name,
-                        'version': version,
-                        'version_map': ', '.join(version_map.keys())
-                    }
-            raise exceptions.UnsupportedVersion(msg)
-
-        return importutils.import_class(client_path)
+# 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
+
+try:
+    import simplejson as json
+except ImportError:
+    import json
+
+import time
+
+from oslo_log import log as logging
+from oslo_utils import importutils
+import requests
+
+from karborclient.i18n import _
+from karborclient.openstack.common.apiclient import exceptions
+
+
+_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 = "karborclient.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 karborclient.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 %(api_name)s client version '%(version)s'. "
+                    "Must be one of: %(version_map)s") % {
+                        'api_name': api_name,
+                        'version': version,
+                        'version_map': ', '.join(version_map.keys())}
+            raise exceptions.UnsupportedVersion(msg)
+
+        return importutils.import_class(client_path)

karborclient/common/apiclient/exceptions.py

@@ -1,465 +1,463 @@
-# 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
-
-from karborclient.i18n import _
-
-
-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 arguments: %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 an 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 HTTPRedirection(HttpError):
-    """HTTP Redirection."""
-    message = _("HTTP Redirection")
-
-
-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 MultipleChoices(HTTPRedirection):
-    """HTTP 300 - Multiple Choices.
-
-    Indicates multiple options for the resource that the client may follow.
-    """
-
-    http_status = 300
-    message = _("Multiple Choices")
-
-
-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
-    """
-
-    req_id = response.headers.get("x-openstack-request-id")
-    #NOTE(hdd) true for older versions of nova and cinder
-    if not req_id:
-        req_id = response.headers.get("x-compute-request-id")
-    kwargs = {
-        "http_status": response.status_code,
-        "response": response,
-        "method": method,
-        "url": url,
-        "request_id": req_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 isinstance(body, dict):
-                error = list(body.values())[0]
-                kwargs["message"] = error.get("message")
-                kwargs["details"] = error.get("details")
-    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)
+# 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
+
+from karborclient.i18n import _
+
+
+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 arguments: %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 an 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 HTTPRedirection(HttpError):
+    """HTTP Redirection."""
+    message = _("HTTP Redirection")
+
+
+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 MultipleChoices(HTTPRedirection):
+    """HTTP 300 - Multiple Choices.
+
+    Indicates multiple options for the resource that the client may follow.
+    """
+
+    http_status = 300
+    message = _("Multiple Choices")
+
+
+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
+    """
+
+    req_id = response.headers.get("x-openstack-request-id")
+    # NOTE(hdd) true for older versions of nova and cinder
+    if not req_id:
+        req_id = response.headers.get("x-compute-request-id")
+    kwargs = {
+        "http_status": response.status_code,
+        "response": response,
+        "method": method,
+        "url": url,
+        "request_id": req_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 isinstance(body, dict):
+                error = list(body.values())[0]
+                kwargs["message"] = error.get("message")
+                kwargs["details"] = error.get("details")
+    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)

karborclient/common/apiclient/fake_client.py

@@ -1,180 +1,177 @@
-# 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 karborclient.openstack.common.apiclient import client
-
-
-def assert_has_keys(dct, required=None, optional=None):
-    if required is None:
-        required = []
-    if optional is None:
-        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)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-
-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,
-        })
+# 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 karborclient.common.apiclient import client
+
+
+def assert_has_keys(dct, required=None, optional=None):
+    if required is None:
+        required = []
+    if optional is None:
+        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)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+
+class FakeHTTPClient(client.HTTPClient):
+
+    def __init__(self, *args, **kwargs):
+        self.callstack = []
+        self.fixtures = kwargs.pop("fixtures", None) or {}
+        if not args and "auth_plugin" not 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,
+        })

karborclient/common/base.py

@@ -20,8 +20,9 @@ import copy
 import six
 from six.moves.urllib import parse
 
+from karborclient.common.apiclient import exceptions
 from karborclient.common import http
-from karborclient.openstack.common.apiclient import exceptions
+
 
 SORT_DIR_VALUES = ('asc', 'desc')
 SORT_KEY_VALUES = ('id', 'status', 'name', 'created_at')

karborclient/common/http.py

@@ -26,7 +26,9 @@ import requests
 import six
 from six.moves import urllib
 
-from karborclient.openstack.common.apiclient import exceptions as exc
+from karborclient.common.apiclient import exceptions as exc
+from karborclient.i18n import _LE
+from karborclient.i18n import _LW
 
 LOG = logging.getLogger(__name__)
 USER_AGENT = 'python-karborclient'
@@ -48,7 +50,7 @@ def get_system_ca_file():
         if os.path.exists(ca):
             LOG.debug("Using ca file %s", ca)
             return ca
-    LOG.warning("System ca file could not be found.")
+    LOG.warning(_LW("System ca file could not be found."))
 
 
 class HTTPClient(object):
@@ -246,7 +248,7 @@ class HTTPClient(object):
             if 'data' in kwargs:
                 raise ValueError("Can't provide both 'data' and "
                                  "'body' to a request")
-            LOG.warning("Use of 'body' is deprecated; use 'data' instead")
+            LOG.warning(_LW("Use of 'body' is deprecated; use 'data' instead"))
             kwargs['data'] = kwargs.pop('body')
         if 'data' in kwargs:
             kwargs['data'] = jsonutils.dumps(kwargs['data'])
@@ -258,7 +260,7 @@ class HTTPClient(object):
             try:
                 body = resp.json()
             except ValueError:
-                LOG.error('Could not decode response body as JSON')
+                LOG.error(_LE('Could not decode response body as JSON'))
         else:
             body = None
 
@@ -269,7 +271,7 @@ class HTTPClient(object):
             if 'data' in kwargs:
                 raise ValueError("Can't provide both 'data' and "
                                  "'body' to a request")
-            LOG.warning("Use of 'body' is deprecated; use 'data' instead")
+            LOG.warning(_LW("Use of 'body' is deprecated; use 'data' instead"))
             kwargs['data'] = kwargs.pop('body')
         # Chunking happens automatically if 'body' is a
         # file-like object
@@ -326,7 +328,7 @@ class SessionClient(keystone_adapter.Adapter):
             if 'data' in kwargs:
                 raise ValueError("Can't provide both 'data' and "
                                  "'body' to a request")
-            LOG.warning("Use of 'body' is deprecated; use 'data' instead")
+            LOG.warning(_LW("Use of 'body' is deprecated; use 'data' instead"))
             kwargs['data'] = kwargs.pop('body')
         if 'data' in kwargs:
             kwargs['data'] = jsonutils.dumps(kwargs['data'])
@@ -351,7 +353,7 @@ class SessionClient(keystone_adapter.Adapter):
             if 'data' in kwargs:
                 raise ValueError("Can't provide both 'data' and "
                                  "'body' to a request")
-            LOG.warning("Use of 'body' is deprecated; use 'data' instead")
+            LOG.warning(_LW("Use of 'body' is deprecated; use 'data' instead"))
             kwargs['data'] = kwargs.pop('body')
         resp = keystone_adapter.Adapter.request(self,
                                                 url,

karborclient/common/utils.py

@@ -12,6 +12,7 @@
 
 from __future__ import print_function
 
+import json
 import os
 import sys
 
@@ -19,11 +20,10 @@ import six
 import uuid
 
 from oslo_utils import encodeutils
-from oslo_utils import importutils
 
 import prettytable
 
-from karborclient.openstack.common.apiclient import exceptions
+from karborclient.common.apiclient import exceptions
 
 
 # Decorator for cli-args
@@ -49,13 +49,6 @@ def env(*vars, **kwargs):
     return kwargs.get('default', '')
 
 
-def import_versioned_module(version, submodule=None):
-    module = 'karborclient.v%s' % version
-    if submodule:
-        module = '.'.join((module, submodule))
-    return importutils.import_module(module)
-
-
 def _print(pt, order):
     if sys.version_info >= (3, 0):
         print(pt.get_string(sortby=order))
@@ -112,7 +105,7 @@ def print_list(objs, fields, exclude_unavailable=False, formatters=None,
         fields.remove(f)
 
     pt = prettytable.PrettyTable((f for f in fields), caching=False)
-    pt.aligns = ['l' for f in fields]
+    pt.align = 'l'
     for row in rows:
         pt.add_row(row)
 
@@ -123,17 +116,40 @@ def print_list(objs, fields, exclude_unavailable=False, formatters=None,
     _print(pt, order_by)
 
 
-def print_dict(d, property="Property"):
+def print_dict(d, property="Property", dict_format_list=None,
+               json_format_list=None):
     pt = prettytable.PrettyTable([property, 'Value'], caching=False)
-    pt.aligns = ['l', 'l']
+    pt.align = 'l'
     for r in six.iteritems(d):
         r = list(r)
         if isinstance(r[1], six.string_types) and "\r" in r[1]:
             r[1] = r[1].replace("\r", " ")
+        if dict_format_list is not None and r[0] in dict_format_list:
+            r[1] = dict_prettyprint(r[1])
+        if json_format_list is not None and r[0] in json_format_list:
+            r[1] = json_prettyprint(r[1])
         pt.add_row(r)
     _print(pt, property)
 
 
+def dict_prettyprint(val):
+    """dict pretty print formatter.
+
+    :param val: dict.
+    :return: formatted json string.
+    """
+    return json.dumps(val, indent=2, sort_keys=True)
+
+
+def json_prettyprint(val):
+    """json pretty print formatter.
+
+    :param val: json string.
+    :return: formatted json string.
+    """
+    return val and json.dumps(json.loads(val), indent=2, sort_keys=True)
+
+
 def find_resource(manager, name_or_id, *args, **kwargs):
     """Helper for the _find_* methods."""
     # first try to get entity as integer id

karborclient/i18n.py

@@ -1,34 +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.
-
-"""oslo.i18n integration module.
-
-See http://docs.openstack.org/developer/oslo.i18n/usage.html
-
-"""
-
-import oslo_i18n
-
-_translators = oslo_i18n.TranslatorFactory(domain='karborclient')
-
-# 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
+#    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.
+
+"""oslo.i18n integration module.
+
+See http://docs.openstack.org/developer/oslo.i18n/usage.html
+
+"""
+
+import oslo_i18n
+
+_translators = oslo_i18n.TranslatorFactory(domain='karborclient')
+
+# 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
+
+
+def get_available_languages():
+    return oslo_i18n.get_available_languages('karborclient')

karborclient/openstack/common/__init__.py

@@ -1,17 +0,0 @@
-#
-#    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'))

karborclient/shell.py

@@ -28,13 +28,16 @@ from keystoneclient import session as ksession
 from oslo_log import handlers
 from oslo_log import log as logging
 from oslo_utils import encodeutils
+from oslo_utils import importutils
+
 import six
 import six.moves.urllib.parse as urlparse
 
 import karborclient
 from karborclient import client as karbor_client
+from karborclient.common.apiclient import exceptions as exc
 from karborclient.common import utils
-from karborclient.openstack.common.apiclient import exceptions as exc
+
 
 logger = logging.getLogger(__name__)
 
@@ -149,7 +152,9 @@ class KarborShell(object):
 
         self.subcommands = {}
         subparsers = parser.add_subparsers(metavar='<subcommand>')
-        submodule = utils.import_versioned_module(version, 'shell')
+        submodule = importutils.import_versioned_module(
+            'karborclient', version, 'shell'
+        )
         self._find_actions(subparsers, submodule)
         self._find_actions(subparsers, self)
 

karborclient/tests/unit/test_http.py

@@ -16,8 +16,8 @@ import socket
 import mock
 import testtools
 
+from karborclient.common.apiclient import exceptions as exc
 from karborclient.common import http
-from karborclient.openstack.common.apiclient import exceptions as exc
 from karborclient.tests.unit import fakes
 
 

karborclient/tests/unit/test_shell.py

@@ -23,7 +23,7 @@ from oslo_log import log
 import six
 from testtools import matchers
 
-from karborclient.openstack.common.apiclient import exceptions
+from karborclient.common.apiclient import exceptions
 import karborclient.shell
 from karborclient.tests.unit import base
 

karborclient/tests/unit/v1/test_checkpoints.py

@@ -88,5 +88,5 @@ class CheckpointsTest(base.TestCaseShell):
             'checkpoints'.format(
                 provider_id=FAKE_PROVIDER_ID),
             data={
-                'checkpoint': {'plan_id': FAKE_PLAN_ID}},
+                'checkpoint': {'plan_id': FAKE_PLAN_ID, 'extra-info': None}},
             headers={})

karborclient/tests/unit/v1/test_plans.py

@@ -48,7 +48,7 @@ class PlansTest(base.TestCaseShell):
     @mock.patch('karborclient.common.http.HTTPClient.json_request')
     def test_create_plan(self, mock_request):
         mock_request.return_value = mock_request_return
-        cs.plans.create('Plan name', 'provider_id', '', "")
+        cs.plans.create('Plan name', 'provider_id', '', "", '')
         mock_request.assert_called_with(
             'POST',
             '/plans',
@@ -56,7 +56,8 @@ class PlansTest(base.TestCaseShell):
                 'plan': {'provider_id': 'provider_id',
                          'name': 'Plan name',
                          'resources': '',
-                         'parameters': ''}},
+                         'parameters': '',
+                         'description': ''}},
             headers={})
 
     @mock.patch('karborclient.common.http.HTTPClient.raw_request')

karborclient/tests/unit/v1/test_triggers.py

@@ -66,7 +66,7 @@ class TriggersTest(base.TestCaseShell):
             headers={})
 
     @mock.patch('karborclient.common.http.HTTPClient.json_request')
-    def test_show_plan(self, mock_request):
+    def test_show_trigger(self, mock_request):
         mock_request.return_value = mock_request_return
         cs.triggers.get('1')
         mock_request.assert_called_with(
@@ -82,3 +82,18 @@ class TriggersTest(base.TestCaseShell):
             'GET',
             '/triggers/1',
             headers={'X-Configuration-Session': 'fake_session_id'})
+
+    @mock.patch('karborclient.common.http.HTTPClient.json_request')
+    def test_update_trigger(self, mock_request):
+        mock_request.return_value = mock_request_return
+        trigger_id = '123'
+        data = {"name": "My Trigger",
+                "properties": {"pattern": "0 10 * * *", "format": "crontab"}}
+        body = {"trigger_info": data}
+        cs.triggers.update(trigger_id, data)
+        mock_request.assert_called_with(
+            'PUT',
+            '/triggers/123',
+            data=body,
+            headers={}
+        )

karborclient/v1/checkpoints.py

@@ -19,15 +19,26 @@ class Checkpoint(base.Resource):
     def __repr__(self):
         return "<Checkpoint %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
+    def get(self):
+        self.set_loaded(True)
+        if not hasattr(self.manager, 'get'):
+            return
+        plan = self.protection_plan
+        if plan is not None:
+            provider_id = plan.get("provider_id", None)
+            new = self.manager.get(provider_id, self.id)
+            if new:
+                self._add_details(new._info)
+        else:
+            return
 
 
 class CheckpointManager(base.ManagerWithFind):
     resource_class = Checkpoint
 
-    def create(self, provider_id, plan_id):
-        body = {'checkpoint': {'plan_id': plan_id}}
+    def create(self, provider_id, plan_id, checkpoint_extra_info=None):
+        body = {'checkpoint': {'plan_id': plan_id,
+                               'extra-info': checkpoint_extra_info}}
         url = "/providers/{provider_id}/" \
               "checkpoints" .format(provider_id=provider_id)
         return self._create(url, body, 'checkpoint')

karborclient/v1/plans.py

@@ -17,15 +17,14 @@ class Plan(base.Resource):
     def __repr__(self):
         return "<Plan %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
-
 
 class PlanManager(base.ManagerWithFind):
     resource_class = Plan
 
-    def create(self, name, provider_id, resources, parameters):
+    def create(self, name, provider_id, resources, parameters,
+               description=None):
         body = {'plan': {'name': name,
+                         'description': description,
                          'provider_id': provider_id,
                          'resources': resources,
                          'parameters': parameters

karborclient/v1/protectables.py

@@ -19,17 +19,11 @@ class Protectable(base.Resource):
     def __repr__(self):
         return "<Protectable %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
-
 
 class Instances(base.Resource):
     def __repr__(self):
         return "<Instances %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
-
 
 class ProtectableManager(base.ManagerWithFind):
     resource_class = Protectable
@@ -77,14 +71,27 @@ class ProtectableManager(base.ManagerWithFind):
             sort_dir=sort_dir, sort=sort)
         return self._list(url, response_key='instances', obj_class=Instances)
 
-    def get_instance(self, type, id, session_id=None):
+    def get_instance(self, type, id, search_opts=None, session_id=None):
         if session_id:
             headers = {'X-Configuration-Session': session_id}
         else:
             headers = {}
-        url = "/protectables/{protectable_type}/" \
-              "instances/{protectable_id}".format(protectable_type=type,
-                                                  protectable_id=id)
+
+        if search_opts is None:
+            search_opts = {}
+        query_params = {}
+        for key, val in search_opts.items():
+            if val:
+                query_params[key] = val
+        query_string = ""
+        if query_params:
+            params = sorted(query_params.items(), key=lambda x: x[0])
+            query_string = "?%s" % parse.urlencode(params)
+
+        url = ("/protectables/{protectable_type}/instances/"
+               "{protectable_id}{query_string}").format(
+            protectable_type=type, protectable_id=id,
+            query_string=query_string)
         return self._get(url, response_key="instance", headers=headers)
 
     def _build_instances_list_url(self, protectable_type,

karborclient/v1/providers.py

@@ -17,9 +17,6 @@ class Provider(base.Resource):
     def __repr__(self):
         return "<Provider %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
-
 
 class ProviderManager(base.ManagerWithFind):
     resource_class = Provider

karborclient/v1/restores.py

@@ -17,9 +17,6 @@ class Restore(base.Resource):
     def __repr__(self):
         return "<Restore %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
-
 
 class RestoreManager(base.ManagerWithFind):
     resource_class = Restore
@@ -38,11 +35,6 @@ class RestoreManager(base.ManagerWithFind):
         url = "/restores"
         return self._create(url, body, 'restore')
 
-    def delete(self, restore_id):
-        path = '/restores/{restore_id}'.format(
-            restore_id=restore_id)
-        return self._delete(path)
-
     def get(self, restore_id, session_id=None):
         if session_id:
             headers = {'X-Configuration-Session': session_id}

karborclient/v1/scheduled_operations.py

@@ -17,9 +17,6 @@ class ScheduledOperation(base.Resource):
     def __repr__(self):
         return "<ScheduledOperation %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
-
 
 class ScheduledOperationManager(base.ManagerWithFind):
     resource_class = ScheduledOperation

karborclient/v1/shell.py

@@ -11,15 +11,17 @@
 #    under the License.
 
 import argparse
-
+import json
 import os
 
-from karborclient.common import base
-from karborclient.common import utils
-from karborclient.openstack.common.apiclient import exceptions
+from datetime import datetime
 from oslo_serialization import jsonutils
 from oslo_utils import uuidutils
 
+from karborclient.common.apiclient import exceptions
+from karborclient.common import base
+from karborclient.common import utils
+
 
 @utils.arg('--all-tenants',
            dest='all_tenants',
@@ -38,6 +40,10 @@ from oslo_utils import uuidutils
            metavar='<name>',
            default=None,
            help='Filters results by a name. Default=None.')
+@utils.arg('--description',
+           metavar='<description>',
+           default=None,
+           help='Filters results by a description. Default=None.')
 @utils.arg('--status',
            metavar='<status>',
            default=None,
@@ -51,7 +57,7 @@ from oslo_utils import uuidutils
 @utils.arg('--limit',
            metavar='<limit>',
            default=None,
-           help='Maximum number of volumes to return. Default=None.')
+           help='Maximum number of plans to return. Default=None.')
 @utils.arg('--sort_key',
            metavar='<sort_key>',
            default=None,
@@ -82,6 +88,7 @@ def do_plan_list(cs, args):
         'all_tenants': all_tenants,
         'project_id': args.tenant,
         'name': args.name,
+        'description': args.description,
         'status': args.status,
     }
 
@@ -94,7 +101,7 @@ def do_plan_list(cs, args):
                           limit=args.limit, sort_key=args.sort_key,
                           sort_dir=args.sort_dir, sort=args.sort)
 
-    key_list = ['Id', 'Name', 'Provider id', 'Status']
+    key_list = ['Id', 'Name', 'Description', 'Provider id', 'Status']
 
     if args.sort_key or args.sort_dir or args.sort:
         sortby_index = None
@@ -129,13 +136,18 @@ def do_plan_list(cs, args):
            'resource_id: limit the parameters to a specific resource. '
            'Other keys and values: according to provider\'s protect schema.'
            )
+@utils.arg('--description',
+           metavar='<description>',
+           help='The description of a plan.')
 def do_plan_create(cs, args):
     """Create a plan."""
     plan_resources = _extract_resources(args)
+    _check_resources(cs, plan_resources)
     plan_parameters = _extract_parameters(args)
     plan = cs.plans.create(args.name, args.provider_id, plan_resources,
-                           plan_parameters)
-    utils.print_dict(plan.to_dict())
+                           plan_parameters, description=args.description)
+    dict_format_list = {"resources", "parameters"}
+    utils.print_dict(plan.to_dict(), dict_format_list=dict_format_list)
 
 
 @utils.arg('plan',
@@ -144,7 +156,8 @@ def do_plan_create(cs, args):
 def do_plan_show(cs, args):
     """Shows plan details."""
     plan = cs.plans.get(args.plan)
-    utils.print_dict(plan.to_dict())
+    dict_format_list = {"resources", "parameters"}
+    utils.print_dict(plan.to_dict(), dict_format_list=dict_format_list)
 
 
 @utils.arg('plan',
@@ -171,7 +184,7 @@ def do_plan_delete(cs, args):
            help="Id of plan to update.")
 @utils.arg("--name", metavar="<name>",
            help="A name to which the plan will be renamed.")
-@utils.arg("--resources", metavar="<id=type,id=type>",
+@utils.arg("--resources", metavar="<id=type=name,id=type=name>",
            help="Resources to which the plan will be updated.")
 @utils.arg("--status", metavar="<suspended|started>",
            help="status to which the plan will be updated.")
@@ -212,22 +225,37 @@ def _extract_resources(args):
     return resources
 
 
+def _check_resources(cs, resources):
+    # check the resource whether it is available
+    for resource in resources:
+        try:
+            instance = cs.protectables.get_instance(
+                resource["type"], resource["id"])
+        except exceptions.NotFound:
+            raise exceptions.CommandError(
+                "The resource: %s can not be found." % resource["id"])
+        else:
+            if instance is None:
+                raise exceptions.CommandError(
+                    "The resource: %s is invalid." % resource["id"])
+
+
 @utils.arg('provider_id',
            metavar='<provider_id>',
            help='Provider id.')
 @utils.arg('checkpoint_id',
            metavar='<checkpoint_id>',
            help='Checkpoint id.')
-@utils.arg('restore_target',
+@utils.arg('--restore_target',
            metavar='<restore_target>',
            help='Restore target.')
-@utils.arg('restore_username',
-           metavar='<username>',
-           default="",
+@utils.arg('--restore_username',
+           metavar='<restore_username>',
+           default=None,
            help='Username to restore target.')
-@utils.arg('restore_password',
-           metavar='<password>',
-           default="",
+@utils.arg('--restore_password',
+           metavar='<restore_password>',
+           default=None,
            help='Password to restore target.')
 @utils.arg('--parameters-json',
            type=str,
@@ -255,15 +283,24 @@ def do_restore_create(cs, args):
             "Invalid checkpoint id provided.")
 
     restore_parameters = _extract_parameters(args)
-    restore_auth = {
-        'type': 'password',
-        'username': args.username,
-        'password': args.password,
-    }
+    restore_auth = None
+    if args.restore_target is not None:
+        if args.restore_username is None:
+            raise exceptions.CommandError(
+                "Must specify username for restore_target.")
+        if args.restore_password is None:
+            raise exceptions.CommandError(
+                "Must specify password for restore_target.")
+        restore_auth = {
+            'type': 'password',
+            'username': args.restore_username,
+            'password': args.restore_password,
+        }
     restore = cs.restores.create(args.provider_id, args.checkpoint_id,
                                  args.restore_target, restore_parameters,
                                  restore_auth)
-    utils.print_dict(restore.to_dict())
+    dict_format_list = {"parameters"}
+    utils.print_dict(restore.to_dict(), dict_format_list=dict_format_list)
 
 
 def _extract_parameters(args):
@@ -289,11 +326,12 @@ def _extract_parameters(args):
                 )
             if key == "resource_type":
                 resource_type = value
-            if key == "resource_id":
+            elif key == "resource_id":
                 if not uuidutils.is_uuid_like(value):
                     raise exceptions.CommandError('resource_id must be a uuid')
                 resource_id = value
-            parameters[key] = value
+            else:
+                parameter[key] = value
         if resource_type is None:
             raise exceptions.CommandError(
                 'Must specify resource_type for parameters'
@@ -327,13 +365,13 @@ def _extract_parameters(args):
 @utils.arg('--marker',
            metavar='<marker>',
            default=None,
-           help='Begin returning plans that appear later in the plan '
-                'list than that represented by this plan id. '
+           help='Begin returning restores that appear later in the restore '
+                'list than that represented by this restore id. '
                 'Default=None.')
 @utils.arg('--limit',
            metavar='<limit>',
            default=None,
-           help='Maximum number of volumes to return. Default=None.')
+           help='Maximum number of restores to return. Default=None.')
 @utils.arg('--sort_key',
            metavar='<sort_key>',
            default=None,
@@ -382,8 +420,10 @@ def do_restore_list(cs, args):
         sortby_index = None
     else:
         sortby_index = 0
+    formatters = {"Parameters": lambda obj: json.dumps(
+        obj.parameters, indent=2, sort_keys=True)}
     utils.print_list(restores, key_list, exclude_unavailable=True,
-                     sortby_index=sortby_index)
+                     sortby_index=sortby_index, formatters=formatters)
 
 
 @utils.arg('restore',
@@ -392,7 +432,8 @@ def do_restore_list(cs, args):
 def do_restore_show(cs, args):
     """Shows restore details."""
     restore = cs.restores.get(args.restore)
-    utils.print_dict(restore.to_dict())
+    dict_format_list = {"parameters"}
+    utils.print_dict(restore.to_dict(), dict_format_list=dict_format_list)
 
 
 def do_protectable_list(cs, args):
@@ -414,17 +455,30 @@ def do_protectable_show(cs, args):
     utils.print_dict(protectable.to_dict())
 
 
-@utils.arg('protectable_id',
-           metavar='<protectable_id>',
-           help='Protectable instance id.')
 @utils.arg('protectable_type',
            metavar='<protectable_type>',
            help='Protectable type.')
+@utils.arg('protectable_id',
+           metavar='<protectable_id>',
+           help='Protectable instance id.')
+@utils.arg('--parameters',
+           type=str,
+           nargs='*',
+           metavar='<key=value>',
+           default=None,
+           help='Show a instance by parameters key and value pair. '
+                'Default=None.')
 def do_protectable_show_instance(cs, args):
     """Shows instance details."""
+    search_opts = {
+        'parameters': (_extract_instances_parameters(args)
+                       if args.parameters else None),
+    }
     instance = cs.protectables.get_instance(args.protectable_type,
-                                            args.protectable_id)
-    utils.print_dict(instance.to_dict())
+                                            args.protectable_id,
+                                            search_opts=search_opts)
+    dict_format_list = {"dependent_resources"}
+    utils.print_dict(instance.to_dict(), dict_format_list=dict_format_list)
 
 
 @utils.arg('protectable_type',
@@ -437,13 +491,13 @@ def do_protectable_show_instance(cs, args):
 @utils.arg('--marker',
            metavar='<marker>',
            default=None,
-           help='Begin returning plans that appear later in the plan '
-                'list than that represented by this plan id. '
+           help='Begin returning instances that appear later in the instance '
+                'list than that represented by this instance id. '
                 'Default=None.')
 @utils.arg('--limit',
            metavar='<limit>',
            default=None,
-           help='Maximum number of volumes to return. Default=None.')
+           help='Maximum number of instances to return. Default=None.')
 @utils.arg('--sort_key',
            metavar='<sort_key>',
            default=None,
@@ -459,11 +513,20 @@ def do_protectable_show_instance(cs, args):
                   'form of <key>[:<asc|desc>]. '
                   'Valid keys: %s. '
                   'Default=None.') % ', '.join(base.SORT_KEY_VALUES)))
+@utils.arg('--parameters',
+           type=str,
+           nargs='*',
+           metavar='<key=value>',
+           default=None,
+           help='List instances by parameters key and value pair. '
+                'Default=None.')
 def do_protectable_list_instances(cs, args):
     """Lists all protectable instances."""
 
     search_opts = {
         'type': args.type,
+        'parameters': (_extract_instances_parameters(args)
+                       if args.parameters else None),
     }
 
     if args.sort and (args.sort_key or args.sort_dir):
@@ -483,8 +546,24 @@ def do_protectable_list_instances(cs, args):
         sortby_index = None
     else:
         sortby_index = 0
+
+    formatters = {"Dependent resources": lambda obj: json.dumps(
+        obj.dependent_resources, indent=2, sort_keys=True)}
     utils.print_list(instances, key_list, exclude_unavailable=True,
-                     sortby_index=sortby_index)
+                     sortby_index=sortby_index, formatters=formatters)
+
+
+def _extract_instances_parameters(args):
+    parameters = {}
+    for parameter in args.parameters:
+        if '=' in parameter:
+            (key, value) = parameter.split('=', 1)
+        else:
+            key = parameter
+            value = None
+
+        parameters[key] = value
+    return parameters
 
 
 @utils.arg('provider_id',
@@ -493,7 +572,8 @@ def do_protectable_list_instances(cs, args):
 def do_provider_show(cs, args):
     """Shows provider details."""
     provider = cs.providers.get(args.provider_id)
-    utils.print_dict(provider.to_dict())
+    dict_format_list = {"extended_info_schema"}
+    utils.print_dict(provider.to_dict(), dict_format_list=dict_format_list)
 
 
 @utils.arg('--name',
@@ -507,13 +587,13 @@ def do_provider_show(cs, args):
 @utils.arg('--marker',
            metavar='<marker>',
            default=None,
-           help='Begin returning plans that appear later in the plan '
-                'list than that represented by this plan id. '
+           help='Begin returning providers that appear later in the provider '
+                'list than that represented by this provider id. '
                 'Default=None.')
 @utils.arg('--limit',
            metavar='<limit>',
            default=None,
-           help='Maximum number of volumes to return. Default=None.')
+           help='Maximum number of providers to return. Default=None.')
 @utils.arg('--sort_key',
            metavar='<sort_key>',
            default=None,
@@ -546,7 +626,7 @@ def do_provider_list(cs, args):
                                   limit=args.limit, sort_key=args.sort_key,
                                   sort_dir=args.sort_dir, sort=args.sort)
 
-    key_list = ['Id', 'Name', 'Description', 'Extended_info_schema']
+    key_list = ['Id', 'Name', 'Description']
 
     if args.sort_key or args.sort_dir or args.sort:
         sortby_index = None
@@ -562,19 +642,57 @@ def do_provider_list(cs, args):
 @utils.arg('plan_id',
            metavar='<plan_id>',
            help='ID of plan.')
+@utils.arg('--extra_info',
+           type=str,
+           nargs='*',
+           metavar='<key=value>',
+           default=None,
+           help='The extra info of a checkpoint.')
 def do_checkpoint_create(cs, args):
     """Create a checkpoint."""
-    checkpoint = cs.checkpoints.create(args.provider_id, args.plan_id)
-    utils.print_dict(checkpoint.to_dict())
+
+    checkpoint_extra_info = None
+    if args.extra_info is not None:
+        checkpoint_extra_info = _extract_extra_info(args)
+    checkpoint = cs.checkpoints.create(args.provider_id, args.plan_id,
+                                       checkpoint_extra_info)
+    dict_format_list = {"protection_plan"}
+    json_format_list = {"resource_graph"}
+    utils.print_dict(checkpoint.to_dict(), dict_format_list=dict_format_list,
+                     json_format_list=json_format_list)
+
+
+def _extract_extra_info(args):
+    checkpoint_extra_info = {}
+    for data in args.extra_info:
+        # unset doesn't require a val, so we have the if/else
+        if '=' in data:
+            (key, value) = data.split('=', 1)
+        else:
+            key = data
+            value = None
+
+        checkpoint_extra_info[key] = value
+    return checkpoint_extra_info
 
 
 @utils.arg('provider_id',
            metavar='<provider_id>',
            help='ID of provider.')
-@utils.arg('--status',
-           metavar='<status>',
+@utils.arg('--plan_id',
+           metavar='<plan_id>',
            default=None,
-           help='Filters results by a status. Default=None.')
+           help='Filters results by a plan_id. Default=None.')
+@utils.arg('--start_date',
+           type=str,
+           metavar='<start_date>',
+           default=None,
+           help='Filters results by a start_date("Y-m-d"). Default=None.')
+@utils.arg('--end_date',
+           type=str,
+           metavar='<end_date>',
+           default=None,
+           help='Filters results by a end_date("Y-m-d"). Default=None.')
 @utils.arg('--project_id',
            metavar='<project_id>',
            default=None,
@@ -582,13 +700,13 @@ def do_checkpoint_create(cs, args):
 @utils.arg('--marker',
            metavar='<marker>',
            default=None,
-           help='Begin returning plans that appear later in the plan '
-                'list than that represented by this plan id. '
+           help='Begin returning checkpoints that appear later in the '
+                'checkpoint list than that represented by this checkpoint id. '
                 'Default=None.')
 @utils.arg('--limit',
            metavar='<limit>',
            default=None,
-           help='Maximum number of volumes to return. Default=None.')
+           help='Maximum number of checkpoints to return. Default=None.')
 @utils.arg('--sort_key',
            metavar='<sort_key>',
            default=None,
@@ -606,9 +724,30 @@ def do_checkpoint_create(cs, args):
                   'Default=None.') % ', '.join(base.SORT_KEY_VALUES)))
 def do_checkpoint_list(cs, args):
     """Lists all checkpoints."""
+    if args.plan_id is not None:
+        if not uuidutils.is_uuid_like(args.plan_id):
+            raise exceptions.CommandError('The plan_id must be a uuid')
+
+    if args.start_date:
+        try:
+            datetime.strptime(
+                args.start_date, "%Y-%m-%d")
+        except (ValueError, SyntaxError):
+            raise exceptions.CommandError(
+                "The format of start_date should be %Y-%m-%d")
+
+    if args.end_date:
+        try:
+            datetime.strptime(
+                args.end_date, "%Y-%m-%d")
+        except (ValueError, SyntaxError):
+            raise exceptions.CommandError(
+                "The format of end_date should be %Y-%m-%d")
 
     search_opts = {
-        'status': args.status,
+        'plan_id': args.plan_id,
+        'start_date': args.start_date,
+        'end_date': args.end_date,
         'project_id': args.project_id,
     }
 
@@ -622,14 +761,17 @@ def do_checkpoint_list(cs, args):
         marker=args.marker, limit=args.limit, sort_key=args.sort_key,
         sort_dir=args.sort_dir, sort=args.sort)
 
-    key_list = ['Id', 'Project id', 'Status', 'Protection plan']
+    key_list = ['Id', 'Project id', 'Status', 'Protection plan', 'Metadata',
+                'Created at']
 
     if args.sort_key or args.sort_dir or args.sort:
         sortby_index = None
     else:
         sortby_index = 0
+    formatters = {"Protection plan": lambda obj: json.dumps(
+        obj.protection_plan, indent=2, sort_keys=True)}
     utils.print_list(checkpoints, key_list, exclude_unavailable=True,
-                     sortby_index=sortby_index)
+                     sortby_index=sortby_index, formatters=formatters)
 
 
 @utils.arg('provider_id',
@@ -641,7 +783,10 @@ def do_checkpoint_list(cs, args):
 def do_checkpoint_show(cs, args):
     """Shows checkpoint details."""
     checkpoint = cs.checkpoints.get(args.provider_id, args.checkpoint_id)
-    utils.print_dict(checkpoint.to_dict())
+    dict_format_list = {"protection_plan"}
+    json_format_list = {"resource_graph"}
+    utils.print_dict(checkpoint.to_dict(), dict_format_list=dict_format_list,
+                     json_format_list=json_format_list)
 
 
 @utils.arg('provider_id',
@@ -696,13 +841,13 @@ def do_checkpoint_delete(cs, args):
 @utils.arg('--marker',
            metavar='<marker>',
            default=None,
-           help='Begin returning plans that appear later in the plan '
-                'list than that represented by this plan id. '
+           help='Begin returning triggers that appear later in the trigger '
+                'list than that represented by this trigger id. '
                 'Default=None.')
 @utils.arg('--limit',
            metavar='<limit>',
            default=None,
-           help='Maximum number of volumes to return. Default=None.')
+           help='Maximum number of triggers to return. Default=None.')
 @utils.arg('--sort_key',
            metavar='<sort_key>',
            default=None,
@@ -752,8 +897,11 @@ def do_trigger_list(cs, args):
         sortby_index = None
     else:
         sortby_index = 0
+
+    formatters = {"Properties": lambda obj: json.dumps(
+        obj.properties, indent=2, sort_keys=True)}
     utils.print_list(triggers, key_list, exclude_unavailable=True,
-                     sortby_index=sortby_index)
+                     sortby_index=sortby_index, formatters=formatters)
 
 
 @utils.arg('name',
@@ -763,18 +911,21 @@ def do_trigger_list(cs, args):
            metavar='<type>',
            help='Type of trigger.')
 @utils.arg('properties',
-           metavar='<key=value:key=value>',
+           metavar='<key=value,key=value>',
            help='Properties of trigger.')
 def do_trigger_create(cs, args):
     """Create a trigger."""
     trigger_properties = _extract_properties(args)
     trigger = cs.triggers.create(args.name, args.type, trigger_properties)
-    utils.print_dict(trigger.to_dict())
+    dict_format_list = {"properties"}
+    utils.print_dict(trigger.to_dict(), dict_format_list=dict_format_list)
 
 
 def _extract_properties(args):
     properties = {}
-    for data in args.properties.split(':'):
+    if args.properties is None:
+        return properties
+    for data in args.properties.split(','):
         if '=' in data:
             (resource_key, resource_value) = data.split('=', 1)
         else:
@@ -785,13 +936,31 @@ def _extract_properties(args):
     return properties
 
 
+@utils.arg("trigger_id", metavar="<TRIGGER ID>",
+           help="Id of trigger to update.")
+@utils.arg("--name", metavar="<name>",
+           help="A new name to which the trigger will be renamed.")
+@utils.arg("--properties", metavar="<key=value,key=value>",
+           help="Properties of trigger which will be updated.")
+def do_trigger_update(cs, args):
+    """Update a trigger."""
+    trigger_info = {}
+    trigger_properties = _extract_properties(args)
+    trigger_info['name'] = args.name
+    trigger_info['properties'] = trigger_properties
+    trigger = cs.triggers.update(args.trigger_id, trigger_info)
+    dict_format_list = {"properties"}
+    utils.print_dict(trigger.to_dict(), dict_format_list=dict_format_list)
+
+
 @utils.arg('trigger',
            metavar='<trigger>',
            help='ID of trigger.')
 def do_trigger_show(cs, args):
     """Shows trigger details."""
     trigger = cs.triggers.get(args.trigger)
-    utils.print_dict(trigger.to_dict())
+    dict_format_list = {"properties"}
+    utils.print_dict(trigger.to_dict(), dict_format_list=dict_format_list)
 
 
 @utils.arg('trigger',
@@ -839,6 +1008,10 @@ def do_trigger_delete(cs, args):
            metavar='<trigger_id>',
            default=None,
            help='Filters results by a trigger id. Default=None.')
+@utils.arg('--operation_definition',
+           metavar='<operation_definition>',
+           default=None,
+           help='Filters results by the operation_definition. Default=None.')
 @utils.arg('--marker',
            metavar='<marker>',
            default=None,
@@ -881,6 +1054,7 @@ def do_scheduledoperation_list(cs, args):
         'name': args.name,
         'operation_type': args.operation_type,
         'trigger_id': args.trigger_id,
+        'operation_definition': args.operation_definition,
     }
 
     if args.sort and (args.sort_key or args.sort_dir):
@@ -913,7 +1087,7 @@ def do_scheduledoperation_list(cs, args):
            metavar='<trigger_id>',
            help='Trigger id of scheduled operation.')
 @utils.arg('operation_definition',
-           metavar='<key=value:key=value>',
+           metavar='<key=value,key=value>',
            help='Operation definition of scheduled operation.')
 def do_scheduledoperation_create(cs, args):
     """Create a scheduled operation."""
@@ -922,12 +1096,14 @@ def do_scheduledoperation_create(cs, args):
                                                         args.operation_type,
                                                         args.trigger_id,
                                                         operation_definition)
-    utils.print_dict(scheduledoperation.to_dict())
+    dict_format_list = {"operation_definition"}
+    utils.print_dict(scheduledoperation.to_dict(),
+                     dict_format_list=dict_format_list)
 
 
 def _extract_operation_definition(args):
     operation_definition = {}
-    for data in args.operation_definition.split(':'):
+    for data in args.operation_definition.split(','):
         if '=' in data:
             (resource_key, resource_value) = data.split('=', 1)
         else:
@@ -944,7 +1120,9 @@ def _extract_operation_definition(args):
 def do_scheduledoperation_show(cs, args):
     """Shows scheduledoperation details."""
     scheduledoperation = cs.scheduled_operations.get(args.scheduledoperation)
-    utils.print_dict(scheduledoperation.to_dict())
+    dict_format_list = {"operation_definition"}
+    utils.print_dict(scheduledoperation.to_dict(),
+                     dict_format_list=dict_format_list)
 
 
 @utils.arg('scheduledoperation',

karborclient/v1/triggers.py

@@ -17,9 +17,6 @@ class Trigger(base.Resource):
     def __repr__(self):
         return "<Trigger %s>" % self._info
 
-    def data(self, **kwargs):
-        return self.manager.data(self, **kwargs)
-
 
 class TriggerManager(base.ManagerWithFind):
     resource_class = Trigger
@@ -46,6 +43,14 @@ class TriggerManager(base.ManagerWithFind):
             trigger_id=trigger_id)
         return self._get(url, response_key="trigger_info", headers=headers)
 
+    def update(self, trigger_id, data):
+
+        body = {"trigger_info": data}
+
+        return self._update('/triggers/{trigger_id}'
+                            .format(trigger_id=trigger_id),
+                            body, "trigger_info")
+
     def list(self, detailed=False, search_opts=None, marker=None, limit=None,
              sort_key=None, sort_dir=None, sort=None):
         """Lists all triggers."""

openstack-common.conf

@@ -1,8 +0,0 @@
-[DEFAULT]
-
-# The list of modules to copy from openstack-common
-module=apiclient.exceptions
-module=apiclient
-
-# The base module to hold the copy of openstack.common
-base=karborclient

requirements.txt

@@ -1,13 +1,13 @@
 # The order of packages is significant, because pip processes them in the order
 # of appearance. Changing the order has an impact on the overall integration
 # process, which may cause wedges in the gate later.
-pbr>=1.6 # Apache-2.0
-PrettyTable<0.8,>=0.7 # BSD
-python-keystoneclient!=2.1.0,>=2.0.0 # Apache-2.0
-requests>=2.10.0 # Apache-2.0
+pbr>=1.8 # Apache-2.0
+PrettyTable<0.8,>=0.7.1 # BSD
+python-keystoneclient>=3.8.0 # Apache-2.0
+requests!=2.12.2,>=2.10.0 # Apache-2.0
 simplejson>=2.2.0 # MIT
 Babel>=2.3.4 # BSD
 six>=1.9.0 # MIT
-oslo.utils>=3.16.0 # Apache-2.0
+oslo.utils>=3.18.0 # Apache-2.0
 oslo.log>=3.11.0 # Apache-2.0
 oslo.i18n>=2.1.0 # Apache-2.0

setup.cfg

@@ -5,7 +5,7 @@ description-file =
     README.rst
 author = OpenStack
 author-email = openstack-dev@lists.openstack.org
-home-page = http://www.openstack.org/
+home-page = http://docs.openstack.org/developer/karbor/
 classifier =
     Environment :: OpenStack
     Intended Audience :: Information Technology
@@ -16,8 +16,8 @@ classifier =
     Programming Language :: Python :: 2
     Programming Language :: Python :: 2.7
     Programming Language :: Python :: 3
-    Programming Language :: Python :: 3.3
     Programming Language :: Python :: 3.4
+    Programming Language :: Python :: 3.5
 
 [global]
 setup-hooks =

test-requirements.txt

@@ -4,10 +4,11 @@
 
 hacking<0.11,>=0.10.2 # Apache-2.0
 
-coverage>=3.6 # Apache-2.0
+coverage>=4.0 # Apache-2.0
 python-subunit>=0.0.18 # Apache-2.0/BSD
-sphinx!=1.3b1,<1.3,>=1.2.1 # BSD
-oslosphinx!=3.4.0,>=2.5.0 # Apache-2.0
+docutils!=0.13.1,>=0.11 # OSI-Approved Open Source, Public Domain
+sphinx!=1.3b1,<1.4,>=1.2.1 # BSD
+oslosphinx>=4.7.0 # Apache-2.0
 oslotest>=1.10.0 # Apache-2.0
 testrepository>=0.0.18 # Apache-2.0/BSD
 testscenarios>=0.4 # Apache-2.0/BSD

tox.ini

@@ -1,14 +1,18 @@
 [tox]
-minversion = 1.6
-envlist = py34,py27,pypy,pep8
+minversion = 2.0
+envlist = py35,py34,py27,pypy,pep8
 skipsdist = True
 
 [testenv]
 usedevelop = True
-install_command = pip install -U {opts} {packages}
+install_command = pip install {opts} {packages}
 setenv =
    VIRTUAL_ENV={envdir}
-deps = -r{toxinidir}/requirements.txt
+   BRANCH_NAME=master
+   CLIENT_NAME=python-karborclient
+   PYTHONWARNINGS=default::DeprecationWarning
+deps = -c{env:UPPER_CONSTRAINTS_FILE:https://git.openstack.org/cgit/openstack/requirements/plain/upper-constraints.txt?h=stable/ocata}
+       -r{toxinidir}/requirements.txt
        -r{toxinidir}/test-requirements.txt
 commands = python setup.py test --slowest --testr-args='{posargs}'
 
@@ -20,6 +24,7 @@ commands = {posargs}
 
 [testenv:functional]
 setenv =
+  {[testenv]setenv}
   OS_TEST_PATH = ./karborclient/tests/functional
 passenv = OS_*
 [testenv:cover]
@@ -37,4 +42,4 @@ commands = oslo_debug_helper {posargs}
 show-source = True
 ignore = E123,E125
 builtins = _
-exclude=.venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,tools
+exclude=.venv,.git,.tox,dist,doc,*lib/python*,*egg,tools