def create_client(self, version=None, **kwargs):
"""Factory function to create a new identity service client.
:param tuple version: The required version of the identity API. If
specified the client will be selected such that
the major version is equivalent and an endpoint
provides at least the specified minor version.
For example to specify the 3.1 API use (3, 1).
(optional)
:param bool unstable: Accept endpoints not marked 'stable'. (optional)
:param kwargs: Additional arguments will override those provided to
this object's constructor.
:returns: An instantiated identity client object.
:raises: DiscoveryFailure if the server response is invalid
:raises: VersionNotAvailable if a suitable client cannot be found.
"""
versions = self._available_clients(**kwargs)
chosen = None
if version:
version = _normalize_version_number(version)
for keystone_version in six.itervalues(versions):
# major versions must be the same (eg even though v2 is a lower
# version than v3 we can't use it if v2 was requested)
if version[0] != keystone_version.version[0]:
continue
# prevent selecting a minor version less than what is required
if version <= keystone_version.version:
chosen = keystone_version
break
elif versions:
# if no version specified pick the latest one
chosen = max(six.iteritems(versions))[1]
if not chosen:
msg = "Could not find a suitable endpoint"
if version:
msg = "%s for client version: %s" % (msg, version)
if versions:
available = ", ".join(
[v._str_ver for v in six.itervalues(versions)])
msg = "%s. Available_versions are: %s" % (msg, available)
else:
msg = "%s. No versions reported available" % msg
raise exceptions.VersionNotAvailable(msg)
return chosen.create_client()
def get_rate_projects(self):
keystone_version = discover.normalize_version_number('3')
auth_dispatch = {
(3, ): ('project', 'projects', 'list'),
(2, ): ('tenant', 'tenants', 'roles_for_user')
}
for auth_version, auth_version_mapping in six.iteritems(auth_dispatch):
if discover.version_match(auth_version, keystone_version):
return self._do_get_projects(auth_version_mapping)
msg = "Keystone version you've specified is not supported"
raise exceptions.VersionNotAvailable(msg)
def get_tenants(self, conf=None):
keystone_version = discover.normalize_version_number(
CONF.keystone_fetcher.keystone_version)
auth_dispatch = {
(3, ): ('project', 'projects', 'list'),
(2, ): ('tenant', 'tenants', 'roles_for_user')
}
for auth_version, auth_version_mapping in auth_dispatch.items():
if discover.version_match(auth_version, keystone_version):
return self._do_get_tenants(auth_version_mapping, conf)
msg = "Keystone version you've specified is not supported"
raise exceptions.VersionNotAvailable(msg)
def _calculate_version(self, version, unstable):
version_data = None
if version:
version_data = self.data_for(version)
else:
# if no version specified pick the latest one
all_versions = self.version_data(unstable=unstable)
if all_versions:
version_data = all_versions[-1]
if not version_data:
msg = 'Could not find a suitable endpoint'
if version:
msg += ' for client version: %s' % str(version)
raise exceptions.VersionNotAvailable(msg)
return version_data
def _filter_current_endpoint(self, service_catalog, service_type,
region_name, service_name,
endpoint_type='publicURL',
filter_attr=None,
filter_value=None):
"""
Helper method to filter latest version of cloudBigData public URL
By default choose public URL available if no versioning
otherwise filter specific version.
"""
current_lava_url = None
sc_endpoints = service_catalog.get_endpoints(
service_type=service_type, endpoint_type=endpoint_type,
region_name=region_name, service_name=service_name)
if not sc_endpoints.get(service_type, []):
sc_endpoints = {}
if service_type not in sc_endpoints:
self._throw_endpoint_error(endpoint_type, service_name,
region_name, service_type)
endpoints = sc_endpoints.get(service_type)
if filter_attr:
endpoints = [endpoint
for endpoint in endpoints
if endpoint.get(filter_attr) == filter_value]
fallback_url = None
for endpoint in endpoints:
version_id = endpoint.get('versionId')
if version_id is None:
fallback_url = endpoint[endpoint_type]
elif version_id == CURRENT_LAVA_VERSION:
current_lava_url = endpoint[endpoint_type]
if not (current_lava_url or fallback_url):
raise ks_error.VersionNotAvailable(
'Unable to find version V{0} for the bigdata '
'endpoint'.format(CURRENT_LAVA_VERSION))
return current_lava_url or fallback_url
