desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Allows addition of another rule to the list of rules that will
be tested. Returns the OrCheck object for convenience.'
| def add_check(self, rule):
| self.rules.append(rule)
return self
|
'Create the class. Injects the \'reducers\' list, a list of
tuples matching token sequences to the names of the
corresponding reduction methods.'
| def __new__(mcs, name, bases, cls_dict):
| reducers = []
for (key, value) in cls_dict.items():
if (not hasattr(value, 'reducers')):
continue
for reduction in value.reducers:
reducers.append((reduction, key))
cls_dict['reducers'] = reducers
return super(ParseStateMeta, mcs).__new__(mcs, name, bases, cls_dic... |
'Initialize the ParseState.'
| def __init__(self):
| self.tokens = []
self.values = []
|
'Perform a greedy reduction of the token stream. If a reducer
method matches, it will be executed, then the reduce() method
will be called recursively to search for any more possible
reductions.'
| def reduce(self):
| for (reduction, methname) in self.reducers:
if ((len(self.tokens) >= len(reduction)) and (self.tokens[(- len(reduction)):] == reduction)):
meth = getattr(self, methname)
results = meth(*self.values[(- len(reduction)):])
self.tokens[(- len(reduction)):] = [r[0] for r in re... |
'Adds one more token to the state. Calls reduce().'
| def shift(self, tok, value):
| self.tokens.append(tok)
self.values.append(value)
self.reduce()
|
'Obtain the final result of the parse. Raises ValueError if
the parse failed to reduce to a single result.'
| @property
def result(self):
| if (len(self.values) != 1):
raise ValueError('Could not parse rule')
return self.values[0]
|
'Turn parenthesized expressions into a \'check\' token.'
| @reducer('(', 'check', ')')
@reducer('(', 'and_expr', ')')
@reducer('(', 'or_expr', ')')
def _wrap_check(self, _p1, check, _p2):
| return [('check', check)]
|
'Create an \'and_expr\' from two checks joined by the \'and\'
operator.'
| @reducer('check', 'and', 'check')
def _make_and_expr(self, check1, _and, check2):
| return [('and_expr', AndCheck([check1, check2]))]
|
'Extend an \'and_expr\' by adding one more check.'
| @reducer('and_expr', 'and', 'check')
def _extend_and_expr(self, and_expr, _and, check):
| return [('and_expr', and_expr.add_check(check))]
|
'Create an \'or_expr\' from two checks joined by the \'or\'
operator.'
| @reducer('check', 'or', 'check')
def _make_or_expr(self, check1, _or, check2):
| return [('or_expr', OrCheck([check1, check2]))]
|
'Extend an \'or_expr\' by adding one more check.'
| @reducer('or_expr', 'or', 'check')
def _extend_or_expr(self, or_expr, _or, check):
| return [('or_expr', or_expr.add_check(check))]
|
'Invert the result of another check.'
| @reducer('not', 'check')
def _make_not_expr(self, _not, check):
| return [('check', NotCheck(check))]
|
'Recursively checks credentials based on the defined rules.'
| def __call__(self, target, creds):
| try:
return _rules[self.match](target, creds)
except KeyError:
return False
|
'Check that there is a matching role in the cred dict.'
| def __call__(self, target, creds):
| return (self.match.lower() in [x.lower() for x in creds['roles']])
|
'Check http: rules by calling to a remote server.
This example implementation simply verifies that the response
is exactly \'True\'.'
| def __call__(self, target, creds):
| url = (('http:' + self.match) % target)
data = {'target': jsonutils.dumps(target), 'credentials': jsonutils.dumps(creds)}
post_data = urllib.urlencode(data)
f = urllib2.urlopen(url, post_data)
return (f.read() == 'True')
|
'Check an individual match.
Matches look like:
tenant:%(tenant_id)s
role:compute:admin'
| def __call__(self, target, creds):
| match = (self.match % target)
if (self.kind in creds):
return (match == unicode(creds[self.kind]))
return False
|
'Object that understands versioning for a package
:param package: name of the python package, such as glance, or
python-glanceclient'
| def __init__(self, package):
| self.package = package
self.release = None
self.version = None
self._cached_version = None
|
'Make the VersionInfo object behave like a string.'
| def __str__(self):
| return self.version_string()
|
'Include the name.'
| def __repr__(self):
| return ('VersionInfo(%s:%s)' % (self.package, self.version_string()))
|
'Get the version of the package from the pkg_resources record
associated with the package.'
| def _get_version_from_pkg_resources(self):
| try:
requirement = pkg_resources.Requirement.parse(self.package)
provider = pkg_resources.get_provider(requirement)
return provider.version
except pkg_resources.DistributionNotFound:
from keystone.openstack.common import setup
return setup.get_version(self.package)
|
'Return the full version of the package including suffixes indicating
VCS status.'
| def release_string(self):
| if (self.release is None):
self.release = self._get_version_from_pkg_resources()
return self.release
|
'Return the short version minus any alpha/beta tags.'
| def version_string(self):
| if (self.version is None):
parts = []
for part in self.release_string().split('.'):
if part[0].isdigit():
parts.append(part)
else:
break
self.version = '.'.join(parts)
return self.version
|
'Generate an object which will expand in a string context to
the results of version_string(). We do this so that don\'t
call into pkg_resources every time we start up a program when
passing version information into the CONF constructor, but
rather only do the calculation when and if a version is requested'
| def cached_version_string(self, prefix=''):
| if (not self._cached_version):
self._cached_version = ('%s%s' % (prefix, self.version_string()))
return self._cached_version
|
'Authenticate a given user, tenant and password.
:returns: (user_ref, tenant_ref, metadata_ref)
:raises: AssertionError'
| def authenticate(self, user_id=None, tenant_id=None, password=None):
| raise exception.NotImplemented()
|
'Get a tenant by id.
:returns: tenant_ref
:raises: keystone.exception.ProjectNotFound'
| def get_project(self, tenant_id):
| raise exception.NotImplemented()
|
'Get a tenant by name.
:returns: tenant_ref
:raises: keystone.exception.ProjectNotFound'
| def get_project_by_name(self, tenant_name, domain_id):
| raise exception.NotImplemented()
|
'Get a user by name.
:returns: user_ref
:raises: keystone.exception.UserNotFound'
| def get_user_by_name(self, user_name, domain_id):
| raise exception.NotImplemented()
|
'Add user to a tenant by creating a default role relationship.
:raises: keystone.exception.ProjectNotFound,
keystone.exception.UserNotFound'
| def add_user_to_project(self, tenant_id, user_id):
| self.add_role_to_user_and_project(user_id, tenant_id, config.CONF.member_role_id)
|
'Remove user from a tenant
:raises: keystone.exception.ProjectNotFound,
keystone.exception.UserNotFound'
| def remove_user_from_project(self, tenant_id, user_id):
| roles = self.get_roles_for_user_and_project(user_id, tenant_id)
if (not roles):
raise exception.NotFound(tenant_id)
for role_id in roles:
self.remove_role_from_user_and_project(user_id, tenant_id, role_id)
|
'Lists all users with a relationship to the specified project.
:returns: a list of user_refs or an empty set.
:raises: keystone.exception.ProjectNotFound'
| def get_project_users(self, tenant_id):
| raise exception.NotImplemented()
|
'Get the tenants associated with a given user.
:returns: a list of tenant_id\'s.
:raises: keystone.exception.UserNotFound'
| def get_projects_for_user(self, user_id):
| raise exception.NotImplemented()
|
'Get the roles associated with a user within given tenant.
:returns: a list of role ids.
:raises: keystone.exception.UserNotFound,
keystone.exception.ProjectNotFound'
| def get_roles_for_user_and_project(self, user_id, tenant_id):
| raise exception.NotImplemented()
|
'Get the roles associated with a user within given domain.
:returns: a list of role ids.
:raises: keystone.exception.UserNotFound,
keystone.exception.ProjectNotFound'
| def get_roles_for_user_and_domain(self, user_id, domain_id):
| def update_metadata_for_group_domain_roles(self, metadata_ref, user_id, domain_id):
group_refs = self.list_groups_for_user(user_id=user_id)
for x in group_refs:
try:
metadata_ref.update(self.get_metadata(group_id=x['id'], domain_id=domain_id))
except exception... |
'Add a role to a user within given tenant.
:raises: keystone.exception.UserNotFound,
keystone.exception.ProjectNotFound,
keystone.exception.RoleNotFound'
| def add_role_to_user_and_project(self, user_id, tenant_id, role_id):
| raise exception.NotImplemented()
|
'Remove a role from a user within given tenant.
:raises: keystone.exception.UserNotFound,
keystone.exception.ProjectNotFound,
keystone.exception.RoleNotFound'
| def remove_role_from_user_and_project(self, user_id, tenant_id, role_id):
| raise exception.NotImplemented()
|
'Creates a new tenant.
:raises: keystone.exception.Conflict'
| def create_project(self, tenant_id, tenant):
| raise exception.NotImplemented()
|
'Updates an existing tenant.
:raises: keystone.exception.ProjectNotFound,
keystone.exception.Conflict'
| def update_project(self, tenant_id, tenant):
| raise exception.NotImplemented()
|
'Deletes an existing tenant.
:raises: keystone.exception.ProjectNotFound'
| def delete_project(self, tenant_id):
| raise exception.NotImplemented()
|
'Gets the metadata for the specified user/group on project/domain.
:raises: keystone.exception.MetadataNotFound
:returns: metadata'
| def get_metadata(self, user_id=None, tenant_id=None, domain_id=None, group_id=None):
| raise exception.NotImplemented()
|
'Creates the metadata for the specified user/group on project/domain.
:returns: metadata created'
| def create_metadata(self, user_id, tenant_id, metadata, domain_id=None, group_id=None):
| raise exception.NotImplemented()
|
'Updates the metadata for the specified user/group on project/domain.
:returns: metadata updated'
| def update_metadata(self, user_id, tenant_id, metadata, domain_id=None, group_id=None):
| raise exception.NotImplemented()
|
'Creates a new domain.
:raises: keystone.exception.Conflict'
| def create_domain(self, domain_id, domain):
| raise exception.NotImplemented()
|
'List all domains in the system.
:returns: a list of domain_refs or an empty list.'
| def list_domains(self):
| raise exception.NotImplemented()
|
'Get a domain by ID.
:returns: domain_ref
:raises: keystone.exception.DomainNotFound'
| def get_domain(self, domain_id):
| raise exception.NotImplemented()
|
'Get a domain by name.
:returns: domain_ref
:raises: keystone.exception.DomainNotFound'
| def get_domain_by_name(self, domain_name):
| raise exception.NotImplemented()
|
'Updates an existing domain.
:raises: keystone.exception.DomainNotFound,
keystone.exception.Conflict'
| def update_domain(self, domain_id, domain):
| raise exception.NotImplemented()
|
'Deletes an existing domain.
:raises: keystone.exception.DomainNotFound'
| def delete_domain(self, domain_id):
| raise exception.NotImplemented()
|
'Creates a new project.
:raises: keystone.exception.Conflict'
| def create_project(self, project_id, project):
| raise exception.NotImplemented()
|
'List all projects in the system.
:returns: a list of project_refs or an empty list.'
| def list_projects(self):
| raise exception.NotImplemented()
|
'List all projects associated with a given user.
:returns: a list of project_refs or an empty list.'
| def list_user_projects(self, user_id):
| raise exception.NotImplemented()
|
'Get a project by ID.
:returns: user_ref
:raises: keystone.exception.ProjectNotFound'
| def get_project(self):
| raise exception.NotImplemented()
|
'Updates an existing project.
:raises: keystone.exception.ProjectNotFound,
keystone.exception.Conflict'
| def update_project(self, project_id, project):
| raise exception.NotImplemented()
|
'Deletes an existing project.
:raises: keystone.exception.ProjectNotFound'
| def delete_project(self, project_id):
| raise exception.NotImplemented()
|
'Creates a new user.
:raises: keystone.exception.Conflict'
| def create_user(self, user_id, user):
| raise exception.NotImplemented()
|
'List all users in the system.
:returns: a list of user_refs or an empty list.'
| def list_users(self):
| raise exception.NotImplemented()
|
'List all users in a group.
:returns: a list of user_refs or an empty list.'
| def list_users_in_group(self, group_id):
| raise exception.NotImplemented()
|
'Get a user by ID.
:returns: user_ref
:raises: keystone.exception.UserNotFound'
| def get_user(self, user_id):
| raise exception.NotImplemented()
|
'Updates an existing user.
:raises: keystone.exception.UserNotFound,
keystone.exception.Conflict'
| def update_user(self, user_id, user):
| raise exception.NotImplemented()
|
'Adds a user to a group.
:raises: keystone.exception.UserNotFound,
keystone.exception.GroupNotFound'
| def add_user_to_group(self, user_id, group_id):
| raise exception.NotImplemented()
|
'Checks if a user is a member of a group.
:raises: keystone.exception.UserNotFound,
keystone.exception.GroupNotFound'
| def check_user_in_group(self, user_id, group_id):
| raise exception.NotImplemented()
|
'Removes a user from a group.
:raises: keystone.exception.NotFound'
| def remove_user_from_group(self, user_id, group_id):
| raise exception.NotImplemented()
|
'Deletes an existing user.
:raises: keystone.exception.UserNotFound'
| def delete_user(self, user_id):
| raise exception.NotImplemented()
|
'Creates a new credential.
:raises: keystone.exception.Conflict'
| def create_credential(self, credential_id, credential):
| raise exception.NotImplemented()
|
'List all credentials in the system.
:returns: a list of credential_refs or an empty list.'
| def list_credentials(self):
| raise exception.NotImplemented()
|
'Get a credential by ID.
:returns: credential_ref
:raises: keystone.exception.CredentialNotFound'
| def get_credential(self, credential_id):
| raise exception.NotImplemented()
|
'Updates an existing credential.
:raises: keystone.exception.CredentialNotFound,
keystone.exception.Conflict'
| def update_credential(self, credential_id, credential):
| raise exception.NotImplemented()
|
'Deletes an existing credential.
:raises: keystone.exception.CredentialNotFound'
| def delete_credential(self, credential_id):
| raise exception.NotImplemented()
|
'Creates a new role.
:raises: keystone.exception.Conflict'
| def create_role(self, role_id, role):
| raise exception.NotImplemented()
|
'List all roles in the system.
:returns: a list of role_refs or an empty list.'
| def list_roles(self):
| raise exception.NotImplemented()
|
'Get a role by ID.
:returns: role_ref
:raises: keystone.exception.RoleNotFound'
| def get_role(self, role_id):
| raise exception.NotImplemented()
|
'Updates an existing role.
:raises: keystone.exception.RoleNotFound,
keystone.exception.Conflict'
| def update_role(self, role_id, role):
| raise exception.NotImplemented()
|
'Deletes an existing role.
:raises: keystone.exception.RoleNotFound'
| def delete_role(self, role_id):
| raise exception.NotImplemented()
|
'Creates a new group.
:raises: keystone.exception.Conflict'
| def create_group(self, group_id, group):
| raise exception.NotImplemented()
|
'List all groups in the system.
:returns: a list of group_refs or an empty list.'
| def list_groups(self):
| raise exception.NotImplemented()
|
'List all groups a user is in
:returns: a list of group_refs or an empty list.'
| def list_groups_for_user(self, user_id):
| raise exception.NotImplemented()
|
'Get a group by ID.
:returns: group_ref
:raises: keystone.exception.GroupNotFound'
| def get_group(self, group_id):
| raise exception.NotImplemented()
|
'Updates an existing group.
:raises: keystone.exceptionGroupNotFound,
keystone.exception.Conflict'
| def update_group(self, group_id, group):
| raise exception.NotImplemented()
|
'Deletes an existing group.
:raises: keystone.exception.GroupNotFound'
| def delete_group(self, group_id):
| raise exception.NotImplemented()
|
'Override parent to_dict() method with a simpler implementation.
Grant tables don\'t have non-indexed \'extra\' attributes, so the
parent implementation is not applicable.'
| def to_dict(self):
| return dict(self.iteritems())
|
'Check the specified password against the data store.
This is modeled on ldap/core.py. The idea is to make it easier to
subclass Identity so that you can still use it to store all the data,
but use some other means to check the password.
Note that we\'ll pass in the entire user_ref in case the subclass
needs things li... | def _check_password(self, password, user_ref):
| return utils.check_password(password, user_ref.get('password'))
|
'Authenticate based on a user, tenant and password.
Expects the user object to have a password field and the tenant to be
in the list of tenants on the user.'
| def authenticate(self, user_id=None, tenant_id=None, password=None):
| user_ref = None
tenant_ref = None
metadata_ref = {}
try:
user_ref = self._get_user(user_id)
except exception.UserNotFound:
raise AssertionError('Invalid user / password')
if (not self._check_password(password, user_ref)):
raise AssertionError('Invalid user ... |
'Authenticate based on a user, tenant and password.
Expects the user object to have a password field and the tenant to be
in the list of tenants on the user.'
| def authenticate(self, user_id=None, tenant_id=None, password=None):
| user_ref = None
tenant_ref = None
metadata_ref = {}
try:
user_ref = self._get_user(user_id)
except exception.UserNotFound:
raise AssertionError('Invalid user / password')
if (not utils.check_password(password, user_ref.get('password'))):
raise AssertionError('Inv... |
'Authenticate based on a user, tenant and password.
Expects the user object to have a password field and the tenant to be
in the list of tenants on the user.'
| def authenticate(self, user_id=None, tenant_id=None, password=None):
| tenant_ref = None
metadata_ref = {}
try:
user_ref = self._get_user(user_id)
except exception.UserNotFound:
raise AssertionError('Invalid user / password')
try:
conn = self.user.get_connection(self.user._id_to_dn(user_id), password)
if (not conn):
... |
'Returns list of tenants a user has access to'
| def get_user_projects(self, user_id):
| associations = self.role_api.list_project_roles_for_user(user_id)
project_ids = set()
for assoc in associations:
project_ids.add(assoc.project_id)
projects = []
for project_id in project_ids:
projects.append(self.get(project_id))
return projects
|
'Returns a list of groups a user has access to'
| def list_user_groups(self, user_id):
| user_dn = self.user_api._id_to_dn(user_id)
query = ('(%s=%s)' % (self.member_attribute, user_dn))
memberships = self.get_all(query)
return memberships
|
'Returns a list of users that belong to a group'
| def list_group_users(self, group_id):
| query = ('(objectClass=%s)' % self.object_class)
conn = self.get_connection()
group_dn = self._id_to_dn(group_id)
try:
attrs = conn.search_s(group_dn, ldap.SCOPE_BASE, query, [('%s' % self.member_attribute)])
except ldap.NO_SUCH_OBJECT:
return []
users = []
for (dn, member) i... |
'Replaces exception.NotFound with exception.DomainNotFound.'
| def get(self, id, filter=None):
| try:
return super(DomainApi, self).get(id, filter)
except exception.NotFound:
raise exception.DomainNotFound(domain_id=id)
|
'Gets a list of all tenants for an admin user.'
| def get_all_projects(self, context, **kw):
| if ('name' in context['query_string']):
return self.get_project_by_name(context, context['query_string'].get('name'))
self.assert_admin(context)
tenant_refs = self.identity_api.list_projects(context)
for tenant_ref in tenant_refs:
tenant_ref = self._filter_domain_id(tenant_ref)
param... |
'Get valid tenants for token based on token used to authenticate.
Pulls the token from the context, validates it and gets the valid
tenants for the user in the token.
Doesn\'t care about token scopedness.'
| def get_projects_for_token(self, context, **kw):
| try:
token_ref = self.token_api.get_token(context=context, token_id=context['token_id'])
except exception.NotFound as e:
LOG.warning(('Authentication failed: %s' % e))
raise exception.Unauthorized(e)
user_ref = token_ref['user']
tenant_ids = self.identity_api.get_projects_f... |
'Update the default tenant.'
| def update_user_project(self, context, user_id, user):
| self.assert_admin(context)
default_tenant_id = user.get('tenantId')
self.identity_api.add_user_to_project(context, default_tenant_id, user_id)
return self.update_user(context, user_id, user)
|
'Get the roles for a user and tenant pair.
Since we\'re trying to ignore the idea of user-only roles we\'re
not implementing them in hopes that the idea will die off.'
| def get_user_roles(self, context, user_id, tenant_id=None):
| self.assert_admin(context)
if (tenant_id is None):
raise exception.NotImplemented(message='User roles not supported: tenant ID required')
roles = self.identity_api.get_roles_for_user_and_project(context, user_id, tenant_id)
return {'roles': [self.identity_api.get_role(context, ... |
'Add a role to a user and tenant pair.
Since we\'re trying to ignore the idea of user-only roles we\'re
not implementing them in hopes that the idea will die off.'
| def add_role_to_user(self, context, user_id, role_id, tenant_id=None):
| self.assert_admin(context)
if (tenant_id is None):
raise exception.NotImplemented(message='User roles not supported: tenant_id required')
self.identity_api.add_role_to_user_and_project(context, user_id, tenant_id, role_id)
self._delete_tokens_for_user(context, user_id)
role_re... |
'Remove a role from a user and tenant pair.
Since we\'re trying to ignore the idea of user-only roles we\'re
not implementing them in hopes that the idea will die off.'
| def remove_role_from_user(self, context, user_id, role_id, tenant_id=None):
| self.assert_admin(context)
if (tenant_id is None):
raise exception.NotImplemented(message='User roles not supported: tenant_id required')
self.identity_api.remove_role_from_user_and_project(context, user_id, tenant_id, role_id)
self._delete_tokens_for_user(context, user_id)
|
'Ultimate hack to get around having to make role_refs first-class.
This will basically iterate over the various roles the user has in
all tenants the user is a member of and create fake role_refs where
the id encodes the user-tenant-role information so we can look
up the appropriate data when we need to delete them.'
| def get_role_refs(self, context, user_id):
| self.assert_admin(context)
self.identity_api.get_user(context, user_id)
tenant_ids = self.identity_api.get_projects_for_user(context, user_id)
o = []
for tenant_id in tenant_ids:
role_ids = self.identity_api.get_roles_for_user_and_project(context, user_id, tenant_id)
for role_id in r... |
'This is actually used for adding a user to a tenant.
In the legacy data model adding a user to a tenant required setting
a role.'
| def create_role_ref(self, context, user_id, role):
| self.assert_admin(context)
tenant_id = role.get('tenantId')
role_id = role.get('roleId')
self.identity_api.add_role_to_user_and_project(context, user_id, tenant_id, role_id)
self._delete_tokens_for_user(context, user_id)
role_ref = self.identity_api.get_role(context, role_id)
return {'role':... |
'This is actually used for deleting a user from a tenant.
In the legacy data model removing a user from a tenant required
deleting a role.
To emulate this, we encode the tenant and role in the role_ref_id,
and if this happens to be the last role for the user-tenant pair,
we remove the user from the tenant.'
| def delete_role_ref(self, context, user_id, role_ref_id):
| self.assert_admin(context)
role_ref_ref = urlparse.parse_qs(role_ref_id)
tenant_id = role_ref_ref.get('tenantId')[0]
role_id = role_ref_ref.get('roleId')[0]
self.identity_api.remove_role_from_user_and_project(context, user_id, tenant_id, role_id)
roles = self.identity_api.get_roles_for_user_and_... |
'Delete the contents of a domain.
Before we delete a domain, we need to remove all the entities
that are owned by it, i.e. Users, Groups & Projects. To do this we
call the respective delete functions for these entities, which are
themselves responsible for deleting any credentials and role grants
associated with them a... | def _delete_domain_contents(self, context, domain_id):
| user_refs = self.identity_api.list_users(context)
user_refs = [r for r in user_refs if (r['domain_id'] == domain_id)]
for user in user_refs:
if user['enabled']:
user['enabled'] = False
self.identity_api.update_user(context, user['id'], user)
self._delete_tokens_fo... |
'Get the domain via its unique name.
For use by token authentication - not for hooking to the identity
router as a public api.'
| def _get_domain_by_name(self, context, domain_name):
| ref = self.identity_api.get_domain_by_name(context, domain_name)
return {'domain': ref}
|
'Grants a role to a user or group on either a domain or project.'
| @controller.protected
def create_grant(self, context, role_id, user_id=None, group_id=None, domain_id=None, project_id=None):
| self._require_domain_xor_project(domain_id, project_id)
self._require_user_xor_group(user_id, group_id)
self.identity_api.create_grant(context, role_id, user_id, group_id, domain_id, project_id)
if user_id:
self._delete_tokens_for_user(context, user_id)
else:
self._delete_tokens_for_... |
'Lists roles granted to user/group on either a domain or project.'
| @controller.protected
def list_grants(self, context, user_id=None, group_id=None, domain_id=None, project_id=None):
| self._require_domain_xor_project(domain_id, project_id)
self._require_user_xor_group(user_id, group_id)
refs = self.identity_api.list_grants(context, user_id, group_id, domain_id, project_id)
return RoleV3.wrap_collection(context, refs)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.