mooncakes.io

README
U
AppendEntriesArgs
U
AppendEntriesReply
U
Changer
U
ChangerConfig
U
Cluster
U
ConfChange
U
ConfChangeTransition
U
ConfChangeType
U
ConfChangeV2
U
ConfDriver
U
ConfState
U
Config
U
ConfigError
U
DemoReport
U
Entry
U
EntryId
U
EntryType
U
FullStatus
U
HardState
U
HeartbeatArgs
U
HeartbeatReply
U
Inflight
U
Inflights
U
InstallSnapshotArgs
U
InstallSnapshotReply
U
LogCompacted
U
LogLevel
U
LogSlice
U
LogStore
U
Logger
U
Membership
U
MemoryStorage
U
Message
U
Node
U
NopLogger
U
NopTracer
U
Payload
U
Persisted
U
Progress
U
ProgressState
U
ProgressStatus
U
RaftLog
U
RaftNode
U
RaftStatus
U
RaftStorage
U
RawNode
U
ReadIndexResp
U
ReadOnlyOption
U
ReadState
U
Ready
U
RequestVoteArgs
U
RequestVoteReply
U
Role
U
Snapshot
U
SoftState
U
StateMachine
U
StorageAppend
U
StorageAppendResp
U
StorageApply
U
StorageApplyResp
U
StorageError
U
TraceEvent
U
Tracer
U
Transport
U
Unstable
U
VoteState
U
WalRecord
U
WalStore
V
committed_index
V
demo_report_lines
V
demo_run
V
describe
V
describe_conf_state
V
describe_entries
V
describe_entry
V
describe_hard_state
V
describe_snapshot
V
entry_encoding_size
V
ents_size
V
hard_state_equal
V
limit_size
V
must_sync
V
no_limit
V
payload_size
V
payloads_size
V
replicate
V
run_election
V
run_single_node
V
vote_result

moonbitstack/moonraft/tracker does not have a README file

Inflight

pub(all) struct Inflight {
  index : UInt64
  bytes : UInt64
} derive(Eq)

One in-flight AppendEntries message: the index of its last entry and the total byte size of the entries it carries.

Inflights

source

pub struct Inflights {
  start : Int
  count : Int
  bytes : UInt64
  size : Int
  max_bytes : UInt64
  buffer : Array[Inflight]
}

A sliding-window flow controller for the AppendEntries messages a leader has sent to one follower but not yet had acknowledged. It caps both the number of outstanding messages (size) and their total byte size (max_bytes), which is what stops a leader from flooding a lagging follower. Callers check full before sending, add on each send, and free_le on each ack.

Inflights::add

source

fn Inflights::add(self : Inflights, index : UInt64, bytes : UInt64) -> Unit

Record that a message ending at index and carrying bytes bytes has been dispatched. full must be false first, and consecutive calls must pass a monotonic sequence of indexes.

Inflights::clone

source

fn Inflights::clone(self : Inflights) -> Inflights

A deep copy that shares no buffer memory with the receiver.

Inflights::count

source

fn Inflights::count(self : Inflights) -> Int

The number of in-flight messages.

Inflights::free_le

source

fn Inflights::free_le(self : Inflights, to : UInt64) -> Unit

Free every in-flight message with last index at or below to, releasing its quota. Acks out of the left edge of the window are ignored.

Inflights::full

source

fn Inflights::full(self : Inflights) -> Bool

Whether no more messages may be sent right now: the message count is at its cap, or the byte budget is exhausted.

Inflights::max_bytes

source

fn Inflights::max_bytes(self : Inflights) -> UInt64

