Struct RelayExclusion

pub struct RelayExclusion<'a> {
    exclude_ids: RelayIdSet,
    exclude_subnets: Vec<IpAddr>,
    exclude_relay_families: RelayList<'a>,
    subnet_config: SubnetConfig,
    family_rules: FamilyRules,
}

A set of relays that we must not use when picking a given relays.

Exclusions are generally used to make sure that we obey family-based path-selection rules, that we avoid putting the same relay into a set more than once, or similar purposes.

(This is a separate type from RelayRestriction so that we can enforce our rule that every RelaySelector must have a RelayExclusion.)

Fields

exclude_ids: RelayIdSet

A list of identities to exclude.

Any relay with any one of these identities is rejecteed.

exclude_subnets: Vec<IpAddr>

A list of subnets from which to exclude addresses.

The side of the subnet is determined by subnet_config.

exclude_relay_families: RelayList<'a>

A list of relays to exclude, along with their families.

subnet_config: SubnetConfig

The configuration to use when deciding whether two addresses are in the same subnet.

family_rules: FamilyRules

The rules to use when deciding whether two relays are in the same family.

Implementations

impl<'a> RelayExclusion<'a>

pub fn no_relays_excluded() -> Self

Exclude no relays at all.

This kind of restriction is useful when picking the first relay for something,

pub fn exclude_identities(ids: RelayIdSet) -> Self

Exclude every relay that has an identity in ids.

pub fn exclude_specific_relays(relays: &[Relay<'a>]) -> Self

Exclude every relay that appears in relays.

pub fn exclude_channel_target_family<CT: ChanTarget>( cfg: &RelaySelectionConfig<'_>, ct: &CT, netdir: &'a NetDir, ) -> Self

Try to exclude every relay in the same family as the ChanTarget ct.

Limitations

A ChanTarget does not have a listed family. Thus, if it does not correspond to a relay listed in netdir, we can only exclude relays that share the same identity, or relays that are in the same subnet.

Whenever possible, it’s better to use exclude_relays_in_same_family.

pub fn exclude_relays_in_same_family( cfg: &RelaySelectionConfig<'_>, relays: Vec<Relay<'a>>, family_rules: FamilyRules, ) -> Self

Exclude every relay that is in the same family as any member of relays.

(Remember that every relay is considered to be in the same family as itself, so you don’t typically need to use exclude_specific_relays along with this.)

Considers relays that are in the same subnets (according to cfg) to belong to the same family.

pub fn extend(&mut self, other: &RelayExclusion<'a>)

Modify this RelayExclusion by adding every exclusion from other.

(Any subnet configuration becomes the union of previous subnet configurations.)

pub(crate) fn rejection_description(&self) -> Option<&'static str>

Return a string describing why we rejected the relays that don’t match this exclusion.

Trait Implementations

impl<'a> Clone for RelayExclusion<'a>

fn clone(&self) -> RelayExclusion<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RelayExclusion<'a>

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

Formats the value using the given formatter.

impl<'a> From<RelayExclusion<'a>> for RelayRestriction<'a>

fn from(value: RelayExclusion<'a>) -> Self

Converts to this type from the input type.

impl<'a> LowLevelRelayPredicate for RelayExclusion<'a>

fn low_level_predicate_permits_relay(&self, relay: &Relay<'_>) -> bool

Return true if relay provides this predicate.