raftapply

type ApplyFaultContextV1 ¶

type ApplyFaultContextV1 struct {
	EntryID           raftentry.ApplyEntryID
	CommandDigest     raftentry.CommandDigestV1
	AppliedCommandLSN uint64
}

type ApplyMetadataV1 ¶

type ApplyMetadataV1 struct {
	EntryID                 raftentry.ApplyEntryID
	LocalDurabilityBoundary LocalDurabilityBoundaryV1
	SyncLocalCommandWAL     bool

	// CurrentCatalogVersion is the caller-observed local catalog version used
	// to enforce deterministic expected-catalog-version guards before mutation.
	CurrentCatalogVersion    uint64
	HasCurrentCatalogVersion bool

	ScopeRule       raftentry.ScopeRuleV1
	DatabaseScope   string
	CatalogScope    string
	RequestMetadata raftentry.RequestMetadataV1
	ExpectedTarget  *raftentry.TargetIdentityV1
}

ApplyMetadataV1 is explicit per-entry metadata carried beside committed deterministic entry bytes. None of these fields are native-wire request structs or handler inputs.

type ApplyProgressRecordV1 ¶

type ApplyProgressRecordV1 struct {
	EntryID           raftentry.ApplyEntryID
	CommandDigest     raftentry.CommandDigestV1
	AppliedCommandLSN uint64
	LogicalDigestV1   LogicalDigestV1
}

ApplyProgressRecordV1 records the apply-progress transition made after an entry has reached the selected local durability and visibility boundary.

type ApplyProgressStore ¶

type ApplyProgressStore interface {
	CheckCanApply(raftentry.ApplyEntryID) error
	CheckCanRecordApplied(ApplyProgressRecordV1) error
	RecordApplied(ApplyProgressRecordV1) error
	LookupApplyProgress(raftentry.ApplyEntryID) (ApplyProgressRecordV1, bool, error)
	LastApplied() (raftentry.ApplyEntryID, bool)
}

ApplyProgressStore checks monotonic apply order and records durable progress.

type ApplyResultRecordV1 ¶

type ApplyResultRecordV1 struct {
	EntryID                 raftentry.ApplyEntryID
	CommandDigest           raftentry.CommandDigestV1
	IdempotencyKey          []byte
	AppliedCommandLSN       uint64
	ProgressLogicalDigestV1 LogicalDigestV1
	Result                  raftentry.ApplyResultV1
}

ApplyResultRecordV1 is the fake/durable result-store unit keyed by ApplyEntryID. The result payload is intentionally bounded separately from the deterministic entry bytes.

type ApplyResultStore ¶

type ApplyResultStore interface {
	LookupApplyResult(raftentry.ApplyEntryID) (ApplyResultRecordV1, bool, error)
	LookupApplyResultByIdempotencyKey([]byte) (ApplyResultRecordV1, bool, error)
	CheckCanRecordApplyResult(ApplyResultRecordV1) error
	RecordApplyResult(ApplyResultRecordV1) error
}

ApplyResultStore records deterministic apply results for idempotency/replay.

type CommandWALApplySeam ¶

type CommandWALApplySeam interface {
	Append(*backenddb.DB, commandwalapply.LoweredFrame, commandwalapply.ApplyMetadata, commandwalapply.Options) (commandwalapply.Handle, commandwalapply.Result, error)
	Finalize(*backenddb.DB, commandwalapply.Handle, commandwalapply.ApplyMetadata, commandwalapply.Options) (commandwalapply.Result, error)
	Abort(*backenddb.DB, commandwalapply.Handle)
}

CommandWALApplySeam is the local command-WAL append/finalize boundary added by commandwalapply. Rejection tests inject a counting seam to prove this boundary is not called before fail-closed validation completes.

type DurableApplyProgressStore ¶

type DurableApplyProgressStore struct {
	// contains filtered or unexported fields
}

DurableApplyProgressStore is an append-only implementation of ApplyProgressStore. It enforces the same strictly-increasing-index and non-decreasing-term rules as MemoryApplyProgressStore, then fsyncs each accepted record by default.

func OpenDurableApplyProgressStore(dir string, opts DurableApplyStoreOptions) (*DurableApplyProgressStore, error)

