Struct FetcherState 

pub struct FetcherState { /* private fields */ }

Logical state for Git fetches happening in the node.

A fetch can either be:

• ActiveFetch: meaning it is currently being fetched from another node on the network
• QueuedFetch: meaning it is expected to be fetched from a given node, but the repository is already being fetched, or the node is at capacity.

For any given repository, identified by its RepoId, there can only be one fetch occurring for it at a given time. This prevents any concurrent fetches from clobbering overlapping references.

If the repository is actively being fetched, then that fetch will be queued for a later attempt.

For any given node, there is a configurable capacity so that only N number of fetches can happen with it concurrently. This does not guarantee that the node will actually allow this node to fetch from it – since it will maintain its own capacity for connections and load.

Implementations

impl FetcherState

pub fn new(config: Config) -> Self

Initialize the FetcherState with the given Config.

impl FetcherState

pub fn handle(&mut self, command: Command) -> Event

Process the handling of a Command, delegating to its corresponding method, and returning the corresponding Event.

This method is useful if the FetcherState is used in batch processing and does need to be explicit about the underlying method.

pub fn fetch(&mut self, _: Fetch) -> Fetch

Process a Fetch command, which transitions the given fetch to active, if possible.

The fetch will only transition to being active if:

• A fetch is not already happening for that repository, in which case it gets queued.
• The node to be fetched from is not already at capacity, again it will be queued.

pub fn fetched(&mut self, _: Fetched) -> Fetched

Process a Fetched command, which removes the given fetch from the set of active fetches. Note that this is agnostic of whether the fetch succeeded or failed.

The caller will be notified if the completed fetch did not exist in the active set.

pub fn dequeue(&mut self, from: &NodeId) -> Option<QueuedFetch>

Attempt to dequeue a QueuedFetch for the given node.

This will only dequeue the fetch if it is not active, and the given node is not at capacity.

pub fn cancel(&mut self, _: Cancel) -> Cancel

Process a Cancel command, which cancels any active and/or queued fetches for that given node.

impl FetcherState

pub fn queued_fetches(&self) -> &BTreeMap<NodeId, Queue>

Get the set of queued fetches.

pub fn active_fetches(&self) -> &BTreeMap<RepoId, ActiveFetch>

Get the set of active fetches.

pub fn get_active_fetch(&self, rid: &RepoId) -> Option<&ActiveFetch>

Get the ActiveFetch for the provided RepoId, returning None if it does not exist.

Trait Implementations

impl Clone for FetcherState

fn clone(&self) -> FetcherState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FetcherState

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

Formats the value using the given formatter.

impl Default for FetcherState

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for FetcherState

fn eq(&self, other: &FetcherState) -> 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 Serialize for FetcherState

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 FetcherState

impl StructuralPartialEq for FetcherState