def make_client(instance):
"""Returns an image service client"""
image_client = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating image client: %s', image_client)
endpoint = instance.get_endpoint_for_service_type(
API_NAME,
region_name=instance.region_name,
interface=instance.interface,
)
client = image_client(
endpoint,
token=instance.auth.get_token(instance.session),
cacert=instance.cacert,
insecure=not instance.verify,
)
# Create the low-level API
image_api = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
IMAGE_API_VERSIONS)
LOG.debug('Instantiating image api: %s', image_api)
client.api = image_api(session=instance.session,
endpoint=instance.get_endpoint_for_service_type(
IMAGE_API_TYPE,
region_name=instance.region_name,
interface=instance.interface,
))
return client
def make_client(instance):
"""Returns a compute service client."""
# Defer client import until we actually need them
from novaclient import client as nova_client
if _compute_api_version is not None:
version = _compute_api_version
else:
version = instance._api_version[API_NAME]
from novaclient import api_versions
# convert to APIVersion object
version = api_versions.get_api_version(version)
if version.is_latest():
import novaclient
# NOTE(RuiChen): executing version discovery make sense, but that need
# an initialized REST client, it's not available now,
# fallback to use the max version of novaclient side.
version = novaclient.API_MAX_VERSION
LOG.debug('Instantiating compute client for %s', version)
compute_api = utils.get_client_class(
API_NAME,
version.ver_major,
COMPUTE_API_VERSIONS,
)
LOG.debug('Instantiating compute api: %s', compute_api)
# Set client http_log_debug to True if verbosity level is high enough
http_log_debug = utils.get_effective_log_level() <= logging.DEBUG
extensions = [ext for ext in nova_client.discover_extensions(version)
if ext.name == "list_extensions"]
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance.interface)
client = nova_client.Client(
version,
session=instance.session,
extensions=extensions,
http_log_debug=http_log_debug,
timings=instance.timing,
region_name=instance.region_name,
**kwargs
)
client.api = compute_api(
session=instance.session,
service_type=COMPUTE_API_TYPE,
endpoint=instance.get_endpoint_for_service_type(
COMPUTE_API_TYPE,
region_name=instance.region_name,
interface=instance.interface,
)
)
return client
def make_client(instance):
"""Returns a zun service client"""
requested_api_version = instance._api_version[API_NAME]
zun_client = utils.get_client_class(
API_NAME,
requested_api_version,
API_VERSIONS)
LOG.debug("Instantiating zun client: {0}".format(
zun_client))
api_version = api_versions.get_api_version(requested_api_version)
if api_version.is_latest():
client = zun_client(
region_name=instance._region_name,
session=instance.session,
service_type='container',
api_version=api_versions.APIVersion("1.1"),
)
api_version = api_versions.discover_version(client, api_version)
client = zun_client(
region_name=instance._region_name,
session=instance.session,
service_type='container',
api_version=api_version,
)
return client
def make_client(instance):
"""Returns a volume service client."""
# Defer client imports until we actually need them
from cinderclient import extension
from cinderclient.v1.contrib import list_extensions
from cinderclient.v1 import volume_snapshots
from cinderclient.v1 import volumes
# Monkey patch for v1 cinderclient
volumes.Volume.NAME_ATTR = 'display_name'
volume_snapshots.Snapshot.NAME_ATTR = 'display_name'
volume_client = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating volume client: %s', volume_client)
# Set client http_log_debug to True if verbosity level is high enough
http_log_debug = utils.get_effective_log_level() <= logging.DEBUG
extensions = [extension.Extension('list_extensions', list_extensions)]
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance.interface)
client = volume_client(session=instance.session,
extensions=extensions,
http_log_debug=http_log_debug,
region_name=instance.region_name,
**kwargs)
return client
def local_orchestration_client(host="127.0.0.1", api_port=8006):
"""Returns a local orchestration service client"""
API_VERSIONS = {
'1': 'heatclient.v1.client.Client',
}
heat_client = osc_lib_utils.get_client_class(
'tripleoclient',
'1',
API_VERSIONS)
LOG.debug('Instantiating local_orchestration client for '
'host %s, port %s: %s',
host, api_port, heat_client)
endpoint = 'http://%s:%s/v1/admin' % (host, api_port)
client = heat_client(
endpoint=endpoint,
username='******',
password='******',
region_name='regionOne',
token='fake',
)
global heatclient
heatclient = EphemeralHeatClient(client, host, api_port)
return heatclient
def make_client(instance):
"""Returns an baremetal service client"""
mogan_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating baremetal-compute client: %s', mogan_client)
endpoint = instance.get_endpoint_for_service_type(
API_NAME,
region_name=instance.region_name,
interface=instance.interface,
)
kwargs = {'endpoint': endpoint,
'auth_url': instance.auth.auth_url,
'region_name': instance.region_name,
'username': instance.auth_ref.username}
if instance.session:
kwargs.update(session=instance.session)
else:
kwargs.update(token=instance.auth_ref.auth_token)
client = mogan_client(**kwargs)
return client
def local_orchestration(self, api_port):
"""Returns an local_orchestration service client"""
if self._local_orchestration is not None:
return self._local_orchestration
API_VERSIONS = {
'1': 'heatclient.v1.client.Client',
}
heat_client = utils.get_client_class(
API_NAME,
'1',
API_VERSIONS)
LOG.debug('Instantiating local_orchestration client: %s', heat_client)
client = heat_client(
endpoint='http://127.0.0.1:%s/v1/admin' % api_port,
username='******',
password='******',
region_name='regionOne',
token='fake',
)
self._local_orchestration = client
return self._local_orchestration
def make_client(instance):
"""Returns a baremetal service client."""
requested_api_version = instance._api_version[API_NAME]
baremetal_client_class = utils.get_client_class(API_NAME,
requested_api_version,
API_VERSIONS)
LOG.debug('Instantiating baremetal client: %s', baremetal_client_class)
LOG.debug(
'Baremetal API version: %s',
requested_api_version if not OS_BAREMETAL_API_LATEST else "latest")
if requested_api_version == '1':
# NOTE(dtantsur): '1' means 'the latest v1 API version'. Since we don't
# have other major versions, it's identical to 'latest'.
requested_api_version = LATEST_VERSION
allow_api_version_downgrade = True
else:
allow_api_version_downgrade = OS_BAREMETAL_API_LATEST
client = baremetal_client_class(
os_ironic_api_version=requested_api_version,
# NOTE(dtantsur): enable re-negotiation of the latest version, if CLI
# latest is too high for the server we're talking to.
allow_api_version_downgrade=allow_api_version_downgrade,
session=instance.session,
region_name=instance._region_name,
# NOTE(vdrok): This will be set as endpoint_override, and the Client
# class will be able to do the version stripping if needed
endpoint=instance.get_endpoint_for_service_type(
API_NAME,
interface=instance.interface,
region_name=instance._region_name))
return client
def make_client(instance):
"""Returns an orchestration service client"""
heat_client = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating orchestration client: %s', heat_client)
kwargs = {
'region_name': instance.region_name,
'interface': instance.interface
}
if instance.session:
kwargs.update({'session': instance.session, 'service_type': API_NAME})
elif instance.auth_plugin_name == 'token_endpoint':
kwargs.update({
'endpoint': instance.auth.url,
'token': instance.auth.token
})
else:
endpoint = instance.get_endpoint_for_service_type(
API_NAME,
region_name=instance.region_name,
interface=instance.interface,
)
kwargs.update({
'endpoint': endpoint,
'auth_url': instance.auth.auth_url,
'username': instance.auth_ref.username,
'token': instance.auth_ref.auth_token
})
client = heat_client(**kwargs)
return client
def make_client(instance):
"""Returns an queues service client."""
global _MESSAGING_ENDPOINT
version = instance._api_version[API_NAME]
try:
version = int(version)
except ValueError:
version = float(version)
queues_client = utils.get_client_class(API_NAME, version, API_VERSIONS)
# TODO(wangxiyuan): Use public attributes instead of private attributes.
if not _MESSAGING_ENDPOINT:
_MESSAGING_ENDPOINT = instance.get_endpoint_for_service_type(
API_NAME,
region_name=instance._region_name,
interface=instance._interface)
auth_params = instance.get_configuration()['auth']
auth_params.update({
"auth_token": instance.auth.get_token(instance.session),
"insecure": instance._insecure,
"cacert": instance._cacert,
"region_name": instance._region_name
})
conf = {"auth_opts": {'options': auth_params}}
LOG.debug('Instantiating queues service client: %s', queues_client)
return queues_client(_MESSAGING_ENDPOINT, version, conf)
def make_client(instance):
"""Returns an orchestration service client"""
heat_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating orchestration client: %s', heat_client)
kwargs = {'region_name': instance.region_name,
'interface': instance.interface}
if instance.session:
kwargs.update({'session': instance.session,
'service_type': API_NAME})
else:
endpoint = instance.get_endpoint_for_service_type(
API_NAME,
region_name=instance.region_name,
interface=instance.interface,
)
kwargs.update({'endpoint': endpoint,
'auth_url': instance.auth.auth_url,
'username': instance.auth_ref.username,
'token': instance.auth_ref.auth_token})
client = heat_client(**kwargs)
return client
def make_client(instance):
"""Returns a shared file system service client."""
requested_api_version = instance._api_version[API_NAME]
shared_file_system_client = utils.get_client_class(
API_NAME, requested_api_version, API_VERSIONS)
# Cast the API version into an object for further processing
requested_api_version = api_versions.APIVersion(
version_str=requested_api_version)
LOG.debug('Instantiating Shared File System (share) client: %s',
shared_file_system_client)
LOG.debug('Shared File System API version: %s',
requested_api_version)
service_type, manila_endpoint_url = _get_manila_url_from_service_catalog(
instance)
instance.setup_auth()
debugging_enabled = instance._cli_options.debug
client = shared_file_system_client(session=instance.session,
service_catalog_url=manila_endpoint_url,
endpoint_type=instance.interface,
region_name=instance.region_name,
service_type=service_type,
auth=instance.auth,
http_log_debug=debugging_enabled,
api_version=requested_api_version)
return client
def make_client(instance):
cls = oscutils.get_client_class(API_NAME, instance._api_version[API_NAME],
API_VERSIONS)
kwargs = oscutils.build_kwargs_dict('endpoint_type', instance._interface)
return cls(session=instance.session,
region_name=instance._region_name,
**kwargs)
def make_client(instance):
cls = oscutils.get_client_class(
API_NAME, instance._api_version[API_NAME],
API_VERSIONS)
kwargs = oscutils.build_kwargs_dict('endpoint_type', instance._interface)
return cls(session=instance.session,
region_name=instance._region_name, **kwargs)
def make_client(instance):
"""Returns a compute service client."""
# Defer client import until we actually need them
from novaclient import client as nova_client
if _compute_api_version is not None:
version = _compute_api_version
else:
version = instance._api_version[API_NAME]
from novaclient import api_versions
# convert to APIVersion object
version = api_versions.get_api_version(version)
if version.is_latest():
import novaclient
# NOTE(RuiChen): executing version discovery make sense, but that need
# an initialized REST client, it's not available now,
# fallback to use the max version of novaclient side.
version = novaclient.API_MAX_VERSION
LOG.debug('Instantiating compute client for %s', version)
compute_api = utils.get_client_class(
API_NAME,
version.ver_major,
COMPUTE_API_VERSIONS,
)
LOG.debug('Instantiating compute api: %s', compute_api)
# Set client http_log_debug to True if verbosity level is high enough
http_log_debug = utils.get_effective_log_level() <= logging.DEBUG
extensions = [
ext for ext in nova_client.discover_extensions(version)
if ext.name == "list_extensions"
]
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance.interface)
client = nova_client.Client(version,
session=instance.session,
extensions=extensions,
http_log_debug=http_log_debug,
timings=instance.timing,
region_name=instance.region_name,
**kwargs)
client.api = compute_api(session=instance.session,
service_type=COMPUTE_API_TYPE,
endpoint=instance.get_endpoint_for_service_type(
COMPUTE_API_TYPE,
region_name=instance.region_name,
interface=instance.interface,
))
return client
def make_client(instance):
"""Returns a volume service client."""
# Defer client imports until we actually need them
from cinderclient import extension
from cinderclient.v3.contrib import list_extensions
from cinderclient.v3 import volume_snapshots
from cinderclient.v3 import volumes
# Check whether the available cinderclient supports v1 or v2
try:
from cinderclient.v1 import services # noqa
except Exception:
del API_VERSIONS['1']
try:
from cinderclient.v2 import services # noqa
except Exception:
del API_VERSIONS['2']
if _volume_api_version is not None:
version = _volume_api_version
else:
version = instance._api_version[API_NAME]
from cinderclient import api_versions
# convert to APIVersion object
version = api_versions.get_api_version(version)
if version.ver_major == '1':
# Monkey patch for v1 cinderclient
volumes.Volume.NAME_ATTR = 'display_name'
volume_snapshots.Snapshot.NAME_ATTR = 'display_name'
volume_client = utils.get_client_class(API_NAME, version.ver_major,
API_VERSIONS)
LOG.debug('Instantiating volume client: %s', volume_client)
# Set client http_log_debug to True if verbosity level is high enough
http_log_debug = utils.get_effective_log_level() <= logging.DEBUG
extensions = [extension.Extension('list_extensions', list_extensions)]
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance.interface)
endpoint_override = instance.sdk_connection.config.get_endpoint(
'block-storage')
client = volume_client(session=instance.session,
extensions=extensions,
http_log_debug=http_log_debug,
region_name=instance.region_name,
endpoint_override=endpoint_override,
api_version=version,
**kwargs)
return client
def make_client(instance):
"""Returns a rating service client."""
version = instance._api_version[API_NAME]
ck_client = utils.get_client_class(API_NAME, version, API_VERSIONS)
instance.setup_auth()
adapter_options = dict(
interface=instance.interface,
region_name=instance.region_name,
)
return ck_client(session=instance.session, adapter_options=adapter_options)
def make_client(instance):
"""Returns an application-catalog service client"""
application_catalog_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug("Instantiating application-catalog client: {0}".format(
application_catalog_client))
kwargs = {
'session': instance.session,
'service_type': 'application-catalog',
'region_name': instance._region_name
}
murano_packages_service = \
instance.get_configuration().get('murano_packages_service')
if murano_packages_service == 'glare':
glare_endpoint = instance.get_configuration().get('glare_url')
if not glare_endpoint:
try:
# no glare_endpoint and we requested to store packages in glare
# check keystone catalog
glare_endpoint = instance.get_endpoint_for_service_type(
'artifact',
region_name=instance._region_name,
interface=instance._interface
)
except Exception:
raise exc.CommandError(
"You set murano-packages-service to {}"
" but there is not 'artifact' endpoint in keystone"
" Either register one or specify endpoint "
" via either --glare-url or env[GLARE_API]".format(
murano_packages_service))
artifacts_client = art_client.Client(
endpoint=glare_endpoint,
type_name='murano',
type_version=1,
token=instance.auth_ref.auth_token)
kwargs['artifacts_client'] = artifacts_client
murano_endpoint = instance.get_configuration().get('murano_url')
if not murano_endpoint:
murano_endpoint = instance.get_endpoint_for_service_type(
'application-catalog',
region_name=instance._region_name,
interface=instance._interface
)
client = application_catalog_client(murano_endpoint, **kwargs)
return client
def make_client(instance):
"""Returns a instance_ha proxy"""
version = instance._api_version[API_NAME]
masakari_client = utils.get_client_class(API_NAME, version, API_VERSIONS)
LOG.debug('Instantiating masakari service client: %s', masakari_client)
client = masakari_client(session=instance.session,
interface=instance.interface,
region_name=instance.region_name,
api_version=instance._api_version[API_NAME])
return client.service
def make_client(instance):
"""Returns an queues service client."""
version = instance._api_version[API_NAME]
try:
version = int(version)
except ValueError:
version = float(version)
aodh_client = utils.get_client_class(API_NAME, version, API_VERSIONS)
# NOTE(sileht): ensure setup of the session is done
instance.setup_auth()
return aodh_client(session=instance.session)
def make_client(instance):
"""Returns a nuage service client"""
nuage_client = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating nuage client: %s', nuage_client)
client = nuage_client(session=instance.session,
region_name=instance.region_name,
endpoint_type=instance.interface,
insecure=not instance.verify,
ca_cert=instance.cacert)
return client
def make_client(instance):
"""Returns a database service client"""
trove_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating database client: %s', trove_client)
client = trove_client(
auth=instance.auth,
session=instance.session
)
return client
def make_client(instance):
"""Returns an infra-optim service client."""
infraoptim_client_class = utils.get_client_class(
API_NAME, instance._api_version[API_NAME], API_VERSIONS)
LOG.debug('Instantiating infraoptim client: %s', infraoptim_client_class)
client = infraoptim_client_class(
os_watcher_api_version=instance._api_version[API_NAME],
session=instance.session,
region_name=instance._region_name,
)
return client
def make_client(instance):
"""Returns a knob service client"""
knob_client = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance._interface)
client = knob_client(session=instance.session,
region_name=instance._region_name,
**kwargs)
return client
def make_client(instance):
"""Returns a zun service client"""
zun_client = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug("Instantiating zun client: {0}".format(zun_client))
client = zun_client(
region_name=instance._region_name,
session=instance.session,
service_type='container',
)
return client
def make_client(instance):
"""Returns a workflow_engine service client."""
version = instance._api_version[API_NAME]
workflow_client = utils.get_client_class(API_NAME, version, API_VERSIONS)
LOG.debug('Instantiating workflow engine client: %s', workflow_client)
mistral_url = instance.get_endpoint_for_service_type('workflowv2',
interface='publicURL')
client = workflow_client(mistral_url=mistral_url, session=instance.session)
return client
def make_client(instance):
"""Returns a magnum client."""
magnum_client = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating magnum client: %s', magnum_client)
client = magnum_client(session=instance.session,
region_name=instance._region_name,
interface=instance._interface,
insecure=instance._insecure,
ca_cert=instance._cacert)
return client
def make_client(instance):
"""Returns a bsn neutron client."""
bsn_neutron_client = utils.get_client_class(
API_NAME, instance._api_version[API_NAME], API_VERSIONS)
LOG.debug('Instantiating bsn neutron client: %s', bsn_neutron_client)
client = bsn_neutron_client(session=instance.session,
region_name=instance.region_name,
endpoint_type=instance.interface,
insecure=not instance.verify,
ca_cert=instance.cacert)
return client
def make_client(instance):
"""Returns a baremetal service client."""
baremetal_client_class = utils.get_client_class(
API_NAME, instance._api_version[API_NAME], API_VERSIONS)
LOG.debug('Instantiating baremetal client: %s', baremetal_client_class)
client = baremetal_client_class(
os_ironic_api_version=instance._api_version[API_NAME],
session=instance.session,
region_name=instance._region_name,
)
return client
def make_client(instance):
"""Returns a vitrage service client."""
version = instance._api_version[API_NAME]
try:
version = int(version)
except ValueError:
version = float(version)
vitrage_client = utils.get_client_class(API_NAME, version, API_VERSIONS)
instance.setup_auth()
return vitrage_client(session=instance.session,
interface=instance.interface,
region_name=instance.region_name)
def make_client(instance):
"""Returns an image service client"""
image_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating image client: %s', image_client)
endpoint = instance.get_endpoint_for_service_type(
API_NAME,
region_name=instance.region_name,
interface=instance.interface,
)
client = image_client(
endpoint,
token=instance.auth.get_token(instance.session),
cacert=instance.cacert,
insecure=not instance.verify,
)
# Create the low-level API
image_api = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
IMAGE_API_VERSIONS)
LOG.debug('Instantiating image api: %s', image_api)
client.api = image_api(
session=instance.session,
endpoint=instance.get_endpoint_for_service_type(
IMAGE_API_TYPE,
region_name=instance.region_name,
interface=instance.interface,
)
)
return client
def make_client(instance):
"""Returns a client."""
nsxclient = utils.get_client_class(API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating vmware nsx client: %s', nsxclient)
client = nsxclient(session=instance.session,
region_name=instance._region_name,
endpoint_type=instance._interface,
insecure=instance._insecure,
ca_cert=instance._cacert)
return client
def make_client(instance):
"""Return a dcmanager client."""
version = instance._api_version[API_NAME]
dcmanager_client = utils.get_client_class(API_NAME, version, API_VERSIONS)
LOG.debug('Instantiating dcmanager client: %s', dcmanager_client)
dcmanager_url = instance.get_endpoint_for_service_type(
'dcmanager', interface='publicURL')
client = dcmanager_client(dcmanager_url=dcmanager_url,
session=instance.session)
return client
def make_client(instance):
"""Returns a rating service client."""
version = instance._api_version[API_NAME]
ck_client = utils.get_client_class(
API_NAME,
version,
API_VERSIONS)
instance.setup_auth()
adapter_options = dict(
interface=instance.interface,
region_name=instance.region_name,
)
return ck_client(session=instance.session,
adapter_options=adapter_options)
def make_client(instance):
"""Returns a client."""
nsxclient = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating vmware nsx client: %s', nsxclient)
client = nsxclient(session=instance.session,
region_name=instance._region_name,
endpoint_type=instance._interface,
insecure=instance._insecure,
ca_cert=instance._cacert)
return client
def make_client(instance):
data_processing_client = utils.get_client_class(
API_NAME, instance._api_version[API_NAME], API_VERSIONS)
LOG.debug('Instantiating data-processing client: %s',
data_processing_client)
kwargs = utils.build_kwargs_dict('endpoint_type', instance._interface)
client = data_processing_client(
session=instance.session,
region_name=instance._region_name,
sahara_url=instance._cli_options.data_processing_url,
**kwargs)
return client
def make_client(instance):
"""Returns a data protection service client"""
data_protection_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating data protection client: %s',
data_protection_client)
client = data_protection_client(
auth=instance.auth,
session=instance.session,
service_type="data-protect"
)
return client
def make_client(instance):
"""Returns a client to the ClientManager
Called to instantiate the requested client version. instance has
any available auth info that may be required to prepare the client.
:param ClientManager instance: The ClientManager that owns the new client
"""
plugin_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating plugin client: %s' % plugin_client)
client = plugin_client()
return client
def make_client(instance):
"""Returns an application-catalog service client"""
application_catalog_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug("Instantiating application-catalog client: {0}".format(
application_catalog_client))
client = application_catalog_client(
instance.get_configuration().get('murano_url'),
region_name=instance._region_name,
session=instance.session,
service_type='application-catalog',
)
return client
def make_client(instance):
"""Returns a baremetal service client."""
baremetal_client_class = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating baremetal client: %s', baremetal_client_class)
LOG.debug('Baremetal API version: %s', http.DEFAULT_VER)
client = baremetal_client_class(
os_ironic_api_version=instance._api_version[API_NAME],
session=instance.session,
region_name=instance._region_name,
)
return client
def make_client(instance):
"""Returns a vitrage service client."""
version = instance._api_version[API_NAME]
try:
version = int(version)
except ValueError:
version = float(version)
vitrage_client = utils.get_client_class(
API_NAME,
version,
API_VERSIONS)
instance.setup_auth()
return vitrage_client(session=instance.session,
interface=instance.interface,
region_name=instance.region_name)
def make_client(instance):
data_processing_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating data-processing client: %s',
data_processing_client)
kwargs = utils.build_kwargs_dict('endpoint_type', instance._interface)
client = data_processing_client(
session=instance.session,
region_name=instance._region_name,
sahara_url=instance._cli_options.data_processing_url,
**kwargs
)
return client
def make_client(instance):
"""Returns a metrics service client."""
version = instance._api_version[API_NAME]
try:
version = int(version)
except ValueError:
version = float(version)
gnocchi_client = utils.get_client_class(
API_NAME,
version,
API_VERSIONS)
# NOTE(sileht): ensure setup of the session is done
instance.setup_auth()
return gnocchi_client(session=instance.session,
interface=instance.interface,
region_name=instance.region_name)
def make_client(instance):
"""Return a sync_engine service client."""
version = instance._api_version[API_NAME]
sync_client = utils.get_client_class(
API_NAME,
version,
API_VERSIONS)
LOG.debug('Instantiating sync engine client: %s', sync_client)
kingbird_url = instance.get_endpoint_for_service_type(
'synchronization',
interface='publicURL'
)
client = sync_client(kingbird_url=kingbird_url, session=instance.session)
return client
def make_client(instance):
"""Returns an infra-optim service client."""
version = api_versioning.APIVersion(instance._api_version[API_NAME])
infraoptim_client_class = utils.get_client_class(
API_NAME,
version.ver_major,
API_VERSIONS)
LOG.debug('Instantiating infraoptim client: %s', infraoptim_client_class)
client = infraoptim_client_class(
os_infra_optim_api_version=instance._api_version[API_NAME],
session=instance.session,
region_name=instance._region_name,
)
return client
def make_client(instance):
"""Returns an neutron client."""
neutron_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating neutron client: %s', neutron_client)
# TODO(amotoki): Check the following arguments need to be passed
# to neutronclient class. Check keystoneauth code.
# - endpoint_type (do we need to specify it explicitly?)
# - auth (session object contains auth. Is it required?)
client = neutron_client(session=instance.session,
region_name=instance.region_name,
endpoint_type=instance.interface,
insecure=not instance.verify,
ca_cert=instance.cacert)
return client
def make_client(instance):
"""Returns an identity service client."""
identity_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating identity client: %s', identity_client)
# Remember interface only if interface is set
kwargs = utils.build_kwargs_dict('interface', instance._interface)
client = identity_client(
session=instance.session,
region_name=instance._region_name,
**kwargs
)
return client
def make_client(instance):
"""Returns a workflow_engine service client."""
version = instance._api_version[API_NAME]
workflow_client = utils.get_client_class(
API_NAME,
version,
API_VERSIONS)
LOG.debug('Instantiating workflow engine client: %s', workflow_client)
mistral_url = instance.get_endpoint_for_service_type(
'workflowv2',
interface='publicURL'
)
client = workflow_client(mistral_url=mistral_url, session=instance.session)
return client
def make_client(instance):
"""Returns a client to the ClientManager."""
tacker_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
LOG.debug('Instantiating tacker client: %s', tacker_client)
kwargs = {'service_type': 'nfv-orchestration',
'region_name': instance._region_name,
'endpoint_type': instance._interface,
'interface': instance._interface,
'session': instance.session
}
client = tacker_client(**kwargs)
return client
def make_client(instance):
"""Returns a search service client"""
search_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS)
# Set client http_log_debug to True if verbosity level is high enough
http_log_debug = utils.get_effective_log_level() <= logging.DEBUG
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance._interface)
client = search_client(
session=instance.session,
http_log_debug=http_log_debug,
region_name=instance._region_name,
**kwargs
)
return client
def make_client(instance):
"""Returns an queues service client."""
global _MESSAGING_ENDPOINT
version = instance._api_version[API_NAME]
try:
version = int(version)
except ValueError:
version = float(version)
queues_client = utils.get_client_class(
API_NAME,
version,
API_VERSIONS)
# TODO(wangxiyuan): Use public attributes instead of private attributes.
if not _MESSAGING_ENDPOINT:
_MESSAGING_ENDPOINT = instance.get_endpoint_for_service_type(
API_NAME,
region_name=instance._region_name,
interface=instance._interface
)
auth_params = instance.get_configuration()['auth']
auth_params.update({
"auth_token": instance.auth.get_token(instance.session),
"insecure": instance._insecure,
"cacert": instance._cacert,
"region_name": instance._region_name
})
conf = {
"auth_opts": {'options': auth_params}
}
LOG.debug('Instantiating queues service client: %s', queues_client)
return queues_client(
_MESSAGING_ENDPOINT,
version,
conf
)
def make_client(instance):
"""Returns a volume service client."""
# Defer client imports until we actually need them
from cinderclient import extension
from cinderclient.v1.contrib import list_extensions
from cinderclient.v1 import volume_snapshots
from cinderclient.v1 import volumes
# Monkey patch for v1 cinderclient
volumes.Volume.NAME_ATTR = 'display_name'
volume_snapshots.Snapshot.NAME_ATTR = 'display_name'
volume_client = utils.get_client_class(
API_NAME,
instance._api_version[API_NAME],
API_VERSIONS
)
LOG.debug('Instantiating volume client: %s', volume_client)
# Set client http_log_debug to True if verbosity level is high enough
http_log_debug = utils.get_effective_log_level() <= logging.DEBUG
extensions = [extension.Extension('list_extensions', list_extensions)]
# Remember interface only if it is set
kwargs = utils.build_kwargs_dict('endpoint_type', instance._interface)
client = volume_client(
session=instance.session,
extensions=extensions,
http_log_debug=http_log_debug,
region_name=instance._region_name,
**kwargs
)
return client
def make_client(instance):
"""Returns a workflow_engine service client."""
version = instance._api_version[API_NAME]
workflow_client = utils.get_client_class(
API_NAME,
version,
API_VERSIONS)
LOG.debug('Instantiating workflow engine client: %s', workflow_client)
if not instance._url:
instance._url = instance.get_endpoint_for_service_type(
'workflowv2',
interface='publicURL'
)
client = workflow_client(
mistral_url=instance._url,
auth_token=instance.auth_ref.auth_token,
project_id=instance.auth_ref.project_id,
user_id=instance.auth_ref.user_id,
)
return client
def make_client(instance):
"""Returns a baremetal service client."""
requested_api_version = instance._api_version[API_NAME]
baremetal_client_class = utils.get_client_class(
API_NAME,
requested_api_version,
API_VERSIONS)
LOG.debug('Instantiating baremetal client: %s', baremetal_client_class)
LOG.debug('Baremetal API version: %s',
requested_api_version if not OS_BAREMETAL_API_LATEST
else "latest")
if requested_api_version == '1':
# NOTE(dtantsur): '1' means 'the latest v1 API version'. Since we don't
# have other major versions, it's identical to 'latest'.
requested_api_version = LATEST_VERSION
allow_api_version_downgrade = True
else:
allow_api_version_downgrade = OS_BAREMETAL_API_LATEST
client = baremetal_client_class(
os_ironic_api_version=requested_api_version,
# NOTE(dtantsur): enable re-negotiation of the latest version, if CLI
# latest is too high for the server we're talking to.
allow_api_version_downgrade=allow_api_version_downgrade,
session=instance.session,
region_name=instance._region_name,
# NOTE(vdrok): This will be set as endpoint_override, and the Client
# class will be able to do the version stripping if needed
endpoint_override=instance.get_endpoint_for_service_type(
API_NAME, interface=instance.interface,
region_name=instance._region_name
)
)
return client
