92 lines
3.0 KiB
Go
92 lines
3.0 KiB
Go
package archied
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"log/slog"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/domain/drain"
|
|
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
|
|
drainio "github.com/samcharles93/archie-core/internal/infrastructure/drain"
|
|
)
|
|
|
|
// defaultDrainPollInterval is how often the daemon looks for a new drain
|
|
// request. It is deliberately short (a few seconds) so an operator-triggered
|
|
// drain is honoured promptly, while the cost is one cheap file read per tick.
|
|
const defaultDrainPollInterval = 5 * time.Second
|
|
|
|
// DefaultDrainRequestPath returns the marker file path the daemon watches. It
|
|
// lives in the instance's config directory.
|
|
func DefaultDrainRequestPath() string {
|
|
return filepath.Join(configuration.DefaultConfigDir(), drainio.DefaultMarkerFilename)
|
|
}
|
|
|
|
// monitorDrainRequests polls check for a live drain request and invokes
|
|
// shutdown when one is honoured. It returns nil once shutdown has been
|
|
// triggered (or when the context is cancelled), and never returns a poll error:
|
|
// a transient read failure is logged and ignored so a broken marker or a
|
|
// momentary read error cannot halt the monitor and silently unmount drain
|
|
// detection.
|
|
//
|
|
// check reports the drain decision; shutdown is the daemon's graceful-stop
|
|
// trigger. Both are injected so tests can exercise the monitor without touching
|
|
// the real filesystem or signalling the process.
|
|
func monitorDrainRequests(
|
|
ctx context.Context,
|
|
check func() (drain.Decision, error),
|
|
shutdown func(),
|
|
log *slog.Logger,
|
|
interval time.Duration,
|
|
) error {
|
|
for {
|
|
decision, err := check()
|
|
switch {
|
|
case err != nil:
|
|
log.Warn("drain request check failed", "err", err)
|
|
case decision == drain.DecisionValid:
|
|
log.Info("drain request accepted; initiating graceful shutdown")
|
|
shutdown()
|
|
return nil
|
|
case decision == drain.DecisionStale:
|
|
log.Warn("stale drain request ignored; marker predates current instantiation")
|
|
}
|
|
|
|
timer := time.NewTimer(interval)
|
|
select {
|
|
case <-ctx.Done():
|
|
timer.Stop()
|
|
return ctx.Err()
|
|
case <-timer.C:
|
|
}
|
|
}
|
|
}
|
|
|
|
// startDrainMonitor launches the drain-monitoring goroutine for the long-lived
|
|
// daemon. The marker path is resolved from the repo's config home; the reader
|
|
// uses the real current instantiation epoch; and a valid request cancels the
|
|
// boot context, which is the exact path a SIGTERM takes to graceful shutdown.
|
|
//
|
|
// It is only called from the non-once run loop, so the monitor never runs for
|
|
// a single-cycle invocation.
|
|
func (b *boot) startDrainMonitor(ctx context.Context) {
|
|
if b.shutdown == nil {
|
|
b.log.Error("drain monitor not started: no shutdown trigger wired")
|
|
return
|
|
}
|
|
reader := drainio.New(DefaultDrainRequestPath(), nil)
|
|
go func() {
|
|
err := monitorDrainRequests(
|
|
ctx,
|
|
func() (drain.Decision, error) { return reader.Check() },
|
|
func() { b.shutdown() },
|
|
b.log,
|
|
defaultDrainPollInterval,
|
|
)
|
|
if err != nil && !errors.Is(err, context.Canceled) {
|
|
b.log.Error("drain monitor stopped", "err", err)
|
|
}
|
|
}()
|
|
}
|