deploy / plan (push) Successful in 6s
deploy / archied-image (push) Canceled after 0s
deploy / agent-image (push) Canceled after 0s
deploy / dist-zip (push) Canceled after 0s
deploy / gate (push) Canceled after 5m37s
ci/woodpecker/push/deploy Pipeline was canceled
246 lines
9.2 KiB
Go
246 lines
9.2 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
// Resources is the PostgreSQL implementation of the State Store's
|
|
// control-plane resource document operations.
|
|
type Resources struct {
|
|
pool *pgxpool.Pool
|
|
}
|
|
|
|
func NewResources(pool *pgxpool.Pool) *Resources {
|
|
return &Resources{pool: pool}
|
|
}
|
|
|
|
// ListResources supplies every org's documents for startup validation.
|
|
func (s *Resources) ListResources(ctx context.Context) ([]storecontract.Resource, error) {
|
|
rows, err := postgresdb.New(s.pool).ListResources(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resources := make([]storecontract.Resource, 0, len(rows))
|
|
for _, row := range rows {
|
|
resources = append(resources, resourceFromCurrent(row))
|
|
}
|
|
return resources, nil
|
|
}
|
|
|
|
func (s *Resources) Resource(ctx context.Context, orgID, kind string) (storecontract.Resource, error) {
|
|
if err := checkResourceKey(orgID, kind); err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
resource, err := postgresdb.New(s.pool).ResourceByKind(ctx, postgresdb.ResourceByKindParams{OrgID: orgID, Kind: kind})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return storecontract.Resource{}, storecontract.ErrResourceNotFound
|
|
}
|
|
if err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
return resourceFromCurrent(resource), nil
|
|
}
|
|
|
|
func (s *Resources) ResourceHistory(ctx context.Context, orgID, kind string, limit int) ([]storecontract.Resource, error) {
|
|
if err := checkResourceKey(orgID, kind); err != nil {
|
|
return nil, err
|
|
}
|
|
if limit <= 0 {
|
|
limit = 0
|
|
}
|
|
history, err := postgresdb.New(s.pool).ResourceHistory(ctx, postgresdb.ResourceHistoryParams{
|
|
OrgID: orgID, Kind: kind, EntryLimit: int64(limit),
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resources := make([]storecontract.Resource, 0, len(history))
|
|
for _, entry := range history {
|
|
resources = append(resources, resourceFromAudit(
|
|
entry.OrgID, entry.Kind, entry.Value, entry.Version, entry.Actor, entry.Source,
|
|
entry.RequestID, entry.ExpectedVersion, entry.CurrentVersion, entry.At,
|
|
))
|
|
}
|
|
return resources, nil
|
|
}
|
|
|
|
// checkResourceKey refuses a key the audit record key could not tell apart from
|
|
// another: an empty org or kind, or either containing the "/" that joins them
|
|
// in storecontract.ResourceAuditKey. A forgotten org fails here rather than
|
|
// reading as an absent resource.
|
|
func checkResourceKey(orgID, kind string) error {
|
|
if orgID == "" || kind == "" || strings.Contains(orgID, "/") || strings.Contains(kind, "/") {
|
|
return fmt.Errorf("invalid resource key: org %q, kind %q", orgID, kind)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// blockersFixedBy names the park blockers an edit of a resource kind may have
|
|
// cleared.
|
|
func blockersFixedBy(kind string) []string {
|
|
switch kind {
|
|
case "forge-connections":
|
|
return []string{taskstate.BlockerConnectionPermit, taskstate.BlockerConnectionCredential, taskstate.BlockerForgeExtension, taskstate.BlockerRepository}
|
|
case "identity-grants":
|
|
return []string{taskstate.BlockerConnectionPermit, taskstate.BlockerAgentAssignment}
|
|
case "repository-policies":
|
|
return []string{taskstate.BlockerRepository}
|
|
case "credential-bindings":
|
|
return []string{taskstate.BlockerConnectionCredential, taskstate.BlockerModelCredential}
|
|
case "provider-settings":
|
|
return []string{taskstate.BlockerModelCredential, taskstate.BlockerModelCredit}
|
|
case "workflow-enablement":
|
|
return []string{taskstate.BlockerWorkflowDisabled}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// PutResource applies one control-plane resource write, idempotent per
|
|
// request ID.
|
|
func (s *Resources) PutResource(ctx context.Context, write storecontract.ResourceWrite) (_ storecontract.Resource, retErr error) {
|
|
if err := checkResourceKey(write.OrgID, write.Kind); err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
queries := postgresdb.New(tx)
|
|
if err := queries.LockResourceWrite(ctx, postgresdb.LockResourceWriteParams{OrgID: write.OrgID, Kind: write.Kind}); err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
if existing, err := queries.ResourceByRequest(ctx, postgresdb.ResourceByRequestParams{
|
|
OrgID: write.OrgID, Kind: write.Kind, RequestID: write.RequestID,
|
|
}); err == nil {
|
|
resource, err := s.replayedResource(ctx, queries, tx, existing)
|
|
if err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
return resource, nil
|
|
} else if !errors.Is(err, pgx.ErrNoRows) {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
|
|
current, err := queries.ResourceVersion(ctx, postgresdb.ResourceVersionParams{OrgID: write.OrgID, Kind: write.Kind})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
current = 0
|
|
} else if err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
if current != write.ExpectedVersion {
|
|
return storecontract.Resource{}, fmt.Errorf("%w: expected %d, current %d", storecontract.ErrResourceVersionConflict, write.ExpectedVersion, current)
|
|
}
|
|
history, err := appendResourceRevision(ctx, queries, write, current)
|
|
if err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
if blockers := blockersFixedBy(write.Kind); len(blockers) > 0 {
|
|
if _, err := queries.MarkBlockerChanged(ctx, postgresdb.MarkBlockerChangedParams{OrgID: write.OrgID, Blockers: blockers}); err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
return resourceFromAudit(
|
|
history.OrgID, history.Kind, history.Value, history.Version, history.Actor, history.Source,
|
|
history.RequestID, history.ExpectedVersion, history.CurrentVersion, history.At,
|
|
), nil
|
|
}
|
|
|
|
// appendResourceRevision writes the resource row, its ledger entry and its audit
|
|
// trail for one accepted write, returning the ledger entry. current is the
|
|
// version being replaced, zero for a first write.
|
|
func appendResourceRevision(ctx context.Context, queries *postgresdb.Queries, write storecontract.ResourceWrite, current int64) (postgresdb.InsertResourceHistoryRow, error) {
|
|
if write.At.IsZero() {
|
|
write.At = time.Now().UTC()
|
|
} else {
|
|
write.At = write.At.UTC()
|
|
}
|
|
|
|
var (
|
|
resource postgresdb.Resource
|
|
err error
|
|
)
|
|
if current == 0 {
|
|
resource, err = queries.InsertResource(ctx, postgresdb.InsertResourceParams{
|
|
OrgID: write.OrgID, Kind: write.Kind, Value: write.Value, UpdatedAt: write.At,
|
|
})
|
|
} else {
|
|
resource, err = queries.UpdateResource(ctx, postgresdb.UpdateResourceParams{
|
|
OrgID: write.OrgID, Kind: write.Kind, Value: write.Value, UpdatedAt: write.At, Version: current,
|
|
})
|
|
}
|
|
if err != nil {
|
|
return postgresdb.InsertResourceHistoryRow{}, err
|
|
}
|
|
history, err := queries.InsertResourceHistory(ctx, postgresdb.InsertResourceHistoryParams{
|
|
OrgID: write.OrgID, Kind: write.Kind, Value: write.Value, Version: resource.Version, Actor: write.Actor,
|
|
Source: write.Source, RequestID: write.RequestID, ExpectedVersion: write.ExpectedVersion,
|
|
CurrentVersion: current, At: write.At,
|
|
})
|
|
if err != nil {
|
|
return postgresdb.InsertResourceHistoryRow{}, err
|
|
}
|
|
if err := queries.InsertResourceAudit(ctx, postgresdb.InsertResourceAuditParams{
|
|
At: write.At, OrgID: write.OrgID, RecordKey: storecontract.ResourceAuditKey(write.OrgID, write.Kind), Kind: write.Kind, Version: resource.Version, Actor: write.Actor,
|
|
Source: write.Source, RequestID: write.RequestID, PreviousVersion: current, Value: write.Value,
|
|
}); err != nil {
|
|
return postgresdb.InsertResourceHistoryRow{}, err
|
|
}
|
|
return history, nil
|
|
}
|
|
|
|
// replayedResource answers a repeated request ID with its recorded revision,
|
|
// re-creating the row if it was removed since.
|
|
func (s *Resources) replayedResource(ctx context.Context, queries *postgresdb.Queries, tx pgx.Tx, existing postgresdb.ResourceByRequestRow) (storecontract.Resource, error) {
|
|
if _, err := queries.ResourceByKind(ctx, postgresdb.ResourceByKindParams{OrgID: existing.OrgID, Kind: existing.Kind}); errors.Is(err, pgx.ErrNoRows) {
|
|
if _, err := queries.ReinsertResource(ctx, postgresdb.ReinsertResourceParams{
|
|
OrgID: existing.OrgID, Kind: existing.Kind, Value: existing.Value, Version: existing.Version, UpdatedAt: existing.At,
|
|
}); err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
} else if err != nil {
|
|
return storecontract.Resource{}, err
|
|
}
|
|
return resourceFromAudit(
|
|
existing.OrgID, existing.Kind, existing.Value, existing.Version, existing.Actor, existing.Source,
|
|
existing.RequestID, existing.ExpectedVersion, existing.CurrentVersion, existing.At,
|
|
), nil
|
|
}
|
|
|
|
func resourceFromCurrent(resource postgresdb.Resource) storecontract.Resource {
|
|
return storecontract.Resource{
|
|
OrgID: resource.OrgID, Kind: resource.Kind, Value: resource.Value, Version: resource.Version, At: resource.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
func resourceFromAudit(
|
|
orgID, kind string,
|
|
value []byte,
|
|
version int64,
|
|
actor, source, requestID string,
|
|
expectedVersion, currentVersion int64,
|
|
at time.Time,
|
|
) storecontract.Resource {
|
|
return storecontract.Resource{
|
|
OrgID: orgID, Kind: kind, Value: value, Version: version, Actor: actor, Source: source,
|
|
RequestID: requestID, ExpectedVersion: expectedVersion, CurrentVersion: currentVersion, At: at,
|
|
}
|
|
}
|