Passer au contenu principal

Management API

L'API primitive qui fournit un support complet pour la gestion des politiques Casbin.

Filtered API​

Presque toutes les api filtrĂ©es ont les mĂȘmes paramĂštres (fieldIndex int, fieldValues ...string). fieldIndex est l'index oĂč commence la correspondance, fieldValues dĂ©signe les valeurs que le rĂ©sultat devrait avoir. Notez qu'une chaĂźne vide dans fieldValues pourrait ĂȘtre n'importe quel mot.

Exemple :

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]]

RĂ©fĂ©rence​

la variable globale e est une instance de Enforcer.

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

Enforce()​

Enforce décide si un "sujet" peut accéder à un "objet" avec l'opération "action", les paramÚtres d'entrée sont généralement : (sub, obj, act).

Par exemple :

ok, err := e.Enforce(request)

EnforceWithMatcher()​

EnforceWithMatcher utilise un comparateur personnalisé pour décider si un "sujet" peut accéder à un "objet" avec l'opération "action", les paramÚtres d'entrée sont généralement : (matcher, sub, obj, act), utilise le comparateur de modÚle par défaut lorsque matcher est "".

Par exemple :

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

EnforceEx()​

EnforceEx explique l'application en informant les rĂšgles correspondantes.

Par exemple :

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

EnforceExWithMatcher()​

EnforceExWithMatcher utilise un comparateur personnalisé et explique l'application en informant les rÚgles correspondantes.

Par exemple :

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

BatchEnforce()​

BatchEnforce applique chaque requĂȘte et renvoie le rĂ©sultat dans un tableau boolĂ©en

Par exemple :

boolArray, err := e.BatchEnforce(requests)

GetAllSubjects()​

GetAllSubjects obtient la liste des sujets qui apparaissent dans la politique actuelle.

Par exemple :

allSubjects := e.GetAllSubjects()

GetAllNamedSubjects()​

GetAllNamedSubjects obtient la liste des sujets qui apparaissent dans la politique nommée actuelle.

Par exemple :

allNamedSubjects := e.GetAllNamedSubjects("p")

GetAllObjects()​

GetAllObjects obtient la liste des objets qui apparaissent dans la politique actuelle.

Par exemple :

allObjects := e.GetAllObjects()

GetAllNamedObjects()​

GetAllNamedObjects obtient la liste des objets qui apparaissent dans la politique nommée actuelle.

Par exemple :

allNamedObjects := e.GetAllNamedObjects("p")

GetAllActions()​

GetAllActions obtient la liste des actions qui apparaissent dans la politique actuelle.

Par exemple :

allActions := e.GetAllActions()

GetAllNamedActions()​

GetAllNamedActions obtient la liste des actions qui apparaissent dans la politique nommée actuelle.

Par exemple :

allNamedActions := e.GetAllNamedActions("p")

GetAllRoles()​

GetAllRoles obtient la liste des rĂŽles qui apparaissent dans la politique actuelle.

Par exemple:

allRoles = e.GetAllRoles()

GetAllNamedRoles()​

GetAllNamedRoles obtient la liste des rÎles qui apparaissent dans la politique nommée actuelle.

Par exemple:

allNamedRoles := e.GetAllNamedRoles("g")

GetPolicy()​

GetPolicy obtient toutes les rĂšgles d'autorisation dans la politique.

Par exemple:

policy = e.GetPolicy()

GetFilteredPolicy()​

GetFilteredPolicy obtient toutes les rĂšgles d'autorisation dans la politique, des filtres de champ peuvent ĂȘtre spĂ©cifiĂ©s.

Par exemple:

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

GetNamedPolicy()​

GetNamedPolicy obtient toutes les rÚgles d'autorisation dans la politique nommée.

Par exemple:

namedPolicy := e.GetNamedPolicy("p")

GetFilteredNamedPolicy()​

GetFilteredNamedPolicy obtient toutes les rĂšgles d'autorisation dans la politique nommĂ©e, des filtres de champ peuvent ĂȘtre spĂ©cifiĂ©s.

Par exemple:

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

GetGroupingPolicy()​

GetGroupingPolicy obtient toutes les rÚgles d'héritage de rÎle dans la politique.

Par exemple:

groupingPolicy := e.GetGroupingPolicy()

GetFilteredGroupingPolicy()​

GetFilteredGroupingPolicy obtient toutes les rĂšgles d'hĂ©ritage de rĂŽle dans la politique, des filtres de champ peuvent ĂȘtre spĂ©cifiĂ©s.

Par exemple:

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

GetNamedGroupingPolicy()​

GetNamedGroupingPolicy obtient toutes les rÚgles d'héritage de rÎle dans la politique.

Par exemple:

namedGroupingPolicy := e.GetNamedGroupingPolicy("g")

GetFilteredNamedGroupingPolicy()​

GetFilteredNamedGroupingPolicy obtient toutes les rÚgles d'héritage de rÎle dans la politique.

Par exemple:

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

HasPolicy()​

