Enum LogStatement

pub enum LogStatement<'a> {
    ExecuteTask {
        reference: Cow<'a, str>,
        auth: Cow<'a, AuthContext>,
        policy: i64,
        state: Cow<'a, State>,
        workflow: Cow<'a, Workflow>,
        task: Cow<'a, str>,
    },
    AssetAccess {
        reference: Cow<'a, str>,
        auth: Cow<'a, AuthContext>,
        policy: i64,
        state: Cow<'a, State>,
        workflow: Cow<'a, Workflow>,
        data: Cow<'a, str>,
        task: Option<Cow<'a, str>>,
    },
    WorkflowValidate {
        reference: Cow<'a, str>,
        auth: Cow<'a, AuthContext>,
        policy: i64,
        state: Cow<'a, State>,
        workflow: Cow<'a, Workflow>,
    },
    ReasonerResponse {
        reference: Cow<'a, str>,
        response: Cow<'a, str>,
    },
    ReasonerVerdict {
        reference: Cow<'a, str>,
        verdict: Cow<'a, Verdict>,
    },
    ReasonerContext {
        connector_context: Value,
        connector_context_hash: String,
    },
    PolicyAdd {
        auth: Cow<'a, AuthContext>,
        connector_context_hash: String,
        policy: Cow<'a, Policy>,
    },
    PolicyActivate {
        auth: Cow<'a, AuthContext>,
        policy: Cow<'a, Policy>,
    },
    PolicyDeactivate {
        auth: Cow<'a, AuthContext>,
    },
}

Collects everything we might want to log in an AuditLogger.

TODO: Nicer to move this to the toplevel crate, logger.rs.

Variants

ExecuteTask

A request that asks if a task may be executed has been received.

Fields

reference: Cow<'a, str>

auth: Cow<'a, AuthContext>

policy: i64

state: Cow<'a, State>

workflow: Cow<'a, Workflow>

task: Cow<'a, str>

AssetAccess

A request that asks if an asset may be accessed has been received.

Fields

reference: Cow<'a, str>

auth: Cow<'a, AuthContext>

policy: i64

state: Cow<'a, State>

workflow: Cow<'a, Workflow>

data: Cow<'a, str>

task: Option<Cow<'a, str>>

WorkflowValidate

A request that asks if a workflow is permitted has been received.

Fields

reference: Cow<'a, str>

auth: Cow<'a, AuthContext>

policy: i64

state: Cow<'a, State>

workflow: Cow<'a, Workflow>

ReasonerResponse

Logs the raw response of a reasoner.

Fields

reference: Cow<'a, str>

response: Cow<'a, str>

ReasonerVerdict

Logs the official response of a reasoner.

Fields

reference: Cow<'a, str>

verdict: Cow<'a, Verdict>

ReasonerContext

Logs the reasoner backend for during startup.

Fields

connector_context: Value

connector_context_hash: String

PolicyAdd

Logs the arrival of a new policy.

Fields

auth: Cow<'a, AuthContext>

connector_context_hash: String

policy: Cow<'a, Policy>

PolicyActivate

Logs the activation of an existing policy.

Fields

auth: Cow<'a, AuthContext>

policy: Cow<'a, Policy>

PolicyDeactivate

Logs the deactivation of the current active policy.

Fields

auth: Cow<'a, AuthContext>

Implementations

impl<'a> LogStatement<'a>

