跳转至主要内容

Management API

Management API 涵盖所有策略和分组（角色）操作：获取、添加、删除、更新、过滤。下文中 e 是一个 Enforcer 实例。

Filtered API​

带过滤的方法接受 (fieldIndex int, fieldValues ...string)：从 fieldIndex 开始匹配，fieldValues 是各个连续位置上要求的值。在 fieldValues 中用 "" 作为该位置的通配符。

示例：

p, alice, book, read
p, bob, book, read
p, bob, book, write
p, alice, pen, get
p, bob, pen ,get
e.GetFilteredPolicy(1, "book") // returns: [["alice", "book", "read"], ["bob", "book", "read"], ["bob", "book", "write"]]

e.GetFilteredPolicy(1, "book", "read") // returns: [["alice", "book", "read"], ["bob", "book", "read"]]

e.GetFilteredPolicy(0, "alice", "", "read") // returns: [[alice book read]]

e.GetFilteredPolicy(0, "alice") // returns: [["alice", "book", "read"], ["alice", "pen", "get"]]

API 参考​

e, err := NewEnforcer("examples/rbac_model.conf", "examples/rbac_policy.csv")

Enforce()​

Enforce决定一个“主体”是否可以用“操作”访问一个“对象”，输入参数通常是：(sub, obj, act)。

例如：

ok, err := e.Enforce(request)

EnforceWithMatcher()​

EnforceWithMatcher使用自定义匹配器来决定一个“主体”是否可以用“操作”访问一个“对象”，输入参数通常是：(matcher, sub, obj, act)，当matcher为空字符串时，默认使用模型匹配器。

例如：

ok, err := e.EnforceWithMatcher(matcher, request)

EnforceEx()​

EnforceEx通过通知匹配的规则来解释执行。

例如：

ok, reason, err := e.EnforceEx(request)

EnforceExWithMatcher()​

EnforceExWithMatcher使用自定义匹配器并通过通知匹配的规则来解释执行。

例如：

ok, reason, err := e.EnforceExWithMatcher(matcher, request)

BatchEnforce()​

BatchEnforce执行每个请求并在布尔数组中返回结果

例如：

boolArray, err := e.BatchEnforce(requests)

GetAllSubjects()​

GetAllSubjects获取出现在当前策略中的主题列表。

例如：

allSubjects := e.GetAllSubjects()

GetAllNamedSubjects()​

GetAllNamedSubjects获取当前命名策略中出现的主题列表。

例如：

allNamedSubjects := e.GetAllNamedSubjects("p")

GetAllObjects()​

GetAllObjects获取当前策略中出现的对象列表。

例如：

allObjects := e.GetAllObjects()

GetAllNamedObjects()​

GetAllNamedObjects获取当前命名策略中出现的对象列表。

例如：

allNamedObjects := e.GetAllNamedObjects("p")

GetAllActions()​

GetAllActions获取当前策略中出现的操作列表。

例如:

allActions := e.GetAllActions()

GetAllNamedActions()​

GetAllNamedActions获取当前命名策略中出现的操作列表。

例如：

allNamedActions := e.GetAllNamedActions("p")

GetAllRoles()​

GetAllRoles获取当前策略中出现的角色列表。

例如:

allRoles = e.GetAllRoles()

GetAllNamedRoles()​

GetAllNamedRoles获取当前命名策略中出现的角色列表。

例如：

allNamedRoles := e.GetAllNamedRoles("g")

GetPolicy()​

GetPolicy获取策略中的所有授权规则。

例如：

policy = e.GetPolicy()

GetFilteredPolicy()​

GetFilteredPolicy获取策略中的所有授权规则，可以指定字段过滤器。

例如:

filteredPolicy := e.GetFilteredPolicy(0, "alice")

GetNamedPolicy()​

GetNamedPolicy获取命名策略中的所有授权规则。

例如：

namedPolicy := e.GetNamedPolicy("p")

GetFilteredNamedPolicy()​

GetFilteredNamedPolicy获取命名策略中的所有授权规则，可以指定字段过滤器。

例如：

filteredNamedPolicy = e.GetFilteredNamedPolicy("p", 0, "bob")

GetGroupingPolicy()​

GetGroupingPolicy获取策略中的所有角色继承规则。

