Struct casbin::Enforcer

pub struct Enforcer { /* fields omitted */ }

Enforcer is the main interface for authorization enforcement and policy management.

Methods

impl Enforcer

pub fn new(m: Model, a: Box<dyn Adapter>) -> Result<Self>

Enforcer::new creates an enforcer via file or DB.

pub fn add_function(&mut self, fname: &str, f: fn(_: String, _: String) -> bool)

pub fn get_model(&self) -> &Model

pub fn get_mut_model(&mut self) -> &mut Model

pub fn set_watcher(&mut self, w: Box<dyn Watcher>)

pub fn enforce(&self, rvals: Vec<&str>) -> Result<bool>

Enforce decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).

Examples

use casbin::{Enforcer, Model, FileAdapter};

let m = Model::from_file("examples/basic_model.conf").unwrap();
let adapter = FileAdapter::new("examples/basic_policy.csv");
let e = Enforcer::new(m, Box::new( adapter)).unwrap();
assert_eq!(true, e.enforce(vec!["alice", "data1", "read"]).unwrap());

pub fn build_role_links(&mut self) -> Result<()>

pub fn load_policy(&mut self) -> Result<()>

pub fn clear_policy(&mut self)

pub fn enable_auto_save(&mut self, auto_save: bool)

pub fn enable_auto_build_role_links(&mut self, auto_build_role_links: bool)

Trait Implementations

impl InternalApi for Enforcer

fn add_policy_internal(
    &mut self,
    sec: &str,
    ptype: &str,
    rule: Vec<&str>
) -> Result<bool>

fn remove_policy_internal(
    &mut self,
    sec: &str,
    ptype: &str,
    rule: Vec<&str>
) -> Result<bool>

fn remove_filtered_policy_internal(
    &mut self,
    sec: &str,
    ptype: &str,
    field_index: usize,
    field_values: Vec<&str>
) -> Result<bool>

impl MgmtApi for Enforcer

fn add_policy(&mut self, params: Vec<&str>) -> Result<bool>

fn remove_policy(&mut self, params: Vec<&str>) -> Result<bool>

fn add_named_policy(&mut self, ptype: &str, params: Vec<&str>) -> Result<bool>

fn remove_named_policy(
    &mut self,
    ptype: &str,
    params: Vec<&str>
) -> Result<bool>

fn add_grouping_policy(&mut self, params: Vec<&str>) -> Result<bool>

fn add_named_grouping_policy(
    &mut self,
    ptype: &str,
    params: Vec<&str>
) -> Result<bool>

fn remove_grouping_policy(&mut self, params: Vec<&str>) -> Result<bool>

fn remove_named_grouping_policy(
    &mut self,
    ptype: &str,
    params: Vec<&str>
) -> Result<bool>

fn remove_filtered_grouping_policy(
    &mut self,
    field_index: usize,
    field_values: Vec<&str>
) -> Result<bool>

fn remove_filtered_named_grouping_policy(
    &mut self,
    ptype: &str,
    field_index: usize,
    field_values: Vec<&str>
) -> Result<bool>

fn remove_filtered_policy(
    &mut self,
    field_index: usize,
    field_values: Vec<&str>
) -> Result<bool>

fn remove_filtered_named_policy(
    &mut self,
    ptype: &str,
    field_index: usize,
    field_values: Vec<&str>
) -> Result<bool>

fn get_policy(&self) -> Vec<Vec<String>>

fn get_named_policy(&self, ptype: &str) -> Vec<Vec<String>>

fn get_filtered_policy(
    &self,
    field_index: usize,
    field_values: Vec<&str>
) -> Vec<Vec<String>>

fn get_filtered_named_policy(
    &self,
    ptype: &str,
    field_index: usize,
    field_values: Vec<&str>
) -> Vec<Vec<String>>

fn has_policy(&self, params: Vec<&str>) -> bool

fn has_named_policy(&self, ptype: &str, params: Vec<&str>) -> bool

fn get_grouping_policy(&self) -> Vec<Vec<String>>

fn get_named_grouping_policy(&self, ptype: &str) -> Vec<Vec<String>>

fn get_filtered_grouping_policy(
    &self,
    field_index: usize,
    field_values: Vec<&str>
) -> Vec<Vec<String>>

fn get_filtered_named_grouping_policy(
    &self,
    ptype: &str,
    field_index: usize,
    field_values: Vec<&str>
) -> Vec<Vec<String>>

fn has_grouping_policy(&self, params: Vec<&str>) -> bool

fn has_grouping_named_policy(&self, ptype: &str, params: Vec<&str>) -> bool

fn get_all_subjects(&self) -> Vec<String>

fn get_all_named_subjects(&self, ptype: &str) -> Vec<String>

fn get_all_objects(&self) -> Vec<String>

fn get_all_named_objects(&self, ptype: &str) -> Vec<String>

fn get_all_actions(&self) -> Vec<String>

fn get_all_named_actions(&self, ptype: &str) -> Vec<String>

fn get_all_roles(&self) -> Vec<String>

fn get_all_named_roles(&self, ptype: &str) -> Vec<String>

impl RbacApi for Enforcer

fn add_permission_for_user(
    &mut self,
    user: &str,
    permission: Vec<&str>
) -> Result<bool>

fn add_role_for_user(
    &mut self,
    user: &str,
    role: &str,
    domain: Option<&str>
) -> Result<bool>

fn delete_role_for_user(
    &mut self,
    user: &str,
    role: &str,
    domain: Option<&str>
) -> Result<bool>

fn delete_roles_for_user(
    &mut self,
    user: &str,
    domain: Option<&str>
) -> Result<bool>

fn get_roles_for_user(
    &mut self,
    name: &str,
    domain: Option<&str>
) -> Vec<String>

fn get_users_for_role(&self, name: &str, domain: Option<&str>) -> Vec<String>

fn has_role_for_user(
    &mut self,
    name: &str,
    role: &str,
    domain: Option<&str>
) -> bool

fn delete_user(&mut self, name: &str) -> Result<bool>

fn delete_role(&mut self, name: &str) -> Result<bool>

fn delete_permission(&mut self, permission: Vec<&str>) -> Result<bool>

fn delete_permission_for_user(
    &mut self,
    user: &str,
    permission: Vec<&str>
) -> Result<bool>

fn delete_permissions_for_user(&mut self, user: &str) -> Result<bool>

fn get_permissions_for_user(
    &self,
    user: &str,
    domain: Option<&str>
) -> Vec<Vec<String>>

fn has_permission_for_user(&self, user: &str, permission: Vec<&str>) -> bool

fn get_implicit_roles_for_user(
    &mut self,
    name: &str,
    domain: Option<&str>
) -> Vec<String>

fn get_implicit_permissions_for_user(
    &mut self,
    user: &str,
    domain: Option<&str>
) -> Vec<Vec<String>>

fn get_implicit_users_for_permission(
    &self,
    permission: Vec<&str>
) -> Vec<String>