Files
archie/internal/infrastructure/postgres/status.go
T

166 lines
5.9 KiB
Go

package postgres
import (
"context"
"errors"
"fmt"
"time"
"github.com/jackc/pgx/v5"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
)
// PutConfigSnapshot replaces the published snapshot (one row, id = 1).
func (s *Store) PutConfigSnapshot(ctx context.Context, snapshot storecontract.ConfigSnapshot) error {
published := snapshot.PublishedAt
if published.IsZero() {
published = time.Now()
}
if err := s.queries().UpsertConfigSnapshot(ctx, postgresdb.UpsertConfigSnapshotParams{
Schema: snapshot.Schema, Document: string(snapshot.Document), PublishedAt: published.UTC(),
}); err != nil {
return fmt.Errorf("store: put config snapshot: %w", err)
}
return nil
}
// ConfigSnapshot returns the published snapshot. found is false, with a nil
// error, before anything has published one.
func (s *Store) ConfigSnapshot(ctx context.Context) (storecontract.ConfigSnapshot, bool, error) {
row, err := s.queries().ConfigSnapshotByID(ctx)
if errors.Is(err, pgx.ErrNoRows) {
return storecontract.ConfigSnapshot{}, false, nil
}
if err != nil {
return storecontract.ConfigSnapshot{}, false, fmt.Errorf("store: read config snapshot: %w", err)
}
return storecontract.ConfigSnapshot{
Schema: row.Schema, Document: []byte(row.Document), PublishedAt: row.PublishedAt,
}, true, nil
}
// PutChannelStatus records the reporting process's whole set in one
// transaction, removing rows it no longer reports.
func (s *Store) PutChannelStatus(ctx context.Context, channels []storecontract.ChannelStatus) error {
tx, err := s.pool.Begin(ctx)
if err != nil {
return fmt.Errorf("store: put channel status: begin: %w", err)
}
defer func() { _ = tx.Rollback(ctx) }()
q := postgresdb.New(tx)
reported := make([]string, 0, len(channels))
for _, channel := range channels {
if channel.ID == "" {
return fmt.Errorf("store: put channel status: a channel needs an id")
}
observed := channel.ObservedAt
if observed.IsZero() {
observed = time.Now()
}
if err := q.UpsertChannelStatus(ctx, postgresdb.UpsertChannelStatusParams{
ID: channel.ID, Name: channel.Name, State: channel.State, Detail: channel.Detail,
Configured: channel.Configured, ReloadSupported: channel.ReloadSupported,
ObservedAt: observed.UTC(),
}); err != nil {
return fmt.Errorf("store: put channel status %s: %w", channel.ID, err)
}
reported = append(reported, channel.ID)
}
if err := q.DeleteChannelStatusNotIn(ctx, reported); err != nil {
return fmt.Errorf("store: put channel status: prune: %w", err)
}
return tx.Commit(ctx)
}
// ChannelStatus returns every reported channel, ordered by id.
func (s *Store) ChannelStatus(ctx context.Context) ([]storecontract.ChannelStatus, error) {
rows, err := s.queries().ListChannelStatus(ctx)
if err != nil {
return nil, fmt.Errorf("store: list channel status: %w", err)
}
out := make([]storecontract.ChannelStatus, 0, len(rows))
for _, r := range rows {
out = append(out, storecontract.ChannelStatus{
ID: r.ID, Name: r.Name, State: r.State, Detail: r.Detail,
Configured: r.Configured, ReloadSupported: r.ReloadSupported, ObservedAt: r.ObservedAt,
})
}
return out, nil
}
// PutApplyStatus records what one process applied for one resource kind,
// replacing its own (process, kind) row.
func (s *Store) PutApplyStatus(ctx context.Context, status storecontract.ApplyStatus) error {
reported := status.ReportedAt
if reported.IsZero() {
reported = time.Now()
}
if err := s.queries().UpsertApplyStatus(ctx, postgresdb.UpsertApplyStatusParams{
Process: status.Process, Kind: status.Kind, AppliedVersion: status.AppliedVersion,
Error: status.Error, ReportedAt: reported.UTC(),
}); err != nil {
return fmt.Errorf("store: put apply status: %w", err)
}
return nil
}
// ListApplyStatus returns every process's report, ordered by (process, kind).
func (s *Store) ListApplyStatus(ctx context.Context) ([]storecontract.ApplyStatus, error) {
rows, err := s.queries().ListApplyStatus(ctx)
if err != nil {
return nil, fmt.Errorf("store: list apply status: %w", err)
}
out := make([]storecontract.ApplyStatus, 0, len(rows))
for _, r := range rows {
out = append(out, storecontract.ApplyStatus{
Process: r.Process, Kind: r.Kind, AppliedVersion: r.AppliedVersion,
Error: r.Error, ReportedAt: r.ReportedAt,
})
}
return out, nil
}
// PutPresence replaces one instance's record and drops records whose
// instance stopped re-stamping long ago, so restarts do not accumulate rows.
func (s *Store) PutPresence(ctx context.Context, presence storecontract.Presence) error {
reported := presence.ReportedAt
if reported.IsZero() {
reported = time.Now()
}
q := s.queries()
if err := q.UpsertPresence(ctx, postgresdb.UpsertPresenceParams{
Service: presence.Service, InstanceID: presence.InstanceID, Version: presence.Version,
InstallType: presence.InstallType, StartedAt: presence.StartedAt.UTC(), ReportedAt: reported.UTC(),
Ready: presence.Ready, Detail: presence.Detail,
}); err != nil {
return fmt.Errorf("store: put presence: %w", err)
}
if err := q.DeletePresenceBefore(ctx, reported.Add(-presenceRetention).UTC()); err != nil {
return fmt.Errorf("store: prune presence: %w", err)
}
return nil
}
// presenceRetention is how long a stopped instance stays listed as down.
const presenceRetention = 24 * time.Hour
// ListPresence returns every instance's record, ordered by (service, instance).
func (s *Store) ListPresence(ctx context.Context) ([]storecontract.Presence, error) {
rows, err := s.queries().ListPresence(ctx)
if err != nil {
return nil, fmt.Errorf("store: list presence: %w", err)
}
out := make([]storecontract.Presence, 0, len(rows))
for _, r := range rows {
out = append(out, storecontract.Presence{
Service: r.Service, InstanceID: r.InstanceID, Version: r.Version, InstallType: r.InstallType,
StartedAt: r.StartedAt, ReportedAt: r.ReportedAt, Ready: r.Ready, Detail: r.Detail,
})
}
return out, nil
}