Quantum的权限认证(3)

最新推荐文章于 2021-02-07 09:39:29 发布

spch2008

最新推荐文章于 2021-02-07 09:39:29 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

分类专栏： OpenStack OpenStack

本文链接：https://blog.youkuaiyun.com/spch2008/article/details/9700071

OpenStack 同时被 2 个专栏收录

30 篇文章

订阅专栏

OpenStack

24 篇文章

订阅专栏

本文详细介绍了量子计算项目中权限信息的加载过程，主要关注`quantumopenstackcommonpolicy.py`中的实现。文章指出全局变量`_checks`用于存储权限验证类，如`RuleCheck`和`RoleCheck`。通过装饰器，该模块在加载时完成初始化。当`or_list`包含多个元素时，会生成一个`OrCheck`对象，若需所有条件满足，则使用`AndCheck`。未匹配的情况下，会创建一个`GenericCheck`对象。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本文地址：http://blog.youkuaiyun.com/spch2008/article/details/9700071

这里主要说一下，权限信息的加载过程。

quantum\openstack\common\policy.py中

全局变量_checks = {}是一个字典，存放各种权限验证类。比如;

{'rule':RuleCheck, 'role':RoleCheck}，由于使用了装饰器，所以，此模块被加载时，_checks就被初始化了，具体可参见带参数的装饰器。

def register(name, func=None):

    def decorator(func):
        _checks[name] = func
        return func

    if func:
        return decorator(func)

    return decorator

@register("role")
class RoleCheck(Check):
    def __call__(self, target, creds):
        """Check that there is a matching role in the cred dict."""

        return self.match.lower() in [x.lower() for x in creds['roles']]

由于register只传递一个参数'role'，所以，register中func值为None，用返回的decorator函数装饰RoleCheck类，将类存放于_check中。

class Rules(dict):
    
    @classmethod
    def load_json(cls, data, default_rule=None):
        
        rules = dict((k, parse_rule(v)) for k, v in
                     jsonutils.loads(data).items())
          
        return cls(rules, default_rule)

data为policy.json中的数据，jsonutils.loads将数据组织成字典返回。所以，对于数据

{
"admin_or_owner": [["role:admin"], ["tenant_id:%(tenant_id)s"]],  
"get_port": [["rule:admin_or_owner"]],
}

实际返回的就是上述格式的字典，然后进行列表解析。

def parse_rule(rule):
    
    if isinstance(rule, basestring):
        return _parse_text_rule(rule)
    return _parse_list_rule(rule)

rule是一个[["role:admin"], ["tenant_id:%(tenant_id)s"]]存放列表的列表，所以继续调用_parse_list_rule

def _parse_list_rule(rule):
    #空条目，例如[]，返回TrueCheck，永真
    if not rule:
        return TrueCheck()
		
    or_list = []
    for inner_rule in rule:
        if isinstance(inner_rule, basestring):
            inner_rule = [inner_rule]
   
        and_list = [_parse_check(r) for r in inner_rule]

        if len(and_list) == 1:
            or_list.append(and_list[0])
        else:
            or_list.append(AndCheck(and_list))

    # If we have only one check, omit the "or"
    if len(or_list) == 0:
        return FalseCheck()
    elif len(or_list) == 1:
        return or_list[0]

    return OrCheck(or_list)

得到的and_list如果只有一个，则可以直接加入or_list，如果有多个，需要合成一个AndCheck对象，表示每一个都需要匹配。

最终，如果or_list大于一个元素，则形成一个Orcheck对象。

原理很简单：对于[ ["role:admin"], ["tenant_id:%(tenant_id)s"] ]情况，只需要满足内部一个条件即可, OrCheck。

而对于 ["role:admin", "tenant_id:%(tenant_id)s"] 这种情况，需要每一个都要满足，需要一个AndCheck。

def _parse_check(rule):

    # Handle the special checks
    if rule == '!':
        return FalseCheck()
    elif rule == '@':
        return TrueCheck()

    try:
        kind, match = rule.split(':', 1)
    except Exception:
        return FalseCheck()

    if kind in _checks:
        return _checks[kind](kind, match)
    elif None in _checks:
        return _checks[None](kind, match)
    else:
        return FalseCheck()

对于一个规则，rule:admin_or_owner，拆分成kind(rule)与match(admin_or_owner)，如果是'rule','role'等创建相应的对象，

如果没有匹配，则创建一个GenericCheck。