Struct AuthzCasdoorPlugin 

pub struct AuthzCasdoorPlugin {

    endpoint_addr: String,
    client_id: String,
    client_secret: String,
    basic_auth: String,
    ssl_verify: bool,
    timeout: Duration,
    sealer: Option<CookieSealer>,
    callback_url: Option<String>,
    callback_path: Option<String>,
    scope: String,
    cookie_name: String,
    flow_cookie_name: String,
    cookie_path: String,
    cookie_lifetime: u64,
    logout_path: Option<String>,
    backend: SessionBackend,
    rng: SystemRandom,
    outbound: Arc<OutboundClient>,
}

Validates a Casdoor access token, and in interactive mode runs the SSO flow.

Fields

endpoint_addr: String

Casdoor server base URL, without a trailing slash.

client_id: String

Casdoor application client id.

client_secret: String

Casdoor application client secret.

basic_auth: String

Authorization: Basic ... header value built from the client credentials.

ssl_verify: bool

TLS certificate verification for the callout.

timeout: Duration

Whole-call timeout for the callout.

sealer: Option<CookieSealer>

When set, interactive SSO login is enabled and this seals/opens cookies.

callback_url: Option<String>

Full callback URL registered with Casdoor (the OAuth redirect_uri).

callback_path: Option<String>

Path component of callback_url, matched against the request path.

scope: String

OAuth scope requested at the authorize step (default read).

cookie_name: String

Session cookie name (interactive mode).

flow_cookie_name: String

Transient login-flow cookie name (interactive mode).

cookie_path: String

Path attribute of the session and flow cookies (interactive mode). Scope to a subpath (e.g. /app_a) for independent per-app sessions; must cover callback_path. Defaults to /.

cookie_lifetime: u64

Session cookie lifetime in seconds (interactive mode).

logout_path: Option<String>

Optional logout path; a request to it clears the session cookie.

backend: SessionBackend

Where the session payload lives: sealed in the cookie itself, or a server-side store keyed by a bare id in the cookie. See session.storage / session.store in AuthzCasdoorPlugin::from_config.

rng: SystemRandom

Randomness source for the anti-CSRF state.

outbound: Arc<OutboundClient>

Shared pooled outbound HTTP client.

Implementations

impl AuthzCasdoorPlugin

pub fn from_config( config: &HashMap<String, Value>, resources: &Arc<PluginResources>, ) -> Result<Self, String>

Builds the plugin from node config.

Accepted keys:

• endpoint_addr (string, required): Casdoor base URL (a trailing / is trimmed).
• client_id (string, required): Casdoor application client id.
• client_secret (string, required): Casdoor application client secret. Used for HTTP Basic auth on the introspection call (stateless) and the code-exchange call (interactive).
• callback_url (string): OAuth redirect_uri. Required in interactive mode; accepted-but-unused in stateless mode.
• ssl_verify (bool, default true): verify the endpoint’s TLS certificate.
• timeout (integer ms, default 3000): callout timeout.

Interactive-mode keys (a session secret ⇒ interactive login is enabled):

• session_secret (string) or session.secret (string): signing/encryption secret for the session and flow cookies. Setting it turns on the SSO flow.
• session.cookie.name (string, default "casdoor_session"): session cookie name.
• session.cookie.path (string, default "/"): session/flow cookie Path; scope to a subpath (e.g. /app_a) for independent per-app sessions. Must cover the callback_url path (rejected at load otherwise).
• session.cookie.lifetime (u64 seconds, default 3600): cookie lifetime.
• scope (string, default "read"): OAuth scope requested at authorize.
• logout_path (string, optional): request path that clears the session cookie and redirects to /.

- id: authz
  type: authz-casdoor
  config:
    endpoint_addr: https://casdoor.example.com
    client_id: ${CASDOOR_CLIENT_ID}
    client_secret: ${CASDOOR_CLIENT_SECRET}
    callback_url: https://app.example.com/casdoor/callback
    session_secret: ${CASDOOR_SESSION_SECRET}
    scope: read

fn deny( ctx: Context, message: impl Into<String>, ) -> Result<PluginOutput, PluginExecutionError>

Builds the 403 denial and exits on the denied port. Reserved for deliberate denials — a missing/invalid token, OAuth state mismatch, or Casdoor actively refusing the decision.

fn redirect( ctx: Context, location: String, set_cookies: Vec<String>, ) -> Result<PluginOutput, PluginExecutionError>

Builds a 302 early-exit and exits on the redirect port. Wire the node’s redirect edge to client.in so this reaches the browser.

fn callout_error( ctx: Context, message: String, ) -> Result<PluginOutput, PluginExecutionError>

Builds a genuine infrastructure-failure Err (a Casdoor token-exchange or introspection callout that transport-failed, timed out, or returned an unparseable response) — exits through the error port because the node could not do its job, unlike deny/redirect which are deliberate, client-facing outcomes. The prepared response is the shared 502 provider_error shape, not a 403 access_denied.

fn store_error(ctx: Context, e: StoreError) -> PluginExecutionError

Session-store outage: 503 through the error port. Deliberately NOT 401 — a store outage is not “unauthenticated”.

fn cookie_attrs(&self, ctx: &Context, max_age: u64) -> CookieAttrs<'_>

Cookie attributes: HttpOnly, SameSite=Lax, Secure only over HTTPS.

async fn read_session( &self, ctx: &Context, ) -> Result<Option<CasdoorSession>, StoreError>

Reads the session cookie via the configured backend, returning the sealed session. Ok(None) = unauthenticated (no cookie/sealer, or an unopenable/unparseable payload); Err = store outage (503 via AuthzCasdoorPlugin::store_error), never a silent re-login.

fn read_flow(&self, ctx: &Context) -> Option<CasdoorFlow>

Reads and opens the transient login-flow cookie.

fn attach_session(&self, ctx: &mut Context, session: &CasdoorSession)

Attaches the authenticated identity from a session to the request.

async fn fetch_access_token(&self, code: &str) -> Result<String, String>

Exchanges an authorization code for a Casdoor access token.

async fn execute_interactive( &self, ctx: Context, ) -> Result<PluginOutput, PluginExecutionError>

Interactive SSO flow: callback → valid session → begin login.

fn is_callback(&self, ctx: &Context) -> bool

True when the request is the OAuth callback (path + code + state).

async fn handle_callback( &self, ctx: Context, sealer: &CookieSealer, ) -> Result<PluginOutput, PluginExecutionError>

Handles the OAuth callback: verify state, exchange code, seal a session, and redirect to the original URI.

fn begin_login( &self, ctx: Context, sealer: &CookieSealer, ) -> Result<PluginOutput, PluginExecutionError>

Begins interactive login: mint a state, stash it plus the original URI in a short-lived flow cookie, and redirect to Casdoor’s authorize URL.

async fn execute_stateless( &self, ctx: Context, ) -> Result<PluginOutput, PluginExecutionError>

Stateless bearer-token validation via introspection (default behavior).

Trait Implementations

impl Plugin for AuthzCasdoorPlugin

fn plugin_type(&self) -> &str

Unique identifier for the plugin type (e.g., “proxy-rewrite”, “upstream”). This is also the key its PortSpec is registered under in port_spec.

fn execute<'life0, 'async_trait>( &'life0 self, ctx: Context, ) -> Pin<Box<dyn Future<Output = Result<PluginOutput, PluginExecutionError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Executes the plugin logic against the request/response context.

fn reads_response_body(&self) -> bool

Whether this configured instance reads context.response.body.

fn cache_target(&self) -> Option<CacheTarget>

The cache backend this node writes to, if it is a proxy-cache half.