Enum EventError 

pub enum EventError {
    Timeout(RequestId),
    InvalidSignal(String),
    InvalidRequest(String),
    PermissionDenied(String),
}

Event layer error.

All variants implement ErrorCode for standardized error handling across the ORCS system.

Variants

Variant	When	Recovery
Timeout	Request exceeded timeout	Retry may help
InvalidSignal	Malformed signal	Fix the caller
InvalidRequest	Malformed request	Fix the caller
PermissionDenied	Insufficient privilege	Elevate session

Example

use orcs_event::EventError;
use orcs_types::{ErrorCode, RequestId};

let err = EventError::Timeout(RequestId::new());
assert_eq!(err.code(), "EVENT_TIMEOUT");
assert!(err.is_recoverable());

Variants

Timeout(RequestId)

Request timed out waiting for response.

This is recoverable - retry may succeed if the target component becomes available or finishes current work.

Common Causes

• Target component is busy processing other requests
• Network latency (in distributed scenarios)
• Target component has crashed (requires restart)

Recovery

• Retry with exponential backoff
• Increase timeout for slow operations
• Check target component health

Example

use orcs_event::EventError;
use orcs_types::{ErrorCode, RequestId};

let req_id = RequestId::new();
let err = EventError::Timeout(req_id);

assert!(err.is_recoverable());
assert!(err.to_string().contains("timed out"));

InvalidSignal(String)

Invalid signal was received.

This is not recoverable - the signal format or content is invalid and won’t change on retry.

Common Causes

• Malformed signal payload
• Invalid scope specification
• Deserialization failure

Recovery

• Fix the signal construction in the caller
• Validate signal before sending

Example

use orcs_event::EventError;
use orcs_types::ErrorCode;

let err = EventError::InvalidSignal("missing scope".into());

assert!(!err.is_recoverable());
assert!(err.to_string().contains("invalid signal"));

InvalidRequest(String)

Invalid request was constructed.

This is not recoverable - the request format or content is invalid and won’t change on retry.

Common Causes

• Empty operation string
• Invalid payload format

Recovery

• Fix the request construction in the caller
• Validate parameters before constructing

Example

use orcs_event::EventError;
use orcs_types::ErrorCode;

let err = EventError::InvalidRequest("operation cannot be empty".into());

assert!(!err.is_recoverable());
assert!(err.to_string().contains("invalid request"));

PermissionDenied(String)

Permission denied for the requested operation.

This is not recoverable by retry - requires privilege elevation or different credentials.

Common Causes

• Attempting Global signal without elevated privilege
• Component trying to signal outside its scope
• Session has expired elevation

Recovery

• Elevate the session: session.elevate(duration)
• Use a more limited scope
• Request elevation from Human

Permission Model

| Scope           | Standard | Elevated |
|-----------------|----------|----------|
| Global          | Denied   | Allowed  |
| Channel (own)   | Allowed  | Allowed  |
| Channel (other) | Denied   | Allowed  |

Example

use orcs_event::EventError;
use orcs_types::ErrorCode;

let err = EventError::PermissionDenied(
    "Global scope requires elevated privilege".into()
);

assert!(!err.is_recoverable());
assert_eq!(err.code(), "EVENT_PERMISSION_DENIED");

Trait Implementations

impl Clone for EventError

fn clone(&self) -> EventError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventError

fn deserialize<__D>( __deserializer: __D, ) -> Result<EventError, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for EventError

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

Formats the value using the given formatter.

impl Error for EventError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl ErrorCode for EventError

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

Returns a machine-readable error code.

All event errors use the EVENT_ prefix.

Codes

• EVENT_TIMEOUT - Request timed out
• EVENT_INVALID_SIGNAL - Malformed signal
• EVENT_INVALID_REQUEST - Malformed request
• EVENT_PERMISSION_DENIED - Insufficient privilege

fn is_recoverable(&self) -> bool

Returns whether the error is recoverable.

Returns

• true: Retry may succeed (Timeout)
• false: Retry will not help, requires different action

impl Serialize for EventError

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

where __S: Serializer,

Serialize this value into the given Serde serializer.