HasPolicy détermine si une rÚgle d'autorisation existe.

Par exemple:

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

HasNamedPolicy()​

HasNamedPolicy détermine si une rÚgle d'autorisation nommée existe.

Par exemple:

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

AddPolicy()​

AddPolicy ajoute une rÚgle d'autorisation à la politique actuelle. Si la rÚgle existe déjà, la fonction renvoie false et la rÚgle ne sera pas ajoutée. Sinon, la fonction renvoie true en ajoutant la nouvelle rÚgle.

Par exemple:

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

AddPolicies()​

AddPolicies ajoute des rÚgles d'autorisation à la politique actuelle. L'opération est de nature atomique. Par conséquent, si les rÚgles d'autorisation consistent en des rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune rÚgle de politique n'est ajoutée à la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie true et chaque rÚgle de politique est ajoutée à la politique actuelle.

Par exemple :

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

areRulesAdded := e.AddPolicies(rules)

AddPoliciesEx()​

AddPoliciesEx ajoute des rÚgles d'autorisation à la politique actuelle. Si la rÚgle existe déjà, la rÚgle ne sera pas ajoutée. Mais contrairement à AddPolicies, d'autres rÚgles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple :

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

AddNamedPolicy()​

AddNamedPolicy ajoute une rÚgle d'autorisation à la politique nommée actuelle. Si la rÚgle existe déjà, la fonction renvoie false et la rÚgle ne sera pas ajoutée. Sinon, la fonction renvoie true en ajoutant la nouvelle rÚgle.

Par exemple :

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

AddNamedPolicies()​

AddNamedPolicies ajoute des rÚgles d'autorisation à la politique nommée actuelle. L'opération est atomique de nature. Par conséquent, si les rÚgles d'autorisation consistent en des rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune rÚgle de politique n'est ajoutée à la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie true et chaque rÚgle de politique est ajoutée à la politique actuelle.

Par exemple :

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 ajoute des rÚgles d'autorisation à la politique nommée actuelle. Si la rÚgle existe déjà, la rÚgle ne sera pas ajoutée. Mais contrairement à AddNamedPolicies, d'autres rÚgles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple :

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

SelfAddPoliciesEx()​

SelfAddPoliciesEx ajoute des rÚgles d'autorisation à la politique nommée actuelle avec autoNotifyWatcher désactivé. Si la rÚgle existe déjà, la rÚgle ne sera pas ajoutée. Mais contrairement à SelfAddPolicies, d'autres rÚgles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple :

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

RemovePolicy()​

RemovePolicy supprime une rĂšgle d'autorisation de la politique actuelle.

Par exemple :

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

RemovePolicies()​

RemovePolicies supprime des rÚgles d'autorisation de la politique actuelle. L'opération est atomique de nature. Par conséquent, si les rÚgles d'autorisation consistent en des rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune rÚgle de politique n'est supprimée de la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie vrai et chaque rÚgle de politique est retirée de la politique actuelle.

Par exemple :

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

areRulesRemoved := e.RemovePolicies(rules)

RemoveFilteredPolicy()​

RemoveFilteredPolicy supprime une rĂšgle d'autorisation de la politique actuelle, des filtres de champ peuvent ĂȘtre spĂ©cifiĂ©s. RemovePolicy supprime une rĂšgle d'autorisation de la politique actuelle.

Par exemple :

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

RemoveNamedPolicy()​

RemoveNamedPolicy supprime une rÚgle d'autorisation de la politique nommée actuelle.

Par exemple :

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

RemoveNamedPolicies()​

RemoveNamedPolicies supprime des rÚgles d'autorisation de la politique nommée actuelle. L'opération est de nature atomique. Par conséquent, si les rÚgles d'autorisation consistent en des rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie faux et aucune rÚgle de politique n'est retirée de la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie vrai et chaque rÚgle de politique est retirée de la politique actuelle.

Par exemple :

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 supprime une rĂšgle d'autorisation de la politique nommĂ©e actuelle, des filtres de champ peuvent ĂȘtre spĂ©cifiĂ©s.

Par exemple :

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

HasGroupingPolicy()​

HasGroupingPolicy détermine si une rÚgle d'héritage de rÎle existe.

Par exemple :

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

HasNamedGroupingPolicy()​

HasNamedGroupingPolicy détermine si une rÚgle d'héritage de rÎle nommée existe.

Par exemple :

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

AddGroupingPolicy()​

AddGroupingPolicy ajoute une rÚgle d'héritage de rÎle à la politique actuelle. Si la rÚgle existe déjà, la fonction renvoie faux et la rÚgle ne sera pas ajoutée. Sinon, la fonction renvoie vrai en ajoutant la nouvelle rÚgle.

Par exemple :

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

AddGroupingPolicies()​

AddGroupingPolicies ajoute des rÚgles d'héritage de rÎle à la politique actuelle. L'opération est de nature atomique. Par conséquent, si les rÚgles d'autorisation consistent en des rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie faux et aucune rÚgle de politique n'est ajoutée à la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie vrai et chaque rÚgle de politique est ajoutée à la politique actuelle.

