Skip to main content

RaceHistory

Struct RaceHistory 

Source
struct RaceHistory {
    races: VecDeque<Race>,
    open: HashMap<HoprSurbId, Race>,
    open_legs: HashMap<HoprSurbId, ([Option<OffchainPublicKey>; 5], usize)>,
    memory: Duration,
    last_home: HashMap<Hop, Instant>,
}

Fields§

§races: VecDeque<Race>§open: HashMap<HoprSurbId, Race>

Races whose partner is home while this relayer’s reply is not, by the SURB still out. Each counts as lost by at least the time since the partner came home.

§open_legs: HashMap<HoprSurbId, ([Option<OffchainPublicKey>; 5], usize)>

The leg each of those replies is out on, and this relayer’s position on it. Beside open and not in it: a race is the same race over any leg, the leg only decides how long the reply is given and which reply answers it (see unanswered).

§memory: Duration

How far back its races count, set when it is judged; zero until then.

§last_home: HashMap<Hop, Instant>

When a reply last came home through this relayer over each of its two hops, whether or not it settled a race. Forgotten after PENDING_SURB_TTL, when no open race is old enough for it to matter.

Implementations§

Source§

impl RaceHistory

Source

fn forget_older_than(&mut self, memory: Duration)

Source

fn finished(&self) -> impl Iterator<Item = &Race>

The races that settled, as opposed to those that expired open and were booked as lost.

Source

fn bar(&self, fallback_usual: Option<f64>) -> Option<f64>

The bar this relayer’s replies are held to: how late one usually is (see usual_margin), or, while it has settled too few races for that, fallback_usual raised to whatever its own settled races measure. None while neither exists.

Source

fn usual_margin(&self) -> Option<f64>

How late a reply of this relayer usually is: the largest margin of its settled races, or None until it has settled MIN_RACES of them, too few for the figure to mean anything.

Source

fn unanswered( &self, last_reply: Option<Instant>, fallback_usual: Option<f64>, bars: &HashMap<OffchainPublicKey, f64>, ) -> Vec<(HoprSurbId, Instant)>

The replies through it that are out for longer than its bar, with nothing home through it, over the hop each of them is out on, since it fell due. At least MIN_RACES of them that nothing has come home after over either hop make it a black hole (see unanswered_at_all), and MIN_RACES_OVER_ONE_HOP over one hop while it delivers over the other make it one over that hop (see hop_at_fault). The bar is the largest margin of the races it finished, or, while it has finished too few, the borrowed one below.

A reply is overdue only if a reply came home, through any relayer, after its grace ran out (last_reply): the network was delivering while this relayer was not. Without that, nothing tells a dead relayer from a pause. The replier’s stream stops for a settle, a phase change or idle, nothing is home for anybody during it, and a few replies lost at random before it would pass for a verdict, each costing the session its whole stock. An outage of every return relayer is likewise no verdict on any one of them. When the stream resumes an alive relayer settles a race, which clears the condition below, while a dead one never does.

A relayer that has settled fewer than MIN_RACES races has no margin of its own to go by, and races settle only in the abnormal order, so a clean history is common. It borrows fallback_usual, the bar of the best-measured relayer, raised to whatever its own settled races measure (own.max(fallback)), and is not judged at all while no relayer has one. “Home through it” is any reply over a leg it is on that reached it over the same hop as the overdue one would (see Hop): from the replier when it is first on both legs, from another relayer when it is not. The same hop, because that is what the overdue reply says something about. A relayer cut off from the replier goes on delivering behind other relayers, and counting those replies kept it from ever being a suspect: measured with that link cut, the relayer behind it on those legs was judged in its place and stayed out for 90 s, or nobody was and the replier spent a quarter of its replies into the cut for as long as its stock lasted. The relayer’s own races that expired open and were booked as lost are not replies that came home, and must not reset the clock.

A reply is held to the bar of the slowest relayer on its leg, bars having every relayer’s: it can be no earlier than that relayer lets it be, whichever of them is asked. Held to its own bar, a relayer behind a slower one had replies overdue that the slower one did not, and was the only suspect. Measured on a cluster behind a relayer stalling for seconds: three such replies, the relayer judged in the stalling one’s place and out for 80 s, the stock wiped twice.

Each overdue race is judged on its own: one that a reply through the relayer came home after is answered, the relayer was delivering after the reply it lost, which was then lost at random. Comparing the latest reply with the oldest overdue race instead lets one stale race, or the replies already past the relayer when it died, hold a verdict back until that race expires, up to a minute.

Returns those replies, by SURB and with when each fell due, empty while the relayer cannot be judged at all; whether they make it a black hole is up to explain_away, which sets aside the ones a relayer already judged dead explains.

Source

fn unanswered_at_all( &self, unanswered: &[(HoprSurbId, Instant)], ) -> Vec<HoprSurbId> ⓘ

Of the replies unanswered over the hop they are out on, those that nothing has come home after through this relayer over either hop: what it is judged on as a whole.

Any reply through it answers them, as before its hops were told apart, and not only one over the same hop. Counting what is unanswered over each hop and adding the two up judged a relayer for a reply lost here and two lost there while it delivered over both: simulated as for Hop, 13 wipes with the two added up against 4 this way, and 2 with the hops not told apart at all.

Source

fn hop_at_fault(&self, unanswered: &[(HoprSurbId, Instant)]) -> Option<Hop>

The hop the replies unanswered are out on, if they are all out on the same one and the relayer has delivered over the other since the oldest of them opened. Its verdict is then about that hop and not about the relayer as a whole: the replier can no longer reach it, say, while other relayers still can.

Source

fn home_over_the_hop_of(&self, surb: &HoprSurbId) -> Option<Instant>

When a reply last came home through this relayer over the hop the open race of surb waits on.

Any reply over that hop counts, in the normal order too: it settles no race, but it is the relayer delivering all the same.

Source

fn hop_of(&self, surb: &HoprSurbId) -> Option<Hop>

The hop the open race of surb waits on.

Trait Implementations§

Source§

impl Debug for RaceHistory

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for RaceHistory

Source§

fn default() -> RaceHistory

Returns the “default value” for a type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more