Files
QuoteForge/internal/services/sync/worker.go
T
Mikhail ChusavitinandClaude Opus 5.5 44a09d4420 fix(sync): stop MariaDB connection leak and cut per-cycle sync waste
- ConnectionManager reuses a stale-but-healthy pool instead of dialing a new
  one every 30s, and closes every pool it replaces (one client held ~30
  connections). Pool capped at 2 connections, idle released after 1 min.
- Background sync every 1 min with ±30% jitter, scheduled from cycle start;
  users-status online threshold = interval × 1.3. One heartbeat per cycle.
- Partnumber books: read headers only, fetch partnumbers_json per book when
  new/incomplete; empty book counts as complete; an incomplete book is
  re-pulled once per process (server book lists BOT_AGIBOT_G2_PERF missing
  from qt_partnumber_book_items).
- NeedSync in one UNION ALL query; SyncQtSettings skips unchanged rewrite.
- Migration 035: server-maintained server_updated_at on qt_configurations and
  qt_projects. Clients pull only changed rows after one full pull per process;
  servers without 035 and old clients keep full pulls.
- Migrator: fresh GORM statement per verify query and history insert; files
  with two verify checks failed to record.

ADL: bible-local/decisions/2026-10-26-mariadb-single-pool.md,
bible-local/decisions/2026-10-26-incremental-config-project-pull.md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 20:46:59 +03:00

125 lines
3.7 KiB
Go

package sync
import (
"context"
"log/slog"
"math/rand/v2"
"time"
"git.mchus.pro/mchus/quoteforge/internal/db"
)
// WorkerJitter spreads background sync cycles by ±30% of the interval so that
// clients started at the same time do not hit MariaDB in lockstep.
const WorkerJitter = 0.3
// jitteredInterval returns base scaled by a random factor in [1-WorkerJitter, 1+WorkerJitter].
func jitteredInterval(base time.Duration) time.Duration {
factor := 1 - WorkerJitter + rand.Float64()*2*WorkerJitter
return time.Duration(float64(base) * factor)
}
// nextCycleDelay returns how long to wait so the next cycle starts a jittered
// interval after started; zero if the cycle itself took longer than that.
func nextCycleDelay(started time.Time, base time.Duration) time.Duration {
return max(jitteredInterval(base)-time.Since(started), 0)
}
// Worker performs background synchronization at jittered intervals
type Worker struct {
service *Service
connMgr *db.ConnectionManager
interval time.Duration
logger *slog.Logger
stopCh chan struct{}
}
// NewWorker creates a new background sync worker
func NewWorker(service *Service, connMgr *db.ConnectionManager, interval time.Duration) *Worker {
return &Worker{
service: service,
connMgr: connMgr,
interval: interval,
logger: slog.Default(),
stopCh: make(chan struct{}),
}
}
// isOnline checks if the database connection is available
func (w *Worker) isOnline() bool {
return w.connMgr.IsOnline()
}
// Start begins the background sync loop in a goroutine
func (w *Worker) Start(ctx context.Context) {
w.logger.Info("starting background sync worker", "interval", w.interval)
// Run once immediately. The next cycle is scheduled from the start of the
// previous one, so heartbeats are at most (1+WorkerJitter)*interval apart.
started := time.Now()
w.runSync()
timer := time.NewTimer(nextCycleDelay(started, w.interval))
defer timer.Stop()
for {
select {
case <-ctx.Done():
w.logger.Info("background sync worker stopped by context")
return
case <-w.stopCh:
w.logger.Info("background sync worker stopped")
return
case <-timer.C:
started = time.Now()
w.runSync()
timer.Reset(nextCycleDelay(started, w.interval))
}
}
}
// Stop gracefully stops the worker
func (w *Worker) Stop() {
w.logger.Info("stopping background sync worker")
close(w.stopCh)
}
// runSync performs a single sync iteration
func (w *Worker) runSync() {
// Check if online
if !w.isOnline() {
w.logger.Debug("offline, skipping background sync")
return
}
// Each stream is independent: a failure in one must not stop the others.
// Readiness only gates pushing local changes to the server.
if readiness, err := w.service.EnsureReadinessForSync(); err != nil {
w.logger.Warn("background sync: push blocked by readiness guard",
"error", err,
"reason_code", readiness.ReasonCode,
"reason_text", readiness.ReasonText,
)
} else if pushed, err := w.service.pushPendingChanges(); err != nil {
w.logger.Warn("background sync: failed to push pending changes", "error", err)
} else if pushed > 0 {
w.logger.Info("background sync: pushed pending changes", "count", pushed)
}
if err := w.service.SyncPricelistsIfNeeded(); err != nil {
w.logger.Warn("background sync: failed to sync pricelists", "error", err)
}
// Pull partnumber books together with pricelists
if _, err := w.service.PullPartnumberBooks(); err != nil {
w.logger.Warn("background sync: failed to pull partnumber books", "error", err)
}
// Pull configurator settings (tab_config, categories, etc.)
if err := w.service.SyncQtSettings(); err != nil {
w.logger.Warn("background sync: failed to sync qt_settings", "error", err)
}
w.logger.Info("background sync cycle completed")
}