Skip to content
quarry Artifact [842f6639c2]
Login

Artifact [842f6639c2]

Artifact 842f6639c2cda4a762a7c9710f83187ee23bc6f17a0757d56b000c559ba5f47a:


package oltp

import (
	"crypto/rand"
	"crypto/sha256"
	"database/sql"
	"encoding/hex"
	"errors"
	"time"
)

// RFC 0030, Install codes. An admin makes a code for one repository; a
// person at their own host redeems it, once, for one worker token. Only
// the code's hash is kept, with who made it and when. A redeemed code's
// row is deleted, so a live row is an unspent, unlapsed code.
//
// worker_token_proof is how the forge knows a worker token's holder
// again: the engine never lists a bearer, so the hash of the bearer the
// forge handed out is kept beside the token's id, and a token retires
// itself by presenting it.
const runnerCodeSchema = `
CREATE TABLE IF NOT EXISTS runner_code (
	hash    TEXT PRIMARY KEY,   -- SHA-256 of the code
	repo    TEXT NOT NULL,
	maker   TEXT NOT NULL,
	created TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS runner_code_repo ON runner_code (repo);
CREATE TABLE IF NOT EXISTS runner_code_fail (
	repo TEXT NOT NULL,
	at   TEXT NOT NULL
);
CREATE INDEX IF NOT EXISTS runner_code_fail_repo ON runner_code_fail (repo, at);
CREATE TABLE IF NOT EXISTS worker_token_proof (
	hash     TEXT PRIMARY KEY,  -- SHA-256 of the bearer
	token_id TEXT NOT NULL,
	repo     TEXT NOT NULL
);`

// RunnerCodeLife is how long an install code, and a window of failed
// redemptions, lasts.
const RunnerCodeLife = 15 * time.Minute

// ErrRunnerCodesFull is a code refused because the repository already
// holds as many live ones as it may.
var ErrRunnerCodesFull = errors.New("oltp: too many live install codes")

func runnerCodeHash(s string) string {
	sum := sha256.Sum256([]byte("runner-code:" + s))
	return hex.EncodeToString(sum[:])
}

func runnerCutoff(now time.Time) string {
	return now.UTC().Add(-RunnerCodeLife).Format(time.RFC3339)
}

// NewRunnerCode makes a code for repo by maker and returns it, shown
// once. Lapsed codes are removed first; past max live ones for repo it
// refuses.
func (d *DB) NewRunnerCode(repo, maker string, max int, now time.Time) (string, error) {
	tx, err := d.w.Begin()
	if err != nil {
		return "", err
	}
	defer tx.Rollback()
	if _, err := tx.Exec(`DELETE FROM runner_code WHERE created < ?`, runnerCutoff(now)); err != nil {
		return "", err
	}
	var live int
	if err := tx.QueryRow(`SELECT count(*) FROM runner_code WHERE repo = ?`, repo).Scan(&live); err != nil {
		return "", err
	}
	if live >= max {
		return "", ErrRunnerCodesFull
	}
	raw := make([]byte, 20)
	if _, err := rand.Read(raw); err != nil {
		return "", err
	}
	code := "qri_" + hex.EncodeToString(raw)
	if _, err := tx.Exec(`INSERT INTO runner_code (hash, repo, maker, created) VALUES (?, ?, ?, ?)`,
		runnerCodeHash(code), repo, maker, now.UTC().Format(time.RFC3339)); err != nil {
		return "", err
	}
	return code, tx.Commit()
}

// SpendRunnerCode takes the code a caller presented for repo, for good:
// one caller gets its maker, every other and every later one gets not
// ok.
func (d *DB) SpendRunnerCode(repo, code string, now time.Time) (maker string, created time.Time, ok bool, err error) {
	tx, err := d.w.Begin()
	if err != nil {
		return "", time.Time{}, false, err
	}
	defer tx.Rollback()
	if _, err := tx.Exec(`DELETE FROM runner_code WHERE created < ?`, runnerCutoff(now)); err != nil {
		return "", time.Time{}, false, err
	}
	h := runnerCodeHash(code)
	var at string
	err = tx.QueryRow(`SELECT maker, created FROM runner_code WHERE hash = ? AND repo = ?`, h, repo).Scan(&maker, &at)
	if errors.Is(err, sql.ErrNoRows) {
		return "", time.Time{}, false, tx.Commit()
	}
	if err != nil {
		return "", time.Time{}, false, err
	}
	if _, err := tx.Exec(`DELETE FROM runner_code WHERE hash = ?`, h); err != nil {
		return "", time.Time{}, false, err
	}
	created, _ = time.Parse(time.RFC3339, at)
	return maker, created, true, tx.Commit()
}

// UnspendRunnerCode puts back a code SpendRunnerCode took when the token
// it was taken for could not be minted, with its own maker and creation
// time, so it lapses when it would have. A code already past its life
// is not put back.
func (d *DB) UnspendRunnerCode(repo, code, maker string, created, now time.Time) error {
	if created.IsZero() || !created.After(now.UTC().Add(-RunnerCodeLife)) {
		return nil
	}
	_, err := d.w.Exec(`INSERT OR IGNORE INTO runner_code (hash, repo, maker, created) VALUES (?, ?, ?, ?)`,
		runnerCodeHash(code), repo, maker, created.UTC().Format(time.RFC3339))
	return err
}

// RunnerCodeFailures is how many failed redemptions repo has met in the
// last RunnerCodeLife.
func (d *DB) RunnerCodeFailures(repo string, now time.Time) (int, error) {
	var n int
	err := d.db.QueryRow(`SELECT count(*) FROM runner_code_fail WHERE repo = ? AND at >= ?`, repo, runnerCutoff(now)).Scan(&n)
	return n, err
}

// NoteRunnerCodeFailure records one failed redemption against repo and
// forgets the ones that have aged out.
func (d *DB) NoteRunnerCodeFailure(repo string, now time.Time) error {
	if _, err := d.w.Exec(`DELETE FROM runner_code_fail WHERE at < ?`, runnerCutoff(now)); err != nil {
		return err
	}
	_, err := d.w.Exec(`INSERT INTO runner_code_fail (repo, at) VALUES (?, ?)`, repo, now.UTC().Format(time.RFC3339))
	return err
}

// NoteWorkerTokenProof remembers whose bearer a worker token is.
func (d *DB) NoteWorkerTokenProof(bearer, id, repo string) error {
	_, err := d.w.Exec(`INSERT OR REPLACE INTO worker_token_proof (hash, token_id, repo) VALUES (?, ?, ?)`,
		runnerCodeHash(bearer), id, repo)
	return err
}

// WorkerTokenByProof is the token id and repository a bearer was handed
// out for; not ok for a bearer the forge never minted.
func (d *DB) WorkerTokenByProof(bearer string) (id, repo string, ok bool, err error) {
	err = d.db.QueryRow(`SELECT token_id, repo FROM worker_token_proof WHERE hash = ?`, runnerCodeHash(bearer)).Scan(&id, &repo)
	if errors.Is(err, sql.ErrNoRows) {
		return "", "", false, nil
	}
	return id, repo, err == nil, err
}