pub fn execute_task( reference: &'a str, auth: &'a AuthContext, policy: i64, state: &'a State, workflow: &'a Workflow, task: &'a str, ) -> Self

Constructor for a LogStatement::ExecuteTask that makes it a bit more convenient to initialize.

Arguments

• reference: The reference ID for this request.
• auth: The AuthContext that explains who performed the request.
• policy: The Policy used to evaluate the request.
• state: The State given to the policy for evaluation.
• workflow: The Workflow that is being evaluated.
• task: Which task in the workflow we’re specifically considering.

Returns

A new LogStatement::ExecuteTask that is initialized with the given properties.

pub fn asset_access( reference: &'a str, auth: &'a AuthContext, policy: i64, state: &'a State, workflow: &'a Workflow, data: &'a str, task: &'a Option<String>, ) -> Self

Constructor for a LogStatement::AssetAccess that makes it a bit more convenient to initialize.

Arguments

• reference: The reference ID for this request.
• auth: The AuthContext that explains who performed the request.
• policy: The Policy used to evaluate the request.
• state: The State given to the policy for evaluation.
• workflow: The Workflow that is being evaluated.
• task: Which task in the workflow we’re specifically considering.

Returns

A new LogStatement::AssetAccess that is initialized with the given properties.

pub fn workflow_validate( reference: &'a str, auth: &'a AuthContext, policy: i64, state: &'a State, workflow: &'a Workflow, ) -> Self

Constructor for a LogStatement::WorkflowValidate that makes it a bit more convenient to initialize.

Arguments

• reference: The reference ID for this request.
• auth: The AuthContext that explains who performed the request.
• policy: The Policy used to evaluate the request.
• state: The State given to the policy for evaluation.
• workflow: The Workflow that is being evaluated.
• task: Which task in the workflow we’re specifically considering.

Returns

A new LogStatement::WorkflowValidate that is initialized with the given properties.

pub fn reasoner_response(reference: &'a str, response: &'a str) -> Self

Constructor for a LogStatement::ReasonerResponse that makes it a bit more convenient to initialize.

Arguments

• reference: The reference ID for this request.
• response: The raw response as returned by the reasoner.

Returns

A new LogStatement::ReasonerResponse that is initialized with the given properties.

pub fn reasoner_verdict(reference: &'a str, verdict: &'a Verdict) -> Self

Constructor for a LogStatement::ReasonerVerdict that makes it a bit more convenient to initialize.

Arguments

• reference: The reference ID for this request.
• verdict: The verdict given by the reasoner.

Returns

A new LogStatement::ReasonerVerdict that is initialized with the given properties.

pub fn reasoner_context<C: ConnectorWithContext>() -> Self

Constructor for a LogStatement::ReasonerContext that makes it a bit more convenient to initialize.

Arguments

• context: The context that is used to give answers with this reasoner.

Returns

A new LogStatement::ReasonerContext that is initialized with the given properties.

pub fn policy_add<C: ConnectorWithContext>( auth: &'a AuthContext, policy: &'a Policy, ) -> Self

Constructor for a LogStatement::PolicyAdd that makes it a bit more convenient to initialize.

Arguments

• auth: The AuthContext that explains who performed the request.
• context: The context that is used to give answers with this reasoner.
• policy: The Policy added to the checker in this request.

Returns

A new LogStatement::ReasonerContext that is initialized with the given properties.

pub fn policy_activate(auth: &'a AuthContext, policy: &'a Policy) -> Self

Constructor for a LogStatement::PolicyActivate that makes it a bit more convenient to initialize.

Arguments

• auth: The AuthContext that explains who performed the request.
• policy: The Policy that got activated in this request.

Returns

A new LogStatement::PolicyActivate that is initialized with the given properties.

pub fn policy_deactivate(auth: &'a AuthContext) -> Self

Constructor for a LogStatement::PolicyDeactivate that makes it a bit more convenient to initialize.

Arguments

• auth: The AuthContext that explains who performed the request.

Returns

A new LogStatement::PolicyDeactivate that is initialized with the given properties.

Trait Implementations

impl<'a> Clone for LogStatement<'a>

fn clone(&self) -> LogStatement<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LogStatement<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for LogStatement<'a>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> EnumDebug for LogStatement<'a>

fn type_name() -> &'static str

Returns the static name of the type used for EnumDebug-printing.

fn variant_names() -> &'static [&'static str]

Returns all variants in the trait as a list of names.

fn variant_name(&self) -> &'static str

Returns the static name of the variant.

fn variant(&self) -> EnumDebugFormatter<'_, Self>

Returns a formatter for this enum that writes its variant name.

fn variants() -> Copied<Iter<'static, &'static str>>

Returns an iterator over all variants in this enum.

impl<'a> Serialize for LogStatement<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.