app

package
v0.22.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 30, 2026 License: AGPL-3.0 Imports: 8 Imported by: 0

Documentation

Overview

Package app holds the use cases of Arnakoff and the ports they consume. It depends on domain only (ADR 0002).

Index

Constants

This section is empty.

Variables

View Source
var (
	ErrUnknownSource   = errors.New("unknown source")
	ErrDuplicateSource = errors.New("duplicate source")
)

Sync errors, checked with errors.Is.

View Source
var ErrInterval = errors.New("sync interval must be positive")

ErrInterval means a plan has no positive interval.

View Source
var ErrNoSnapshot = errors.New("no stored snapshot")

ErrNoSnapshot is returned by SnapshotStore.Load when it holds no snapshot of the source.

Functions

This section is empty.

Types

type Alert added in v0.19.0

type Alert struct {
	Source domain.Source
	At     time.Time
	Err    error
}

Alert is a sync or reload of one source that failed or was rejected.

type Alerter added in v0.19.0

type Alerter interface {
	Alert(ctx context.Context, a Alert)
}

Alerter tells the operator that a source could not be synced or reloaded. It reports its own failures: the caller has nothing to do about them.

type Clock

type Clock interface {
	Now() time.Time
}

Clock tells the current time; tests inject a fixed one.

type Jitter added in v0.19.0

type Jitter func(maxJitter time.Duration) time.Duration

Jitter returns a random duration from 0 up to, but not including, max.

type Plan added in v0.19.0

type Plan struct {
	Source domain.Source
	Every  time.Duration
}

Plan says how often a source is synced.

type Reloader added in v0.19.0

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

Reloader restores, at an interval, the snapshots the sync process stored, so that the API process serves them without a restart. It alerts when a source starts failing to reload, not again until it has recovered.

func NewReloader added in v0.19.0

func NewReloader(s *Sync, sleeper Sleeper, alerter Alerter, every time.Duration) *Reloader

NewReloader returns a Reloader of the sources of s, checking every interval.

func (*Reloader) Run added in v0.19.0

func (r *Reloader) Run(ctx context.Context)

Run reloads every source at each interval until ctx is done. Restore the snapshots once before, so the first ones are in service at once.

type Scheduler added in v0.19.0

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

Scheduler syncs each planned source at its interval, plus a jitter, and alerts on every sync that fails or is rejected.

func NewScheduler added in v0.19.0

func NewScheduler(s *Sync, sleeper Sleeper, alerter Alerter, jitter Jitter, plans ...Plan) (*Scheduler, error)

NewScheduler returns a Scheduler of plans, or ErrUnknownSource, ErrDuplicateSource or ErrInterval for a plan s cannot follow.

func (*Scheduler) Once added in v0.19.0

func (sc *Scheduler) Once(ctx context.Context, sources ...domain.Source) error

Once syncs each of sources once, or every planned source when none is given, alerts on each failure and joins the errors. It returns ErrUnknownSource without syncing anything when a source is not planned.

func (*Scheduler) Run added in v0.19.0

func (sc *Scheduler) Run(ctx context.Context)

Run syncs every planned source until ctx is done. A source whose snapshot in service is younger than its interval waits until it is due: restore the stored snapshots first so that a restart does not download every source again.

type Sleeper added in v0.19.0

type Sleeper interface {
	// Sleep returns after d, or with the error of ctx once it is done.
	Sleep(ctx context.Context, d time.Duration) error
}

Sleeper pauses a scheduling loop; tests inject one that does not wait.

type SnapshotStore

type SnapshotStore interface {
	// Save durably replaces the stored snapshot of s.Source.
	Save(ctx context.Context, s domain.Snapshot) error
	// Load returns the stored snapshot of source, or ErrNoSnapshot.
	Load(ctx context.Context, source domain.Source) (domain.Snapshot, error)
}

SnapshotStore keeps the last valid snapshot of each source across restarts and between the sync and API processes.

func DryRun added in v0.19.0

func DryRun(st SnapshotStore) SnapshotStore

DryRun returns a store that reads st and keeps nothing: a Sync on it, once restored, validates new snapshots against the stored ones without replacing them.

type SourceFetcher

type SourceFetcher interface {
	// Spec declares the source and what a sane file of it holds.
	Spec() domain.SnapshotSpec
	// Fetch downloads the source and parses it into a snapshot. Sync sets
	// its FetchedAt.
	Fetch(ctx context.Context) (domain.Snapshot, error)
}

SourceFetcher downloads and parses one upstream source.

type SourceSync

type SourceSync struct {
	Source domain.Source
	// LastSuccess is when the snapshot in service was fetched, zero when
	// none is.
	LastSuccess time.Time
	// LastFailure is when the last failed or rejected sync ran, zero when
	// none did. It is kept after a later success.
	LastFailure time.Time
	// LastError is why that sync failed.
	LastError error
	// Rows is the number of rows of the snapshot in service.
	Rows int
	// Newest is the date of the most recent entry in service, zero when the
	// source dates none.
	Newest time.Time
}

SourceSync is the sync state of one source, as /v1/sources shows it.

type Sync

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

Sync downloads each source, validates the new snapshot against the connector's spec and the last valid one, stores it, then swaps it in for the readers. A rejected snapshot leaves the last valid one in service. It is safe for concurrent use.

func NewSync

func NewSync(store SnapshotStore, clock Clock, fetchers ...SourceFetcher) (*Sync, error)

NewSync returns a Sync of the sources the fetchers declare, or ErrDuplicateSource when two declare the same one.

func (*Sync) Restore

func (s *Sync) Restore(ctx context.Context) error

Restore puts in service the stored snapshot of every source when it is valid and newer than the one in service. It runs at startup, and in the API process to pick up what the sync process stored. A source with no stored snapshot is skipped; errors of the others are joined.

func (*Sync) Run

func (s *Sync) Run(ctx context.Context) error

Run syncs every source in turn and joins their errors: one source failing does not stop the others.

func (*Sync) RunSource

func (s *Sync) RunSource(ctx context.Context, source domain.Source) error

RunSource syncs one source, or returns ErrUnknownSource.

func (*Sync) Snapshot

func (s *Sync) Snapshot(source domain.Source) (domain.Snapshot, bool)

Snapshot returns the snapshot in service for source, if any. It is shared with every reader: treat it as read-only.

func (*Sync) States

func (s *Sync) States() []SourceSync

States returns the sync state of every source, in declaration order.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL