def test_update_endpoints(self, mock_deployment_update):
mock_deployment_update.return_value = self.deployment
deploy = objects.Deployment(deployment=self.deployment)
endpoints = {
"admin":
objects.Credential("url", "user", "pwd", "tenant",
consts.EndpointPermission.ADMIN),
"users": [
objects.Credential("url1", "user1", "pwd1", "tenant1",
consts.EndpointPermission.USER),
objects.Credential("url2", "user2", "pwd2", "tenant2",
consts.EndpointPermission.USER),
]
}
expected_users = [
u.to_dict(include_permission=True) for u in endpoints["users"]
]
deploy.update_endpoints(endpoints)
mock_deployment_update.assert_called_once_with(
self.deployment["uuid"], {
"admin": endpoints["admin"].to_dict(include_permission=True),
"users": expected_users
})
def test_users_contains_correct_endpoint_type(self, mock_identity):
credential = objects.Credential(
"foo_url",
"foo",
"foo_pass",
endpoint_type=consts.EndpointType.INTERNAL)
config = {
"config": {
"users": {
"tenants": 1,
"users_per_tenant": 2,
"resource_management_workers": 1
}
},
"admin": {
"credential": credential
},
"task": {
"uuid": "task_id"
}
}
user_generator = users.UserGenerator(config)
users_ = user_generator._create_users()
for user in users_:
self.assertEqual("internal", user["credential"].endpoint_type)
def test_to_dict_with_include_permission(self):
credential = objects.Credential(
"foo_url",
"foo_user",
"foo_password",
tenant_name="foo_tenant",
permission=consts.EndpointPermission.ADMIN)
self.assertEqual(
{
"auth_url": "foo_url",
"username": "******",
"password": "******",
"tenant_name": "foo_tenant",
"region_name": None,
"domain_name": None,
"permission": consts.EndpointPermission.ADMIN,
"endpoint": None,
"endpoint_type": None,
"https_insecure": False,
"https_cacert": None,
"project_domain_name": None,
"user_domain_name": None,
"profiler_hmac_key": None,
"profiler_conn_str": None
}, credential.to_dict(include_permission=True))
def consume(cache, args):
username, password, project_dom, user_dom, tenant_id = args
if "client" not in cache:
clients = osclients.Clients(self.credential)
cache["client"] = identity.Identity(
clients, name_generator=self.generate_random_name)
client = cache["client"]
user = client.create_user(username,
password=password,
project_id=tenant_id,
domain_name=user_dom,
default_role=default_role)
user_credential = objects.Credential(
self.credential.auth_url,
user.name,
password,
self.context["tenants"][tenant_id]["name"],
consts.EndpointPermission.USER,
project_domain_name=project_dom,
user_domain_name=user_dom,
endpoint_type=self.credential.endpoint_type,
https_insecure=self.credential.insecure,
https_cacert=self.credential.cacert,
region_name=self.credential.region_name)
users.append({
"id": user.id,
"credential": user_credential,
"tenant_id": tenant_id
})
def consume(cache, args):
username, password, project_dom, user_dom, tenant_id = args
if "client" not in cache:
clients = osclients.Clients(self.endpoint)
cache["client"] = keystone.wrap(clients.keystone())
client = cache["client"]
user = client.create_user(username, password,
"*****@*****.**" % username, tenant_id,
user_dom)
user_endpoint = objects.Credential(
client.auth_url,
user.name,
password,
self.context["tenants"][tenant_id]["name"],
consts.EndpointPermission.USER,
client.region_name,
project_domain_name=project_dom,
user_domain_name=user_dom,
endpoint_type=self.endpoint.endpoint_type,
https_insecure=self.endpoint.insecure,
https_cacert=self.endpoint.cacert)
users.append({
"id": user.id,
"endpoint": user_endpoint,
"tenant_id": tenant_id
})
def deploy(self):
self.servers = self.get_provider().create_servers()
devstack_repo = self.config.get("devstack_repo", DEVSTACK_REPO)
devstack_branch = self.config.get("devstack_branch", DEVSTACK_BRANCH)
local_conf = "[[local|localrc]]\n"
for k, v in six.iteritems(self.local_conf):
local_conf += "%s=%s\n" % (k, v)
for server in self.servers:
self.deployment.add_resource(provider_name="DevstackEngine",
type="credentials",
info=server.get_credentials())
cmd = "/bin/sh -e -s %s %s" % (devstack_repo, devstack_branch)
server.ssh.run(cmd, stdin=get_script("install.sh"))
devstack_server = get_updated_server(server, user=DEVSTACK_USER)
devstack_server.ssh.run("cat > ~/devstack/local.conf",
stdin=local_conf)
devstack_server.ssh.run("~/devstack/stack.sh")
admin_endpoint = objects.Credential("http://%s:5000/v2.0/" %
self.servers[0].host, "admin",
self.local_conf["ADMIN_PASSWORD"],
"admin",
consts.EndpointPermission.ADMIN)
return {"admin": admin_endpoint}
def test_keystone_get_session(self, auth_url):
credential = objects.Credential(auth_url, "user", "pass", "tenant")
self.set_up_keystone_mocks()
keystone = osclients.Keystone(credential, {}, {})
version_data = mock.Mock(return_value=[{"version": (1, 0)}])
self.ksa_auth.discover.Discover.return_value = (mock.Mock(
version_data=version_data))
self.assertEqual(
(self.ksa_session.Session.return_value, self.ksa_identity_plugin),
keystone.get_session())
if auth_url.endswith("v2.0"):
self.ksa_password.assert_called_once_with(auth_url=auth_url,
password="******",
tenant_name="tenant",
username="******")
else:
self.ksa_password.assert_called_once_with(auth_url=auth_url,
password="******",
tenant_name="tenant",
username="******",
domain_name=None,
project_domain_name=None,
user_domain_name=None)
self.ksa_session.Session.assert_has_calls([
mock.call(timeout=180.0, verify=True),
mock.call(auth=self.ksa_identity_plugin,
timeout=180.0,
verify=True)
])
def test_to_dict_with_kwarg_credential(self):
credential = objects.Credential(
"foo_url",
"foo_user",
"foo_password",
tenant_name="foo_tenant",
permission=consts.EndpointPermission.ADMIN,
endpoint="foo_endpoint",
endpoint_type=consts.EndpointType.PUBLIC)
self.assertEqual(
credential.to_dict(), {
"auth_url": "foo_url",
"username": "******",
"password": "******",
"tenant_name": "foo_tenant",
"region_name": None,
"domain_name": None,
"endpoint": "foo_endpoint",
"endpoint_type": consts.EndpointType.PUBLIC,
"https_insecure": False,
"https_cacert": None,
"project_domain_name": None,
"user_domain_name": None,
"profiler_hmac_key": None,
"profiler_conn_str": None
})
def test_deployment_check_raise(self):
sample_credential = objects.Credential("http://192.168.1.1:5000/v2.0/",
"admin",
"adminpass").to_dict()
sample_credential["not-exist-key"] = "error"
deployment = {"admin": sample_credential}
self.assertRaises(TypeError, api.Deployment.check, deployment)
def _prepare_context(self, ctx, name):
scenario_cls = scenario.Scenario.get(name)
namespace = scenario_cls.get_namespace()
# FIXME(astudenov): currently there is no credentials for
# namespace 'default', thus 'opentack' is used as a workaround
if namespace == "default":
namespace = "openstack"
creds = self.deployment.get_credentials_for(namespace)
existing_users = creds["users"]
# TODO(astudenov): use credential plugin in future refactoring
admin = objects.Credential(**creds["admin"])
scenario_context = copy.deepcopy(scenario_cls.get_default_context())
if existing_users and "users" not in ctx:
scenario_context.setdefault("existing_users", existing_users)
elif "users" not in ctx:
scenario_context.setdefault("users", {})
scenario_context.update(ctx)
context_obj = {
"task": self.task,
"admin": {
"credential": admin
},
"scenario_name": name,
"config": scenario_context
}
return context_obj
def flavors(self, deployment=None):
"""Display available flavors.
:param deployment: UUID or name of a deployment
"""
headers = ["ID", "Name", "vCPUs", "RAM (MB)", "Swap (MB)", "Disk (GB)"]
mixed_case_fields = ["ID", "Name", "vCPUs"]
float_cols = ["RAM (MB)", "Swap (MB)", "Disk (GB)"]
formatters = dict(
zip(float_cols,
[cliutils.pretty_float_formatter(col) for col in float_cols]))
for credential_dict in self._get_credentials(deployment):
self._print_header("Flavors", credential_dict)
table_rows = []
clients = osclients.Clients(objects.Credential(**credential_dict))
nova_client = clients.nova()
for flavor in nova_client.flavors.list():
data = [
flavor.id, flavor.name, flavor.vcpus, flavor.ram,
flavor.swap, flavor.disk
]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
formatters=formatters,
mixed_case_fields=mixed_case_fields)
def images(self, deployment=None):
"""Display available images.
:param deployment: UUID or name of a deployment
"""
headers = ["UUID", "Name", "Size (B)"]
mixed_case_fields = ["UUID", "Name"]
float_cols = ["Size (B)"]
formatters = dict(
zip(float_cols,
[cliutils.pretty_float_formatter(col) for col in float_cols]))
for credential_dict in self._get_credentials(deployment):
self._print_header("Images", credential_dict)
table_rows = []
clients = osclients.Clients(objects.Credential(**credential_dict))
glance_client = clients.glance()
for image in glance_client.images.list():
data = [image.id, image.name, image.size]
table_rows.append(utils.Struct(**dict(zip(headers, data))))
cliutils.print_list(table_rows,
fields=headers,
formatters=formatters,
mixed_case_fields=mixed_case_fields)
def setup(self):
self.context["users"] = []
self.context["tenants"] = {}
for user in self.config:
user_credential = objects.Credential(**user)
#user_kclient = osclients.Clients(user_credential).keystone()
#if user_kclient.tenant_id not in self.context["tenants"]:
# self.context["tenants"][user_kclient.tenant_id] = {
# "id": user_kclient.tenant_id,
# "name": user_kclient.tenant_name
# }
#self.context["users"].append({
# "credential": user_credential,
# "id": user_kclient.user_id,
# "tenant_id": user_kclient.tenant_id
#})
self.context["users"].append({
"credential": user_credential,
"id": "1231243434",
"tenant_id": "123234456"
})
def __init__(self,
config,
task,
admin=None,
users=None,
abort_on_sla_failure=False):
"""TaskEngine constructor.
:param config: Dict with configuration of specified benchmark scenarios
:param task: Instance of Task,
the current task which is being performed
:param admin: Dict with admin credentials
:param users: List of dicts with user credentials
:param abort_on_sla_failure: True if the execution should be stopped
when some SLA check fails
"""
try:
self.config = TaskConfig(config)
except Exception as e:
log = [str(type(e)), str(e), json.dumps(traceback.format_exc())]
task.set_failed(log=log)
raise exceptions.InvalidTaskException(str(e))
self.task = task
self.admin = admin and objects.Credential(**admin) or None
self.existing_users = users or []
self.abort_on_sla_failure = abort_on_sla_failure
def required_services(config, clients, deployment, *required_services):
"""Validator checks if specified OpenStack services are available.
:param *required_services: list of services names
"""
available_services = list(clients.services().values())
if consts.Service.NOVA_NET in required_services:
nova = osclients.Clients(
objects.Credential(**deployment["admin"])).nova()
for service in nova.services.list():
if (service.binary == consts.Service.NOVA_NET
and service.status == "enabled"):
available_services.append(consts.Service.NOVA_NET)
for service in required_services:
# NOTE(andreykurilin): validator should ignore services configured via
# context(a proper validation should be in context)
service_config = config.get("context", {}).get("api_versions",
{}).get(service, {})
if (service not in available_services
and not ("service_type" in service_config
or "service_name" in service_config)):
return ValidationResult(
False,
_("'{0}' service is not available. Hint: If '{0}' "
"service has non-default service_type, try to setup "
"it via 'api_versions' context.").format(service))
def test_deployment_check(self, mock_keystone_create_client,
mock_clients_services):
sample_credential = objects.Credential("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
deployment = {"admin": sample_credential, "users": [sample_credential]}
api.Deployment.check(deployment)
mock_keystone_create_client.assert_called_with()
mock_clients_services.assert_called_once_with()
def test_deployment_check_connect_failed(self, mock_clients_services):
sample_credential = objects.Credential("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
deployment = {"admin": sample_credential}
refused = keystone_exceptions.ConnectionRefused()
mock_clients_services.side_effect = refused
self.assertRaises(keystone_exceptions.ConnectionRefused,
api.Deployment.check, deployment)
def test_deployment_check_raise(self, mock_deployment_get,
mock_clients_verified_keystone):
deployment_id = "e87e4dca-b515-4477-888d-5f6103f13b42"
sample_endpoint = objects.Credential("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
sample_endpoint["not-exist-key"] = "error"
mock_deployment_get.return_value = {"admin": sample_endpoint}
mock_clients_verified_keystone.services.list.return_value = []
self.assertRaises(TypeError, self.deployment.check, deployment_id)
def service_list(cls, deployment):
"""Get the services list.
:param deployment: Deployment object
:returns: Service list
"""
# TODO(kun): put this work into objects.Deployment
clients = osclients.Clients(objects.Credential(**deployment["admin"]))
return clients.services()
def test_deployment_check_connect_failed(self, mock_deployment_get,
mock_clients_services):
deployment_id = "e87e4dca-b515-4477-888d-5f6103f13b42"
sample_endpoint = objects.Credential("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
mock_deployment_get.return_value = {"admin": sample_endpoint}
refused = keystone_exceptions.ConnectionRefused()
mock_clients_services.side_effect = refused
self.assertEqual(self.deployment.check(deployment_id), 1)
def test_users_and_tenants_in_context(self, mock_keystone):
wrapped_keystone = mock.MagicMock()
mock_keystone.wrap.return_value = wrapped_keystone
credential = objects.Credential("foo_url",
"foo",
"foo_pass",
https_insecure=True,
https_cacert="cacert")
tmp_context = dict(self.context)
tmp_context["config"]["users"] = {
"tenants": 1,
"users_per_tenant": 2,
"resource_management_workers": 1
}
tmp_context["admin"]["credential"] = credential
credential_dict = credential.to_dict(False)
user_list = [
mock.MagicMock(id="id_%d" % i) for i in range(self.users_num)
]
wrapped_keystone.create_user.side_effect = user_list
with users.UserGenerator(tmp_context) as ctx:
ctx.generate_random_name = mock.Mock()
ctx.setup()
create_tenant_calls = []
for i, t in enumerate(ctx.context["tenants"]):
create_tenant_calls.append(
mock.call(ctx.generate_random_name.return_value,
ctx.config["project_domain"]))
for user in ctx.context["users"]:
self.assertEqual(set(["id", "credential", "tenant_id"]),
set(user.keys()))
user_credential_dict = user["credential"].to_dict(False)
excluded_keys = [
"auth_url", "username", "password", "tenant_name",
"region_name", "project_domain_name", "admin_domain_name",
"user_domain_name"
]
for key in (set(credential_dict.keys()) - set(excluded_keys)):
self.assertEqual(credential_dict[key],
user_credential_dict[key])
tenants_ids = []
for t in ctx.context["tenants"].keys():
tenants_ids.append(t)
for (user, tenant_id, orig_user) in zip(ctx.context["users"],
tenants_ids, user_list):
self.assertEqual(user["id"], orig_user.id)
self.assertEqual(user["tenant_id"], tenant_id)
def test_deployment_check_raise(self, mock_deployment_get,
mock_deployment_check):
deployment_id = "e87e4dca-b515-4477-888d-5f6103f13b42"
sample_credential = objects.Credential("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
sample_credential["not-exist-key"] = "error"
mock_deployment_get.return_value = {"admin": sample_credential}
refused = keystone_exceptions.ConnectionRefused()
mock_deployment_check.side_effect = refused
self.assertEqual(self.deployment.check(deployment_id), 1)
def service_list(cls, deployment):
"""Get the services list.
:param deployment: Deployment object
:returns: Service list
"""
# TODO(astudenov): put this work into Credential plugins
admin = deployment.get_credentials_for("openstack")["admin"]
clients = osclients.Clients(objects.Credential(**admin))
return clients.services()
class FakeUserContext(FakeContext):
admin = {
"id": "adminuuid",
"endpoint": objects.Credential("aurl", "aname", "apwd", "atenant")
}
user = {
"id": "uuid",
"endpoint": objects.Credential("url", "name", "pwd", "tenant"),
"tenant_id": "uuid"
}
tenants = {"uuid": {"name": "tenant"}}
def __init__(self, ctx):
super(FakeUserContext, self).__init__(ctx)
self.context.setdefault("admin", FakeUserContext.admin)
self.context.setdefault("users", [FakeUserContext.user])
self.context.setdefault("tenants", FakeUserContext.tenants)
self.context.setdefault(
"scenario_name", "NovaServers.boot_server_from_volume_and_delete")
def check(cls, deployment):
"""Check keystone authentication and list all available services.
:returns: Service list
"""
services = cls.service_list(deployment)
users = deployment["users"]
for endpoint_dict in users:
osclients.Clients(objects.Credential(**endpoint_dict)).keystone()
return services
def create_from_env(cls):
creds = envutils.get_creds_from_env_vars()
return cls(
objects.Credential(creds["auth_url"],
creds["admin"]["username"],
creds["admin"]["password"],
creds["admin"]["tenant_name"],
endpoint=creds["endpoint"],
region_name=creds["region_name"],
https_cacert=creds["https_cacert"],
https_insecure=creds["https_insecure"]))
def __init__(self, deployment):
self.deployment = deployment
self.credential = db.deployment_get(deployment)["admin"]
self.clients = osclients.Clients(objects.Credential(**self.credential))
self.keystone = self.clients.verified_keystone()
self.available_services = self.clients.services().values()
self.data_dir = _create_or_get_data_dir()
self.conf = configparser.ConfigParser()
self.conf.read(os.path.join(os.path.dirname(__file__), "config.ini"))
def check(cls, deployment):
"""Check keystone authentication and list all available services.
:returns: Service list
"""
# TODO(astudenov): put this work into Credential plugins
services = cls.service_list(deployment)
users = deployment.get_credentials_for("openstack")["users"]
for endpoint_dict in users:
osclients.Clients(objects.Credential(**endpoint_dict)).keystone()
return services
def test_deployment_check(self, mock_deployment_get,
mock_keystone_create_client,
mock_clients_verified_keystone):
deployment_id = "e87e4dca-b515-4477-888d-5f6103f13b42"
sample_endpoint = objects.Credential("http://192.168.1.1:5000/v2.0/",
"admin", "adminpass").to_dict()
mock_deployment_get.return_value = {
"admin": sample_endpoint,
"users": [sample_endpoint]
}
self.deployment.check(deployment_id)
mock_deployment_get.assert_called_once_with(deployment_id)
def __init__(self, deployment, conf_path):
endpoint = db.deployment_get(deployment)["admin"]
self.clients = osclients.Clients(objects.Credential(**endpoint))
self.available_services = self.clients.services().values()
self.conf_path = conf_path
self.conf = configparser.ConfigParser()
self.conf.read(conf_path)
self._created_roles = []
self._created_images = []
self._created_flavors = []
self._created_networks = []
