Python keystone.wrap函数代码示例

 def setUp(self):
     super(KeystoneV3WrapperTestCase, self).setUp()
     self.client = mock.MagicMock()
     self.client.version = "v3"
     self.wrapped_client = keystone.wrap(self.client)
     self.client.domains.get.side_effect = exceptions.NotFound
     self.client.domains.list.return_value = [
         mock.MagicMock(id="domain_id")]

    def _role_delete(self, role_id):
        """Creates keystone user role with random name.

        :param user_id: id of the role
        """
        admin_clients = keystone_wrapper.wrap(self.admin_clients("keystone"))

        admin_clients.delete_role(role_id)

 def consume(cache, args):
     domain, task_id, i = args
     if "client" not in cache:
         clients = osclients.Clients(self.credential)
         cache["client"] = keystone.wrap(clients.keystone())
     tenant = cache["client"].create_project(
         self.generate_random_name(), domain)
     tenant_dict = {"id": tenant.id, "name": tenant.name, "users": []}
     tenants.append(tenant_dict)

 def consume(cache, args):
     domain, task_id, i = args
     if "client" not in cache:
         clients = osclients.Clients(self.endpoint)
         cache["client"] = keystone.wrap(clients.keystone())
     tenant = cache["client"].create_project(
         self.PATTERN_TENANT % {"task_id": task_id, "iter": i}, domain)
     tenant_dict = {"id": tenant.id, "name": tenant.name}
     tenants.append(tenant_dict)

    def _remove_role(self, admin_endpoint, role):
        """Remove given role from users.

        :param admin_endpoint: The base url.
        :param role: dictionary with role parameters (id, name).
        """
        client = keystone.wrap(osclients.Clients(admin_endpoint).keystone())

        for user in self.context["users"]:
            with logging.ExceptionLogger(LOG, _("Failed to remove role: %s") % role["id"]):
                client.remove_role(user_id=user["id"], role_id=role["id"], project_id=user["tenant_id"])

    def _role_create(self, **kwargs):
        """Creates keystone user role with random name.

        :param **kwargs: Optional additional arguments for roles creation
        :returns: keystone user role
        """
        admin_clients = keystone_wrapper.wrap(self.admin_clients("keystone"))

        role = admin_clients.create_role(
            self.generate_random_name(), **kwargs)
        return role

    def _get_role_object(self, context_role):
        """Check if role exists.

        :param context_role: name of existing role.
        """
        client = keystone.wrap(osclients.Clients(self.credential).keystone())
        default_roles = client.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 _add_role(self, admin_endpoint, context_role):
        """Add role to users.

        :param admin_endpoint: The base url.
        :param context_role: name of existing role.
        """
        client = keystone.wrap(osclients.Clients(admin_endpoint).keystone())
        default_roles = client.list_roles()
        for def_role in default_roles:
            if str(def_role.name) == context_role:
                role = def_role
                break
        else:
            raise exceptions.NoSuchRole(role=context_role)

        LOG.debug("Adding role %s to all users" % (role.id))
        for user in self.context["users"]:
            client.add_role(user_id=user["id"], role_id=role.id, project_id=user["tenant_id"])

        return {"id": str(role.id), "name": str(role.name)}

 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"] = keystone.wrap(clients.keystone())
     client = cache["client"]
     user = client.create_user(
         username, password,
         "%[email protected]" % username,
         tenant_id, user_dom,
         default_role=default_role)
     user_credential = 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.credential.endpoint_type,
         https_insecure=self.credential.insecure,
         https_cacert=self.credential.cacert)
     users.append({"id": user.id,
                   "credential": user_credential,
                   "tenant_id": tenant_id})

 def _manager(self):
     return keystone_wrapper.wrap(getattr(self.admin, self._service)())

 def consume(cache, user_id):
     if "client" not in cache:
         clients = osclients.Clients(self.endpoint)
         cache["client"] = keystone.wrap(clients.keystone())
     cache["client"].delete_user(user_id)

 def consume(cache, args):
     role_id, user_id, project_id = args
     if "client" not in cache:
         clients = osclients.Clients(self.credential)
         cache["client"] = keystone.wrap(clients.keystone())
     getattr(cache["client"], func_name)(role_id, user_id, project_id)