Struct SqlxWatcher 

pub struct SqlxWatcher { /* private fields */ }

A sqlx based Watcher for casbin policy changes.

The watcher is responsible for both notifying and listening to casbin policy changes. By default load_policy is called when any changes are received. The user can alter this behaviour via set_update_callback.

Since the Watcher trait doesn’t supply the payload to the callback, you can access that via the last_message field.

Example:

use casbin::Watcher;
use casbin_sqlx_watcher::SqlxWatcher;
use sqlx::PgPool;

#[tokio::main]
async fn main() {
   use std::sync::Arc;
   use casbin::{CoreApi, Enforcer};
   use tokio::sync::RwLock;
   let db = PgPool::connect(std::env::var("DATABASE_URL").unwrap_or_default().as_str()).await.unwrap();
   let mut watcher = SqlxWatcher::new(db.clone());
   let mut watcher_clone = watcher.clone();

   let policy = sqlx_adapter::SqlxAdapter::new_with_pool(db.clone()).await.unwrap();
   let model = casbin::DefaultModel::from_str(include_str!("./resources/rbac_model.conf")).await.unwrap();

   let enforcer = Arc::new(RwLock::new(Enforcer::new(model, policy).await.unwrap()));

   tokio::task::spawn(async move {
      if let Err(err) = watcher_clone.listen(enforcer).await {
         eprintln!("casbin watcher failed: {}", err);
     }
   });


   watcher.set_update_callback(Box::new(|| {
      println!("casbin policy changed");
   }));

   // This is not the recommended way to trigger changes, casbin will do that automatically.
   // But for illustration purposes, we can manually trigger a change.
   sqlx::query("NOTIFY casbin_policy_change").execute(&db).await.unwrap();

   tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
   // output: casbin policy changed
}

Implementations

impl SqlxWatcher

pub fn new(db: PgPool) -> Self

pub fn set_channel(&mut self, channel: &str)

Set the channel to listen and notify on. By default, the value of DEFAULT_NOTIFY_CHANNEL is used, which is “casbin_policy_change”.

pub fn channel(&self) -> String

Get the channel that is listened to and notified on.

pub async fn listen(&mut self, enforcer: Arc<RwLock<Enforcer>>) -> Result<()>

The main listen loop

This listens to the postgres notification channel for casbin policy changes. It also listens for updates to the callback function.

Trait Implementations

impl Clone for SqlxWatcher

fn clone(&self) -> SqlxWatcher

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Watcher for SqlxWatcher

fn set_update_callback(&mut self, cb: Box<dyn FnMut() + Send + Sync>)

fn update(&mut self, d: EventData)