Enum Path 

pub enum Path {
    InProcess {
        slot: SlotId,
    },
    Mount {
        dir: PathBuf,
    },
    Direct {
        endpoint: Endpoint,
    },
    Relayed {
        session: SessionId,
    },
}

How two endpoints reach each other. Cheapest first.

Variants

InProcess

Nothing is transferred: both ends are this process, and the value is passed. The slice still runs where it was placed — this is the .at() that never actually left home and pays for a trip anyway.

Never inferred. Whoever registers a host says it is in-process; a broker that worked it out by comparing addresses would quietly undo the reason a worker is a separate process, which is the GIL.

Fields

slot: SlotId

Where the client finds it, in a registry only the client has.

Mount

Both ends see the same filesystem: a path is written and read. Free, and a cluster already has one.

Fields

dir: PathBuf

The directory both ends agree they can see. That they really do is what the probing establishes, and the probing is not written yet.

Direct

The two ends reach each other and speak directly, whether over a socket or over a child’s pipes. One crossing, lowest latency, broker gone.

Fields

endpoint: Endpoint

How to obtain the stream.

Relayed

Neither can reach the other, so the bytes stream through the broker. No disk, no durability, and never more than a window in flight.

Fields

session: SessionId

Which stream through the relay this pair was given.

Implementations

impl Path

pub fn shared(&self) -> bool

Whether two hosts given this same path are one place, and so share one wire and one catalog.

It matters more than it looks. A worker has one catalog, and half of one is a different catalog: provisioning the same process twice, once per host name, swaps what it had live and takes every activation over there with it. Getting this wrong is not an extra socket, it is a run that quietly loses its state.

An address is an identity: the same host and port is the same process. A command is not — it is a thing to run, and running it twice gives two of them.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Path

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Path

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Path

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

Named the way a reader would say it out loud, because these end up in the record and in error messages both.

impl Ord for Path

fn cmp(&self, other: &Path) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Path

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Path

fn partial_cmp(&self, other: &Path) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Path

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Path

impl StructuralPartialEq for Path