merge: record the operator's accepted package authority against the digest (em7s.3)
This commit is contained in:
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,
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -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 {
|
||||
|
||||
@@ -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},
|
||||
}
|
||||
|
||||
|
||||
@@ -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 {}
|
||||
|
||||
|
||||
Reference in new issue
Block a user