例如：

groupingPolicy := e.GetGroupingPolicy()

GetFilteredGroupingPolicy()​

GetFilteredGroupingPolicy获取策略中的所有角色继承规则，可以指定字段过滤器。

例如：

filteredGroupingPolicy := e.GetFilteredGroupingPolicy(0, "alice")

GetNamedGroupingPolicy()​

GetNamedGroupingPolicy获取策略中的所有角色继承规则。

例如：

namedGroupingPolicy := e.GetNamedGroupingPolicy("g")

GetFilteredNamedGroupingPolicy()​

GetFilteredNamedGroupingPolicy获取策略中的所有角色继承规则。

例如:

namedGroupingPolicy := e.GetFilteredNamedGroupingPolicy("g", 0, "alice")

HasPolicy()​

HasPolicy确定是否存在授权规则。

例如:

hasPolicy := e.HasPolicy("data2_admin", "data2", "read")

HasNamedPolicy()​

HasNamedPolicy确定是否存在命名的授权规则。

例如：

hasNamedPolicy := e.HasNamedPolicy("p", "data2_admin", "data2", "read")

AddPolicy()​

AddPolicy将授权规则添加到当前策略。如果规则已经存在，函数将返回false，规则不会被添加。否则，函数通过添加新规则返回true。

例如:

added := e.AddPolicy('eve', 'data3', 'read')

AddPolicies()​

AddPolicies将授权规则添加到当前策略。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，且不会向当前策略添加策略规则。如果所有授权规则与策略规则一致，函数将返回true，并将每个策略规则添加到当前策略。

例如：

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesAdded := e.AddPolicies(rules)

AddPoliciesEx()​

AddPoliciesEx将授权规则添加到当前策略。如果规则已经存在，规则不会被添加。但与AddPolicies不同，其他不存在的规则会被添加，而不是直接返回false

例如：

