Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package api
import (
"database/sql"
"fmt"
"strings"
"sync"
"time"
)
const (
purchaseReturnRedemptionStateStarted = "started"
purchaseReturnRedemptionStateActivated = "activated"
purchaseReturnRedemptionStateFailed = "failed"
purchaseReturnRedemptionDecisionStarted = "started"
purchaseReturnRedemptionDecisionAlreadyActivated = "already_activated"
purchaseReturnRedemptionDecisionInProgress = "in_progress"
purchaseReturnRedemptionDecisionConflict = "conflict"
purchaseReturnRedemptionStaleAfter = 30 * time.Second
)
type purchaseReturnRedemptionStore struct {
once sync.Once
db *sql.DB
mu sync.Mutex
configDir string
initErr error
}
type purchaseReturnRedemptionAttempt struct {
PortalHandoffID string
PurchaseReturnJTI string
CheckoutSessionID string
LicenseID string
ActivationKeyPrefix string
ExpiresAt time.Time
}
type purchaseReturnRedemptionRecord struct {
PortalHandoffID string
PurchaseReturnJTI string
CheckoutSessionID string
LicenseID string
ActivationKeyPrefix string
Status string
FailureReason string
FailureMessage string
CreatedAt time.Time
UpdatedAt time.Time
ExpiresAt time.Time
RedeemedAt *time.Time
}
func (s *purchaseReturnRedemptionStore) init() {
s.once.Do(func() {
schema := `
CREATE TABLE IF NOT EXISTS purchase_return_redemptions (
portal_handoff_id TEXT NOT NULL,
purchase_return_jti TEXT NOT NULL,
checkout_session_id TEXT NOT NULL,
license_id TEXT NOT NULL DEFAULT '',
activation_key_prefix TEXT NOT NULL DEFAULT '',
status TEXT NOT NULL,
failure_reason TEXT NOT NULL DEFAULT '',
failure_message TEXT NOT NULL DEFAULT '',
created_at INTEGER NOT NULL,
updated_at INTEGER NOT NULL,
expires_at INTEGER NOT NULL,
redeemed_at INTEGER NOT NULL DEFAULT 0,
PRIMARY KEY (portal_handoff_id, purchase_return_jti)
);
CREATE UNIQUE INDEX IF NOT EXISTS idx_purchase_return_redemptions_portal_handoff
ON purchase_return_redemptions(portal_handoff_id);
CREATE UNIQUE INDEX IF NOT EXISTS idx_purchase_return_redemptions_checkout_session
ON purchase_return_redemptions(checkout_session_id);
CREATE INDEX IF NOT EXISTS idx_purchase_return_redemptions_status
ON purchase_return_redemptions(status);
`
db, err := openHardenedSecretsDB(s.configDir, "purchase_return_redemptions.db", "purchase return", "purchase return redemption", schema)
if err != nil {
s.initErr = err
return
}
s.db = db
})
}
func (s *purchaseReturnRedemptionStore) begin(attempt purchaseReturnRedemptionAttempt) (string, *purchaseReturnRedemptionRecord, error) {
s.init()
if s.initErr != nil {
return "", nil, s.initErr
}
if s.db == nil {
return "", nil, fmt.Errorf("purchase return redemption store not initialized")
}
attempt.PortalHandoffID = strings.TrimSpace(attempt.PortalHandoffID)
attempt.PurchaseReturnJTI = strings.TrimSpace(attempt.PurchaseReturnJTI)
attempt.CheckoutSessionID = strings.TrimSpace(attempt.CheckoutSessionID)
attempt.LicenseID = strings.TrimSpace(attempt.LicenseID)
attempt.ActivationKeyPrefix = strings.TrimSpace(attempt.ActivationKeyPrefix)
if attempt.PortalHandoffID == "" {
return "", nil, fmt.Errorf("portal handoff id is required")
}
if attempt.PurchaseReturnJTI == "" {
return "", nil, fmt.Errorf("purchase return jti is required")
}
if attempt.CheckoutSessionID == "" {
return "", nil, fmt.Errorf("checkout session id is required")
}
if attempt.ExpiresAt.IsZero() {
return "", nil, fmt.Errorf("expires at is required")
}
attempt.ExpiresAt = attempt.ExpiresAt.UTC()
s.mu.Lock()
defer s.mu.Unlock()
tx, err := s.db.Begin()
if err != nil {
return "", nil, fmt.Errorf("begin purchase return redemption tx: %w", err)
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
now := time.Now().UTC()
existing, err := loadPurchaseReturnRedemptionExactTx(tx, attempt.PortalHandoffID, attempt.PurchaseReturnJTI)
if err != nil {
return "", nil, err
}
if existing != nil {
if existing.CheckoutSessionID != attempt.CheckoutSessionID {
return purchaseReturnRedemptionDecisionConflict, existing, nil
}
switch existing.Status {
case purchaseReturnRedemptionStateActivated:
if err := tx.Commit(); err != nil {
return "", nil, fmt.Errorf("commit activated purchase redemption lookup: %w", err)
}
committed = true
return purchaseReturnRedemptionDecisionAlreadyActivated, existing, nil
case purchaseReturnRedemptionStateStarted:
if now.Sub(existing.UpdatedAt) < purchaseReturnRedemptionStaleAfter {
if err := tx.Commit(); err != nil {
return "", nil, fmt.Errorf("commit in-progress purchase redemption lookup: %w", err)
}
committed = true
return purchaseReturnRedemptionDecisionInProgress, existing, nil
}
case purchaseReturnRedemptionStateFailed:
default:
return "", nil, fmt.Errorf("unexpected purchase return redemption status %q", existing.Status)
}
if err := updatePurchaseReturnRedemptionStartedTx(tx, attempt, now); err != nil {
return "", nil, err
}
record, err := loadPurchaseReturnRedemptionExactTx(tx, attempt.PortalHandoffID, attempt.PurchaseReturnJTI)
if err != nil {
return "", nil, err
}
if record == nil {
return "", nil, fmt.Errorf("purchase return redemption row disappeared after restart")
}
if err := tx.Commit(); err != nil {
return "", nil, fmt.Errorf("commit restarted purchase return redemption: %w", err)
}
committed = true
return purchaseReturnRedemptionDecisionStarted, record, nil
}
byPortalHandoffID, err := loadPurchaseReturnRedemptionByPortalHandoffTx(tx, attempt.PortalHandoffID)
if err != nil {
return "", nil, err
}
if byPortalHandoffID != nil {
if err := tx.Commit(); err != nil {
return "", nil, fmt.Errorf("commit portal handoff conflict lookup: %w", err)
}
committed = true
return purchaseReturnRedemptionDecisionConflict, byPortalHandoffID, nil
}
bySessionID, err := loadPurchaseReturnRedemptionBySessionTx(tx, attempt.CheckoutSessionID)
if err != nil {
return "", nil, err
}
if bySessionID != nil {
if err := tx.Commit(); err != nil {
return "", nil, fmt.Errorf("commit checkout session conflict lookup: %w", err)
}
committed = true
return purchaseReturnRedemptionDecisionConflict, bySessionID, nil
}
if err := insertPurchaseReturnRedemptionStartedTx(tx, attempt, now); err != nil {
return "", nil, err
}
record, err := loadPurchaseReturnRedemptionExactTx(tx, attempt.PortalHandoffID, attempt.PurchaseReturnJTI)
if err != nil {
return "", nil, err
}
if record == nil {
return "", nil, fmt.Errorf("purchase return redemption row missing after insert")
}
if err := tx.Commit(); err != nil {
return "", nil, fmt.Errorf("commit purchase return redemption insert: %w", err)
}
committed = true
return purchaseReturnRedemptionDecisionStarted, record, nil
}
func (s *purchaseReturnRedemptionStore) markFailed(portalHandoffID, purchaseReturnJTI, reason, message string) error {
return s.update(portalHandoffID, purchaseReturnJTI, func(tx *sql.Tx, now time.Time, existing *purchaseReturnRedemptionRecord) error {
if existing.Status == purchaseReturnRedemptionStateActivated {
return nil
}
if _, err := tx.Exec(
`UPDATE purchase_return_redemptions
SET status = ?, failure_reason = ?, failure_message = ?, updated_at = ?
WHERE portal_handoff_id = ? AND purchase_return_jti = ?`,
purchaseReturnRedemptionStateFailed,
strings.TrimSpace(reason),
strings.TrimSpace(message),
now.Unix(),
strings.TrimSpace(portalHandoffID),
strings.TrimSpace(purchaseReturnJTI),
); err != nil {
return fmt.Errorf("mark purchase return redemption failed: %w", err)
}
return nil
})
}
func (s *purchaseReturnRedemptionStore) markActivated(portalHandoffID, purchaseReturnJTI, licenseID, activationKeyPrefix string) error {
return s.update(portalHandoffID, purchaseReturnJTI, func(tx *sql.Tx, now time.Time, existing *purchaseReturnRedemptionRecord) error {
if existing.Status == purchaseReturnRedemptionStateActivated {
return nil
}
if _, err := tx.Exec(
`UPDATE purchase_return_redemptions
SET status = ?, failure_reason = '', failure_message = '', license_id = ?, activation_key_prefix = ?, updated_at = ?, redeemed_at = ?
WHERE portal_handoff_id = ? AND purchase_return_jti = ?`,
purchaseReturnRedemptionStateActivated,
strings.TrimSpace(licenseID),
strings.TrimSpace(activationKeyPrefix),
now.Unix(),
now.Unix(),
strings.TrimSpace(portalHandoffID),
strings.TrimSpace(purchaseReturnJTI),
); err != nil {
return fmt.Errorf("mark purchase return redemption activated: %w", err)
}
return nil
})
}
func (s *purchaseReturnRedemptionStore) get(portalHandoffID, purchaseReturnJTI string) (*purchaseReturnRedemptionRecord, error) {
s.init()
if s.initErr != nil {
return nil, s.initErr
}
if s.db == nil {
return nil, fmt.Errorf("purchase return redemption store not initialized")
}
s.mu.Lock()
defer s.mu.Unlock()
return loadPurchaseReturnRedemptionExactTx(nil, strings.TrimSpace(portalHandoffID), strings.TrimSpace(purchaseReturnJTI), s.db)
}
func (s *purchaseReturnRedemptionStore) update(portalHandoffID, purchaseReturnJTI string, apply func(tx *sql.Tx, now time.Time, existing *purchaseReturnRedemptionRecord) error) error {
s.init()
if s.initErr != nil {
return s.initErr
}
if s.db == nil {
return fmt.Errorf("purchase return redemption store not initialized")
}
portalHandoffID = strings.TrimSpace(portalHandoffID)
purchaseReturnJTI = strings.TrimSpace(purchaseReturnJTI)
if portalHandoffID == "" {
return fmt.Errorf("portal handoff id is required")
}
if purchaseReturnJTI == "" {
return fmt.Errorf("purchase return jti is required")
}
s.mu.Lock()
defer s.mu.Unlock()
tx, err := s.db.Begin()
if err != nil {
return fmt.Errorf("begin purchase return redemption update tx: %w", err)
}
committed := false
defer func() {
if !committed {
_ = tx.Rollback()
}
}()
existing, err := loadPurchaseReturnRedemptionExactTx(tx, portalHandoffID, purchaseReturnJTI)
if err != nil {
return err
}
if existing == nil {
return fmt.Errorf("purchase return redemption not found")
}
if err := apply(tx, time.Now().UTC(), existing); err != nil {
return err
}
if err := tx.Commit(); err != nil {
return fmt.Errorf("commit purchase return redemption update: %w", err)
}
committed = true
return nil
}
func insertPurchaseReturnRedemptionStartedTx(tx *sql.Tx, attempt purchaseReturnRedemptionAttempt, now time.Time) error {
_, err := tx.Exec(
`INSERT INTO purchase_return_redemptions (
portal_handoff_id, purchase_return_jti, checkout_session_id, license_id, activation_key_prefix,
status, failure_reason, failure_message, created_at, updated_at, expires_at, redeemed_at
) VALUES (?, ?, ?, ?, ?, ?, '', '', ?, ?, ?, 0)`,
attempt.PortalHandoffID,
attempt.PurchaseReturnJTI,
attempt.CheckoutSessionID,
attempt.LicenseID,
attempt.ActivationKeyPrefix,
purchaseReturnRedemptionStateStarted,
now.Unix(),
now.Unix(),
attempt.ExpiresAt.Unix(),
)
if err != nil {
if isSQLiteUniqueViolation(err) {
return fmt.Errorf("purchase return redemption binding already exists: %w", err)
}
return fmt.Errorf("insert purchase return redemption: %w", err)
}
return nil
}
func updatePurchaseReturnRedemptionStartedTx(tx *sql.Tx, attempt purchaseReturnRedemptionAttempt, now time.Time) error {
_, err := tx.Exec(
`UPDATE purchase_return_redemptions
SET checkout_session_id = ?, license_id = ?, activation_key_prefix = ?, status = ?, failure_reason = '', failure_message = '', updated_at = ?, expires_at = ?, redeemed_at = 0
WHERE portal_handoff_id = ? AND purchase_return_jti = ?`,
attempt.CheckoutSessionID,
attempt.LicenseID,
attempt.ActivationKeyPrefix,
purchaseReturnRedemptionStateStarted,
now.Unix(),
attempt.ExpiresAt.Unix(),
attempt.PortalHandoffID,
attempt.PurchaseReturnJTI,
)
if err != nil {
return fmt.Errorf("restart purchase return redemption: %w", err)
}
return nil
}
func loadPurchaseReturnRedemptionExactTx(tx *sql.Tx, portalHandoffID, purchaseReturnJTI string, dbs ...*sql.DB) (*purchaseReturnRedemptionRecord, error) {
const query = `SELECT
portal_handoff_id,
purchase_return_jti,
checkout_session_id,
license_id,
activation_key_prefix,
status,
failure_reason,
failure_message,
created_at,
updated_at,
expires_at,
redeemed_at
FROM purchase_return_redemptions
WHERE portal_handoff_id = ? AND purchase_return_jti = ?`
var row *sql.Row
switch {
case tx != nil:
row = tx.QueryRow(query, portalHandoffID, purchaseReturnJTI)
case len(dbs) > 0 && dbs[0] != nil:
row = dbs[0].QueryRow(query, portalHandoffID, purchaseReturnJTI)
default:
return nil, fmt.Errorf("database handle is required")
}
return scanPurchaseReturnRedemptionRow(row)
}
func loadPurchaseReturnRedemptionByPortalHandoffTx(tx *sql.Tx, portalHandoffID string) (*purchaseReturnRedemptionRecord, error) {
return scanPurchaseReturnRedemptionRow(tx.QueryRow(
`SELECT
portal_handoff_id,
purchase_return_jti,
checkout_session_id,
license_id,
activation_key_prefix,
status,
failure_reason,
failure_message,
created_at,
updated_at,
expires_at,
redeemed_at
FROM purchase_return_redemptions
WHERE portal_handoff_id = ?`,
portalHandoffID,
))
}
func loadPurchaseReturnRedemptionBySessionTx(tx *sql.Tx, checkoutSessionID string) (*purchaseReturnRedemptionRecord, error) {
return scanPurchaseReturnRedemptionRow(tx.QueryRow(
`SELECT
portal_handoff_id,
purchase_return_jti,
checkout_session_id,
license_id,
activation_key_prefix,
status,
failure_reason,
failure_message,
created_at,
updated_at,
expires_at,
redeemed_at
FROM purchase_return_redemptions
WHERE checkout_session_id = ?`,
checkoutSessionID,
))
}
func scanPurchaseReturnRedemptionRow(row *sql.Row) (*purchaseReturnRedemptionRecord, error) {
if row == nil {
return nil, fmt.Errorf("purchase return redemption row is required")
}
record := purchaseReturnRedemptionRecord{}
var createdAt, updatedAt, expiresAt, redeemedAt int64
err := row.Scan(
&record.PortalHandoffID,
&record.PurchaseReturnJTI,
&record.CheckoutSessionID,
&record.LicenseID,
&record.ActivationKeyPrefix,
&record.Status,
&record.FailureReason,
&record.FailureMessage,
&createdAt,
&updatedAt,
&expiresAt,
&redeemedAt,
)
if err != nil {
if err == sql.ErrNoRows {
return nil, nil
}
return nil, fmt.Errorf("scan purchase return redemption: %w", err)
}
record.CreatedAt = time.Unix(createdAt, 0).UTC()
record.UpdatedAt = time.Unix(updatedAt, 0).UTC()
record.ExpiresAt = time.Unix(expiresAt, 0).UTC()
if redeemedAt > 0 {
redeemedAtTime := time.Unix(redeemedAt, 0).UTC()
record.RedeemedAt = &redeemedAtTime
}
return &record, nil
}