diff -pruN 2.6.2-1/ceilometerclient/apiclient/auth.py 2.9.0-6/ceilometerclient/apiclient/auth.py --- 2.6.2-1/ceilometerclient/apiclient/auth.py 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/ceilometerclient/apiclient/auth.py 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,231 @@ +# 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 + +######################################################################## +# +# THIS MODULE IS DEPRECATED +# +# Please refer to +# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for +# the discussion leading to this deprecation. +# +# We recommend checking out the python-openstacksdk project +# (https://launchpad.net/python-openstacksdk) instead. +# +######################################################################## + +import abc +import argparse +import os + +import six +from stevedore import extension + +from ceilometerclient.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 = "ceilometerclient.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 + """ diff -pruN 2.6.2-1/ceilometerclient/apiclient/base.py 2.9.0-6/ceilometerclient/apiclient/base.py --- 2.6.2-1/ceilometerclient/apiclient/base.py 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/ceilometerclient/apiclient/base.py 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,535 @@ +# Copyright 2010 Jacob Kaplan-Moss +# Copyright 2011 OpenStack Foundation +# Copyright 2012 Grid Dynamics +# Copyright 2013 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Base utilities to build API operation managers and objects on top of. +""" + +######################################################################## +# +# THIS MODULE IS DEPRECATED +# +# Please refer to +# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for +# the discussion leading to this deprecation. +# +# We recommend checking out the python-openstacksdk project +# (https://launchpad.net/python-openstacksdk) instead. +# +######################################################################## + + +# E1102: %s is not callable +# pylint: disable=E1102 + +import abc +import copy + +from oslo_utils import reflection +from oslo_utils import strutils +import six +from six.moves.urllib import parse + +from ceilometerclient.apiclient import exceptions +from ceilometerclient.i18n import _ + + +def getid(obj): + """Return id if argument is a Resource. + + Abstracts the common pattern of allowing both an object or an object's ID + (UUID) as a parameter when dealing with relationships. + """ + try: + if obj.uuid: + return obj.uuid + except AttributeError: + pass + try: + return obj.id + except AttributeError: + return obj + + +# TODO(aababilov): call run_hooks() in HookableMixin's child classes +class HookableMixin(object): + """Mixin so classes can register and run hooks.""" + _hooks_map = {} + + @classmethod + def add_hook(cls, hook_type, hook_func): + """Add a new hook of specified type. + + :param cls: class that registers hooks + :param hook_type: hook type, e.g., '__pre_parse_args__' + :param hook_func: hook function + """ + if hook_type not in cls._hooks_map: + cls._hooks_map[hook_type] = [] + + cls._hooks_map[hook_type].append(hook_func) + + @classmethod + def run_hooks(cls, hook_type, *args, **kwargs): + """Run all hooks of specified type. + + :param cls: class that registers hooks + :param hook_type: hook type, e.g., '__pre_parse_args__' + :param args: args to be passed to every hook function + :param kwargs: kwargs to be passed to every hook function + """ + hook_funcs = cls._hooks_map.get(hook_type) or [] + for hook_func in hook_funcs: + hook_func(*args, **kwargs) + + +class BaseManager(HookableMixin): + """Basic manager type providing common operations. + + Managers interact with a particular type of API (servers, flavors, images, + etc.) and provide CRUD operations for them. + """ + resource_class = None + + def __init__(self, client): + """Initializes BaseManager with `client`. + + :param client: instance of BaseClient descendant for HTTP requests + """ + super(BaseManager, self).__init__() + self.client = client + + def _list(self, url, response_key=None, obj_class=None, json=None): + """List the collection. + + :param url: a partial URL, e.g., '/servers' + :param response_key: the key to be looked up in response dictionary, + e.g., 'servers'. If response_key is None - all response body + will be used. + :param obj_class: class for constructing the returned objects + (self.resource_class will be used by default) + :param json: data that will be encoded as JSON and passed in POST + request (GET will be sent by default) + """ + if json: + body = self.client.post(url, json=json).json() + else: + body = self.client.get(url).json() + + if obj_class is None: + obj_class = self.resource_class + + data = body[response_key] if response_key is not None else body + # NOTE(ja): keystone returns values as list as {'values': [ ... ]} + # unlike other services which just return the list... + try: + data = data['values'] + except (KeyError, TypeError): + pass + + return [obj_class(self, res, loaded=True) for res in data if res] + + def _get(self, url, response_key=None): + """Get an object from collection. + + :param url: a partial URL, e.g., '/servers' + :param response_key: the key to be looked up in response dictionary, + e.g., 'server'. If response_key is None - all response body + will be used. + """ + body = self.client.get(url).json() + data = body[response_key] if response_key is not None else body + return self.resource_class(self, data, loaded=True) + + def _head(self, url): + """Retrieve request headers for an object. + + :param url: a partial URL, e.g., '/servers' + """ + resp = self.client.head(url) + return resp.status_code == 204 + + def _post(self, url, json, response_key=None, return_raw=False): + """Create an object. + + :param url: a partial URL, e.g., '/servers' + :param json: data that will be encoded as JSON and passed in POST + request (GET will be sent by default) + :param response_key: the key to be looked up in response dictionary, + e.g., 'server'. If response_key is None - all response body + will be used. + :param return_raw: flag to force returning raw JSON instead of + Python object of self.resource_class + """ + body = self.client.post(url, json=json).json() + data = body[response_key] if response_key is not None else body + if return_raw: + return data + return self.resource_class(self, data) + + def _put(self, url, json=None, response_key=None): + """Update an object with PUT method. + + :param url: a partial URL, e.g., '/servers' + :param json: data that will be encoded as JSON and passed in POST + request (GET will be sent by default) + :param response_key: the key to be looked up in response dictionary, + e.g., 'servers'. If response_key is None - all response body + will be used. + """ + resp = self.client.put(url, json=json) + # PUT requests may not return a body + if resp.content: + body = resp.json() + if response_key is not None: + return self.resource_class(self, body[response_key]) + else: + return self.resource_class(self, body) + + def _patch(self, url, json=None, response_key=None): + """Update an object with PATCH method. + + :param url: a partial URL, e.g., '/servers' + :param json: data that will be encoded as JSON and passed in POST + request (GET will be sent by default) + :param response_key: the key to be looked up in response dictionary, + e.g., 'servers'. If response_key is None - all response body + will be used. + """ + body = self.client.patch(url, json=json).json() + if response_key is not None: + return self.resource_class(self, body[response_key]) + else: + return self.resource_class(self, body) + + def _delete(self, url): + """Delete an object. + + :param url: a partial URL, e.g., '/servers/my-server' + """ + return self.client.delete(url) + + +@six.add_metaclass(abc.ABCMeta) +class ManagerWithFind(BaseManager): + """Manager with additional `find()`/`findall()` methods.""" + + @abc.abstractmethod + def list(self): + pass + + def find(self, **kwargs): + """Find a single item with attributes matching ``**kwargs``. + + This isn't very efficient: it loads the entire list then filters on + the Python side. + """ + matches = self.findall(**kwargs) + num_matches = len(matches) + if num_matches == 0: + msg = _("No %(name)s matching %(args)s.") % { + 'name': self.resource_class.__name__, + 'args': kwargs + } + raise exceptions.NotFound(msg) + elif num_matches > 1: + raise exceptions.NoUniqueMatch() + else: + return matches[0] + + def findall(self, **kwargs): + """Find all items with attributes matching ``**kwargs``. + + This isn't very efficient: it loads the entire list then filters on + the Python side. + """ + found = [] + searches = kwargs.items() + + for obj in self.list(): + try: + if all(getattr(obj, attr) == value + for (attr, value) in searches): + found.append(obj) + except AttributeError: + continue + + return found + + +class CrudManager(BaseManager): + """Base manager class for manipulating entities. + + Children of this class are expected to define a `collection_key` and `key`. + + - `collection_key`: Usually a plural noun by convention (e.g. `entities`); + used to refer collections in both URL's (e.g. `/v3/entities`) and JSON + objects containing a list of member resources (e.g. `{'entities': [{}, + {}, {}]}`). + - `key`: Usually a singular noun by convention (e.g. `entity`); used to + refer to an individual member of the collection. + + """ + collection_key = None + key = None + + def build_url(self, base_url=None, **kwargs): + """Builds a resource URL for the given kwargs. + + Given an example collection where `collection_key = 'entities'` and + `key = 'entity'`, the following URL's could be generated. + + By default, the URL will represent a collection of entities, e.g.:: + + /entities + + If kwargs contains an `entity_id`, then the URL will represent a + specific member, e.g.:: + + /entities/{entity_id} + + :param base_url: if provided, the generated URL will be appended to it + """ + url = base_url if base_url is not None else '' + + url += '/%s' % self.collection_key + + # do we have a specific entity? + entity_id = kwargs.get('%s_id' % self.key) + if entity_id is not None: + url += '/%s' % entity_id + + return url + + def _filter_kwargs(self, kwargs): + """Drop null values and handle ids.""" + for key, ref in six.iteritems(kwargs.copy()): + if ref is None: + kwargs.pop(key) + else: + if isinstance(ref, Resource): + kwargs.pop(key) + kwargs['%s_id' % key] = getid(ref) + return kwargs + + def create(self, **kwargs): + kwargs = self._filter_kwargs(kwargs) + return self._post( + self.build_url(**kwargs), + {self.key: kwargs}, + self.key) + + def get(self, **kwargs): + kwargs = self._filter_kwargs(kwargs) + return self._get( + self.build_url(**kwargs), + self.key) + + def head(self, **kwargs): + kwargs = self._filter_kwargs(kwargs) + return self._head(self.build_url(**kwargs)) + + def list(self, base_url=None, **kwargs): + """List the collection. + + :param base_url: if provided, the generated URL will be appended to it + """ + kwargs = self._filter_kwargs(kwargs) + + return self._list( + '%(base_url)s%(query)s' % { + 'base_url': self.build_url(base_url=base_url, **kwargs), + 'query': '?%s' % parse.urlencode(kwargs) if kwargs else '', + }, + self.collection_key) + + def put(self, base_url=None, **kwargs): + """Update an element. + + :param base_url: if provided, the generated URL will be appended to it + """ + kwargs = self._filter_kwargs(kwargs) + + return self._put(self.build_url(base_url=base_url, **kwargs)) + + def update(self, **kwargs): + kwargs = self._filter_kwargs(kwargs) + params = kwargs.copy() + params.pop('%s_id' % self.key) + + return self._patch( + self.build_url(**kwargs), + {self.key: params}, + self.key) + + def delete(self, **kwargs): + kwargs = self._filter_kwargs(kwargs) + + return self._delete( + self.build_url(**kwargs)) + + def find(self, base_url=None, **kwargs): + """Find a single item with attributes matching ``**kwargs``. + + :param base_url: if provided, the generated URL will be appended to it + """ + kwargs = self._filter_kwargs(kwargs) + + rl = self._list( + '%(base_url)s%(query)s' % { + 'base_url': self.build_url(base_url=base_url, **kwargs), + 'query': '?%s' % parse.urlencode(kwargs) if kwargs else '', + }, + self.collection_key) + num = len(rl) + + if num == 0: + msg = _("No %(name)s matching %(args)s.") % { + 'name': self.resource_class.__name__, + 'args': kwargs + } + raise exceptions.NotFound(404, msg) + elif num > 1: + raise exceptions.NoUniqueMatch + else: + return rl[0] + + +class Extension(HookableMixin): + """Extension descriptor.""" + + SUPPORTED_HOOKS = ('__pre_parse_args__', '__post_parse_args__') + manager_class = None + + def __init__(self, name, module): + super(Extension, self).__init__() + self.name = name + self.module = module + self._parse_extension_module() + + def _parse_extension_module(self): + self.manager_class = None + for attr_name, attr_value in self.module.__dict__.items(): + if attr_name in self.SUPPORTED_HOOKS: + self.add_hook(attr_name, attr_value) + else: + try: + if issubclass(attr_value, BaseManager): + self.manager_class = attr_value + except TypeError: + pass + + def __repr__(self): + return "" % self.name + + +class Resource(object): + """Base class for OpenStack resources (tenant, user, etc.). + + This is pretty much just a bag for attributes. + """ + + HUMAN_ID = False + NAME_ATTR = 'name' + + def __init__(self, manager, info, loaded=False): + """Populate and bind to a manager. + + :param manager: BaseManager object + :param info: dictionary representing resource attributes + :param loaded: prevent lazy-loading if set to True + """ + self.manager = manager + self._info = info + self._add_details(info) + self._loaded = loaded + + def __repr__(self): + reprkeys = sorted(k + for k in self.__dict__.keys() + if k[0] != '_' and k != 'manager') + info = ", ".join("%s=%s" % (k, getattr(self, k)) for k in reprkeys) + self_cls_name = reflection.get_class_name(self, + fully_qualified=False) + return "<%s %s>" % (self_cls_name, info) + + @property + def human_id(self): + """Human-readable ID which can be used for bash completion.""" + if self.HUMAN_ID: + name = getattr(self, self.NAME_ATTR, None) + if name is not None: + return strutils.to_slug(name) + return None + + def _add_details(self, info): + for (k, v) in six.iteritems(info): + try: + setattr(self, k, v) + self._info[k] = v + except AttributeError: + # In this case we already defined the attribute on the class + pass + + def __getattr__(self, k): + if k not in self.__dict__: + # NOTE(bcwaldon): disallow lazy-loading if already loaded once + if not self.is_loaded(): + self.get() + return self.__getattr__(k) + + raise AttributeError(k) + else: + return self.__dict__[k] + + def get(self): + """Support for lazy loading details. + + Some clients, such as novaclient have the option to lazy load the + details, details which can be loaded with this function. + """ + # set_loaded() first ... so if we have to bail, we know we tried. + self.set_loaded(True) + if not hasattr(self.manager, 'get'): + return + + new = self.manager.get(self.id) + if new: + self._add_details(new._info) + self._add_details( + {'x_request_id': self.manager.client.last_request_id}) + + def __eq__(self, other): + if not isinstance(other, Resource): + return NotImplemented + # two resources of different types are not equal + if not isinstance(other, self.__class__): + return False + return self._info == other._info + + def __ne__(self, other): + return not self.__eq__(other) + + def is_loaded(self): + return self._loaded + + def set_loaded(self, val): + self._loaded = val + + def to_dict(self): + return copy.deepcopy(self._info) diff -pruN 2.6.2-1/ceilometerclient/apiclient/client.py 2.9.0-6/ceilometerclient/apiclient/client.py --- 2.6.2-1/ceilometerclient/apiclient/client.py 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/ceilometerclient/apiclient/client.py 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,388 @@ +# Copyright 2010 Jacob Kaplan-Moss +# Copyright 2011 OpenStack Foundation +# Copyright 2011 Piston Cloud Computing, Inc. +# Copyright 2013 Alessio Ababilov +# Copyright 2013 Grid Dynamics +# Copyright 2013 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +OpenStack Client interface. Handles the REST calls and responses. +""" + +# E0202: An attribute inherited from %s hide this method +# pylint: disable=E0202 + +import hashlib +import logging +import time + +try: + import simplejson as json +except ImportError: + import json + +from oslo_utils import encodeutils +from oslo_utils import importutils +import requests + +from ceilometerclient.apiclient import exceptions +from ceilometerclient.i18n import _ + +_logger = logging.getLogger(__name__) +SENSITIVE_HEADERS = ('X-Auth-Token', 'X-Subject-Token',) + + +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 = "ceilometerclient.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 + self.last_request_id = None + + def _safe_header(self, name, value): + if name in SENSITIVE_HEADERS: + # because in python3 byte string handling is ... ug + v = value.encode('utf-8') + h = hashlib.sha1(v) + d = h.hexdigest() + return encodeutils.safe_decode(name), "{SHA1}%s" % d + else: + return (encodeutils.safe_decode(name), + encodeutils.safe_decode(value)) + + def _http_log_req(self, method, url, kwargs): + if not self.debug: + return + + string_parts = [ + "curl -g -i", + "-X '%s'" % method, + "'%s'" % url, + ] + + for element in kwargs['headers']: + header = ("-H '%s: %s'" % + self._safe_header(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["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) + + self.last_request_id = resp.headers.get('x-openstack-request-id') + + 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 + if self.auth_plugin.opts.get('token'): + self.auth_plugin.opts['token'] = None + if self.auth_plugin.opts.get('endpoint'): + self.auth_plugin.opts['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) + + @property + def last_request_id(self): + return self.http_client.last_request_id + + 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) diff -pruN 2.6.2-1/ceilometerclient/apiclient/exceptions.py 2.9.0-6/ceilometerclient/apiclient/exceptions.py --- 2.6.2-1/ceilometerclient/apiclient/exceptions.py 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/ceilometerclient/apiclient/exceptions.py 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,477 @@ +# Copyright 2010 Jacob Kaplan-Moss +# Copyright 2011 Nebula, Inc. +# Copyright 2013 Alessio Ababilov +# Copyright 2013 OpenStack Foundation +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Exception definitions. +""" + +######################################################################## +# +# THIS MODULE IS DEPRECATED +# +# Please refer to +# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for +# the discussion leading to this deprecation. +# +# We recommend checking out the python-openstacksdk project +# (https://launchpad.net/python-openstacksdk) instead. +# +######################################################################## + +import inspect +import sys + +import six + +from ceilometerclient.i18n import _ + + +class ClientException(Exception): + """The base exception class for all exceptions this library raises.""" + pass + + +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 ConnectionError(ClientException): + """Cannot connect to API service.""" + pass + + +class ConnectionRefused(ConnectionError): + """Connection refused while trying to 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 = body.get(list(body)[0]) + if isinstance(error, dict): + kwargs["message"] = (error.get("message") or + error.get("faultstring")) + kwargs["details"] = (error.get("details") or + six.text_type(body)) + 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) diff -pruN 2.6.2-1/ceilometerclient/apiclient/fake_client.py 2.9.0-6/ceilometerclient/apiclient/fake_client.py --- 2.6.2-1/ceilometerclient/apiclient/fake_client.py 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/ceilometerclient/apiclient/fake_client.py 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,190 @@ +# 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. +""" + +######################################################################## +# +# THIS MODULE IS DEPRECATED +# +# Please refer to +# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for +# the discussion leading to this deprecation. +# +# We recommend checking out the python-openstacksdk project +# (https://launchpad.net/python-openstacksdk) instead. +# +######################################################################## + +# W0102: Dangerous default value %s as argument +# pylint: disable=W0102 + +import json + +import requests +import six +from six.moves.urllib import parse + +from ceilometerclient.apiclient import client + + +def assert_has_keys(dct, required=None, optional=None): + required = required or [] + optional = optional or [] + 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 = {} + self.last_request_id = headers.get('x-openstack-request-id', + 'req-test') + return TestResponse({ + "status_code": status, + "text": body, + "headers": headers, + }) diff -pruN 2.6.2-1/ceilometerclient/apiclient/utils.py 2.9.0-6/ceilometerclient/apiclient/utils.py --- 2.6.2-1/ceilometerclient/apiclient/utils.py 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/ceilometerclient/apiclient/utils.py 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,100 @@ +# +# 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. + +######################################################################## +# +# THIS MODULE IS DEPRECATED +# +# Please refer to +# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for +# the discussion leading to this deprecation. +# +# We recommend checking out the python-openstacksdk project +# (https://launchpad.net/python-openstacksdk) instead. +# +######################################################################## + +from oslo_utils import encodeutils +from oslo_utils import uuidutils +import six + +from ceilometerclient.apiclient import exceptions +from ceilometerclient.i18n import _ + + +def find_resource(manager, name_or_id, **find_args): + """Look for resource in a given manager. + + Used as a helper for the _find_* methods. + Example: + + .. code-block:: python + + def _find_hypervisor(cs, hypervisor): + #Get a hypervisor by name or ID. + return cliutils.find_resource(cs.hypervisors, hypervisor) + """ + # first try to get entity as integer id + try: + return manager.get(int(name_or_id)) + except (TypeError, ValueError, exceptions.NotFound): + pass + + # now try to get entity as uuid + try: + if six.PY2: + tmp_id = encodeutils.safe_encode(name_or_id) + else: + tmp_id = encodeutils.safe_decode(name_or_id) + + if uuidutils.is_uuid_like(tmp_id): + return manager.get(tmp_id) + except (TypeError, ValueError, exceptions.NotFound): + pass + + # for str id which is not uuid + if getattr(manager, 'is_alphanum_id_allowed', False): + try: + return manager.get(name_or_id) + except exceptions.NotFound: + pass + + try: + try: + return manager.find(human_id=name_or_id, **find_args) + except exceptions.NotFound: + pass + + # finally try to find entity by name + try: + resource = getattr(manager, 'resource_class', None) + name_attr = resource.NAME_ATTR if resource else 'name' + kwargs = {name_attr: name_or_id} + kwargs.update(find_args) + return manager.find(**kwargs) + except exceptions.NotFound: + msg = _("No %(name)s with a name or " + "ID of '%(name_or_id)s' exists.") % \ + { + "name": manager.resource_class.__name__.lower(), + "name_or_id": name_or_id + } + raise exceptions.CommandError(msg) + except exceptions.NoUniqueMatch: + msg = _("Multiple %(name)s matches found for " + "'%(name_or_id)s', use an ID to be more specific.") % \ + { + "name": manager.resource_class.__name__.lower(), + "name_or_id": name_or_id + } + raise exceptions.CommandError(msg) diff -pruN 2.6.2-1/ceilometerclient/client.py 2.9.0-6/ceilometerclient/client.py --- 2.6.2-1/ceilometerclient/client.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/client.py 2017-06-09 17:39:30.000000000 +0000 @@ -19,14 +19,14 @@ from keystoneauth1 import exceptions as from keystoneauth1.identity import v2 as v2_auth from keystoneauth1.identity import v3 as v3_auth from keystoneauth1 import session +from oslo_utils import importutils from oslo_utils import strutils import six.moves.urllib.parse as urlparse -from ceilometerclient.common import utils +from ceilometerclient.apiclient import auth +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import exceptions from ceilometerclient import exc -from ceilometerclient.openstack.common.apiclient import auth -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import exceptions def _discover_auth_versions(session, auth_url): @@ -87,13 +87,17 @@ def _get_keystone_session(**kwargs): # create the keystone client session ks_session = session.Session(verify=verify, cert=cert, timeout=timeout) v2_auth_url, v3_auth_url = _discover_auth_versions(ks_session, auth_url) - username = kwargs.pop('username', None) user_id = kwargs.pop('user_id', None) user_domain_name = kwargs.pop('user_domain_name', None) user_domain_id = kwargs.pop('user_domain_id', None) project_domain_name = kwargs.pop('project_domain_name', None) project_domain_id = kwargs.pop('project_domain_id', None) + if v3_auth_url: + if not user_domain_name: + user_domain_name = 'Default' + if not project_domain_name: + project_domain_name = 'Default' auth = None use_domain = (user_domain_id or user_domain_name or @@ -288,7 +292,7 @@ def _adjust_kwargs(kwargs): if timeout <= 0: timeout = None - insecure = strutils.bool_from_string(kwargs.get('insecure')) + insecure = strutils.bool_from_string(client_kwargs.get('insecure')) verify = kwargs.get('verify') if verify is None: if insecure: @@ -308,7 +312,8 @@ def _adjust_kwargs(kwargs): def Client(version, *args, **kwargs): client_kwargs = _adjust_kwargs(kwargs) - module = utils.import_versioned_module(version, 'client') + module = importutils.import_versioned_module('ceilometerclient', + version, 'client') client_class = getattr(module, 'Client') return client_class(*args, **client_kwargs) @@ -379,7 +384,7 @@ def get_auth_plugin(endpoint, **kwargs): endpoint=endpoint, username=kwargs.get('username'), password=kwargs.get('password'), - tenant_name=kwargs.get('tenant_name') or kwargs.get('project_name'), + tenant_name=kwargs.get('project_name') or kwargs.get('tenant_name'), user_domain_name=kwargs.get('user_domain_name'), user_domain_id=kwargs.get('user_domain_id'), project_domain_name=kwargs.get('project_domain_name'), @@ -388,7 +393,7 @@ def get_auth_plugin(endpoint, **kwargs): return auth_plugin -LEGACY_OPTS = ('auth_plugin', 'auth_url', 'token', 'insecure', 'cacert', +LEGACY_OPTS = ('auth_plugin', 'auth_url', 'token', 'insecure', 'cacert', 'tenant_id', 'project_id', 'username', 'password', 'project_name', 'tenant_name', 'user_domain_name', 'user_domain_id', @@ -402,8 +407,9 @@ def _construct_http_client(**kwargs): # Drop legacy options for opt in LEGACY_OPTS: kwargs.pop(opt, None) - # Drop aodh_endpoint from kwargs + # Drop redirect endpoints from kwargs kwargs.pop('aodh_endpoint', None) + kwargs.pop('panko_endpoint', None) return SessionClient( session=kwargs.pop('session'), diff -pruN 2.6.2-1/ceilometerclient/common/base.py 2.9.0-6/ceilometerclient/common/base.py --- 2.6.2-1/ceilometerclient/common/base.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/common/base.py 2017-06-09 17:39:30.000000000 +0000 @@ -19,9 +19,9 @@ Base utilities to build API operation ma import copy +from ceilometerclient.apiclient import base +from ceilometerclient.apiclient import exceptions from ceilometerclient import exc -from ceilometerclient.openstack.common.apiclient import base -from ceilometerclient.openstack.common.apiclient import exceptions def getid(obj): diff -pruN 2.6.2-1/ceilometerclient/common/utils.py 2.9.0-6/ceilometerclient/common/utils.py --- 2.6.2-1/ceilometerclient/common/utils.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/common/utils.py 2017-06-09 17:39:30.000000000 +0000 @@ -20,7 +20,6 @@ import textwrap from oslo_serialization import jsonutils from oslo_utils import encodeutils -from oslo_utils import importutils import prettytable import six @@ -140,13 +139,6 @@ def print_dict(d, dict_property="Propert print(encoded) -def import_versioned_module(version, submodule=None): - module = 'ceilometerclient.v%s' % version - if submodule: - module = '.'.join((module, submodule)) - return importutils.import_module(module) - - def args_array_to_dict(kwargs, key_to_convert): values_to_convert = kwargs.get(key_to_convert) if values_to_convert: diff -pruN 2.6.2-1/ceilometerclient/i18n.py 2.9.0-6/ceilometerclient/i18n.py --- 2.6.2-1/ceilometerclient/i18n.py 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/ceilometerclient/i18n.py 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,27 @@ +# Copyright 2014 IBM Corp. +# +# 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='ceilometerclient') + +# The primary translation function using the well-known name "_" +_ = _translators.primary diff -pruN 2.6.2-1/ceilometerclient/openstack/common/apiclient/auth.py 2.9.0-6/ceilometerclient/openstack/common/apiclient/auth.py --- 2.6.2-1/ceilometerclient/openstack/common/apiclient/auth.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/openstack/common/apiclient/auth.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,234 +0,0 @@ -# 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 - -######################################################################## -# -# THIS MODULE IS DEPRECATED -# -# Please refer to -# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for -# the discussion leading to this deprecation. -# -# We recommend checking out the python-openstacksdk project -# (https://launchpad.net/python-openstacksdk) instead. -# -######################################################################## - -import abc -import argparse -import os - -import six -from stevedore import extension - -from ceilometerclient.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 = "ceilometerclient.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 - """ diff -pruN 2.6.2-1/ceilometerclient/openstack/common/apiclient/base.py 2.9.0-6/ceilometerclient/openstack/common/apiclient/base.py --- 2.6.2-1/ceilometerclient/openstack/common/apiclient/base.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/openstack/common/apiclient/base.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,536 +0,0 @@ -# Copyright 2010 Jacob Kaplan-Moss -# Copyright 2011 OpenStack Foundation -# Copyright 2012 Grid Dynamics -# Copyright 2013 OpenStack Foundation -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -""" -Base utilities to build API operation managers and objects on top of. -""" - -######################################################################## -# -# THIS MODULE IS DEPRECATED -# -# Please refer to -# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for -# the discussion leading to this deprecation. -# -# We recommend checking out the python-openstacksdk project -# (https://launchpad.net/python-openstacksdk) instead. -# -######################################################################## - - -# E1102: %s is not callable -# pylint: disable=E1102 - -import abc -import copy - -from oslo_utils import strutils -import six -from six.moves.urllib import parse -from oslo_utils import reflection - -from ceilometerclient.openstack.common._i18n import _ -from ceilometerclient.openstack.common.apiclient import exceptions - - -def getid(obj): - """Return id if argument is a Resource. - - Abstracts the common pattern of allowing both an object or an object's ID - (UUID) as a parameter when dealing with relationships. - """ - try: - if obj.uuid: - return obj.uuid - except AttributeError: - pass - try: - return obj.id - except AttributeError: - return obj - - -# TODO(aababilov): call run_hooks() in HookableMixin's child classes -class HookableMixin(object): - """Mixin so classes can register and run hooks.""" - _hooks_map = {} - - @classmethod - def add_hook(cls, hook_type, hook_func): - """Add a new hook of specified type. - - :param cls: class that registers hooks - :param hook_type: hook type, e.g., '__pre_parse_args__' - :param hook_func: hook function - """ - if hook_type not in cls._hooks_map: - cls._hooks_map[hook_type] = [] - - cls._hooks_map[hook_type].append(hook_func) - - @classmethod - def run_hooks(cls, hook_type, *args, **kwargs): - """Run all hooks of specified type. - - :param cls: class that registers hooks - :param hook_type: hook type, e.g., '__pre_parse_args__' - :param args: args to be passed to every hook function - :param kwargs: kwargs to be passed to every hook function - """ - hook_funcs = cls._hooks_map.get(hook_type) or [] - for hook_func in hook_funcs: - hook_func(*args, **kwargs) - - -class BaseManager(HookableMixin): - """Basic manager type providing common operations. - - Managers interact with a particular type of API (servers, flavors, images, - etc.) and provide CRUD operations for them. - """ - resource_class = None - - def __init__(self, client): - """Initializes BaseManager with `client`. - - :param client: instance of BaseClient descendant for HTTP requests - """ - super(BaseManager, self).__init__() - self.client = client - - def _list(self, url, response_key=None, obj_class=None, json=None): - """List the collection. - - :param url: a partial URL, e.g., '/servers' - :param response_key: the key to be looked up in response dictionary, - e.g., 'servers'. If response_key is None - all response body - will be used. - :param obj_class: class for constructing the returned objects - (self.resource_class will be used by default) - :param json: data that will be encoded as JSON and passed in POST - request (GET will be sent by default) - """ - if json: - body = self.client.post(url, json=json).json() - else: - body = self.client.get(url).json() - - if obj_class is None: - obj_class = self.resource_class - - data = body[response_key] if response_key is not None else body - # NOTE(ja): keystone returns values as list as {'values': [ ... ]} - # unlike other services which just return the list... - try: - data = data['values'] - except (KeyError, TypeError): - pass - - return [obj_class(self, res, loaded=True) for res in data if res] - - def _get(self, url, response_key=None): - """Get an object from collection. - - :param url: a partial URL, e.g., '/servers' - :param response_key: the key to be looked up in response dictionary, - e.g., 'server'. If response_key is None - all response body - will be used. - """ - body = self.client.get(url).json() - data = body[response_key] if response_key is not None else body - return self.resource_class(self, data, loaded=True) - - def _head(self, url): - """Retrieve request headers for an object. - - :param url: a partial URL, e.g., '/servers' - """ - resp = self.client.head(url) - return resp.status_code == 204 - - def _post(self, url, json, response_key=None, return_raw=False): - """Create an object. - - :param url: a partial URL, e.g., '/servers' - :param json: data that will be encoded as JSON and passed in POST - request (GET will be sent by default) - :param response_key: the key to be looked up in response dictionary, - e.g., 'server'. If response_key is None - all response body - will be used. - :param return_raw: flag to force returning raw JSON instead of - Python object of self.resource_class - """ - body = self.client.post(url, json=json).json() - data = body[response_key] if response_key is not None else body - if return_raw: - return data - return self.resource_class(self, data) - - def _put(self, url, json=None, response_key=None): - """Update an object with PUT method. - - :param url: a partial URL, e.g., '/servers' - :param json: data that will be encoded as JSON and passed in POST - request (GET will be sent by default) - :param response_key: the key to be looked up in response dictionary, - e.g., 'servers'. If response_key is None - all response body - will be used. - """ - resp = self.client.put(url, json=json) - # PUT requests may not return a body - if resp.content: - body = resp.json() - if response_key is not None: - return self.resource_class(self, body[response_key]) - else: - return self.resource_class(self, body) - - def _patch(self, url, json=None, response_key=None): - """Update an object with PATCH method. - - :param url: a partial URL, e.g., '/servers' - :param json: data that will be encoded as JSON and passed in POST - request (GET will be sent by default) - :param response_key: the key to be looked up in response dictionary, - e.g., 'servers'. If response_key is None - all response body - will be used. - """ - body = self.client.patch(url, json=json).json() - if response_key is not None: - return self.resource_class(self, body[response_key]) - else: - return self.resource_class(self, body) - - def _delete(self, url): - """Delete an object. - - :param url: a partial URL, e.g., '/servers/my-server' - """ - return self.client.delete(url) - - -@six.add_metaclass(abc.ABCMeta) -class ManagerWithFind(BaseManager): - """Manager with additional `find()`/`findall()` methods.""" - - @abc.abstractmethod - def list(self): - pass - - def find(self, **kwargs): - """Find a single item with attributes matching ``**kwargs``. - - This isn't very efficient: it loads the entire list then filters on - the Python side. - """ - matches = self.findall(**kwargs) - num_matches = len(matches) - if num_matches == 0: - msg = _("No %(name)s matching %(args)s.") % { - 'name': self.resource_class.__name__, - 'args': kwargs - } - raise exceptions.NotFound(msg) - elif num_matches > 1: - raise exceptions.NoUniqueMatch() - else: - return matches[0] - - def findall(self, **kwargs): - """Find all items with attributes matching ``**kwargs``. - - This isn't very efficient: it loads the entire list then filters on - the Python side. - """ - found = [] - searches = kwargs.items() - - for obj in self.list(): - try: - if all(getattr(obj, attr) == value - for (attr, value) in searches): - found.append(obj) - except AttributeError: - continue - - return found - - -class CrudManager(BaseManager): - """Base manager class for manipulating entities. - - Children of this class are expected to define a `collection_key` and `key`. - - - `collection_key`: Usually a plural noun by convention (e.g. `entities`); - used to refer collections in both URL's (e.g. `/v3/entities`) and JSON - objects containing a list of member resources (e.g. `{'entities': [{}, - {}, {}]}`). - - `key`: Usually a singular noun by convention (e.g. `entity`); used to - refer to an individual member of the collection. - - """ - collection_key = None - key = None - - def build_url(self, base_url=None, **kwargs): - """Builds a resource URL for the given kwargs. - - Given an example collection where `collection_key = 'entities'` and - `key = 'entity'`, the following URL's could be generated. - - By default, the URL will represent a collection of entities, e.g.:: - - /entities - - If kwargs contains an `entity_id`, then the URL will represent a - specific member, e.g.:: - - /entities/{entity_id} - - :param base_url: if provided, the generated URL will be appended to it - """ - url = base_url if base_url is not None else '' - - url += '/%s' % self.collection_key - - # do we have a specific entity? - entity_id = kwargs.get('%s_id' % self.key) - if entity_id is not None: - url += '/%s' % entity_id - - return url - - def _filter_kwargs(self, kwargs): - """Drop null values and handle ids.""" - for key, ref in six.iteritems(kwargs.copy()): - if ref is None: - kwargs.pop(key) - else: - if isinstance(ref, Resource): - kwargs.pop(key) - kwargs['%s_id' % key] = getid(ref) - return kwargs - - def create(self, **kwargs): - kwargs = self._filter_kwargs(kwargs) - return self._post( - self.build_url(**kwargs), - {self.key: kwargs}, - self.key) - - def get(self, **kwargs): - kwargs = self._filter_kwargs(kwargs) - return self._get( - self.build_url(**kwargs), - self.key) - - def head(self, **kwargs): - kwargs = self._filter_kwargs(kwargs) - return self._head(self.build_url(**kwargs)) - - def list(self, base_url=None, **kwargs): - """List the collection. - - :param base_url: if provided, the generated URL will be appended to it - """ - kwargs = self._filter_kwargs(kwargs) - - return self._list( - '%(base_url)s%(query)s' % { - 'base_url': self.build_url(base_url=base_url, **kwargs), - 'query': '?%s' % parse.urlencode(kwargs) if kwargs else '', - }, - self.collection_key) - - def put(self, base_url=None, **kwargs): - """Update an element. - - :param base_url: if provided, the generated URL will be appended to it - """ - kwargs = self._filter_kwargs(kwargs) - - return self._put(self.build_url(base_url=base_url, **kwargs)) - - def update(self, **kwargs): - kwargs = self._filter_kwargs(kwargs) - params = kwargs.copy() - params.pop('%s_id' % self.key) - - return self._patch( - self.build_url(**kwargs), - {self.key: params}, - self.key) - - def delete(self, **kwargs): - kwargs = self._filter_kwargs(kwargs) - - return self._delete( - self.build_url(**kwargs)) - - def find(self, base_url=None, **kwargs): - """Find a single item with attributes matching ``**kwargs``. - - :param base_url: if provided, the generated URL will be appended to it - """ - kwargs = self._filter_kwargs(kwargs) - - rl = self._list( - '%(base_url)s%(query)s' % { - 'base_url': self.build_url(base_url=base_url, **kwargs), - 'query': '?%s' % parse.urlencode(kwargs) if kwargs else '', - }, - self.collection_key) - num = len(rl) - - if num == 0: - msg = _("No %(name)s matching %(args)s.") % { - 'name': self.resource_class.__name__, - 'args': kwargs - } - raise exceptions.NotFound(404, msg) - elif num > 1: - raise exceptions.NoUniqueMatch - else: - return rl[0] - - -class Extension(HookableMixin): - """Extension descriptor.""" - - SUPPORTED_HOOKS = ('__pre_parse_args__', '__post_parse_args__') - manager_class = None - - def __init__(self, name, module): - super(Extension, self).__init__() - self.name = name - self.module = module - self._parse_extension_module() - - def _parse_extension_module(self): - self.manager_class = None - for attr_name, attr_value in self.module.__dict__.items(): - if attr_name in self.SUPPORTED_HOOKS: - self.add_hook(attr_name, attr_value) - else: - try: - if issubclass(attr_value, BaseManager): - self.manager_class = attr_value - except TypeError: - pass - - def __repr__(self): - return "" % self.name - - -class Resource(object): - """Base class for OpenStack resources (tenant, user, etc.). - - This is pretty much just a bag for attributes. - """ - - HUMAN_ID = False - NAME_ATTR = 'name' - - def __init__(self, manager, info, loaded=False): - """Populate and bind to a manager. - - :param manager: BaseManager object - :param info: dictionary representing resource attributes - :param loaded: prevent lazy-loading if set to True - """ - self.manager = manager - self._info = info - self._add_details(info) - self._loaded = loaded - - def __repr__(self): - reprkeys = sorted(k - for k in self.__dict__.keys() - if k[0] != '_' and k != 'manager') - info = ", ".join("%s=%s" % (k, getattr(self, k)) for k in reprkeys) - self_cls_name = reflection.get_class_name(self, - fully_qualified=False) - return "<%s %s>" % (self_cls_name, info) - - @property - def human_id(self): - """Human-readable ID which can be used for bash completion. - """ - if self.HUMAN_ID: - name = getattr(self, self.NAME_ATTR, None) - if name is not None: - return strutils.to_slug(name) - return None - - def _add_details(self, info): - for (k, v) in six.iteritems(info): - try: - setattr(self, k, v) - self._info[k] = v - except AttributeError: - # In this case we already defined the attribute on the class - pass - - def __getattr__(self, k): - if k not in self.__dict__: - # NOTE(bcwaldon): disallow lazy-loading if already loaded once - if not self.is_loaded(): - self.get() - return self.__getattr__(k) - - raise AttributeError(k) - else: - return self.__dict__[k] - - def get(self): - """Support for lazy loading details. - - Some clients, such as novaclient have the option to lazy load the - details, details which can be loaded with this function. - """ - # set_loaded() first ... so if we have to bail, we know we tried. - self.set_loaded(True) - if not hasattr(self.manager, 'get'): - return - - new = self.manager.get(self.id) - if new: - self._add_details(new._info) - self._add_details( - {'x_request_id': self.manager.client.last_request_id}) - - def __eq__(self, other): - if not isinstance(other, Resource): - return NotImplemented - # two resources of different types are not equal - if not isinstance(other, self.__class__): - return False - return self._info == other._info - - def __ne__(self, other): - return not self.__eq__(other) - - def is_loaded(self): - return self._loaded - - def set_loaded(self, val): - self._loaded = val - - def to_dict(self): - return copy.deepcopy(self._info) diff -pruN 2.6.2-1/ceilometerclient/openstack/common/apiclient/client.py 2.9.0-6/ceilometerclient/openstack/common/apiclient/client.py --- 2.6.2-1/ceilometerclient/openstack/common/apiclient/client.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/openstack/common/apiclient/client.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,388 +0,0 @@ -# Copyright 2010 Jacob Kaplan-Moss -# Copyright 2011 OpenStack Foundation -# Copyright 2011 Piston Cloud Computing, Inc. -# Copyright 2013 Alessio Ababilov -# Copyright 2013 Grid Dynamics -# Copyright 2013 OpenStack Foundation -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -""" -OpenStack Client interface. Handles the REST calls and responses. -""" - -# E0202: An attribute inherited from %s hide this method -# pylint: disable=E0202 - -import hashlib -import logging -import time - -try: - import simplejson as json -except ImportError: - import json - -from oslo_utils import encodeutils -from oslo_utils import importutils -import requests - -from ceilometerclient.openstack.common._i18n import _ -from ceilometerclient.openstack.common.apiclient import exceptions - -_logger = logging.getLogger(__name__) -SENSITIVE_HEADERS = ('X-Auth-Token', 'X-Subject-Token',) - - -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 = "ceilometerclient.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 - self.last_request_id = None - - def _safe_header(self, name, value): - if name in SENSITIVE_HEADERS: - # because in python3 byte string handling is ... ug - v = value.encode('utf-8') - h = hashlib.sha1(v) - d = h.hexdigest() - return encodeutils.safe_decode(name), "{SHA1}%s" % d - else: - return (encodeutils.safe_decode(name), - encodeutils.safe_decode(value)) - - def _http_log_req(self, method, url, kwargs): - if not self.debug: - return - - string_parts = [ - "curl -g -i", - "-X '%s'" % method, - "'%s'" % url, - ] - - for element in kwargs['headers']: - header = ("-H '%s: %s'" % - self._safe_header(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["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) - - self.last_request_id = resp.headers.get('x-openstack-request-id') - - 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 - if self.auth_plugin.opts.get('token'): - self.auth_plugin.opts['token'] = None - if self.auth_plugin.opts.get('endpoint'): - self.auth_plugin.opts['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) - - @property - def last_request_id(self): - return self.http_client.last_request_id - - 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) diff -pruN 2.6.2-1/ceilometerclient/openstack/common/apiclient/exceptions.py 2.9.0-6/ceilometerclient/openstack/common/apiclient/exceptions.py --- 2.6.2-1/ceilometerclient/openstack/common/apiclient/exceptions.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/openstack/common/apiclient/exceptions.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,479 +0,0 @@ -# Copyright 2010 Jacob Kaplan-Moss -# Copyright 2011 Nebula, Inc. -# Copyright 2013 Alessio Ababilov -# Copyright 2013 OpenStack Foundation -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -""" -Exception definitions. -""" - -######################################################################## -# -# THIS MODULE IS DEPRECATED -# -# Please refer to -# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for -# the discussion leading to this deprecation. -# -# We recommend checking out the python-openstacksdk project -# (https://launchpad.net/python-openstacksdk) instead. -# -######################################################################## - -import inspect -import sys - -import six - -from ceilometerclient.openstack.common._i18n import _ - - -class ClientException(Exception): - """The base exception class for all exceptions this library raises. - """ - pass - - -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 ConnectionError(ClientException): - """Cannot connect to API service.""" - pass - - -class ConnectionRefused(ConnectionError): - """Connection refused while trying to 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 = body.get(list(body)[0]) - if isinstance(error, dict): - kwargs["message"] = (error.get("message") or - error.get("faultstring")) - kwargs["details"] = (error.get("details") or - six.text_type(body)) - 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) diff -pruN 2.6.2-1/ceilometerclient/openstack/common/apiclient/fake_client.py 2.9.0-6/ceilometerclient/openstack/common/apiclient/fake_client.py --- 2.6.2-1/ceilometerclient/openstack/common/apiclient/fake_client.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/openstack/common/apiclient/fake_client.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,190 +0,0 @@ -# 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. -""" - -######################################################################## -# -# THIS MODULE IS DEPRECATED -# -# Please refer to -# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for -# the discussion leading to this deprecation. -# -# We recommend checking out the python-openstacksdk project -# (https://launchpad.net/python-openstacksdk) instead. -# -######################################################################## - -# W0102: Dangerous default value %s as argument -# pylint: disable=W0102 - -import json - -import requests -import six -from six.moves.urllib import parse - -from ceilometerclient.openstack.common.apiclient import client - - -def assert_has_keys(dct, required=None, optional=None): - required = required or [] - optional = optional or [] - for k in required: - try: - assert k in dct - except AssertionError: - extra_keys = set(dct.keys()).difference(set(required + optional)) - raise AssertionError("found unexpected keys: %s" % - list(extra_keys)) - - -class TestResponse(requests.Response): - """Wrap requests.Response and provide a convenient initialization. - """ - - def __init__(self, data): - super(TestResponse, self).__init__() - self._content_consumed = True - if isinstance(data, dict): - self.status_code = data.get('status_code', 200) - # Fake the text attribute to streamline Response creation - text = data.get('text', "") - if isinstance(text, (dict, list)): - self._content = json.dumps(text) - default_headers = { - "Content-Type": "application/json", - } - else: - self._content = text - default_headers = {} - if six.PY3 and isinstance(self._content, six.string_types): - self._content = self._content.encode('utf-8', 'strict') - self.headers = data.get('headers') or default_headers - else: - self.status_code = data - - def __eq__(self, other): - return (self.status_code == other.status_code and - self.headers == other.headers and - self._content == other._content) - - -class FakeHTTPClient(client.HTTPClient): - - def __init__(self, *args, **kwargs): - self.callstack = [] - self.fixtures = kwargs.pop("fixtures", None) or {} - if not args and "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 = {} - self.last_request_id = headers.get('x-openstack-request-id', - 'req-test') - return TestResponse({ - "status_code": status, - "text": body, - "headers": headers, - }) diff -pruN 2.6.2-1/ceilometerclient/openstack/common/apiclient/utils.py 2.9.0-6/ceilometerclient/openstack/common/apiclient/utils.py --- 2.6.2-1/ceilometerclient/openstack/common/apiclient/utils.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/openstack/common/apiclient/utils.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,100 +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. - -######################################################################## -# -# THIS MODULE IS DEPRECATED -# -# Please refer to -# https://etherpad.openstack.org/p/kilo-ceilometerclient-library-proposals for -# the discussion leading to this deprecation. -# -# We recommend checking out the python-openstacksdk project -# (https://launchpad.net/python-openstacksdk) instead. -# -######################################################################## - -from oslo_utils import encodeutils -from oslo_utils import uuidutils -import six - -from ceilometerclient.openstack.common._i18n import _ -from ceilometerclient.openstack.common.apiclient import exceptions - - -def find_resource(manager, name_or_id, **find_args): - """Look for resource in a given manager. - - Used as a helper for the _find_* methods. - Example: - - .. code-block:: python - - def _find_hypervisor(cs, hypervisor): - #Get a hypervisor by name or ID. - return cliutils.find_resource(cs.hypervisors, hypervisor) - """ - # first try to get entity as integer id - try: - return manager.get(int(name_or_id)) - except (TypeError, ValueError, exceptions.NotFound): - pass - - # now try to get entity as uuid - try: - if six.PY2: - tmp_id = encodeutils.safe_encode(name_or_id) - else: - tmp_id = encodeutils.safe_decode(name_or_id) - - if uuidutils.is_uuid_like(tmp_id): - return manager.get(tmp_id) - except (TypeError, ValueError, exceptions.NotFound): - pass - - # for str id which is not uuid - if getattr(manager, 'is_alphanum_id_allowed', False): - try: - return manager.get(name_or_id) - except exceptions.NotFound: - pass - - try: - try: - return manager.find(human_id=name_or_id, **find_args) - except exceptions.NotFound: - pass - - # finally try to find entity by name - try: - resource = getattr(manager, 'resource_class', None) - name_attr = resource.NAME_ATTR if resource else 'name' - kwargs = {name_attr: name_or_id} - kwargs.update(find_args) - return manager.find(**kwargs) - except exceptions.NotFound: - msg = _("No %(name)s with a name or " - "ID of '%(name_or_id)s' exists.") % \ - { - "name": manager.resource_class.__name__.lower(), - "name_or_id": name_or_id - } - raise exceptions.CommandError(msg) - except exceptions.NoUniqueMatch: - msg = _("Multiple %(name)s matches found for " - "'%(name_or_id)s', use an ID to be more specific.") % \ - { - "name": manager.resource_class.__name__.lower(), - "name_or_id": name_or_id - } - raise exceptions.CommandError(msg) diff -pruN 2.6.2-1/ceilometerclient/openstack/common/_i18n.py 2.9.0-6/ceilometerclient/openstack/common/_i18n.py --- 2.6.2-1/ceilometerclient/openstack/common/_i18n.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/openstack/common/_i18n.py 1970-01-01 00:00:00.000000000 +0000 @@ -1,45 +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. - -"""oslo.i18n integration module. - -See http://docs.openstack.org/developer/oslo.i18n/usage.html - -""" - -try: - import oslo_i18n - - # NOTE(dhellmann): This reference to o-s-l-o will be replaced by the - # application name when this module is synced into the separate - # repository. It is OK to have more than one translation function - # using the same domain, since there will still only be one message - # catalog. - _translators = oslo_i18n.TranslatorFactory(domain='ceilometerclient') - - # 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 -except ImportError: - # NOTE(dims): Support for cases where a project wants to use - # code from oslo-incubator, but is not ready to be internationalized - # (like tempest) - _ = _LI = _LW = _LE = _LC = lambda x: x diff -pruN 2.6.2-1/ceilometerclient/shell.py 2.9.0-6/ceilometerclient/shell.py --- 2.6.2-1/ceilometerclient/shell.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/shell.py 2017-06-09 17:39:30.000000000 +0000 @@ -19,8 +19,10 @@ from __future__ import print_function import argparse import logging import sys +import warnings from oslo_utils import encodeutils +from oslo_utils import importutils import six import ceilometerclient @@ -112,22 +114,13 @@ class CeilometerShell(object): self.subcommands = {} subparsers = parser.add_subparsers(metavar='') - submodule = utils.import_versioned_module(version, 'shell') + submodule = importutils.import_versioned_module('ceilometerclient', + version, 'shell') self._find_actions(subparsers, submodule) self._find_actions(subparsers, self) - self._add_bash_completion_subparser(subparsers) return parser - def _add_bash_completion_subparser(self, subparsers): - subparser = subparsers.add_parser( - 'bash_completion', - add_help=False, - formatter_class=HelpFormatter - ) - self.subcommands['bash_completion'] = subparser - subparser.set_defaults(func=self.do_bash_completion) - def _find_actions(self, subparsers, actions_module): for attr in (a for a in dir(actions_module) if a.startswith('do_')): # I prefer to be hypen-separated instead of underscores. @@ -179,16 +172,11 @@ class CeilometerShell(object): # Return parsed args return api_version, subcommand_parser.parse_args(argv) - @staticmethod - def no_project_and_domain_set(args): - if not (args.os_project_id or (args.os_project_name and - (args.os_user_domain_name or args.os_user_domain_id)) or - (args.os_tenant_id or args.os_tenant_name)): - return True - else: - return False - def main(self, argv): + warnings.warn( + "ceilometerclient is now deprecated as the Ceilometer API has " + "been deprecated. Please use either aodhclient, pankoclient or " + "gnocchiclient.") parsed = self.parse_args(argv) if parsed == 0: return 0 @@ -215,17 +203,12 @@ class CeilometerShell(object): "either --os-password or via " "env[OS_PASSWORD]") - if self.no_project_and_domain_set(args): + if not (args.os_project_id or args.os_project_name + or args.os_tenant_id or args.os_tenant_name): # steer users towards Keystone V3 API - raise exc.CommandError("You must provide a project_id via " - "either --os-project-id or via " - "env[OS_PROJECT_ID] and " - "a domain_name via either " - "--os-user-domain-name or via " - "env[OS_USER_DOMAIN_NAME] or " - "a domain_id via either " - "--os-user-domain-id or via " - "env[OS_USER_DOMAIN_ID]") + raise exc.CommandError("You must provide a project_id " + "(or name) via either --os-project-id " + "or via env[OS_PROJECT_ID]") if not self.auth_plugin.opts['auth_url']: raise exc.CommandError("You must provide an auth url via " @@ -255,7 +238,6 @@ class CeilometerShell(object): options.add(option) commands.remove('bash-completion') - commands.remove('bash_completion') print(' '.join(commands | options)) @utils.arg('command', metavar='', nargs='?', diff -pruN 2.6.2-1/ceilometerclient/tests/functional/test_readonly_ceilometer.py 2.9.0-6/ceilometerclient/tests/functional/test_readonly_ceilometer.py --- 2.6.2-1/ceilometerclient/tests/functional/test_readonly_ceilometer.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/functional/test_readonly_ceilometer.py 2017-06-09 17:39:30.000000000 +0000 @@ -63,9 +63,5 @@ class SimpleReadOnlyCeilometerClientTest # Optional arguments - def test_ceilometer_version(self): - version = self.ceilometer('', flags='--version', merge_stderr=True) - self.assertTrue(re.search('^[0-9.]+', version)) - def test_ceilometer_debug_list(self): self.ceilometer('meter-list', flags='--debug') diff -pruN 2.6.2-1/ceilometerclient/tests/unit/test_client.py 2.9.0-6/ceilometerclient/tests/unit/test_client.py --- 2.6.2-1/ceilometerclient/tests/unit/test_client.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/test_client.py 2017-06-09 17:39:30.000000000 +0000 @@ -19,9 +19,9 @@ from keystoneauth1 import session as ks_ import mock import requests +from ceilometerclient.apiclient import exceptions from ceilometerclient import client from ceilometerclient import exc -from ceilometerclient.openstack.common.apiclient import exceptions from ceilometerclient.tests.unit import utils from ceilometerclient.v2 import client as v2client @@ -43,8 +43,9 @@ class ClientTest(utils.BaseTestCase): def create_client(env, api_version=2, endpoint=None, exclude=[]): env = dict((k, v) for k, v in env.items() if k not in exclude) - with mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None): + with mock.patch( + 'ceilometerclient.v2.client.Client._get_redirect_client', + return_value=None): return client.get_client(api_version, **env) def test_client_v2_with_session(self): @@ -132,7 +133,7 @@ class ClientTest(utils.BaseTestCase): 'user_agent': None, 'debug': None, } - cls = 'ceilometerclient.openstack.common.apiclient.client.HTTPClient' + cls = 'ceilometerclient.apiclient.client.HTTPClient' with mock.patch(cls) as mocked: self.create_client(env) mocked.assert_called_with(**expected) @@ -173,7 +174,7 @@ class ClientTest(utils.BaseTestCase): def test_v2_client_insecure(self): env = FAKE_ENV.copy() env.pop('auth_plugin') - env['insecure'] = 'True' + env['os_insecure'] = 'True' client = self.create_client(env) self.assertIn('insecure', client.auth_plugin.opts) self.assertEqual('True', client.auth_plugin.opts['insecure']) @@ -184,8 +185,9 @@ class ClientTest2(ClientTest): def create_client(env, api_version=2, endpoint=None, exclude=[]): env = dict((k, v) for k, v in env.items() if k not in exclude) - with mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None): + with mock.patch( + 'ceilometerclient.v2.client.Client._get_redirect_client', + return_value=None): return client.Client(api_version, endpoint, **env) @@ -194,7 +196,7 @@ class ClientTestWithAodh(ClientTest): def create_client(env, api_version=2, endpoint=None, exclude=[]): env = dict((k, v) for k, v in env.items() if k not in exclude) - with mock.patch('ceilometerclient.openstack.common.apiclient.client.' + with mock.patch('ceilometerclient.apiclient.client.' 'HTTPClient.client_request', return_value=mock.MagicMock()): return client.get_client(api_version, **env) @@ -219,7 +221,7 @@ class ClientTestWithAodh(ClientTest): def test_ceilometerclient_available_without_aodh_services_running(self): env = FAKE_ENV.copy() env.pop('auth_plugin', None) - with mock.patch('ceilometerclient.openstack.common.apiclient.client.' + with mock.patch('ceilometerclient.apiclient.client.' 'HTTPClient.client_request') as mocked_request: mocked_request.side_effect = requests.exceptions.ConnectionError ceiloclient = client.get_client(2, **env) @@ -250,7 +252,7 @@ class ClientAuthTest(utils.BaseTestCase) def create_client(env, api_version=2, endpoint=None, exclude=[]): env = dict((k, v) for k, v in env.items() if k not in exclude) - with mock.patch('ceilometerclient.openstack.common.apiclient.client.' + with mock.patch('ceilometerclient.apiclient.client.' 'HTTPClient.client_request', return_value=mock.MagicMock()): return client.get_client(api_version, **env) diff -pruN 2.6.2-1/ceilometerclient/tests/unit/test_shell.py 2.9.0-6/ceilometerclient/tests/unit/test_shell.py --- 2.6.2-1/ceilometerclient/tests/unit/test_shell.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/test_shell.py 2017-06-09 17:39:30.000000000 +0000 @@ -19,9 +19,9 @@ import mock import six from testtools import matchers +from ceilometerclient.apiclient import client as api_client from ceilometerclient import client from ceilometerclient import exc -from ceilometerclient.openstack.common.apiclient import client as api_client from ceilometerclient import shell as ceilometer_shell from ceilometerclient.tests.unit import utils @@ -112,18 +112,18 @@ class ShellBashCompletionTest(ShellTestB class ShellKeystoneV2Test(ShellTestBase): @mock.patch.object(ks_session, 'Session') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_debug_switch_raises_error(self, get_alarm_client, mock_ksclient): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_debug_switch_raises_error(self, mock_ksclient): mock_ksclient.side_effect = exc.HTTPUnauthorized self.make_env(FAKE_V2_ENV) args = ['--debug', 'event-list'] self.assertRaises(exc.CommandError, ceilometer_shell.main, args) @mock.patch.object(ks_session, 'Session') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_dash_d_switch_raises_error(self, get_alarm_client, mock_ksclient): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_dash_d_switch_raises_error(self, mock_ksclient): mock_ksclient.side_effect = exc.CommandError("FAIL") self.make_env(FAKE_V2_ENV) args = ['-d', 'event-list'] @@ -141,9 +141,9 @@ class ShellKeystoneV2Test(ShellTestBase) class ShellKeystoneV3Test(ShellTestBase): @mock.patch.object(ks_session, 'Session') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_debug_switch_raises_error(self, get_alarm_client, mock_ksclient): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_debug_switch_raises_error(self, mock_ksclient): mock_ksclient.side_effect = exc.HTTPUnauthorized self.make_env(FAKE_V3_ENV) args = ['--debug', 'event-list'] @@ -194,9 +194,9 @@ class ShellTimeoutTest(ShellTestBase): self._test_timeout('0', expected_msg) @mock.patch.object(ks_session, 'Session') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_timeout_keystone_session(self, get_alarm_client, mocked_session): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_timeout_keystone_session(self, mocked_session): mocked_session.side_effect = exc.HTTPUnauthorized("FAIL") self.make_env(FAKE_V2_ENV) args = ['--debug', '--timeout', '5', 'alarm-list'] @@ -208,9 +208,9 @@ class ShellTimeoutTest(ShellTestBase): class ShellInsecureTest(ShellTestBase): @mock.patch.object(api_client, 'HTTPClient') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_insecure_true_ceilometer(self, get_alarm_client, mocked_client): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_insecure_true_ceilometer(self, mocked_client): self.make_env(FAKE_V2_ENV) args = ['--debug', '--os-insecure', 'true', 'alarm-list'] self.assertIsNone(ceilometer_shell.main(args)) @@ -218,9 +218,9 @@ class ShellInsecureTest(ShellTestBase): self.assertFalse(kwargs.get('verify')) @mock.patch.object(ks_session, 'Session') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_insecure_true_keystone(self, get_alarm_client, mocked_session): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_insecure_true_keystone(self, mocked_session): mocked_session.side_effect = exc.HTTPUnauthorized("FAIL") self.make_env(FAKE_V2_ENV) args = ['--debug', '--os-insecure', 'true', 'alarm-list'] @@ -229,9 +229,9 @@ class ShellInsecureTest(ShellTestBase): self.assertFalse(kwargs.get('verify')) @mock.patch.object(api_client, 'HTTPClient') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_insecure_false_ceilometer(self, get_alarm_client, mocked_client): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_insecure_false_ceilometer(self, mocked_client): self.make_env(FAKE_V2_ENV) args = ['--debug', '--os-insecure', 'false', 'alarm-list'] self.assertIsNone(ceilometer_shell.main(args)) @@ -239,9 +239,9 @@ class ShellInsecureTest(ShellTestBase): self.assertTrue(kwargs.get('verify')) @mock.patch.object(ks_session, 'Session') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', - return_value=None) - def test_insecure_false_keystone(self, get_alarm_client, mocked_session): + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', + mock.Mock(return_value=None)) + def test_insecure_false_keystone(self, mocked_session): mocked_session.side_effect = exc.HTTPUnauthorized("FAIL") self.make_env(FAKE_V2_ENV) args = ['--debug', '--os-insecure', 'false', 'alarm-list'] @@ -270,7 +270,7 @@ class ShellEndpointTest(ShellTestBase): class ShellAlarmUpdateRepeatAction(ShellTestBase): @mock.patch('ceilometerclient.v2.alarms.AlarmManager.update') - @mock.patch('ceilometerclient.v2.client.Client._get_alarm_client', + @mock.patch('ceilometerclient.v2.client.Client._get_redirect_client', mock.Mock()) def test_repeat_action_not_specified(self, mocked): self.make_env(FAKE_V2_ENV) @@ -279,7 +279,7 @@ class ShellAlarmUpdateRepeatAction(Shell args = ['--debug', method, '--state', 'alarm', '123'] ceilometer_shell.main(args) args, kwargs = mocked.call_args - self.assertEqual(None, kwargs.get('repeat_actions')) + self.assertIsNone(kwargs.get('repeat_actions')) _test('alarm-update') _test('alarm-threshold-update') diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_alarms.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_alarms.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_alarms.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_alarms.py 2017-06-09 17:39:30.000000000 +0000 @@ -19,9 +19,9 @@ import six from six.moves import xrange # noqa import testtools +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient import exc -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client from ceilometerclient.v2 import alarms AN_ALARM = {u'alarm_actions': [u'http://site:8000/alarm'], @@ -400,7 +400,7 @@ class AlarmManagerTest(testtools.TestCas alarm = self.mgr.update(alarm_id='unk-alarm-id', **UPDATE_ALARM) except exc.CommandError: pass - self.assertEqual(alarm, None) + self.assertIsNone(alarm) def test_delete_from_alarm_class(self): alarm = self.mgr.get(alarm_id='alarm-id') diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_capabilities.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_capabilities.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_capabilities.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_capabilities.py 2017-06-09 17:39:30.000000000 +0000 @@ -14,8 +14,8 @@ import testtools -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.v2 import capabilities diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_events.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_events.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_events.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_events.py 2017-06-09 17:39:30.000000000 +0000 @@ -11,8 +11,8 @@ # 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 ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils import ceilometerclient.v2.events diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_event_types.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_event_types.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_event_types.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_event_types.py 2017-06-09 17:39:30.000000000 +0000 @@ -13,8 +13,8 @@ # under the License. -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils import ceilometerclient.v2.event_types diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_query_alarm_history.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_query_alarm_history.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_query_alarm_history.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_query_alarm_history.py 2017-06-09 17:39:30.000000000 +0000 @@ -12,8 +12,8 @@ # License for the specific language governing permissions and limitations # under the License. -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils from ceilometerclient.v2 import query diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_query_alarms.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_query_alarms.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_query_alarms.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_query_alarms.py 2017-06-09 17:39:30.000000000 +0000 @@ -12,8 +12,8 @@ # License for the specific language governing permissions and limitations # under the License. -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils from ceilometerclient.v2 import query diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_query_samples.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_query_samples.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_query_samples.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_query_samples.py 2017-06-09 17:39:30.000000000 +0000 @@ -12,8 +12,8 @@ # License for the specific language governing permissions and limitations # under the License. -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils from ceilometerclient.v2 import query diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_resources.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_resources.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_resources.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_resources.py 2017-06-09 17:39:30.000000000 +0000 @@ -12,8 +12,8 @@ # 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 ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils import ceilometerclient.v2.resources diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_samples.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_samples.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_samples.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_samples.py 2017-06-09 17:39:30.000000000 +0000 @@ -15,8 +15,8 @@ import copy -from ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils import ceilometerclient.v2.samples diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_shell.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_shell.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_shell.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_shell.py 2017-06-09 17:39:30.000000000 +0000 @@ -651,7 +651,7 @@ class ShellAlarmGnocchiCommandTest(test_ def _test_alarm_gnocchi_resources_arguments(self, action, argv): self.make_env(test_shell.FAKE_V2_ENV) with mock.patch.object(alarms.AlarmManager, action) as mocked: - with mock.patch('ceilometerclient.openstack.common.apiclient.' + with mock.patch('ceilometerclient.apiclient.' 'client.HTTPClient.client_request') as request: request.site_effect = exceptions.EndpointNotFound base_shell.main(argv) @@ -673,7 +673,7 @@ class ShellAlarmGnocchiCommandTest(test_ def _test_alarm_gnocchi_aggr_by_metrics_arguments(self, action, argv): self.make_env(test_shell.FAKE_V2_ENV) with mock.patch.object(alarms.AlarmManager, action) as mocked: - with mock.patch('ceilometerclient.openstack.common.apiclient.' + with mock.patch('ceilometerclient.apiclient.' 'client.HTTPClient.client_request') as request: request.site_effect = exceptions.EndpointNotFound base_shell.main(argv) @@ -695,7 +695,7 @@ class ShellAlarmGnocchiCommandTest(test_ def _test_alarm_gnocchi_aggr_by_resources_arguments(self, action, argv): self.make_env(test_shell.FAKE_V2_ENV) with mock.patch.object(alarms.AlarmManager, action) as mocked: - with mock.patch('ceilometerclient.openstack.common.apiclient.' + with mock.patch('ceilometerclient.apiclient.' 'client.HTTPClient.client_request') as request: request.site_effect = exceptions.EndpointNotFound base_shell.main(argv) @@ -1633,7 +1633,7 @@ class ShellShadowedArgsTest(test_shell.S '--user-id', 'the-user-id-i-want-to-set', '--name', 'project-id-test'] + args with mock.patch.object(alarms.AlarmManager, method) as mocked: - with mock.patch('ceilometerclient.openstack.common.apiclient.' + with mock.patch('ceilometerclient.apiclient.' 'client.HTTPClient.client_request') as request: request.site_effect = exceptions.EndpointNotFound base_shell.main(cli_args) @@ -1724,7 +1724,7 @@ class ShellShadowedArgsTest(test_shell.S '--meter-unit', 'ns', '--sample-volume', '10086', ] - with mock.patch('ceilometerclient.openstack.common.apiclient.client.' + with mock.patch('ceilometerclient.apiclient.client.' 'HTTPClient.client_request') as client_request: client_request.site_effect = exceptions.EndpointNotFound base_shell.main(cli_args) diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_statistics.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_statistics.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_statistics.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_statistics.py 2017-06-09 17:39:30.000000000 +0000 @@ -12,8 +12,8 @@ # 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 ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils import ceilometerclient.v2.statistics diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_trait_descriptions.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_trait_descriptions.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_trait_descriptions.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_trait_descriptions.py 2017-06-09 17:39:30.000000000 +0000 @@ -11,8 +11,8 @@ # 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 ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils import ceilometerclient.v2.trait_descriptions diff -pruN 2.6.2-1/ceilometerclient/tests/unit/v2/test_traits.py 2.9.0-6/ceilometerclient/tests/unit/v2/test_traits.py --- 2.6.2-1/ceilometerclient/tests/unit/v2/test_traits.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/tests/unit/v2/test_traits.py 2017-06-09 17:39:30.000000000 +0000 @@ -11,8 +11,8 @@ # 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 ceilometerclient.openstack.common.apiclient import client -from ceilometerclient.openstack.common.apiclient import fake_client +from ceilometerclient.apiclient import client +from ceilometerclient.apiclient import fake_client from ceilometerclient.tests.unit import utils import ceilometerclient.v2.traits diff -pruN 2.6.2-1/ceilometerclient/v2/alarms.py 2.9.0-6/ceilometerclient/v2/alarms.py --- 2.6.2-1/ceilometerclient/v2/alarms.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/v2/alarms.py 2017-06-09 17:39:30.000000000 +0000 @@ -70,13 +70,7 @@ class AlarmChange(base.Resource): class AlarmManager(base.Manager): resource_class = Alarm - def __init__(self, api, aodh_enabled=False): - self.aodh_enabled = aodh_enabled - super(AlarmManager, self).__init__(api) - def _path(self, id=None): - # TODO(liusheng) if aodh will only have v1 api, we need to change - # following path if aodh enabled (self.aodh_enabled) return '/v2/alarms/%s' % id if id else '/v2/alarms' def list(self, q=None): diff -pruN 2.6.2-1/ceilometerclient/v2/client.py 2.9.0-6/ceilometerclient/v2/client.py --- 2.6.2-1/ceilometerclient/v2/client.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/v2/client.py 2017-06-09 17:39:30.000000000 +0000 @@ -62,21 +62,28 @@ class Client(object): self.auth_plugin = kwargs.get('auth_plugin') self.http_client = ceiloclient._construct_http_client(**kwargs) - self.alarm_client = self._get_alarm_client(**kwargs) + self.alarm_client = self._get_redirect_client( + 'alarming', 'aodh', **kwargs) aodh_enabled = self.alarm_client is not None if not aodh_enabled: self.alarm_client = self.http_client + self.event_client = self._get_redirect_client( + 'event', 'panko', **kwargs) + panko_enabled = self.event_client is not None + if not panko_enabled: + self.event_client = self.http_client + self.meters = meters.MeterManager(self.http_client) self.samples = samples.OldSampleManager(self.http_client) self.new_samples = samples.SampleManager(self.http_client) self.statistics = statistics.StatisticsManager(self.http_client) self.resources = resources.ResourceManager(self.http_client) - self.alarms = alarms.AlarmManager(self.alarm_client, aodh_enabled) - self.events = events.EventManager(self.http_client) - self.event_types = event_types.EventTypeManager(self.http_client) - self.traits = traits.TraitManager(self.http_client) + self.alarms = alarms.AlarmManager(self.alarm_client) + self.events = events.EventManager(self.event_client) + self.event_types = event_types.EventTypeManager(self.event_client) + self.traits = traits.TraitManager(self.event_client) self.trait_descriptions = trait_descriptions.\ - TraitDescriptionManager(self.http_client) + TraitDescriptionManager(self.event_client) self.query_samples = query.QuerySamplesManager( self.http_client) @@ -86,36 +93,36 @@ class Client(object): self.capabilities = capabilities.CapabilitiesManager(self.http_client) @staticmethod - def _get_alarm_client(**ceilo_kwargs): - """Get client for alarm manager that redirect to aodh.""" + def _get_redirect_client(new_service_type, new_service, **ceilo_kwargs): + """Get client for new service manager to redirect to.""" # NOTE(sileht): the auth_plugin/keystone session cannot be copied # because they rely on threading module. auth_plugin = ceilo_kwargs.pop('auth_plugin', None) session = ceilo_kwargs.pop('session', None) kwargs = copy.deepcopy(ceilo_kwargs) - kwargs["service_type"] = "alarming" - aodh_endpoint = ceilo_kwargs.get('aodh_endpoint') + kwargs["service_type"] = new_service_type + endpoint = ceilo_kwargs.get('%s_endpoint' % new_service) if session: # keystone session can be shared between client ceilo_kwargs['session'] = kwargs['session'] = session - if aodh_endpoint: - kwargs['endpoint_override'] = aodh_endpoint + if endpoint: + kwargs['endpoint_override'] = endpoint elif auth_plugin and kwargs.get('auth_url'): ceilo_kwargs['auth_plugin'] = auth_plugin kwargs.pop('endpoint', None) kwargs['auth_plugin'] = ceiloclient.get_auth_plugin( - aodh_endpoint, **kwargs) + endpoint, **kwargs) else: # Users may just provide ceilometer endpoint and token, and no # auth_url, in this case, we need 'aodh_endpoint' also to be # provided, otherwise we cannot get aodh endpoint from - # keystone, and assume aodh is unavailable. + # keystone, and assume aodh is unavailable. Same applies to panko. return None try: - # NOTE(sileht): try to use aodh + # NOTE(sileht): try to use redirect c = ceiloclient._construct_http_client(**kwargs) c.get("/") return c diff -pruN 2.6.2-1/ceilometerclient/v2/shell.py 2.9.0-6/ceilometerclient/v2/shell.py --- 2.6.2-1/ceilometerclient/v2/shell.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/ceilometerclient/v2/shell.py 2017-06-09 17:39:30.000000000 +0000 @@ -1,5 +1,5 @@ # -# Copyright 2013 Red Hat, Inc +# Copyright 2013-2016 Red Hat, Inc # Copyright Ericsson AB 2014. All rights reserved # # Licensed under the Apache License, Version 2.0 (the "License"); you may @@ -17,6 +17,7 @@ import argparse import functools import json +import warnings from oslo_serialization import jsonutils from oslo_utils import strutils @@ -396,6 +397,7 @@ def alarm_change_detail_formatter(change 'but if supplied must be string, integer, float, or boolean.') def do_alarm_list(cc, args={}): """List the user's alarms.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") alarms = cc.alarms.list(q=options.cli_to_array(args.query)) _display_alarm_list(alarms, sortby=0) @@ -440,6 +442,7 @@ def _display_alarm(alarm): action=NotEmptyAction, help='ID of the alarm to show.') def do_alarm_show(cc, args={}): """Show an alarm.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") alarm = cc.alarms.get(args.alarm_id) # alarm.get actually catches the HTTPNotFound exception and turns the # result into None if the alarm wasn't found. @@ -633,6 +636,7 @@ def common_alarm_event_arguments(): @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_create(cc, args={}): """Create a new alarm (Deprecated). Use alarm-threshold-create instead.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, "time_constraints") fields = utils.args_array_to_dict(fields, "matching_metadata") @@ -648,6 +652,7 @@ def do_alarm_create(cc, args={}): @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_gnocchi_resources_threshold_create(cc, args={}): """Create a new alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -664,6 +669,7 @@ def do_alarm_gnocchi_resources_threshold @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_gnocchi_aggregation_by_metrics_threshold_create(cc, args={}): """Create a new alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -680,6 +686,7 @@ def do_alarm_gnocchi_aggregation_by_metr @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_gnocchi_aggregation_by_resources_threshold_create(cc, args={}): """Create a new alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -716,6 +723,7 @@ def do_alarm_gnocchi_aggregation_by_reso @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_threshold_create(cc, args={}): """Create a new alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -739,6 +747,7 @@ def do_alarm_threshold_create(cc, args={ @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_combination_create(cc, args={}): """Create a new alarm based on state of other alarms.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -753,6 +762,7 @@ def do_alarm_combination_create(cc, args @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_event_create(cc, args={}): """Create a new alarm based on events.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: x[1] is not None, vars(args).items())) fields = utils.key_with_slash_to_nested_dict(fields) fields['type'] = 'event' @@ -795,6 +805,7 @@ def do_alarm_event_create(cc, args={}): @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_update(cc, args={}): """Update an existing alarm (Deprecated).""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, "time_constraints") fields = utils.args_array_to_dict(fields, "matching_metadata") @@ -844,6 +855,7 @@ def do_alarm_update(cc, args={}): @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_threshold_update(cc, args={}): """Update an existing alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -875,6 +887,7 @@ def do_alarm_threshold_update(cc, args={ @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_gnocchi_resources_threshold_update(cc, args={}): """Update an existing alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -904,6 +917,7 @@ def do_alarm_gnocchi_resources_threshold @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_gnocchi_aggregation_by_metrics_threshold_update(cc, args={}): """Update an existing alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -933,6 +947,7 @@ def do_alarm_gnocchi_aggregation_by_metr @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_gnocchi_aggregation_by_resources_threshold_update(cc, args={}): """Update an existing alarm based on computed statistics.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -966,6 +981,7 @@ def do_alarm_gnocchi_aggregation_by_reso @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_combination_update(cc, args={}): """Update an existing alarm based on state of other alarms.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: not (x[1] is None), vars(args).items())) fields = utils.args_array_to_list_of_dicts(fields, 'time_constraints') fields = utils.key_with_slash_to_nested_dict(fields) @@ -989,6 +1005,7 @@ def do_alarm_combination_update(cc, args @_restore_shadowed_arg('user_id', 'alarm_user_id') def do_alarm_event_update(cc, args={}): """Update an existing alarm based on events.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") fields = dict(filter(lambda x: x[1] is not None, vars(args).items())) fields = utils.key_with_slash_to_nested_dict(fields) fields.pop('alarm_id') @@ -1010,6 +1027,7 @@ def do_alarm_event_update(cc, args={}): action=NotEmptyAction, help='ID of the alarm to delete.') def do_alarm_delete(cc, args={}): """Delete an alarm.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") try: cc.alarms.delete(args.alarm_id) except exc.HTTPNotFound: @@ -1026,6 +1044,7 @@ def do_alarm_delete(cc, args={}): '.') def do_alarm_state_set(cc, args={}): """Set the state of an alarm.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") try: state = cc.alarms.set_state(args.alarm_id, args.state) except exc.HTTPNotFound: @@ -1040,6 +1059,7 @@ def do_alarm_state_set(cc, args={}): action=NotEmptyAction, help='ID of the alarm state to show.') def do_alarm_state_get(cc, args={}): """Get the state of an alarm.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") try: state = cc.alarms.get_state(args.alarm_id) except exc.HTTPNotFound: @@ -1057,6 +1077,7 @@ def do_alarm_state_get(cc, args={}): 'but if supplied must be string, integer, float, or boolean.') def do_alarm_history(cc, args={}): """Display the change history of an alarm.""" + warnings.warn("Alarm commands are deprecated, please use aodhclient") kwargs = dict(alarm_id=args.alarm_id, q=options.cli_to_array(args.query)) try: diff -pruN 2.6.2-1/debian/changelog 2.9.0-6/debian/changelog --- 2.6.2-1/debian/changelog 2016-12-28 22:53:11.000000000 +0000 +++ 2.9.0-6/debian/changelog 2020-04-24 17:12:04.000000000 +0000 @@ -1,43 +1,68 @@ -python-ceilometerclient (2.6.2-1) unstable; urgency=medium +python-ceilometerclient (2.9.0-6) unstable; urgency=medium - * Team upload. - * New upstream release - * Bumped debhelper compat version to 10 + [ Ondřej Nový ] + * Bump Standards-Version to 4.4.1. - -- Ondřej Nový Wed, 28 Dec 2016 23:53:11 +0100 + [ Michal Arbet ] + * d/copyright: Add me + * d/control: Add me to uploaders field + * Rebuild with newest oslosphinx (Closes: #955091) -python-ceilometerclient (2.6.1-2) unstable; urgency=medium + -- Michal Arbet Fri, 24 Apr 2020 19:12:04 +0200 - [ Ondřej Nový ] - * d/s/options: extend-diff-ignore of .gitreview - * d/control: Use correct branch in Vcs-* fields +python-ceilometerclient (2.9.0-5) unstable; urgency=medium [ Thomas Goirand ] + * Removed Python 2 support (Closes: #936079). + * Add do-not-call-execfile.patch. + + [ Ondřej Nový ] + * d/control: Set Vcs-* to salsa.debian.org + * Running wrap-and-sort -bast. + * Use 'python3 -m sphinx' instead of sphinx-build for building docs. + * Bump Standards-Version to 4.4.0. + * Fix autopkgtests after Python 2 remove. + * d/tests: Use AUTOPKGTEST_TMP instead of ADTTMP + * d/control: Use team+openstack@tracker.debian.org as maintainer + * Running wrap-and-sort -bast. + * Use debhelper-compat instead of debian/compat. + + -- Thomas Goirand Sun, 01 Sep 2019 16:30:24 +0200 + +python-ceilometerclient (2.9.0-2) unstable; urgency=medium + * Uploading to unstable. - -- Thomas Goirand Tue, 04 Oct 2016 10:35:28 +0200 + -- Thomas Goirand Wed, 01 Nov 2017 23:46:43 +0000 -python-ceilometerclient (2.6.1-1) experimental; urgency=medium +python-ceilometerclient (2.9.0-1) experimental; urgency=medium [ Ondřej Nový ] * Standards-Version is 3.9.8 now (no change) * Change directory to $ADTTMP before running Debian tests * d/copyright: Changed source URL to https protocol - [ Corey Bryant ] - * New upstream release. - * .gitreview: Copy from orig tar file. - * d/gbp.conf: Update debian-branch for Newton. - * d/control: Align (Build-)Depends with upstream. - * ceilometerclient/v2/client.py: Copy from orig tar file. + [ Daniel Baumann ] + * Updating vcs fields. + * Updating copyright format url. + * Running wrap-and-sort -bast. + * Updating maintainer field. + * Updating standards version to 4.0.0. + * Removing gbp.conf, not used anymore or should be specified in the + developers dotfiles. + * Correcting permissions in debian packaging files. + * Updating standards version to 4.0.1. + * Deprecating priority extra as per policy 4.0.1. + * Updating standards version to 4.1.0. [ Thomas Goirand ] * New upstream release. - * Using pkgos-dh_auto_{install,test} from openstack-pkg-tools >= 52~. - * Using OpenStack's Gerrit as VCS URLs. - * d/p/skip-tests.patch: deleted. + * Fixed (build-)depends for this release. + * Using pkgos-dh_auto_install. + * Remove test patch. + * Removed XS-Testsuite: field. - -- Thomas Goirand Tue, 13 Sep 2016 09:48:32 +0200 + -- Thomas Goirand Wed, 04 Oct 2017 19:31:50 +0200 python-ceilometerclient (2.4.0-2) unstable; urgency=medium diff -pruN 2.6.2-1/debian/compat 2.9.0-6/debian/compat --- 2.6.2-1/debian/compat 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/compat 1970-01-01 00:00:00.000000000 +0000 @@ -1 +0,0 @@ -10 diff -pruN 2.6.2-1/debian/control 2.9.0-6/debian/control --- 2.6.2-1/debian/control 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/control 2020-04-24 17:11:42.000000000 +0000 @@ -1,75 +1,51 @@ Source: python-ceilometerclient Section: python -Priority: extra -Maintainer: PKG OpenStack -Uploaders: Thomas Goirand , - Corey Bryant , -Build-Depends: debhelper (>= 10), - dh-python, - openstack-pkg-tools (>= 52~), - python-all, - python-pbr (>= 1.8), - python-setuptools, - python-sphinx, - python3-all, - python3-pbr (>= 1.8), - python3-setuptools, -Build-Depends-Indep: python-coverage, - python-fixtures, - python-iso8601, - python-keystoneclient (>= 1:1.6.0), - python-mock, - python-oslo.i18n (>= 2.1.0), - python-oslo.serialization (>= 1.10.0), - python-oslo.utils (>= 3.5.0), - python-oslosphinx (>= 2.5.0), - python-prettytable, - python-requests (>= 2.8.1), - python-six (>= 1.9.0), - python-stevedore (>= 1.10.0), - python-tempest (>= 1:11.0.0), - python-testtools, - python-keystoneauth1 (>= 2.1.0), - python3-fixtures, - python3-iso8601, - python3-keystoneclient (>= 1:1.6.0), - python3-mock, - python3-oslo.i18n (>= 2.1.0), - python3-oslo.serialization (>= 1.10.0), - python3-oslo.utils (>= 3.5.0), - python3-prettytable, - python3-requests (>= 2.8.1), - python3-six (>= 1.9.0), - python3-stevedore (>= 1.10.0), - python3-subunit, - python3-tempest (>= 1:11.0.0), - python3-testtools, - python3-keystoneauth1 (>= 2.1.0), - subunit, - testrepository, -Standards-Version: 3.9.8 -Vcs-Browser: https://git.openstack.org/cgit/openstack/deb-python-ceilometerclient?h=debian%2Fnewton -Vcs-Git: https://git.openstack.org/openstack/deb-python-ceilometerclient -b debian/newton +Priority: optional +Maintainer: Debian OpenStack +Uploaders: + Thomas Goirand , + Michal Arbet , + Corey Bryant , +Build-Depends: + debhelper-compat (= 10), + dh-python, + openstack-pkg-tools (>= 99~), + python3-all, + python3-pbr, + python3-setuptools, + python3-sphinx, +Build-Depends-Indep: + python3-coverage, + python3-fixtures, + python3-hacking, + python3-iso8601, + python3-keystoneauth1, + python3-mock, + python3-oslo.i18n, + python3-oslo.serialization, + python3-oslo.utils (>= 3.20.0), + python3-oslosphinx, + python3-prettytable, + python3-requests, + python3-six, + python3-stevedore, + python3-subunit, + python3-tempest, + python3-testtools, + subunit, + testrepository, +Standards-Version: 4.4.1 +Vcs-Browser: https://salsa.debian.org/openstack-team/clients/python-ceilometerclient +Vcs-Git: https://salsa.debian.org/openstack-team/clients/python-ceilometerclient.git Homepage: http://www.openstack.org -XS-Testsuite: autopkgtest -Package: python-ceilometerclient +Package: python-ceilometerclient-doc +Section: doc Architecture: all -Depends: python-iso8601, - python-keystoneclient (>= 1:1.6.0), - python-oslo.i18n (>= 2.1.0), - python-oslo.serialization (>= 1.10.0), - python-oslo.utils (>= 3.5.0), - python-pbr (>= 1.8), - python-prettytable, - python-requests (>= 2.8.1), - python-six (>= 1.9.0), - python-stevedore (>= 1.10.0), - python-keystoneauth1 (>= 2.1.0), - ${misc:Depends}, - ${python:Depends}, -Suggests: python-ceilometerclient-doc -Description: Client library for Openstack Ceilometer API server - Python 2.7 +Depends: + ${misc:Depends}, + ${sphinxdoc:Depends}, +Description: Client library for Openstack Ceilometer API server - doc Ceilometer aims to deliver a unique point of contact for billing systems to acquire all counters they need to establish customer billing, across all current and future OpenStack components. The delivery of counters must be @@ -81,24 +57,25 @@ Description: Client library for Openstac There's a Python API (the "ceilometerclient" module), and a command-line script ("ceilometer"). . - This package contains the Python 2.7 module. + This package contains the documentation. Package: python3-ceilometerclient Architecture: all -Depends: python3-iso8601, - python3-keystoneclient (>= 1:1.6.0), - python3-oslo.i18n (>= 2.1.0), - python3-oslo.serialization (>= 1.10.0), - python3-oslo.utils (>= 3.5.0), - python3-pbr (>= 1.8), - python3-prettytable, - python3-requests (>= 2.8.1), - python3-six (>= 1.9.0), - python3-stevedore (>= 1.10.0), - python3-keystoneauth1 (>= 2.1.0), - ${misc:Depends}, - ${python3:Depends}, -Suggests: python-ceilometerclient-doc +Depends: + python3-iso8601, + python3-keystoneauth1, + python3-oslo.i18n, + python3-oslo.serialization, + python3-oslo.utils (>= 3.20.0), + python3-pbr, + python3-prettytable, + python3-requests, + python3-six, + python3-stevedore, + ${misc:Depends}, + ${python3:Depends}, +Suggests: + python-ceilometerclient-doc, Description: Client library for Openstack Ceilometer API server - Python 3.x Ceilometer aims to deliver a unique point of contact for billing systems to acquire all counters they need to establish customer billing, across all @@ -112,22 +89,3 @@ Description: Client library for Openstac script ("ceilometer"). . This package contains the Python 3.x module. - -Package: python-ceilometerclient-doc -Section: doc -Architecture: all -Depends: ${misc:Depends}, - ${sphinxdoc:Depends}, -Description: Client library for Openstack Ceilometer API server - doc - Ceilometer aims to deliver a unique point of contact for billing systems to - acquire all counters they need to establish customer billing, across all - current and future OpenStack components. The delivery of counters must be - tracable and auditable, the counters must be easily extensible to support new - projects, and agents doing data collections should be independent of the - overall system. - . - This is a client for the Ceilometer which uses the OpenStack Image API. - There's a Python API (the "ceilometerclient" module), and a command-line - script ("ceilometer"). - . - This package contains the documentation. diff -pruN 2.6.2-1/debian/copyright 2.9.0-6/debian/copyright --- 2.6.2-1/debian/copyright 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/copyright 2020-04-24 17:11:42.000000000 +0000 @@ -1,4 +1,4 @@ -Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: python-ceilometerclient Source: https://github.com/asalkeld/python-ceilometerclient @@ -22,6 +22,7 @@ License: Apache-2 Files: debian/* Copyright: (c) 2012-2016, Thomas Goirand + (c) 2020, Michal Arbet License: Apache-2 License: Apache-2 diff -pruN 2.6.2-1/debian/gbp.conf 2.9.0-6/debian/gbp.conf --- 2.6.2-1/debian/gbp.conf 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/gbp.conf 1970-01-01 00:00:00.000000000 +0000 @@ -1,9 +0,0 @@ -[DEFAULT] -upstream-branch = master -debian-branch = debian/newton -upstream-tag = %(version)s -compression = xz - -[buildpackage] -export-dir = ../build-area/ -cleaner = true diff -pruN 2.6.2-1/debian/patches/do-not-call-execfile.patch 2.9.0-6/debian/patches/do-not-call-execfile.patch --- 2.6.2-1/debian/patches/do-not-call-execfile.patch 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/debian/patches/do-not-call-execfile.patch 2020-04-24 17:10:29.000000000 +0000 @@ -0,0 +1,23 @@ +Description: Do not call execfile in conf.py +Author: Thomas Goirand +Forwarded: no +Last-Update: 2019-09-02 + +--- python-ceilometerclient-2.9.0.orig/doc/source/conf.py ++++ python-ceilometerclient-2.9.0/doc/source/conf.py +@@ -11,15 +11,9 @@ + # under the License. + + import os +-execfile(os.path.join("..", "ext", "gen_ref.py")) + + project = 'python-ceilometerclient' + +-gen_ref("", "Client Reference", ["client", "exc"]) +-gen_ref("v2", "Version 2 API Reference", +- ["meters", "samples", "statistics", "resources", "query", "alarms", +- "events", "event_types", "traits", "trait_descriptions"]) +- + # -- General configuration ---------------------------------------------------- + + # Add any Sphinx extension module names here, as strings. They can be diff -pruN 2.6.2-1/debian/patches/series 2.9.0-6/debian/patches/series --- 2.6.2-1/debian/patches/series 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/debian/patches/series 2020-04-24 17:10:29.000000000 +0000 @@ -0,0 +1 @@ +do-not-call-execfile.patch diff -pruN 2.6.2-1/debian/python3-ceilometerclient.install 2.9.0-6/debian/python3-ceilometerclient.install --- 2.6.2-1/debian/python3-ceilometerclient.install 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/debian/python3-ceilometerclient.install 2020-04-24 17:10:29.000000000 +0000 @@ -0,0 +1 @@ +/usr/* diff -pruN 2.6.2-1/debian/python3-ceilometerclient.postinst 2.9.0-6/debian/python3-ceilometerclient.postinst --- 2.6.2-1/debian/python3-ceilometerclient.postinst 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/python3-ceilometerclient.postinst 1970-01-01 00:00:00.000000000 +0000 @@ -1,11 +0,0 @@ -#!/bin/sh - -set -e - -if [ "$1" = "configure" ] ; then - update-alternatives --install /usr/bin/ceilometer ceilometer /usr/bin/python3-ceilometer 200 -fi - -#DEBHELPER# - -exit 0 diff -pruN 2.6.2-1/debian/python-ceilometerclient.postinst 2.9.0-6/debian/python-ceilometerclient.postinst --- 2.6.2-1/debian/python-ceilometerclient.postinst 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/python-ceilometerclient.postinst 1970-01-01 00:00:00.000000000 +0000 @@ -1,11 +0,0 @@ -#!/bin/sh - -set -e - -if [ "$1" = "configure" ] ; then - update-alternatives --install /usr/bin/ceilometer ceilometer /usr/bin/python2-ceilometer 300 -fi - -#DEBHELPER# - -exit 0 diff -pruN 2.6.2-1/debian/python-ceilometerclient.postrm 2.9.0-6/debian/python-ceilometerclient.postrm --- 2.6.2-1/debian/python-ceilometerclient.postrm 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/python-ceilometerclient.postrm 1970-01-01 00:00:00.000000000 +0000 @@ -1,11 +0,0 @@ -#!/bin/sh - -set -e - -if [ "$1" = "remove" ] || [ "$1" = "disappear" ] ; then - update-alternatives --remove ceilometer /usr/bin/python2-ceilometer -fi - -#DEBHELPER# - -exit 0 diff -pruN 2.6.2-1/debian/python-ceilometerclient.prerm 2.9.0-6/debian/python-ceilometerclient.prerm --- 2.6.2-1/debian/python-ceilometerclient.prerm 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/python-ceilometerclient.prerm 1970-01-01 00:00:00.000000000 +0000 @@ -1,11 +0,0 @@ -#!/bin/sh - -set -e - -if [ "$1" = "remove" ] ; then - update-alternatives --remove ceilometer /usr/bin/python2-ceilometer -fi - -#DEBHELPER# - -exit 0 diff -pruN 2.6.2-1/debian/rules 2.9.0-6/debian/rules --- 2.6.2-1/debian/rules 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/rules 2020-04-24 17:10:29.000000000 +0000 @@ -4,42 +4,35 @@ MANIFEST_EXCLUDE_STANDARD := ceilometerc include /usr/share/openstack-pkg-tools/pkgos.make %: - dh $@ --buildsystem=python_distutils --with python2,python3,sphinxdoc + dh $@ --buildsystem=python_distutils --with python3,sphinxdoc -override_dh_auto_install: - pkgos-dh_auto_install +override_dh_auto_clean: + rm -rf .testrepository doc/man -override_dh_python3: - dh_python3 --shebang=/usr/bin/python3 +override_dh_auto_build: + echo "Do nothing..." + +override_dh_install: + echo "Do nothing..." override_dh_auto_test: + echo "Do nothing..." + +override_dh_auto_install: + pkgos-dh_auto_install --no-py2 --in-tmp + ifeq (,$(filter nocheck,$(DEB_BUILD_OPTIONS))) - pkgos-dh_auto_test -# @echo "===> Running tests" -# set -e ; set -x ; for i in $(PYTHONS) $(PYTHON3S) ; do \ -# PYMAJOR=`echo $$i | cut -d'.' -f1` ; \ -# echo "===> Testing with python$$i (python$$PYMAJOR)" ; \ -# rm -rf .testrepository ; \ -# testr-python$$PYMAJOR init ; \ -# TEMP_REZ=`mktemp -t` ; \ -# PYTHONPATH=$(CURDIR) PYTHON=python$$i testr-python$$PYMAJOR run --subunit 'ceilometerclient\.tests\.unit\.(?!.*test_client.ClientAuthTest\.test_discover_auth_versions.*)' | tee $$TEMP_REZ | subunit2pyunit ; \ -# cat $$TEMP_REZ | subunit-filter -s --no-passthrough | subunit-stats ; \ -# rm -f $$TEMP_REZ ; \ -# testr-python$$PYMAJOR slowest ; \ -# done + pkgos-dh_auto_test --no-py2 'ceilometerclient\.tests\.unit\.(?!.*test_client.ClientAuthTest\.test_discover_auth_versions.*)' endif + dh_install + dh_missing --fail-missing override_dh_sphinxdoc: -ifeq (,$(findstring nodocs, $(DEB_BUILD_OPTIONS))) - sphinx-build -b html doc/source $(CURDIR)/debian/python-ceilometerclient-doc/usr/share/doc/python-ceilometerclient-doc/html +ifeq (,$(findstring nodoc, $(DEB_BUILD_OPTIONS))) + python3 -m sphinx -b html doc/source $(CURDIR)/debian/python-ceilometerclient-doc/usr/share/doc/python-ceilometerclient-doc/html dh_sphinxdoc -O--buildsystem=python_distutils endif -override_dh_clean: - dh_clean -O--buildsystem=python_distutils - rm -rf .testrepository - rm -rf doc/man - override_dh_installman: #ifeq (,$(findstring nodocs, $(DEB_BUILD_OPTIONS))) # sphinx-build -b man doc/source doc/man @@ -47,3 +40,6 @@ override_dh_installman: # sed -i s/python-ceilometerclient/python-ceilometerclient/ doc/man/ceilometer.1 # dh_installman -O--buildsystem=python_distutils #endif + +override_dh_python3: + dh_python3 --shebang=/usr/bin/python3 diff -pruN 2.6.2-1/debian/source/options 2.9.0-6/debian/source/options --- 2.6.2-1/debian/source/options 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/source/options 2020-04-24 17:10:29.000000000 +0000 @@ -1,2 +1 @@ extend-diff-ignore = "^[^/]*[.]egg-info/" -extend-diff-ignore = "^[.]gitreview$" diff -pruN 2.6.2-1/debian/tests/client 2.9.0-6/debian/tests/client --- 2.6.2-1/debian/tests/client 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/tests/client 2020-04-24 17:10:29.000000000 +0000 @@ -4,7 +4,7 @@ #------------------------- set -e -cd "$ADTTMP" +cd "$AUTOPKGTEST_TMP" HELP_CLIENTS=('ceilometer') for client in "${HELP_CLIENTS[@]}"; do diff -pruN 2.6.2-1/debian/tests/control 2.9.0-6/debian/tests/control --- 2.6.2-1/debian/tests/control 2016-12-28 22:52:03.000000000 +0000 +++ 2.9.0-6/debian/tests/control 2020-04-24 17:10:29.000000000 +0000 @@ -1,8 +1,7 @@ Tests: client -Depends: python-ceilometerclient +Depends: + python3-ceilometerclient, -Depends: python-ceilometerclient -Test-Command: cd "$ADTTMP" ; python -c "import ceilometerclient; print ceilometerclient.__version__" - -Depends: python3-ceilometerclient -Test-Command: cd "$ADTTMP" ; python3 -c "import ceilometerclient; print(ceilometerclient.__version__)" +Depends: + python3-ceilometerclient, +Test-Command: cd "$AUTOPKGTEST_TMP" ; python3 -c "import ceilometerclient; print(ceilometerclient.__version__)" diff -pruN 2.6.2-1/.gitreview 2.9.0-6/.gitreview --- 2.6.2-1/.gitreview 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/.gitreview 2017-06-09 17:39:30.000000000 +0000 @@ -2,4 +2,3 @@ host=review.openstack.org port=29418 project=openstack/python-ceilometerclient.git -defaultbranch=stable/newton diff -pruN 2.6.2-1/releasenotes/notes/alarm_deprecated-74363d70d48a20e2.yaml 2.9.0-6/releasenotes/notes/alarm_deprecated-74363d70d48a20e2.yaml --- 2.6.2-1/releasenotes/notes/alarm_deprecated-74363d70d48a20e2.yaml 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/releasenotes/notes/alarm_deprecated-74363d70d48a20e2.yaml 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,3 @@ +--- +deprecations: + - Alarm commands are deprecated in favor of aodhclient. diff -pruN 2.6.2-1/releasenotes/notes/deprecation-44ae455f4ef3a81e.yaml 2.9.0-6/releasenotes/notes/deprecation-44ae455f4ef3a81e.yaml --- 2.6.2-1/releasenotes/notes/deprecation-44ae455f4ef3a81e.yaml 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/releasenotes/notes/deprecation-44ae455f4ef3a81e.yaml 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,6 @@ +--- +deprecations: + - | + As the Ceilometer API has been deprecated, this client is also now marked + as deprecated and will print a warning when used as a command-line + interface tool. diff -pruN 2.6.2-1/releasenotes/notes/panko-redirect-9d03598dbf51f8fd.yaml 2.9.0-6/releasenotes/notes/panko-redirect-9d03598dbf51f8fd.yaml --- 2.6.2-1/releasenotes/notes/panko-redirect-9d03598dbf51f8fd.yaml 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/releasenotes/notes/panko-redirect-9d03598dbf51f8fd.yaml 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,7 @@ +--- +prelude: > + Panko replaces the API and storage of events previously in Ceilometer +features: + - | + Similar to aodh redirect support, specify `panko_endpoint` as a redirect + to Panko API. diff -pruN 2.6.2-1/releasenotes/source/conf.py 2.9.0-6/releasenotes/source/conf.py --- 2.6.2-1/releasenotes/source/conf.py 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/releasenotes/source/conf.py 2017-06-09 17:39:30.000000000 +0000 @@ -273,3 +273,6 @@ texinfo_documents = [ # If true, do not generate a @detailmenu in the "Top" node's menu. # texinfo_no_detailmenu = False + +# -- Options for Internationalization output ------------------------------ +locale_dirs = ['locale/'] diff -pruN 2.6.2-1/releasenotes/source/index.rst 2.9.0-6/releasenotes/source/index.rst --- 2.6.2-1/releasenotes/source/index.rst 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/releasenotes/source/index.rst 2017-06-09 17:39:30.000000000 +0000 @@ -7,10 +7,11 @@ Contents .. toctree:: :maxdepth: 2 - liberty - mitaka unreleased - + ocata + newton + mitaka + liberty Indices and tables ================== diff -pruN 2.6.2-1/releasenotes/source/newton.rst 2.9.0-6/releasenotes/source/newton.rst --- 2.6.2-1/releasenotes/source/newton.rst 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/releasenotes/source/newton.rst 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,6 @@ +=================================== + Newton Series Release Notes +=================================== + +.. release-notes:: + :branch: origin/stable/newton diff -pruN 2.6.2-1/releasenotes/source/ocata.rst 2.9.0-6/releasenotes/source/ocata.rst --- 2.6.2-1/releasenotes/source/ocata.rst 1970-01-01 00:00:00.000000000 +0000 +++ 2.9.0-6/releasenotes/source/ocata.rst 2017-06-09 17:39:30.000000000 +0000 @@ -0,0 +1,6 @@ +=================================== + Ocata Series Release Notes +=================================== + +.. release-notes:: + :branch: origin/stable/ocata diff -pruN 2.6.2-1/requirements.txt 2.9.0-6/requirements.txt --- 2.6.2-1/requirements.txt 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/requirements.txt 2017-06-09 17:39:30.000000000 +0000 @@ -6,7 +6,7 @@ iso8601>=0.1.11 # MIT keystoneauth1>=2.1.0 # Apache-2.0 oslo.i18n>=2.1.0 # Apache-2.0 oslo.serialization>=1.10.0 # Apache-2.0 -oslo.utils>=3.5.0 # Apache-2.0 +oslo.utils>=3.17.0 # Apache-2.0 PrettyTable<0.8,>=0.7 # BSD requests!=2.9.0,>=2.8.1 # Apache-2.0 six>=1.9.0 # MIT diff -pruN 2.6.2-1/setup.cfg 2.9.0-6/setup.cfg --- 2.6.2-1/setup.cfg 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/setup.cfg 2017-06-09 17:39:30.000000000 +0000 @@ -16,7 +16,6 @@ classifier = Programming Language :: Python :: 2 Programming Language :: Python :: 2.7 Programming Language :: Python :: 3 - Programming Language :: Python :: 3.4 Programming Language :: Python :: 3.5 [files] diff -pruN 2.6.2-1/tox.ini 2.9.0-6/tox.ini --- 2.6.2-1/tox.ini 2016-10-11 09:10:10.000000000 +0000 +++ 2.9.0-6/tox.ini 2017-06-09 17:39:30.000000000 +0000 @@ -1,5 +1,5 @@ [tox] -envlist = py34,py35,py27,pypy,pep8 +envlist = py35,py27,pypy,pep8 minversion = 1.6 skipsdist = True @@ -9,15 +9,18 @@ install_command = pip install -U {opts} setenv = VIRTUAL_ENV={envdir} deps = -r{toxinidir}/requirements.txt -r{toxinidir}/test-requirements.txt +# NOTE(tonyb): This project has chosen to *NOT* consume upper-constraints.txt commands = python setup.py testr --slowest --testr-args='{posargs}' [testenv:pep8] -deps = hacking<0.12,>=0.11.0 +deps = hacking<0.13,>=0.12 commands = flake8 [testenv:cover] -commands = python setup.py testr --coverage --testr-args='{posargs}' +commands = + python setup.py testr --coverage --testr-args='{posargs}' + coverage report [testenv:venv] commands = {posargs} @@ -35,4 +38,8 @@ commands = sphinx-build -a -E -W -d rele [flake8] show-source = True -exclude = .venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build,tools +exclude = .venv,.git,.tox,dist,doc,*lib/python*,*egg,build,tools + +[hacking] +import_exceptions = + ceilometerclient.i18n