196 lines
6.9 KiB
Go
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)
|
|
}
|