LovroG05
abecc4b888
All checks were successful
ci/woodpecker/push/woodpecker Pipeline was successful
Add an optional exporter that writes one point per proxied request to the InfluxDB 3 write endpoint. Points are batched in memory and flushed by size or interval. The exporter is off until GATEWAY_INFLUX_URL is set.
287 lines
7.8 KiB
Go
287 lines
7.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"log/slog"
|
|
"net/http"
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
"time"
|
|
|
|
"github.com/go-chi/chi/v5"
|
|
"github.com/go-chi/chi/v5/middleware"
|
|
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/api"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/catalog"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/config"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/crypto"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/db"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/influx"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/oidcauth"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/providermgr"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/ratelimit"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/store"
|
|
"git.govekar.net/LovroG05/localmodelroutex/internal/web"
|
|
|
|
// Self-register all provider implementations.
|
|
_ "git.govekar.net/LovroG05/localmodelroutex/internal/providers/all"
|
|
)
|
|
|
|
func main() {
|
|
if err := run(); err != nil {
|
|
slog.Error("startup failed", "err", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func run() error {
|
|
cfg, err := config.Load()
|
|
if err != nil {
|
|
return fmt.Errorf("load config: %w", err)
|
|
}
|
|
|
|
level := new(slog.LevelVar)
|
|
slog.SetDefault(newLogger(cfg, level))
|
|
|
|
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
|
|
defer stop()
|
|
|
|
pool, err := db.New(ctx, cfg.DB)
|
|
if err != nil {
|
|
return fmt.Errorf("connect database: %w", err)
|
|
}
|
|
defer pool.Close()
|
|
slog.Info("connected to database")
|
|
|
|
if err := db.Migrate(cfg.DB.URL); err != nil {
|
|
return fmt.Errorf("run migrations: %w", err)
|
|
}
|
|
slog.Info("database schema up to date")
|
|
|
|
cipher, err := crypto.NewCipher(cfg.Security.EncryptionKey)
|
|
if err != nil {
|
|
return fmt.Errorf("init cipher: %w", err)
|
|
}
|
|
|
|
st := store.New(pool)
|
|
mgr := providermgr.New(st, cipher)
|
|
|
|
// The dashboard's log level setting overrides the env default once set.
|
|
var levelName string
|
|
if ok, _ := st.GetSetting(ctx, "app.log_level", &levelName); ok {
|
|
level.Set(parseLogLevel(levelName))
|
|
}
|
|
|
|
if err := mgr.Reload(ctx); err != nil {
|
|
slog.Warn("initial provider load failed", "err", err)
|
|
}
|
|
|
|
cache := catalog.NewCache(st)
|
|
if err := cache.Reload(ctx); err != nil {
|
|
slog.Warn("initial catalog load failed", "err", err)
|
|
}
|
|
|
|
syncer := catalog.NewSyncer(st, cache)
|
|
|
|
oidcV, err := oidcauth.New(ctx, cfg.OIDC.Issuer, cfg.OIDC.ClientID, cfg.OIDC.AdminGroup)
|
|
if err != nil {
|
|
return fmt.Errorf("init oidc: %w", err)
|
|
}
|
|
slog.Info("OIDC auth enabled", "issuer", cfg.OIDC.Issuer)
|
|
|
|
limiter := ratelimit.New()
|
|
|
|
// syncNow is used by admin endpoints to force an immediate refresh.
|
|
syncNow := func(ctx context.Context) error {
|
|
if err := mgr.Reload(ctx); err != nil {
|
|
return err
|
|
}
|
|
return syncer.SyncAll(ctx, toProviderRefs(mgr.List()))
|
|
}
|
|
|
|
// refresh is called each syncer tick: reload providers then return refs.
|
|
refresh := func(ctx context.Context) ([]catalog.ProviderRef, error) {
|
|
if err := mgr.Reload(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
return toProviderRefs(mgr.List()), nil
|
|
}
|
|
|
|
go syncer.Run(ctx, cfg.Catalog.SyncInterval, refresh)
|
|
|
|
// Purge request logs once at startup and then daily. Retention is
|
|
// controlled by the log.retention_days setting (0 = keep forever).
|
|
go func() {
|
|
purge := func() {
|
|
purgeCtx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
|
|
defer cancel()
|
|
days := 365
|
|
if ok, _ := st.GetSetting(purgeCtx, "log.retention_days", &days); !ok {
|
|
days = 365
|
|
}
|
|
if days <= 0 {
|
|
return
|
|
}
|
|
tag, err := pool.Exec(purgeCtx,
|
|
`DELETE FROM request_logs WHERE created_at < NOW() - make_interval(days => $1)`, days)
|
|
if err != nil {
|
|
slog.Warn("request log purge failed", "err", err)
|
|
return
|
|
}
|
|
if tag.RowsAffected() > 0 {
|
|
slog.Info("purged request logs", "rows", tag.RowsAffected(), "retention_days", days)
|
|
}
|
|
}
|
|
purge()
|
|
tick := time.NewTicker(24 * time.Hour)
|
|
defer tick.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-tick.C:
|
|
purge()
|
|
}
|
|
}
|
|
}()
|
|
|
|
// The exporter sends one point per request to InfluxDB 3 when configured.
|
|
var stats api.RequestStats
|
|
var exporter *influx.Exporter
|
|
if cfg.Influx.Enabled() {
|
|
exporter, err = influx.New(influx.Config{
|
|
URL: cfg.Influx.URL,
|
|
Token: cfg.Influx.Token,
|
|
Database: cfg.Influx.Database,
|
|
Measurement: cfg.Influx.Measurement,
|
|
FlushInterval: cfg.Influx.FlushInterval,
|
|
BatchSize: cfg.Influx.BatchSize,
|
|
})
|
|
if err != nil {
|
|
return fmt.Errorf("init influx exporter: %w", err)
|
|
}
|
|
exporter.Start()
|
|
stats = exporter
|
|
slog.Info("influx exporter enabled", "url", cfg.Influx.URL, "database", cfg.Influx.Database)
|
|
}
|
|
|
|
deps := api.Deps{
|
|
Store: st,
|
|
Stats: stats,
|
|
Cache: cache,
|
|
Manager: mgr,
|
|
Cipher: cipher,
|
|
OIDCVerifier: oidcV,
|
|
OIDCClientID: cfg.OIDC.ClientID,
|
|
OIDCClientSecret: cfg.OIDC.ClientSecret,
|
|
OIDCAuthURL: oidcV.AuthURL(),
|
|
OIDCTokenURL: oidcV.TokenURL(),
|
|
PublicBaseURL: cfg.Server.PublicURL,
|
|
Limiter: limiter,
|
|
SyncNow: syncNow,
|
|
LogLevel: level,
|
|
}
|
|
a := api.New(deps)
|
|
|
|
srv := &http.Server{
|
|
Addr: fmt.Sprintf(":%d", cfg.Server.Port),
|
|
Handler: newRouter(pool, a),
|
|
ReadHeaderTimeout: 10 * time.Second,
|
|
ReadTimeout: 30 * time.Second,
|
|
// WriteTimeout is intentionally zero: SSE streams can run indefinitely.
|
|
IdleTimeout: 120 * time.Second,
|
|
}
|
|
|
|
serverErr := make(chan error, 1)
|
|
go func() {
|
|
slog.Info("http server listening", "addr", srv.Addr, "env", cfg.Server.Env)
|
|
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
serverErr <- err
|
|
}
|
|
}()
|
|
|
|
select {
|
|
case err := <-serverErr:
|
|
return fmt.Errorf("http server: %w", err)
|
|
case <-ctx.Done():
|
|
slog.Info("shutdown signal received")
|
|
}
|
|
|
|
shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
if err := srv.Shutdown(shutdownCtx); err != nil {
|
|
return fmt.Errorf("graceful shutdown: %w", err)
|
|
}
|
|
if exporter != nil {
|
|
if err := exporter.Close(shutdownCtx); err != nil {
|
|
slog.Warn("influx exporter did not flush in time", "err", err)
|
|
}
|
|
}
|
|
slog.Info("server stopped cleanly")
|
|
return nil
|
|
}
|
|
|
|
func newLogger(cfg *config.Config, level *slog.LevelVar) *slog.Logger {
|
|
level.Set(slog.LevelInfo)
|
|
opts := &slog.HandlerOptions{Level: level}
|
|
if cfg.IsDev() {
|
|
level.Set(slog.LevelDebug)
|
|
return slog.New(slog.NewTextHandler(os.Stdout, opts))
|
|
}
|
|
return slog.New(slog.NewJSONHandler(os.Stdout, opts))
|
|
}
|
|
|
|
func parseLogLevel(s string) slog.Level {
|
|
switch s {
|
|
case "debug":
|
|
return slog.LevelDebug
|
|
case "warn":
|
|
return slog.LevelWarn
|
|
case "error":
|
|
return slog.LevelError
|
|
default:
|
|
return slog.LevelInfo
|
|
}
|
|
}
|
|
|
|
func newRouter(pool interface{ Ping(context.Context) error }, a *api.API) http.Handler {
|
|
r := chi.NewRouter()
|
|
r.Use(middleware.RequestID)
|
|
r.Use(middleware.Recoverer)
|
|
// No Timeout middleware: SSE streams must not be cut off by a global deadline.
|
|
|
|
r.Get("/healthz", func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write([]byte("ok"))
|
|
})
|
|
r.Get("/readyz", func(w http.ResponseWriter, r *http.Request) {
|
|
ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
|
|
defer cancel()
|
|
if err := pool.Ping(ctx); err != nil {
|
|
http.Error(w, "database unavailable", http.StatusServiceUnavailable)
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusOK)
|
|
_, _ = w.Write([]byte("ok"))
|
|
})
|
|
|
|
a.Mount(r)
|
|
|
|
// Dashboard SPA — registered last so API routes take precedence.
|
|
r.Handle("/*", web.Handler())
|
|
|
|
return r
|
|
}
|
|
|
|
// toProviderRefs converts manager instances to catalog provider references.
|
|
func toProviderRefs(insts []providermgr.Instance) []catalog.ProviderRef {
|
|
refs := make([]catalog.ProviderRef, len(insts))
|
|
for i, inst := range insts {
|
|
refs[i] = catalog.ProviderRef{ID: inst.ID, Provider: inst.Provider}
|
|
}
|
|
return refs
|
|
}
|