90 lines
2.8 KiB
Go
90 lines
2.8 KiB
Go
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
// Package health persists the migration service liveness marker.
|
|
package health
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const Filename = "heartbeat"
|
|
|
|
const Schema = "enodia.go.health.v1"
|
|
|
|
// Status is the stable machine-readable result returned by the health command.
|
|
type Status struct {
|
|
Schema string `json:"schema"`
|
|
Healthy bool `json:"healthy"`
|
|
Heartbeat string `json:"heartbeat,omitempty"`
|
|
AgeSeconds int64 `json:"age_seconds,omitempty"`
|
|
MaxAgeSeconds int64 `json:"max_age_seconds"`
|
|
Detail string `json:"detail"`
|
|
}
|
|
|
|
// WriteHeartbeat atomically stores a Unix timestamp in the state directory.
|
|
// A stale retained value is intentional: watchdogs can distinguish a stopped
|
|
// or wedged process from a service that has never completed a sweep.
|
|
func WriteHeartbeat(stateDir string, now time.Time) error {
|
|
if stateDir == "" {
|
|
return fmt.Errorf("state directory is required")
|
|
}
|
|
if err := os.MkdirAll(stateDir, 0o750); err != nil {
|
|
return fmt.Errorf("create heartbeat directory: %w", err)
|
|
}
|
|
path := filepath.Join(stateDir, Filename)
|
|
temporary := path + ".tmp"
|
|
content := []byte(strconv.FormatInt(now.Unix(), 10) + "\n")
|
|
if err := os.WriteFile(temporary, content, 0o600); err != nil {
|
|
return fmt.Errorf("write heartbeat: %w", err)
|
|
}
|
|
if err := os.Rename(temporary, path); err != nil {
|
|
return fmt.Errorf("replace heartbeat: %w", err)
|
|
}
|
|
if err := os.Chmod(path, 0o600); err != nil {
|
|
return fmt.Errorf("protect heartbeat: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ReadHeartbeat loads the retained Unix timestamp.
|
|
func ReadHeartbeat(stateDir string) (time.Time, error) {
|
|
raw, err := os.ReadFile(filepath.Join(stateDir, Filename))
|
|
if err != nil {
|
|
return time.Time{}, err
|
|
}
|
|
seconds, err := strconv.ParseInt(strings.TrimSpace(string(raw)), 10, 64)
|
|
if err != nil {
|
|
return time.Time{}, fmt.Errorf("parse heartbeat: %w", err)
|
|
}
|
|
return time.Unix(seconds, 0), nil
|
|
}
|
|
|
|
// Check evaluates the retained heartbeat against the configured maximum age.
|
|
// Missing or malformed state is represented in the result instead of returned
|
|
// as an error so callers can always emit a complete health record.
|
|
func Check(stateDir string, now time.Time, maxAge time.Duration) Status {
|
|
status := Status{Schema: Schema, MaxAgeSeconds: int64(maxAge / time.Second)}
|
|
heartbeat, err := ReadHeartbeat(stateDir)
|
|
if err != nil {
|
|
status.Detail = "heartbeat unavailable: " + err.Error()
|
|
return status
|
|
}
|
|
age := now.Sub(heartbeat)
|
|
if age < 0 {
|
|
age = 0
|
|
}
|
|
status.Heartbeat = heartbeat.Local().Format(time.RFC3339)
|
|
status.AgeSeconds = int64(age / time.Second)
|
|
status.Healthy = age <= maxAge
|
|
if status.Healthy {
|
|
status.Detail = "heartbeat is fresh"
|
|
} else {
|
|
status.Detail = "heartbeat is stale"
|
|
}
|
|
return status
|
|
}
|