Files
archie/internal/domain/storepkg/update.go
T

196 lines
6.9 KiB
Go

package storepkg
import (
"context"
"errors"
"fmt"
"github.com/samcharles93/archie-core/internal/domain/access"
)
// Update policies. Manual is the default; an auto package follows the
// catalogue, with a widening update still waiting for approval.
const (
PolicyManual = "manual"
PolicyAuto = "auto"
)
// ErrInvalidPolicy: the update policy is neither manual nor auto.
var ErrInvalidPolicy = errors.New("store package update policy must be manual or auto")
// OrgPackage names one installed package.
type OrgPackage struct{ OrgID, Name string }
// SetPackageUpdatePolicy sets whether name follows the catalogue on its own.
func (s Service) SetPackageUpdatePolicy(ctx context.Context, orgID, name, policy string) (Installed, error) {
if policy != PolicyManual && policy != PolicyAuto {
return Installed{}, ErrInvalidPolicy
}
if err := s.Store.SetUpdatePolicy(ctx, orgID, name, policy); err != nil {
return Installed{}, err
}
return s.Store.Get(ctx, orgID, name)
}
// UpdateAuto runs UpdatePackage for every auto package. No caller is behind
// it, so the audit trail attributes it to the process doing the work.
func (s Service) UpdateAuto(ctx context.Context) error {
ctx = access.WithActor(ctx, "archie-state-store")
ctx = access.WithSource(ctx, "package auto-update")
return updateAuto(ctx, s.Store, s)
}
// updateAuto tries every auto package: one that fails does not stop the rest.
func updateAuto(ctx context.Context, store interface {
ListAutoUpdate(context.Context) ([]OrgPackage, error)
}, updates OrgUpdates,
) error {
refs, err := store.ListAutoUpdate(ctx)
if err != nil {
return fmt.Errorf("list auto-update packages: %w", err)
}
var errs []error
for _, ref := range refs {
if _, err := updates.UpdatePackage(ctx, ref.OrgID, ref.Name); err != nil {
errs = append(errs, fmt.Errorf("update %s/%s: %w", ref.OrgID, ref.Name, err))
}
}
return errors.Join(errs...)
}
var (
// ErrNoPendingUpdate: there is no update waiting for approval.
ErrNoPendingUpdate = errors.New("store package has no pending update")
// ErrNoPrevious: the package has no earlier version to roll back to.
ErrNoPrevious = errors.New("store package has no previous version")
)
// Widens reports whether an update's declared authority asks for more than
// the operator accepted. A package never accepted holds no authority, so
// any grant it declares is wider.
func (i Installed) Widens(next Authority) bool {
var held Authority
if i.AcceptedAuthority != nil {
held = *i.AcceptedAuthority
}
return !held.Covers(next)
}
// UpdatePackage moves name to the digest the verified catalogue lists. An
// update that does not widen authority applies at once; a widening one waits
// as pending until ApprovePackageUpdate, with the live pin untouched.
func (s Service) UpdatePackage(ctx context.Context, orgID, name string) (Installed, error) {
installed, err := s.Store.Get(ctx, orgID, name)
if err != nil {
return Installed{}, fmt.Errorf("installed package %q: %w", name, err)
}
catalogue, err := s.ListCatalogue(ctx)
if err != nil {
return Installed{}, err
}
for _, entry := range catalogue.Packages {
if entry.Name != name {
continue
}
pin := Pin{Reference: entry.Reference, Digest: entry.Digest}
if pin.Digest == installed.Digest || (installed.Pending != nil && installed.Pending.Digest == pin.Digest) {
return installed, nil
}
next, contents, err := s.prepare(ctx, orgID, name, pin)
if err != nil {
return Installed{}, err
}
if installed.Widens(next.Descriptor.Authority) {
if err := s.Store.SetPending(ctx, orgID, name, pin, next.Descriptor.Authority); err != nil {
return Installed{}, err
}
return s.Store.Get(ctx, orgID, name)
}
next.AcceptedAuthority = installed.AcceptedAuthority
return s.swap(ctx, installed, next, contents, ActionUpdate)
}
return Installed{}, fmt.Errorf("catalogue package %q: %w", name, ErrNotFound)
}
// ApprovePackageUpdate applies the pending update and accepts the authority
// it declares.
func (s Service) ApprovePackageUpdate(ctx context.Context, orgID, name string) (Installed, error) {
installed, err := s.Store.Get(ctx, orgID, name)
if err != nil {
return Installed{}, fmt.Errorf("installed package %q: %w", name, err)
}
if installed.Pending == nil {
return Installed{}, fmt.Errorf("package %q: %w", name, ErrNoPendingUpdate)
}
next, contents, err := s.prepare(ctx, orgID, name, *installed.Pending)
if err != nil {
return Installed{}, err
}
accepted := next.Descriptor.Authority
next.AcceptedAuthority = &accepted
return s.swap(ctx, installed, next, contents, ActionApproveUpdate)
}
// RollbackPackage reinstalls the previous digest with the authority accepted
// against it.
func (s Service) RollbackPackage(ctx context.Context, orgID, name string) (Installed, error) {
installed, err := s.Store.Get(ctx, orgID, name)
if err != nil {
return Installed{}, fmt.Errorf("installed package %q: %w", name, err)
}
if installed.Previous == nil {
return Installed{}, fmt.Errorf("package %q: %w", name, ErrNoPrevious)
}
next, contents, err := s.prepare(ctx, orgID, name, *installed.Previous)
if err != nil {
return Installed{}, err
}
next.AcceptedAuthority = installed.PreviousAccepted
return s.swap(ctx, installed, next, contents, ActionRollback)
}
// prepare fetches and validates the package at pin and resolves its
// contributions before anything live changes.
func (s Service) prepare(ctx context.Context, orgID, name string, pin Pin) (Installed, map[string]map[string][]byte, error) {
descriptor, layer, err := s.Registry.Fetch(ctx, pin.Reference, pin.Digest)
if err != nil {
return Installed{}, nil, fmt.Errorf("fetch package: %w", err)
}
if err := descriptor.Validate(); err != nil {
return Installed{}, nil, fmt.Errorf("validate package: %w", err)
}
contents, err := s.resolveFamilyContents(descriptor, layer)
if err != nil {
return Installed{}, nil, err
}
return Installed{
OrgID: orgID, Name: name, Reference: pin.Reference, Digest: pin.Digest,
Descriptor: descriptor, Layer: layer,
}, contents, nil
}
// swap replaces installed with next: old contributions come out, new ones go
// in, then the record flips. A failure puts the old contributions back so
// the record, which still names the old pin, stays true.
func (s Service) swap(ctx context.Context, installed, next Installed, contents map[string]map[string][]byte, action string) (Installed, error) {
if err := s.withdraw(ctx, installed); err != nil {
return Installed{}, err
}
err := s.project(ctx, next, contents)
if err == nil {
err = s.Store.Replace(ctx, next, action)
}
if err != nil {
return Installed{}, errors.Join(err, s.withdraw(ctx, next), s.restore(ctx, installed))
}
return s.Store.Get(ctx, installed.OrgID, installed.Name)
}
func (s Service) restore(ctx context.Context, installed Installed) error {
contents, err := s.resolveFamilyContents(installed.Descriptor, installed.Layer)
if err != nil {
return err
}
return s.project(ctx, installed, contents)
}