beamr 0.4.2

A Rust runtime with the BEAM's execution model, targeting Gleam
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//! Capability audit events and violation reporting hooks.
//!
//! Runtime native capability checks can publish audit events to an optional
//! sink. Denied checks can additionally notify a violation handler. Neither
//! facility persists events; embedders choose the in-memory collector or callback
//! behavior they need by wiring these traits into `NativeServices`.

use crate::atom::Atom;
use crate::native::{Capability, CapabilitySet};

/// Native operation whose capability was checked.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CapabilityOperation {
    /// Native module atom.
    pub module: Atom,
    /// Native function atom.
    pub function: Atom,
    /// Native arity.
    pub arity: u8,
}

/// Observable record for a runtime native capability check.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CapabilityAuditEvent {
    /// Calling process identifier.
    pub pid: u64,
    /// Required capability for the native operation.
    pub capability: Capability,
    /// Native operation being checked.
    pub operation: CapabilityOperation,
    /// Whether the process capability set granted the operation.
    pub granted: bool,
    /// Capabilities held by the process at check time.
    pub process_capabilities: CapabilitySet,
}

/// Sink for capability audit events.
pub trait CapabilityAuditSink: Send + Sync {
    /// Observe one capability check event.
    fn record(&self, event: CapabilityAuditEvent);
}

/// Callback invoked for denied capability checks.
pub trait ViolationHandler: Send + Sync {
    /// Handle one capability violation.
    fn on_violation(&self, event: CapabilityAuditEvent);
}

/// Violation handler that writes denied capability context to stderr.
#[derive(Debug, Default, Clone, Copy)]
pub struct StderrViolationHandler;

impl ViolationHandler for StderrViolationHandler {
    fn on_violation(&self, event: CapabilityAuditEvent) {
        eprintln!(
            "capability violation: pid={} operation={:?}:{:?}/{} required={:?} process_capabilities={:?}",
            event.pid,
            event.operation.module,
            event.operation.function,
            event.operation.arity,
            event.capability,
            event.process_capabilities,
        );
    }
}