edgeguard-native/cmd/edgeguard-scheduler/main.go

// edgeguard-scheduler runs background jobs that don't belong on the
// API request path:
//
//   - ACME cert renewal (every 6h, re-issues anything < 30d to expiry)
//
// Future jobs (cluster heartbeat, backup, audit-log retention)
// hang off the same Tick loop. Stays single-process — no leader
// election yet (Phase 3).
package main

import (
	"context"
	"encoding/json"
	"log/slog"
	"os"
	"time"

	"git.netcell-it.de/projekte/edgeguard-native/internal/database"
	"git.netcell-it.de/projekte/edgeguard-native/internal/license"
	"git.netcell-it.de/projekte/edgeguard-native/internal/services/acme"
	"git.netcell-it.de/projekte/edgeguard-native/internal/services/certrenewer"
	licsvc "git.netcell-it.de/projekte/edgeguard-native/internal/services/license"
	"git.netcell-it.de/projekte/edgeguard-native/internal/services/setup"
	"git.netcell-it.de/projekte/edgeguard-native/internal/services/tlscerts"
)

var version = "1.0.63"

const (
	// renewTickInterval — how often we re-evaluate expiring certs.
	// 6h is enough: LE renewal window is 30 days; missing one tick
	// makes no difference. Hourly would log too much.
	renewTickInterval = 6 * time.Hour

	// certDir matches handlers.NewTLSCertsHandler default — HAProxy
	// reads from this directory.
	certDir = "/etc/edgeguard/tls"

	// licenseTickInterval — daily re-verify against
	// license.netcell-it.com. Result lands in the licenses table.
	licenseTickInterval = 24 * time.Hour
)

func main() {
	slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelInfo})))
	slog.Info("edgeguard-scheduler starting", "version", version)

	ctx := context.Background()

	pool, err := database.Open(ctx, database.ConnStringFromEnv())
	if err != nil {
		slog.Error("scheduler: DB open failed — sleeping forever", "error", err)
		select {}
	}
	defer pool.Close()

	tlsRepo := tlscerts.New(pool)
	setupStore := setup.NewStore(setup.DefaultDir)
	st, _ := setupStore.Load()

	var renewer *certrenewer.Service
	if st != nil && st.ACMEEmail != "" {
		issuer := acme.New(st.ACMEEmail)
		renewer = certrenewer.New(tlsRepo, issuer, certDir, 30*24*time.Hour)
		slog.Info("scheduler: ACME renewer enabled",
			"email", st.ACMEEmail, "tick", renewTickInterval, "threshold", "30d")
	} else {
		slog.Warn("scheduler: setup.acme_email empty — ACME renewal disabled until setup wizard ran")
	}

	licRepo := licsvc.New(pool)
	licClient := license.NewClient()
	licKeyStore := license.NewKeyStore()
	nodeID := os.Getenv("EDGEGUARD_NODE_ID")
	slog.Info("scheduler: license re-verify enabled", "tick", licenseTickInterval)

	if renewer != nil {
		runRenewer(ctx, renewer)
	}
	runLicenseVerify(ctx, licClient, licKeyStore, licRepo, nodeID)

	renewTick := time.NewTicker(renewTickInterval)
	defer renewTick.Stop()
	licTick := time.NewTicker(licenseTickInterval)
	defer licTick.Stop()

	for {
		select {
		case <-renewTick.C:
			if renewer != nil {
				runRenewer(ctx, renewer)
			}
		case <-licTick.C:
			runLicenseVerify(ctx, licClient, licKeyStore, licRepo, nodeID)
		}
	}
}

// runLicenseVerify performs a single re-verify pass. Empty key = no-op
// (box stays in trial), so this is safe to call on every tick.
func runLicenseVerify(ctx context.Context, c *license.Client, ks *license.KeyStore,
	repo *licsvc.Repo, nodeID string) {
	key := ks.Get()
	if key == "" {
		slog.Debug("scheduler: license verify skipped — no key")
		return
	}
	res, err := c.Verify(key)
	if err != nil {
		_ = repo.MarkError(ctx, key, err.Error())
		slog.Warn("scheduler: license verify failed", "error", err)
		return
	}
	payload, _ := json.Marshal(res)
	status := "active"
	if !res.Valid {
		status = "expired"
		if res.Status == "revoked" {
			status = "invalid"
		}
	}
	if err := repo.Upsert(ctx, key, status, res.ExpiresAt, nodeID, 0, payload, ""); err != nil {
		slog.Warn("scheduler: license db upsert failed", "error", err)
		return
	}
	slog.Info("scheduler: license verified",
		"status", status, "valid", res.Valid, "expires_at", res.ExpiresAt)
}

func runRenewer(ctx context.Context, r *certrenewer.Service) {
	res, err := r.Run(ctx)
	if err != nil {
		slog.Error("scheduler: renewer run failed", "error", err)
		return
	}
	slog.Info("scheduler: renewer pass complete",
		"checked", res.Checked, "renewed", res.Renewed,
		"failed", res.Failed, "skipped", res.Skipped)
}