func OpenDurableApplyProgressStoreFile(path string, opts DurableApplyStoreOptions) (*DurableApplyProgressStore, error)

func (s *DurableApplyProgressStore) CheckCanApply(id raftentry.ApplyEntryID) error

func (s *DurableApplyProgressStore) CheckCanRecordApplied(record ApplyProgressRecordV1) error

func (s *DurableApplyProgressStore) Close() error

func (s *DurableApplyProgressStore) LastApplied() (raftentry.ApplyEntryID, bool)

func (s *DurableApplyProgressStore) LastAppliedRecord() (ApplyProgressRecordV1, bool)

func (s *DurableApplyProgressStore) Len() int

func (s *DurableApplyProgressStore) LookupApplyProgress(id raftentry.ApplyEntryID) (ApplyProgressRecordV1, bool, error)

func (s *DurableApplyProgressStore) RecordApplied(record ApplyProgressRecordV1) error

type DurableApplyResultStore ¶

type DurableApplyResultStore struct {
	// contains filtered or unexported fields
}

DurableApplyResultStore is an append-only implementation of ApplyResultStore. It persists records before they are inserted into the in-memory lookup maps, and rebuilds those maps from checksummed records when reopened.

func OpenDurableApplyResultStore(dir string, opts DurableApplyStoreOptions) (*DurableApplyResultStore, error)

func OpenDurableApplyResultStoreFile(path string, opts DurableApplyStoreOptions) (*DurableApplyResultStore, error)

func (s *DurableApplyResultStore) CheckCanRecordApplyResult(record ApplyResultRecordV1) error

func (s *DurableApplyResultStore) Close() error

func (s *DurableApplyResultStore) Len() int

func (s *DurableApplyResultStore) LookupApplyResult(id raftentry.ApplyEntryID) (ApplyResultRecordV1, bool, error)

func (s *DurableApplyResultStore) LookupApplyResultByIdempotencyKey(key []byte) (ApplyResultRecordV1, bool, error)

func (s *DurableApplyResultStore) RecordApplyResult(record ApplyResultRecordV1) error

type DurableApplyStoreOptions ¶

type DurableApplyStoreOptions struct {
	MaxRecords  int
	MaxIndex    uint64
	DisableSync bool

	// AllowInitialIndexGap accepts a first TreeDB command index above 1 for
	// consensus logs that reserve lower indexes for internal membership entries.
	// Later gaps are accepted when indexes strictly increase.
	AllowInitialIndexGap bool
}

DurableApplyStoreOptions configures the append-only durable R3a metadata stores. By default, records are fsynced as they are appended; tests and microbenchmarks may set DisableSync to isolate encode/index overhead.

type Error ¶

type Error struct {
	Code raftentry.DeterministicErrorCodeV1
	Err  error
}

Error carries stable deterministic apply error names through fake stores and the harness boundary.

func (e *Error) Error() string

func (e *Error) Unwrap() error

type FaultInjector ¶

type FaultInjector interface {
	InjectApplyFault(FaultPointV1, ApplyFaultContextV1) error
}

type FaultPointV1 ¶

type FaultPointV1 string

const (
	FaultBeforeLocalWALAppendV1             FaultPointV1 = "before-local-wal-append-v1"
	FaultAfterLocalWALAppendBeforeVisibleV1 FaultPointV1 = "after-local-wal-append-before-visible-v1"
	FaultAfterVisibleBeforeResultRecordV1   FaultPointV1 = "after-visible-before-result-record-v1"
	FaultAfterResultRecordBeforeProgressV1  FaultPointV1 = "after-result-record-before-progress-v1"
	FaultAfterProgressRecordV1              FaultPointV1 = "after-progress-record-v1"
)

type Harness ¶

type Harness struct {
	// contains filtered or unexported fields
}

Harness applies committed deterministic entry bytes to one local DB handle.

func NewHarness(db *backenddb.DB, opts Options) *Harness

func (h *Harness) ApplyCommittedEntryV1(entryBytes []byte, meta ApplyMetadataV1) (raftentry.ApplyResultV1, error)

func (h *Harness) PreflightCommandEntryV1(entryBytes []byte, meta ApplyMetadataV1) (PreflightResultV1, error)

