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 }