Files
archie/internal/infrastructure/postgres/installed_packages.go
T
sam bf68866dca feat(store): record accepted package authority against the pin
An archie package declares its authority; nothing in the tree recorded the
operator's acceptance of it. This lands the acceptance-record slice of
docs/prds/store.md ("Authority"):

- storepkg.Authority gains Covers (the upper-bound predicate: equal or
  narrower applies, wider does not) and Validate (forge-permission
  vocabulary, no blank grants).
- Installed carries AcceptedAuthority (nil until accepted); install leaves it
  unset, so an unaccepted package has no authority.
- AcceptPackageAuthority on the storepkg Manager records the acceptance
  against the pinned digest and refuses grants the package does not declare
  (storepkg.ErrAuthorityNotDeclared), carried over the wire.
- staterpc gains the admin-only AcceptPackageAuthority RPC;
  InstalledPackage carries accepted_authority.
2026-09-30 07:40:06 +10:00

193 lines
5.9 KiB
Go

package postgres
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"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
}
return tx.Commit(ctx)
}
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)
}
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)
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
}
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
}
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
}
rows, err := postgresdb.New(s.pool).AcceptInstalledPackageAuthority(ctx, postgresdb.AcceptInstalledPackageAuthorityParams{
OrgID: orgID, Name: name, AcceptedAuthority: encoded,
})
if err != nil {
return err
}
if rows == 0 {
return storepkg.ErrNotFound
}
return nil
}
func installedFromRow(orgID, name, reference, digest string, raw, layer []byte, updatePolicy string, accepted []byte) (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
}
return storepkg.Installed{OrgID: orgID, Name: name, Reference: reference, Digest: digest, Descriptor: descriptor, Layer: layer, UpdatePolicy: updatePolicy, AcceptedAuthority: authority}, 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 ""
}