mirror of
https://github.com/MeshCore-Beacon/beacon-server.git
synced 2026-09-01 16:48:19 +00:00
MrAlders0n
7d759d0a0f
* fix: cascade channel_messages on packet delete * rebuild known_routes keyed on (iata, path_key) * add route retention delete, batch reconfirm, path_key upsert * compute route path_key in store, add DeleteOldRoutes * add routes retention config * wire route retention into cleanup, batch reconfirm * prune routes in reconfirm task, not cleanup * expand routes retention docs in example config
102 lines
3.3 KiB
Go
102 lines
3.3 KiB
Go
// Copyright 2026 Beacon Contributors
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
package background
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
|
|
"github.com/MeshCore-Beacon/beacon-server/db"
|
|
)
|
|
|
|
// ViewRefreshTask returns a Task that refreshes all materialized views.
|
|
func ViewRefreshTask(store *db.Store, interval time.Duration) Task {
|
|
return Task{
|
|
Name: "view_refresh",
|
|
Interval: interval,
|
|
Run: func(ctx context.Context) error {
|
|
if err := store.RefreshHourlyStats(ctx); err != nil {
|
|
log.Printf("background[view_refresh]: hourly stats: %v", err)
|
|
}
|
|
if err := store.RefreshTopNodes(ctx); err != nil {
|
|
log.Printf("background[view_refresh]: top nodes: %v", err)
|
|
}
|
|
if err := store.RefreshTopObservers(ctx); err != nil {
|
|
log.Printf("background[view_refresh]: top observers: %v", err)
|
|
}
|
|
if err := store.RefreshPayloadBreakdown(ctx); err != nil {
|
|
log.Printf("background[view_refresh]: payload breakdown: %v", err)
|
|
}
|
|
if err := store.RefreshTopTalkers(ctx); err != nil {
|
|
log.Printf("background[view_refresh]: top talkers: %v", err)
|
|
}
|
|
if err := store.RefreshTopAdvertisers(ctx); err != nil {
|
|
log.Printf("background[view_refresh]: top advertisers: %v", err)
|
|
}
|
|
if err := store.RefreshRadioPresets(ctx); err != nil {
|
|
log.Printf("background[view_refresh]: radio presets: %v", err)
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
}
|
|
|
|
// CleanupTask returns a Task that prunes old telemetry, packet, and node rows.
|
|
func CleanupTask(store *db.Store, telemetryRetention, packetRetention, nodeDeleteAfter, interval time.Duration) Task {
|
|
return Task{
|
|
Name: "cleanup",
|
|
Interval: interval,
|
|
Run: func(ctx context.Context) error {
|
|
if err := store.DeleteOldTelemetry(ctx, time.Now().Add(-telemetryRetention)); err != nil {
|
|
return err
|
|
}
|
|
// One cutoff for all three so the IATA tables stay in step
|
|
// with the packets they mirror.
|
|
cutoff := time.Now().Add(-packetRetention)
|
|
if err := store.DeleteOldPackets(ctx, cutoff); err != nil {
|
|
return err
|
|
}
|
|
if err := store.DeleteOldChannelIATAs(ctx, cutoff); err != nil {
|
|
return err
|
|
}
|
|
if err := store.DeleteOldTraceIATAs(ctx, cutoff); err != nil {
|
|
return err
|
|
}
|
|
if err := store.DeleteOldNodes(ctx, time.Now().Add(-nodeDeleteAfter)); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
}
|
|
|
|
// reconfirmBatchSize bounds per-tick reconfirm work; at hourly ticks a 16M-row
|
|
// table gets fully re-checked roughly daily.
|
|
const reconfirmBatchSize = 750_000
|
|
|
|
// ReconfirmTask returns a Task that prunes aged routes first, then reconfirms
|
|
// stale and ambiguous resolved paths and neighbors, so known_routes only ever
|
|
// has one writer at a time.
|
|
func ReconfirmTask(store *db.Store, routeRetention, routeGrace time.Duration, routeMinObservations int64, interval time.Duration) Task {
|
|
return Task{
|
|
Name: "reconfirm",
|
|
Interval: interval,
|
|
Run: func(ctx context.Context) error {
|
|
now := time.Now()
|
|
if err := store.DeleteOldRoutes(ctx, now.Add(-routeRetention), routeMinObservations, now.Add(-routeGrace)); err != nil {
|
|
return fmt.Errorf("route retention: %w", err)
|
|
}
|
|
if err := store.ReconfirmRoutes(ctx, reconfirmBatchSize); err != nil {
|
|
return fmt.Errorf("routes: %w", err)
|
|
}
|
|
if err := store.ReconfirmNeighbors(ctx); err != nil {
|
|
return fmt.Errorf("neighbors: %w", err)
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
}
|