Par exemple :

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

areRulesAdded := e.AddGroupingPolicies(rules)

AddGroupingPoliciesEx()​

AddGroupingPoliciesEx ajoute des rÚgles d'héritage de rÎle à la politique actuelle. Si la rÚgle existe déjà, la rÚgle ne sera pas ajoutée. Mais contrairement à AddGroupingPolicies, d'autres rÚgles non existantes sont ajoutées au lieu de renvoyer directement faux

Par exemple:

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

AddNamedGroupingPolicy()​

AddNamedGroupingPolicy ajoute une rÚgle d'héritage de rÎle nommée à la politique actuelle. Si la rÚgle existe déjà, la fonction renvoie false et la rÚgle ne sera pas ajoutée. Sinon, la fonction renvoie true en ajoutant la nouvelle rÚgle.

Par exemple:

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

AddNamedGroupingPolicies()​

AddNamedGroupingPolicies ajoute des rÚgles d'héritage de rÎle nommées à la politique actuelle. L'opération est de nature atomique. Par conséquent, si les rÚgles d'autorisation se composent de rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune rÚgle de politique n'est ajoutée à la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie true et chaque rÚgle de politique est ajoutée à la politique actuelle.

Par exemple:

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

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

AddNamedGroupingPoliciesEx()​

AddNamedGroupingPoliciesEx ajoute des rÚgles d'héritage de rÎle nommées à la politique actuelle. Si la rÚgle existe déjà, la rÚgle ne sera pas ajoutée. Mais contrairement à AddNamedGroupingPolicies, d'autres rÚgles non existantes sont ajoutées au lieu de renvoyer false directement

Par exemple:

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

RemoveGroupingPolicy()​

RemoveGroupingPolicy supprime une rÚgle d'héritage de rÎle de la politique actuelle.

Par exemple:

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

RemoveGroupingPolicies()​

RemoveGroupingPolicies supprime des rÚgles d'héritage de rÎle de la politique actuelle. L'opération est de nature atomique. Par conséquent, si les rÚgles d'autorisation se composent de rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune rÚgle de politique n'est supprimée de la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie true et chaque rÚgle de politique est supprimée de la politique actuelle.

Par exemple:

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

areRulesRemoved := e.RemoveGroupingPolicies(rules)

RemoveFilteredGroupingPolicy()​

RemoveFilteredGroupingPolicy supprime une rĂšgle d'hĂ©ritage de rĂŽle de la politique actuelle, des filtres de champ peuvent ĂȘtre spĂ©cifiĂ©s.

Par exemple:

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

RemoveNamedGroupingPolicy()​

RemoveNamedGroupingPolicy supprime une rÚgle d'héritage de rÎle de la politique nommée actuelle.

Par exemple:

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

RemoveNamedGroupingPolicies()​

RemoveNamedGroupingPolicies supprime des rÚgles d'héritage de rÎle nommées de la politique actuelle. L'opération est de nature atomique. Par conséquent, si les rÚgles d'autorisation se composent de rÚgles qui ne sont pas cohérentes avec la politique actuelle, la fonction renvoie false et aucune rÚgle de politique n'est supprimée de la politique actuelle. Si toutes les rÚgles d'autorisation sont cohérentes avec les rÚgles de politique, la fonction renvoie true et chaque rÚgle de politique est supprimée de la politique actuelle.

Par exemple:

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

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

RemoveFilteredNamedGroupingPolicy()​

RemoveFilteredNamedGroupingPolicy supprime une rĂšgle d'hĂ©ritage de rĂŽle de la politique nommĂ©e actuelle, des filtres de champ peuvent ĂȘtre spĂ©cifiĂ©s.

Par exemple:

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

UpdatePolicy()​

UpdatePolicy met Ă  jour une ancienne politique en une nouvelle politique.

Par exemple:

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

UpdatePolicies()​

UpdatePolicies met Ă  jour toutes les anciennes politiques en nouvelles politiques.

Par exemple:

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

AddFunction()​

AddFunction ajoute une fonction personnalisée.

Par exemple:

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 charge des politiques filtrées à partir du fichier/de la base de données.

Par exemple:

err := e.LoadFilteredPolicy()

LoadIncrementalFilteredPolicy()​

LoadIncrementalFilteredPolicy ajoute une politique filtrée à partir du fichier/de la base de données.

Par exemple:

err := e.LoadIncrementalFilteredPolicy()

UpdateGroupingPolicy()​

UpdateGroupingPolicy met Ă  jour oldRule en newRulein dans la section g

Par exemple:

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

UpdateNamedGroupingPolicy()​

UpdateNamedGroupingPolicy met à jour oldRule nommé ptype en newRulein dans la section g

Par exemple:

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

SetFieldIndex()​

SetFieldIndex supporte la personnalisation du nom conventionnel et de la position de sub, obj, domain et priority.

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

Par exemple:

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