Struct ExecutionId 

pub struct ExecutionId(/* private fields */);

Identifier of a single durable execution.

Runtime-minted as a UUIDv7 (time-ordered) at execution start. It is never consumer-supplied for a fresh execution — a resumed execution reuses the persisted value, but a new one always calls ExecutionId::new.

Examples

use zeph_durable::ExecutionId;

let a = ExecutionId::new();
let b = ExecutionId::new();
assert_ne!(a, b, "each execution gets a distinct identity");

Implementations

impl ExecutionId

pub fn new() -> Self

Mint a fresh, time-ordered execution identity.

pub fn as_uuid(self) -> Uuid

Return the underlying UUID.

pub fn as_bytes(&self) -> &[u8; 16]

Return the 16 raw bytes of the underlying UUID.

pub fn parse_str(s: &str) -> Result<Self, Error>

Parse a canonical UUID string into an execution identity.

Used by operability surfaces (the zeph durable CLI, the TUI) that accept a user-supplied execution id. A fresh execution always uses ExecutionId::new; this is for addressing an existing one.

Errors

Returns the underlying uuid::Error when s is not a valid UUID.

Examples

use zeph_durable::ExecutionId;

let id = ExecutionId::new();
let parsed = ExecutionId::parse_str(&id.as_uuid().to_string()).unwrap();
assert_eq!(parsed, id);
assert!(ExecutionId::parse_str("not-a-uuid").is_err());

pub fn derive(domain: &[u8], payload: &[u8]) -> Self

Derive a deterministic execution identity from a domain tag and opaque payload bytes.

Produces a stable ExecutionId for a (domain, payload) pair using BLAKE3 in derive_key mode. Two calls with identical inputs produce the same id; differing inputs produce cryptographically distinct ids. Use this for exactly-once adapters that need to reattach to an existing journal execution on restart (e.g. the scheduler fire adapter, which derives the id from (job_name, slot_ms) so a crashed and restarted scheduler finds the same row).

The domain string separates id spaces — choose a stable, globally-unique literal per adapter (e.g. "zeph.scheduler.fire.v1"). The payload carries the distinguishing bytes (e.g. little-endian slot timestamp).

Examples

use zeph_durable::ExecutionId;

let a = ExecutionId::derive(b"zeph.test.v1", b"job_name\x00\x01\x00\x00\x00\x00\x00\x00\x00");
let b = ExecutionId::derive(b"zeph.test.v1", b"job_name\x00\x01\x00\x00\x00\x00\x00\x00\x00");
let c = ExecutionId::derive(b"zeph.test.v1", b"other_job\x00\x02\x00\x00\x00\x00\x00\x00\x00");
assert_eq!(a, b, "same domain+payload derives the same id");
assert_ne!(a, c, "different payload derives a different id");

Trait Implementations

impl Clone for ExecutionId

fn clone(&self) -> ExecutionId

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ExecutionId

impl Debug for ExecutionId

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

Formats the value using the given formatter.

impl Default for ExecutionId

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExecutionId

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExecutionId

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

Formats the value using the given formatter.

impl Eq for ExecutionId

impl Hash for ExecutionId

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ExecutionId

fn eq(&self, other: &ExecutionId) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for ExecutionId

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExecutionId