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