102 lines
3.5 KiB
Go
102 lines
3.5 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
)
|
|
|
|
// Lease ist die aktuelle Lease eines Knotens. Document ist das signierte
|
|
// JSON (license.Lease); die Zeiten liegen zusätzlich als Spalten vor, damit
|
|
// der Server ohne Parsen entscheiden kann.
|
|
type Lease struct {
|
|
NodeID string
|
|
IssuedAt time.Time
|
|
RenewAfter time.Time
|
|
ValidUntil time.Time
|
|
Document string
|
|
}
|
|
|
|
// PutLease speichert bzw. ersetzt die Lease eines Knotens.
|
|
func (s *Store) PutLease(ctx context.Context, l Lease) error {
|
|
_, err := s.db.ExecContext(ctx, `INSERT INTO leases (node_id, issued_at, renew_after, valid_until, document)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
ON CONFLICT(node_id) DO UPDATE SET issued_at = excluded.issued_at, renew_after = excluded.renew_after,
|
|
valid_until = excluded.valid_until, document = excluded.document`,
|
|
l.NodeID, formatTime(l.IssuedAt), formatTime(l.RenewAfter), formatTime(l.ValidUntil), l.Document)
|
|
if sqliteCode(err) != 0 {
|
|
return fmt.Errorf("Lease für %s: Knoten: %w", l.NodeID, ErrNotFound)
|
|
}
|
|
return err
|
|
}
|
|
|
|
// GetLease liest die Lease eines Knotens.
|
|
func (s *Store) GetLease(ctx context.Context, nodeID string) (Lease, error) {
|
|
l := Lease{NodeID: nodeID}
|
|
err := s.db.QueryRowContext(ctx, `SELECT issued_at, renew_after, valid_until, document FROM leases WHERE node_id = ?`, nodeID).
|
|
Scan(dbTime{&l.IssuedAt}, dbTime{&l.RenewAfter}, dbTime{&l.ValidUntil}, &l.Document)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return Lease{}, fmt.Errorf("Lease für %s: %w", nodeID, ErrNotFound)
|
|
}
|
|
return l, err
|
|
}
|
|
|
|
// NodeCommand ist ein Befehl in der Warteschlange für einen Knoten. Die CLI
|
|
// (eigener Prozess) reiht ein, der Server stellt zu.
|
|
type NodeCommand struct {
|
|
ID int64
|
|
NodeID string
|
|
Command string
|
|
Reason string
|
|
CreatedAt time.Time
|
|
}
|
|
|
|
// EnqueueNodeCommand reiht einen Befehl für nodeID ein.
|
|
func (s *Store) EnqueueNodeCommand(ctx context.Context, nodeID, command, reason string) error {
|
|
if blank(command) {
|
|
return invalid("Befehl fehlt")
|
|
}
|
|
_, err := s.db.ExecContext(ctx, `INSERT INTO node_commands (node_id, command, reason, created_at) VALUES (?, ?, ?, ?)`,
|
|
nodeID, command, reason, formatTime(s.now()))
|
|
return mapConstraint(err, "Befehl für "+nodeID)
|
|
}
|
|
|
|
// PendingNodeCommands liefert die noch nicht zugestellten Befehle in Reihenfolge.
|
|
func (s *Store) PendingNodeCommands(ctx context.Context, nodeID string) ([]NodeCommand, error) {
|
|
rows, err := s.db.QueryContext(ctx, `SELECT id, command, reason, created_at FROM node_commands
|
|
WHERE node_id = ? AND sent_at IS NULL ORDER BY id`, nodeID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var out []NodeCommand
|
|
for rows.Next() {
|
|
c := NodeCommand{NodeID: nodeID}
|
|
if err := rows.Scan(&c.ID, &c.Command, &c.Reason, dbTime{&c.CreatedAt}); err != nil {
|
|
return nil, err
|
|
}
|
|
out = append(out, c)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
// MarkNodeCommandSent vermerkt die Zustellung.
|
|
func (s *Store) MarkNodeCommandSent(ctx context.Context, id int64) error {
|
|
res, err := s.db.ExecContext(ctx, `UPDATE node_commands SET sent_at = ? WHERE id = ?`, formatTime(s.now()), id)
|
|
return requireAffected(res, err, fmt.Sprintf("Befehl %d", id))
|
|
}
|
|
|
|
// UpdateNodePublicKey tauscht den Schlüssel eines Knotens (rotate_key).
|
|
func (s *Store) UpdateNodePublicKey(ctx context.Context, nodeID, publicKey string) error {
|
|
if blank(publicKey) {
|
|
return invalid("Public Key fehlt")
|
|
}
|
|
res, err := s.db.ExecContext(ctx, `UPDATE nodes SET public_key = ? WHERE id = ?`, publicKey, nodeID)
|
|
if err != nil {
|
|
return mapConstraint(err, "Knoten "+nodeID)
|
|
}
|
|
return requireAffected(res, nil, "Knoten "+nodeID)
|
|
}
|