Priority Model
Casbin supporta il caricamento delle politiche con priorità.
Carica Politica con Priorità Implicita
È piuttosto semplice: l'ordine determina la priorità; le politiche che compaiono prima hanno una priorità più alta.
model.conf:
[policy_effect]
e = priority(p.eft) || deny
Carica Politica con Priorità Esplicita
Vedi anche: casbin#550
Un valore di priorità più piccolo indica una priorità più alta. Se c'è un carattere non numerico nella priorità, verrà posizionato per ultimo invece di generare un errore.
Il nome del token di priorità comunemente utilizzato nella definizione della politica è "priority". Per utilizzare un nome personalizzato, è necessario invocare e.SetFieldIndex() e ricaricare le politiche (vedi l'esempio completo su TestCustomizedFieldIndex).
model.conf:
[policy_definition]
p = customized_priority, sub, obj, act, eft
Esempio di codice Golang:
e, _ := NewEnforcer("./example/priority_model_explicit_customized.conf",
"./example/priority_policy_explicit_customized.csv")
// Due to the customized priority token, the enforcer fails to handle the priority.
ok, err := e.Enforce("bob", "data2", "read") // the result will be `true, nil`
// Set PriorityIndex and reload
e.SetFieldIndex("p", constant.PriorityIndex, 0)
err := e.LoadPolicy()
if err != nil {
log.Fatalf("LoadPolicy: %v", err)
}
ok, err := e.Enforce("bob", "data2", "read") // the result will be `false, nil`
Attualmente, la priorità esplicita supporta solo AddPolicy e AddPolicies. Se UpdatePolicy è stato chiamato, non dovresti cambiare l'attributo di priorità.
model.conf:
[request_definition]
r = sub, obj, act
[policy_definition]
p = priority, sub, obj, act, eft
[role_definition]
g = _, _
[policy_effect]
e = priority(p.eft) || deny
[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act
policy.csv
p, 10, data1_deny_group, data1, read, deny
p, 10, data1_deny_group, data1, write, deny
p, 10, data2_allow_group, data2, read, allow
p, 10, data2_allow_group, data2, write, allow
p, 1, alice, data1, write, allow
p, 1, alice, data1, read, allow
p, 1, bob, data2, read, deny
g, bob, data2_allow_group
g, alice, data1_deny_group
richiesta:
alice, data1, write --> true // because `p, 1, alice, data1, write, allow` has the highest priority
bob, data2, read --> false
bob, data2, write --> true // because bob has the role of `data2_allow_group` which has the right to write data2, and there's no deny policy with higher priority
Carica Politica con Priorità Basata su Ruolo e Gerarchia Utente
La struttura ereditata di ruoli e utenti può essere solo un insieme di alberi multipli, non grafi. Se un utente ha più ruoli, devi assicurarti che l'utente abbia lo stesso livello in diversi alberi. Se due ruoli hanno lo stesso livello, la politica (associata al ruolo) che appare prima ha una priorità maggiore. Per maggiori dettagli, consulta anche casbin#833 e casbin#831.
model.conf:
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act, eft
[role_definition]
g = _, _
[policy_effect]
e = subjectPriority(p.eft) || deny
[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act
policy.csv
p, root, data1, read, deny
p, admin, data1, read, deny
p, editor, data1, read, deny
p, subscriber, data1, read, deny
p, jane, data1, read, allow
p, alice, data1, read, allow
g, admin, root
g, editor, admin
g, subscriber, admin
g, jane, editor
g, alice, subscriber
Richiesta:
jane, data1, read --> true // because jane is at the bottom, her priority is higher than that of editor, admin, and root
alice, data1, read --> true
La gerarchia dei ruoli è simile a questa:
role: root
└─ role: admin
├─ role editor
│ └─ user: jane
│
└─ role: subscriber
└─ user: alice
La priorità si presenta automaticamente in questo modo:
role: root # auto priority: 30
└─ role: admin # auto priority: 20
├─ role: editor # auto priority: 10
└─ role: subscriber # auto priority: 10