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

import functools
import re
import time
from urllib import parse
import uuid

import requests

from keystoneauth1 import exceptions as ks_exc
from keystoneauth1 import loading as keystone
from oslo_log import log as logging
from oslo_serialization import jsonutils
from oslo_utils import versionutils

from neutron_lib._i18n import _
from neutron_lib.exceptions import placement as n_exc


LOG = logging.getLogger(__name__)

API_VERSION_REQUEST_HEADER = 'OpenStack-API-Version'
PLACEMENT_API_WITH_MEMBER_OF = 'placement 1.3'
PLACEMENT_API_WITH_NESTED_RESOURCES = 'placement 1.14'
PLACEMENT_API_RETURN_PROVIDER_BODY = 'placement 1.20'
PLACEMENT_API_ERROR_CODE = 'placement 1.23'
PLACEMENT_API_CONSUMER_GENERATION = 'placement 1.28'
PLACEMENT_API_UPDATE_REPARENT = 'placement 1.37'
PLACEMENT_API_LATEST_SUPPORTED = PLACEMENT_API_UPDATE_REPARENT
GENERATION_CONFLICT_RETRIES = 10


def _check_placement_api_available(f):
    """Check if the placement API is available.

    :param f: Function to execute.
    :returns: The returned value of the function f.
    """
    @functools.wraps(f)
    def wrapper(self, *a, **k):
        try:
            if not self._client:
                self._client = self._create_client()
            return f(self, *a, **k)
        except ks_exc.http.HttpError as exc:
            if 400 <= exc.http_status <= 499:
                # NOTE(bence romsics): Placement has inconsistently formatted
                # error messages. Some error response bodies are JSON
                # formatted, seemingly machine readible objects. While others
                # are free format text. We have to keep the whole thing
                # to avoid losing information.
                raise n_exc.PlacementClientError(
                    msg=exc.response.text.replace('\n', ' '))
            raise
    return wrapper


def _get_version(openstack_api_version):
    match = re.search(r"placement (?P<api_version>\d+\.\d+)",
                      openstack_api_version)
    return versionutils.convert_version_to_tuple(match.group('api_version'))


class UUIDEncoder(jsonutils.JSONEncoder):
    def default(self, o):
        if isinstance(o, uuid.UUID):
            return str(o)
        return super().default(o)


class NoAuthClient(object):
    """Placement NoAuthClient for fullstack testing"""

    def __init__(self, url):
        self.url = url
        # TODO(lajoskatona): use perhaps http_connect_timeout from
        # keystone_authtoken group
        self.timeout = 5
        self.retries = 2

    def request(self, url, method, body=None, headers=None, **kwargs):
        headers = headers or {}
        headers.setdefault('Accept', 'application/json')

        # Note(lajoskatona): placement report plugin fills uuid fields with
        # UUID objects, and that is good for keystone, but requests goes mad
        # with that if we use json=body as it can't serialize UUID.
        # To make things worse if we give a serialized json, it will do the
        # jsonification again, so better to create the json here and give it
        # to requests with the data parameter.
        body = jsonutils.dumps(body, cls=UUIDEncoder)
        for i in range(self.retries):
            try:
                resp = requests.request(
                    method,
                    url,
                    data=body,
                    headers=headers,
                    verify=False,
                    timeout=self.timeout,
                    **kwargs)
                return resp
            except requests.Timeout:
                LOG.exception('requests Timeout, let\'s retry it...')
            except requests.ConnectionError:
                LOG.exception('Connection Error appeared')
            except requests.RequestException:
                LOG.exception('Some really weird thing happened, let\'s '
                              'retry it')
            time.sleep(self.timeout)
        # Note(lajoskatona): requests raise ConnectionError, but
        # PlacementReportPlugin expects keystonauth1 HttpError.
        raise ks_exc.HttpError

    def get(self, url, endpoint_filter, **kwargs):
        return self.request('%s%s' % (self.url, url), 'GET', **kwargs)

    def post(self, url, json, endpoint_filter, **kwargs):
        return self.request('%s%s' % (self.url, url), 'POST', body=json,
                            **kwargs)

    def put(self, url, json, endpoint_filter, **kwargs):
        resp = self.request('%s%s' % (self.url, url), 'PUT', body=json,
                            **kwargs)
        return resp

    def delete(self, url, endpoint_filter, **kwargs):
        return self.request('%s%s' % (self.url, url), 'DELETE', **kwargs)


