Complete the var _ storecontract.X = (*T)(nil) sweep so each of the 31 contract interfaces is compiler-checked against at least one adapter: postgres.Store (19), postgres.EDA (11, consolidated into edastore.go), staterpc.Client (29). Removes the scattered single-line assertions from harness_secrets.go, edastore_eventtypes.go, sources.go, run_credentials.go. task check green.
130 lines
4.5 KiB
Go
130 lines
4.5 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
|
|
"github.com/samcharles93/archie-core/internal/domain/storecontract"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/bindingcipher"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
|
|
)
|
|
|
|
// harnessSecretPayload is the JSON shape sealed into harness_secrets.secret_enc:
|
|
// the whole token set behind one envelope, never separate plaintext columns.
|
|
type harnessSecretPayload struct {
|
|
AccessToken string `json:"access_token"`
|
|
RefreshToken string `json:"refresh_token"`
|
|
TokenType string `json:"token_type"`
|
|
ExpiresAt time.Time `json:"expires_at"`
|
|
Scopes []string `json:"scopes,omitempty"`
|
|
}
|
|
|
|
// GetHarnessSecret returns the stored OAuth token set for an org/service
|
|
// credential binding, or storecontract.ErrHarnessSecretNotFound.
|
|
func (s *EDA) GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error) {
|
|
row, err := s.q.GetHarnessSecret(ctx, postgresdb.GetHarnessSecretParams{Org: org, Service: service})
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return harnesssecret.Secret{}, storecontract.ErrHarnessSecretNotFound
|
|
}
|
|
if err != nil {
|
|
return harnesssecret.Secret{}, fmt.Errorf("postgres: get harness secret: %w", err)
|
|
}
|
|
payload, err := s.openHarnessSecret(row.SecretEnc)
|
|
if err != nil {
|
|
return harnesssecret.Secret{}, err
|
|
}
|
|
return harnesssecret.Secret{
|
|
Org: row.Org, Service: row.Service,
|
|
AccessToken: payload.AccessToken, RefreshToken: payload.RefreshToken,
|
|
TokenType: payload.TokenType, ExpiresAt: payload.ExpiresAt,
|
|
Scopes: payload.Scopes,
|
|
UpdatedAt: row.UpdatedAt,
|
|
}, nil
|
|
}
|
|
|
|
// PutHarnessSecret upserts an org/service credential binding's OAuth token
|
|
// set. Called by the setup terminal's first capture and by the egress
|
|
// proxy's every refresh.
|
|
func (s *EDA) PutHarnessSecret(ctx context.Context, secret harnesssecret.Secret) error {
|
|
if err := secret.Validate(); err != nil {
|
|
return err
|
|
}
|
|
sealed, err := s.sealHarnessSecret(harnessSecretPayload{
|
|
AccessToken: secret.AccessToken, RefreshToken: secret.RefreshToken,
|
|
TokenType: secret.TokenType, ExpiresAt: secret.ExpiresAt,
|
|
Scopes: secret.Scopes,
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() { _ = tx.Rollback(ctx) }()
|
|
q := postgresdb.New(tx)
|
|
inserted, err := q.PutHarnessSecret(ctx, postgresdb.PutHarnessSecretParams{
|
|
Org: secret.Org, Service: secret.Service, SecretEnc: sealed,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("postgres: put harness secret: %w", err)
|
|
}
|
|
// The trail records that the credential changed, never any part of it: no
|
|
// access token, refresh token or ciphertext. The insert flag is read by the
|
|
// same statement, so a concurrent first capture is an update, not a second
|
|
// create. A first capture has a nil old side.
|
|
var oldValue []byte
|
|
if !inserted {
|
|
if oldValue, err = auditJSON(map[string]bool{"changed": true}); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
newValue, err := auditJSON(map[string]bool{"changed": true})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := insertAudit(ctx, q, "harness_secrets", secret.Service, "credential", oldValue, newValue, 0, secret.Org); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit(ctx)
|
|
}
|
|
|
|
// sealHarnessSecret encrypts the token set under HarnessSecretDomain. An
|
|
// encryption key is required.
|
|
func (s *EDA) sealHarnessSecret(payload harnessSecretPayload) (string, error) {
|
|
if s.cipher == nil {
|
|
return "", errors.New("postgres: harness secrets require an encryption key")
|
|
}
|
|
raw, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return "", fmt.Errorf("postgres: marshal harness secret: %w", err)
|
|
}
|
|
sealed, err := s.cipher.EncryptDomain(bindingcipher.HarnessSecretDomain, string(raw))
|
|
if err != nil {
|
|
return "", fmt.Errorf("postgres: encrypt harness secret: %w", err)
|
|
}
|
|
return sealed, nil
|
|
}
|
|
|
|
// openHarnessSecret reverses sealHarnessSecret.
|
|
func (s *EDA) openHarnessSecret(stored string) (harnessSecretPayload, error) {
|
|
if s.cipher == nil {
|
|
return harnessSecretPayload{}, errors.New("postgres: harness secrets require an encryption key")
|
|
}
|
|
raw, err := s.cipher.DecryptDomain(bindingcipher.HarnessSecretDomain, stored)
|
|
if err != nil {
|
|
return harnessSecretPayload{}, fmt.Errorf("postgres: decrypt harness secret: %w", err)
|
|
}
|
|
var payload harnessSecretPayload
|
|
if err := json.Unmarshal([]byte(raw), &payload); err != nil {
|
|
return harnessSecretPayload{}, fmt.Errorf("postgres: unmarshal harness secret: %w", err)
|
|
}
|
|
return payload, nil
|
|
}
|