main.go

package main

import (
	"context"
	"flag"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/yourorg/loadbalancer/core"
	"github.com/yourorg/loadbalancer/observability"
	//"github.com/yourorg/loadbalancer/routing"
)


func main() {
	cfgPath := flag.String("config", "config.json", "path to config file")
	flag.Parse()

	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
		Level: slog.LevelInfo,
	}))

	cfg, err := core.LoadConfig(*cfgPath)
	if err != nil {
		logger.Error("failed to load config", "error", err)
		os.Exit(1)
	}

	logger.Info("starting load balancer",
		"addr", cfg.ListenAddr,
		"algorithm", cfg.Algorithm,
		"backends", len(cfg.Backends),
	)

	
	var backends []*core.Backend
	var backendURLs []string
	for _, bc := range cfg.Backends {
		b, err := core.NewBackend(bc.URL, bc.Weight)
		if err != nil {
			logger.Error("invalid backend URL", "url", bc.URL, "error", err)
			os.Exit(1)
		}
		backends = append(backends, b)
		backendURLs = append(backendURLs, bc.URL)
	}
	pool := core.NewPool(backends)

	collector := observability.NewCollector(backendURLs)
	sticky    := routing.NewStickySessionStore(cfg.StickySession)
	algo      := core.NewAlgorithm(cfg.Algorithm, pool)

	logger.Info("algorithm selected", "name", algo.Name())

	lb := core.NewLoadBalancer(core.Options{
		Pool:          pool,
		Algorithm:     algo,
		Collector:     collector,
		Sticky:        sticky,
		StickyEnabled: cfg.Stickysession.Enabled,
		Logger:        logger,
	})

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	if cfg.HealthCheck.Enabled {
		checker := observability.NewChecker(pool, cfg.HealthCheck, logger)
		go checker.Start(ctx)
	}

	mux := http.NewServeMux()
	if cfg.Metrics.Enabled {
		mux.Handle(cfg.Metrics.Path, collector.Handler())
		logger.Info("metrics endpoint enabled succassfully", "path", cfg.Metrics.Path)
	}
	mux.Handle("/", observability.Logger(logger, lb))

	//timing
	srv := &http.Server{
		Addr:         cfg.ListenAddr,
		Handler:      mux,
		ReadTimeout:  15 * time.Second,
		WriteTimeout: 30 * time.Second,
		IdleTimeout:  60 * time.Second,
	}

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-quit
		logger.Info("shutting down...")
		cancel()
		sdCtx, sdCancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer sdCancel()
		if err := srv.Shutdown(sdCtx); err != nil {
			logger.Error("shutdown error", "error", err)
		}
	}()
	

	if cfg.TLS.Enabled {
		logger.Info("TLS enabled", "cert", cfg.TLS.CertFile)
		err = srv.ListenAndServeTLS(cfg.TLS.CertFile, cfg.TLS.KeyFile)
	} else {
		err = srv.ListenAndServe()
	}
	if err != nil && err != http.ErrServerClosed {
		logger.Error("server error", "error", err)
		os.Exit(1)
	}
	logger.Info("load balancer stopped! restart")
}