def get_all_credentials(self): all_credentials = {} for platform, credentials in self._all_credentials.items(): if platform == "openstack": try: from rally_openstack import credential except ImportError: all_credentials[platform] = credentials else: admin = credentials[0]["admin"] if admin: admin = credential.OpenStackCredential( permission=consts.EndpointPermission.ADMIN, **admin) all_credentials[platform] = [{ "admin": admin, "users": [ credential.OpenStackCredential(**user) for user in credentials[0]["users"] ] }] else: all_credentials[platform] = credentials return all_credentials
def __init__(self, context): super(UserGenerator, self).__init__(context) creds = self.env["platforms"]["openstack"] if creds.get("admin"): admin_cred = copy.deepcopy(creds["admin"]) api_info = copy.deepcopy(creds.get("api_info", {})) if "api_info" in admin_cred: api_info.update(creds["admin"]["api_info"]) admin_cred["api_info"] = api_info context["admin"] = { "credential": credential.OpenStackCredential(**admin_cred) } if creds["users"] and not (set(self.config) - {"user_choice_method"}): self.existing_users = creds["users"] else: self.existing_users = [] self.credential = context["admin"]["credential"] project_domain = (self.credential["project_domain_name"] or cfg.CONF.openstack.project_domain) user_domain = (self.credential["user_domain_name"] or cfg.CONF.openstack.user_domain) self.DEFAULT_FOR_NEW_USERS["project_domain"] = project_domain self.DEFAULT_FOR_NEW_USERS["user_domain"] = user_domain with self.config.unlocked(): for key, value in self.DEFAULT_FOR_NEW_USERS.items(): self.config.setdefault(key, value)
def test_users_contains_default_endpoint_type(self, mock_identity): credential = oscredential.OpenStackCredential("foo_url", "foo", "foo_pass") config = { "config": { "users": { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } }, "env": { "platforms": { "openstack": { "admin": credential, "users": [] } } }, "task": { "uuid": "task_id", "deployment_uuid": "deployment_id" } } user_generator = users.UserGenerator(config) users_ = user_generator._create_users(2) for user in users_: self.assertEqual("public", user["credential"].endpoint_type)
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 = credential.OpenStackCredential( auth_url=self.credential["auth_url"], username=user.name, password=password, tenant_name=self.context["tenants"][tenant_id]["name"], permission=consts.EndpointPermission.USER, project_domain_name=project_dom, user_domain_name=user_dom, endpoint_type=self.credential["endpoint_type"], https_insecure=self.credential["https_insecure"], https_cacert=self.credential["https_cacert"], region_name=self.credential["region_name"], profiler_hmac_key=self.credential["profiler_hmac_key"], profiler_conn_str=self.credential["profiler_conn_str"], api_info=self.credential["api_info"]) users.append({ "id": user.id, "credential": user_credential, "tenant_id": tenant_id })
def test_keystone_get_session(self, auth_url): credential = oscredential.OpenStackCredential(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 use_existing_users(self): LOG.debug("Using existing users for OpenStack platform.") api_info = copy.deepcopy(self.env["platforms"]["openstack"].get( "api_info", {})) for user_credential in self.existing_users: user_credential = copy.deepcopy(user_credential) if "api_info" in user_credential: api_info.update(user_credential["api_info"]) user_credential["api_info"] = api_info user_credential = credential.OpenStackCredential(**user_credential) user_clients = osclients.Clients(user_credential) user_id = user_clients.keystone.auth_ref.user_id tenant_id = user_clients.keystone.auth_ref.project_id if tenant_id not in self.context["tenants"]: self.context["tenants"][tenant_id] = { "id": tenant_id, "name": user_credential.tenant_name } self.context["users"].append({ "credential": user_credential, "id": user_id, "tenant_id": tenant_id })
def _get_context(self): context = test.get_test_context() cred = credential.OpenStackCredential(auth_url="url", username="******", password="******") context.update({ "admin": { "id": "fake_user_id", "credential": cred }, "user": { "id": "fake_user_id", "credential": cred }, "tenant": { "id": "fake", "name": "fake", "volumes": [{ "id": "uuid", "size": 1 }], "servers": [1] } }) return context
def test_users_and_tenants_in_context(self, mock_identity): identity_service = mock_identity.Identity.return_value credential = oscredential.OpenStackCredential("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["env"]["platforms"]["openstack"]["admin"] = credential credential_dict = credential.to_dict() user_list = [ mock.MagicMock(id="id_%d" % i) for i in range(self.users_num) ] identity_service.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() excluded_keys = [ "auth_url", "username", "password", "tenant_name", "region_name", "project_domain_name", "user_domain_name", "permission" ] for key in (set(credential_dict.keys()) - set(excluded_keys)): self.assertEqual(credential_dict[key], user_credential_dict[key], "The key '%s' differs." % 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(orig_user.id, user["id"]) self.assertEqual(tenant_id, user["tenant_id"])
def __init__(self, credential, api_info=None, cache_obj=None): self.credential = credential if not isinstance(self.credential, oscred.OpenStackCredential): self.credential = oscred.OpenStackCredential(**self.credential) if api_info: LOG.warning("api_info argument of %s is deprecated. api" " information has been moved into credential" " argument." % self.__class__.__name__) self.credential.api_info.update(api_info) self.cache = cache_obj if cache_obj is not None else {}
def create_from_env(cls): creds = envutils.get_creds_from_env_vars() from rally_openstack import credential oscred = credential.OpenStackCredential( auth_url=creds["auth_url"], username=creds["admin"]["username"], password=creds["admin"]["password"], tenant_name=creds["admin"]["tenant_name"], endpoint_type=creds["endpoint_type"], user_domain_name=creds["admin"].get("user_domain_name"), project_domain_name=creds["admin"].get("project_domain_name"), endpoint=creds["endpoint"], region_name=creds["region_name"], https_cacert=creds["https_cacert"], https_insecure=creds["https_insecure"]) return cls(oscred)
def setUp(self): super(OSClientsTestCase, self).setUp() self.credential = oscredential.OpenStackCredential( "http://auth_url/v2.0", "user", "pass", "tenant") self.clients = osclients.Clients(self.credential, {}) self.fake_keystone = fakes.FakeKeystoneClient() keystone_patcher = mock.patch("%s.Keystone.create_client" % PATH, return_value=self.fake_keystone) self.mock_create_keystone_client = keystone_patcher.start() self.auth_ref_patcher = mock.patch("%s.Keystone.auth_ref" % PATH) self.auth_ref = self.auth_ref_patcher.start() self.service_catalog = self.auth_ref.service_catalog self.service_catalog.url_for = mock.MagicMock()
def use_existing_users(self): LOG.debug("Using existing users for OpenStack platform.") for user_credential in self.existing_users: user_credential = credential.OpenStackCredential(**user_credential) user_clients = osclients.Clients(user_credential) user_id = user_clients.keystone.auth_ref.user_id tenant_id = user_clients.keystone.auth_ref.project_id if tenant_id not in self.context["tenants"]: self.context["tenants"][tenant_id] = { "id": tenant_id, "name": user_credential.tenant_name } self.context["users"].append({ "credential": user_credential, "id": user_id, "tenant_id": tenant_id })
def setUp(self): super(SaharaOutputDataSourcesTestCase, self).setUp() fake_dict = oscredential.OpenStackCredential( "http://fake.example.org:5000/v2.0/", "user", "passwd") self.tenants_num = 2 self.users_per_tenant = 2 self.users = self.tenants_num * self.users_per_tenant self.task = mock.MagicMock() self.tenants = {} self.users_key = [] for i in range(self.tenants_num): self.tenants[str(i)] = {"id": str(i), "name": str(i), "sahara": {"image": "42"}} for j in range(self.users_per_tenant): self.users_key.append({"id": "%s_%s" % (str(i), str(j)), "tenant_id": str(i), "credential": fake_dict}) self.user_key = [{"id": i, "tenant_id": j, "credential": "credential"} for j in range(self.tenants_num) for i in range(self.users_per_tenant)] self.context.update({ "config": { "users": { "tenants": self.tenants_num, "users_per_tenant": self.users_per_tenant, }, "sahara_output_data_sources": { "output_type": "hdfs", "output_url_prefix": "hdfs://test_host/", }, }, "admin": {"credential": mock.MagicMock()}, "task": mock.MagicMock(), "users": self.users_key, "tenants": self.tenants })
def test__get_endpoint(self, mock_keystone_service_catalog, endpoint_type, service_type, region_name): credential = oscredential.OpenStackCredential( "http://auth_url/v2.0", "user", "pass", endpoint_type=endpoint_type, region_name=region_name) mock_choose_service_type = mock.MagicMock() osclient = osclients.OSClient(credential, {}, mock.MagicMock()) osclient.choose_service_type = mock_choose_service_type mock_url_for = mock_keystone_service_catalog.url_for self.assertEqual(mock_url_for.return_value, osclient._get_endpoint(service_type)) call_args = { "service_type": mock_choose_service_type.return_value, "region_name": region_name } if endpoint_type: call_args["interface"] = endpoint_type mock_url_for.assert_called_once_with(**call_args) mock_choose_service_type.assert_called_once_with(service_type)
def create_from_env(cls): from rally_openstack import credential from rally_openstack.platforms import existing spec = existing.OpenStack.create_spec_from_sys_environ(os.environ) if not spec["available"]: raise ValueError(spec["message"]) creds = spec["spec"] oscred = credential.OpenStackCredential( auth_url=creds["auth_url"], username=creds["admin"]["username"], password=creds["admin"]["password"], tenant_name=creds["admin"].get("tenant_name", creds["admin"].get("project_name")), endpoint_type=creds["endpoint_type"], user_domain_name=creds["admin"].get("user_domain_name"), project_domain_name=creds["admin"].get("project_domain_name"), region_name=creds["region_name"], https_cacert=creds["https_cacert"], https_insecure=creds["https_insecure"]) return cls(oscred)
def test__remove_url_version(self, original, cropped): credential = oscredential.OpenStackCredential(original, "user", "pass", "tenant") keystone = osclients.Keystone(credential, {}, {}) self.assertEqual(cropped, keystone._remove_url_version())
def setUp(self): super(TestCreateKeystoneClient, self).setUp() self.credential = oscredential.OpenStackCredential( "http://auth_url/v2.0", "user", "pass", "tenant")
def __init__(self, **kwargs): self.clients = credential.OpenStackCredential(**kwargs).clients()
def setUp(self): super(OpenStackCredentialTestCase, self).setUp() self.credential = credential.OpenStackCredential( "foo_url", "foo_user", "foo_password", tenant_name="foo_tenant")