456 lines
15 KiB
Go
456 lines
15 KiB
Go
package postgres
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgconn"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/storepkg"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
|
|
)
|
|
|
|
// InstalledPackages persists org-scoped Archie package pins.
|
|
type InstalledPackages struct{ pool *pgxpool.Pool }
|
|
|
|
var _ storepkg.Repository = (*InstalledPackages)(nil)
|
|
|
|
func NewInstalledPackages(pool *pgxpool.Pool) *InstalledPackages {
|
|
return &InstalledPackages{pool: pool}
|
|
}
|
|
|
|
func (s *InstalledPackages) Install(ctx context.Context, p storepkg.Installed) error {
|
|
if p.OrgID == "" || p.Name == "" || p.Reference == "" || p.Digest == "" {
|
|
return errors.New("installed package identity and pin are required")
|
|
}
|
|
if err := p.Descriptor.Validate(); err != nil {
|
|
return err
|
|
}
|
|
descriptor, err := json.Marshal(p.Descriptor)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockInstalledPackages(ctx, p.OrgID); err != nil {
|
|
return err
|
|
}
|
|
if err := checkInstalledRequirements(ctx, q, p); err != nil {
|
|
return err
|
|
}
|
|
if err := q.InsertInstalledPackage(ctx, postgresdb.InsertInstalledPackageParams{
|
|
OrgID: p.OrgID, Name: p.Name, Reference: p.Reference, Digest: p.Digest,
|
|
Descriptor: descriptor, Layer: p.Layer, UpdatePolicy: p.UpdatePolicy,
|
|
}); err != nil {
|
|
if pgCode(err) == "23505" {
|
|
return storepkg.ErrInstalled
|
|
}
|
|
return err
|
|
}
|
|
if err := insertInstalledRequirements(ctx, q, p); err != nil {
|
|
return err
|
|
}
|
|
if err := auditPackage(ctx, q, p.OrgID, p.Name, "install", nil,
|
|
&packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: p.UpdatePolicy}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// packageAuditValue is the non-secret state an installed_packages audit row
|
|
// records: the pin, the policy that decides whether it follows the catalogue,
|
|
// and a pending update's declared authority. Pending marks a pin waiting for
|
|
// approval.
|
|
type packageAuditValue struct {
|
|
Reference string `json:"reference"`
|
|
Digest string `json:"digest"`
|
|
UpdatePolicy string `json:"update_policy,omitempty"`
|
|
Pending bool `json:"pending,omitempty"`
|
|
Authority json.RawMessage `json:"authority,omitempty"`
|
|
}
|
|
|
|
// auditPackage writes one installed_packages row. A nil side stays NULL, which
|
|
// the read model treats as a create or a delete.
|
|
func auditPackage(ctx context.Context, q *postgresdb.Queries, orgID, name, action string, oldValue, newValue *packageAuditValue) error {
|
|
oldJSON, err := auditJSON(oldValue)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
newJSON, err := auditJSON(newValue)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return insertAudit(ctx, q, "installed_packages", name, action, oldJSON, newJSON, 0, orgID)
|
|
}
|
|
|
|
// getInstalledRow reads one package inside the caller's transaction, mapping
|
|
// an absent row to storepkg.ErrNotFound.
|
|
func getInstalledRow(ctx context.Context, q *postgresdb.Queries, orgID, name string) (postgresdb.GetInstalledPackageRow, error) {
|
|
row, err := q.GetInstalledPackage(ctx, postgresdb.GetInstalledPackageParams{OrgID: orgID, Name: name})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return postgresdb.GetInstalledPackageRow{}, storepkg.ErrNotFound
|
|
}
|
|
if err != nil {
|
|
return postgresdb.GetInstalledPackageRow{}, err
|
|
}
|
|
return row, nil
|
|
}
|
|
|
|
func checkInstalledRequirements(ctx context.Context, q *postgresdb.Queries, p storepkg.Installed) error {
|
|
for _, required := range p.Descriptor.Requires {
|
|
existing, err := q.GetInstalledPackage(ctx, postgresdb.GetInstalledPackageParams{OrgID: p.OrgID, Name: required.Name})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return fmt.Errorf("required package %q: %w", required.Name, storepkg.ErrNotFound)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if existing.Digest != required.Digest {
|
|
return fmt.Errorf("required package %q has a different digest", required.Name)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func insertInstalledRequirements(ctx context.Context, q *postgresdb.Queries, p storepkg.Installed) error {
|
|
for _, required := range p.Descriptor.Requires {
|
|
if err := q.InsertInstalledRequirement(ctx, postgresdb.InsertInstalledRequirementParams{
|
|
OrgID: p.OrgID, PackageName: p.Name, RequiredName: required.Name, RequiredDigest: required.Digest,
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *InstalledPackages) Get(ctx context.Context, orgID, name string) (storepkg.Installed, error) {
|
|
row, err := postgresdb.New(s.pool).GetInstalledPackage(ctx, postgresdb.GetInstalledPackageParams{OrgID: orgID, Name: name})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return storepkg.Installed{}, storepkg.ErrNotFound
|
|
}
|
|
if err != nil {
|
|
return storepkg.Installed{}, err
|
|
}
|
|
return installedFromRow(row.OrgID, row.Name, row.Reference, row.Digest, row.Descriptor, row.Layer, row.UpdatePolicy, row.AcceptedAuthority, updateColumns{row.PendingReference, row.PendingDigest, row.PreviousReference, row.PreviousDigest, row.PendingAuthority, row.PreviousAcceptedAuthority})
|
|
}
|
|
|
|
func (s *InstalledPackages) List(ctx context.Context, orgID string) ([]storepkg.Installed, error) {
|
|
rows, err := postgresdb.New(s.pool).ListInstalledPackages(ctx, orgID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
packages := make([]storepkg.Installed, 0, len(rows))
|
|
for _, row := range rows {
|
|
p, err := installedFromRow(row.OrgID, row.Name, row.Reference, row.Digest, row.Descriptor, row.Layer, row.UpdatePolicy, row.AcceptedAuthority, updateColumns{row.PendingReference, row.PendingDigest, row.PreviousReference, row.PreviousDigest, row.PendingAuthority, row.PreviousAcceptedAuthority})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
packages = append(packages, p)
|
|
}
|
|
return packages, nil
|
|
}
|
|
|
|
func (s *InstalledPackages) Remove(ctx context.Context, orgID, name string) error {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockInstalledPackages(ctx, orgID); err != nil {
|
|
return err
|
|
}
|
|
current, err := getInstalledRow(ctx, q, orgID, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rows, err := q.DeleteInstalledPackage(ctx, postgresdb.DeleteInstalledPackageParams{OrgID: orgID, Name: name})
|
|
if pgCode(err) == "23001" {
|
|
return storepkg.ErrRequired
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rows == 0 {
|
|
return storepkg.ErrNotFound
|
|
}
|
|
if err := auditPackage(ctx, q, orgID, name, "remove",
|
|
&packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy}, nil); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
func (s *InstalledPackages) Accept(ctx context.Context, orgID, name string, authority storepkg.Authority) error {
|
|
if orgID == "" || name == "" {
|
|
return errors.New("org and name are required")
|
|
}
|
|
if err := authority.Validate(); err != nil {
|
|
return fmt.Errorf("accepted authority: %w", err)
|
|
}
|
|
encoded, err := json.Marshal(authority)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockInstalledPackages(ctx, orgID); err != nil {
|
|
return err
|
|
}
|
|
current, err := getInstalledRow(ctx, q, orgID, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rows, err := q.AcceptInstalledPackageAuthority(ctx, postgresdb.AcceptInstalledPackageAuthorityParams{
|
|
OrgID: orgID, Name: name, AcceptedAuthority: encoded,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rows == 0 {
|
|
return storepkg.ErrNotFound
|
|
}
|
|
if err := insertAudit(ctx, q, "installed_packages", name, "accept_authority",
|
|
current.AcceptedAuthority, encoded, 0, orgID); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// updateColumns are the nullable pending and previous pin columns of a row.
|
|
type updateColumns struct {
|
|
pendingReference, pendingDigest, previousReference, previousDigest pgtype.Text
|
|
pendingAuthority, previousAccepted []byte
|
|
}
|
|
|
|
func pinOf(reference, digest pgtype.Text) *storepkg.Pin {
|
|
if !reference.Valid || !digest.Valid {
|
|
return nil
|
|
}
|
|
return &storepkg.Pin{Reference: reference.String, Digest: digest.String}
|
|
}
|
|
|
|
func (s *InstalledPackages) SetPending(ctx context.Context, orgID, name string, pending storepkg.Pin, declared storepkg.Authority) error {
|
|
encoded, err := json.Marshal(declared)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockInstalledPackages(ctx, orgID); err != nil {
|
|
return err
|
|
}
|
|
current, err := getInstalledRow(ctx, q, orgID, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rows, err := q.SetInstalledPackagePending(ctx, postgresdb.SetInstalledPackagePendingParams{
|
|
OrgID: orgID, Name: name, PendingReference: pgtype.Text{String: pending.Reference, Valid: true}, PendingDigest: pgtype.Text{String: pending.Digest, Valid: true}, PendingAuthority: encoded,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rows == 0 {
|
|
return storepkg.ErrNotFound
|
|
}
|
|
// The declared authority is recorded here because this is the only place
|
|
// it is known before approval.
|
|
if err := auditPackage(ctx, q, orgID, name, "update",
|
|
&packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy},
|
|
&packageAuditValue{Reference: pending.Reference, Digest: pending.Digest, UpdatePolicy: current.UpdatePolicy, Pending: true, Authority: encoded}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// Replace swaps the live pin under the org's package lock. Another package
|
|
// pinning this one's digest, or a requirement the new descriptor cannot
|
|
// meet, refuses the swap. action names the operation in the audit trail.
|
|
func (s *InstalledPackages) Replace(ctx context.Context, p storepkg.Installed, action string) error {
|
|
if err := p.Descriptor.Validate(); err != nil {
|
|
return err
|
|
}
|
|
descriptor, err := json.Marshal(p.Descriptor)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
var accepted []byte
|
|
if p.AcceptedAuthority != nil {
|
|
if accepted, err = json.Marshal(p.AcceptedAuthority); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockInstalledPackages(ctx, p.OrgID); err != nil {
|
|
return err
|
|
}
|
|
current, err := getInstalledRow(ctx, q, p.OrgID, p.Name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
dependents, err := q.CountInstalledDependents(ctx, postgresdb.CountInstalledDependentsParams{OrgID: p.OrgID, RequiredName: p.Name})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if dependents > 0 {
|
|
return storepkg.ErrRequired
|
|
}
|
|
if err := checkInstalledRequirements(ctx, q, p); err != nil {
|
|
return err
|
|
}
|
|
rows, err := q.ReplaceInstalledPackage(ctx, postgresdb.ReplaceInstalledPackageParams{
|
|
OrgID: p.OrgID, Name: p.Name, Reference: p.Reference, Digest: p.Digest,
|
|
Descriptor: descriptor, Layer: p.Layer, AcceptedAuthority: accepted,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rows == 0 {
|
|
return storepkg.ErrNotFound
|
|
}
|
|
if err := replaceInstalledRequirements(ctx, q, p); err != nil {
|
|
return err
|
|
}
|
|
// Approvals and rollbacks change the accepted authority as well as the pin.
|
|
if err := auditReplace(ctx, q, p, current, accepted, action); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// auditReplace records the pin swap, and for the actions that also change the
|
|
// accepted authority, that change as its own row. Both rows share the
|
|
// transaction's timestamp, so the read model groups them as one change set.
|
|
func auditReplace(ctx context.Context, q *postgresdb.Queries, p storepkg.Installed, current postgresdb.GetInstalledPackageRow, accepted []byte, action string) error {
|
|
if err := auditPackage(ctx, q, p.OrgID, p.Name, action,
|
|
&packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy, Pending: current.PendingDigest.Valid},
|
|
&packageAuditValue{Reference: p.Reference, Digest: p.Digest, UpdatePolicy: current.UpdatePolicy}); err != nil {
|
|
return err
|
|
}
|
|
if action != storepkg.ActionApproveUpdate && action != storepkg.ActionRollback {
|
|
return nil
|
|
}
|
|
// An unchanged authority, including none at all, is not an approval.
|
|
if bytes.Equal(current.AcceptedAuthority, accepted) {
|
|
return nil
|
|
}
|
|
return insertAudit(ctx, q, "installed_packages", p.Name, "accept_authority", current.AcceptedAuthority, accepted, 0, p.OrgID)
|
|
}
|
|
|
|
// replaceInstalledRequirements rebuilds p's requirement edges.
|
|
func replaceInstalledRequirements(ctx context.Context, q *postgresdb.Queries, p storepkg.Installed) error {
|
|
if err := q.DeleteInstalledRequirements(ctx, postgresdb.DeleteInstalledRequirementsParams{OrgID: p.OrgID, PackageName: p.Name}); err != nil {
|
|
return err
|
|
}
|
|
return insertInstalledRequirements(ctx, q, p)
|
|
}
|
|
|
|
func installedFromRow(orgID, name, reference, digest string, raw, layer []byte, updatePolicy string, accepted []byte, update updateColumns) (storepkg.Installed, error) {
|
|
var descriptor storepkg.Descriptor
|
|
if err := json.Unmarshal(raw, &descriptor); err != nil {
|
|
return storepkg.Installed{}, fmt.Errorf("decode installed package: %w", err)
|
|
}
|
|
authority, err := acceptedFromRow(accepted)
|
|
if err != nil {
|
|
return storepkg.Installed{}, err
|
|
}
|
|
pendingAuthority, err := acceptedFromRow(update.pendingAuthority)
|
|
if err != nil {
|
|
return storepkg.Installed{}, err
|
|
}
|
|
previousAccepted, err := acceptedFromRow(update.previousAccepted)
|
|
if err != nil {
|
|
return storepkg.Installed{}, err
|
|
}
|
|
return storepkg.Installed{
|
|
OrgID: orgID, Name: name, Reference: reference, Digest: digest, Descriptor: descriptor, Layer: layer,
|
|
UpdatePolicy: updatePolicy, AcceptedAuthority: authority,
|
|
Pending: pinOf(update.pendingReference, update.pendingDigest), PendingAuthority: pendingAuthority,
|
|
Previous: pinOf(update.previousReference, update.previousDigest), PreviousAccepted: previousAccepted,
|
|
}, nil
|
|
}
|
|
|
|
func acceptedFromRow(raw []byte) (*storepkg.Authority, error) {
|
|
if len(raw) == 0 {
|
|
return nil, nil
|
|
}
|
|
var authority storepkg.Authority
|
|
if err := json.Unmarshal(raw, &authority); err != nil {
|
|
return nil, fmt.Errorf("decode accepted authority: %w", err)
|
|
}
|
|
return &authority, nil
|
|
}
|
|
|
|
func pgCode(err error) string {
|
|
if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok {
|
|
return pgErr.Code
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (s *InstalledPackages) SetUpdatePolicy(ctx context.Context, orgID, name, policy string) error {
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
if err := q.LockInstalledPackages(ctx, orgID); err != nil {
|
|
return err
|
|
}
|
|
current, err := getInstalledRow(ctx, q, orgID, name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rows, err := q.SetInstalledPackageUpdatePolicy(ctx, postgresdb.SetInstalledPackageUpdatePolicyParams{
|
|
OrgID: orgID, Name: name, UpdatePolicy: policy,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if rows == 0 {
|
|
return storepkg.ErrNotFound
|
|
}
|
|
if err := auditPackage(ctx, q, orgID, name, "update_policy",
|
|
&packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: current.UpdatePolicy},
|
|
&packageAuditValue{Reference: current.Reference, Digest: current.Digest, UpdatePolicy: policy}); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
func (s *InstalledPackages) ListAutoUpdate(ctx context.Context) ([]storepkg.OrgPackage, error) {
|
|
rows, err := postgresdb.New(s.pool).ListAutoUpdateInstalledPackages(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
refs := make([]storepkg.OrgPackage, 0, len(rows))
|
|
for _, row := range rows {
|
|
refs = append(refs, storepkg.OrgPackage{OrgID: row.OrgID, Name: row.Name})
|
|
}
|
|
return refs, nil
|
|
}
|