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.
This commit is contained in:
sam committed 2026-09-30 07:40:06 +10:00
1 parent 92ab327475
commit af25fea427
16 files changed
+1144 -377

No files matched your search

File diff suppressed because it is too large. Load diff
@@ -22,6 +22,7 @@ const (
StateStoreService_InstallPackage_FullMethodName = "/state.v1.StateStoreService/InstallPackage"
StateStoreService_GetInstalledPackage_FullMethodName = "/state.v1.StateStoreService/GetInstalledPackage"
StateStoreService_ListInstalledPackages_FullMethodName = "/state.v1.StateStoreService/ListInstalledPackages"
StateStoreService_AcceptPackageAuthority_FullMethodName = "/state.v1.StateStoreService/AcceptPackageAuthority"
StateStoreService_RemoveInstalledPackage_FullMethodName = "/state.v1.StateStoreService/RemoveInstalledPackage"
StateStoreService_RegisterTaskGrant_FullMethodName = "/state.v1.StateStoreService/RegisterTaskGrant"
StateStoreService_RevokeTaskGrant_FullMethodName = "/state.v1.StateStoreService/RevokeTaskGrant"
@@ -131,6 +132,10 @@ type StateStoreServiceClient interface {
InstallPackage(ctx context.Context, in *InstallPackageRequest, opts ...grpc.CallOption) (*InstallPackageResponse, error)
GetInstalledPackage(ctx context.Context, in *GetInstalledPackageRequest, opts ...grpc.CallOption) (*GetInstalledPackageResponse, error)
ListInstalledPackages(ctx context.Context, in *ListInstalledPackagesRequest, opts ...grpc.CallOption) (*ListInstalledPackagesResponse, error)
// AcceptPackageAuthority records the operator's accepted authority against
// the pinned digest (the approve action; install is the create action).
// Administrative until org-scoped principals land.
AcceptPackageAuthority(ctx context.Context, in *AcceptPackageAuthorityRequest, opts ...grpc.CallOption) (*AcceptPackageAuthorityResponse, error)
RemoveInstalledPackage(ctx context.Context, in *RemoveInstalledPackageRequest, opts ...grpc.CallOption) (*RemoveInstalledPackageResponse, error)
// Administrative task credential lifecycle. Worker credentials cannot call these.
RegisterTaskGrant(ctx context.Context, in *RegisterTaskGrantRequest, opts ...grpc.CallOption) (*RegisterTaskGrantResponse, error)
@@ -335,6 +340,16 @@ func (c *stateStoreServiceClient) ListInstalledPackages(ctx context.Context, in
return out, nil
}
func (c *stateStoreServiceClient) AcceptPackageAuthority(ctx context.Context, in *AcceptPackageAuthorityRequest, opts ...grpc.CallOption) (*AcceptPackageAuthorityResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(AcceptPackageAuthorityResponse)
err := c.cc.Invoke(ctx, StateStoreService_AcceptPackageAuthority_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *stateStoreServiceClient) RemoveInstalledPackage(ctx context.Context, in *RemoveInstalledPackageRequest, opts ...grpc.CallOption) (*RemoveInstalledPackageResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(RemoveInstalledPackageResponse)
@@ -1288,6 +1303,10 @@ type StateStoreServiceServer interface {
InstallPackage(context.Context, *InstallPackageRequest) (*InstallPackageResponse, error)
GetInstalledPackage(context.Context, *GetInstalledPackageRequest) (*GetInstalledPackageResponse, error)
ListInstalledPackages(context.Context, *ListInstalledPackagesRequest) (*ListInstalledPackagesResponse, error)
// AcceptPackageAuthority records the operator's accepted authority against
// the pinned digest (the approve action; install is the create action).
// Administrative until org-scoped principals land.
AcceptPackageAuthority(context.Context, *AcceptPackageAuthorityRequest) (*AcceptPackageAuthorityResponse, error)
RemoveInstalledPackage(context.Context, *RemoveInstalledPackageRequest) (*RemoveInstalledPackageResponse, error)
// Administrative task credential lifecycle. Worker credentials cannot call these.
RegisterTaskGrant(context.Context, *RegisterTaskGrantRequest) (*RegisterTaskGrantResponse, error)
@@ -1471,6 +1490,9 @@ func (UnimplementedStateStoreServiceServer) GetInstalledPackage(context.Context,
func (UnimplementedStateStoreServiceServer) ListInstalledPackages(context.Context, *ListInstalledPackagesRequest) (*ListInstalledPackagesResponse, error) {
return nil, status.Error(codes.Unimplemented, "method ListInstalledPackages not implemented")
}
func (UnimplementedStateStoreServiceServer) AcceptPackageAuthority(context.Context, *AcceptPackageAuthorityRequest) (*AcceptPackageAuthorityResponse, error) {
return nil, status.Error(codes.Unimplemented, "method AcceptPackageAuthority not implemented")
}
func (UnimplementedStateStoreServiceServer) RemoveInstalledPackage(context.Context, *RemoveInstalledPackageRequest) (*RemoveInstalledPackageResponse, error) {
return nil, status.Error(codes.Unimplemented, "method RemoveInstalledPackage not implemented")
}
@@ -1819,6 +1841,24 @@ func _StateStoreService_ListInstalledPackages_Handler(srv interface{}, ctx conte
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_AcceptPackageAuthority_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(AcceptPackageAuthorityRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StateStoreServiceServer).AcceptPackageAuthority(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: StateStoreService_AcceptPackageAuthority_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StateStoreServiceServer).AcceptPackageAuthority(ctx, req.(*AcceptPackageAuthorityRequest))
}
return interceptor(ctx, in, info, handler)
}
func _StateStoreService_RemoveInstalledPackage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(RemoveInstalledPackageRequest)
if err := dec(in); err != nil {
@@ -3455,6 +3495,10 @@ var StateStoreService_ServiceDesc = grpc.ServiceDesc{
MethodName: "ListInstalledPackages",
Handler: _StateStoreService_ListInstalledPackages_Handler,
},
{
MethodName: "AcceptPackageAuthority",
Handler: _StateStoreService_AcceptPackageAuthority_Handler,
},
{
MethodName: "RemoveInstalledPackage",
Handler: _StateStoreService_RemoveInstalledPackage_Handler,
+59
View File
@@ -0,0 +1,59 @@
package storepkg
import (
"fmt"
"strings"
)
// Covers reports whether accepted authority is an upper bound of the
// requested authority: every grant the request asks for is one the accepted
// record grants, per field, never across fields. The acceptance record and
// the update-widening check share this predicate (docs/prds/store.md,
// "Authority": an update whose authority is equal or narrower applies).
func (a Authority) Covers(b Authority) bool {
return listCovers(a.CredentialServices, b.CredentialServices) &&
listCovers(a.EgressHosts, b.EgressHosts) &&
listCovers(a.ForgePermissions, b.ForgePermissions) &&
listCovers(a.Triggers, b.Triggers) &&
listCovers(a.Tools, b.Tools)
}
func listCovers(have, want []string) bool {
granted := make(map[string]struct{}, len(have))
for _, grant := range have {
granted[grant] = struct{}{}
}
for _, grant := range want {
if _, ok := granted[grant]; !ok {
return false
}
}
return true
}
// Validate checks authority grant values: forge permissions use the
// descriptor's vocabulary and every grant list rejects blank entries.
func (a Authority) Validate() error {
for _, permission := range a.ForgePermissions {
if !validForgePermission(permission) {
return fmt.Errorf("invalid forge permission %q", permission)
}
}
fields := []struct {
name string
grants []string
}{
{name: "credential service", grants: a.CredentialServices},
{name: "egress host", grants: a.EgressHosts},
{name: "trigger", grants: a.Triggers},
{name: "tool", grants: a.Tools},
}
for _, field := range fields {
for i, grant := range field.grants {
if strings.TrimSpace(grant) == "" {
return fmt.Errorf("%s %d: name is required", field.name, i)
}
}
}
return nil
}
+100
View File
@@ -0,0 +1,100 @@
package storepkg
import "testing"
func TestAuthorityCovers(t *testing.T) {
tests := []struct {
name string
have Authority
want Authority
covers bool
}{
{
name: "equal authority covers itself",
have: Authority{ForgePermissions: []string{"read", "comment"}, Tools: []string{"shell"}},
want: Authority{ForgePermissions: []string{"comment", "read"}, Tools: []string{"shell"}},
covers: true,
},
{
name: "wider accepted authority covers the narrower request",
have: Authority{ForgePermissions: []string{"read", "comment", "review"}},
want: Authority{ForgePermissions: []string{"read"}},
covers: true,
},
{
name: "an update asking for a forge permission the record lacks is wider",
have: Authority{ForgePermissions: []string{"read"}},
want: Authority{ForgePermissions: []string{"read", "push"}},
covers: false,
},
{
name: "grants are never interchangeable across fields",
have: Authority{Tools: []string{"registry"}},
want: Authority{CredentialServices: []string{"registry"}},
covers: false,
},
{
name: "coverage is checked along every field",
have: Authority{
CredentialServices: []string{"github"},
EgressHosts: []string{"api.github.com"},
ForgePermissions: []string{"read"},
Triggers: []string{"repo/archie-core:pull_request"},
Tools: []string{"shell"},
},
want: Authority{
CredentialServices: []string{"github"},
EgressHosts: []string{"internal.invalid"},
},
covers: false,
},
{
name: "nothing accepted covers nothing requested",
have: Authority{},
want: Authority{},
covers: true,
},
{
name: "an empty accepted record covers any request at all",
have: Authority{},
want: Authority{Tools: []string{"shell"}},
covers: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := tt.have.Covers(tt.want); got != tt.covers {
t.Fatalf("Covers = %v, want %v", got, tt.covers)
}
})
}
}
func TestAuthorityValidate(t *testing.T) {
tests := []struct {
name string
authority Authority
wantErr string
}{
{name: "valid authority", authority: Authority{ForgePermissions: []string{"read"}, Tools: []string{"shell"}}},
{name: "invalid forge permission", authority: Authority{ForgePermissions: []string{"admin"}}, wantErr: `invalid forge permission "admin"`},
{name: "blank credential service", authority: Authority{CredentialServices: []string{" "}}, wantErr: "credential service 0: name is required"},
{name: "blank egress host", authority: Authority{EgressHosts: []string{""}}, wantErr: "egress host 0: name is required"},
{name: "blank trigger", authority: Authority{Triggers: []string{""}}, wantErr: "trigger 0: name is required"},
{name: "blank tool", authority: Authority{Tools: []string{""}}, wantErr: "tool 0: name is required"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := tt.authority.Validate()
if tt.wantErr == "" {
if err != nil {
t.Fatalf("Validate = %v, want nil", err)
}
return
}
if err == nil || err.Error() != tt.wantErr {
t.Fatalf("Validate = %v, want %q", err, tt.wantErr)
}
})
}
}
+37
View File
@@ -11,6 +11,11 @@ var (
ErrNotFound = errors.New("store package not found")
ErrInstalled = errors.New("store package already installed")
ErrRequired = errors.New("store package is required by another installed package")
// ErrAuthorityNotDeclared: the operator asked to accept authority the
// package itself does not declare, which is not an acceptance of that
// package. Acceptance records the package's own declared grants against
// the pinned digest (docs/prds/store.md, "Authority").
ErrAuthorityNotDeclared = errors.New("store package does not declare this authority")
)
// Installed is one organisation's pinned Archie package.
@@ -22,6 +27,10 @@ type Installed struct {
Descriptor Descriptor
Layer []byte
UpdatePolicy string
// AcceptedAuthority is the operator's acceptance, recorded against the
// pinned digest. A nil Authority means the operator has not accepted;
// until then the package's authority at use time is nothing.
AcceptedAuthority *Authority
}
// Repository owns installed package records and dependency-safe deletion.
@@ -30,6 +39,9 @@ type Repository interface {
Get(context.Context, string, string) (Installed, error)
List(context.Context, string) ([]Installed, error)
Remove(context.Context, string, string) error
// Accept records the operator's accepted authority against the package's
// currently pinned digest.
Accept(context.Context, string, string, Authority) error
}
// Registry reads a package by immutable OCI manifest digest.
@@ -43,6 +55,7 @@ type Manager interface {
GetInstalled(context.Context, string, string) (Installed, error)
ListInstalled(context.Context, string) ([]Installed, error)
RemoveInstalled(context.Context, string, string) error
AcceptPackageAuthority(ctx context.Context, orgID, name string, accepted Authority) (Installed, error)
}
// Service validates the registry content before persisting an installation.
@@ -69,6 +82,30 @@ func (s Service) RemoveInstalled(ctx context.Context, orgID, name string) error
return s.Remove(ctx, orgID, name)
}
// AcceptPackageAuthority records the operator's acceptance against the pinned
// digest. Only grants the package declares are acceptable, and the accepted
// record may be narrower than the declaration: the record, not the descriptor,
// is the authority the package is later checked against.
func (s Service) AcceptPackageAuthority(ctx context.Context, orgID, name string, accepted Authority) (Installed, error) {
if strings.TrimSpace(orgID) == "" || strings.TrimSpace(name) == "" {
return Installed{}, errors.New("org and name are required")
}
if err := accepted.Validate(); err != nil {
return Installed{}, fmt.Errorf("accepted authority: %w", err)
}
installed, err := s.Store.Get(ctx, orgID, name)
if err != nil {
return Installed{}, fmt.Errorf("installed package %q: %w", name, err)
}
if !installed.Descriptor.Authority.Covers(accepted) {
return Installed{}, fmt.Errorf("package %q: %w", name, ErrAuthorityNotDeclared)
}
if err := s.Store.Accept(ctx, orgID, name, accepted); err != nil {
return Installed{}, err
}
return s.Store.Get(ctx, orgID, name)
}
func (s Service) Install(ctx context.Context, orgID, name, reference, digest string) (Installed, error) {
if strings.TrimSpace(orgID) == "" || strings.TrimSpace(name) == "" || strings.TrimSpace(reference) == "" {
return Installed{}, errors.New("org, name and reference are required")
@@ -57,6 +57,17 @@ func (s *fakeInstalledStore) Remove(_ context.Context, org, name string) error {
return nil
}
func (s *fakeInstalledStore) Accept(_ context.Context, org, name string, authority Authority) error {
record, ok := s.records[org+"/"+name]
if !ok {
return ErrNotFound
}
accepted := authority
record.AcceptedAuthority = &accepted
s.records[org+"/"+name] = record
return nil
}
func TestServiceInstall(t *testing.T) {
ctx := context.Background()
valid, err := Decode(strings.NewReader(validDescriptor))
@@ -101,6 +112,73 @@ func TestServiceInstall(t *testing.T) {
}
}
func TestServiceAcceptPackageAuthority(t *testing.T) {
ctx := context.Background()
declared, err := Decode(strings.NewReader(validDescriptor))
if err != nil {
t.Fatal(err)
}
declared.Authority = Authority{ForgePermissions: []string{"read", "comment"}, Tools: []string{"shell"}}
declared.Requires = nil
install := func(t *testing.T) (Service, *fakeInstalledStore) {
t.Helper()
store := &fakeInstalledStore{records: map[string]Installed{}}
svc := Service{Registry: &fakeRegistry{descriptor: declared}, Store: store}
if _, err := svc.Install(ctx, "org-a", "review", "localhost:5000/review", "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); err != nil {
t.Fatal(err)
}
return svc, store
}
t.Run("records the accepted authority against the pin", func(t *testing.T) {
svc, store := install(t)
accepted := Authority{ForgePermissions: []string{"read"}}
record, err := svc.AcceptPackageAuthority(ctx, "org-a", "review", accepted)
if err != nil {
t.Fatal(err)
}
if record.AcceptedAuthority == nil || !record.AcceptedAuthority.Covers(accepted) {
t.Fatalf("accepted record = %#v", record.AcceptedAuthority)
}
stored, err := store.Get(ctx, "org-a", "review")
if err != nil || stored.AcceptedAuthority == nil || !stored.AcceptedAuthority.Covers(accepted) {
t.Fatalf("stored record = %#v, %v", stored.AcceptedAuthority, err)
}
// The acceptance record is the bound the package is later checked
// against: the operator accepted a narrowed set, so the package's full
// declaration now exceeds the accepted authority.
if record.AcceptedAuthority.Covers(declared.Authority) {
t.Fatal("accepted record covers authority the operator did not accept")
}
})
t.Run("refuses grants the package does not declare", func(t *testing.T) {
svc, store := install(t)
_, err := svc.AcceptPackageAuthority(ctx, "org-a", "review", Authority{EgressHosts: []string{"internal.invalid"}})
if !errors.Is(err, ErrAuthorityNotDeclared) {
t.Fatalf("undeclared grant error = %v", err)
}
stored, err := store.Get(ctx, "org-a", "review")
if err != nil || stored.AcceptedAuthority != nil {
t.Fatalf("refused acceptance changed the record: %#v, %v", stored.AcceptedAuthority, err)
}
})
t.Run("refuses an acceptance nothing installed", func(t *testing.T) {
svc, _ := install(t)
if _, err := svc.AcceptPackageAuthority(ctx, "org-a", "missing", Authority{}); !errors.Is(err, ErrNotFound) {
t.Fatalf("unknown package error = %v", err)
}
})
t.Run("rejects an invalid acceptance", func(t *testing.T) {
svc, store := install(t)
if _, err := svc.AcceptPackageAuthority(ctx, "org-a", "review", Authority{ForgePermissions: []string{"admin"}}); err == nil {
t.Fatal("invalid forge permission accepted")
}
stored, err := store.Get(ctx, "org-a", "review")
if err != nil || stored.AcceptedAuthority != nil {
t.Fatalf("rejected acceptance changed the record: %#v, %v", stored.AcceptedAuthority, err)
}
})
}
func TestServiceInstallRequiresPinnedDependency(t *testing.T) {
ctx := context.Background()
valid, err := Decode(strings.NewReader(validDescriptor))
@@ -96,7 +96,7 @@ func (s *InstalledPackages) Get(ctx context.Context, orgID, name string) (storep
if err != nil {
return storepkg.Installed{}, err
}
return installedFromRow(row.OrgID, row.Name, row.Reference, row.Digest, row.Descriptor, row.Layer, row.UpdatePolicy)
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) {
@@ -106,7 +106,7 @@ func (s *InstalledPackages) List(ctx context.Context, orgID string) ([]storepkg.
}
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)
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
}
@@ -138,12 +138,50 @@ func (s *InstalledPackages) Remove(ctx context.Context, orgID, name string) erro
return tx.Commit(ctx)
}
func installedFromRow(orgID, name, reference, digest string, raw, layer []byte, updatePolicy string) (storepkg.Installed, error) {
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)
}
return storepkg.Installed{OrgID: orgID, Name: name, Reference: reference, Digest: digest, Descriptor: descriptor, Layer: layer, UpdatePolicy: updatePolicy}, nil
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 {
@@ -0,0 +1,8 @@
-- +goose Up
-- The operator's accepted authority, recorded against the pinned digest. NULL
-- until the operator accepts; NULL is also the correct value for existing
-- rows, which were installed before acceptance records existed.
ALTER TABLE installed_packages ADD COLUMN accepted_authority jsonb;
-- +goose Down
ALTER TABLE installed_packages DROP COLUMN accepted_authority;
@@ -9,6 +9,25 @@ import (
"context"
)
const acceptInstalledPackageAuthority = `-- name: AcceptInstalledPackageAuthority :execrows
UPDATE installed_packages SET accepted_authority = $3
WHERE org_id = $1 AND name = $2
`
type AcceptInstalledPackageAuthorityParams struct {
OrgID string
Name string
AcceptedAuthority []byte
}
func (q *Queries) AcceptInstalledPackageAuthority(ctx context.Context, arg AcceptInstalledPackageAuthorityParams) (int64, error) {
result, err := q.db.Exec(ctx, acceptInstalledPackageAuthority, arg.OrgID, arg.Name, arg.AcceptedAuthority)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const deleteInstalledPackage = `-- name: DeleteInstalledPackage :execrows
DELETE FROM installed_packages WHERE org_id = $1 AND name = $2
`
@@ -27,7 +46,7 @@ func (q *Queries) DeleteInstalledPackage(ctx context.Context, arg DeleteInstalle
}
const getInstalledPackage = `-- name: GetInstalledPackage :one
SELECT org_id, name, reference, digest, descriptor, layer, update_policy
SELECT org_id, name, reference, digest, descriptor, layer, update_policy, accepted_authority
FROM installed_packages WHERE org_id = $1 AND name = $2
`
@@ -37,13 +56,14 @@ type GetInstalledPackageParams struct {
}
type GetInstalledPackageRow struct {
OrgID string
Name string
Reference string
Digest string
Descriptor []byte
Layer []byte
UpdatePolicy string
OrgID string
Name string
Reference string
Digest string
Descriptor []byte
Layer []byte
UpdatePolicy string
AcceptedAuthority []byte
}
func (q *Queries) GetInstalledPackage(ctx context.Context, arg GetInstalledPackageParams) (GetInstalledPackageRow, error) {
@@ -57,6 +77,7 @@ func (q *Queries) GetInstalledPackage(ctx context.Context, arg GetInstalledPacka
&i.Descriptor,
&i.Layer,
&i.UpdatePolicy,
&i.AcceptedAuthority,
)
return i, err
}
@@ -130,18 +151,19 @@ func (q *Queries) InsertInstalledRequirement(ctx context.Context, arg InsertInst
}
const listInstalledPackages = `-- name: ListInstalledPackages :many
SELECT org_id, name, reference, digest, descriptor, layer, update_policy
SELECT org_id, name, reference, digest, descriptor, layer, update_policy, accepted_authority
FROM installed_packages WHERE org_id = $1 ORDER BY name
`
type ListInstalledPackagesRow struct {
OrgID string
Name string
Reference string
Digest string
Descriptor []byte
Layer []byte
UpdatePolicy string
OrgID string
Name string
Reference string
Digest string
Descriptor []byte
Layer []byte
UpdatePolicy string
AcceptedAuthority []byte
}
func (q *Queries) ListInstalledPackages(ctx context.Context, orgID string) ([]ListInstalledPackagesRow, error) {
@@ -161,6 +183,7 @@ func (q *Queries) ListInstalledPackages(ctx context.Context, orgID string) ([]Li
&i.Descriptor,
&i.Layer,
&i.UpdatePolicy,
&i.AcceptedAuthority,
); err != nil {
return nil, err
}
@@ -186,14 +186,15 @@ type IdentitySubject struct {
}
type InstalledPackage struct {
OrgID string
Name string
Reference string
Digest string
Descriptor []byte
Layer []byte
UpdatePolicy string
InstalledAt time.Time
OrgID string
Name string
Reference string
Digest string
Descriptor []byte
Layer []byte
UpdatePolicy string
InstalledAt time.Time
AcceptedAuthority []byte
}
type InstalledPackageRequirement struct {
@@ -10,13 +10,17 @@ INSERT INTO installed_package_requirements (org_id, package_name, required_name,
VALUES ($1, $2, $3, $4);
-- name: GetInstalledPackage :one
SELECT org_id, name, reference, digest, descriptor, layer, update_policy
SELECT org_id, name, reference, digest, descriptor, layer, update_policy, accepted_authority
FROM installed_packages WHERE org_id = $1 AND name = $2;
-- name: ListInstalledPackages :many
SELECT org_id, name, reference, digest, descriptor, layer, update_policy
SELECT org_id, name, reference, digest, descriptor, layer, update_policy, accepted_authority
FROM installed_packages WHERE org_id = $1 ORDER BY name;
-- name: AcceptInstalledPackageAuthority :execrows
UPDATE installed_packages SET accepted_authority = $3
WHERE org_id = $1 AND name = $2;
-- name: DeleteInstalledPackage :execrows
DELETE FROM installed_packages WHERE org_id = $1 AND name = $2;
@@ -10,6 +10,7 @@ import (
"google.golang.org/grpc/status"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/storepkg"
)
// TestUnmapErrorPreservesContextIdentity pins the §6 deadline contract that
@@ -86,6 +87,7 @@ func TestUnmapErrorSentinelFidelity(t *testing.T) {
{name: "already dispatched", store: storecontract.ErrAlreadyDispatched, rehyd: storecontract.ErrAlreadyDispatched},
{name: "source not found", store: storecontract.ErrSourceNotFound, rehyd: storecontract.ErrSourceNotFound},
{name: "source path taken", store: storecontract.ErrSourcePathTaken, rehyd: storecontract.ErrSourcePathTaken},
{name: "package authority not declared", store: storepkg.ErrAuthorityNotDeclared, rehyd: storepkg.ErrAuthorityNotDeclared},
{name: "source signing stale", store: storecontract.ErrSourceSigningStale, rehyd: storecontract.ErrSourceSigningStale},
}
for _, tt := range tests {
+56 -1
View File
@@ -48,6 +48,17 @@ func (s *server) ListInstalledPackages(ctx context.Context, request *pb.ListInst
return result, nil
}
func (s *server) AcceptPackageAuthority(ctx context.Context, request *pb.AcceptPackageAuthorityRequest) (*pb.AcceptPackageAuthorityResponse, error) {
if s.deps.Packages == nil {
return nil, status.Error(codes.Unavailable, "package store unavailable")
}
p, err := s.deps.Packages.AcceptPackageAuthority(ctx, request.GetOrgId(), request.GetName(), authorityValue(request.GetAccepted()))
if err != nil {
return nil, s.logErr("AcceptPackageAuthority", err)
}
return &pb.AcceptPackageAuthorityResponse{Package: packageProto(p, true)}, nil
}
func (s *server) RemoveInstalledPackage(ctx context.Context, request *pb.RemoveInstalledPackageRequest) (*pb.RemoveInstalledPackageResponse, error) {
if s.deps.Packages == nil {
return nil, status.Error(codes.Unavailable, "package store unavailable")
@@ -95,18 +106,54 @@ func (c *Client) RemoveInstalled(ctx context.Context, orgID, name string) error
return unmapError(err)
}
func (c *Client) AcceptPackageAuthority(ctx context.Context, orgID, name string, accepted storepkg.Authority) (storepkg.Installed, error) {
response, err := c.client.AcceptPackageAuthority(ctx, &pb.AcceptPackageAuthorityRequest{
OrgId: orgID, Name: name, Accepted: authorityProto(accepted),
})
if err != nil {
return storepkg.Installed{}, unmapError(err)
}
return packageValue(response.GetPackage())
}
func packageProto(p storepkg.Installed, includeLayer bool) *pb.InstalledPackage {
descriptor, _ := json.Marshal(p.Descriptor)
value := &pb.InstalledPackage{
OrgId: p.OrgID, Name: p.Name, Reference: p.Reference, Digest: p.Digest,
DescriptorJson: descriptor, UpdatePolicy: p.UpdatePolicy,
}
if p.AcceptedAuthority != nil {
value.AcceptedAuthority = authorityProto(*p.AcceptedAuthority)
}
if includeLayer {
value.Layer = p.Layer
}
return value
}
func authorityProto(a storepkg.Authority) *pb.PackageAuthority {
return &pb.PackageAuthority{
CredentialServices: a.CredentialServices,
EgressHosts: a.EgressHosts,
ForgePermissions: a.ForgePermissions,
Triggers: a.Triggers,
Tools: a.Tools,
}
}
func authorityValue(value *pb.PackageAuthority) storepkg.Authority {
if value == nil {
return storepkg.Authority{}
}
return storepkg.Authority{
CredentialServices: value.GetCredentialServices(),
EgressHosts: value.GetEgressHosts(),
ForgePermissions: value.GetForgePermissions(),
Triggers: value.GetTriggers(),
Tools: value.GetTools(),
}
}
func packageValue(value *pb.InstalledPackage) (storepkg.Installed, error) {
var descriptor storepkg.Descriptor
if err := json.Unmarshal(value.GetDescriptorJson(), &descriptor); err != nil {
@@ -115,6 +162,14 @@ func packageValue(value *pb.InstalledPackage) (storepkg.Installed, error) {
return storepkg.Installed{
OrgID: value.GetOrgId(), Name: value.GetName(), Reference: value.GetReference(),
Digest: value.GetDigest(), Descriptor: descriptor, Layer: value.GetLayer(),
UpdatePolicy: value.GetUpdatePolicy(),
UpdatePolicy: value.GetUpdatePolicy(), AcceptedAuthority: authorityPtr(value.GetAcceptedAuthority()),
}, nil
}
func authorityPtr(value *pb.PackageAuthority) *storepkg.Authority {
if value == nil {
return nil
}
authority := authorityValue(value)
return &authority
}
@@ -68,3 +68,84 @@ func TestInstalledPackagesCrossStateStoreWire(t *testing.T) {
t.Fatalf("removed package get error = %v", err)
}
}
// TestPackageAuthorityCrossStateStoreWire drives the acceptance record over a
// real gRPC connection against a real database: the record the operator
// accepts rides the wire, persists against the pinned digest, and a grant
// declared beyond the record is refused end to end
// (docs/prds/store.md, "Authority").
func TestPackageAuthorityCrossStateStoreWire(t *testing.T) {
declared := storepkg.Descriptor{
APIVersion: storepkg.APIVersion, DisplayName: "Review", Version: "1",
Contributes: storepkg.Contributions{Workflows: []string{"review"}},
Authority: storepkg.Authority{ForgePermissions: []string{"read", "comment"}, Tools: []string{"shell"}},
}
db := pgstore.Open(t)
service := storepkg.Service{
Registry: packageRegistry{descriptor: declared},
Store: postgres.NewInstalledPackages(db.Pool),
}
listener := bufconn.Listen(1 << 20)
server := grpc.NewServer()
RegisterServer(server, Deps{Packages: service})
go func() { _ = server.Serve(listener) }()
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
conn, err := grpc.NewClient("passthrough:///state",
grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) { return listener.DialContext(ctx) }))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = conn.Close() })
client := NewClient(conn)
const digest = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
if _, err := client.InstallPackage(t.Context(), "org-a", "review", "localhost:5000/review", digest); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = client.RemoveInstalled(t.Context(), "org-a", "review") })
installed, err := client.GetInstalled(t.Context(), "org-a", "review")
if err != nil {
t.Fatal(err)
}
if installed.AcceptedAuthority != nil {
t.Fatalf("fresh install already accepted: %#v", installed.AcceptedAuthority)
}
// The operator accepts a narrowed subset: the record is the bound the
// package is later checked against, not the full declaration.
accepted := storepkg.Authority{ForgePermissions: []string{"read"}}
if _, err := client.AcceptPackageAuthority(t.Context(), "org-a", "review", accepted); err != nil {
t.Fatal(err)
}
for _, got := range []struct {
name string
pkg storepkg.Installed
}{{"get", mustGetInstalled(t, client, "org-a", "review")}} {
if got.pkg.AcceptedAuthority == nil || !got.pkg.AcceptedAuthority.Covers(accepted) {
t.Fatalf("%s record lost the acceptance: %#v", got.name, got.pkg.AcceptedAuthority)
}
}
list, err := client.ListInstalled(t.Context(), "org-a")
if err != nil || len(list) != 1 || list[0].AcceptedAuthority == nil || !list[0].AcceptedAuthority.Covers(accepted) {
t.Fatalf("list lost the acceptance: %#v, %v", list, err)
}
// A grant the package never declares is not an acceptance of that
// package: the wire preserves the sentinel so the caller sees one error.
if _, err := client.AcceptPackageAuthority(t.Context(), "org-a", "review", storepkg.Authority{ForgePermissions: []string{"read", "push"}}); !errors.Is(err, storepkg.ErrAuthorityNotDeclared) {
t.Fatalf("undeclared grant error = %v", err)
}
if _, err := client.AcceptPackageAuthority(t.Context(), "org-a", "missing", accepted); !errors.Is(err, storepkg.ErrNotFound) {
t.Fatalf("unknown package error = %v", err)
}
}
func mustGetInstalled(t *testing.T, client *Client, org, name string) storepkg.Installed {
t.Helper()
installed, err := client.GetInstalled(t.Context(), org, name)
if err != nil {
t.Fatal(err)
}
return installed
}
@@ -510,6 +510,7 @@ var wireErrors = []struct {
{storepkg.ErrNotFound, codes.NotFound, storepkg.ErrNotFound.Error()},
{storepkg.ErrInstalled, codes.AlreadyExists, storepkg.ErrInstalled.Error()},
{storepkg.ErrRequired, codes.FailedPrecondition, storepkg.ErrRequired.Error()},
{storepkg.ErrAuthorityNotDeclared, codes.FailedPrecondition, storepkg.ErrAuthorityNotDeclared.Error()},
{logging.ErrTaskLogsUnavailable, codes.Unavailable, msgTaskLogsUnavailable},
}
+22
View File
@@ -16,6 +16,10 @@ service StateStoreService {
rpc InstallPackage(InstallPackageRequest) returns (InstallPackageResponse);
rpc GetInstalledPackage(GetInstalledPackageRequest) returns (GetInstalledPackageResponse);
rpc ListInstalledPackages(ListInstalledPackagesRequest) returns (ListInstalledPackagesResponse);
// AcceptPackageAuthority records the operator's accepted authority against
// the pinned digest (the approve action; install is the create action).
// Administrative until org-scoped principals land.
rpc AcceptPackageAuthority(AcceptPackageAuthorityRequest) returns (AcceptPackageAuthorityResponse);
rpc RemoveInstalledPackage(RemoveInstalledPackageRequest) returns (RemoveInstalledPackageResponse);
// Administrative task credential lifecycle. Worker credentials cannot call these.
rpc RegisterTaskGrant(RegisterTaskGrantRequest) returns (RegisterTaskGrantResponse);
@@ -1049,6 +1053,18 @@ message InstalledPackage {
bytes descriptor_json = 5;
bytes layer = 6;
string update_policy = 7;
// The operator's accepted authority, recorded against the pinned digest.
// Absent until the operator accepts (docs/prds/store.md, "Authority").
PackageAuthority accepted_authority = 8;
}
// PackageAuthority mirrors storepkg.Authority: the grants a package needs to
// operate. An acceptance record is an upper bound, checked field by field.
message PackageAuthority {
repeated string credential_services = 1;
repeated string egress_hosts = 2;
repeated string forge_permissions = 3;
repeated string triggers = 4;
repeated string tools = 5;
}
message InstallPackageRequest {
string org_id = 1;
@@ -1061,6 +1077,12 @@ message GetInstalledPackageRequest { string org_id = 1; string name = 2; }
message GetInstalledPackageResponse { InstalledPackage package = 1; }
message ListInstalledPackagesRequest { string org_id = 1; }
message ListInstalledPackagesResponse { repeated InstalledPackage packages = 1; }
message AcceptPackageAuthorityRequest {
string org_id = 1;
string name = 2;
PackageAuthority accepted = 3;
}
message AcceptPackageAuthorityResponse { InstalledPackage package = 1; }
message RemoveInstalledPackageRequest { string org_id = 1; string name = 2; }
message RemoveInstalledPackageResponse {}