def heat_client(context):
endpoint = "%s/%s/" % (HEAT_URL, context.tenant)
client = HeatClient.Client(username=context.user,
password="******",
token=context.auth_token,
os_no_client_auth=True,
endpoint=endpoint)
return client
def hclient(self):
if self._hclient is None:
ksclient = self.ksclient
endpoint = ksclient.service_catalog.url_for(
service_type='orchestration', endpoint_type='publicURL')
self._hclient = heat_client.Client(endpoint=endpoint,
token=ksclient.auth_token)
return self._hclient
def __init__(self, name='', args=None):
super(HeatV1Driver, self).__init__(name, args=args)
datasource_driver.ExecutionDriver.__init__(self)
self.creds = args
session = ds_utils.get_keystone_session(self.creds)
endpoint = session.get_endpoint(service_type='orchestration',
interface='publicURL')
self.heat = heatclient.Client(session=session, endpoint=endpoint)
self.initialize_update_methods()
self._init_end_start_poll()
def get_orchestration_client(self, context):
heat_endpoint = keystone_utils.get_endpoint_for_project('heat')
endpoint_url = keystone_utils.format_url(
heat_endpoint.url, {'tenant_id': context.project_id})
return heatclient.Client(endpoint_url,
region_name=heat_endpoint.region,
token=context.auth_token,
username=context.user_name)
def _connect_heat(self):
if self._heat_connection_tried:
return
self._heat_connection_tried = True
try:
heat_endpoint = self._keystone.service_catalog.url_for(
service_type='orchestration')
self._heat = heatclient.Client(heat_endpoint,
token=self._keystone.auth_token)
self.logger.info('heat connected')
except keystone_exceptions.EndpointNotFound as e:
self._heat = None
self.logger.warn(e)
def hclient(self):
if self._hclient is None:
ksclient = self.ksclient
endpoint = ksclient.service_catalog.url_for(
service_type='orchestration', endpoint_type='publicURL')
try:
self._hclient = heat_client.Client(
endpoint=endpoint,
token=ksclient.auth_token)
except Exception as e:
print("Error connecting to Heat: {}".format(e.message),
file=sys.stderr)
sys.exit(1)
return self._hclient
def get_hclient():
ksclient = get_ksclient()
heat_url = os.getenv('HEAT_URL')
if not heat_url:
heat_url = ksclient.service_catalog.url_for(
service_type='orchestration',
attr='region',
filter_value=os.getenv('OS_REGION_NAME'),
endpoint_type='publicURL')
token = os.getenv('OS_AUTH_TOKEN', ksclient.auth_token)
return heatclient.Client(endpoint=heat_url, token=token)
def heat_client(context):
if CONF.heat_url:
url = '%(heat_url)s%(tenant)s' % {
'heat_url': normalize_url(CONF.heat_url),
'tenant': context.tenant
}
else:
url = get_endpoint(context.service_catalog,
service_type=CONF.heat_service_type,
endpoint_region=CONF.os_region_name)
client = HeatClient.Client(token=context.auth_token,
os_no_client_auth=True,
endpoint=url)
return client
def get_orchestration_client(self):
"""Return the orchestration (heat) client.
This method will return a client object using the legacy library. Upon
the creation of a successful client creation, the client object will
be stored in the `self.client_cache object`, should this method be
called more than once, the cached object will automatically return,
resulting in fewer authentications and faster API interactions.
:returns: Object
"""
if 'heatclient' in self.client_cache:
return self.client_cache['heatclient']
else:
self.client_cache['heatclient'] = \
heatclient.Client(session=self.sess)
return self.client_cache['heatclient']
def _get_heat(self, username, password, project, auth_url,
auth_token, insecure, keystone):
kwargs = {
'insecure': False,
'ca_file': None,
'username': username,
'insecure': insecure,
'auth_url': auth_url,
'tenant_id': project,
'token':auth_token
}
heat = heat_client.Client(keystone.service_catalog.url_for(service_type='orchestration',
endpoint_type='publicURL'),
**kwargs)
management_url = keystone.service_catalog.url_for(service_type='orchestration',
endpoint_type='publicURL')
# heat.client.auth_token = auth_token
# cinder.client.management_url = management_url
return heat
def get_orchestration_client():
OS_AUTH_URL = os.environ['OS_AUTH_URL']
OS_USERNAME = os.environ['OS_USERNAME']
OS_TENANT_NAME = os.environ['OS_TENANT_NAME']
OS_PASSWORD = os.environ['OS_PASSWORD']
auth = v2.Password(auth_url=OS_AUTH_URL,
username=OS_USERNAME,
password=OS_PASSWORD,
tenant_name=OS_TENANT_NAME)
sess = session.Session(auth=auth)
keystone = client.Client(session=sess)
token = auth.get_token(session=sess)
#log.info("KRS: token: %s" % token)
endpoint = auth.get_endpoint(sess,
service_name='heat',
service_type='orchestration')
#log.info("KRS: endpoint: %s" % endpoint)
return heatclient.Client(
endpoint=endpoint,
token=token,
)
def heat(self):
if self._heat:
return self._heat
endpoint_type = self._get_client_option('heat', 'endpoint_type')
region_name = self._get_client_option('heat', 'region_name')
endpoint = self.url_for(service_type='orchestration',
endpoint_type=endpoint_type,
region_name=region_name)
args = {
'endpoint': endpoint,
'auth_url': self.auth_url,
'token': self.auth_token,
'username': None,
'password': None,
'ca_file': self._get_client_option('heat', 'ca_file'),
'cert_file': self._get_client_option('heat', 'cert_file'),
'key_file': self._get_client_option('heat', 'key_file'),
'insecure': self._get_client_option('heat', 'insecure')
}
self._heat = heatclient.Client(**args)
return self._heat
def decorator_method(*args, **kwargs):
'''
Authenticate request and format return data
'''
connection_args = {'profile': kwargs.get('profile', None)}
nkwargs = {}
for kwarg in kwargs:
if 'connection_' in kwarg:
connection_args.update({kwarg: kwargs[kwarg]})
elif '__' not in kwarg:
nkwargs.update({kwarg: kwargs[kwarg]})
kstone = __salt__['keystone.auth'](**connection_args)
token = kstone.auth_token
endpoint = kstone.service_catalog.url_for(
service_type='orchestration',
endpoint_type='publicURL')
heat_interface = client.Client(
endpoint_url=endpoint, token=token)
return_data = func_name(heat_interface, *args, **nkwargs)
if isinstance(return_data, list):
# format list as a dict for rendering
return {data.get('name', None) or data['id']: data
for data in return_data}
return return_data
def test_init_with_client(self):
session = keystone.get_keystone_session()
self.test_init(client=heatclient.Client(session=session))
def authenticate_heat_admin(self, keystone):
"""Authenticates the admin user with heat."""
self.log.debug('Authenticating heat admin...')
ep = keystone.service_catalog.url_for(service_type='orchestration',
endpoint_type='publicURL')
return heat_client.Client(endpoint=ep, token=keystone.auth_token)
def heat_client(context):
endpoint = "%s/%s" % (HEAT_URL, context.tenant)
client = HeatClient.Client(token=context.auth_token,
os_no_client_auth=True,
endpoint=endpoint)
return client
def init_client(self, session) -> HeatClient:
return v1_client.Client(session=session,
endpoint_type='public',
service_type='orchestration')
def get_heat_client(**kwargs):
return heatclient.Client('')