func (h *Harness) PreflightDecodedCommandEntryV1(entry raftentry.CommandEntryV1, meta ApplyMetadataV1) (PreflightResultV1, error)

type LocalDurabilityBoundaryV1 ¶

type LocalDurabilityBoundaryV1 string

LocalDurabilityBoundaryV1 names the local durability boundary a committed deterministic entry is allowed to use before it becomes locally visible.

const (
	// LocalDurabilityCommandWALV1 requires a local command-WAL frame before any
	// visible mutation, result/idempotency record, or apply-progress advance.
	LocalDurabilityCommandWALV1 LocalDurabilityBoundaryV1 = "local-command-wal-v1"
)

type LogicalDigestOptionsV1 ¶

type LogicalDigestOptionsV1 struct {
	ScopeRule     raftentry.ScopeRuleV1
	DatabaseScope string
	CatalogScope  string
}

type LogicalDigestV1 ¶

type LogicalDigestV1 [32]byte

LogicalDigestV1 is a convergence digest over the supported logical catalog state. It intentionally excludes physical root/page IDs, WAL LSNs, value-log RIDs, segment names, and filesystem paths.

func LogicalDigestV1ForDB(db *backenddb.DB, opts LogicalDigestOptionsV1) (LogicalDigestV1, error)

func (d LogicalDigestV1) Hex() string

type MemoryApplyProgressStore ¶

type MemoryApplyProgressStore struct {
	// contains filtered or unexported fields
}

MemoryApplyProgressStore is a bounded fake apply-progress store for tests and early harness wiring. The first in-memory entry must start at index 1; later entries enforce strictly increasing indexes, allowing gaps, and non-decreasing terms.

func NewMemoryApplyProgressStore(maxRecords int, maxIndex uint64) *MemoryApplyProgressStore

func (s *MemoryApplyProgressStore) CheckCanApply(id raftentry.ApplyEntryID) error

func (s *MemoryApplyProgressStore) CheckCanRecordApplied(record ApplyProgressRecordV1) error

func (s *MemoryApplyProgressStore) LastApplied() (raftentry.ApplyEntryID, bool)

func (s *MemoryApplyProgressStore) LastAppliedRecord() (ApplyProgressRecordV1, bool)

func (s *MemoryApplyProgressStore) Len() int

func (s *MemoryApplyProgressStore) LookupApplyProgress(id raftentry.ApplyEntryID) (ApplyProgressRecordV1, bool, error)

func (s *MemoryApplyProgressStore) RecordApplied(record ApplyProgressRecordV1) error

type MemoryApplyResultStore ¶

type MemoryApplyResultStore struct {
	// contains filtered or unexported fields
}

MemoryApplyResultStore is a bounded fake result/idempotency store for tests and early harness wiring. It is not durable.

func NewMemoryApplyResultStore(maxRecords int) *MemoryApplyResultStore

func (s *MemoryApplyResultStore) CheckCanRecordApplyResult(record ApplyResultRecordV1) error

func (s *MemoryApplyResultStore) Len() int

func (s *MemoryApplyResultStore) LookupApplyResult(id raftentry.ApplyEntryID) (ApplyResultRecordV1, bool, error)

func (s *MemoryApplyResultStore) LookupApplyResultByIdempotencyKey(key []byte) (ApplyResultRecordV1, bool, error)

func (s *MemoryApplyResultStore) RecordApplyResult(record ApplyResultRecordV1) error

type Options ¶

type Options struct {
	DecodeLimits        nativewire.Limits
	ProgressStore       ApplyProgressStore
	ResultStore         ApplyResultStore
	CommandWALApplySeam CommandWALApplySeam
	FaultInjector       FaultInjector
}

Options wires the harness to deterministic decode limits, fake or durable stores, and the command-WAL seam. Nil stores are allowed for early tests but mean duplicates/progress cannot be durably recorded.

type PreflightResultV1 ¶

type PreflightResultV1 struct {
	KnownIdempotencyReplay bool
}

func PreflightCommandEntryV1(db *backenddb.DB, entryBytes []byte, meta ApplyMetadataV1, opts Options) (PreflightResultV1, error)

func PreflightDecodedCommandEntryV1(db *backenddb.DB, entry raftentry.CommandEntryV1, meta ApplyMetadataV1, opts Options) (PreflightResultV1, error)