cluster

type Executor struct {
	ID string `json:"id"`
	// Version is the application version of the workflows (app.version): a worker only resumes
	// workflows of its own version.
	Version string `json:"version"`
	// Build is the manent binary version.
	Build    string `json:"build,omitempty"`
	Hostname string `json:"hostname,omitempty"`
	// Region is the worker's region (dbos.region), if configured.
	Region      string     `json:"region,omitempty"`
	StartedAt   time.Time  `json:"started_at"`
	HeartbeatAt time.Time  `json:"heartbeat_at"`
	StoppedAt   *time.Time `json:"stopped_at,omitempty"`
	// RecoveredBy is who claimed the executor's workflows after it was lost.
	RecoveredBy string     `json:"recovered_by,omitempty"`
	RecoveredAt *time.Time `json:"recovered_at,omitempty"`
	// Queues are the DBOS queues the executor dequeues from.
	Queues []string `json:"queues,omitempty"`
	// Resources is the last resource sample sent by the executor, in JSON
	// (service.WorkerResources): the registry stores it without interpreting it.
	Resources json.RawMessage `json:"resources,omitempty"`
}

type FreezeRecord struct {
	Name      string
	Data      string
	CreatedBy string
	CreatedAt time.Time
}

type InUseError struct {
	ID, Hostname           string
	StartedAt, HeartbeatAt time.Time
}

type PolicyRecord struct {
	Revision    int64
	SHA256      string
	Status      string
	Author      string
	Comment     string
	ReviewedBy  string
	CreatedAt   time.Time
	ActivatedAt *time.Time
	// Tests is the test report (JSON), Files the files of the revision (JSON object); Files
	// is empty in listings.
	Tests string
	Files string
}

type PolicyStore interface {
	// CreatePolicy stores a draft revision and returns its number.
	CreatePolicy(ctx context.Context, r PolicyRecord) (int64, error)
	// Policies lists the revisions, newest first, without files.
	Policies(ctx context.Context) ([]PolicyRecord, error)
	// Policy returns a revision with its files, nil if missing.
	Policy(ctx context.Context, revision int64) (*PolicyRecord, error)
	// ActivePolicy returns the active revision, 0 if none.
	ActivePolicy(ctx context.Context) (int64, error)
	// ActivatePolicy makes revision active if the active one is still expected (0 = none):
	// otherwise ErrPolicyConflict. reviewer, if set, is recorded as who reviewed a draft.
	ActivatePolicy(ctx context.Context, revision, expected int64, reviewer string) error
	CreateFreeze(ctx context.Context, f FreezeRecord) error
	// DeleteFreeze returns false if the window does not exist.
	DeleteFreeze(ctx context.Context, name string) (bool, error)
	ListFreezes(ctx context.Context) ([]FreezeRecord, error)
	// NotifyPolicy tells the other processes that policy or freezes changed (Postgres NOTIFY;
	// nothing on SQLite, where they poll).
	NotifyPolicy(ctx context.Context) error
	// ListenPolicy calls fn at every notification until ctx ends; on SQLite it returns at once.
	ListenPolicy(ctx context.Context, fn func()) error
}

type Registry interface {
	// Register records the executor's startup and clears previous shutdown and claim.
	// It returns false if a recovery of its workflows is running: retry later.
	// It returns *InUseError if the same ID is registered by another startup that has not
	// stopped and sent a heartbeat less than staleAfter ago: two processes with the same ID would
	// resume each other's workflows. Call it before starting DBOS.
	Register(ctx context.Context, e Executor, staleAfter time.Duration) (bool, error)
	// Heartbeat updates the executor started at startedAt. It returns who claimed its workflows,
	// if that happened while it was unreachable, or ErrReplaced if another startup registered
	// with the same ID.
	Heartbeat(ctx context.Context, id string, startedAt time.Time) (recoveredBy string, err error)
	// Report stores the resource sample (JSON) of the executor started at startedAt.
	Report(ctx context.Context, id string, startedAt time.Time, resources json.RawMessage) error
	// Stopped records the orderly shutdown of the executor started at startedAt.
	Stopped(ctx context.Context, id string, startedAt time.Time) error
	// List returns the registered executors, ordered by ID.
	List(ctx context.Context) ([]Executor, error)
	// Claim claims the workflows of a lost executor: it succeeds only if the executor stopped or
	// has sent no heartbeat since before staleBefore, and nobody claimed it already (or the claim
	// stayed unfinished beyond ClaimTimeout). With force it always succeeds, even on an executor
	// never registered.
	Claim(ctx context.Context, id, by string, staleBefore time.Time, force bool) (bool, error)
	// ClaimDone marks the recovery of the executor's workflows as done.
	ClaimDone(ctx context.Context, id string) error
	// Lease acquires or renews lease name for ttl: it succeeds if it is free, expired or already
	// held by holder.
	Lease(ctx context.Context, name, holder string, ttl time.Duration) (bool, error)
	Close() error
}

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

type TargetStore interface {
	SaveTargets(ctx context.Context, r TargetsRecord) error
	// ListTargets returns all records, ordered by application, environment and scope.
	ListTargets(ctx context.Context) ([]TargetsRecord, error)
}

type TargetsRecord struct {
	Application string
	Environment string
	// Tenant is the tenant of the deploy read ("" for untenanted deploys).
	Tenant string
	// Artifact is the artifact of the release read.
	Artifact  string
	Scope     string
	CheckedAt time.Time
	// Data is the state, in JSON (service.TargetsState).
	Data string
}