ayurishchevandClaude Sonnet 5.5
e95b5eb7d5
A validator that failed the self-check of an address no longer gets that address
again in the current round (ClaimNextQueued skips it); the validator itself stays
in service and takes all other addresses. The verdict fail is set when the number
of failed self-checks of an address reaches settings.self_check_max_attempts
(1..50, default 5, independent of the number of validators); max_retries and
retry_count are no longer used for self-check. If every working validator has
already failed the address, a new round starts and the exclusions lapse.
Migration 0012: ip_self_check_failures (permanent history per registry address),
ip_queue.sc_failures and sc_round_start_cycle (cycle_id is used instead of
attempt_number, which restarts when a queue row is recreated), the setting.
db.FailSelfCheck does it in one transaction; re-submission starts a new series.
API: self_check_max_attempts in GET/PUT /admin/config/orchestrator,
self_check_failed_on in /admin/ips/{ip} and /admin/registry/{ip}. Dashboard: the
field on /settings and the line "Self-check не прошёл на: ..." on the address
pages. Docs, plan and summary in docs/changes/.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
75 lines
2.8 KiB
Go
75 lines
2.8 KiB
Go
package db
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
)
|
|
|
|
// GetSettings returns the singleton settings row. BootstrapFromConfig
|
|
// guarantees it exists before any other code path can observe it, so
|
|
// sql.ErrNoRows here would indicate a bootstrap bug, not a normal
|
|
// condition.
|
|
func (d *DB) GetSettings(ctx context.Context) (Settings, error) {
|
|
var s Settings
|
|
var createdAt, updatedAt string
|
|
err := d.QueryRowContext(ctx, `
|
|
SELECT fip_settle_seconds, history_retention_cycles, self_check_max_attempts, created_at, updated_at FROM settings WHERE id=1
|
|
`).Scan(&s.FIPSettleSeconds, &s.HistoryRetentionCycles, &s.SelfCheckMaxAttempts, &createdAt, &updatedAt)
|
|
if err != nil {
|
|
return Settings{}, err
|
|
}
|
|
if s.CreatedAt, err = dbToTime(createdAt); err != nil {
|
|
return Settings{}, err
|
|
}
|
|
if s.UpdatedAt, err = dbToTime(updatedAt); err != nil {
|
|
return Settings{}, err
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
// SetFIPSettleSeconds persists a new fip_settle_seconds value. Only
|
|
// enforces seconds >= 0 — the cross-field rule against
|
|
// lease_ttl_seconds/self_check_timeout_seconds lives in
|
|
// orchestrator.Orchestrator.SetFIPSettleSeconds, which has access to the
|
|
// static orchestrator config this package doesn't.
|
|
func (d *DB) SetFIPSettleSeconds(ctx context.Context, seconds int) error {
|
|
if seconds < 0 {
|
|
return fmt.Errorf("fip_settle_seconds must be >= 0: %w", ErrValidation)
|
|
}
|
|
now := timeToDB(Now())
|
|
_, err := d.ExecContext(ctx, `
|
|
UPDATE settings SET fip_settle_seconds=?, updated_at=? WHERE id=1
|
|
`, seconds, now)
|
|
return err
|
|
}
|
|
|
|
// SetHistoryRetentionCycles persists how many recent check cycles to keep
|
|
// per registry address; 0 means unlimited (the default, matching behavior
|
|
// before this setting existed). Does not retroactively prune anything
|
|
// itself — pruning happens per-address as each check cycle finishes (see
|
|
// orchestrator.aggregateAndRelease).
|
|
func (d *DB) SetHistoryRetentionCycles(ctx context.Context, cycles int) error {
|
|
if cycles < 0 {
|
|
return fmt.Errorf("history_retention_cycles must be >= 0: %w", ErrValidation)
|
|
}
|
|
now := timeToDB(Now())
|
|
_, err := d.ExecContext(ctx, `
|
|
UPDATE settings SET history_retention_cycles=?, updated_at=? WHERE id=1
|
|
`, cycles, now)
|
|
return err
|
|
}
|
|
|
|
// SetSelfCheckMaxAttempts persists the ceiling of failed self-checks per
|
|
// address (1..MaxSelfCheckMaxAttempts). It applies from the next failed
|
|
// self-check, without a restart.
|
|
func (d *DB) SetSelfCheckMaxAttempts(ctx context.Context, attempts int) error {
|
|
if attempts < MinSelfCheckMaxAttempts || attempts > MaxSelfCheckMaxAttempts {
|
|
return fmt.Errorf("self_check_max_attempts must be in %d..%d: %w", MinSelfCheckMaxAttempts, MaxSelfCheckMaxAttempts, ErrValidation)
|
|
}
|
|
now := timeToDB(Now())
|
|
_, err := d.ExecContext(ctx, `
|
|
UPDATE settings SET self_check_max_attempts=?, updated_at=? WHERE id=1
|
|
`, attempts, now)
|
|
return err
|
|
}
|