ok, err := e.AddPoliciesEx([][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

AddNamedPolicy()​

AddNamedPolicy将授权规则添加到当前命名策略。如果规则已经存在，函数将返回false，规则不会被添加。否则，函数通过添加新规则返回true。

例如:

added := e.AddNamedPolicy("p", "eve", "data3", "read")

AddNamedPolicies()​

AddNamedPolicies将授权规则添加到当前命名策略。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，且不会向当前策略添加策略规则。如果所有授权规则与策略规则一致，函数将返回true，并将每个策略规则添加到当前策略。

例如：

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesAdded := e.AddNamedPolicies("p", rules)

AddNamedPoliciesEx()​

AddNamedPoliciesEx将授权规则添加到当前命名策略。如果规则已经存在，规则不会被添加。但与AddNamedPolicies不同，其他不存在的规则会被添加，而不是直接返回false

例如:

ok, err := e.AddNamedPoliciesEx("p", [][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

SelfAddPoliciesEx()​

SelfAddPoliciesEx将授权规则添加到当前命名策略，且自动通知观察者功能被禁用。如果规则已经存在，规则不会被添加。但与SelfAddPolicies不同，其他不存在的规则会被添加，而不是直接返回false

例如：

ok, err := e.SelfAddPoliciesEx("p", "p", [][]string{{"user1", "data1", "read"}, {"user2", "data2", "read"}})

RemovePolicy()​

RemovePolicy从当前策略中移除一个授权规则。

例如：

removed := e.RemovePolicy("alice", "data1", "read")

RemovePolicies()​

RemovePolicies从当前策略中移除授权规则。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，并且不会从当前策略中删除任何策略规则。如果所有的授权规则都与策略规则一致，函数将返回true，并且每个策略规则都将从当前策略中删除。

例如：

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesRemoved := e.RemovePolicies(rules)

RemoveFilteredPolicy()​

RemoveFilteredPolicy从当前策略中移除一个授权规则，可以指定字段过滤器。 RemovePolicy从当前策略中移除一个授权规则。

例如：

removed := e.RemoveFilteredPolicy(0, "alice", "data1", "read")

RemoveNamedPolicy()​

RemoveNamedPolicy从当前命名策略中移除一个授权规则。

例如：

removed := e.RemoveNamedPolicy("p", "alice", "data1", "read")

RemoveNamedPolicies()​

RemoveNamedPolicies从当前命名策略中移除授权规则。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，并且不会从当前策略中删除任何策略规则。如果所有的授权规则都与策略规则一致，函数将返回true，并且每个策略规则都将从当前策略中删除。

例如：

rules := [][] string {
    []string {"jack", "data4", "read"},
    []string {"katy", "data4", "write"},
    []string {"leyo", "data4", "read"},
    []string {"ham", "data4", "write"},
}

areRulesRemoved := e.RemoveNamedPolicies("p", rules)

RemoveFilteredNamedPolicy()​

RemoveFilteredNamedPolicy从当前命名策略中移除一个授权规则，可以指定字段过滤器。

例如:

removed := e.RemoveFilteredNamedPolicy("p", 0, "alice", "data1", "read")

HasGroupingPolicy()​

HasGroupingPolicy确定是否存在角色继承规则。

例如：

has := e.HasGroupingPolicy("alice", "data2_admin")

HasNamedGroupingPolicy()​

HasNamedGroupingPolicy确定是否存在命名角色继承规则。

例如:

has := e.HasNamedGroupingPolicy("g", "alice", "data2_admin")

AddGroupingPolicy()​

AddGroupingPolicy向当前策略添加角色继承规则。如果规则已经存在，函数将返回false，规则不会被添加。否则，函数通过添加新规则返回true。

例如：

added := e.AddGroupingPolicy("group1", "data2_admin")

AddGroupingPolicies()​

AddGroupingPolicies将角色继承规则添加到当前策略。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，且不会向当前策略添加策略规则。如果所有授权规则与策略规则一致，函数将返回true，并将每个策略规则添加到当前策略。

例如：

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesAdded := e.AddGroupingPolicies(rules)

AddGroupingPoliciesEx()​

AddGroupingPoliciesEx将角色继承规则添加到当前策略。如果规则已经存在，规则不会被添加。但与AddGroupingPolicies不同，其他不存在的规则会被添加，而不是直接返回false

例如：

ok, err := e.AddGroupingPoliciesEx([][]string{{"user1", "member"}, {"user2", "member"}})

AddNamedGroupingPolicy()​

AddNamedGroupingPolicy将命名的角色继承规则添加到当前策略。如果规则已经存在，函数将返回false，规则不会被添加。否则，函数通过添加新规则返回true。

例如：

added := e.AddNamedGroupingPolicy("g", "group1", "data2_admin")

AddNamedGroupingPolicies()​

AddNamedGroupingPolicies将命名的角色继承规则添加到当前策略。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，且不会向当前策略添加策略规则。如果所有授权规则与策略规则一致，函数将返回true，并将每个策略规则添加到当前策略。

例如：

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesAdded := e.AddNamedGroupingPolicies("g", rules)

AddNamedGroupingPoliciesEx()​

AddNamedGroupingPoliciesEx将命名的角色继承规则添加到当前策略。如果规则已经存在，规则不会被添加。但与AddNamedGroupingPolicies不同，其他不存在的规则会被添加，而不是直接返回false

例如:

ok, err := e.AddNamedGroupingPoliciesEx("g", [][]string{{"user1", "member"}, {"user2", "member"}})

RemoveGroupingPolicy()​

RemoveGroupingPolicy从当前策略中删除一个角色继承规则。

例如:

removed := e.RemoveGroupingPolicy("alice", "data2_admin")

RemoveGroupingPolicies()​

RemoveGroupingPolicies从当前策略中删除角色继承规则。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，并且不会从当前策略中删除任何策略规则。如果所有的授权规则都与策略规则一致，函数将返回true，并且每个策略规则都将从当前策略中删除。

例如：

rules := [][] string {
                []string {"ham", "data4_admin"},
                []string {"jack", "data5_admin"},
        }

areRulesRemoved := e.RemoveGroupingPolicies(rules)

RemoveFilteredGroupingPolicy()​

RemoveFilteredGroupingPolicy从当前策略中删除一个角色继承规则，可以指定字段过滤器。

例如:

removed := e.RemoveFilteredGroupingPolicy(0, "alice")

RemoveNamedGroupingPolicy()​

RemoveNamedGroupingPolicy从当前命名策略中删除一个角色继承规则。

例如：

removed := e.RemoveNamedGroupingPolicy("g", "alice")

RemoveNamedGroupingPolicies()​

RemoveNamedGroupingPolicies从当前策略中删除命名的角色继承规则。该操作的性质是原子性的。因此，如果授权规则包含的规则与当前策略不一致，函数将返回false，并且不会从当前策略中删除任何策略规则。如果所有的授权规则都与策略规则一致，函数将返回true，并且每个策略规则都将从当前策略中删除。

例如:

rules := [][] string {
    []string {"ham", "data4_admin"},
    []string {"jack", "data5_admin"},
}

areRulesRemoved := e.RemoveNamedGroupingPolicies("g", rules)

RemoveFilteredNamedGroupingPolicy()​

RemoveFilteredNamedGroupingPolicy从当前命名策略中删除一个角色继承规则，可以指定字段过滤器。

例如：

removed := e.RemoveFilteredNamedGroupingPolicy("g", 0, "alice")

UpdatePolicy()​

UpdatePolicy将旧策略更新为新策略。

例如：

updated, err := e.UpdatePolicy([]string{"eve", "data3", "read"}, []string{"eve", "data3", "write"})

UpdatePolicies()​

UpdatePolicies将所有旧策略更新为新策略。

例如:

updated, err := e.UpdatePolicies([][]string{{"eve", "data3", "read"}, {"jack", "data3", "read"}}, [][]string{{"eve", "data3", "write"}, {"jack", "data3", "write"}})

UpdateNamedPolicy()​

UpdateNamedPolicy 把命名策略中的一条旧策略更新为新策略。

例如：

updated, err := e.UpdateNamedPolicy("p", []string{"eve", "data3", "read"}, []string{"eve", "data3", "write"})

UpdateNamedPolicies()​

UpdateNamedPolicies 把命名策略中的所有旧策略更新为新策略。

例如:

updated, err := e.UpdateNamedPolicies("p", [][]string{{"eve", "data3", "read"}, {"jack", "data3", "read"}}, [][]string{{"eve", "data3", "write"}, {"jack", "data3", "write"}})

UpdateFilteredPolicies()​

UpdateFilteredPolicies 把所有匹配过滤条件的旧策略更新为新策略。

例如:

updated, err := e.UpdateFilteredPolicies([][]string{{"eve", "data3", "write"}}, 0, "eve", "data3", "read")

AddFunction()​

AddFunction添加一个自定义函数。

例如:

func CustomFunction(key1 string, key2 string) bool {
    if key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data/:resource" {
        return true
    } else if key1 == "/alice_data2/myid/using/res_id" && key2 == "/alice_data2/:id/using/:resId" {
        return true
    } else {
        return false
    }
}

func CustomFunctionWrapper(args ...interface{}) (interface{}, error) {
    key1 := args[0].(string)
    key2 := args[1].(string)

    return bool(CustomFunction(key1, key2)), nil
}

e.AddFunction("keyMatchCustom", CustomFunctionWrapper)

LoadFilteredPolicy()​

LoadFilteredPolicy从文件/数据库加载过滤策略。

例如：

err := e.LoadFilteredPolicy()

LoadIncrementalFilteredPolicy()​

LoadIncrementalFilteredPolicy从文件/数据库追加一个过滤策略。

例如：

err := e.LoadIncrementalFilteredPolicy()

UpdateGroupingPolicy()​

UpdateGroupingPolicy更新g部分的oldRule为newRule。

例如：

succeed, err : = e.UpdateGroupingPolicy([]string{"data3_admin", "data4_admin"}, []string{"admin", "data4_admin"})

UpdateNamedGroupingPolicy()​

UpdateNamedGroupingPolicy更新名为ptype的oldRule为g部分的newRule。

例如：

succeed, err : = e.UpdateGroupingPolicy("g1",[]string{"data3_admin", "data4_admin"}, []string{"admin", "data4_admin"})

SetFieldIndex()​

SetFieldIndex支持sub、obj、domain和priority的常规名称和位置的自定义。

[policy_definition]
p = customized_priority, obj, act, eft, subject

例如:

e.SetFieldIndex("p", constant.PriorityIndex, 0)
e.SetFieldIndex("p", constant.SubjectIndex, 4)