sequencer

type Config struct {
	Chaos           float32       // Set by tests to inject errors.
	FlushPeriod     time.Duration // Don't queue mutations for longer than this.
	FlushSize       int           // Ideal target database transaction size
	Parallelism     int           // The number of concurrent connections to use.
	QuiescentPeriod time.Duration // How often to sweep for queued mutations.
	RetireOffset    time.Duration // Delay removal of applied mutations.
	ScanSize        int           // Limit on staging-table read queries.
	TaskGracePeriod time.Duration // How long to allow previous iteration to clean up.
	TimestampLimit  int           // The maximum number of timestamps to operate on.
}

type MarkingAcceptor interface {
	// IsMarking should return true.
	IsMarking() bool
}

type Sequencer interface {
	// Start any goroutines necessary for operating within a
	// [types.TableGroup] and return an acceptor for admitting mutations
	// into that group. The Sequencer will monitor the
	// [StartOptions.Bounds] for updates and periodically emit a Stat
	// which reflects the Sequencer's current state.  It is reasonable
	// to extend the maximum value of the bounds over time, but the
	// minimum value should not be advanced until all tables in the Stat
	// have advanced to at least some common minimum value. When
	// switching between different Sequencers at runtime, callers should
	// discontinue updates to the bounds and ideally wait for the Stat
	// variable to catch up.
	Start(ctx *stopper.Context, opts *StartOptions) (types.MultiAcceptor, *notify.Var[Stat], error)
}

type Shim interface {
	// Wrap will modify the delegate's behavior. The shim should call
	// [StartOptions.Copy] if the options passed to [Sequencer.Start]
	// are to be modified before passing them to the delegate.
	Wrap(ctx *stopper.Context, delegate Sequencer) (Sequencer, error)
}

type StartOptions struct {
	Bounds      *notify.Var[hlc.Range] // Control the range of eligible timestamps.
	Delegate    types.MultiAcceptor    // The acceptor to use when continuing to process mutations.
	Group       *types.TableGroup      // The tables that should be operated on.
	MaxDeferred int                    // Back off after deferring this many mutations.
}

type Stat interface {
	Copy() Stat                           // Copy returns a deep copy of the Stat.
	Group() *types.TableGroup             // The TableGroup that was passed to [Sequencer.Start].
	Progress() *ident.TableMap[hlc.Range] // The times to which the members of the group have advanced.
}