def test_mistral_url_https_bad_insecure(self, session_mock,
log_warning_mock):
fd, path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = self.setup_keystone_mock(
session_mock
)
try:
client.client(
mistral_url=MISTRAL_HTTPS_URL,
user_id=keystone_client_instance.user_id,
project_id=keystone_client_instance.project_id,
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3,
cacert=path,
insecure=True
)
finally:
os.close(fd)
os.unlink(path)
self.assertTrue(log_warning_mock.called)
def test_mistral_url_https_secure(self, http_client_mock, session_mock):
fd, cert_path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = self.setup_keystone_mock( # noqa
session_mock
)
expected_args = (
MISTRAL_HTTPS_URL,
)
try:
client.client(
mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3,
cacert=cert_path,
insecure=False
)
finally:
os.close(fd)
os.unlink(cert_path)
self.assertTrue(http_client_mock.called)
self.assertEqual(http_client_mock.call_args[0], expected_args)
self.assertEqual(http_client_mock.call_args[1]['cacert'], cert_path)
def test_mistral_url_https_secure(self, mock, keystone_client_mock):
fd, path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = keystone_client_mock.return_value
keystone_client_instance.auth_token = str(uuid.uuid4())
keystone_client_instance.project_id = str(uuid.uuid4())
keystone_client_instance.user_id = str(uuid.uuid4())
expected_args = (MISTRAL_HTTPS_URL,
keystone_client_instance.auth_token,
keystone_client_instance.project_id,
keystone_client_instance.user_id)
expected_kwargs = {
'cacert': path,
'insecure': False,
'target_auth_uri': None,
'target_token': None
}
try:
client.client(mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL_v3,
cacert=path,
insecure=False)
finally:
os.close(fd)
os.unlink(path)
self.assertTrue(mock.called)
self.assertEqual(mock.call_args[0], expected_args)
self.assertDictEqual(mock.call_args[1], expected_kwargs)
def test_mistral_url_https_bad_insecure(self, session_mock,
log_warning_mock):
fd, path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = self.setup_keystone_mock(
session_mock
)
try:
client.client(
mistral_url=MISTRAL_HTTPS_URL,
user_id=keystone_client_instance.user_id,
project_id=keystone_client_instance.project_id,
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3,
cacert=path,
insecure=True
)
finally:
os.close(fd)
os.unlink(path)
self.assertTrue(log_warning_mock.called)
def test_mistral_url_https_insecure(self, mock, keystone_client_mock):
keystone_client_instance = keystone_client_mock.return_value
keystone_client_instance.auth_token = str(uuid.uuid4())
keystone_client_instance.project_id = str(uuid.uuid4())
keystone_client_instance.user_id = str(uuid.uuid4())
expected_args = (
MISTRAL_HTTPS_URL,
keystone_client_instance.auth_token,
keystone_client_instance.project_id,
keystone_client_instance.user_id
)
expected_kwargs = {
'cacert': None,
'insecure': True
}
client.client(
mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL,
cacert=None,
insecure=True
)
self.assertTrue(mock.called)
self.assertEqual(mock.call_args[0], expected_args)
self.assertDictEqual(mock.call_args[1], expected_kwargs)
def test_mistral_url_default(self, mocked, keystone_client_mock):
keystone_client_instance = keystone_client_mock.return_value
keystone_client_instance.auth_token = str(uuid.uuid4())
keystone_client_instance.project_id = str(uuid.uuid4())
keystone_client_instance.user_id = str(uuid.uuid4())
url_for = mock.Mock(side_effect=Exception)
keystone_client_instance.service_catalog.url_for = url_for
expected_args = (MISTRAL_HTTP_URL, keystone_client_instance.auth_token,
keystone_client_instance.project_id,
keystone_client_instance.user_id)
expected_kwargs = {
'cacert': None,
'insecure': False,
'target_auth_uri': None,
'target_token': None
}
client.client(username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL_v3)
self.assertTrue(mocked.called)
self.assertEqual(mocked.call_args[0], expected_args)
self.assertDictEqual(mocked.call_args[1], expected_kwargs)
def test_target_parameters_processed(self, http_client_mock,
keystone_client_mock):
keystone_client_instance = self.setup_keystone_mock(
keystone_client_mock)
url_for = mock.Mock(return_value='http://mistral_host:8989/v2')
keystone_client_instance.service_catalog.url_for = url_for
client.client(target_username='******',
target_project_name='tmistralp',
target_auth_url=AUTH_HTTP_URL_v3,
target_region_name='tregion')
self.assertTrue(http_client_mock.called)
mistral_url_for_http = http_client_mock.call_args[0][0]
kwargs = http_client_mock.call_args[1]
self.assertEqual(MISTRAL_HTTP_URL, mistral_url_for_http)
expected_values = {
'target_project_id': keystone_client_instance.project_id,
'target_auth_token': keystone_client_instance.auth_token,
'target_user_id': keystone_client_instance.user_id,
'target_auth_url': AUTH_HTTP_URL_v3,
'target_project_name': 'tmistralp',
'target_username': '******',
'target_region_name': 'tregion',
'target_service_catalog': '"{}"'
}
for key in expected_values:
self.assertEqual(expected_values[key], kwargs[key])
def test_mistral_url_https_secure(self, http_client_mock, session_mock):
fd, cert_path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = self.setup_keystone_mock( # noqa
session_mock)
expected_args = (MISTRAL_HTTPS_URL, )
try:
client.client(mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3,
cacert=cert_path,
insecure=False)
finally:
os.close(fd)
os.unlink(cert_path)
self.assertTrue(http_client_mock.called)
self.assertEqual(http_client_mock.call_args[0], expected_args)
self.assertEqual(http_client_mock.call_args[1]['cacert'], cert_path)
def test_mistral_profile_enabled(self, mock, keystone_client_mock):
keystone_client_instance = keystone_client_mock.return_value
keystone_client_instance.auth_token = str(uuid.uuid4())
keystone_client_instance.project_id = str(uuid.uuid4())
keystone_client_instance.user_id = str(uuid.uuid4())
expected_args = (
MISTRAL_HTTP_URL,
keystone_client_instance.auth_token,
keystone_client_instance.project_id,
keystone_client_instance.user_id
)
expected_kwargs = {
'cacert': None,
'insecure': False
}
client.client(
username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL,
profile=PROFILER_HMAC_KEY
)
self.assertTrue(mock.called)
self.assertEqual(mock.call_args[0], expected_args)
self.assertDictEqual(mock.call_args[1], expected_kwargs)
profiler = osprofiler.profiler.get()
self.assertEqual(profiler.hmac_key, PROFILER_HMAC_KEY)
def test_mistral_url_defult(self, mock, keystone_client_mock):
client.client(username='******',
project_name='misteal',
auth_url="http://localhost:35357/v3")
self.assertTrue(mock.called)
params = mock.call_args
self.assertEqual('http://localhost:8989/v2',
params[0][0])
def test_target_parameters_processed(self, http_client_mock, session_mock,
password_mock, catalog_type_mock):
session = mock.MagicMock()
target_session = mock.MagicMock()
session_mock.side_effect = [session, target_session]
auth = mock.MagicMock()
target_auth = mock.MagicMock()
target_auth._plugin.auth_url = AUTH_HTTP_URL_v3
password_mock.side_effect = [auth, target_auth]
get_endpoint = mock.Mock(return_value='http://mistral_host:8989/v2')
session.get_endpoint = get_endpoint
target_session.get_project_id = mock.Mock(return_value='projectid')
target_session.get_user_id = mock.Mock(return_value='userid')
target_session.get_auth_headers = mock.Mock(
return_value={'X-Auth-Token': 'authtoken'})
mock_access = mock.MagicMock()
mock_catalog = mock.MagicMock()
mock_catalog.catalog = {}
mock_access.service_catalog = mock_catalog
auth.get_access = mock.Mock(return_value=mock_access)
client.client(auth_url=AUTH_HTTP_URL_v3,
username='******',
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
target_username='******',
target_project_name='tmistralp',
target_auth_url=AUTH_HTTP_URL_v3,
target_api_key='tpassword',
target_user_domain_name='Default',
target_project_domain_name='Default',
target_region_name='tregion')
self.assertTrue(http_client_mock.called)
mistral_url_for_http = http_client_mock.call_args[0][0]
kwargs = http_client_mock.call_args[1]
self.assertEqual('http://mistral_host:8989/v2', mistral_url_for_http)
expected_values = {
'target_project_id': 'projectid',
'target_auth_token': 'authtoken',
'target_user_id': 'userid',
'target_auth_url': AUTH_HTTP_URL_v3,
'target_project_name': 'tmistralp',
'target_username': '******',
'target_region_name': 'tregion',
'target_service_catalog': "{}"
}
for key in expected_values:
self.assertEqual(expected_values[key], kwargs[key])
def test_mistral_no_auth(self, get_auth_handler_mock):
# Test that we don't authenticate if auth url wasn't provided
client.client(username='******',
project_name='mistral',
api_key='password',
service_type='workflowv2')
self.assertEqual(0, get_auth_handler_mock.call_count)
def test_mistral_no_auth(self, get_auth_handler_mock):
# Test that we don't authenticate if auth url wasn't provided
client.client(
username='******',
project_name='mistral',
api_key='password',
service_type='workflowv2'
)
self.assertEqual(0, get_auth_handler_mock.call_count)
def test_mistral_profile_enabled(self, http_client_mock,
keystone_client_mock):
keystone_client_instance = self.setup_keystone_mock( # noqa
keystone_client_mock)
client.client(username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL_v3,
profile=PROFILER_HMAC_KEY)
self.assertTrue(http_client_mock.called)
profiler = osprofiler.profiler.get()
self.assertEqual(profiler.hmac_key, PROFILER_HMAC_KEY)
def _create_client(region):
if not mistralcli:
LOG.warning(_LW("Mistral client is not available"))
raise mistral_import_error
mistral_settings = CONF.mistral
endpoint_type = mistral_settings.endpoint_type
service_type = mistral_settings.service_type
session = auth_utils.get_client_session()
mistral_url = mistral_settings.url or session.get_endpoint(
service_type=service_type,
endpoint_type=endpoint_type,
region_name=region)
auth_ref = session.auth.get_access(session)
return mistralcli.client(mistral_url=mistral_url,
project_id=auth_ref.project_id,
endpoint_type=endpoint_type,
service_type=service_type,
auth_token=auth_ref.auth_token,
user_id=auth_ref.user_id,
insecure=mistral_settings.insecure,
cacert=mistral_settings.ca_cert)
def get_workflow_client(self, context):
mistral_endpoint = keystone_utils.get_endpoint_for_project('mistral')
mc = mistral_client.client(auth_token=context.auth_token,
mistral_url=mistral_endpoint.url)
return mc
def initialize_app(self, argv):
self._clear_shell_commands()
ver = client.determine_client_version(self.options.mistral_version)
self._set_shell_commands(self._get_commands(ver))
do_help = ('help' in argv) or ('-h' in argv) or not argv
# Set default for auth_url if not supplied. The default is not
# set at the parser to support use cases where auth is not enabled.
# An example use case would be a developer's environment.
if not self.options.auth_url:
if self.options.password or self.options.token:
self.options.auth_url = 'http://localhost:35357/v3'
# bash-completion should not require authentification.
if do_help or ('bash-completion' in argv):
self.options.auth_url = None
self.client = client.client(mistral_url=self.options.mistral_url,
username=self.options.username,
api_key=self.options.password,
project_name=self.options.tenant_name,
auth_url=self.options.auth_url,
project_id=self.options.tenant_id,
endpoint_type=self.options.endpoint_type,
service_type=self.options.service_type,
auth_token=self.options.token,
cacert=self.options.cacert)
def _create_client(region):
if not mistralclient:
raise mistral_import_error
mistral_settings = CONF.mistral
endpoint_type = mistral_settings.endpoint_type
service_type = mistral_settings.service_type
session = auth_utils.get_client_session()
mistral_url = mistral_settings.url or session.get_endpoint(
service_type=service_type,
endpoint_type=endpoint_type,
region_name=region)
auth_ref = session.auth.get_access(session)
return mistralclient.client(
mistral_url=mistral_url,
project_id=auth_ref.project_id,
endpoint_type=endpoint_type,
service_type=service_type,
auth_token=auth_ref.auth_token,
user_id=auth_ref.user_id,
insecure=mistral_settings.insecure,
cacert=mistral_settings.ca_cert
)
def run(self, action_parameters):
client = mistral.client(mistral_url='%s/v2' % self.url)
# Update workbook definition.
workbook_name = self.action.pack + '.' + self.action.name
with open(self.entry_point, 'r') as wbkfile:
definition = wbkfile.read()
try:
wbk = client.workbooks.get(workbook_name)
if wbk.definition != definition:
client.workbooks.update(definition)
except:
client.workbooks.create(definition)
# Setup context for the workflow execution.
context = self.runner_parameters.get('context', dict())
context.update(action_parameters)
endpoint = 'http://%s:%s/actionexecutions' % (cfg.CONF.api.host, cfg.CONF.api.port)
params = {'st2_api_url': endpoint,
'st2_parent': self.action_execution_id}
# Execute the workflow.
execution = client.executions.create(self.runner_parameters.get('workflow'),
workflow_input=context, **params)
# Return status and output.
output = {
'id': str(execution.id),
'state': str(execution.state)
}
self.container_service.report_status(ACTIONEXEC_STATUS_RUNNING)
self.container_service.report_result(output)
return (str(execution.state) == 'RUNNING')
def _initialize_tests(self):
"""Perform final initialization before tests get run."""
# Access the sentries for inspecting service units
self.mistral_sentry = self.d.sentry['mistral'][0]
self.mysql_sentry = self.d.sentry['percona-cluster'][0]
self.keystone_sentry = self.d.sentry['keystone'][0]
self.rabbitmq_sentry = self.d.sentry['rabbitmq-server'][0]
self.mistral_svcs = [
'mistral-api', 'mistral-engine', 'mistral-executor'
]
# Authenticate admin with keystone endpoint
self.keystone = u.authenticate_keystone_admin(self.keystone_sentry,
user='******',
password='******',
tenant='admin')
mistral_ep = self.keystone.service_catalog.url_for(
service_type='workflowv2', endpoint_type='publicURL')
keystone_ep = self.keystone.service_catalog.url_for(
service_type='identity', endpoint_type='publicURL')
self.mclient = mistral_client.client(username='******',
mistral_url=mistral_ep,
auth_url=keystone_ep,
project_name='admin',
api_key='openstack')
def _create_client(region):
if not mistralcli:
LOG.warning("Mistral client is not available")
raise ImportError("Import mistralcliet error")
mistral_settings = CONF.mistral
endpoint_type = mistral_settings.endpoint_type
service_type = mistral_settings.service_type
session = auth_utils.get_client_session()
mistral_url = mistral_settings.url or session.get_endpoint(
service_type=service_type,
endpoint_type=endpoint_type,
region_name=region)
auth_ref = session.auth.get_access(session)
# TODO(gyurco): use auth_utils.get_session_client_parameters
return mistralcli.client(
mistral_url=mistral_url,
project_id=auth_ref.project_id,
endpoint_type=endpoint_type,
service_type=service_type,
auth_token=auth_ref.auth_token,
user_id=auth_ref.user_id,
insecure=mistral_settings.insecure,
cacert=mistral_settings.cafile
)
def test_mistral_url_https_insecure(self, http_client_mock,
keystone_client_mock):
keystone_client_instance = self.setup_keystone_mock( # noqa
keystone_client_mock)
expected_args = (MISTRAL_HTTPS_URL, )
client.client(mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL_v3,
cacert=None,
insecure=True)
self.assertTrue(http_client_mock.called)
self.assertEqual(http_client_mock.call_args[0], expected_args)
self.assertEqual(http_client_mock.call_args[1]['insecure'], True)
def __init__(self):
super(MistralWorkflowValidator, self).__init__()
self._client = mistral.client(
mistral_url=self.url,
username=cfg.CONF.mistral.keystone_username,
api_key=cfg.CONF.mistral.keystone_password,
project_name=cfg.CONF.mistral.keystone_project_name,
auth_url=cfg.CONF.mistral.keystone_auth_url)
def main():
sc = client.client(**creds())
workflow = sc.workflows.get("sosreport_test")
trigger = sc.event_triggers.create("map_sosreport_test",
workflow_id=workflow.id,
exchange="openstack",
topic="notifications",
event="new_sosreport")
def get_workflow_client(self, context):
mistral_endpoint = keystone_utils.get_endpoint_for_project(
context, 'mistral')
mc = mistral_client.client(auth_token=context.auth_token,
mistral_url=mistral_endpoint.url)
return mc
def __init__(self):
super(MistralWorkflowValidator, self).__init__()
self._client = mistral.client(
mistral_url=self.url,
username=cfg.CONF.mistral.keystone_username,
api_key=cfg.CONF.mistral.keystone_password,
project_name=cfg.CONF.mistral.keystone_project_name,
auth_url=cfg.CONF.mistral.keystone_auth_url)
def _create(self):
endpoint_type = self._get_client_option("mistral", "endpoint_type")
endpoint = self.url_for(service_type=self.WORKFLOW_V2, endpoint_type=endpoint_type)
args = {"mistral_url": endpoint, "auth_token": self.auth_token}
client = mistral_client.client(**args)
return client
def _get_workflow_client(self):
ctx = context.ctx()
mistral_endpoint = keystone_utils.get_endpoint_for_project('mistral')
mc = mistral_client.client(auth_token=ctx.auth_token,
mistral_url=mistral_endpoint.url)
return mc
def test_mistral_url_default(self, http_client_mock, session_mock):
session = mock.Mock()
session_mock.side_effect = [session]
get_endpoint = mock.Mock(side_effect=Exception)
session.get_endpoint = get_endpoint
client.client(username='******',
project_name='mistral',
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3)
self.assertTrue(http_client_mock.called)
mistral_url_for_http = http_client_mock.call_args[0][0]
self.assertEqual(MISTRAL_HTTP_URL, mistral_url_for_http)
def create_client(self, service_type=None):
"""Return Mistral client."""
from mistralclient.api import client as mistral
client = mistral.client(
mistral_url=self._get_endpoint(service_type),
service_type=self.choose_service_type(service_type),
auth_token=self.keystone.auth_ref.auth_token)
return client
def get_workflow_client(self, context):
security_ctx = context.security
mistral_endpoint = keystone_utils.get_endpoint_for_project(
security_ctx, 'mistral')
mc = mistral_client.client(auth_token=security_ctx.auth_token,
mistral_url=mistral_endpoint.url)
return mc
def create_client(self, service_type=None):
"""Return Mistral client."""
from mistralclient.api import client as mistral
client = mistral.client(
mistral_url=self._get_endpoint(service_type),
service_type=self.choose_service_type(service_type),
auth_token=self.keystone.auth_ref.auth_token)
return client
def __init__(self, id, *args, **kwargs):
super(MistralResultsQuerier, self).__init__(*args, **kwargs)
self._base_url = get_url_without_trailing_slash(cfg.CONF.mistral.v2_base_url)
self._client = mistral.client(
mistral_url=self._base_url,
username=cfg.CONF.mistral.keystone_username,
api_key=cfg.CONF.mistral.keystone_password,
project_name=cfg.CONF.mistral.keystone_project_name,
auth_url=cfg.CONF.mistral.keystone_auth_url)
def _create(self):
endpoint_type = self._get_client_option(CLIENT_NAME, 'endpoint_type')
endpoint = self.url_for(service_type=self.WORKFLOW_V2,
endpoint_type=endpoint_type)
args = {'mistral_url': endpoint, 'auth_token': self.auth_token}
client = mistral_client.client(**args)
return client
def test_mistral_url_default(self, http_client_mock, session_mock):
session = mock.Mock()
session_mock.side_effect = [session]
get_endpoint = mock.Mock(side_effect=Exception)
session.get_endpoint = get_endpoint
client.client(
username='******',
project_name='mistral',
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3
)
self.assertTrue(http_client_mock.called)
mistral_url_for_http = http_client_mock.call_args[0][0]
self.assertEqual(MISTRAL_HTTP_URL, mistral_url_for_http)
def _create(self):
endpoint_type = self._get_client_option(CLIENT_NAME, 'endpoint_type')
endpoint = self.url_for(service_type=self.WORKFLOW_V2,
endpoint_type=endpoint_type)
args = {
'mistral_url': endpoint,
'auth_token': self.context.keystone_session.get_token()
}
client = mistral_client.client(**args)
return client
def test_mistral_url_default(self, http_client_mock, keystone_client_mock):
keystone_client_instance = self.setup_keystone_mock(
keystone_client_mock)
url_for = mock.Mock(side_effect=Exception)
keystone_client_instance.service_catalog.url_for = url_for
client.client(username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL_v3)
self.assertTrue(http_client_mock.called)
mistral_url_for_http = http_client_mock.call_args[0][0]
kwargs = http_client_mock.call_args[1]
self.assertEqual(MISTRAL_HTTP_URL, mistral_url_for_http)
self.assertEqual(keystone_client_instance.auth_token,
kwargs['auth_token'])
self.assertEqual(keystone_client_instance.project_id,
kwargs['project_id'])
self.assertEqual(keystone_client_instance.user_id, kwargs['user_id'])
def __init__(self, runner_id):
super(MistralRunner, self).__init__(runner_id=runner_id)
self._on_behalf_user = cfg.CONF.system_user.user
self._notify = None
self._skip_notify_tasks = []
self._client = mistral.client(
mistral_url=self.url,
username=cfg.CONF.mistral.keystone_username,
api_key=cfg.CONF.mistral.keystone_password,
project_name=cfg.CONF.mistral.keystone_project_name,
auth_url=cfg.CONF.mistral.keystone_auth_url)
def test_mistral_profile_enabled(self, http_client_mock, session_mock):
keystone_client_instance = self.setup_keystone_mock( # noqa
session_mock
)
client.client(
username='******',
project_name='mistral',
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3,
profile=PROFILER_HMAC_KEY
)
self.assertTrue(http_client_mock.called)
profiler = osprofiler.profiler.get()
self.assertEqual(profiler.hmac_key, PROFILER_HMAC_KEY)
def __init__(self, runner_id):
super(MistralRunner, self).__init__(runner_id=runner_id)
self._on_behalf_user = cfg.CONF.system_user.user
self._notify = None
self._skip_notify_tasks = []
self._client = mistral.client(
mistral_url=self.url,
username=cfg.CONF.mistral.keystone_username,
api_key=cfg.CONF.mistral.keystone_password,
project_name=cfg.CONF.mistral.keystone_project_name,
auth_url=cfg.CONF.mistral.keystone_auth_url)
def _create(self):
endpoint_type = self._get_client_option(CLIENT_NAME, 'endpoint_type')
endpoint = self.url_for(service_type=self.WORKFLOW_V2,
endpoint_type=endpoint_type)
args = {
'mistral_url': endpoint,
'session': self.context.keystone_session,
'region_name': self._get_region_name()
}
client = mistral_client.client(**args)
return client
def test_mistral_url_https_bad_insecure(self, keystone_client_mock,
log_warning_mock):
fd, path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = keystone_client_mock.return_value
keystone_client_instance.auth_token = str(uuid.uuid4())
keystone_client_instance.project_id = str(uuid.uuid4())
keystone_client_instance.user_id = str(uuid.uuid4())
try:
client.client(mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL_v3,
cacert=path,
insecure=True)
finally:
os.close(fd)
os.unlink(path)
self.assertTrue(log_warning_mock.called)
def _create(self):
endpoint_type = self._get_client_option('mistral', 'endpoint_type')
endpoint = self.url_for(service_type=self.WORKFLOW_V2,
endpoint_type=endpoint_type)
args = {
'mistral_url': endpoint,
'auth_token': self.auth_token
}
client = mistral_client.client(**args)
return client
def mistral(self):
if self._mistral:
return self._mistral
args = {
'auth_token': self.auth_token,
}
endpoint_type = self._get_client_option('mistral', 'endpoint_type')
endpoint = self.url_for(service_type='workflow',
endpoint_type=endpoint_type)
self._mistral = mistralclient.client(mistral_url=endpoint, **args)
return self._mistral
def get_mistralclinet_from_env():
username = env("OS_USERNAME", default=None)
password = env("OS_PASSWORD", default=None)
project_name = env("OS_TENANT_NAME", "OS_PROJECT_NAME", default=None)
auth_url = env("OS_AUTH_URL", default=None)
mistral_url = env("OS_MISTRAL_URL", default=None)
mistralclient = client.client(
mistral_url=mistral_url,
username=username,
api_key=password,
project_name=project_name,
auth_url=auth_url)
return mistralclient
def mistralclient(request):
return mistral_client.client(
username=request.user.username,
auth_token=request.user.token.id,
project_id=request.user.tenant_id,
# Ideally, we should get it from identity endpoint, but since
# python-mistralclient is not supporting v2.0 API it might create
# additional troubles for those who still rely on v2.0 stack-wise.
auth_url=getattr(settings, 'OPENSTACK_KEYSTONE_URL'),
# Todo: add SECONDARY_ENDPOINT_TYPE support
endpoint_type=getattr(settings, 'OPENSTACK_ENDPOINT_TYPE',
'internalURL'),
service_type=SERVICE_TYPE)
def initialize_app(self, argv):
self._clear_shell_commands()
self._set_shell_commands(self._get_commands(
client.determine_client_version(self.options.mistral_url)))
self.client = client.client(mistral_url=self.options.mistral_url,
username=self.options.username,
api_key=self.options.password,
project_name=self.options.tenant_name,
auth_url=self.options.auth_url,
project_id=self.options.tenant_id,
endpoint_type='publicURL',
service_type='workflow',
auth_token=self.options.token)
def mistral(self):
"""Return Mistral client."""
from mistralclient.api import client
kc = self.keystone()
mistral_url = kc.service_catalog.url_for(
service_type="workflowv2",
endpoint_type=self.endpoint.endpoint_type,
region_name=self.endpoint.region_name)
client = client.client(mistral_url=mistral_url,
service_type="workflowv2",
auth_token=kc.auth_token)
return client
def test_mistral_url_from_catalog_v2(self, keystone_client_mock):
keystone_client_instance = self.setup_keystone_mock(
keystone_client_mock)
url_for = mock.Mock(return_value='http://mistral_host:8989/v2')
keystone_client_instance.service_catalog.url_for = url_for
mistralclient = client.client(username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL_v2_0,
service_type='workflowv2')
self.assertEqual('http://mistral_host:8989/v2',
mistralclient.actions.http_client.base_url)
def _update_action_execution(cls, url, data):
action_execution_id = get_action_execution_id_from_url(url)
LOG.info('Sending callback to %s with data %s.', url, data)
client = mistral.client(
mistral_url=cfg.CONF.mistral.v2_base_url,
username=cfg.CONF.mistral.keystone_username,
api_key=cfg.CONF.mistral.keystone_password,
project_name=cfg.CONF.mistral.keystone_project_name,
auth_url=cfg.CONF.mistral.keystone_auth_url)
manager = action_executions.ActionExecutionManager(client)
manager.update(action_execution_id, **data)
def mistral(self):
"""Return Mistral client."""
from mistralclient.api import client
kc = self.keystone()
mistral_url = kc.service_catalog.url_for(
service_type="workflowv2",
endpoint_type=self.endpoint.endpoint_type,
region_name=self.endpoint.region_name)
client = client.client(mistral_url=mistral_url,
service_type="workflowv2",
auth_token=kc.auth_token)
return client
def test_mistral_url_https_bad_insecure(self, keystone_client_mock,
log_warning_mock):
fd, path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = keystone_client_mock.return_value
keystone_client_instance.auth_token = str(uuid.uuid4())
keystone_client_instance.project_id = str(uuid.uuid4())
keystone_client_instance.user_id = str(uuid.uuid4())
try:
client.client(
mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL,
cacert=path,
insecure=True
)
finally:
os.close(fd)
os.unlink(path)
self.assertTrue(log_warning_mock.called)
def _update_action_execution(cls, url, data):
action_execution_id = get_action_execution_id_from_url(url)
LOG.info('Sending callback to %s with data %s.', url, data)
client = mistral.client(
mistral_url=cfg.CONF.mistral.v2_base_url,
username=cfg.CONF.mistral.keystone_username,
api_key=cfg.CONF.mistral.keystone_password,
project_name=cfg.CONF.mistral.keystone_project_name,
auth_url=cfg.CONF.mistral.keystone_auth_url)
manager = action_executions.ActionExecutionManager(client)
manager.update(action_execution_id, **data)
def test_mistral_url_https_insecure(self, http_client_mock, session_mock):
keystone_client_instance = self.setup_keystone_mock( # noqa
session_mock
)
expected_args = (
MISTRAL_HTTPS_URL,
)
client.client(
mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
api_key='password',
user_domain_name='Default',
project_domain_name='Default',
auth_url=AUTH_HTTP_URL_v3,
cacert=None,
insecure=True
)
self.assertTrue(http_client_mock.called)
self.assertEqual(http_client_mock.call_args[0], expected_args)
self.assertEqual(http_client_mock.call_args[1]['insecure'], True)
def test_mistral_url_https_secure(self, mock, keystone_client_mock):
fd, path = tempfile.mkstemp(suffix='.pem')
keystone_client_instance = keystone_client_mock.return_value
keystone_client_instance.auth_token = str(uuid.uuid4())
keystone_client_instance.project_id = str(uuid.uuid4())
keystone_client_instance.user_id = str(uuid.uuid4())
expected_args = (
MISTRAL_HTTPS_URL,
keystone_client_instance.auth_token,
keystone_client_instance.project_id,
keystone_client_instance.user_id
)
expected_kwargs = {
'cacert': path,
'insecure': False
}
try:
client.client(
mistral_url=MISTRAL_HTTPS_URL,
username='******',
project_name='mistral',
auth_url=AUTH_HTTP_URL,
cacert=path,
insecure=False
)
finally:
os.close(fd)
os.unlink(path)
self.assertTrue(mock.called)
self.assertEqual(mock.call_args[0], expected_args)
self.assertDictEqual(mock.call_args[1], expected_kwargs)
def mistral(self):
if self._mistral:
return self._mistral
args = {
'auth_token': self.auth_token,
}
endpoint_type = get_client_option('mistral', 'endpoint_type')
region_name = get_client_option('mistral', 'region_name')
endpoint = self.url_for(service_type='workflow',
endpoint_type=endpoint_type,
region_name=region_name)
self._mistral = mistralclient.client(mistral_url=endpoint, **args)
return self._mistral
def factory(keystone_client, auth_token):
mistral_settings = CONF.mistral
endpoint_type = mistral_settings.endpoint_type
service_type = mistral_settings.service_type
mistral_url = keystone_client.service_catalog.url_for(
service_type=service_type,
endpoint_type=endpoint_type)
return mistralclient.client(mistral_url=mistral_url,
project_id=keystone_client.tenant_id,
endpoint_type=endpoint_type,
service_type=service_type,
auth_token=auth_token,
user_id=keystone_client.user_id)
def initialize_app(self, argv):
self._clear_shell_commands()
ver = client.determine_client_version(self.options.mistral_version)
self._set_shell_commands(self._get_commands(ver))
do_help = ('help' in argv) or ('-h' in argv) or not argv
# Set default for auth_url if not supplied. The default is not
# set at the parser to support use cases where auth is not enabled.
# An example use case would be a developer's environment.
if not self.options.auth_url:
if self.options.password or self.options.token:
self.options.auth_url = 'http://localhost:35357/v3'
# bash-completion should not require authentification.
if do_help or ('bash-completion' in argv):
self.options.auth_url = None
self.client = client.client(
mistral_url=self.options.mistral_url,
username=self.options.username,
api_key=self.options.password,
project_name=self.options.tenant_name,
auth_url=self.options.auth_url,
project_id=self.options.tenant_id,
endpoint_type=self.options.endpoint_type,
service_type=self.options.service_type,
auth_token=self.options.token,
cacert=self.options.cacert,
insecure=self.options.insecure,
profile=self.options.profile,
auth_type=self.options.auth_type,
client_id=self.options.client_id,
client_secret=self.options.client_secret,
)
# Adding client_manager variable to make mistral client work with
# unified OpenStack client.
ClientManager = type(
'ClientManager',
(object,),
dict(workflow_engine=self.client)
)
self.client_manager = ClientManager()
