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 = []