32f9e5b388
In Keystone V3, the service catalog in the token response has been split into multiple entries per service. This change checks the version of the Identity Service and performs the appropriate parsing of the catalog. Core code for Keystone V3 authentication are in openstack_auth. TODO: Move to auto-detection of API versions when it is available. Implements blueprint login-domain-support Change-Id: I69073e5744def037caf522b1123755668887cfd9
226 lines
7.3 KiB
Python
226 lines
7.3 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2012 United States Government as represented by the
|
|
# Administrator of the National Aeronautics and Space Administration.
|
|
# All Rights Reserved.
|
|
#
|
|
# Copyright 2012 Nebula, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from collections import Sequence
|
|
import logging
|
|
|
|
from django.conf import settings
|
|
|
|
from horizon import exceptions
|
|
|
|
|
|
__all__ = ('APIResourceWrapper', 'APIDictWrapper',
|
|
'get_service_from_catalog', 'url_for',)
|
|
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class APIVersionManager(object):
|
|
""" Object to store and manage API versioning data and utility methods. """
|
|
|
|
SETTINGS_KEY = "OPENSTACK_API_VERSIONS"
|
|
|
|
def __init__(self, service_type, preferred_version=None):
|
|
self.service_type = service_type
|
|
self.preferred = preferred_version
|
|
self._active = None
|
|
self.supported = {}
|
|
|
|
@property
|
|
def active(self):
|
|
if self._active is None:
|
|
self.get_active_version()
|
|
return self._active
|
|
|
|
def load_supported_version(self, version, data):
|
|
self.supported[version] = data
|
|
|
|
def get_active_version(self):
|
|
if self._active is not None:
|
|
return self.supported[self._active]
|
|
key = getattr(settings, self.SETTINGS_KEY, {}).get(self.service_type)
|
|
if key is None:
|
|
# TODO: support API version discovery here; we'll leave the setting
|
|
# in as a way of overriding the latest available version.
|
|
key = self.preferred
|
|
self._active = key
|
|
return self.supported[self._active]
|
|
|
|
|
|
class APIResourceWrapper(object):
|
|
""" Simple wrapper for api objects
|
|
|
|
Define _attrs on the child class and pass in the
|
|
api object as the only argument to the constructor
|
|
"""
|
|
_attrs = []
|
|
|
|
def __init__(self, apiresource):
|
|
self._apiresource = apiresource
|
|
|
|
def __getattr__(self, attr):
|
|
if attr in self._attrs:
|
|
# __getattr__ won't find properties
|
|
return self._apiresource.__getattribute__(attr)
|
|
else:
|
|
msg = ('Attempted to access unknown attribute "%s" on '
|
|
'APIResource object of type "%s" wrapping resource of '
|
|
'type "%s".') % (attr, self.__class__,
|
|
self._apiresource.__class__)
|
|
LOG.debug(exceptions.error_color(msg))
|
|
raise AttributeError(attr)
|
|
|
|
|
|
class APIDictWrapper(object):
|
|
""" Simple wrapper for api dictionaries
|
|
|
|
Some api calls return dictionaries. This class provides identical
|
|
behavior as APIResourceWrapper, except that it will also behave as a
|
|
dictionary, in addition to attribute accesses.
|
|
|
|
Attribute access is the preferred method of access, to be
|
|
consistent with api resource objects from novclient.
|
|
"""
|
|
def __init__(self, apidict):
|
|
self._apidict = apidict
|
|
|
|
def __getattr__(self, attr):
|
|
try:
|
|
return self._apidict[attr]
|
|
except KeyError:
|
|
msg = 'Unknown attribute "%(attr)s" on APIResource object ' \
|
|
'of type "%(cls)s"' % {'attr': attr, 'cls': self.__class__}
|
|
LOG.debug(exceptions.error_color(msg))
|
|
raise AttributeError(msg)
|
|
|
|
def __getitem__(self, item):
|
|
try:
|
|
return self.__getattr__(item)
|
|
except AttributeError, e:
|
|
# caller is expecting a KeyError
|
|
raise KeyError(e)
|
|
|
|
def get(self, item, default=None):
|
|
try:
|
|
return self.__getattr__(item)
|
|
except AttributeError:
|
|
return default
|
|
|
|
|
|
class Quota(object):
|
|
"""Wrapper for individual limits in a quota."""
|
|
def __init__(self, name, limit):
|
|
self.name = name
|
|
self.limit = limit
|
|
|
|
def __repr__(self):
|
|
return "<Quota: (%s, %s)>" % (self.name, self.limit)
|
|
|
|
|
|
class QuotaSet(Sequence):
|
|
"""
|
|
Wrapper for client QuotaSet objects which turns the individual quotas
|
|
into Quota objects for easier handling/iteration.
|
|
|
|
`QuotaSet` objects support a mix of `list` and `dict` methods; you can use
|
|
the bracket notiation (`qs["my_quota"] = 0`) to add new quota values, and
|
|
use the `get` method to retrieve a specific quota, but otherwise it
|
|
behaves much like a list or tuple, particularly in supporting iteration.
|
|
"""
|
|
def __init__(self, apiresource=None):
|
|
self.items = []
|
|
if apiresource:
|
|
for k, v in apiresource._info.items():
|
|
if k == 'id':
|
|
continue
|
|
self[k] = v
|
|
|
|
def __setitem__(self, k, v):
|
|
v = int(v) if v is not None else v
|
|
q = Quota(k, v)
|
|
self.items.append(q)
|
|
|
|
def __getitem__(self, index):
|
|
return self.items[index]
|
|
|
|
def __len__(self):
|
|
return len(self.items)
|
|
|
|
def __repr__(self):
|
|
return repr(self.items)
|
|
|
|
def get(self, key, default=None):
|
|
match = [quota for quota in self.items if quota.name == key]
|
|
return match.pop() if len(match) else Quota(key, default)
|
|
|
|
|
|
def get_service_from_catalog(catalog, service_type):
|
|
if catalog:
|
|
for service in catalog:
|
|
if service['type'] == service_type:
|
|
return service
|
|
return None
|
|
|
|
|
|
# TODO: Use API discovery to determine the version, for now read the settings
|
|
IDENTITY_VERSION = getattr(settings, APIVersionManager.SETTINGS_KEY, {}).\
|
|
get('identity', 2.0)
|
|
|
|
|
|
# Mapping of V2 Catalog Endpoint_type to V3 Catalog Interfaces
|
|
ENDPOINT_TYPE_TO_INTERFACE = {
|
|
'publicURL': 'public',
|
|
'internalURL': 'internal',
|
|
'adminURL': 'admin',
|
|
}
|
|
|
|
|
|
def url_for(request, service_type, admin=False, endpoint_type=None):
|
|
endpoint_type = endpoint_type or getattr(settings,
|
|
'OPENSTACK_ENDPOINT_TYPE',
|
|
'publicURL')
|
|
catalog = request.user.service_catalog
|
|
service = get_service_from_catalog(catalog, service_type)
|
|
if admin:
|
|
endpoint_type = 'adminURL'
|
|
if service:
|
|
try:
|
|
if IDENTITY_VERSION < 3:
|
|
return service['endpoints'][0][endpoint_type]
|
|
else:
|
|
interface = ENDPOINT_TYPE_TO_INTERFACE.get(endpoint_type, '')
|
|
for endpoint in service['endpoints']:
|
|
if endpoint['interface'] == interface:
|
|
return endpoint['url']
|
|
except (IndexError, KeyError):
|
|
raise exceptions.ServiceCatalogException(service_type)
|
|
else:
|
|
raise exceptions.ServiceCatalogException(service_type)
|
|
|
|
|
|
def is_service_enabled(request, service_type, service_name=None):
|
|
service = get_service_from_catalog(request.user.service_catalog,
|
|
service_type)
|
|
if service and service_name:
|
|
return service['name'] == service_name
|
|
else:
|
|
return service is not None
|