def require_service(self, service_type, min_microversion=None, **kwargs):
"""Method to check whether a service exists
Usage:
class TestMeter(base.BaseFunctionalTest):
...
def setUp(self):
super(TestMeter, self).setUp()
self.require_service('metering')
:returns: True if the service exists, otherwise False.
"""
try:
data = self.conn.session.get_endpoint_data(
service_type=service_type, **kwargs)
except _exceptions.EndpointNotFound:
self.skipTest('Service {service_type} not found in cloud'.format(
service_type=service_type))
if not min_microversion:
return
if not (data.min_microversion
and data.max_microversion
and discover.version_between(
data.min_microversion,
data.max_microversion,
min_microversion)):
self.skipTest('Service {service_type} does not provide '
'microversion {ver}'.format(
service_type=service_type,
ver=min_microversion))
def require_service(self, service_type, min_microversion=None, **kwargs):
"""Method to check whether a service exists
Usage:
class TestMeter(base.BaseFunctionalTest):
...
def setUp(self):
super(TestMeter, self).setUp()
self.require_service('metering')
:returns: True if the service exists, otherwise False.
"""
try:
data = self.conn.session.get_endpoint_data(
service_type=service_type, **kwargs)
except _exceptions.EndpointNotFound:
self.skipTest('Service {service_type} not found in cloud'.format(
service_type=service_type))
if not min_microversion:
return
if not (data.min_microversion
and data.max_microversion and discover.version_between(
data.min_microversion, data.max_microversion,
min_microversion)):
self.skipTest('Service {service_type} does not provide '
'microversion {ver}'.format(
service_type=service_type, ver=min_microversion))
def supports_microversion(adapter, microversion, raise_exception=False):
"""Determine if the given adapter supports the given microversion.
Checks the min and max microversion asserted by the service and checks to
make sure that ``min <= microversion <= max``. Current default microversion
is taken into consideration if set and verifies that ``microversion <=
default``.
:param adapter: :class:`~keystoneauth1.adapter.Adapter` instance.
:param str microversion: String containing the desired microversion.
:param bool raise_exception: Raise exception when requested microversion
is not supported be the server side or is higher than the current
default microversion.
:returns: True if the service supports the microversion.
:rtype: bool
:raises: :class:`~openstack.exceptions.SDKException` when requested
microversion is not supported.
"""
endpoint_data = adapter.get_endpoint_data()
if (endpoint_data.min_microversion
and endpoint_data.max_microversion and discover.version_between(
endpoint_data.min_microversion, endpoint_data.max_microversion,
microversion)):
if adapter.default_microversion is not None:
# If default_microversion is set - evaluate
# whether it match the expectation
candidate = discover.normalize_version_number(
adapter.default_microversion)
required = discover.normalize_version_number(microversion)
supports = discover.version_match(required, candidate)
if raise_exception and not supports:
raise exceptions.SDKException(
'Required microversion {ver} is higher than currently '
'selected {curr}'.format(
ver=microversion, curr=adapter.default_microversion))
return supports
return True
if raise_exception:
raise exceptions.SDKException(
'Required microversion {ver} is not supported '
'by the server side'.format(ver=microversion))
return False
def supports_microversion(adapter, microversion):
"""Determine if the given adapter supports the given microversion.
Checks the min and max microversion asserted by the service and checks
to make sure that ``min <= microversion <= max``.
:param adapter:
:class:`~keystoneauth1.adapter.Adapter` instance.
:param str microversion:
String containing the desired microversion.
:returns: True if the service supports the microversion.
:rtype: bool
"""
endpoint_data = adapter.get_endpoint_data()
if (endpoint_data.min_microversion
and endpoint_data.max_microversion and discover.version_between(
endpoint_data.min_microversion, endpoint_data.max_microversion,
microversion)):
return True
return False
def supports_microversion(adapter, microversion):
"""Determine if the given adapter supports the given microversion.
Checks the min and max microversion asserted by the service and checks
to make sure that ``min <= microversion <= max``.
:param adapter:
:class:`~keystoneauth1.adapter.Adapter` instance.
:param str microversion:
String containing the desired microversion.
:returns: True if the service supports the microversion.
:rtype: bool
"""
endpoint_data = adapter.get_endpoint_data()
if (endpoint_data.min_microversion
and endpoint_data.max_microversion
and discover.version_between(
endpoint_data.min_microversion,
endpoint_data.max_microversion,
microversion)):
return True
return False
def get_session_client(self,
service_type,
version=None,
constructor=_adapter.OpenStackSDKAdapter,
**kwargs):
"""Return a prepped keystoneauth Adapter for a given service.
This is useful for making direct requests calls against a
'mounted' endpoint. That is, if you do:
client = get_session_client('compute')
then you can do:
client.get('/flavors')
and it will work like you think.
"""
version_request = self._get_version_request(service_type, version)
kwargs.setdefault('connect_retries',
self.get_connect_retries(service_type))
kwargs.setdefault('status_code_retries',
self.get_status_code_retries(service_type))
endpoint_override = self.get_endpoint(service_type)
version = version_request.version
min_api_version = (kwargs.pop('min_version', None)
or version_request.min_api_version)
max_api_version = (kwargs.pop('max_version', None)
or version_request.max_api_version)
# Older neutron has inaccessible discovery document. Nobody noticed
# because neutronclient hard-codes an append of v2.0. YAY!
if service_type == 'network':
version = None
min_api_version = None
max_api_version = None
if endpoint_override is None:
network_adapter = constructor(
session=self.get_session(),
service_type=self.get_service_type(service_type),
service_name=self.get_service_name(service_type),
interface=self.get_interface(service_type),
region_name=self.region_name,
)
network_endpoint = network_adapter.get_endpoint()
if not network_endpoint.rstrip().rsplit('/')[-1] == 'v2.0':
if not network_endpoint.endswith('/'):
network_endpoint += '/'
network_endpoint = urllib.parse.urljoin(
network_endpoint, 'v2.0')
endpoint_override = network_endpoint
client = constructor(
session=self.get_session(),
service_type=self.get_service_type(service_type),
service_name=self.get_service_name(service_type),
interface=self.get_interface(service_type),
region_name=self.region_name,
version=version,
min_version=min_api_version,
max_version=max_api_version,
endpoint_override=endpoint_override,
default_microversion=version_request.default_microversion,
rate_limit=self.get_rate_limit(service_type),
concurrency=self.get_concurrency(service_type),
**kwargs)
if version_request.default_microversion:
default_microversion = version_request.default_microversion
info = client.get_endpoint_data()
if not discover.version_between(info.min_microversion,
info.max_microversion,
default_microversion):
if self.get_default_microversion(service_type):
raise exceptions.ConfigException(
"A default microversion for service {service_type} of"
" {default_microversion} was requested, but the cloud"
" only supports a minimum of {min_microversion} and"
" a maximum of {max_microversion}.".format(
service_type=service_type,
default_microversion=default_microversion,
min_microversion=discover.version_to_string(
info.min_microversion),
max_microversion=discover.version_to_string(
info.max_microversion)))
else:
raise exceptions.ConfigException(
"A default microversion for service {service_type} of"
" {default_microversion} was requested, but the cloud"
" only supports a maximum of"
" only supports a minimum of {min_microversion} and"
" a maximum of {max_microversion}. The default"
" microversion was set because a microversion"
" formatted version string, '{api_version}', was"
" passed for the api_version of the service. If it"
" was not intended to set a default microversion"
" please remove anything other than an integer major"
" version from the version setting for"
" the service.".format(
service_type=service_type,
api_version=self.get_api_version(service_type),
default_microversion=default_microversion,
min_microversion=discover.version_to_string(
info.min_microversion),
max_microversion=discover.version_to_string(
info.max_microversion)))
return client
def get_session_client(
self, service_type, version=None,
constructor=proxy.Proxy,
**kwargs):
"""Return a prepped keystoneauth Adapter for a given service.
This is useful for making direct requests calls against a
'mounted' endpoint. That is, if you do:
client = get_session_client('compute')
then you can do:
client.get('/flavors')
and it will work like you think.
"""
version_request = self._get_version_request(service_type, version)
kwargs.setdefault('region_name', self.get_region_name(service_type))
kwargs.setdefault('connect_retries',
self.get_connect_retries(service_type))
kwargs.setdefault('status_code_retries',
self.get_status_code_retries(service_type))
kwargs.setdefault('statsd_prefix', self.get_statsd_prefix())
kwargs.setdefault('statsd_client', self.get_statsd_client())
kwargs.setdefault('prometheus_counter', self.get_prometheus_counter())
kwargs.setdefault(
'prometheus_histogram', self.get_prometheus_histogram())
kwargs.setdefault('influxdb_config', self._influxdb_config)
kwargs.setdefault('influxdb_client', self.get_influxdb_client())
endpoint_override = self.get_endpoint(service_type)
version = version_request.version
min_api_version = (
kwargs.pop('min_version', None) or version_request.min_api_version)
max_api_version = (
kwargs.pop('max_version', None) or version_request.max_api_version)
# Older neutron has inaccessible discovery document. Nobody noticed
# because neutronclient hard-codes an append of v2.0. YAY!
# Also, older octavia has a similar issue.
if service_type in ('network', 'load-balancer'):
version = None
min_api_version = None
max_api_version = None
if endpoint_override is None:
endpoint_override = self._get_hardcoded_endpoint(
service_type, constructor)
client = constructor(
session=self.get_session(),
service_type=self.get_service_type(service_type),
service_name=self.get_service_name(service_type),
interface=self.get_interface(service_type),
version=version,
min_version=min_api_version,
max_version=max_api_version,
endpoint_override=endpoint_override,
default_microversion=version_request.default_microversion,
rate_limit=self.get_rate_limit(service_type),
concurrency=self.get_concurrency(service_type),
**kwargs)
if version_request.default_microversion:
default_microversion = version_request.default_microversion
info = client.get_endpoint_data()
if not discover.version_between(
info.min_microversion,
info.max_microversion,
default_microversion
):
if self.get_default_microversion(service_type):
raise exceptions.ConfigException(
"A default microversion for service {service_type} of"
" {default_microversion} was requested, but the cloud"
" only supports a minimum of {min_microversion} and"
" a maximum of {max_microversion}.".format(
service_type=service_type,
default_microversion=default_microversion,
min_microversion=discover.version_to_string(
info.min_microversion),
max_microversion=discover.version_to_string(
info.max_microversion)))
else:
raise exceptions.ConfigException(
"A default microversion for service {service_type} of"
" {default_microversion} was requested, but the cloud"
" only supports a maximum of"
" only supports a minimum of {min_microversion} and"
" a maximum of {max_microversion}. The default"
" microversion was set because a microversion"
" formatted version string, '{api_version}', was"
" passed for the api_version of the service. If it"
" was not intended to set a default microversion"
" please remove anything other than an integer major"
" version from the version setting for"
" the service.".format(
service_type=service_type,
api_version=self.get_api_version(service_type),
default_microversion=default_microversion,
min_microversion=discover.version_to_string(
info.min_microversion),
max_microversion=discover.version_to_string(
info.max_microversion)))
return client
def get_session_client(self,
service_type,
version=None,
constructor=adapter.Adapter,
**kwargs):
"""Return a prepped keystoneauth Adapter for a given service.
This is useful for making direct requests calls against a
'mounted' endpoint. That is, if you do:
client = get_session_client('compute')
then you can do:
client.get('/flavors')
and it will work like you think.
"""
version_request = self._get_version_request(service_type, version)
kwargs.setdefault('connect_retries',
self.get_connect_retries(service_type))
kwargs.setdefault('status_code_retries',
self.get_status_code_retries(service_type))
client = constructor(
session=self.get_session(),
service_type=self.get_service_type(service_type),
service_name=self.get_service_name(service_type),
interface=self.get_interface(service_type),
region_name=self.region_name,
version=version_request.version,
min_version=version_request.min_api_version,
max_version=version_request.max_api_version,
endpoint_override=self.get_endpoint(service_type),
default_microversion=version_request.default_microversion,
**kwargs)
if version_request.default_microversion:
default_microversion = version_request.default_microversion
info = client.get_endpoint_data()
if not discover.version_between(info.min_microversion,
info.max_microversion,
default_microversion):
if self.get_default_microversion(service_type):
raise exceptions.ConfigException(
"A default microversion for service {service_type} of"
" {default_microversion} was requested, but the cloud"
" only supports a minimum of {min_microversion} and"
" a maximum of {max_microversion}.".format(
service_type=service_type,
default_microversion=default_microversion,
min_microversion=discover.version_to_string(
info.min_microversion),
max_microversion=discover.version_to_string(
info.max_microversion)))
else:
raise exceptions.ConfigException(
"A default microversion for service {service_type} of"
" {default_microversion} was requested, but the cloud"
" only supports a maximum of"
" only supports a minimum of {min_microversion} and"
" a maximum of {max_microversion}. The default"
" microversion was set because a microversion"
" formatted version string, '{api_version}', was"
" passed for the api_version of the service. If it"
" was not intended to set a default microversion"
" please remove anything other than an integer major"
" version from the version setting for"
" the service.".format(
service_type=service_type,
api_version=self.get_api_version(service_type),
default_microversion=default_microversion,
min_microversion=discover.version_to_string(
info.min_microversion),
max_microversion=discover.version_to_string(
info.max_microversion)))
return client
def bad(minver, maxver, cand):
self.assertFalse(discover.version_between(minver, maxver, cand))
def good(minver, maxver, cand):
self.assertTrue(discover.version_between(minver, maxver, cand))
def bad(minver, maxver, cand):
self.assertFalse(discover.version_between(minver, maxver, cand))
def good(minver, maxver, cand):
self.assertTrue(discover.version_between(minver, maxver, cand))
