diff --git a/internal/infrastructure/postgres/access.go b/internal/infrastructure/postgres/access.go index 5ace29efd..fd104e08f 100644 --- a/internal/infrastructure/postgres/access.go +++ b/internal/infrastructure/postgres/access.go @@ -53,6 +53,63 @@ func auditKey(p access.Policy) string { return strings.Trim(joined, "/") } +// The reset command runs on the State Store host with no authenticated caller, +// so its own audit rows name the recovery rather than reading as "unknown". +const ( + resetActor = "archie-state-store access reset" + resetSource = "archie-state-store" +) + +// policyFromResetRow is one policy a reset deleted, as the audit row needs it. +func policyFromResetRow(level, orgID, wsID, kind, id, policyID, text string) access.Policy { + return access.Policy{ + ID: policyID, Level: access.Level(level), OrgID: org.OrgID(orgID), + WorkspaceID: org.WorkspaceID(wsID), ObjectKind: access.ResourceKind(kind), + ObjectID: id, Text: text, + } +} + +// auditResetDeletes writes one delete row per policy a reset removed, at the +// same scope version a DeletePolicy would have written. The shipped policies +// the reset then re-puts carry their own PutPolicy rows. +func auditResetDeletes(ctx context.Context, q *postgresdb.Queries, policies []access.Policy) error { + type scope struct { + level, orgID, workspaceID string + } + versions := make(map[scope]int64, len(policies)) + for _, p := range policies { + level, orgID, wsID, _, _, _ := accessScopeOf(p) + s := scope{level: level, orgID: orgID, workspaceID: wsID} + version, ok := versions[s] + if !ok { + bumped, err := q.UpsertAccessPolicyVersion(ctx, postgresdb.UpsertAccessPolicyVersionParams{ + Level: level, OrgID: orgID, WorkspaceID: wsID, + }) + if err != nil { + return err + } + version = bumped + versions[s] = bumped + } + oldValue, err := auditJSON(p.Text) + if err != nil { + return err + } + if err := insertAudit(ctx, q, "access_policies", auditKey(p), "text", oldValue, nil, version, auditOrg(p)); err != nil { + return err + } + } + for s := range versions { + // A scope with no policies left keeps no version row, as DeletePolicy does. + if err := q.DeleteAccessPolicyVersion(ctx, postgresdb.DeleteAccessPolicyVersionParams{ + Level: s.level, OrgID: s.orgID, WorkspaceID: s.workspaceID, + }); err != nil { + return err + } + } + return nil +} + // ListPolicies returns the stored policies the request's scope may see: // every policy across levels for an unscoped service. func (s *Store) ListPolicies(ctx context.Context) ([]access.Policy, error) { @@ -252,8 +309,21 @@ func (s *Store) ResetOrgPolicies(ctx context.Context, orgID org.OrgID) error { if orgID == "" { return fmt.Errorf("%w: no org", access.ErrInvalidPolicy) } - if err := s.queries().DeleteOrgPoliciesNotShipped(ctx, postgresdb.DeleteOrgPoliciesNotShippedParams{ - OrgID: string(orgID), Column2: shippedOrgPolicyIDs(), + ctx = access.WithActor(ctx, resetActor) + ctx = access.WithSource(ctx, resetSource) + if err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + rows, err := q.DeleteOrgPoliciesNotShipped(ctx, postgresdb.DeleteOrgPoliciesNotShippedParams{ + OrgID: string(orgID), Column2: shippedOrgPolicyIDs(), + }) + if err != nil { + return err + } + policies := make([]access.Policy, 0, len(rows)) + for _, r := range rows { + policies = append(policies, policyFromResetRow(r.Level, r.OrgID, r.WorkspaceID, r.ObjectKind, r.ObjectID, r.PolicyID, r.Text)) + } + return auditResetDeletes(ctx, q, policies) }); err != nil { return err } @@ -268,8 +338,18 @@ func (s *Store) ResetOrgPolicies(ctx context.Context, orgID org.OrgID) error { // ResetInstancePolicies removes every stored instance policy. The // cross-org forbid is engine-enforced and survives any reset. func (s *Store) ResetInstancePolicies(ctx context.Context) error { + ctx = access.WithActor(ctx, resetActor) + ctx = access.WithSource(ctx, resetSource) _, err := s.writePolicy(ctx, func(q *postgresdb.Queries) error { - return q.ResetInstancePolicies(ctx) + rows, err := q.ResetInstancePolicies(ctx) + if err != nil { + return err + } + policies := make([]access.Policy, 0, len(rows)) + for _, r := range rows { + policies = append(policies, policyFromResetRow(r.Level, r.OrgID, r.WorkspaceID, r.ObjectKind, r.ObjectID, r.PolicyID, r.Text)) + } + return auditResetDeletes(ctx, q, policies) }) return err } diff --git a/internal/infrastructure/postgres/audit.go b/internal/infrastructure/postgres/audit.go index b3c326f29..35eed259a 100644 --- a/internal/infrastructure/postgres/audit.go +++ b/internal/infrastructure/postgres/audit.go @@ -30,6 +30,20 @@ func insertAudit(ctx context.Context, q *postgresdb.Queries, table, recordKey, f return nil } +// insertAuditValues encodes both sides of one change and writes the row, so a +// caller records the value it holds rather than pre-encoding it. +func insertAuditValues(ctx context.Context, q *postgresdb.Queries, table, recordKey, field string, oldValue, newValue any, version int64, orgID string) error { + oldJSON, err := auditJSON(oldValue) + if err != nil { + return err + } + newJSON, err := auditJSON(newValue) + if err != nil { + return err + } + return insertAudit(ctx, q, table, recordKey, field, oldJSON, newJSON, version, orgID) +} + // auditJSON encodes one side of an audit change. An absent value stays nil, // which the column stores as NULL: absent is not the same fact as JSON null. // A value that cannot be encoded is an error, never a silent NULL that would diff --git a/internal/infrastructure/postgres/edastore.go b/internal/infrastructure/postgres/edastore.go index 6fe6bdcbd..70c48d6df 100644 --- a/internal/infrastructure/postgres/edastore.go +++ b/internal/infrastructure/postgres/edastore.go @@ -10,6 +10,7 @@ import ( "errors" "fmt" "log/slog" + "reflect" "time" "github.com/google/uuid" @@ -73,6 +74,50 @@ func (s *EDA) notifyWrite(kind, subject, action, id string) { func newRecordID() string { return uuid.NewString() } +// decodedJSON keeps a stored JSON text structured in an audit value, and falls +// back to the raw string when it will not decode. +func decodedJSON(raw string) any { + var v any + if err := json.Unmarshal([]byte(raw), &v); err != nil { + return raw + } + return v +} + +// mappingAuditDoc is the record an audit row shows for a mapping. +func mappingAuditDoc(id, name, sourceHint, eventType, fields string) map[string]any { + return map[string]any{ + "id": id, "name": name, "source_hint": sourceHint, + "event_type": eventType, "fields": decodedJSON(fields), + } +} + +func mappingRowAuditDoc(r postgresdb.GetMappingRow) map[string]any { + return mappingAuditDoc(r.Mapping.ID, r.Mapping.Name, r.Mapping.SourceHint, r.Mapping.EventType, r.Mapping.Fields) +} + +// bindingAuditDoc is the record an audit row shows for a binding. +func bindingAuditDoc(id, name, source, mappingID, filter, workflow, owner, repo, repoParam, inputs, status string, version int64) map[string]any { + return map[string]any{ + "id": id, "name": name, "source": source, "mapping": mappingID, + "filter": filter, "workflow": workflow, "owner": owner, "repo": repo, + "repo_param": repoParam, "inputs": decodedJSON(inputs), "status": status, + "version": version, + } +} + +func bindingRowAuditDoc(r postgresdb.GetBindingRow) map[string]any { + return bindingAuditDoc(r.ID, r.Name, r.Source, r.Mapping, r.Filter, r.Workflow, r.Owner, r.Repo, r.RepoParam, r.Inputs, r.Status, r.Version) +} + +// bindingEditableEqual reports whether b would change any field UpdateBinding +// writes, so an identical save is not recorded as a change. +func bindingEditableEqual(r postgresdb.GetBindingRow, b binding.Binding, inputs string) bool { + return r.Name == b.Name && r.Source == b.Matcher.Source && r.Mapping == b.MappingID && + r.Filter == b.Filter && r.Workflow == b.Workflow && r.Owner == b.Owner && + r.Repo == b.Repo && r.RepoParam == b.RepoParam && r.Inputs == inputs +} + // --- captures --- // InsertCapture stores one inbound event verbatim, tagged with the event type @@ -229,15 +274,23 @@ func (s *EDA) InsertMapping(ctx context.Context, m mapping.Mapping) (string, err return "", err } id := newRecordID() - if err := s.q.InsertMapping(ctx, postgresdb.InsertMappingParams{ - OrgID: string(org.OrgFromContext(ctx)), - ID: id, - Name: m.Name, - SourceHint: m.SourceHint, - EventType: m.EventTypeID, - Fields: encoded, + orgID := string(org.OrgFromContext(ctx)) + if err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.InsertMapping(ctx, postgresdb.InsertMappingParams{ + OrgID: orgID, + ID: id, + Name: m.Name, + SourceHint: m.SourceHint, + EventType: m.EventTypeID, + Fields: encoded, + }); err != nil { + return fmt.Errorf("edastore: insert mapping: %w", err) + } + return insertAuditValues(ctx, q, "mappings", id, "mapping", nil, + mappingAuditDoc(id, m.Name, m.SourceHint, m.EventTypeID, encoded), 0, orgID) }); err != nil { - return "", fmt.Errorf("edastore: insert mapping: %w", err) + return "", err } s.notifyWrite(events.KindMappingChanged, "mapping", "create", id) return id, nil @@ -281,32 +334,71 @@ func (s *EDA) UpdateMapping(ctx context.Context, m mapping.Mapping) error { if err != nil { return err } - n, err := s.q.UpdateMapping(ctx, postgresdb.UpdateMappingParams{ - ScopeOrg: scopeOrg(ctx), - ID: m.ID, - Name: m.Name, - SourceHint: m.SourceHint, - EventType: m.EventTypeID, - Fields: encoded, + err = pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "mappings", RecordKey: m.ID}); err != nil { + return err + } + old, err := q.GetMapping(ctx, postgresdb.GetMappingParams{ID: m.ID, ScopeOrg: scopeOrg(ctx)}) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrMappingNotFound + } + if err != nil { + return err + } + n, err := q.UpdateMapping(ctx, postgresdb.UpdateMappingParams{ + ScopeOrg: scopeOrg(ctx), + ID: m.ID, + Name: m.Name, + SourceHint: m.SourceHint, + EventType: m.EventTypeID, + Fields: encoded, + }) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrMappingNotFound + } + oldDoc := mappingRowAuditDoc(old) + newDoc := mappingAuditDoc(m.ID, m.Name, m.SourceHint, m.EventTypeID, encoded) + if reflect.DeepEqual(oldDoc, newDoc) { + return nil + } + return insertAuditValues(ctx, q, "mappings", m.ID, "mapping", oldDoc, newDoc, 0, old.Mapping.OrgID) }) if err != nil { return err } - if n == 0 { - return storecontract.ErrMappingNotFound - } s.notifyWrite(events.KindMappingChanged, "mapping", "update", m.ID) return nil } func (s *EDA) DeleteMapping(ctx context.Context, id string) error { - n, err := s.q.DeleteMapping(ctx, postgresdb.DeleteMappingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "mappings", RecordKey: id}); err != nil { + return err + } + old, err := q.GetMapping(ctx, postgresdb.GetMappingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrMappingNotFound + } + if err != nil { + return err + } + n, err := q.DeleteMapping(ctx, postgresdb.DeleteMappingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrMappingNotFound + } + return insertAuditValues(ctx, q, "mappings", id, "mapping", mappingRowAuditDoc(old), nil, 0, old.Mapping.OrgID) + }) if err != nil { return err } - if n == 0 { - return storecontract.ErrMappingNotFound - } s.notifyWrite(events.KindMappingChanged, "mapping", "delete", id) return nil } @@ -370,22 +462,30 @@ func (s *EDA) InsertBinding(ctx context.Context, b binding.Binding) (string, err if err != nil { return "", err } - err = s.q.InsertBinding(ctx, postgresdb.InsertBindingParams{ - OrgID: string(org.OrgFromContext(ctx)), - ID: id, - Name: b.Name, - Source: b.Matcher.Source, - Mapping: b.MappingID, - Filter: b.Filter, - Workflow: b.Workflow, - Owner: b.Owner, - Repo: b.Repo, - Status: string(binding.StatusPendingApproval), - Inputs: inputs, - RepoParam: b.RepoParam, - }) - if err != nil { - return "", fmt.Errorf("edastore: insert binding: %w", err) + orgID := string(org.OrgFromContext(ctx)) + if err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.InsertBinding(ctx, postgresdb.InsertBindingParams{ + OrgID: orgID, + ID: id, + Name: b.Name, + Source: b.Matcher.Source, + Mapping: b.MappingID, + Filter: b.Filter, + Workflow: b.Workflow, + Owner: b.Owner, + Repo: b.Repo, + Status: string(binding.StatusPendingApproval), + Inputs: inputs, + RepoParam: b.RepoParam, + }); err != nil { + return fmt.Errorf("edastore: insert binding: %w", err) + } + return insertAuditValues(ctx, q, "bindings", id, "binding", nil, + bindingAuditDoc(id, b.Name, b.Matcher.Source, b.MappingID, b.Filter, b.Workflow, + b.Owner, b.Repo, b.RepoParam, inputs, string(binding.StatusPendingApproval), 1), 1, orgID) + }); err != nil { + return "", err } s.notifyWrite(events.KindBindingChanged, "binding", "create", id) return id, nil @@ -448,61 +548,115 @@ func (s *EDA) UpdateBinding(ctx context.Context, b binding.Binding) error { if err != nil { return err } - n, err := s.q.UpdateBinding(ctx, postgresdb.UpdateBindingParams{ - ScopeOrg: scopeOrg(ctx), - ID: b.ID, - Name: b.Name, - Source: b.Matcher.Source, - Mapping: b.MappingID, - Filter: b.Filter, - Workflow: b.Workflow, - Owner: b.Owner, - Repo: b.Repo, - Status: string(binding.StatusPendingApproval), - Inputs: inputs, - RepoParam: b.RepoParam, + err = pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: b.ID}); err != nil { + return err + } + old, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: b.ID, ScopeOrg: scopeOrg(ctx)}) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrBindingNotFound + } + if err != nil { + return err + } + unchanged := bindingEditableEqual(old, b, inputs) && old.Status == string(binding.StatusPendingApproval) + n, err := q.UpdateBinding(ctx, postgresdb.UpdateBindingParams{ + ScopeOrg: scopeOrg(ctx), + ID: b.ID, + Name: b.Name, + Source: b.Matcher.Source, + Mapping: b.MappingID, + Filter: b.Filter, + Workflow: b.Workflow, + Owner: b.Owner, + Repo: b.Repo, + Status: string(binding.StatusPendingApproval), + Inputs: inputs, + RepoParam: b.RepoParam, + }) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrBindingNotFound + } + if unchanged { + return nil + } + next := old.Version + 1 + return insertAuditValues(ctx, q, "bindings", b.ID, "binding", + bindingRowAuditDoc(old), + bindingAuditDoc(b.ID, b.Name, b.Matcher.Source, b.MappingID, b.Filter, b.Workflow, + b.Owner, b.Repo, b.RepoParam, inputs, string(binding.StatusPendingApproval), next), + next, old.OrgID) }) if err != nil { return err } - if n == 0 { - return storecontract.ErrBindingNotFound - } s.notifyWrite(events.KindBindingChanged, "binding", "update", b.ID) return nil } func (s *EDA) DeleteBinding(ctx context.Context, id string) error { - n, err := s.q.DeleteBinding(ctx, postgresdb.DeleteBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: id}); err != nil { + return err + } + old, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrBindingNotFound + } + if err != nil { + return err + } + n, err := q.DeleteBinding(ctx, postgresdb.DeleteBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrBindingNotFound + } + return insertAuditValues(ctx, q, "bindings", id, "binding", bindingRowAuditDoc(old), nil, old.Version, old.OrgID) + }) if err != nil { return err } - if n == 0 { - return storecontract.ErrBindingNotFound - } s.notifyWrite(events.KindBindingChanged, "binding", "delete", id) return nil } // ApproveBinding is the only transition that arms a binding. func (s *EDA) ApproveBinding(ctx context.Context, id string) error { - r, err := s.q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) - if errors.Is(err, pgx.ErrNoRows) { - return storecontract.ErrBindingNotFound - } + err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: id}); err != nil { + return err + } + r, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrBindingNotFound + } + if err != nil { + return err + } + if r.Status != string(binding.StatusPendingApproval) { + return storecontract.ErrBindingTransition + } + n, err := q.SetBindingArmed(ctx, postgresdb.SetBindingArmedParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrBindingNotFound + } + return insertAuditValues(ctx, q, "bindings", id, "status", + string(binding.StatusPendingApproval), string(binding.StatusArmed), r.Version, r.OrgID) + }) if err != nil { return err } - if r.Status != string(binding.StatusPendingApproval) { - return storecontract.ErrBindingTransition - } - n, err := s.q.SetBindingArmed(ctx, postgresdb.SetBindingArmedParams{ID: id, ScopeOrg: scopeOrg(ctx)}) - if err != nil { - return err - } - if n == 0 { - return storecontract.ErrBindingNotFound - } s.notifyWrite(events.KindBindingChanged, "binding", "approve", id) return nil } @@ -519,18 +673,32 @@ func (s *EDA) ResumeBinding(ctx context.Context, id string) error { } func (s *EDA) transitionBinding(ctx context.Context, id string, from, to binding.Status, verb string) error { - n, err := s.q.TransitionBindingStatus(ctx, postgresdb.TransitionBindingStatusParams{ - ID: id, FromStatus: string(from), ToStatus: string(to), ScopeOrg: scopeOrg(ctx), + err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "bindings", RecordKey: id}); err != nil { + return err + } + n, err := q.TransitionBindingStatus(ctx, postgresdb.TransitionBindingStatusParams{ + ID: id, FromStatus: string(from), ToStatus: string(to), ScopeOrg: scopeOrg(ctx), + }) + if err != nil { + return err + } + if n == 0 { + if _, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}); errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrBindingNotFound + } + return storecontract.ErrBindingTransition + } + current, err := q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if err != nil { + return err + } + return insertAuditValues(ctx, q, "bindings", id, "status", string(from), string(to), current.Version, current.OrgID) }) if err != nil { return err } - if n == 0 { - if _, err := s.q.GetBinding(ctx, postgresdb.GetBindingParams{ID: id, ScopeOrg: scopeOrg(ctx)}); errors.Is(err, pgx.ErrNoRows) { - return storecontract.ErrBindingNotFound - } - return storecontract.ErrBindingTransition - } s.notifyWrite(events.KindBindingChanged, "binding", verb, id) return nil } diff --git a/internal/infrastructure/postgres/edastore_eventtypes.go b/internal/infrastructure/postgres/edastore_eventtypes.go index 880b53c9b..068d7e06a 100644 --- a/internal/infrastructure/postgres/edastore_eventtypes.go +++ b/internal/infrastructure/postgres/edastore_eventtypes.go @@ -30,6 +30,14 @@ func eventTypeValue(r postgresdb.EventType) (eventtype.EventType, error) { return t, nil } +// eventTypeAuditDoc is the record an audit row shows for an event type. +func eventTypeAuditDoc(id, source, name, rule, schema string) map[string]any { + return map[string]any{ + "id": id, "source": source, "name": name, + "rule": decodedJSON(rule), "schema": decodedJSON(schema), + } +} + func eventTypeValues(rows []postgresdb.EventType) ([]eventtype.EventType, error) { out := make([]eventtype.EventType, 0, len(rows)) for _, r := range rows { @@ -113,11 +121,16 @@ func (s *EDA) InsertEventType(ctx context.Context, t eventtype.EventType) (strin return "", fmt.Errorf("edastore: encode event type schema: %w", err) } id := newRecordID() + orgID := string(org.OrgFromContext(ctx)) err = s.saveEventType(ctx, t, func(q *postgresdb.Queries, rule string) error { - return q.InsertEventType(ctx, postgresdb.InsertEventTypeParams{ + if err := q.InsertEventType(ctx, postgresdb.InsertEventTypeParams{ ID: id, Source: t.Source, Name: t.Name, Rule: rule, Schema: string(schema), - OrgID: string(org.OrgFromContext(ctx)), - }) + OrgID: orgID, + }); err != nil { + return err + } + return insertAuditValues(ctx, q, "event_types", id, "event_type", nil, + eventTypeAuditDoc(id, t.Source, t.Name, rule, string(schema)), 0, orgID) }) if err != nil { return "", err @@ -137,25 +150,55 @@ func (s *EDA) UpdateEventType(ctx context.Context, t eventtype.EventType) error } t.Source = stored.Source return s.saveEventType(ctx, t, func(q *postgresdb.Queries, rule string) error { - n, err := q.UpdateEventType(ctx, postgresdb.UpdateEventTypeParams{ID: t.ID, Name: t.Name, Rule: rule}) - if err == nil && n == 0 { + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "event_types", RecordKey: t.ID}); err != nil { + return err + } + old, err := q.GetEventType(ctx, postgresdb.GetEventTypeParams{ID: t.ID, ScopeOrg: scopeOrg(ctx)}) + if errors.Is(err, pgx.ErrNoRows) { return storecontract.ErrEventTypeNotFound } - return err + if err != nil { + return err + } + n, err := q.UpdateEventType(ctx, postgresdb.UpdateEventTypeParams{ID: t.ID, Name: t.Name, Rule: rule}) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrEventTypeNotFound + } + return insertAuditValues(ctx, q, "event_types", t.ID, "event_type", + eventTypeAuditDoc(old.ID, old.Source, old.Name, old.Rule, old.Schema), + eventTypeAuditDoc(t.ID, old.Source, t.Name, rule, old.Schema), + 0, old.OrgID) }) } // DeleteEventType removes a type. Captures already identified as it keep the // ID they were stored with. func (s *EDA) DeleteEventType(ctx context.Context, id string) error { - n, err := s.q.DeleteEventType(ctx, postgresdb.DeleteEventTypeParams{ID: id, ScopeOrg: scopeOrg(ctx)}) - if err != nil { - return err - } - if n == 0 { - return storecontract.ErrEventTypeNotFound - } - return nil + return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "event_types", RecordKey: id}); err != nil { + return err + } + old, err := q.GetEventType(ctx, postgresdb.GetEventTypeParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrEventTypeNotFound + } + if err != nil { + return err + } + n, err := q.DeleteEventType(ctx, postgresdb.DeleteEventTypeParams{ID: id, ScopeOrg: scopeOrg(ctx)}) + if err != nil { + return err + } + if n == 0 { + return storecontract.ErrEventTypeNotFound + } + return insertAuditValues(ctx, q, "event_types", id, "event_type", + eventTypeAuditDoc(old.ID, old.Source, old.Name, old.Rule, old.Schema), nil, 0, old.OrgID) + }) } // ListEventTypes returns every event type, by source then name. diff --git a/internal/infrastructure/postgres/orgs.go b/internal/infrastructure/postgres/orgs.go index 87ff90699..aed69c910 100644 --- a/internal/infrastructure/postgres/orgs.go +++ b/internal/infrastructure/postgres/orgs.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "strings" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgtype" @@ -57,6 +58,10 @@ func (s *Store) CreateOrg(ctx context.Context, value org.Org, owner identity.Ide }); err != nil { return org.Org{}, err } + if err := insertAuditValues(ctx, q, "orgs", string(value.ID), "org", nil, + map[string]string{"id": string(value.ID), "name": value.Name}, 0, string(value.ID)); err != nil { + return org.Org{}, err + } return value, tx.Commit(ctx) } @@ -94,13 +99,24 @@ func (s *Store) CreateWorkspace(ctx context.Context, value org.Workspace) (org.W if _, err := s.GetOrg(ctx, value.OrgID); err != nil { return org.Workspace{}, err } - if err := s.queries().InsertWorkspace(ctx, postgresdb.InsertWorkspaceParams{ - ID: string(value.ID), OrgID: string(value.OrgID), - Name: value.Name, Environment: value.Environment, - }); err != nil { - if isUniqueViolation(err) { - return org.Workspace{}, fmt.Errorf("%w: %s/%s", org.ErrWorkspaceExists, value.OrgID, value.ID) + err := pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + if err := q.InsertWorkspace(ctx, postgresdb.InsertWorkspaceParams{ + ID: string(value.ID), OrgID: string(value.OrgID), + Name: value.Name, Environment: value.Environment, + }); err != nil { + return err } + return insertAuditValues(ctx, q, "workspaces", string(value.OrgID)+"/"+string(value.ID), "workspace", nil, + map[string]string{ + "id": string(value.ID), "org_id": string(value.OrgID), + "name": value.Name, "environment": value.Environment, + }, 0, string(value.OrgID)) + }) + if isUniqueViolation(err) { + return org.Workspace{}, fmt.Errorf("%w: %s/%s", org.ErrWorkspaceExists, value.OrgID, value.ID) + } + if err != nil { return org.Workspace{}, err } return value, nil @@ -147,13 +163,52 @@ func (s *Store) EnsureMembership(ctx context.Context, value org.Membership) erro Role: string(value.Role), } if value.WorkspaceID != "" || value.Role == org.RoleOwner { - return s.queries().EnsureMembership(ctx, params) + return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + return ensureMembershipAudited(ctx, postgresdb.New(tx), value, params) + }) } return s.guardOwners(ctx, string(value.IdentityID), string(value.OrgID), func(q *postgresdb.Queries) error { - return q.EnsureMembership(ctx, params) + return ensureMembershipAudited(ctx, q, value, params) }) } +// membershipAuditKey names one membership by the scope the unique index uses, +// so an org-wide grant and a workspace grant never collide. +func membershipAuditKey(m org.Membership) string { + parts := []string{string(m.OrgID)} + if m.WorkspaceID != "" { + parts = append(parts, string(m.WorkspaceID)) + } + return strings.Join(append(parts, string(m.IdentityID)), "/") +} + +// ensureMembershipAudited upserts one membership and records the role it held +// before and holds now, in the caller's transaction. An unchanged role is not +// a change and writes no audit row. +func ensureMembershipAudited(ctx context.Context, q *postgresdb.Queries, value org.Membership, params postgresdb.EnsureMembershipParams) error { + key := membershipAuditKey(value) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "memberships", RecordKey: key}); err != nil { + return err + } + previous, err := q.MembershipRole(ctx, postgresdb.MembershipRoleParams{ + IdentityID: string(value.IdentityID), OrgID: string(value.OrgID), WorkspaceID: string(value.WorkspaceID), + }) + var oldRole any + switch { + case err == nil: + if previous == string(value.Role) { + return nil + } + oldRole = previous + case !errors.Is(err, pgx.ErrNoRows): + return err + } + if err := q.EnsureMembership(ctx, params); err != nil { + return err + } + return insertAuditValues(ctx, q, "memberships", key, "role", oldRole, string(value.Role), 0, string(value.OrgID)) +} + // AssignAgent records the one org an agent or service identity serves, // replacing any prior assignment for that identity. func (s *Store) AssignAgent(ctx context.Context, value org.AgentAssignment) error { @@ -163,8 +218,39 @@ func (s *Store) AssignAgent(ctx context.Context, value org.AgentAssignment) erro if _, err := s.GetOrg(ctx, value.OrgID); err != nil { return err } - return s.queries().UpsertAgentAssignment(ctx, postgresdb.UpsertAgentAssignmentParams{ - IdentityID: string(value.IdentityID), OrgID: string(value.OrgID), + return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + // The assignment is unique per identity, so the identity is the lock. + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "org_agents", RecordKey: string(value.IdentityID)}); err != nil { + return err + } + var oldOrg string + previous, err := q.AgentAssignmentOrg(ctx, string(value.IdentityID)) + switch { + case err == nil: + oldOrg = previous + if oldOrg == string(value.OrgID) { + return nil + } + case !errors.Is(err, pgx.ErrNoRows): + return err + } + if err := q.UpsertAgentAssignment(ctx, postgresdb.UpsertAgentAssignmentParams{ + IdentityID: string(value.IdentityID), OrgID: string(value.OrgID), + }); err != nil { + return err + } + // A move is two facts: the identity joins the target org and leaves the + // old one, each filed under the org it belongs to. + if err := insertAuditValues(ctx, q, "org_agents", string(value.OrgID)+"/"+string(value.IdentityID), "org_id", + nil, string(value.OrgID), 0, string(value.OrgID)); err != nil { + return err + } + if oldOrg != "" { + return insertAuditValues(ctx, q, "org_agents", oldOrg+"/"+string(value.IdentityID), "org_id", + oldOrg, nil, 0, oldOrg) + } + return nil }) } @@ -197,13 +283,43 @@ func (s *Store) RemoveMembership(ctx context.Context, value org.Membership) erro IdentityID: string(value.IdentityID), OrgID: string(value.OrgID), WorkspaceID: string(value.WorkspaceID), } if value.WorkspaceID != "" { - return s.queries().RemoveMembership(ctx, params) + return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + return removeMembershipAudited(ctx, postgresdb.New(tx), value, params) + }) } return s.guardOwners(ctx, string(value.IdentityID), string(value.OrgID), func(q *postgresdb.Queries) error { - return q.RemoveMembership(ctx, params) + return removeMembershipAudited(ctx, q, value, params) }) } +// removeMembershipAudited revokes one membership and records the role it held, +// only when a row was actually removed; a membership that was absent leaves no +// row to audit. +func removeMembershipAudited(ctx context.Context, q *postgresdb.Queries, value org.Membership, params postgresdb.RemoveMembershipParams) error { + key := membershipAuditKey(value) + if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "memberships", RecordKey: key}); err != nil { + return err + } + role, err := q.MembershipRole(ctx, postgresdb.MembershipRoleParams{ + IdentityID: string(value.IdentityID), OrgID: string(value.OrgID), WorkspaceID: string(value.WorkspaceID), + }) + if errors.Is(err, pgx.ErrNoRows) { + _, err := q.RemoveMembership(ctx, params) + return err + } + if err != nil { + return err + } + n, err := q.RemoveMembership(ctx, params) + if err != nil { + return err + } + if n == 0 { + return nil + } + return insertAuditValues(ctx, q, "memberships", key, "role", role, nil, 0, string(value.OrgID)) +} + // ListOrgAgents returns the agent and service identities assigned to an org. func (s *Store) ListOrgAgents(ctx context.Context, id org.OrgID) ([]org.AgentAssignment, error) { rows, err := s.queries().ListOrgAgents(ctx, string(id)) diff --git a/internal/infrastructure/postgres/postgresdb/access.sql.go b/internal/infrastructure/postgres/postgresdb/access.sql.go index cb028f5da..62c5b0146 100644 --- a/internal/infrastructure/postgres/postgresdb/access.sql.go +++ b/internal/infrastructure/postgres/postgresdb/access.sql.go @@ -133,9 +133,10 @@ func (q *Queries) DeleteAccessPolicyVersion(ctx context.Context, arg DeleteAcces return err } -const deleteOrgPoliciesNotShipped = `-- name: DeleteOrgPoliciesNotShipped :exec +const deleteOrgPoliciesNotShipped = `-- name: DeleteOrgPoliciesNotShipped :many DELETE FROM access_policies WHERE level = 'org' AND org_id = $1 AND NOT (policy_id = ANY($2::text[])) +RETURNING level, org_id, workspace_id, object_kind, object_id, policy_id, text ` type DeleteOrgPoliciesNotShippedParams struct { @@ -143,9 +144,42 @@ type DeleteOrgPoliciesNotShippedParams struct { Column2 []string } -func (q *Queries) DeleteOrgPoliciesNotShipped(ctx context.Context, arg DeleteOrgPoliciesNotShippedParams) error { - _, err := q.db.Exec(ctx, deleteOrgPoliciesNotShipped, arg.OrgID, arg.Column2) - return err +type DeleteOrgPoliciesNotShippedRow struct { + Level string + OrgID string + WorkspaceID string + ObjectKind string + ObjectID string + PolicyID string + Text string +} + +func (q *Queries) DeleteOrgPoliciesNotShipped(ctx context.Context, arg DeleteOrgPoliciesNotShippedParams) ([]DeleteOrgPoliciesNotShippedRow, error) { + rows, err := q.db.Query(ctx, deleteOrgPoliciesNotShipped, arg.OrgID, arg.Column2) + if err != nil { + return nil, err + } + defer rows.Close() + var items []DeleteOrgPoliciesNotShippedRow + for rows.Next() { + var i DeleteOrgPoliciesNotShippedRow + if err := rows.Scan( + &i.Level, + &i.OrgID, + &i.WorkspaceID, + &i.ObjectKind, + &i.ObjectID, + &i.PolicyID, + &i.Text, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil } const insertAccessPolicyAudit = `-- name: InsertAccessPolicyAudit :exec @@ -180,7 +214,7 @@ func (q *Queries) InsertAccessPolicyAudit(ctx context.Context, arg InsertAccessP const insertAccessResetAudit = `-- name: InsertAccessResetAudit :exec INSERT INTO sys_audit (at, table_name, record_key, field, record_version, actor, source, request_id, org_id) -VALUES (now(), 'access_policies', $1, 'reset', 1, 'archied access reset', 'archied', '', $2) +VALUES (now(), 'access_policies', $1, 'reset', 1, 'archie-state-store access reset', 'archie-state-store', '', $2) ` type InsertAccessResetAuditParams struct { @@ -326,13 +360,47 @@ func (q *Queries) RecordDenial(ctx context.Context, arg RecordDenialParams) erro return err } -const resetInstancePolicies = `-- name: ResetInstancePolicies :exec +const resetInstancePolicies = `-- name: ResetInstancePolicies :many DELETE FROM access_policies WHERE level = 'instance' +RETURNING level, org_id, workspace_id, object_kind, object_id, policy_id, text ` -func (q *Queries) ResetInstancePolicies(ctx context.Context) error { - _, err := q.db.Exec(ctx, resetInstancePolicies) - return err +type ResetInstancePoliciesRow struct { + Level string + OrgID string + WorkspaceID string + ObjectKind string + ObjectID string + PolicyID string + Text string +} + +func (q *Queries) ResetInstancePolicies(ctx context.Context) ([]ResetInstancePoliciesRow, error) { + rows, err := q.db.Query(ctx, resetInstancePolicies) + if err != nil { + return nil, err + } + defer rows.Close() + var items []ResetInstancePoliciesRow + for rows.Next() { + var i ResetInstancePoliciesRow + if err := rows.Scan( + &i.Level, + &i.OrgID, + &i.WorkspaceID, + &i.ObjectKind, + &i.ObjectID, + &i.PolicyID, + &i.Text, + ); err != nil { + return nil, err + } + items = append(items, i) + } + if err := rows.Err(); err != nil { + return nil, err + } + return items, nil } const upsertAccessPolicy = `-- name: UpsertAccessPolicy :exec diff --git a/internal/infrastructure/postgres/postgresdb/audit.sql.go b/internal/infrastructure/postgres/postgresdb/audit.sql.go index a98712cdb..8afa2d25f 100644 --- a/internal/infrastructure/postgres/postgresdb/audit.sql.go +++ b/internal/infrastructure/postgres/postgresdb/audit.sql.go @@ -150,3 +150,20 @@ func (q *Queries) InsertResourceAudit(ctx context.Context, arg InsertResourceAud ) return err } + +const lockAuditRecord = `-- name: LockAuditRecord :exec +SELECT pg_advisory_xact_lock(hashtextextended($1::text || ':' || $2::text, 0)) +` + +type LockAuditRecordParams struct { + TableName string + RecordKey string +} + +// Serialises a read-modify-write on one audited record so the old side the +// audit row reports cannot change between the read and the write. Row locks +// cannot hold a key that does not exist yet; this can. +func (q *Queries) LockAuditRecord(ctx context.Context, arg LockAuditRecordParams) error { + _, err := q.db.Exec(ctx, lockAuditRecord, arg.TableName, arg.RecordKey) + return err +} diff --git a/internal/infrastructure/postgres/postgresdb/orgs.sql.go b/internal/infrastructure/postgres/postgresdb/orgs.sql.go index e39a4c123..406531402 100644 --- a/internal/infrastructure/postgres/postgresdb/orgs.sql.go +++ b/internal/infrastructure/postgres/postgresdb/orgs.sql.go @@ -11,6 +11,17 @@ import ( "github.com/jackc/pgx/v5/pgtype" ) +const agentAssignmentOrg = `-- name: AgentAssignmentOrg :one +SELECT org_id FROM org_agents WHERE identity_id = $1 +` + +func (q *Queries) AgentAssignmentOrg(ctx context.Context, identityID string) (string, error) { + row := q.db.QueryRow(ctx, agentAssignmentOrg, identityID) + var org_id string + err := row.Scan(&org_id) + return org_id, err +} + const ensureAgentOrgMembership = `-- name: EnsureAgentOrgMembership :exec INSERT INTO memberships (identity_id, org_id, role) SELECT a.identity_id, a.org_id, 'developer' FROM org_agents a @@ -297,7 +308,28 @@ func (q *Queries) ListWorkspaces(ctx context.Context, orgID string) ([]Workspace return items, nil } -const removeMembership = `-- name: RemoveMembership :exec +const membershipRole = `-- name: MembershipRole :one +SELECT role FROM memberships +WHERE identity_id = $1 AND org_id = $2 + AND COALESCE(workspace_id, '') = $3::text +` + +type MembershipRoleParams struct { + IdentityID string + OrgID string + WorkspaceID string +} + +// The current role of the membership EnsureMembership/RemoveMembership targets, +// read in the same transaction so the audit row carries both sides. +func (q *Queries) MembershipRole(ctx context.Context, arg MembershipRoleParams) (string, error) { + row := q.db.QueryRow(ctx, membershipRole, arg.IdentityID, arg.OrgID, arg.WorkspaceID) + var role string + err := row.Scan(&role) + return role, err +} + +const removeMembership = `-- name: RemoveMembership :execrows DELETE FROM memberships WHERE identity_id = $1 AND org_id = $2 AND COALESCE(workspace_id, '') = $3::text ` @@ -310,9 +342,12 @@ type RemoveMembershipParams struct { // The workspace is matched through the same COALESCE the unique index uses, so // an org-wide membership (NULL) and the empty string are the same target. -func (q *Queries) RemoveMembership(ctx context.Context, arg RemoveMembershipParams) error { - _, err := q.db.Exec(ctx, removeMembership, arg.IdentityID, arg.OrgID, arg.WorkspaceID) - return err +func (q *Queries) RemoveMembership(ctx context.Context, arg RemoveMembershipParams) (int64, error) { + result, err := q.db.Exec(ctx, removeMembership, arg.IdentityID, arg.OrgID, arg.WorkspaceID) + if err != nil { + return 0, err + } + return result.RowsAffected(), nil } const resolveIdentityOrg = `-- name: ResolveIdentityOrg :one diff --git a/internal/infrastructure/postgres/queries/access.sql b/internal/infrastructure/postgres/queries/access.sql index 7dc5ca4a4..d8e4d2cac 100644 --- a/internal/infrastructure/postgres/queries/access.sql +++ b/internal/infrastructure/postgres/queries/access.sql @@ -38,12 +38,14 @@ FOR UPDATE; SELECT count(*) FROM access_policies WHERE level = 'org' AND org_id = $1 AND policy_id = ANY($2::text[]); --- name: DeleteOrgPoliciesNotShipped :exec +-- name: DeleteOrgPoliciesNotShipped :many DELETE FROM access_policies -WHERE level = 'org' AND org_id = $1 AND NOT (policy_id = ANY($2::text[])); +WHERE level = 'org' AND org_id = $1 AND NOT (policy_id = ANY($2::text[])) +RETURNING level, org_id, workspace_id, object_kind, object_id, policy_id, text; --- name: ResetInstancePolicies :exec -DELETE FROM access_policies WHERE level = 'instance'; +-- name: ResetInstancePolicies :many +DELETE FROM access_policies WHERE level = 'instance' +RETURNING level, org_id, workspace_id, object_kind, object_id, policy_id, text; -- name: UpsertAccessPolicyVersion :one INSERT INTO access_policy_versions (level, org_id, workspace_id, version) VALUES ($1, $2, $3, 2) @@ -74,7 +76,7 @@ FROM access_denials WHERE org_id = $1 ORDER BY id DESC LIMIT $2; -- name: InsertAccessResetAudit :exec INSERT INTO sys_audit (at, table_name, record_key, field, record_version, actor, source, request_id, org_id) -VALUES (now(), 'access_policies', $1, 'reset', 1, 'archied access reset', 'archied', '', $2); +VALUES (now(), 'access_policies', $1, 'reset', 1, 'archie-state-store access reset', 'archie-state-store', '', $2); -- name: BumpAccessPolicyRevision :one -- The instance-wide version. It moves inside the transaction of every policy diff --git a/internal/infrastructure/postgres/queries/audit.sql b/internal/infrastructure/postgres/queries/audit.sql index fccbdb7c1..b234daf26 100644 --- a/internal/infrastructure/postgres/queries/audit.sql +++ b/internal/infrastructure/postgres/queries/audit.sql @@ -10,6 +10,12 @@ FROM audit_json_diff( ) d ORDER BY d.field; +-- name: LockAuditRecord :exec +-- Serialises a read-modify-write on one audited record so the old side the +-- audit row reports cannot change between the read and the write. Row locks +-- cannot hold a key that does not exist yet; this can. +SELECT pg_advisory_xact_lock(hashtextextended(sqlc.arg(table_name)::text || ':' || sqlc.arg(record_key)::text, 0)); + -- name: InsertAudit :exec -- The generic write for tables that are not control-plane resources. Callers -- pass the table's own name as table_name; old_value is nil for a create and diff --git a/internal/infrastructure/postgres/queries/orgs.sql b/internal/infrastructure/postgres/queries/orgs.sql index 2b76d5e87..1dbf3aeef 100644 --- a/internal/infrastructure/postgres/queries/orgs.sql +++ b/internal/infrastructure/postgres/queries/orgs.sql @@ -33,7 +33,14 @@ JOIN identities i ON i.id = m.identity_id WHERE m.org_id = $1 ORDER BY m.created_at, m.identity_id, m.workspace_id; --- name: RemoveMembership :exec +-- name: MembershipRole :one +-- The current role of the membership EnsureMembership/RemoveMembership targets, +-- read in the same transaction so the audit row carries both sides. +SELECT role FROM memberships +WHERE identity_id = sqlc.arg(identity_id) AND org_id = sqlc.arg(org_id) + AND COALESCE(workspace_id, '') = sqlc.arg(workspace_id)::text; + +-- name: RemoveMembership :execrows -- The workspace is matched through the same COALESCE the unique index uses, so -- an org-wide membership (NULL) and the empty string are the same target. DELETE FROM memberships @@ -46,6 +53,9 @@ SELECT identity_id, org_id FROM org_agents WHERE org_id = $1 ORDER BY identity_i SELECT identity_id, org_id, workspace_id, role, created_at FROM memberships WHERE identity_id = $1 ORDER BY created_at, org_id; +-- name: AgentAssignmentOrg :one +SELECT org_id FROM org_agents WHERE identity_id = $1; + -- name: UpsertAgentAssignment :exec INSERT INTO org_agents (identity_id, org_id) VALUES ($1, $2) ON CONFLICT (identity_id) DO UPDATE SET org_id = excluded.org_id; diff --git a/internal/infrastructure/postgres/sources.go b/internal/infrastructure/postgres/sources.go index 40464cedf..26461ab06 100644 --- a/internal/infrastructure/postgres/sources.go +++ b/internal/infrastructure/postgres/sources.go @@ -79,23 +79,30 @@ func (s *EDA) ListSources(ctx context.Context) ([]source.Source, error) { // SetSourceSigning moves a source from one signing state to another, and // refuses when the stored state is no longer from. func (s *EDA) SetSourceSigning(ctx context.Context, path string, from, to source.Signing) error { - n, err := s.q.SetSourceSigning(ctx, postgresdb.SetSourceSigningParams{ - Path: path, FromSigning: string(from), ToSigning: string(to), ScopeOrg: scopeOrg(ctx), + orgID := string(org.OrgFromContext(ctx)) + return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + n, err := q.SetSourceSigning(ctx, postgresdb.SetSourceSigningParams{ + Path: path, FromSigning: string(from), ToSigning: string(to), ScopeOrg: scopeOrg(ctx), + }) + if err != nil { + return fmt.Errorf("edastore: set source signing: %w", err) + } + if n == 1 { + if from == to { + return nil + } + return insertAuditValues(ctx, q, "sources", path, "signing", string(from), string(to), 0, orgID) + } + exists, err := q.SourceExists(ctx, path) + if err != nil { + return fmt.Errorf("edastore: set source signing: %w", err) + } + if !exists { + return storecontract.ErrSourceNotFound + } + return storecontract.ErrSourceSigningStale }) - if err != nil { - return fmt.Errorf("edastore: set source signing: %w", err) - } - if n == 1 { - return nil - } - exists, err := s.q.SourceExists(ctx, path) - if err != nil { - return fmt.Errorf("edastore: set source signing: %w", err) - } - if !exists { - return storecontract.ErrSourceNotFound - } - return storecontract.ErrSourceSigningStale } func (s *EDA) SetSourceSecret(ctx context.Context, path, secret string) error { @@ -103,14 +110,20 @@ func (s *EDA) SetSourceSecret(ctx context.Context, path, secret string) error { if err != nil { return err } - n, err := s.q.SetSourceSecret(ctx, postgresdb.SetSourceSecretParams{Path: path, Secret: sealed, ScopeOrg: scopeOrg(ctx)}) - if err != nil { - return fmt.Errorf("edastore: set source secret: %w", err) - } - if n == 0 { - return storecontract.ErrSourceNotFound - } - return nil + orgID := string(org.OrgFromContext(ctx)) + return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + n, err := q.SetSourceSecret(ctx, postgresdb.SetSourceSecretParams{Path: path, Secret: sealed, ScopeOrg: scopeOrg(ctx)}) + if err != nil { + return fmt.Errorf("edastore: set source secret: %w", err) + } + if n == 0 { + return storecontract.ErrSourceNotFound + } + // The value never reaches the trail: only the fact that it changed does. + changed := map[string]bool{"changed": true} + return insertAuditValues(ctx, q, "sources", path, "secret", changed, changed, 0, orgID) + }) } // SetSourceName relabels a source. @@ -139,21 +152,40 @@ func (s *EDA) SetSourceDeliveryHeader(ctx context.Context, path, header string) // DeleteSource deletes a source no armed binding fires on. func (s *EDA) DeleteSource(ctx context.Context, path string) error { - n, err := s.q.DeleteUnboundSource(ctx, postgresdb.DeleteUnboundSourceParams{Path: path, ScopeOrg: scopeOrg(ctx)}) - if err != nil { - return fmt.Errorf("edastore: delete source: %w", err) - } - if n > 0 { - return nil - } - exists, err := s.q.SourceExists(ctx, path) - if err != nil { - return fmt.Errorf("edastore: delete source: %w", err) - } - if exists { - return storecontract.ErrSourceInUse - } - return storecontract.ErrSourceNotFound + return pgx.BeginFunc(ctx, s.pool, func(tx pgx.Tx) error { + q := postgresdb.New(tx) + // The read is scoped like the delete: another org's source is absent, + // and its secret never leaves the database. + params := postgresdb.GetSourceParams{Path: path, ScopeOrg: scopeOrg(ctx)} + old, err := q.GetSource(ctx, params) + if errors.Is(err, pgx.ErrNoRows) { + return storecontract.ErrSourceNotFound + } + if err != nil { + return fmt.Errorf("edastore: delete source: %w", err) + } + n, err := q.DeleteUnboundSource(ctx, postgresdb.DeleteUnboundSourceParams{Path: path, ScopeOrg: scopeOrg(ctx)}) + if err != nil { + return fmt.Errorf("edastore: delete source: %w", err) + } + if n == 0 { + // It was there a moment ago: gone means someone else removed it, + // otherwise an armed binding holds it in place. + switch _, err := q.GetSource(ctx, params); { + case errors.Is(err, pgx.ErrNoRows): + return storecontract.ErrSourceNotFound + case err != nil: + return fmt.Errorf("edastore: delete source: %w", err) + default: + return storecontract.ErrSourceInUse + } + } + return insertAuditValues(ctx, q, "sources", path, "source", + map[string]string{ + "path": old.Path, "name": old.Name, "signing": old.Signing, + "delivery_header": old.DeliveryHeader, "org_id": old.OrgID, "workspace_id": old.WorkspaceID, + }, nil, 0, old.OrgID) + }) } // sealSecret encrypts a non-empty secret when a cipher is configured.