474 lines
19 KiB
Python
474 lines
19 KiB
Python
# Copyright 2013, 2014 IBM Corp.
|
|
|
|
import logging
|
|
import re
|
|
import urlparse
|
|
|
|
import powervc.common.client.delegate as delegate
|
|
from oslo.utils import importutils
|
|
from powervc.common.constants import SERVICE_TYPES as SERVICE_TYPES
|
|
from powervc.common import netutils
|
|
from powervc.common.client.extensions.glance import Extended_V2_Client
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
class AbstractService(object):
|
|
"""a stub over a service endpoint which permits consumers
|
|
to create openstack python clients directly from this object.
|
|
"""
|
|
def __init__(self, svc_type, version, url, base_args, keystone):
|
|
self.svc_type = svc_type
|
|
self.version = version
|
|
self.url = url
|
|
self.base_args = base_args.copy()
|
|
self.keystone = keystone
|
|
self.base_name = SERVICE_TYPES[svc_type].to_codename()
|
|
self.client_version = version = version.replace('.', '_')
|
|
self.clazz = self._lookup_client()
|
|
self.extension = self._lookup_extension()
|
|
self.management_url = url
|
|
|
|
def _extend(self, client, client_extension=None, *extension_args):
|
|
if self.extension is None and client_extension is None:
|
|
return client
|
|
delegates = []
|
|
if client_extension is not None:
|
|
delegates.append(client_extension(client, *extension_args))
|
|
if self.extension is not None:
|
|
delegates.append(self.extension(client, *extension_args))
|
|
delegates.append(client)
|
|
# extend the base client using a mixin type delegate
|
|
return delegate.new_composite_deletgate(delegates)
|
|
|
|
def _patch(self, client):
|
|
try:
|
|
# if applicable patch the client
|
|
module = (importutils.
|
|
import_module("powervc.common.client.patch.%s" %
|
|
(self.base_name)))
|
|
module.patch_client(self, client)
|
|
except ImportError:
|
|
pass
|
|
return client
|
|
|
|
def _lookup_client(self):
|
|
return importutils.import_class("%sclient.%s.client.Client" %
|
|
(self.base_name,
|
|
self.get_client_version()))
|
|
|
|
def _lookup_extension(self):
|
|
try:
|
|
return (importutils.
|
|
import_class("powervc.common.client.extensions.%s.Client" %
|
|
(self.base_name)))
|
|
except ImportError:
|
|
return None
|
|
return None
|
|
|
|
def _chomp_version(self, version):
|
|
match = re.search('(v[0-9])[_]*[0-9]*', version, re.IGNORECASE)
|
|
if match:
|
|
version = match.group(1)
|
|
return version
|
|
|
|
def _init_std_client(self):
|
|
region_name = self.base_args.get('region_name', None)
|
|
return self._patch(self.clazz(self.base_args['username'],
|
|
self.base_args['password'],
|
|
self.base_args['tenant_name'],
|
|
self.base_args['auth_url'],
|
|
self.base_args['insecure'],
|
|
region_name=region_name,
|
|
cacert=self.base_args['cacert']))
|
|
|
|
def new_client(self, client_extension=None, *extension_args):
|
|
"""build and return a new python client for this service
|
|
|
|
:param client_extension: the optional subclass of
|
|
powervc.common.client.extensions.base to extend the python client with.
|
|
:param extension_args: optional arguments to pass to the client
|
|
extension when it is created.
|
|
"""
|
|
return self._extend(self._init_std_client(), client_extension,
|
|
*extension_args)
|
|
|
|
def get_client_version(self):
|
|
"""returns the version of the client for this service
|
|
"""
|
|
return self.client_version
|
|
|
|
|
|
class KeystoneService(AbstractService):
|
|
"""wrappers keystone service endpoint
|
|
"""
|
|
def __init__(self, *kargs):
|
|
super(KeystoneService, self).__init__(*kargs)
|
|
|
|
def new_client(self, client_extension=None, *extension_args):
|
|
return self._extend(self.clazz(**self.base_args), client_extension,
|
|
*extension_args)
|
|
|
|
def get_client_version(self):
|
|
if self.client_version == 'v3_0':
|
|
return 'v3'
|
|
return self.client_version
|
|
|
|
|
|
class CinderService(AbstractService):
|
|
"""wrappers cinder service endpoint
|
|
"""
|
|
def __init__(self, *kargs):
|
|
super(CinderService, self).__init__(*kargs)
|
|
|
|
def get_client_version(self):
|
|
return self._chomp_version(self.client_version)
|
|
|
|
|
|
class NovaService(AbstractService):
|
|
"""wrappers nova service endpoint
|
|
"""
|
|
def __init__(self, *kargs):
|
|
super(NovaService, self).__init__(*kargs)
|
|
|
|
def get_client_version(self):
|
|
if re.search('v2', self.client_version) is not None:
|
|
return 'v1_1'
|
|
return self.client_version
|
|
|
|
|
|
class GlanceService(AbstractService):
|
|
"""wrappers glance service endpoint
|
|
"""
|
|
def __init__(self, *kargs):
|
|
super(GlanceService, self).__init__(*kargs)
|
|
|
|
def new_client(self, client_extension=None, *extension_args):
|
|
url = self.url
|
|
if not url.endswith('/'):
|
|
url += '/'
|
|
if 'v2' in self.version:
|
|
client_info = {}
|
|
client_info['endpoint'] = self.url
|
|
client_info['cacert'] = self.base_args['cacert']
|
|
client_info['insecure'] = self.base_args['insecure']
|
|
client_info['token'] = self.keystone.auth_token
|
|
extened_client = Extended_V2_Client(client_info)
|
|
return (self._extend(self._patch(extened_client),
|
|
client_extension,
|
|
*extension_args))
|
|
return (self.
|
|
_extend(self.
|
|
_patch(self.clazz(url, token=self.keystone.auth_token,
|
|
insecure=self.base_args['insecure'],
|
|
cacert=self.base_args['cacert'])),
|
|
client_extension, *extension_args))
|
|
|
|
def get_client_version(self):
|
|
return self._chomp_version(self.client_version)
|
|
|
|
|
|
class NeutronService(AbstractService):
|
|
"""wrappers neutron service endpoint
|
|
"""
|
|
def __init__(self, *kargs):
|
|
super(NeutronService, self).__init__(*kargs)
|
|
|
|
def new_client(self, client_extension=None, *extension_args):
|
|
region_name = self.base_args.get('region_name', None)
|
|
return self._extend(self._patch(self.clazz(
|
|
username=self.base_args['username'],
|
|
tenant_name=self.base_args['tenant_name'],
|
|
password=self.base_args['password'],
|
|
auth_url=self.base_args['auth_url'],
|
|
endpoint_url=self.management_url,
|
|
insecure=self.base_args['insecure'],
|
|
region_name=region_name,
|
|
token=self.keystone.auth_token,
|
|
ca_cert=self.base_args['cacert'])),
|
|
client_extension, *extension_args)
|
|
|
|
def get_client_version(self):
|
|
if self.client_version.startswith('v1'):
|
|
return 'v2_0'
|
|
return self.client_version
|
|
|
|
|
|
class ClientServiceCatalog(object):
|
|
"""provides a simple catalog of openstack services
|
|
for a single host and permits consumers to query
|
|
those services based on service types, versions
|
|
as well as create new python clients from the service
|
|
directly.
|
|
"""
|
|
def __init__(self, base_client_opts, keystone):
|
|
self.base_opts = base_client_opts
|
|
self.keystone = keystone
|
|
|
|
# validate authN
|
|
self.token = self.keystone.auth_token
|
|
|
|
self.host = urlparse.urlsplit(self.base_opts['auth_url']).hostname
|
|
self.endpoints = {}
|
|
self.blacklist = [str(SERVICE_TYPES.s3), str(SERVICE_TYPES.ec2),
|
|
str(SERVICE_TYPES.ttv)]
|
|
|
|
self._discover_services()
|
|
|
|
def new_client(self, svc_type, client_extension=None, *extension_args):
|
|
"""creates a new python client for the given service type
|
|
using the most recent version of the service in the catalog.
|
|
|
|
:param svc_type: the service type to create a client for
|
|
:param client_extension: the optional extension to decorate
|
|
the base client with
|
|
:param extension_args: optional arguments to pass to the client
|
|
extension when it is created.
|
|
"""
|
|
service_versions = self.get_services(svc_type)
|
|
if service_versions:
|
|
return service_versions[0].new_client(client_extension,
|
|
*extension_args)
|
|
return None
|
|
|
|
def get_services(self, svc_type, version_filter=None):
|
|
"""queries this catalogs services based on service type
|
|
and version filter.
|
|
|
|
:param svc_type: the type of service to query.
|
|
:param version_filter: a filter string to indicate the
|
|
service version the caller wants. if None the highest
|
|
version of the service is returned.
|
|
"""
|
|
if svc_type not in self.endpoints:
|
|
return None
|
|
|
|
def _find_version(versions, version_filter):
|
|
for version in versions.keys():
|
|
if version.find(version_filter) > -1:
|
|
return versions[version]
|
|
|
|
versions = self.endpoints[svc_type]
|
|
# Here we need test version_filter is None or empty, use 'if not'.
|
|
if not version_filter:
|
|
return versions[max(versions, key=str)]
|
|
|
|
version = _find_version(versions, version_filter)
|
|
if version is not None:
|
|
return version
|
|
# >> fix bug/1358215 - timing issue between openstack service endpoints
|
|
# becoming active and powervc-driver's client initialization of those.
|
|
# Check https://review.openstack.org/#/c/115519/ for the details.
|
|
# TODO(design): re-consider for #2 in the commit message
|
|
else:
|
|
# A lock is not necessary here. Only glance sync service use
|
|
# specified version apis and might run into this and starup_sync
|
|
# won't pass until the specified versions are ready. So there
|
|
# shouldn't be concurrent accesses to self.endpoints[svc_type] with
|
|
# svc_type='image'.
|
|
LOG.info(_("rediscover service for type:%s") % svc_type)
|
|
self._rediscover_service(svc_type)
|
|
versions = self.endpoints[svc_type]
|
|
return _find_version(versions, version_filter)
|
|
# << fix bug/1358215
|
|
|
|
def get_versions(self, svc_type):
|
|
"""return a list of the versions for the given service type
|
|
|
|
:param svc_type: the type of service to query
|
|
"""
|
|
if svc_type not in self.endpoints:
|
|
return None
|
|
return self.endpoints[svc_type].keys()
|
|
|
|
def get_version(self, svc_type, version_filter=None):
|
|
"""query a service to determine if a given version exists.
|
|
|
|
:param svc_type: the service type to query.
|
|
:param version_filter: a string to search for in the version.
|
|
if None the most recent version of the service type is returned.
|
|
"""
|
|
if svc_type not in self.endpoints:
|
|
return None
|
|
for version in self.endpoints[svc_type].keys():
|
|
if not version_filter or version.find(version_filter) > -1:
|
|
return version
|
|
return None
|
|
|
|
def get_service_types(self):
|
|
"""returns a list of all service types in this catalog.
|
|
"""
|
|
return self.endpoints.keys()
|
|
|
|
def get_token(self):
|
|
"""returns a keystone token for the host this catalog
|
|
belongs to.
|
|
"""
|
|
return self.keystone.auth_token
|
|
|
|
def get_client(self, svc_type, version_filter=None, client_extension=None,
|
|
*extension_args):
|
|
"""creates a new python cient for the given service type
|
|
and version.
|
|
|
|
:param svc_type: the service type to create a client for.
|
|
:param version_filter: a string to search for in the version
|
|
the caller wants. if None the most recent version is used.
|
|
:param client_extension: the optional class to extend
|
|
the client with
|
|
"""
|
|
services = self.get_services(svc_type, version_filter)
|
|
if not services:
|
|
return None
|
|
return services[0].new_client(client_extension, *extension_args)
|
|
|
|
def _parse_link_href(self, links):
|
|
hrefs = []
|
|
for link_meta in links:
|
|
if link_meta['rel'] == 'self':
|
|
href = self._filter_host(link_meta['href'])
|
|
hrefs.append(href)
|
|
return hrefs
|
|
|
|
def _filter_host(self, loc):
|
|
# endpoint urls from base api query will often
|
|
# return localhost in the url; resolve those
|
|
return loc.replace('localhost',
|
|
self.host).replace('127.0.0.1',
|
|
self.host).replace('0.0.0.0',
|
|
self.host)
|
|
|
|
def _parse_version_meta(self, ver, ver_map={}):
|
|
ver_map[ver['id']] = self._parse_link_href(ver['links'])
|
|
return ver_map
|
|
|
|
def _parse_version(self, response_json, url):
|
|
if response_json is not None:
|
|
if 'version' in response_json:
|
|
return {response_json['version']['id']:
|
|
[self._filter_host(url)]}
|
|
elif 'versions' in response_json:
|
|
services = {}
|
|
versions = response_json['versions']
|
|
if 'values' in versions:
|
|
versions = versions['values']
|
|
for version_meta in versions:
|
|
if 'status' in version_meta and \
|
|
version_meta['status'] == 'CURRENT':
|
|
ver = version_meta['id']
|
|
if ver not in services:
|
|
services[ver] = []
|
|
services[ver].append(self._filter_host(url))
|
|
return services
|
|
return None
|
|
|
|
def _parse_version_from_url(self, url):
|
|
for seg in reversed(url.split('/')):
|
|
match = re.search('^(v[0-9][.]?[0-9]?$)', seg, re.IGNORECASE)
|
|
if match:
|
|
return match.group(0)
|
|
return None
|
|
|
|
def _build_wrappered_services(self, version_map, svc_type):
|
|
services = {}
|
|
for version in version_map.keys():
|
|
wrappers = []
|
|
for s_url in version_map[version]:
|
|
if svc_type == (str(SERVICE_TYPES.compute) or
|
|
svc_type == str(SERVICE_TYPES.computev3)):
|
|
wrappers.append(NovaService(svc_type, version,
|
|
s_url, self.base_opts,
|
|
self.keystone))
|
|
elif svc_type == str(SERVICE_TYPES.image):
|
|
wrappers.append(GlanceService(svc_type, version,
|
|
s_url, self.base_opts,
|
|
self.keystone))
|
|
elif svc_type == str(SERVICE_TYPES.identity):
|
|
# keystone is a special case as the auth url given
|
|
# in the base opts may not match the auth url from
|
|
# the catalog
|
|
keystone_opts = self.base_opts.copy()
|
|
keystone_opts['auth_url'] = s_url
|
|
wrappers.append(KeystoneService(svc_type, version,
|
|
s_url, keystone_opts,
|
|
self.keystone))
|
|
elif svc_type == str(SERVICE_TYPES.volume):
|
|
wrappers.append(CinderService(svc_type, version,
|
|
s_url, self.base_opts,
|
|
self.keystone))
|
|
elif svc_type == str(SERVICE_TYPES.network):
|
|
wrappers.append(NeutronService(svc_type, version,
|
|
s_url, self.base_opts,
|
|
self.keystone))
|
|
services[version] = wrappers
|
|
return services
|
|
|
|
def _query_endpoint(self, url):
|
|
# query the endpoint to get version info
|
|
client = netutils.JSONRESTClient(self.get_token())
|
|
urldata = urlparse.urlsplit(url)
|
|
host = urldata.scheme + '://' + urldata.netloc
|
|
segments = filter(lambda x: x != '', urldata.path.split('/'))
|
|
if not segments:
|
|
segments = ['']
|
|
# chomp uri until we find base of endpoint
|
|
for segment in segments[:] or ['']:
|
|
endpoint_url = "%s/%s/" % (host, '/'.join(segments))
|
|
segments.pop()
|
|
response = None
|
|
try:
|
|
response = client.get(endpoint_url)
|
|
except:
|
|
continue
|
|
versions = self._parse_version(response, url)
|
|
if versions is not None:
|
|
return versions
|
|
return {'v1': [url]}
|
|
|
|
def _build_endpoint_services(self, url, svc_type):
|
|
# try to parse from the url
|
|
ver = self._parse_version_from_url(url)
|
|
if ver is not None:
|
|
return self._build_wrappered_services({ver: [url]}, svc_type)
|
|
versions = self._query_endpoint(url)
|
|
# From the latest ICM, versions are stripped from image service,
|
|
# only ip:port left, in this case only "CURRENT" status client can be
|
|
# retrieved, that is to say, for image service only v2.3 url returned
|
|
# but v1.1 is lost, this will fail glance sync progress as both of
|
|
# v2.3 and v1.1 are necessary, add this workaround to fix the problem.
|
|
if svc_type == str(SERVICE_TYPES.image):
|
|
versions['v1'] = [url]
|
|
return self._build_wrappered_services(versions, svc_type)
|
|
|
|
def _normalize_catalog_entry(self, entry):
|
|
for key in entry.keys():
|
|
if re.search('url', key, re.IGNORECASE):
|
|
entry[key] = self._filter_host(entry[key])
|
|
if self.keystone.version == 'v2.0':
|
|
# keystone v2.0 entries differ from v3; normalize
|
|
entry['url'] = entry['publicURL']
|
|
return entry
|
|
|
|
def _discover_services(self):
|
|
public_eps = (self.keystone.
|
|
service_catalog.get_endpoints(endpoint_type='publicURL'))
|
|
self.endpoints = {}
|
|
for svc_type in public_eps.keys():
|
|
if svc_type in self.blacklist:
|
|
continue
|
|
for entry in public_eps[svc_type]:
|
|
entry = self._normalize_catalog_entry(entry)
|
|
self.endpoints[svc_type] = \
|
|
self._build_endpoint_services(entry['url'], svc_type)
|
|
|
|
# >> fix bug/1358215, timing issue between openstack service endpoints
|
|
# becoming active and powervc-driver's client initialization of those.
|
|
def _rediscover_service(self, svc_type):
|
|
public_eps = (self.keystone.
|
|
service_catalog.get_endpoints(endpoint_type='publicURL'))
|
|
for entry in public_eps[svc_type]:
|
|
entry = self._normalize_catalog_entry(entry)
|
|
self.endpoints[svc_type] = \
|
|
self._build_endpoint_services(entry['url'], svc_type)
|
|
# << fix bug/1358215
|