feat(store): key control-plane resources by (org, kind)

resources and resource_history are one document per org and kind, with
per-org advisory locks, request-ID idempotency and audit keys. The
control-plane Query/History/Command/Watch requests carry org_id; a request
naming none acts in the default org until the caller's org is derived
server-side.
This commit is contained in:
sam committed 2026-09-30 03:34:02 +10:00
1 parent 82cfbe7cc9
commit 62fe55e474
25 files changed
+459 -187

No files matched your search

+6 -5
View File
@@ -259,7 +259,7 @@ func TestRecoveryRollbackReplaysTheRevisionThroughReplace(t *testing.T) {
if !strings.Contains(stdout, controlplane.ModelRoleAssignmentsKind) {
t.Errorf("rollback must name the resource it replayed; stdout = %q", stdout)
}
resource, err := st.Resource(t.Context(), controlplane.ModelRoleAssignmentsKind)
resource, err := st.Resource(t.Context(), storecontract.DefaultOrgID, controlplane.ModelRoleAssignmentsKind)
if err != nil {
t.Fatal(err)
}
@@ -269,7 +269,7 @@ func TestRecoveryRollbackReplaysTheRevisionThroughReplace(t *testing.T) {
if resource.Version != 3 {
t.Errorf("resource version = %d, want a new revision (3) rather than a rewrite of the old one", resource.Version)
}
history, err := st.ResourceHistory(t.Context(), controlplane.ModelRoleAssignmentsKind, 0)
history, err := st.ResourceHistory(t.Context(), storecontract.DefaultOrgID, controlplane.ModelRoleAssignmentsKind, 0)
if err != nil {
t.Fatal(err)
}
@@ -293,7 +293,7 @@ func TestRecoveryRollbackRestoresANamedRevision(t *testing.T) {
if code != 0 {
t.Fatalf("rollback exited %d: %s", code, stderr)
}
resource, err := st.Resource(t.Context(), controlplane.ModelRoleAssignmentsKind)
resource, err := st.Resource(t.Context(), storecontract.DefaultOrgID, controlplane.ModelRoleAssignmentsKind)
if err != nil {
t.Fatal(err)
}
@@ -463,7 +463,7 @@ func storedResourceCount(t *testing.T, stdout string) int {
// a silent no-op.
func seedResource(t *testing.T, st *pgstore.TaskDB, kind, value, label string) {
t.Helper()
current, err := st.Resource(t.Context(), kind)
current, err := st.Resource(t.Context(), storecontract.DefaultOrgID, kind)
expected := int64(0)
if err == nil {
expected = current.Version
@@ -477,7 +477,8 @@ func seedResource(t *testing.T, st *pgstore.TaskDB, kind, value, label string) {
t.Fatal(err)
}
if _, err := st.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: kind, Value: encoded, Actor: label, Source: "test",
OrgID: storecontract.DefaultOrgID,
Kind: kind, Value: encoded, Actor: label, Source: "test",
RequestID: fmt.Sprintf("%s-%d", label, expected+1), ExpectedVersion: expected,
}); err != nil {
t.Fatalf("seed resource %s: %v", kind, err)
@@ -47,7 +47,7 @@ func (s *outageStore) down(stall time.Duration) {
s.failing, s.stall = true, stall
}
func (s *outageStore) Resource(ctx context.Context, kind string) (storecontract.Resource, error) {
func (s *outageStore) Resource(ctx context.Context, orgID, kind string) (storecontract.Resource, error) {
s.mu.Lock()
failing, stall := s.failing, s.stall
s.mu.Unlock()
@@ -55,7 +55,7 @@ func (s *outageStore) Resource(ctx context.Context, kind string) (storecontract.
time.Sleep(stall)
return storecontract.Resource{}, errors.New("state store unreachable")
}
return s.TaskDB.Resource(ctx, kind)
return s.TaskDB.Resource(ctx, orgID, kind)
}
// TestWatchRetryGrowsWhileTheStateStoreIsDown is the outage this reconnect
@@ -13,6 +13,7 @@ import (
"github.com/samcharles93/archie-core/internal/app/controlplane"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgtest"
"github.com/samcharles93/archie-core/internal/secret"
@@ -51,7 +52,7 @@ func TestStateStoreBootSeedsProviderSourceReference(t *testing.T) {
go func() { errCh <- RunStateStore(ctx, StateStoreOptions{Config: path, Listen: "127.0.0.1:0"}) }()
deadline := time.After(10 * time.Second)
for {
resource, err := store.Resource(t.Context(), controlplane.ProviderSettingsKind)
resource, err := store.Resource(t.Context(), storecontract.DefaultOrgID, controlplane.ProviderSettingsKind)
if err == nil {
if strings.Contains(string(resource.Value), "ARCHIE_PROVIDER_") || !strings.Contains(string(resource.Value), ref.Key) {
t.Fatalf("stored provider settings = %s, want source reference and no derived env name", resource.Value)
+2 -2
View File
@@ -135,7 +135,7 @@ func replayRevision(ctx context.Context, resources controlplane.ResourceStore, o
if !server.Owns(options.Kind) {
return "", fmt.Errorf("unknown resource kind %q", options.Kind)
}
current, err := resources.Resource(ctx, options.Kind)
current, err := resources.Resource(ctx, storecontract.DefaultOrgID, options.Kind)
if errors.Is(err, storecontract.ErrResourceNotFound) {
return "", fmt.Errorf("%s has no stored value to roll back", options.Kind)
}
@@ -165,7 +165,7 @@ func replayRevision(ctx context.Context, resources controlplane.ResourceStore, o
// revisionToReplay picks the value to put back: the revision the operator
// named, or the newest one older than the value the resource carries now.
func revisionToReplay(ctx context.Context, st controlplane.ResourceStore, kind string, current, requested int64) (storecontract.Resource, error) {
history, err := st.ResourceHistory(ctx, kind, 0)
history, err := st.ResourceHistory(ctx, storecontract.DefaultOrgID, kind, 0)
if err != nil {
return storecontract.Resource{}, fmt.Errorf("read %s history: %w", kind, err)
}
@@ -54,11 +54,12 @@ func putResource(t *testing.T, pool *pgxpool.Pool, kind, value, label string) {
t.Helper()
resources := postgres.NewResources(pool)
expected := int64(0)
if current, err := resources.Resource(t.Context(), kind); err == nil {
if current, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, kind); err == nil {
expected = current.Version
}
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: kind, Value: []byte(value), Actor: label, Source: "test",
OrgID: storecontract.DefaultOrgID,
Kind: kind, Value: []byte(value), Actor: label, Source: "test",
RequestID: fmt.Sprintf("%s-%d", label, expected+1), ExpectedVersion: expected,
}); err != nil {
t.Fatalf("put %s: %v", kind, err)
@@ -125,7 +126,7 @@ func TestPostgresRecoveryBackupAndRestore(t *testing.T) {
if !strings.Contains(summary, "after the snapshot") {
t.Errorf("restore must say writes after the snapshot are lost; summary = %q", summary)
}
current, err := postgres.NewResources(pool).Resource(t.Context(), controlplane.ModelRoleAssignmentsKind)
current, err := postgres.NewResources(pool).Resource(t.Context(), storecontract.DefaultOrgID, controlplane.ModelRoleAssignmentsKind)
if err != nil {
t.Fatal(err)
}
@@ -188,7 +189,7 @@ func TestPostgresRecoveryRollback(t *testing.T) {
if _, err := RunStateStoreRecovery(t.Context(), options); err != nil {
t.Fatalf("rollback: %v", err)
}
current, err := postgres.NewResources(pool).Resource(t.Context(), kind)
current, err := postgres.NewResources(pool).Resource(t.Context(), storecontract.DefaultOrgID, kind)
if err != nil {
t.Fatal(err)
}
+16 -7
View File
@@ -31,8 +31,8 @@ var (
// root asserts the State Store against it, so this is the single definition of
// what a control-plane backing store must offer.
type ResourceStore interface {
Resource(context.Context, string) (storecontract.Resource, error)
ResourceHistory(context.Context, string, int) ([]storecontract.Resource, error)
Resource(ctx context.Context, orgID, kind string) (storecontract.Resource, error)
ResourceHistory(ctx context.Context, orgID, kind string, limit int) ([]storecontract.Resource, error)
Audit(ctx context.Context, table string, keys []string, limit int) ([]storecontract.AuditEntry, error)
PutResource(context.Context, storecontract.ResourceWrite) (storecontract.Resource, error)
}
@@ -78,7 +78,7 @@ func (s *Server) Query(ctx context.Context, request *pb.QueryRequest) (*pb.Query
if _, ok := s.definitions[request.GetKind()]; !ok {
return nil, status.Error(codes.NotFound, "resource not found")
}
resource, err := s.store.Resource(ctx, request.Kind)
resource, err := s.store.Resource(ctx, requestOrg(request.GetOrgId()), request.Kind)
if err != nil {
return nil, mapError(err)
}
@@ -96,7 +96,7 @@ func (s *Server) History(ctx context.Context, request *pb.HistoryRequest) (*pb.H
if limit <= 0 || limit > defaultHistoryLimit {
limit = defaultHistoryLimit
}
revisions, err := s.store.ResourceHistory(ctx, request.Kind, limit)
revisions, err := s.store.ResourceHistory(ctx, requestOrg(request.GetOrgId()), request.Kind, limit)
if err != nil {
return nil, mapError(err)
}
@@ -149,7 +149,7 @@ func (s *Server) Command(ctx context.Context, request *pb.CommandRequest) (*pb.C
if err != nil {
return nil, mapError(err)
}
resource, err := s.store.PutResource(ctx, storecontract.ResourceWrite{Kind: request.Kind, Value: value, Actor: request.Actor, Source: request.Source, RequestID: request.RequestId, ExpectedVersion: request.ExpectedVersion, At: time.Now().UTC()})
resource, err := s.store.PutResource(ctx, storecontract.ResourceWrite{OrgID: requestOrg(request.GetOrgId()), Kind: request.Kind, Value: value, Actor: request.Actor, Source: request.Source, RequestID: request.RequestId, ExpectedVersion: request.ExpectedVersion, At: time.Now().UTC()})
if err != nil {
return nil, mapError(err)
}
@@ -164,7 +164,7 @@ func (s *Server) Watch(request *pb.WatchRequest, stream pb.ControlPlaneService_W
ticker := time.NewTicker(250 * time.Millisecond)
defer ticker.Stop()
for {
resource, err := s.store.Resource(stream.Context(), request.Kind)
resource, err := s.store.Resource(stream.Context(), requestOrg(request.GetOrgId()), request.Kind)
if err == nil && resource.Version > version {
if err := stream.Send(&pb.WatchResponse{Resource: resourceProto(resource)}); err != nil {
return err
@@ -182,7 +182,16 @@ func (s *Server) Watch(request *pb.WatchRequest, stream pb.ControlPlaneService_W
}
func resourceProto(resource storecontract.Resource) *pb.Resource {
return &pb.Resource{Kind: resource.Kind, Version: resource.Version, ValueJson: resource.Value, UpdatedAt: timestamp(resource.At)}
return &pb.Resource{OrgId: resource.OrgID, Kind: resource.Kind, Version: resource.Version, ValueJson: resource.Value, UpdatedAt: timestamp(resource.At)}
}
// requestOrg is the org a request acts in. Until the caller's org is derived
// server-side (access), a request that names none acts in the default org.
func requestOrg(orgID string) string {
if orgID == "" {
return storecontract.DefaultOrgID
}
return orgID
}
func timestamp(value time.Time) *timestamppb.Timestamp {
+37 -11
View File
@@ -79,7 +79,7 @@ func TestImportConfigSeedsWorkflowDefinitionsWithoutOverwritingOverride(t *testi
if _, _, err := server.ImportConfig(t.Context(), config.Config{}); err != nil {
t.Fatal(err)
}
resource, err := resources.Resource(t.Context(), WorkflowDefinitionsKind)
resource, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind)
if err != nil {
t.Fatal(err)
}
@@ -95,13 +95,13 @@ func TestImportConfigSeedsWorkflowDefinitionsWithoutOverwritingOverride(t *testi
if err != nil {
t.Fatal(err)
}
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{Kind: WorkflowDefinitionsKind, Value: value, ExpectedVersion: resource.Version, Actor: "test", Source: "test", RequestID: "override"}); err != nil {
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{OrgID: storecontract.DefaultOrgID, Kind: WorkflowDefinitionsKind, Value: value, ExpectedVersion: resource.Version, Actor: "test", Source: "test", RequestID: "override"}); err != nil {
t.Fatal(err)
}
if _, _, err := server.ImportConfig(t.Context(), config.Config{}); err != nil {
t.Fatal(err)
}
got, err := resources.Resource(t.Context(), WorkflowDefinitionsKind)
got, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind)
if err != nil {
t.Fatal(err)
}
@@ -119,7 +119,7 @@ func TestImportConfigSeedsPersonasWithoutOverwritingEdits(t *testing.T) {
if _, _, err := server.ImportConfig(t.Context(), config.Config{}); err != nil {
t.Fatal(err)
}
resource, err := resources.Resource(t.Context(), PersonasKind)
resource, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, PersonasKind)
if err != nil {
t.Fatal(err)
}
@@ -132,13 +132,13 @@ func TestImportConfigSeedsPersonasWithoutOverwritingEdits(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{Kind: PersonasKind, Value: value, ExpectedVersion: resource.Version, Actor: "test", Source: "test", RequestID: "persona-edit"}); err != nil {
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{OrgID: storecontract.DefaultOrgID, Kind: PersonasKind, Value: value, ExpectedVersion: resource.Version, Actor: "test", Source: "test", RequestID: "persona-edit"}); err != nil {
t.Fatal(err)
}
if _, _, err := server.ImportConfig(t.Context(), config.Config{}); err != nil {
t.Fatal(err)
}
got, err := resources.Resource(t.Context(), PersonasKind)
got, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, PersonasKind)
if err != nil {
t.Fatal(err)
}
@@ -161,7 +161,7 @@ func TestImportWorkflowExecutionSettingsDoesNotOverwriteExistingValue(t *testing
if _, err := server.ImportWorkflowExecutionSettings(t.Context(), workflow.ExecutionSettings{MaxModelToolSteps: 99, MaxRuntime: time.Hour, MaxConsecutiveGateFailures: 9}); err != nil {
t.Fatal(err)
}
resource, err := resources.Resource(t.Context(), WorkflowExecutionSettingsKind)
resource, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowExecutionSettingsKind)
if err != nil {
t.Fatal(err)
}
@@ -186,7 +186,7 @@ func TestRegistryRoutesAndValidatesDefinitions(t *testing.T) {
if _, _, err := server.ImportConfig(t.Context(), config.Config{Containers: config.ContainerConfig{Image: "archie-agent:test", PullPolicy: "missing"}}); err != nil {
t.Fatal(err)
}
if _, err := resources.Resource(t.Context(), ContainerRuntimePoliciesKind); err != nil {
if _, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, ContainerRuntimePoliciesKind); err != nil {
t.Fatalf("container runtime policies were not seeded: %v", err)
}
@@ -220,7 +220,7 @@ func TestProviderSeedKeepsReferencesAndNeverResolvedSecrets(t *testing.T) {
if _, _, err := server.ImportConfig(context.Background(), cfg); err != nil {
t.Fatal(err)
}
resource, err := resources.Resource(t.Context(), ProviderSettingsKind)
resource, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, ProviderSettingsKind)
if err != nil {
t.Fatal(err)
}
@@ -308,12 +308,38 @@ func TestImportConfigSkipsASeedItCannotValidate(t *testing.T) {
if len(skipped) != 1 || skipped[0].Kind != RepositoryPoliciesKind || skipped[0].Err == nil {
t.Fatalf("skipped = %+v, want the repository policies and the reason", skipped)
}
if _, err := resources.Resource(t.Context(), RepositoryPoliciesKind); !errors.Is(err, storecontract.ErrResourceNotFound) {
if _, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, RepositoryPoliciesKind); !errors.Is(err, storecontract.ErrResourceNotFound) {
t.Errorf("repository policies Resource = %v, want ErrResourceNotFound: an invalid seed must not be stored", err)
}
// Kinds that are fine are still seeded: one skipped kind does not abandon
// the rest of the migration.
if _, err := resources.Resource(t.Context(), WorkflowDefinitionsKind); err != nil {
if _, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind); err != nil {
t.Errorf("workflow definitions: %v, want them seeded alongside the skipped kind", err)
}
}
// A request names the org whose copy of a kind it acts on; one naming none acts
// in the default org, so a write for one org is invisible to the others.
func TestControlPlaneRequestsActInTheirOrg(t *testing.T) {
t.Parallel()
resources := pgstore.Open(t)
defer resources.Close()
server := testServer(t, resources)
written, err := server.Command(t.Context(), &pb.CommandRequest{
Kind: WorkflowEnablementKind, Command: "replace", ValueJson: []byte(`{"orgs":{}}`),
Actor: "test", Source: "test", RequestId: "acme-write", OrgId: "acme",
})
if err != nil {
t.Fatal(err)
}
if written.Resource.OrgId != "acme" || written.Resource.Version != 1 {
t.Fatalf("written = %+v, want acme at version 1", written.Resource)
}
if _, err := server.Query(t.Context(), &pb.QueryRequest{Kind: WorkflowEnablementKind, OrgId: "acme"}); err != nil {
t.Fatalf("acme Query: %v", err)
}
if _, err := server.Query(t.Context(), &pb.QueryRequest{Kind: WorkflowEnablementKind}); status.Code(err) != codes.NotFound {
t.Fatalf("default-org Query = %v, want NotFound: acme's write leaked into the default org", err)
}
}
@@ -285,7 +285,7 @@ func TestWatchServesOnlyVersionsAfterTheRequestedOne(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if _, err := resources.PutResource(ctx, storecontract.ResourceWrite{Kind: WorkflowExecutionSettingsKind, Value: value, ExpectedVersion: version, Actor: "test", Source: "test", RequestID: "watch-next"}); err != nil {
if _, err := resources.PutResource(ctx, storecontract.ResourceWrite{OrgID: storecontract.DefaultOrgID, Kind: WorkflowExecutionSettingsKind, Value: value, ExpectedVersion: version, Actor: "test", Source: "test", RequestID: "watch-next"}); err != nil {
t.Fatal(err)
}
select {
@@ -45,7 +45,7 @@ func TestImportConfigRefusesAResolvedProviderSnapshot(t *testing.T) {
if !reported {
t.Errorf("skipped = %+v, want provider-settings reported", skipped)
}
if _, err := resources.Resource(t.Context(), ProviderSettingsKind); err == nil {
if _, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, ProviderSettingsKind); err == nil {
t.Fatal("provider-settings was stored from a resolved snapshot")
} else if !strings.Contains(err.Error(), "not found") {
t.Fatalf("Resource = %v, want %v", err, storecontract.ErrResourceNotFound)
+4 -4
View File
@@ -156,7 +156,7 @@ func (r *seedRefusal) Unwrap() error { return r.err }
// value this build derived is not one the resource's validator accepts, and
// nothing was written.
func (s *Server) seedKind(ctx context.Context, definition Definition, cfg config.Config) (int64, error) {
stored, storedErr := s.store.Resource(ctx, definition.Kind)
stored, storedErr := s.store.Resource(ctx, storecontract.DefaultOrgID, definition.Kind)
absent := errors.Is(storedErr, storecontract.ErrResourceNotFound)
if storedErr != nil && !absent {
return 0, storedErr
@@ -188,7 +188,7 @@ func (s *Server) seedKind(ctx context.Context, definition Definition, cfg config
}
}
write := storecontract.ResourceWrite{
Kind: definition.Kind, Value: value,
OrgID: storecontract.DefaultOrgID, Kind: definition.Kind, Value: value,
Actor: seedActor, Source: seedSource,
RequestID: seedRequestID(definition.Kind, value),
ExpectedVersion: expectedVersion(stored, absent), At: time.Now().UTC(),
@@ -226,7 +226,7 @@ func (s *Server) shippedValueIsStale(ctx context.Context, definition Definition)
// seed. It reads the ledger rather than the current row because the ledger is
// what records who wrote a value, and the row does not.
func (s *Server) seedWroteNewest(ctx context.Context, kind string) (bool, error) {
history, err := s.store.ResourceHistory(ctx, kind, 1)
history, err := s.store.ResourceHistory(ctx, storecontract.DefaultOrgID, kind, 1)
if err != nil {
return false, fmt.Errorf("read %s history: %w", kind, err)
}
@@ -305,7 +305,7 @@ func (s *Server) ValidateStored(ctx context.Context) (int, error) {
checked := 0
var failures []error
for _, definition := range s.ordered {
resource, err := s.store.Resource(ctx, definition.Kind)
resource, err := s.store.Resource(ctx, storecontract.DefaultOrgID, definition.Kind)
if errors.Is(err, storecontract.ErrResourceNotFound) {
continue
}
+15 -13
View File
@@ -46,13 +46,14 @@ func staleWorkflowDefinitions(t *testing.T) []byte {
// -- so a test does not restate a key or an identity it would then be pinning.
func writeSeeded(t *testing.T, resources *pgstore.TaskDB, kind string, value []byte) storecontract.Resource {
t.Helper()
if current, err := resources.Resource(t.Context(), kind); err == nil {
if current, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, kind); err == nil {
t.Fatalf("%s already holds version %d; a seeded fixture writes the first revision", kind, current.Version)
} else if !errors.Is(err, storecontract.ErrResourceNotFound) {
t.Fatalf("read %s: %v", kind, err)
}
seeded, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: kind, Value: value, ExpectedVersion: 0,
OrgID: storecontract.DefaultOrgID,
Kind: kind, Value: value, ExpectedVersion: 0,
Actor: seedActor, Source: seedSource, RequestID: seedRequestID(kind, value),
})
if err != nil {
@@ -66,7 +67,8 @@ func writeSeeded(t *testing.T, resources *pgstore.TaskDB, kind string, value []b
func replaceAsOperator(t *testing.T, resources *pgstore.TaskDB, kind string, value []byte, expected int64) storecontract.Resource {
t.Helper()
replaced, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: kind, Value: value, ExpectedVersion: expected,
OrgID: storecontract.DefaultOrgID,
Kind: kind, Value: value, ExpectedVersion: expected,
Actor: "operator", Source: "archie-ui", RequestID: "operator-replace-" + kind,
})
if err != nil {
@@ -96,7 +98,7 @@ func TestImportConfigRefreshesAStaleShippedValue(t *testing.T) {
if err != nil {
t.Fatalf("ImportConfig: %v", err)
}
refreshed, err := resources.Resource(t.Context(), WorkflowDefinitionsKind)
refreshed, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind)
if err != nil {
t.Fatal(err)
}
@@ -115,7 +117,7 @@ func TestImportConfigRefreshesAStaleShippedValue(t *testing.T) {
}
// A refresh is a write like any other: what it replaced stays a revision, so
// the value the previous release shipped is still readable.
history, err := resources.ResourceHistory(t.Context(), WorkflowDefinitionsKind, 0)
history, err := resources.ResourceHistory(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind, 0)
if err != nil {
t.Fatal(err)
}
@@ -138,7 +140,7 @@ func TestImportConfigLeavesASeededValueAloneOnceItMatches(t *testing.T) {
if _, _, err := server.ImportConfig(t.Context(), config.Config{}); err != nil {
t.Fatalf("ImportConfig %d: %v", attempt, err)
}
stored, err := resources.Resource(t.Context(), WorkflowDefinitionsKind)
stored, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind)
if err != nil {
t.Fatal(err)
}
@@ -220,7 +222,7 @@ func TestImportConfigKeepsAStoredValueThatIsNotTheSeeds(t *testing.T) {
if _, _, err := testServer(t, resources).ImportConfig(t.Context(), resolved); err != nil {
t.Fatal(err)
}
stored, err := resources.Resource(t.Context(), RepositoryPoliciesKind)
stored, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, RepositoryPoliciesKind)
if err != nil {
t.Fatal(err)
}
@@ -243,7 +245,7 @@ func TestImportConfigKeepsAStoredValueThatIsNotTheSeeds(t *testing.T) {
defer resources.Close()
server := testServer(t, resources)
want := tt.settle(t, resources)
before, err := resources.Resource(t.Context(), tt.kind)
before, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, tt.kind)
if err != nil {
t.Fatal(err)
}
@@ -253,7 +255,7 @@ func TestImportConfigKeepsAStoredValueThatIsNotTheSeeds(t *testing.T) {
if err != nil {
t.Fatalf("ImportConfig %d: %v", attempt, err)
}
after, err := resources.Resource(t.Context(), tt.kind)
after, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, tt.kind)
if err != nil {
t.Fatal(err)
}
@@ -284,11 +286,11 @@ func TestImportConfigRecreatesAKindAnOperatorRemoved(t *testing.T) {
if _, _, err := server.ImportConfig(t.Context(), config.Config{}); err != nil {
t.Fatal(err)
}
seeded, err := resources.Resource(t.Context(), WorkflowDefinitionsKind)
seeded, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind)
if err != nil {
t.Fatal(err)
}
history, err := resources.ResourceHistory(t.Context(), WorkflowDefinitionsKind, 0)
history, err := resources.ResourceHistory(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind, 0)
if err != nil {
t.Fatal(err)
}
@@ -299,14 +301,14 @@ func TestImportConfigRecreatesAKindAnOperatorRemoved(t *testing.T) {
if _, err := resources.Pool.Exec(t.Context(), `DELETE FROM resources WHERE kind = $1`, WorkflowDefinitionsKind); err != nil {
t.Fatalf("remove the resource: %v", err)
}
if _, err := resources.Resource(t.Context(), WorkflowDefinitionsKind); !errors.Is(err, storecontract.ErrResourceNotFound) {
if _, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind); !errors.Is(err, storecontract.ErrResourceNotFound) {
t.Fatalf("resource after the removal = %v, want ErrResourceNotFound", err)
}
if _, _, err := server.ImportConfig(t.Context(), config.Config{}); err != nil {
t.Fatalf("ImportConfig after the removal: %v", err)
}
restored, err := resources.Resource(t.Context(), WorkflowDefinitionsKind)
restored, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind)
if err != nil {
t.Fatalf("the removed %s was not re-seeded: %v", WorkflowDefinitionsKind, err)
}
+1 -1
View File
@@ -71,7 +71,7 @@ type storeReader struct {
}
func (r storeReader) Query(ctx context.Context, kind string, decode func([]byte) error) (int64, bool, error) {
resource, err := r.resources.Resource(ctx, kind)
resource, err := r.resources.Resource(ctx, storecontract.DefaultOrgID, kind)
if errors.Is(err, storecontract.ErrResourceNotFound) {
seed, ok := r.seeds[kind]
if !ok {
@@ -34,6 +34,7 @@ import (
"github.com/samcharles93/archie-core/internal/app/agentworker"
pb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/infrastructure/workflowsteps"
@@ -267,7 +268,7 @@ func admitThroughStateStore(t *testing.T, steps *workflow.Manager, stepType stri
t.Fatalf("build control plane server: %v", err)
}
if resource, resourceErr := resources.Resource(t.Context(), WorkflowDefinitionsKind); resourceErr == nil {
if resource, resourceErr := resources.Resource(t.Context(), storecontract.DefaultOrgID, WorkflowDefinitionsKind); resourceErr == nil {
before = resource.Version
}
value, err := json.Marshal(probeCollection(stepType))
@@ -33,7 +33,7 @@ type executionSettingsDocument struct {
// holds is left alone, and a kind it does not hold is seeded under the one seed
// identity (see seedActor and seedRequestID).
func (s *Server) ImportWorkflowExecutionSettings(ctx context.Context, settings workflow.ExecutionSettings) (int64, error) {
resource, err := s.store.Resource(ctx, WorkflowExecutionSettingsKind)
resource, err := s.store.Resource(ctx, storecontract.DefaultOrgID, WorkflowExecutionSettingsKind)
if err == nil {
return resource.Version, nil
}
@@ -48,7 +48,7 @@ func (s *Server) ImportWorkflowExecutionSettings(ctx context.Context, settings w
if err != nil {
return 0, err
}
resource, err = s.store.PutResource(ctx, storecontract.ResourceWrite{Kind: WorkflowExecutionSettingsKind, Value: value, Actor: seedActor, Source: seedSource, RequestID: seedRequestID(WorkflowExecutionSettingsKind, value), ExpectedVersion: 0, At: time.Now().UTC()})
resource, err = s.store.PutResource(ctx, storecontract.ResourceWrite{OrgID: storecontract.DefaultOrgID, Kind: WorkflowExecutionSettingsKind, Value: value, Actor: seedActor, Source: seedSource, RequestID: seedRequestID(WorkflowExecutionSettingsKind, value), ExpectedVersion: 0, At: time.Now().UTC()})
return resource.Version, err
}
@@ -213,6 +213,7 @@ type Resource struct {
Version int64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
ValueJson []byte `protobuf:"bytes,3,opt,name=value_json,json=valueJson,proto3" json:"value_json,omitempty"`
UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
OrgId string `protobuf:"bytes,5,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -275,9 +276,19 @@ func (x *Resource) GetUpdatedAt() *timestamppb.Timestamp {
return nil
}
func (x *Resource) GetOrgId() string {
if x != nil {
return x.OrgId
}
return ""
}
// Every request that names a resource acts in one org's copy of it. An empty
// org_id is the default org.
type QueryRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
OrgId string `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -319,6 +330,13 @@ func (x *QueryRequest) GetKind() string {
return ""
}
func (x *QueryRequest) GetOrgId() string {
if x != nil {
return x.OrgId
}
return ""
}
type QueryResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Resource *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
@@ -454,7 +472,8 @@ type HistoryRequest struct {
Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
// Limit caps the revisions returned, newest first. Zero means the server's
// own default.
Limit int32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
Limit int32 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"`
OrgId string `protobuf:"bytes,3,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -503,6 +522,13 @@ func (x *HistoryRequest) GetLimit() int32 {
return 0
}
func (x *HistoryRequest) GetOrgId() string {
if x != nil {
return x.OrgId
}
return ""
}
type HistoryResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Revisions []*Revision `protobuf:"bytes,1,rep,name=revisions,proto3" json:"revisions,omitempty"`
@@ -790,6 +816,7 @@ type CommandRequest struct {
// from browser/request JSON.
Actor string `protobuf:"bytes,6,opt,name=actor,proto3" json:"actor,omitempty"`
Source string `protobuf:"bytes,7,opt,name=source,proto3" json:"source,omitempty"`
OrgId string `protobuf:"bytes,8,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -873,6 +900,13 @@ func (x *CommandRequest) GetSource() string {
return ""
}
func (x *CommandRequest) GetOrgId() string {
if x != nil {
return x.OrgId
}
return ""
}
type CommandResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Resource *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
@@ -921,6 +955,7 @@ type WatchRequest struct {
state protoimpl.MessageState `protogen:"open.v1"`
Kind string `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind,omitempty"`
AfterVersion int64 `protobuf:"varint,2,opt,name=after_version,json=afterVersion,proto3" json:"after_version,omitempty"`
OrgId string `protobuf:"bytes,3,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -969,6 +1004,13 @@ func (x *WatchRequest) GetAfterVersion() int64 {
return 0
}
func (x *WatchRequest) GetOrgId() string {
if x != nil {
return x.OrgId
}
return ""
}
type WatchResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
Resource *Resource `protobuf:"bytes,1,opt,name=resource,proto3" json:"resource,omitempty"`
@@ -1039,16 +1081,18 @@ const file_controlplane_v1_controlplane_proto_rawDesc = "" +
"\rdefaults_json\x18\b \x01(\tR\fdefaultsJson\"\x10\n" +
"\x0eCatalogRequest\"T\n" +
"\x0fCatalogResponse\x12A\n" +
"\tresources\x18\x01 \x03(\v2#.controlplane.v1.ResourceDescriptorR\tresources\"\x92\x01\n" +
"\tresources\x18\x01 \x03(\v2#.controlplane.v1.ResourceDescriptorR\tresources\"\xa9\x01\n" +
"\bResource\x12\x12\n" +
"\x04kind\x18\x01 \x01(\tR\x04kind\x12\x18\n" +
"\aversion\x18\x02 \x01(\x03R\aversion\x12\x1d\n" +
"\n" +
"value_json\x18\x03 \x01(\fR\tvalueJson\x129\n" +
"\n" +
"updated_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\"\"\n" +
"updated_at\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\tupdatedAt\x12\x15\n" +
"\x06org_id\x18\x05 \x01(\tR\x05orgId\"9\n" +
"\fQueryRequest\x12\x12\n" +
"\x04kind\x18\x01 \x01(\tR\x04kind\"F\n" +
"\x04kind\x18\x01 \x01(\tR\x04kind\x12\x15\n" +
"\x06org_id\x18\x02 \x01(\tR\x05orgId\"F\n" +
"\rQueryResponse\x125\n" +
"\bresource\x18\x01 \x01(\v2\x19.controlplane.v1.ResourceR\bresource\"\xbc\x01\n" +
"\bRevision\x12\x18\n" +
@@ -1059,10 +1103,11 @@ const file_controlplane_v1_controlplane_proto_rawDesc = "" +
"\x06source\x18\x04 \x01(\tR\x06source\x12\x1d\n" +
"\n" +
"request_id\x18\x05 \x01(\tR\trequestId\x12*\n" +
"\x02at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\x02at\":\n" +
"\x02at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\x02at\"Q\n" +
"\x0eHistoryRequest\x12\x12\n" +
"\x04kind\x18\x01 \x01(\tR\x04kind\x12\x14\n" +
"\x05limit\x18\x02 \x01(\x05R\x05limit\"J\n" +
"\x05limit\x18\x02 \x01(\x05R\x05limit\x12\x15\n" +
"\x06org_id\x18\x03 \x01(\tR\x05orgId\"J\n" +
"\x0fHistoryResponse\x127\n" +
"\trevisions\x18\x01 \x03(\v2\x19.controlplane.v1.RevisionR\trevisions\"\xc6\x02\n" +
"\n" +
@@ -1087,7 +1132,7 @@ const file_controlplane_v1_controlplane_proto_rawDesc = "" +
"recordKeys\x12\x14\n" +
"\x05limit\x18\x03 \x01(\x05R\x05limit\"F\n" +
"\rAuditResponse\x125\n" +
"\aentries\x18\x01 \x03(\v2\x1b.controlplane.v1.AuditEntryR\aentries\"\xd5\x01\n" +
"\aentries\x18\x01 \x03(\v2\x1b.controlplane.v1.AuditEntryR\aentries\"\xec\x01\n" +
"\x0eCommandRequest\x12\x12\n" +
"\x04kind\x18\x01 \x01(\tR\x04kind\x12\x18\n" +
"\acommand\x18\x02 \x01(\tR\acommand\x12\x1d\n" +
@@ -1097,12 +1142,14 @@ const file_controlplane_v1_controlplane_proto_rawDesc = "" +
"\n" +
"request_id\x18\x05 \x01(\tR\trequestId\x12\x14\n" +
"\x05actor\x18\x06 \x01(\tR\x05actor\x12\x16\n" +
"\x06source\x18\a \x01(\tR\x06source\"H\n" +
"\x06source\x18\a \x01(\tR\x06source\x12\x15\n" +
"\x06org_id\x18\b \x01(\tR\x05orgId\"H\n" +
"\x0fCommandResponse\x125\n" +
"\bresource\x18\x01 \x01(\v2\x19.controlplane.v1.ResourceR\bresource\"G\n" +
"\bresource\x18\x01 \x01(\v2\x19.controlplane.v1.ResourceR\bresource\"^\n" +
"\fWatchRequest\x12\x12\n" +
"\x04kind\x18\x01 \x01(\tR\x04kind\x12#\n" +
"\rafter_version\x18\x02 \x01(\x03R\fafterVersion\"\\\n" +
"\rafter_version\x18\x02 \x01(\x03R\fafterVersion\x12\x15\n" +
"\x06org_id\x18\x03 \x01(\tR\x05orgId\"\\\n" +
"\rWatchResponse\x125\n" +
"\bresource\x18\x01 \x01(\v2\x19.controlplane.v1.ResourceR\bresource\x12\x14\n" +
"\x05error\x18\x02 \x01(\tR\x05error2\xd9\x03\n" +
+19 -3
View File
@@ -521,11 +521,12 @@ var (
ErrResourceVersionConflict = errors.New("resource version conflict")
)
// Resource is one control-plane resource document: the stored value for a
// kind, its revision, and the audit record written with the last write.
// Resource is one control-plane resource document: the stored value for an
// org's kind, its revision, and the audit record written with the last write.
// Resource and ResourceWrite live here so the UI-side consumers can reference
// them without linking the PostgreSQL implementation.
type Resource struct {
OrgID string
Kind string
Value []byte
Version int64
@@ -538,9 +539,23 @@ type Resource struct {
}
// AuditTableResources is the sys_audit table name for control-plane resources,
// keyed by resource kind.
// keyed by ResourceAuditKey.
const AuditTableResources = "resources"
// DefaultOrgID is the org every resource written before orgs existed belongs
// to, and the org a request that names none acts in.
const DefaultOrgID = "default"
// ResourceAuditKey is the sys_audit record key of one org's resource kind. The
// default org keeps the bare kind, so audit rows written before resources were
// per-org still resolve.
func ResourceAuditKey(orgID, kind string) string {
if orgID == DefaultOrgID {
return kind
}
return orgID + "/" + kind
}
// AuditEntry is one changed field of one record, as sys_audit holds it. Any
// store table may write entries; Table and RecordKey locate the record.
// OldValue and NewValue are JSON; an absent side is empty.
@@ -562,6 +577,7 @@ type AuditEntry struct {
// the optimistic-concurrency guard: a write whose expectation does not match
// the stored revision is refused with ErrResourceVersionConflict.
type ResourceWrite struct {
OrgID string
Kind string
Value []byte
Actor string
@@ -0,0 +1,24 @@
-- +goose Up
-- A control-plane resource is one document per (org, kind). Every existing row
-- already carries org_id 'default' from 0013, so the wider key holds wherever
-- the kind-only one did.
ALTER TABLE resources DROP CONSTRAINT resources_pkey;
ALTER TABLE resources ADD PRIMARY KEY (org_id, kind);
DROP INDEX idx_resource_history_kind_version;
DROP INDEX idx_resource_history_kind_request;
CREATE INDEX idx_resource_history_org_kind_version ON resource_history (org_id, kind, version);
-- The request-ID idempotency key is per org and kind: a resource write replays
-- only the same org's prior write of the same kind (resourceByRequest).
CREATE UNIQUE INDEX idx_resource_history_org_kind_request ON resource_history (org_id, kind, request_id);
-- +goose Down
DROP INDEX idx_resource_history_org_kind_request;
DROP INDEX idx_resource_history_org_kind_version;
CREATE UNIQUE INDEX idx_resource_history_kind_request ON resource_history (kind, request_id);
CREATE INDEX idx_resource_history_kind_version ON resource_history (kind, version);
ALTER TABLE resources DROP CONSTRAINT resources_pkey;
ALTER TABLE resources ADD PRIMARY KEY (kind);
@@ -62,19 +62,21 @@ SELECT $1::timestamptz, 'resources', $2::text, d.field, d.old_value, d.new_value
$3::bigint, $4::text, $5::text, $6::text
FROM audit_json_diff(
(SELECT convert_from(h.value, 'UTF8')::jsonb FROM resource_history h
WHERE h.kind = $2::text AND h.version = $7::bigint),
convert_from($8::bytea, 'UTF8')::jsonb
WHERE h.org_id = $7::text AND h.kind = $8::text AND h.version = $9::bigint),
convert_from($10::bytea, 'UTF8')::jsonb
) d
ORDER BY d.field
`
type InsertResourceAuditParams struct {
At time.Time
Kind string
RecordKey string
Version int64
Actor string
Source string
RequestID string
OrgID string
Kind string
PreviousVersion int64
Value []byte
}
@@ -84,11 +86,13 @@ type InsertResourceAuditParams struct {
func (q *Queries) InsertResourceAudit(ctx context.Context, arg InsertResourceAuditParams) error {
_, err := q.db.Exec(ctx, insertResourceAudit,
arg.At,
arg.Kind,
arg.RecordKey,
arg.Version,
arg.Actor,
arg.Source,
arg.RequestID,
arg.OrgID,
arg.Kind,
arg.PreviousVersion,
arg.Value,
)
@@ -11,19 +11,25 @@ import (
)
const insertResource = `-- name: InsertResource :one
INSERT INTO resources (kind, value, version, updated_at)
VALUES ($1, $2, 1, $3)
INSERT INTO resources (org_id, kind, value, version, updated_at)
VALUES ($1, $2, $3, 1, $4)
RETURNING kind, value, version, updated_at, org_id
`
type InsertResourceParams struct {
OrgID string
Kind string
Value []byte
UpdatedAt time.Time
}
func (q *Queries) InsertResource(ctx context.Context, arg InsertResourceParams) (Resource, error) {
row := q.db.QueryRow(ctx, insertResource, arg.Kind, arg.Value, arg.UpdatedAt)
row := q.db.QueryRow(ctx, insertResource,
arg.OrgID,
arg.Kind,
arg.Value,
arg.UpdatedAt,
)
var i Resource
err := row.Scan(
&i.Kind,
@@ -37,15 +43,16 @@ func (q *Queries) InsertResource(ctx context.Context, arg InsertResourceParams)
const insertResourceHistory = `-- name: InsertResourceHistory :one
INSERT INTO resource_history (
kind, value, version, actor, source, request_id, expected_version,
org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING kind, value, version, actor, source, request_id, expected_version,
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
RETURNING org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at
`
type InsertResourceHistoryParams struct {
OrgID string
Kind string
Value []byte
Version int64
@@ -58,6 +65,7 @@ type InsertResourceHistoryParams struct {
}
type InsertResourceHistoryRow struct {
OrgID string
Kind string
Value []byte
Version int64
@@ -71,6 +79,7 @@ type InsertResourceHistoryRow struct {
func (q *Queries) InsertResourceHistory(ctx context.Context, arg InsertResourceHistoryParams) (InsertResourceHistoryRow, error) {
row := q.db.QueryRow(ctx, insertResourceHistory,
arg.OrgID,
arg.Kind,
arg.Value,
arg.Version,
@@ -83,6 +92,7 @@ func (q *Queries) InsertResourceHistory(ctx context.Context, arg InsertResourceH
)
var i InsertResourceHistoryRow
err := row.Scan(
&i.OrgID,
&i.Kind,
&i.Value,
&i.Version,
@@ -97,24 +107,31 @@ func (q *Queries) InsertResourceHistory(ctx context.Context, arg InsertResourceH
}
const lockResourceWrite = `-- name: LockResourceWrite :exec
SELECT pg_advisory_xact_lock(hashtextextended($1, 0))
SELECT pg_advisory_xact_lock(hashtextextended($1::text || '/' || $2::text, 0))
`
type LockResourceWriteParams struct {
OrgID string
Kind string
}
// This lock is acquired in its own statement before a resource read. PostgreSQL
// takes a fresh Read Committed snapshot for the subsequent read, so concurrent
// optimistic writers see the committed revision rather than both writing v1.
func (q *Queries) LockResourceWrite(ctx context.Context, hashtextextended string) error {
_, err := q.db.Exec(ctx, lockResourceWrite, hashtextextended)
// The lock is per (org, kind): two orgs writing the same kind do not contend.
func (q *Queries) LockResourceWrite(ctx context.Context, arg LockResourceWriteParams) error {
_, err := q.db.Exec(ctx, lockResourceWrite, arg.OrgID, arg.Kind)
return err
}
const reinsertResource = `-- name: ReinsertResource :one
INSERT INTO resources (kind, value, version, updated_at)
VALUES ($1, $2, $3, $4)
INSERT INTO resources (org_id, kind, value, version, updated_at)
VALUES ($1, $2, $3, $4, $5)
RETURNING kind, value, version, updated_at, org_id
`
type ReinsertResourceParams struct {
OrgID string
Kind string
Value []byte
Version int64
@@ -124,11 +141,12 @@ type ReinsertResourceParams struct {
// Re-creates the current row for a revision resource_history already records.
// The ledger outlives the row it describes, so a resource an operator removed
// still has its revisions; putting one back needs the row re-created without a
// second ledger entry, which idx_resource_history_kind_request would refuse.
// second ledger entry, which idx_resource_history_org_kind_request would refuse.
// The revision is the ledger's, not a fresh one: this is the row that write
// produced, restored.
func (q *Queries) ReinsertResource(ctx context.Context, arg ReinsertResourceParams) (Resource, error) {
row := q.db.QueryRow(ctx, reinsertResource,
arg.OrgID,
arg.Kind,
arg.Value,
arg.Version,
@@ -146,11 +164,17 @@ func (q *Queries) ReinsertResource(ctx context.Context, arg ReinsertResourcePara
}
const resourceByKind = `-- name: ResourceByKind :one
SELECT kind, value, version, updated_at, org_id FROM resources WHERE kind = $1
SELECT kind, value, version, updated_at, org_id FROM resources
WHERE org_id = $1 AND kind = $2
`
func (q *Queries) ResourceByKind(ctx context.Context, kind string) (Resource, error) {
row := q.db.QueryRow(ctx, resourceByKind, kind)
type ResourceByKindParams struct {
OrgID string
Kind string
}
func (q *Queries) ResourceByKind(ctx context.Context, arg ResourceByKindParams) (Resource, error) {
row := q.db.QueryRow(ctx, resourceByKind, arg.OrgID, arg.Kind)
var i Resource
err := row.Scan(
&i.Kind,
@@ -163,18 +187,20 @@ func (q *Queries) ResourceByKind(ctx context.Context, kind string) (Resource, er
}
const resourceByRequest = `-- name: ResourceByRequest :one
SELECT kind, value, version, actor, source, request_id, expected_version,
SELECT org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at
FROM resource_history
WHERE kind = $1 AND request_id = $2
WHERE org_id = $1 AND kind = $2 AND request_id = $3
`
type ResourceByRequestParams struct {
OrgID string
Kind string
RequestID string
}
type ResourceByRequestRow struct {
OrgID string
Kind string
Value []byte
Version int64
@@ -187,9 +213,10 @@ type ResourceByRequestRow struct {
}
func (q *Queries) ResourceByRequest(ctx context.Context, arg ResourceByRequestParams) (ResourceByRequestRow, error) {
row := q.db.QueryRow(ctx, resourceByRequest, arg.Kind, arg.RequestID)
row := q.db.QueryRow(ctx, resourceByRequest, arg.OrgID, arg.Kind, arg.RequestID)
var i ResourceByRequestRow
err := row.Scan(
&i.OrgID,
&i.Kind,
&i.Value,
&i.Version,
@@ -204,20 +231,22 @@ func (q *Queries) ResourceByRequest(ctx context.Context, arg ResourceByRequestPa
}
const resourceHistory = `-- name: ResourceHistory :many
SELECT kind, value, version, actor, source, request_id, expected_version,
SELECT org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at
FROM resource_history
WHERE kind = $1
WHERE org_id = $1 AND kind = $2
ORDER BY version DESC
LIMIT NULLIF($2::bigint, 0)
LIMIT NULLIF($3::bigint, 0)
`
type ResourceHistoryParams struct {
OrgID string
Kind string
EntryLimit int64
}
type ResourceHistoryRow struct {
OrgID string
Kind string
Value []byte
Version int64
@@ -230,7 +259,7 @@ type ResourceHistoryRow struct {
}
func (q *Queries) ResourceHistory(ctx context.Context, arg ResourceHistoryParams) ([]ResourceHistoryRow, error) {
rows, err := q.db.Query(ctx, resourceHistory, arg.Kind, arg.EntryLimit)
rows, err := q.db.Query(ctx, resourceHistory, arg.OrgID, arg.Kind, arg.EntryLimit)
if err != nil {
return nil, err
}
@@ -239,6 +268,7 @@ func (q *Queries) ResourceHistory(ctx context.Context, arg ResourceHistoryParams
for rows.Next() {
var i ResourceHistoryRow
if err := rows.Scan(
&i.OrgID,
&i.Kind,
&i.Value,
&i.Version,
@@ -260,11 +290,16 @@ func (q *Queries) ResourceHistory(ctx context.Context, arg ResourceHistoryParams
}
const resourceVersion = `-- name: ResourceVersion :one
SELECT version FROM resources WHERE kind = $1
SELECT version FROM resources WHERE org_id = $1 AND kind = $2
`
func (q *Queries) ResourceVersion(ctx context.Context, kind string) (int64, error) {
row := q.db.QueryRow(ctx, resourceVersion, kind)
type ResourceVersionParams struct {
OrgID string
Kind string
}
func (q *Queries) ResourceVersion(ctx context.Context, arg ResourceVersionParams) (int64, error) {
row := q.db.QueryRow(ctx, resourceVersion, arg.OrgID, arg.Kind)
var version int64
err := row.Scan(&version)
return version, err
@@ -272,12 +307,13 @@ func (q *Queries) ResourceVersion(ctx context.Context, kind string) (int64, erro
const updateResource = `-- name: UpdateResource :one
UPDATE resources
SET value = $2, version = version + 1, updated_at = $3
WHERE kind = $1 AND version = $4
SET value = $3, version = version + 1, updated_at = $4
WHERE org_id = $1 AND kind = $2 AND version = $5
RETURNING kind, value, version, updated_at, org_id
`
type UpdateResourceParams struct {
OrgID string
Kind string
Value []byte
UpdatedAt time.Time
@@ -286,6 +322,7 @@ type UpdateResourceParams struct {
func (q *Queries) UpdateResource(ctx context.Context, arg UpdateResourceParams) (Resource, error) {
row := q.db.QueryRow(ctx, updateResource,
arg.OrgID,
arg.Kind,
arg.Value,
arg.UpdatedAt,
@@ -2,11 +2,11 @@
-- Records the fields one resource write changed, against the version it
-- replaced. Runs in the write's own transaction.
INSERT INTO sys_audit (at, table_name, record_key, field, old_value, new_value, record_version, actor, source, request_id)
SELECT sqlc.arg(at)::timestamptz, 'resources', sqlc.arg(kind)::text, d.field, d.old_value, d.new_value,
SELECT sqlc.arg(at)::timestamptz, 'resources', sqlc.arg(record_key)::text, d.field, d.old_value, d.new_value,
sqlc.arg(version)::bigint, sqlc.arg(actor)::text, sqlc.arg(source)::text, sqlc.arg(request_id)::text
FROM audit_json_diff(
(SELECT convert_from(h.value, 'UTF8')::jsonb FROM resource_history h
WHERE h.kind = sqlc.arg(kind)::text AND h.version = sqlc.arg(previous_version)::bigint),
WHERE h.org_id = sqlc.arg(org_id)::text AND h.kind = sqlc.arg(kind)::text AND h.version = sqlc.arg(previous_version)::bigint),
convert_from(sqlc.arg(value)::bytea, 'UTF8')::jsonb
) d
ORDER BY d.field;
@@ -2,55 +2,57 @@
-- This lock is acquired in its own statement before a resource read. PostgreSQL
-- takes a fresh Read Committed snapshot for the subsequent read, so concurrent
-- optimistic writers see the committed revision rather than both writing v1.
SELECT pg_advisory_xact_lock(hashtextextended($1, 0));
-- The lock is per (org, kind): two orgs writing the same kind do not contend.
SELECT pg_advisory_xact_lock(hashtextextended(sqlc.arg(org_id)::text || '/' || sqlc.arg(kind)::text, 0));
-- name: ResourceByKind :one
SELECT kind, value, version, updated_at, org_id FROM resources WHERE kind = $1;
SELECT kind, value, version, updated_at, org_id FROM resources
WHERE org_id = $1 AND kind = $2;
-- name: ResourceByRequest :one
SELECT kind, value, version, actor, source, request_id, expected_version,
SELECT org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at
FROM resource_history
WHERE kind = $1 AND request_id = $2;
WHERE org_id = $1 AND kind = $2 AND request_id = $3;
-- name: ReinsertResource :one
-- Re-creates the current row for a revision resource_history already records.
-- The ledger outlives the row it describes, so a resource an operator removed
-- still has its revisions; putting one back needs the row re-created without a
-- second ledger entry, which idx_resource_history_kind_request would refuse.
-- second ledger entry, which idx_resource_history_org_kind_request would refuse.
-- The revision is the ledger's, not a fresh one: this is the row that write
-- produced, restored.
INSERT INTO resources (kind, value, version, updated_at)
VALUES ($1, $2, $3, $4)
INSERT INTO resources (org_id, kind, value, version, updated_at)
VALUES ($1, $2, $3, $4, $5)
RETURNING kind, value, version, updated_at, org_id;
-- name: ResourceHistory :many
SELECT kind, value, version, actor, source, request_id, expected_version,
SELECT org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at
FROM resource_history
WHERE kind = $1
WHERE org_id = $1 AND kind = $2
ORDER BY version DESC
LIMIT NULLIF(sqlc.arg(entry_limit)::bigint, 0);
-- name: ResourceVersion :one
SELECT version FROM resources WHERE kind = $1;
SELECT version FROM resources WHERE org_id = $1 AND kind = $2;
-- name: InsertResource :one
INSERT INTO resources (kind, value, version, updated_at)
VALUES ($1, $2, 1, $3)
INSERT INTO resources (org_id, kind, value, version, updated_at)
VALUES ($1, $2, $3, 1, $4)
RETURNING kind, value, version, updated_at, org_id;
-- name: UpdateResource :one
UPDATE resources
SET value = $2, version = version + 1, updated_at = $3
WHERE kind = $1 AND version = $4
SET value = $3, version = version + 1, updated_at = $4
WHERE org_id = $1 AND kind = $2 AND version = $5
RETURNING kind, value, version, updated_at, org_id;
-- name: InsertResourceHistory :one
INSERT INTO resource_history (
kind, value, version, actor, source, request_id, expected_version,
org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING kind, value, version, actor, source, request_id, expected_version,
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
RETURNING org_id, kind, value, version, actor, source, request_id, expected_version,
current_version, at;
+63 -46
View File
@@ -24,8 +24,8 @@ func NewResources(pool *pgxpool.Pool) *Resources {
return &Resources{pool: pool}
}
func (s *Resources) Resource(ctx context.Context, kind string) (storecontract.Resource, error) {
resource, err := postgresdb.New(s.pool).ResourceByKind(ctx, kind)
func (s *Resources) Resource(ctx context.Context, orgID, kind string) (storecontract.Resource, error) {
resource, err := postgresdb.New(s.pool).ResourceByKind(ctx, postgresdb.ResourceByKindParams{OrgID: orgID, Kind: kind})
if errors.Is(err, pgx.ErrNoRows) {
return storecontract.Resource{}, storecontract.ErrResourceNotFound
}
@@ -35,12 +35,12 @@ func (s *Resources) Resource(ctx context.Context, kind string) (storecontract.Re
return resourceFromCurrent(resource), nil
}
func (s *Resources) ResourceHistory(ctx context.Context, kind string, limit int) ([]storecontract.Resource, error) {
func (s *Resources) ResourceHistory(ctx context.Context, orgID, kind string, limit int) ([]storecontract.Resource, error) {
if limit <= 0 {
limit = 0
}
history, err := postgresdb.New(s.pool).ResourceHistory(ctx, postgresdb.ResourceHistoryParams{
Kind: kind, EntryLimit: int64(limit),
OrgID: orgID, Kind: kind, EntryLimit: int64(limit),
})
if err != nil {
return nil, err
@@ -48,7 +48,7 @@ func (s *Resources) ResourceHistory(ctx context.Context, kind string, limit int)
resources := make([]storecontract.Resource, 0, len(history))
for _, entry := range history {
resources = append(resources, resourceFromAudit(
entry.Kind, entry.Value, entry.Version, entry.Actor, entry.Source,
entry.OrgID, entry.Kind, entry.Value, entry.Version, entry.Actor, entry.Source,
entry.RequestID, entry.ExpectedVersion, entry.CurrentVersion, entry.At,
))
}
@@ -80,7 +80,7 @@ func (s *Resources) Audit(ctx context.Context, table string, keys []string, limi
// PutResource applies one control-plane resource write.
//
// It is idempotent per request ID: a write whose (kind, request_id) is already
// It is idempotent per request ID: a write whose (org_id, kind, request_id) is already
// in resource_history returns that revision instead of writing a second one, so a
// retry that reached the store twice is still one revision. The ledger is what
// carries the key -- resource_history outlives the row it describes -- so a
@@ -90,17 +90,20 @@ func (s *Resources) Audit(ctx context.Context, table string, keys []string, limi
// caller cannot tell the difference, and a kind can stay gone while every
// process believes it holds a value.
func (s *Resources) PutResource(ctx context.Context, write storecontract.ResourceWrite) (_ storecontract.Resource, retErr error) {
if write.OrgID == "" {
return storecontract.Resource{}, errors.New("resource write names no org")
}
tx, err := s.pool.Begin(ctx)
if err != nil {
return storecontract.Resource{}, err
}
defer func() { _ = tx.Rollback(ctx) }()
queries := postgresdb.New(tx)
if err := queries.LockResourceWrite(ctx, write.Kind); err != nil {
if err := queries.LockResourceWrite(ctx, postgresdb.LockResourceWriteParams{OrgID: write.OrgID, Kind: write.Kind}); err != nil {
return storecontract.Resource{}, err
}
if existing, err := queries.ResourceByRequest(ctx, postgresdb.ResourceByRequestParams{
Kind: write.Kind, RequestID: write.RequestID,
OrgID: write.OrgID, Kind: write.Kind, RequestID: write.RequestID,
}); err == nil {
resource, err := s.replayedResource(ctx, queries, tx, existing)
if err != nil {
@@ -111,7 +114,7 @@ func (s *Resources) PutResource(ctx context.Context, write storecontract.Resourc
return storecontract.Resource{}, err
}
current, err := queries.ResourceVersion(ctx, write.Kind)
current, err := queries.ResourceVersion(ctx, postgresdb.ResourceVersionParams{OrgID: write.OrgID, Kind: write.Kind})
if errors.Is(err, pgx.ErrNoRows) {
current = 0
} else if err != nil {
@@ -120,48 +123,62 @@ func (s *Resources) PutResource(ctx context.Context, write storecontract.Resourc
if current != write.ExpectedVersion {
return storecontract.Resource{}, fmt.Errorf("%w: expected %d, current %d", storecontract.ErrResourceVersionConflict, write.ExpectedVersion, current)
}
if write.At.IsZero() {
write.At = time.Now().UTC()
} else {
write.At = write.At.UTC()
}
var resource postgresdb.Resource
if current == 0 {
resource, err = queries.InsertResource(ctx, postgresdb.InsertResourceParams{
Kind: write.Kind, Value: write.Value, UpdatedAt: write.At,
})
} else {
resource, err = queries.UpdateResource(ctx, postgresdb.UpdateResourceParams{
Kind: write.Kind, Value: write.Value, UpdatedAt: write.At, Version: current,
})
}
history, err := appendResourceRevision(ctx, queries, write, current)
if err != nil {
return storecontract.Resource{}, err
}
history, err := queries.InsertResourceHistory(ctx, postgresdb.InsertResourceHistoryParams{
Kind: write.Kind, Value: write.Value, Version: resource.Version, Actor: write.Actor,
Source: write.Source, RequestID: write.RequestID, ExpectedVersion: write.ExpectedVersion,
CurrentVersion: current, At: write.At,
})
if err != nil {
return storecontract.Resource{}, err
}
if err := queries.InsertResourceAudit(ctx, postgresdb.InsertResourceAuditParams{
At: write.At, Kind: write.Kind, Version: resource.Version, Actor: write.Actor,
Source: write.Source, RequestID: write.RequestID, PreviousVersion: current, Value: write.Value,
}); err != nil {
return storecontract.Resource{}, err
}
if err := tx.Commit(ctx); err != nil {
return storecontract.Resource{}, err
}
return resourceFromAudit(
history.Kind, history.Value, history.Version, history.Actor, history.Source,
history.OrgID, history.Kind, history.Value, history.Version, history.Actor, history.Source,
history.RequestID, history.ExpectedVersion, history.CurrentVersion, history.At,
), nil
}
// appendResourceRevision writes the resource row, its ledger entry and its audit
// trail for one accepted write, returning the ledger entry. current is the
// version being replaced, zero for a first write.
func appendResourceRevision(ctx context.Context, queries *postgresdb.Queries, write storecontract.ResourceWrite, current int64) (postgresdb.InsertResourceHistoryRow, error) {
if write.At.IsZero() {
write.At = time.Now().UTC()
} else {
write.At = write.At.UTC()
}
var (
resource postgresdb.Resource
err error
)
if current == 0 {
resource, err = queries.InsertResource(ctx, postgresdb.InsertResourceParams{
OrgID: write.OrgID, Kind: write.Kind, Value: write.Value, UpdatedAt: write.At,
})
} else {
resource, err = queries.UpdateResource(ctx, postgresdb.UpdateResourceParams{
OrgID: write.OrgID, Kind: write.Kind, Value: write.Value, UpdatedAt: write.At, Version: current,
})
}
if err != nil {
return postgresdb.InsertResourceHistoryRow{}, err
}
history, err := queries.InsertResourceHistory(ctx, postgresdb.InsertResourceHistoryParams{
OrgID: write.OrgID, Kind: write.Kind, Value: write.Value, Version: resource.Version, Actor: write.Actor,
Source: write.Source, RequestID: write.RequestID, ExpectedVersion: write.ExpectedVersion,
CurrentVersion: current, At: write.At,
})
if err != nil {
return postgresdb.InsertResourceHistoryRow{}, err
}
if err := queries.InsertResourceAudit(ctx, postgresdb.InsertResourceAuditParams{
At: write.At, OrgID: write.OrgID, RecordKey: storecontract.ResourceAuditKey(write.OrgID, write.Kind), Kind: write.Kind, Version: resource.Version, Actor: write.Actor,
Source: write.Source, RequestID: write.RequestID, PreviousVersion: current, Value: write.Value,
}); err != nil {
return postgresdb.InsertResourceHistoryRow{}, err
}
return history, nil
}
// replayedResource answers a write whose request ID resource_history already
// holds. The ledger's revision is the answer and a replay writes nothing, with
// one repair: when the resource that revision describes is no longer the current
@@ -170,9 +187,9 @@ func (s *Resources) PutResource(ctx context.Context, write storecontract.Resourc
// revision it does not hold, so the caller reads a version for a kind that is
// absent and the kind stays absent.
func (s *Resources) replayedResource(ctx context.Context, queries *postgresdb.Queries, tx pgx.Tx, existing postgresdb.ResourceByRequestRow) (storecontract.Resource, error) {
if _, err := queries.ResourceByKind(ctx, existing.Kind); errors.Is(err, pgx.ErrNoRows) {
if _, err := queries.ResourceByKind(ctx, postgresdb.ResourceByKindParams{OrgID: existing.OrgID, Kind: existing.Kind}); errors.Is(err, pgx.ErrNoRows) {
if _, err := queries.ReinsertResource(ctx, postgresdb.ReinsertResourceParams{
Kind: existing.Kind, Value: existing.Value, Version: existing.Version, UpdatedAt: existing.At,
OrgID: existing.OrgID, Kind: existing.Kind, Value: existing.Value, Version: existing.Version, UpdatedAt: existing.At,
}); err != nil {
return storecontract.Resource{}, err
}
@@ -183,19 +200,19 @@ func (s *Resources) replayedResource(ctx context.Context, queries *postgresdb.Qu
return storecontract.Resource{}, err
}
return resourceFromAudit(
existing.Kind, existing.Value, existing.Version, existing.Actor, existing.Source,
existing.OrgID, existing.Kind, existing.Value, existing.Version, existing.Actor, existing.Source,
existing.RequestID, existing.ExpectedVersion, existing.CurrentVersion, existing.At,
), nil
}
func resourceFromCurrent(resource postgresdb.Resource) storecontract.Resource {
return storecontract.Resource{
Kind: resource.Kind, Value: resource.Value, Version: resource.Version, At: resource.UpdatedAt,
OrgID: resource.OrgID, Kind: resource.Kind, Value: resource.Value, Version: resource.Version, At: resource.UpdatedAt,
}
}
func resourceFromAudit(
kind string,
orgID, kind string,
value []byte,
version int64,
actor, source, requestID string,
@@ -203,7 +220,7 @@ func resourceFromAudit(
at time.Time,
) storecontract.Resource {
return storecontract.Resource{
Kind: kind, Value: value, Version: version, Actor: actor, Source: source,
OrgID: orgID, Kind: kind, Value: value, Version: version, Actor: actor, Source: source,
RequestID: requestID, ExpectedVersion: expectedVersion, CurrentVersion: currentVersion, At: at,
}
}
@@ -192,7 +192,8 @@ func TestResourceWritesPreserveOptimisticAndIdempotentSemantics(t *testing.T) {
resources := resourcesFor(t)
firstAt := time.Date(2026, 9, 24, 1, 0, 0, 0, time.UTC)
first, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(`{"v":1}`), Actor: "operator", Source: "archie-ui",
OrgID: storecontract.DefaultOrgID,
Kind: "settings", Value: []byte(`{"v":1}`), Actor: "operator", Source: "archie-ui",
RequestID: "r1", ExpectedVersion: 0, At: firstAt,
})
if err != nil {
@@ -203,7 +204,8 @@ func TestResourceWritesPreserveOptimisticAndIdempotentSemantics(t *testing.T) {
}
replay, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(`{"v":999}`), Actor: "other", Source: "retry",
OrgID: storecontract.DefaultOrgID,
Kind: "settings", Value: []byte(`{"v":999}`), Actor: "other", Source: "retry",
RequestID: "r1", ExpectedVersion: 0, At: firstAt.Add(time.Minute),
})
if err != nil {
@@ -214,14 +216,16 @@ func TestResourceWritesPreserveOptimisticAndIdempotentSemantics(t *testing.T) {
}
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(`{"v":2}`), Actor: "operator", Source: "archie-ui",
OrgID: storecontract.DefaultOrgID,
Kind: "settings", Value: []byte(`{"v":2}`), Actor: "operator", Source: "archie-ui",
RequestID: "r2", ExpectedVersion: 0, At: firstAt.Add(2 * time.Minute),
}); !errors.Is(err, storecontract.ErrResourceVersionConflict) {
t.Fatalf("stale PutResource = %v, want ErrResourceVersionConflict", err)
}
second, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(`{"v":2}`), Actor: "operator", Source: "messaging",
OrgID: storecontract.DefaultOrgID,
Kind: "settings", Value: []byte(`{"v":2}`), Actor: "operator", Source: "messaging",
RequestID: "r2", ExpectedVersion: 1, At: firstAt.Add(3 * time.Minute),
})
if err != nil {
@@ -231,7 +235,8 @@ func TestResourceWritesPreserveOptimisticAndIdempotentSemantics(t *testing.T) {
t.Fatalf("second write = %+v, want version 2 from version 1", second)
}
lateReplay, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(`{"v":999}`), Actor: "other", Source: "retry",
OrgID: storecontract.DefaultOrgID,
Kind: "settings", Value: []byte(`{"v":999}`), Actor: "other", Source: "retry",
RequestID: "r1", ExpectedVersion: 0, At: firstAt.Add(4 * time.Minute),
})
if err != nil {
@@ -240,7 +245,7 @@ func TestResourceWritesPreserveOptimisticAndIdempotentSemantics(t *testing.T) {
if lateReplay.Version != first.Version || string(lateReplay.Value) != string(first.Value) {
t.Fatalf("late replay = %+v, want original %+v", lateReplay, first)
}
live, err := resources.Resource(t.Context(), "settings")
live, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, "settings")
if err != nil {
t.Fatalf("Resource: %v", err)
}
@@ -248,21 +253,21 @@ func TestResourceWritesPreserveOptimisticAndIdempotentSemantics(t *testing.T) {
t.Fatalf("live resource after replay = %+v, want second write %+v", live, second)
}
history, err := resources.ResourceHistory(t.Context(), "settings", 1)
history, err := resources.ResourceHistory(t.Context(), storecontract.DefaultOrgID, "settings", 1)
if err != nil {
t.Fatalf("ResourceHistory: %v", err)
}
if len(history) != 1 || history[0].Version != 2 || history[0].Source != "messaging" {
t.Fatalf("limited history = %+v, want newest revision only", history)
}
history, err = resources.ResourceHistory(t.Context(), "settings", 0)
history, err = resources.ResourceHistory(t.Context(), storecontract.DefaultOrgID, "settings", 0)
if err != nil {
t.Fatalf("unlimited ResourceHistory: %v", err)
}
if len(history) != 2 {
t.Fatalf("history after late replay = %+v, want two revisions", history)
}
if _, err := resources.Resource(t.Context(), "missing"); !errors.Is(err, storecontract.ErrResourceNotFound) {
if _, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, "missing"); !errors.Is(err, storecontract.ErrResourceNotFound) {
t.Fatalf("missing Resource = %v, want ErrResourceNotFound", err)
}
}
@@ -278,7 +283,8 @@ func TestResourceReplayRecreatesARemovedResource(t *testing.T) {
resources := NewResources(pool)
at := time.Date(2026, 9, 27, 9, 0, 0, 0, time.UTC)
write := storecontract.ResourceWrite{
Kind: "workflow-definitions", Value: []byte(`{"definitions":[]}`), Actor: "system:migration",
OrgID: storecontract.DefaultOrgID,
Kind: "workflow-definitions", Value: []byte(`{"definitions":[]}`), Actor: "system:migration",
Source: "legacy-config", RequestID: "import:workflow-definitions", ExpectedVersion: 0, At: at,
}
seeded, err := resources.PutResource(t.Context(), write)
@@ -289,7 +295,7 @@ func TestResourceReplayRecreatesARemovedResource(t *testing.T) {
if _, err := pool.Exec(t.Context(), `DELETE FROM resources WHERE kind = $1`, write.Kind); err != nil {
t.Fatalf("remove the resource: %v", err)
}
if _, err := resources.Resource(t.Context(), write.Kind); !errors.Is(err, storecontract.ErrResourceNotFound) {
if _, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, write.Kind); !errors.Is(err, storecontract.ErrResourceNotFound) {
t.Fatalf("resource after the removal = %v, want ErrResourceNotFound", err)
}
@@ -300,7 +306,7 @@ func TestResourceReplayRecreatesARemovedResource(t *testing.T) {
if replayed.Version != seeded.Version || string(replayed.Value) != string(seeded.Value) {
t.Fatalf("replay = %+v, want the revision the ledger records, %+v", replayed, seeded)
}
live, err := resources.Resource(t.Context(), write.Kind)
live, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, write.Kind)
if err != nil {
t.Fatalf("the replay did not re-create the resource: %v", err)
}
@@ -309,7 +315,7 @@ func TestResourceReplayRecreatesARemovedResource(t *testing.T) {
}
// The repair re-creates the row the write produced; it does not append a
// second ledger entry, which idx_resource_history_kind_request would refuse.
history, err := resources.ResourceHistory(t.Context(), write.Kind, 0)
history, err := resources.ResourceHistory(t.Context(), storecontract.DefaultOrgID, write.Kind, 0)
if err != nil {
t.Fatalf("ResourceHistory: %v", err)
}
@@ -320,7 +326,8 @@ func TestResourceReplayRecreatesARemovedResource(t *testing.T) {
// A resource the store still holds is answered from the ledger, unchanged:
// the idempotent replay the index exists for.
again, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: write.Kind, Value: []byte(`{"definitions":[{"id":"different"}]}`), Actor: "other",
OrgID: storecontract.DefaultOrgID,
Kind: write.Kind, Value: []byte(`{"definitions":[{"id":"different"}]}`), Actor: "other",
Source: "retry", RequestID: write.RequestID, ExpectedVersion: 0, At: at.Add(time.Minute),
})
if err != nil {
@@ -340,14 +347,16 @@ func TestResourceRequestIDIsIdempotentPerKind(t *testing.T) {
resources := resourcesFor(t)
at := time.Date(2026, 9, 26, 12, 0, 0, 0, time.UTC)
first, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "provider-settings", Value: []byte(`{"v":1}`), Actor: "operator", Source: "import",
OrgID: storecontract.DefaultOrgID,
Kind: "provider-settings", Value: []byte(`{"v":1}`), Actor: "operator", Source: "import",
RequestID: "shared", ExpectedVersion: 0, At: at,
})
if err != nil {
t.Fatalf("first PutResource: %v", err)
}
second, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "scheduling-policy", Value: []byte(`{"v":2}`), Actor: "operator", Source: "import",
OrgID: storecontract.DefaultOrgID,
Kind: "scheduling-policy", Value: []byte(`{"v":2}`), Actor: "operator", Source: "import",
RequestID: "shared", ExpectedVersion: 0, At: at,
})
if err != nil {
@@ -358,7 +367,8 @@ func TestResourceRequestIDIsIdempotentPerKind(t *testing.T) {
}
replay, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "scheduling-policy", Value: []byte(`{"v":999}`), Actor: "other", Source: "retry",
OrgID: storecontract.DefaultOrgID,
Kind: "scheduling-policy", Value: []byte(`{"v":999}`), Actor: "other", Source: "retry",
RequestID: "shared", ExpectedVersion: 0, At: at.Add(time.Minute),
})
if err != nil {
@@ -368,7 +378,7 @@ func TestResourceRequestIDIsIdempotentPerKind(t *testing.T) {
t.Fatalf("replay = %+v, want scheduling-policy's original %+v", replay, second)
}
live, err := resources.Resource(t.Context(), "scheduling-policy")
live, err := resources.Resource(t.Context(), storecontract.DefaultOrgID, "scheduling-policy")
if err != nil {
t.Fatalf("Resource: %v", err)
}
@@ -389,7 +399,8 @@ func TestConcurrentResourceWritesAcceptOnlyOneExpectedVersion(t *testing.T) {
go func() {
<-start
_, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(`{"v":1}`), Actor: "operator", Source: "test",
OrgID: storecontract.DefaultOrgID,
Kind: "settings", Value: []byte(`{"v":1}`), Actor: "operator", Source: "test",
RequestID: requestID, ExpectedVersion: 0,
})
results <- result{err: err}
@@ -413,7 +424,7 @@ func TestConcurrentResourceWritesAcceptOnlyOneExpectedVersion(t *testing.T) {
t.Fatalf("concurrent writes = %d succeeded, %d conflicted; want 1 each", succeeded, conflicted)
}
history, err := resources.ResourceHistory(t.Context(), "settings", 0)
history, err := resources.ResourceHistory(t.Context(), storecontract.DefaultOrgID, "settings", 0)
if err != nil {
t.Fatalf("ResourceHistory: %v", err)
}
@@ -429,7 +440,8 @@ func TestResourceWritesRecordFieldLevelAudit(t *testing.T) {
put := func(value string, expected int64, request string) {
t.Helper()
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(value), Actor: "sam", Source: "archie-ui",
OrgID: storecontract.DefaultOrgID,
Kind: "settings", Value: []byte(value), Actor: "sam", Source: "archie-ui",
RequestID: request, ExpectedVersion: expected,
}); err != nil {
t.Fatalf("PutResource(%s): %v", value, err)
@@ -455,3 +467,66 @@ func TestResourceWritesRecordFieldLevelAudit(t *testing.T) {
t.Fatalf("audit =\n%s\nwant\n%s", strings.Join(got, "\n"), strings.Join(want, "\n"))
}
}
// A kind is one document per org: two orgs write the same kind under the same
// request ID and each keeps its own value, revision, history and audit trail.
func TestResourcesAreIndependentPerOrg(t *testing.T) {
resources := resourcesFor(t)
at := time.Date(2026, 9, 30, 12, 0, 0, 0, time.UTC)
put := func(orgID, value string, expected int64) storecontract.Resource {
t.Helper()
got, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
OrgID: orgID, Kind: "workflow-definitions", Value: []byte(value), Actor: "operator",
Source: "test", RequestID: "shared-" + value, ExpectedVersion: expected, At: at,
})
if err != nil {
t.Fatalf("PutResource(%s): %v", orgID, err)
}
return got
}
put("acme", `{"v":"a1"}`, 0)
acme := put("acme", `{"v":"a2"}`, 1)
globex := put("globex", `{"v":"g1"}`, 0)
if acme.Version != 2 || globex.Version != 1 {
t.Fatalf("versions acme=%d globex=%d, want 2 and 1: orgs must not share a revision counter", acme.Version, globex.Version)
}
if _, err := resources.PutResource(t.Context(), storecontract.ResourceWrite{
OrgID: "globex", Kind: "workflow-definitions", Value: []byte(`{}`), Actor: "operator",
Source: "test", RequestID: "stale", ExpectedVersion: 2, At: at,
}); !errors.Is(err, storecontract.ErrResourceVersionConflict) {
t.Fatalf("globex write expecting acme's version = %v, want ErrResourceVersionConflict", err)
}
live, err := resources.Resource(t.Context(), "globex", "workflow-definitions")
if err != nil || string(live.Value) != `{"v":"g1"}` || live.OrgID != "globex" {
t.Fatalf("globex Resource = %+v, %v", live, err)
}
if _, err := resources.Resource(t.Context(), "initech", "workflow-definitions"); !errors.Is(err, storecontract.ErrResourceNotFound) {
t.Fatalf("an org that never wrote the kind reads %v, want ErrResourceNotFound", err)
}
history, err := resources.ResourceHistory(t.Context(), "acme", "workflow-definitions", 0)
if err != nil || len(history) != 2 {
t.Fatalf("acme history = %d entries, %v; want its own 2", len(history), err)
}
audit, err := resources.Audit(t.Context(), storecontract.AuditTableResources,
[]string{storecontract.ResourceAuditKey("globex", "workflow-definitions")}, 0)
if err != nil {
t.Fatalf("Audit: %v", err)
}
for _, entry := range audit {
if entry.Version != 1 {
t.Fatalf("globex audit entry at version %d: acme's revisions leaked into its trail", entry.Version)
}
}
if len(audit) == 0 {
t.Fatal("globex audit is empty, want its first write")
}
}
func TestPutResourceRefusesNoOrg(t *testing.T) {
if _, err := resourcesFor(t).PutResource(t.Context(), storecontract.ResourceWrite{
Kind: "settings", Value: []byte(`{}`), Actor: "operator", Source: "test", RequestID: "r",
}); err == nil {
t.Fatal("a write naming no org was accepted")
}
}
+1 -1
View File
@@ -30,7 +30,7 @@ import (
type liveResourceStore struct{ controlplane.ResourceStore }
func (*liveResourceStore) Resource(_ context.Context, kind string) (storecontract.Resource, error) {
func (*liveResourceStore) Resource(_ context.Context, _, kind string) (storecontract.Resource, error) {
if kind == controlplane.PersonasKind {
return storecontract.Resource{Kind: kind, Version: 1, Value: []byte(`{"default":"archie","personas":[]}`)}, nil
}
+10 -1
View File
@@ -36,8 +36,14 @@ message Resource {
int64 version = 2;
bytes value_json = 3;
google.protobuf.Timestamp updated_at = 4;
string org_id = 5;
}
// Every request that names a resource acts in one org's copy of it. An empty
// org_id is the default org.
message QueryRequest {
string kind = 1;
string org_id = 2;
}
message QueryRequest { string kind = 1; }
message QueryResponse { Resource resource = 1; }
// Revision is one entry of a resource's audit trail: the value that version
@@ -55,6 +61,7 @@ message HistoryRequest {
// Limit caps the revisions returned, newest first. Zero means the server's
// own default.
int32 limit = 2;
string org_id = 3;
}
message HistoryResponse { repeated Revision revisions = 1; }
@@ -92,12 +99,14 @@ message CommandRequest {
// from browser/request JSON.
string actor = 6;
string source = 7;
string org_id = 8;
}
message CommandResponse { Resource resource = 1; }
message WatchRequest {
string kind = 1;
int64 after_version = 2;
string org_id = 3;
}
message WatchResponse {
Resource resource = 1;