The configured byte budget (etcd's MaxInflightBytes); 0 means no limit.

Inflights::new

source

fn Inflights::new(size : Int, max_bytes : UInt64) -> Inflights

A tracker allowing up to size in-flight messages and up to max_bytes total bytes. max_bytes of 0 means no byte limit. The byte limit is soft: one message that crosses it is still accepted.

Inflights::reset

source

fn Inflights::reset(self : Inflights) -> Unit

Free all in-flight messages, e.g. when a follower's progress is reset.

Progress

source

pub(all) struct Progress {
  next_index : UInt64
  match_index : UInt64
  state : ProgressState
  recent_active : Bool
  msg_app_flow_paused : Bool
  pending_snapshot : UInt64
  is_learner : Bool
  sent_commit : UInt64
  inflights : Inflights
}

The leader's view of one follower's replication progress. next_index is the next log index to send; match_index is the highest index known to be stored on the follower. recent_active records whether the follower has answered since the last liveness sweep, which the read-index and lease paths use to confirm the leader still commands a quorum.

Progress::become_probe

source

fn Progress::become_probe(self : Progress) -> Unit

Move back to cautious probing, one entry at a time. Coming out of Snapshot, resume just past the snapshot the follower was sent (etcd's BecomeProbe).

Progress::become_replicate

source

fn Progress::become_replicate(self : Progress) -> Unit

Move to streaming replication, sending from just past the match point.

Progress::become_snapshot

source

fn Progress::become_snapshot(self : Progress, snapshot_index : UInt64) -> Unit

Mark the follower as needing a snapshot up to snapshot_index; probing will resume just past it once the snapshot is acknowledged.

Progress::can_bump_commit

source

fn Progress::can_bump_commit(self : Progress, index : UInt64) -> Bool

Whether sending index as the commit index could still advance this follower's commit (etcd CanBumpCommit). True only when index is past what we last put in flight and that in-flight commit has not already reached the last acknowledged-in-flight entry (next_index - 1) — so the ③-path can skip redundant commit-only MsgApps. Staged for the 0.4.0 replication wiring.

Progress::copy

source

fn Progress::copy(self : Progress) -> Progress

A deep copy sharing no mutable state (used by the confchange Changer, which preserves a demoted voter's progress across a joint transition).

Progress::free_le

source

fn Progress::free_le(self : Progress, index : UInt64) -> Unit

Free every in-flight slot up through the acknowledged index.

Progress::is_active

source

fn Progress::is_active(self : Progress) -> Bool

Whether the follower has answered since the last sweep.

Progress::is_paused

source

fn Progress::is_paused(self : Progress) -> Bool

Whether replication to this follower is currently throttled: while a snapshot is pending, or whenever the MsgApp flow has been paused (a probe in flight, or a full in-flight window).

Progress::mark_active

source

fn Progress::mark_active(self : Progress) -> Unit

Record that the follower answered during the current liveness sweep.

Progress::maybe_decr_to

source

fn Progress::maybe_decr_to(self : Progress, rejected : UInt64, match_hint : UInt64) -> Bool

Adjust to a rejected AppendEntries (etcd MaybeDecrTo). rejected is the prev-index the follower rejected; match_hint is where we want to retry (the leader-side findConflictByTerm result). A rejection is stale — and ignored — if it cannot pertain to an entry still in flight. Returns whether next_index moved.

Progress::maybe_decrease

source

fn Progress::maybe_decrease(self : Progress, hint : UInt64) -> Bool

Back off after a rejected AppendEntries, using the follower's conflict hint to jump rather than decrement by one. Never rewinds below the match point or below index 1. Returns whether next_index actually moved.

Progress::maybe_update

source

fn Progress::maybe_update(self : Progress, index : UInt64) -> Bool

Fold in a successful acknowledgement up through index. Advances the match and next indices, never backwards, and returns whether the match point moved forward (which is what can let the leader commit new entries).

Progress::new

source

fn Progress::new(next : UInt64, max_inflight? : Int, max_inflight_bytes? : UInt64) -> Progress

A fresh progress that will start probing from next, with a replication flow-control window of max_inflight outstanding AppendEntries and, when max_inflight_bytes is non-zero, at most that many outstanding bytes (etcd's MaxInflightBytes; 0 = no byte limit). The byte budget is threaded straight into the Inflights window so the ③-path only has to pass the real entry size to sent_entries once its Config carries the knob.

Progress::note_commit_sent

source

fn Progress::note_commit_sent(self : Progress, commit : UInt64) -> Unit

Record the highest commit index put in flight to this follower (etcd SentCommit). The ③-path calls this after emitting an append/commit MsgApp.

Progress::optimistic_advance

source

fn Progress::optimistic_advance(self : Progress, last : UInt64) -> Unit

Optimistically advance next_index past last while streaming, so the next AppendEntries carries the following batch without waiting for the ack.

Progress::reset_active

source

fn Progress::reset_active(self : Progress) -> Unit

Clear the liveness flag at the start of a new sweep.

Progress::sent_entries

source

fn Progress::sent_entries(self : Progress, last : UInt64, has_entries : Bool, bytes? : UInt64) -> Unit

Record that a replication message ending at last, carrying has_entries entries totalling bytes bytes, was sent. In Replicate this consumes an in-flight slot (against both the message-count and the byte budget) and pauses once the window fills; in Probe any non-empty send pauses until acked. bytes defaults to 0: while the ③-path send loop does not yet supply the real encoded size (see Progress::new), byte accounting is inert because the byte budget is disabled — the message-count limit still applies exactly as before. Pass the real size to activate MaxInflightBytes.

Progress::to_string

source

fn Progress::to_string(self : Progress) -> String

A one-line, self-describing summary of this progress (etcd's Progress.String).

Progress::unpause

source

fn Progress::unpause(self : Progress) -> Unit

Clear the flow-control throttle (on an ack or a heartbeat response), so one more message may be sent.

ProgressState

source

pub(all) enum ProgressState {
  Probe
  Replicate
  Snapshot
} derive(Eq)

How the leader is currently replicating to one follower.

Probe sends one AppendEntries at a time until the follower's match point is found; Replicate streams entries once the logs are known to agree; and Snapshot means the follower is so far behind that the next thing it needs has already been compacted, so a snapshot must be shipped first (etcd's three progress states).

Source Files

Site source Report issue Packages Build queue Skills Statistics

#Inflight

#Inflights

#Inflights::add

#Inflights::clone

#Inflights::count

#Inflights::free_le

#Inflights::full

#Inflights::max_bytes

#Inflights::new

#Inflights::reset

#Progress

#Progress::become_probe

#Progress::become_replicate

#Progress::become_snapshot

#Progress::can_bump_commit

#Progress::copy

#Progress::free_le

#Progress::is_active

#Progress::is_paused

#Progress::mark_active

#Progress::maybe_decr_to

#Progress::maybe_decrease

#Progress::maybe_update

#Progress::new

#Progress::note_commit_sent

#Progress::optimistic_advance

#Progress::reset_active

#Progress::sent_entries

#Progress::to_string

#Progress::unpause

#ProgressState

Source Files

Inflight

Inflights

Inflights::add

Inflights::clone

Inflights::count

Inflights::free_le

Inflights::full

Inflights::max_bytes

Inflights::new

Inflights::reset

Progress

Progress::become_probe

Progress::become_replicate

Progress::become_snapshot

Progress::can_bump_commit

Progress::copy

Progress::free_le

Progress::is_active

Progress::is_paused

Progress::mark_active

Progress::maybe_decr_to

Progress::maybe_decrease

Progress::maybe_update

Progress::new

Progress::note_commit_sent

Progress::optimistic_advance

Progress::reset_active

Progress::sent_entries

Progress::to_string

Progress::unpause

ProgressState