cloudreport

type Events struct {
	// Reader is the event store. A nil Reader leaves runs out of reports.
	Reader eventstore.DAGRunReader
	// RetentionDays is how many days the event store keeps events; 0 keeps
	// them forever.
	RetentionDays int
	// State persists which events Dagu Console has acknowledged.
	State StateStore
	// Stale persists, without the lease, that the position in State predates
	// a period below runs, so that the next process to take the lease
	// discards it. It must be set when Reader is.
	Stale StateStore
	// Lease lets one process at a time report the events of a shared data
	// directory.
	Lease Lease
	// Statuses lists the runs in progress when they are not known from the
	// events: when the reporter starts without a saved list of them, and
	// after events were lost. It must be set when Reader is.
	Statuses RunStatuses
}

type Lease interface {
	TryLock() error
	Heartbeat(ctx context.Context) error
	Unlock() error
}

type LeaseLister interface {
	ListAll(ctx context.Context) ([]dispatch.DAGRunLease, error)
}

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

type ProcLister interface {
	ListAllAlive(ctx context.Context) (map[string][]ir.DAGRunRef, error)
}

type QueueStore interface {
	queue.Summarizer
	GetByItemID(ctx context.Context, name, itemID string) (queue.QueuedItemData, error)
}

type Queues struct {
	// Store sums up the queues that hold queued runs, and reads a queue's
	// next run in line.
	Store QueueStore
	// Procs lists the runs in progress on the server's own processes, by
	// queue, and Leases those on distributed workers.
	Procs  ProcLister
	Leases LeaseLister
	// Runs opens a queued run's attempt, to read why it cannot start.
	Runs RunFinder
	// Capacity is how many runs of the queue may run at once; a queue runs
	// at least one, as the scheduler does.
	Capacity func(queue string) int
}

type RemoteAccess interface {
	Status(ctx context.Context) (cloudaccess.Status, error)
}

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

type RunFinder interface {
	FindAttempt(ctx context.Context, ref ir.DAGRunRef) (dagrun.Attempt, error)
}

type RunStatuses interface {
	ListStatuses(ctx context.Context, options persis.DAGRunListOptions) ([]*ir.DAGRunStatus, error)
}

type Scheduler struct {
	// State holds each DAG's next run and latest start slot, and the last
	// tick.
	State schedulerstate.Store
	// Pause says whether the scheduler is paused.
	Pause schedulerstate.PauseStore
}

type StateStore interface {
	Load(ctx context.Context) (data []byte, found bool, err error)
	Save(ctx context.Context, data []byte) error
}

type Status struct {
	// Level is the level in effect.
	Level config.ReportLevel
	// Configured reports that configuration fixes Level.
	Configured bool
	// Chosen reports that an administrator chose Level.
	Chosen bool
	// NoticeDismissed reports that an administrator dismissed the notice
	// asking them to choose a level.
	NoticeDismissed bool
	// ErrorsOffered reports that an administrator was offered to send error
	// messages: they chose a level, which they choose among choices that
	// include them, or dismissed the notice that offers them.
	ErrorsOffered bool
	// LastReportAt is when Dagu Console accepted the last report this
	// process sent, or zero before the first.
	LastReportAt time.Time
	// LastReport is the JSON body of that report, with the heartbeat secret
	// redacted.
	LastReport []byte
	// RunsPausedUntil is when Dagu Console stores this server's finished runs
	// again, as the last accepted report was told, or zero when it was not
	// paused.
	RunsPausedUntil time.Time
}