def __init__(self, context=None, admin_clients=None, clients=None): super(KeystoneBasic, self).__init__(context, admin_clients, clients) if hasattr(self, "_admin_clients"): self.admin_keystone = identity.Identity( self._admin_clients, name_generator=self.generate_random_name, atomic_inst=self.atomic_actions()) if hasattr(self, "_clients"): self.keystone = identity.Identity( self._clients, name_generator=self.generate_random_name, atomic_inst=self.atomic_actions())
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): role_id, user_id, project_id = args if "client" not in cache: clients = osclients.Clients(self.credential) cache["client"] = identity.Identity(clients) getattr(cache["client"], func_name)(role_id=role_id, user_id=user_id, project_id=project_id)
def consume(cache, args): domain, task_id, i = args if "client" not in cache: clients = osclients.Clients(self.credential) cache["client"] = identity.Identity( clients, name_generator=self.generate_random_name) tenant = cache["client"].create_project(domain_name=domain) tenant_dict = {"id": tenant.id, "name": tenant.name, "users": []} tenants.append(tenant_dict)
def _get_role_object(self, context_role): """Check if role exists. :param context_role: name of existing role. """ keystone = identity.Identity(osclients.Clients(self.credential)) default_roles = keystone.list_roles() for def_role in default_roles: if str(def_role.name) == context_role: return def_role else: raise exceptions.NoSuchRole(role=context_role)
def _get_role_object(self, context_role): """Check if role exists. :param context_role: name of existing role. """ keystone = identity.Identity(osclients.Clients(self.credential)) default_roles = keystone.list_roles() for def_role in default_roles: if str(def_role.name) == context_role: return def_role else: raise exceptions.NotFoundException( _("There is no role with name `%s`") % context_role)
def consume(cache, resource_id): if "client" not in cache: clients = osclients.Clients(self.credential) cache["client"] = identity.Identity(clients) getattr(cache["client"], func_name)(resource_id)
def _manager(self): return identity.Identity(self.user)
def _manager(self): return identity.Identity(self.admin)
def list(self): if not self.tenant_uuid: return [] client = self._admin_required and self.admin or self.user project = identity.Identity(client).get_project(self.tenant_uuid) return [project]
def get_service_with_fake_impl(self): path = "rally.plugins.openstack.services.identity.identity" with mock.patch("%s.Identity.discover_impl" % path) as mock_discover: mock_discover.return_value = mock.MagicMock(), None service = identity.Identity(self.clients) return service
def test_init_identity_service(self): self.clients.keystone.return_value.version = "v3" self.assertIsInstance( identity.Identity(self.clients)._impl, keystone_v3.UnifiedKeystoneV3Service)
def _get_user_role_ids(self, user_id, project_id): keystone = identity.Identity(osclients.Clients(self.credential)) user_roles = keystone.list_roles(user_id=user_id, project_id=project_id) return [role.id for role in user_roles]