跳转至主要内容

Management API

提供对Casbin策略管理的全面支持的原始API

Filtered API​

几乎所有的过滤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") // will return: [[alice book read] [bob book read] [bob book write]]

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

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

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

参考​

全局变量 e 是Enforcer实例。

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"}})

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)