feat(state): audit access reset, org, membership and EDA writes
This commit is contained in:
14 files changed
+873
-185
No files matched your search
@@ -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,27 @@ 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))
|
||||
}
|
||||
if err := auditResetDeletes(ctx, q, policies); err != nil {
|
||||
return err
|
||||
}
|
||||
// Commit the revision with the deletes: an authorizer must stop
|
||||
// honouring a removed policy even if the re-puts never run.
|
||||
_, err = q.BumpAccessPolicyRevision(ctx)
|
||||
return err
|
||||
}); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -268,8 +344,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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -10,6 +10,7 @@ import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"reflect"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
@@ -73,6 +74,63 @@ 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, workspaceID 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,
|
||||
"workspace_id": workspaceID, "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.WorkspaceID, r.Version)
|
||||
}
|
||||
|
||||
// bindingWorkspace is the workspace the binding SQL derives: its source's, or
|
||||
// "default" when the source no longer exists.
|
||||
func bindingWorkspace(ctx context.Context, q *postgresdb.Queries, source, orgID string) (string, error) {
|
||||
workspace, err := q.SourceWorkspace(ctx, postgresdb.SourceWorkspaceParams{Path: source, OrgID: orgID})
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return "default", nil
|
||||
}
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return workspace, nil
|
||||
}
|
||||
|
||||
// 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 +287,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 +347,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
|
||||
}
|
||||
oldDoc := mappingRowAuditDoc(old)
|
||||
newDoc := mappingAuditDoc(m.ID, m.Name, m.SourceHint, m.EventTypeID, encoded)
|
||||
if reflect.DeepEqual(oldDoc, newDoc) {
|
||||
return nil
|
||||
}
|
||||
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
|
||||
}
|
||||
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 +475,34 @@ 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)
|
||||
workspace, err := bindingWorkspace(ctx, q, b.Matcher.Source, orgID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
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), workspace, 1), 1, orgID)
|
||||
}); err != nil {
|
||||
return "", err
|
||||
}
|
||||
s.notifyWrite(events.KindBindingChanged, "binding", "create", id)
|
||||
return id, nil
|
||||
@@ -448,61 +565,125 @@ 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
|
||||
}
|
||||
// The target workspace comes from the source, so hold the source's lock
|
||||
// until the UPDATE has recomputed it too. Binding then source is the
|
||||
// only order taken, so it cannot cycle.
|
||||
if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "sources", RecordKey: b.Matcher.Source}); err != nil {
|
||||
return err
|
||||
}
|
||||
targetWorkspace, err := bindingWorkspace(ctx, q, b.Matcher.Source, old.OrgID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if bindingEditableEqual(old, b, inputs) && old.Status == string(binding.StatusPendingApproval) &&
|
||||
old.WorkspaceID == targetWorkspace {
|
||||
return nil
|
||||
}
|
||||
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
|
||||
}
|
||||
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), targetWorkspace, 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 +700,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
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -4,6 +4,7 @@ import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgtype"
|
||||
@@ -47,12 +48,20 @@ func (s *Store) CreateOrg(ctx context.Context, value org.Org, owner identity.Ide
|
||||
}
|
||||
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
|
||||
}
|
||||
workspace := org.Workspace{ID: org.DefaultWorkspaceID, OrgID: value.ID, Name: "Default"}
|
||||
if err := q.InsertWorkspace(ctx, postgresdb.InsertWorkspaceParams{
|
||||
ID: string(org.DefaultWorkspaceID), OrgID: string(value.ID), Name: "Default",
|
||||
ID: string(workspace.ID), OrgID: string(workspace.OrgID), Name: workspace.Name,
|
||||
}); err != nil {
|
||||
return org.Org{}, err
|
||||
}
|
||||
if err := q.EnsureMembership(ctx, postgresdb.EnsureMembershipParams{
|
||||
if err := auditWorkspaceCreate(ctx, q, workspace); err != nil {
|
||||
return org.Org{}, err
|
||||
}
|
||||
if err := ensureMembershipAudited(ctx, q, membership, postgresdb.EnsureMembershipParams{
|
||||
IdentityID: string(owner), OrgID: string(value.ID), Role: string(org.RoleOwner),
|
||||
}); err != nil {
|
||||
return org.Org{}, err
|
||||
@@ -94,18 +103,34 @@ 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 auditWorkspaceCreate(ctx, q, value)
|
||||
})
|
||||
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
|
||||
}
|
||||
|
||||
// auditWorkspaceCreate writes the create row for a workspace.
|
||||
func auditWorkspaceCreate(ctx context.Context, q *postgresdb.Queries, value org.Workspace) error {
|
||||
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))
|
||||
}
|
||||
|
||||
// workspaceFromRow maps the generated workspace row to the domain workspace.
|
||||
func workspaceFromRow(w postgresdb.Workspace) org.Workspace {
|
||||
return org.Workspace{
|
||||
@@ -147,13 +172,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 +227,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 +292,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))
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -1205,6 +1205,24 @@ func (q *Queries) SourceExists(ctx context.Context, path string) (bool, error) {
|
||||
return exists, err
|
||||
}
|
||||
|
||||
const sourceWorkspace = `-- name: SourceWorkspace :one
|
||||
SELECT workspace_id FROM sources WHERE path = $1 AND org_id = $2
|
||||
`
|
||||
|
||||
type SourceWorkspaceParams struct {
|
||||
Path string
|
||||
OrgID string
|
||||
}
|
||||
|
||||
// The workspace the binding/mapping SQL derives from a source path, so an
|
||||
// audit snapshots the same value the write stores.
|
||||
func (q *Queries) SourceWorkspace(ctx context.Context, arg SourceWorkspaceParams) (string, error) {
|
||||
row := q.db.QueryRow(ctx, sourceWorkspace, arg.Path, arg.OrgID)
|
||||
var workspace_id string
|
||||
err := row.Scan(&workspace_id)
|
||||
return workspace_id, err
|
||||
}
|
||||
|
||||
const taskToolCalls = `-- name: TaskToolCalls :many
|
||||
SELECT id, task_id, attempt, tool, result, error, called_at
|
||||
FROM tool_calls WHERE task_id = $1 AND ($2::text IS NULL OR org_id = $2) ORDER BY called_at ASC
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -208,6 +208,11 @@ FROM workspaces w WHERE w.org_id = sqlc.arg(org_id) AND w.id = sqlc.arg(workspac
|
||||
-- name: GetSource :one
|
||||
SELECT path, signing, secret, created_at, updated_at, org_id, workspace_id, name, delivery_header FROM sources WHERE path = sqlc.arg(path) AND (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org));
|
||||
|
||||
-- name: SourceWorkspace :one
|
||||
-- The workspace the binding/mapping SQL derives from a source path, so an
|
||||
-- audit snapshots the same value the write stores.
|
||||
SELECT workspace_id FROM sources WHERE path = sqlc.arg(path) AND org_id = sqlc.arg(org_id);
|
||||
|
||||
-- name: ListSources :many
|
||||
SELECT path, signing, secret, created_at, updated_at, org_id, workspace_id, name, delivery_header FROM sources WHERE (sqlc.narg(scope_org)::text IS NULL OR org_id = sqlc.narg(scope_org)) ORDER BY created_at DESC, path;
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -79,23 +79,44 @@ 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)
|
||||
if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "sources", RecordKey: path}); err != nil {
|
||||
return err
|
||||
}
|
||||
if from == to {
|
||||
// No transition to write; still report a missing source or a
|
||||
// caller whose idea of the current state is stale.
|
||||
current, err := q.GetSource(ctx, postgresdb.GetSourceParams{Path: path, ScopeOrg: scopeOrg(ctx)})
|
||||
switch {
|
||||
case errors.Is(err, pgx.ErrNoRows):
|
||||
return storecontract.ErrSourceNotFound
|
||||
case err != nil:
|
||||
return fmt.Errorf("edastore: set source signing: %w", err)
|
||||
case current.Signing != string(to):
|
||||
return storecontract.ErrSourceSigningStale
|
||||
}
|
||||
return nil
|
||||
}
|
||||
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 {
|
||||
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,57 +124,100 @@ 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)
|
||||
if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "sources", RecordKey: path}); err != nil {
|
||||
return err
|
||||
}
|
||||
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.
|
||||
func (s *EDA) SetSourceName(ctx context.Context, path, name string) error {
|
||||
n, err := s.q.SetSourceName(ctx, postgresdb.SetSourceNameParams{Path: path, Name: name, ScopeOrg: scopeOrg(ctx)})
|
||||
if err != nil {
|
||||
return fmt.Errorf("edastore: set source name: %w", err)
|
||||
}
|
||||
if n == 0 {
|
||||
return storecontract.ErrSourceNotFound
|
||||
}
|
||||
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: "sources", RecordKey: path}); err != nil {
|
||||
return err
|
||||
}
|
||||
n, err := q.SetSourceName(ctx, postgresdb.SetSourceNameParams{Path: path, Name: name, ScopeOrg: scopeOrg(ctx)})
|
||||
if err != nil {
|
||||
return fmt.Errorf("edastore: set source name: %w", err)
|
||||
}
|
||||
if n == 0 {
|
||||
return storecontract.ErrSourceNotFound
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// SetSourceDeliveryHeader sets the header that names a source's deliveries.
|
||||
func (s *EDA) SetSourceDeliveryHeader(ctx context.Context, path, header string) error {
|
||||
n, err := s.q.SetSourceDeliveryHeader(ctx, postgresdb.SetSourceDeliveryHeaderParams{Path: path, DeliveryHeader: header, ScopeOrg: scopeOrg(ctx)})
|
||||
if err != nil {
|
||||
return fmt.Errorf("edastore: set source delivery header: %w", err)
|
||||
}
|
||||
if n == 0 {
|
||||
return storecontract.ErrSourceNotFound
|
||||
}
|
||||
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: "sources", RecordKey: path}); err != nil {
|
||||
return err
|
||||
}
|
||||
n, err := q.SetSourceDeliveryHeader(ctx, postgresdb.SetSourceDeliveryHeaderParams{Path: path, DeliveryHeader: header, ScopeOrg: scopeOrg(ctx)})
|
||||
if err != nil {
|
||||
return fmt.Errorf("edastore: set source delivery header: %w", err)
|
||||
}
|
||||
if n == 0 {
|
||||
return storecontract.ErrSourceNotFound
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// 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)
|
||||
if err := q.LockAuditRecord(ctx, postgresdb.LockAuditRecordParams{TableName: "sources", RecordKey: path}); err != nil {
|
||||
return err
|
||||
}
|
||||
// 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.
|
||||
|
||||
Reference in new issue
Block a user