class PlacementAPIClient(object):
    """Client class for placement ReST API."""

    def __init__(self, conf,
                 openstack_api_version=PLACEMENT_API_LATEST_SUPPORTED):
        self._openstack_api_version = openstack_api_version
        self._target_version = _get_version(openstack_api_version)
        self._conf = conf
        self._ks_filter = {'service_type': 'placement',
                           'region_name': self._conf.placement.region_name,
                           'interface': self._conf.placement.endpoint_type}
        self._api_version_header = {API_VERSION_REQUEST_HEADER:
                                    self._openstack_api_version}
        self._client = None

    def _create_client(self):
        """Create the HTTP session accessing the placement service."""
        # Flush _resource_providers and aggregates so we start from a
        # clean slate.
        self._resource_providers = {}
        self._provider_aggregate_map = {}
        # TODO(lajoskatona): perhaps not the best to override config options,
        # actually the abused keystoneauth1 options are:
        # auth_type (used for deciding for NoAuthClient) and auth_section
        # (used for communicating the url for the NoAuthClient)
        if self._conf.placement.auth_type == 'noauth':
            return NoAuthClient(self._conf.placement.auth_section)
        else:
            auth_plugin = keystone.load_auth_from_conf_options(
                self._conf, 'placement')
            return keystone.load_session_from_conf_options(
                self._conf, 'placement', auth=auth_plugin,
                additional_headers={'accept': 'application/json'})

    def _extend_header_with_api_version(self, **kwargs):
        headers = kwargs.get('headers', {})
        if API_VERSION_REQUEST_HEADER not in headers:
            if 'headers' not in kwargs:
                kwargs['headers'] = self._api_version_header
            else:
                kwargs['headers'].update(self._api_version_header)
        return kwargs

    def _get(self, url, **kwargs):
        kwargs = self._extend_header_with_api_version(**kwargs)
        return self._client.get(url, endpoint_filter=self._ks_filter,
                                **kwargs)

    def _post(self, url, data, **kwargs):
        kwargs = self._extend_header_with_api_version(**kwargs)
        return self._client.post(url, json=data,
                                 endpoint_filter=self._ks_filter, **kwargs)

    def _put(self, url, data, **kwargs):
        kwargs = self._extend_header_with_api_version(**kwargs)
        return self._client.put(url, json=data,
                                endpoint_filter=self._ks_filter, **kwargs)

    def _put_with_retry_for_generation_conflict(
            self, url, body,
            resource_provider_uuid,
            resource_provider_generation=None):

        if resource_provider_generation is None:
            # If the client's user did not supply a generation to us we dare to
            # retry without handing the control back to our caller.
            max_tries = GENERATION_CONFLICT_RETRIES
        else:
            # If the client's user supplied a generation to us we don't dare to
            # retry on her behalf since we don't know her intention.
            max_tries = 1

        body['resource_provider_generation'] = resource_provider_generation

        for i in range(max_tries):
            if resource_provider_generation is None:
                # In the bodies of
                # PUT /resource_providers/{uuid}/traits
                # PUT /resource_providers/{uuid}/inventories
                # PUT /resource_providers/{uuid}/inventories/{resource_class}
                # resource_provider_generation happens to be at the same place.
                body['resource_provider_generation'] = \
                    self.get_resource_provider(
                        resource_provider_uuid=resource_provider_uuid)[
                            'generation']
            try:
                return self._put(url, body).json()
            except ks_exc.Conflict as e:
                if e.response.json()[
                        'errors'][0]['code'] == 'placement.concurrent_update':
                    continue
                raise

        raise n_exc.PlacementResourceProviderGenerationConflict(
            resource_provider=resource_provider_uuid,
            generation=body['resource_provider_generation'])

    def _delete(self, url, **kwargs):
        kwargs = self._extend_header_with_api_version(**kwargs)
        return self._client.delete(url, endpoint_filter=self._ks_filter,
                                   **kwargs)

    @_check_placement_api_available
    def create_resource_provider(self, resource_provider):
        """Create a resource provider.

        :param resource_provider: The resource provider. A dict with
                                  the uuid (required),
                                  the name (required) and
                                  the parent_provider_uuid (optional).
        :returns: The resource provider created.
        """
        url = '/resource_providers'
        rsp = self._post(url, resource_provider)
        if (self._target_version <
                _get_version(PLACEMENT_API_RETURN_PROVIDER_BODY)):
            return
        else:
            return rsp.json()

    @_check_placement_api_available
    def update_resource_provider(self, resource_provider):
        """Update the resource provider identified by uuid.

        :param resource_provider: The resource provider. A dict with
                                  the uuid (required),
                                  the name (required) and
                                  the parent_provider_uuid (optional).
        :raises PlacementResourceProviderNotFound: No such resource provider.
        :raises PlacementResourceProviderNameNotUnique: Conflict with another
                                                        resource provider with
                                                        the same name.
        :returns: The updated resource provider.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_providers/%s' % resource_provider['uuid']
        # update does not tolerate if the uuid is repeated in the body
        update_body = resource_provider.copy()
        update_body.pop('uuid')
        try:
            return self._put(url, update_body).json()
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceProviderNotFound(
                resource_provider=resource_provider['uuid'])
        except ks_exc.Conflict:
            raise n_exc.PlacementResourceProviderNameNotUnique(
                name=resource_provider['name'])

    @_check_placement_api_available
    def ensure_resource_provider(self, resource_provider):
        """Ensure a resource provider exists by updating or creating it.

        :param resource_provider: The resource provider. A dict with
                                  the uuid (required),
                                  the name (required) and
                                  the parent_provider_uuid (optional).
        :returns: The Resource Provider updated or created.

        Beware, this is not an atomic operation of the API.
        """
        try:
            return self.update_resource_provider(
                resource_provider=resource_provider)
        except n_exc.PlacementResourceProviderNotFound:
            return self.create_resource_provider(resource_provider)

    @_check_placement_api_available
    def delete_resource_provider(self, resource_provider_uuid):
        """Delete a resource provider.

        :param resource_provider_uuid: UUID of the resource provider.
        """
        url = '/resource_providers/%s' % resource_provider_uuid
        self._delete(url)

    @_check_placement_api_available
    def get_resource_provider(self, resource_provider_uuid):
        """Get resource provider by UUID.

        :param resource_provider_uuid: UUID of the resource provider.
        :raises PlacementResourceProviderNotFound: For failure to find resource
        :returns: The Resource Provider matching the UUID.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_providers/%s' % resource_provider_uuid
        try:
            return self._get(url).json()
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceProviderNotFound(
                resource_provider=resource_provider_uuid)

    @_check_placement_api_available
    def list_resource_providers(self, name=None, member_of=None,
                                resources=None, in_tree=None, uuid=None):
        """Get a list of resource providers.

        :param name: Name of the resource providers.
        :param member_of: List of aggregate UUID to get those resource
                          providers that are associated with.
                          NOTE: placement 1.3 needed.
        :param resources: Dictionary of resource classes and requested values.
        :param in_tree: UUID of a resource provider that the caller wants to
                        limit the returned providers to those within its
                        'provider tree'. The returned list will contain only
                        resource providers with the root_provider_id of the
                        resource provider with UUID == tree_uuid.
                        NOTE: placement 1.14 needed.
        :param uuid: UUID of the resource provider.
        :raises PlacementAPIVersionIncorrect: If placement API target version
                                              is too low
        :returns: A list of Resource Provider matching the filters.
        """
        url = '/resource_providers'
        filters = {}
        if name:
            filters['name'] = name
        if member_of:
            needed_version = _get_version(PLACEMENT_API_WITH_MEMBER_OF)
            if self._target_version < needed_version:
                raise n_exc.PlacementAPIVersionIncorrect(
                    current_version=self._target_version,
                    needed_version=needed_version)
            filters['member_of'] = member_of
        if resources:
            filters['resources'] = resources
        if in_tree:
            needed_version = _get_version(
                PLACEMENT_API_WITH_NESTED_RESOURCES)
            if self._target_version < needed_version:
                raise n_exc.PlacementAPIVersionIncorrect(
                    current_version=self._target_version,
                    needed_version=needed_version)
            filters['in_tree'] = in_tree
        if uuid:
            filters['uuid'] = uuid
        url = '%s?%s' % (url, parse.urlencode(filters))
        return self._get(url).json()

    @_check_placement_api_available
    def update_resource_provider_inventories(
            self, resource_provider_uuid, inventories,
            resource_provider_generation=None):
        """Replaces the set of inventory records for a resource provider.

        :param resource_provider_uuid: UUID of the resource provider.
        :param inventories: The inventories. A dict in the format (see:
                            Placement API ref: https://goo.gl/F22mtk)
                            {resource_class(required):
                            {allocation_ratio(required):
                            total(required):
                            max_unit(required):
                            min_unit(required):
                            reserved(required):
                            step_size(required):
                            }}
        :param resource_provider_generation: The generation of the resource
                                             provider. Optional.
        :raises PlacementResourceProviderNotFound: if the resource provider
                                                   is not found.
        :raises PlacementResourceProviderGenerationConflict: if the generation
                                                             of the resource
                                                             provider does not
                                                             match with the
                                                             server side.
        :returns: The updated set of inventory records.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_providers/%s/inventories' % resource_provider_uuid
        body = {
            'resource_provider_generation': resource_provider_generation,
            'inventories': inventories
        }

        try:
            return self._put_with_retry_for_generation_conflict(
                url, body, resource_provider_uuid,
                resource_provider_generation)
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceProviderNotFound(
                resource_provider=resource_provider_uuid)

    @_check_placement_api_available
    def delete_resource_provider_inventories(self, resource_provider_uuid):
        """Delete all inventory records for the resource provider.

        :param resource_provider_uuid: UUID of the resource provider.
        :raises PlacementResourceProviderNotFound: If the resource provider
                                                   is not found.
        :returns: None.
        """
        url = '/resource_providers/%s/inventories' % (
            resource_provider_uuid)
        try:
            self._delete(url)
        except ks_exc.NotFound as e:
            if "No resource provider with uuid" in e.details:
                raise n_exc.PlacementResourceProviderNotFound(
                    resource_provider=resource_provider_uuid)
            raise

    @_check_placement_api_available
    def delete_resource_provider_inventory(self, resource_provider_uuid,
                                           resource_class):
        """Delete inventory of the resource class for a resource provider.

        :param resource_provider_uuid: UUID of the resource provider.
        :param resource_class: The name of the resource class
        :raises PlacementResourceProviderNotFound: If the resource provider
                                                   is not found.
        :raises PlacementInventoryNotFound: No inventory of class.
        :returns: None.
        """
        url = '/resource_providers/%s/inventories/%s' % (
            resource_provider_uuid, resource_class)
        try:
            self._delete(url)
        except ks_exc.NotFound as e:
            if "No resource provider with uuid" in e.details:
                raise n_exc.PlacementResourceProviderNotFound(
                    resource_provider=resource_provider_uuid)
            if "No inventory of class" in e.details:
                raise n_exc.PlacementInventoryNotFound(
                    resource_provider=resource_provider_uuid,
                    resource_class=resource_class)
            raise

    @_check_placement_api_available
    def get_inventory(self, resource_provider_uuid, resource_class):
        """Get resource provider inventory.

        :param resource_provider_uuid: UUID of the resource provider.
        :param resource_class: Resource class name of the inventory to be
                               returned.
        :raises PlacementResourceProviderNotFound: If the resource provider is
                                                   not found.
        :raises PlacementInventoryNotFound: For failure to find inventory
                                            for a resource provider.
        :returns: The inventory of the resource class as a dict.
        """
        url = '/resource_providers/%s/inventories/%s' % (
            resource_provider_uuid, resource_class)
        try:
            return self._get(url).json()
        except ks_exc.NotFound as e:
            if "No resource provider with uuid" in e.details:
                raise n_exc.PlacementResourceProviderNotFound(
                    resource_provider=resource_provider_uuid)
            if _("No inventory of class") in e.details:
                raise n_exc.PlacementInventoryNotFound(
                    resource_provider=resource_provider_uuid,
                    resource_class=resource_class)
            raise

    @_check_placement_api_available
    def update_resource_provider_inventory(
            self, resource_provider_uuid, inventory, resource_class,
            resource_provider_generation=None):
        """Update resource provider inventory.

        :param resource_provider_uuid: UUID of the resource provider.
        :param inventory: The inventory to be updated for the resource class.
        :param resource_class: The name of the resource class.
        :param resource_provider_generation: The generation of the resource
                                             provider. Optional.
        :raises PlacementResourceNotFound: If the resource provider or the
                                           resource class is not found.
        :raises PlacementResourceProviderGenerationConflict: If the resource
                                                             provider
                                                             generation does
                                                             not match with the
                                                             server side.
        :returns: The updated inventory of the resource class as a dict.
        """
        url = '/resource_providers/%s/inventories/%s' % (
            resource_provider_uuid, resource_class)
        body = inventory

        try:
            return self._put_with_retry_for_generation_conflict(
                url, body, resource_provider_uuid,
                resource_provider_generation)
        except ks_exc.NotFound as e:
            raise n_exc.PlacementResourceNotFound(url=e.url)

    @_check_placement_api_available
    def associate_aggregates(self, resource_provider_uuid, aggregates):
        """Associate a list of aggregates with a resource provider.

        :param resource_provider_uuid: UUID of the resource provider.
        :param aggregates: aggregates to be associated to the resource
                           provider.
        :returns: All aggregates associated with the resource provider.
        """
        url = '/resource_providers/%s/aggregates' % resource_provider_uuid
        return self._put(url, aggregates).json()

    @_check_placement_api_available
    def list_aggregates(self, resource_provider_uuid):
        """List resource provider aggregates.

        :param resource_provider_uuid: UUID of the resource provider.
        :raises PlacementAggregateNotFound: For failure to the aggregates of
                                            a resource provider.
        :returns: The list of aggregates together with the resource provider
                  generation.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_providers/%s/aggregates' % resource_provider_uuid
        try:
            return self._get(url).json()
        except ks_exc.NotFound:
            raise n_exc.PlacementAggregateNotFound(
                resource_provider=resource_provider_uuid)

    @_check_placement_api_available
    def list_traits(self):
        """List all traits."""
        url = '/traits'
        return self._get(url).json()

    @_check_placement_api_available
    def get_trait(self, name):
        """Check if a given trait exists

        :param name: name of the trait to check.
        :raises PlacementTraitNotFound: If the trait name not found.
        :returns: Evaluates to True if the trait exists.
        """
        # pylint: disable=raise-missing-from
        url = '/traits/%s' % name
        try:
            return self._get(url)
        except ks_exc.NotFound:
            raise n_exc.PlacementTraitNotFound(trait=name)

    @_check_placement_api_available
    def update_trait(self, name):
        """Insert a single custom trait.

        :param name: name of the trait to create.
        :returns: The Response object so you may access response headers.
        """
        url = '/traits/%s' % (name)
        return self._put(url, None)

    @_check_placement_api_available
    def delete_trait(self, name):
        """Delete the specified trait.

        :param name: the name of the trait to be deleted.
        :raises PlacementTraitNotFound: If the trait did not exist.
        :returns: None.
        """
        # pylint: disable=raise-missing-from
        url = '/traits/%s' % (name)
        try:
            self._delete(url)
        except ks_exc.NotFound:
            raise n_exc.PlacementTraitNotFound(trait=name)

    @_check_placement_api_available
    def update_resource_provider_traits(
            self, resource_provider_uuid, traits,
            resource_provider_generation=None):
        """Replace all associated traits of a resource provider.

        :param resource_provider_uuid: UUID of the resource provider for which
                                       to set the traits
        :param traits: a list of traits.
        :param resource_provider_generation: The generation of the resource
                                             provider. Optional. If not
                                             supplied by the caller, handle
                                             potential generation conflict
                                             by retrying the call. If supplied
                                             we assume the caller handles
                                             generation conflict.
        :raises PlacementResourceProviderNotFound: If the resource provider
                                                   is not found.
        :raises PlacementTraitNotFound: If any of the specified traits are not
                                        valid.
        :raises PlacementResourceProviderGenerationConflict: For concurrent
                                                             conflicting
                                                             updates detected.
        :returns: The new traits of the resource provider together with the
                  resource provider generation.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_providers/%s/traits' % (resource_provider_uuid)
        body = {
            'resource_provider_generation': resource_provider_generation,
            'traits': traits
        }

        try:
            return self._put_with_retry_for_generation_conflict(
                url, body, resource_provider_uuid,
                resource_provider_generation)
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceProviderNotFound(
                resource_provider=resource_provider_uuid)
        except ks_exc.BadRequest:
            raise n_exc.PlacementTraitNotFound(trait=traits)

    @_check_placement_api_available
    def list_resource_provider_traits(self, resource_provider_uuid):
        """List all traits associated with a resource provider

        :param resource_provider_uuid: UUID of the resource provider for which
                                       the traits will be listed
        :raises PlacementResourceProviderNotFound: If the resource provider
                                                   is not found.
        :returns: The associated traits of the resource provider together
                  with the resource provider generation.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_providers/%s/traits' % (resource_provider_uuid)
        try:
            return self._get(url).json()
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceProviderNotFound(
                resource_provider=resource_provider_uuid)

    @_check_placement_api_available
    def delete_resource_provider_traits(self, resource_provider_uuid):
        """Delete resource provider traits.

        :param resource_provider_uuid: The UUID of the resource provider for
                                       which to delete all the traits.
        :raises PlacementResourceProviderNotFound: If the resource provider
                                                   is not found.
        :returns: None.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_providers/%s/traits' % (resource_provider_uuid)
        try:
            self._delete(url)
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceProviderNotFound(
                resource_provider=resource_provider_uuid)

    @_check_placement_api_available
    def list_resource_classes(self):
        """List resource classes"""
        url = '/resource_classes'
        return self._get(url).json()

    @_check_placement_api_available
    def get_resource_class(self, name):
        """Show resource class.

        :param name: The name of the resource class to show
        :raises PlacementResourceClassNotFound: If the resource class
                                                is not found.
        :returns: The name of resource class and its set of links.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_classes/%s' % (name)
        try:
            return self._get(url).json()
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceClassNotFound(resource_class=name)

    @_check_placement_api_available
    def create_resource_class(self, name):
        """Create a custom resource class

        :param name: the name of the resource class
        :returns: None.
        """
        url = '/resource_classes'
        body = {'name': name}
        self._post(url, body)

    @_check_placement_api_available
    def update_resource_class(self, name):
        """Create or validate the existence of the resource custom class.

        :param name: the name of the resource class to be updated or validated
        :returns: None.
        """
        url = '/resource_classes/%s' % name
        self._put(url, None)

    @_check_placement_api_available
    def delete_resource_class(self, name):
        """Delete a custom resource class.

        :param name: The name of the resource class to be deleted.
        :raises PlacementResourceClassNotFound: If the resource class
                                                is not found.
        :returns: None.
        """
        # pylint: disable=raise-missing-from
        url = '/resource_classes/%s' % (name)
        try:
            self._delete(url)
        except ks_exc.NotFound:
            raise n_exc.PlacementResourceClassNotFound(resource_class=name)

    @_check_placement_api_available
    def list_allocations(self, consumer_uuid):
        """List allocations for the consumer

        :param consumer_uuid: The uuid of the consumer, in case of bound port
                              owned by a VM, the VM uuid.
        :returns: All allocation records for the consumer.
        """
        url = '/allocations/%s' % consumer_uuid
        return self._get(url).json()

    def update_qos_allocation(self, consumer_uuid, alloc_diff):
        """Update allocation for QoS minimum bandwidth consumer

        :param consumer_uuid: The uuid of the consumer, in case of bound port
                              owned by a VM, the VM uuid.
        :param alloc_diff: A dict which contains RP UUIDs as keys and
                           corresponding fields to update for the allocation
                           under the given resource provider.
        """
        for i in range(GENERATION_CONFLICT_RETRIES):
            body = self.list_allocations(consumer_uuid)
            if not body['allocations']:
                raise n_exc.PlacementAllocationRemoved(consumer=consumer_uuid)
            # Count new values based on the diff in alloc_diff
            for rp_uuid, diff in alloc_diff.items():
                if rp_uuid not in body['allocations']:
                    raise n_exc.PlacementAllocationRpNotExists(
                        resource_provider=rp_uuid, consumer=consumer_uuid)
                for drctn, value in diff.items():
                    orig_value = body['allocations'][rp_uuid][
                        'resources'].get(drctn, 0)
                    new_value = orig_value + value
                    if new_value > 0:
                        body['allocations'][rp_uuid]['resources'][
                            drctn] = new_value
                    else:
                        # Remove the resource class if the new value is 0
                        resources = body['allocations'][rp_uuid]['resources']
                        resources.pop(drctn, None)

            # Remove RPs without any resources
            body['allocations'] = {
                rp: alloc for rp, alloc in body['allocations'].items()
                if alloc.get('resources')}
            try:
                # Update allocations has no return body, but leave the loop
                return self.update_allocation(consumer_uuid, body)
            except ks_exc.Conflict as e:
                resp = e.response.json()
                if resp['errors'][0]['code'] == 'placement.concurrent_update':
                    continue
                raise
        raise n_exc.PlacementAllocationGenerationConflict(
            consumer=consumer_uuid)

    def update_allocation(self, consumer_uuid, allocations):
        """Update allocation record for given consumer and rp

        :param consumer_uuid: The uuid of the consumer
        :param allocations: Dict in the form described in placement API ref:
                            https://tinyurl.com/yxeuzn6l
        """
        url = '/allocations/%s' % consumer_uuid
        self._put(url, allocations)
