server.go

// Code generated by lisette from src/; DO NOT EDIT.

package httpserver

import (
	"context"
	"errors"
	lisette "github.com/ivov/lisette/prelude"
	"log"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"sync/atomic"
	"syscall"
	"time"
)

type ShutdownHook func(context.Context) error

type Server struct {
	srv              *http.Server
	shutdown_timeout time.Duration
	ready            *atomic.Bool
	logger           *slog.Logger
	shutdown_hooks   []ShutdownHook
}

func New(options []ServerOption) *Server {
	cfg := default_config()
	WithPortFromEnv()(&cfg)
	for _, o := range options {
		o(&cfg)
	}
	ready := &atomic.Bool{}
	ready.Store(true)
	mux := http.NewServeMux()
	if !cfg.disable_default_probes {
		mux.HandleFunc(cfg.liveness_path, liveness_handler)
		mux.Handle(cfg.readiness_path, readiness_handler(ready, cfg.readiness_checks, cfg.logger))
	}
	subject_1 := cfg.metrics_handler
	if subject_1.Tag == lisette.OptionSome {
		mux.Handle("/_metrics", subject_1.SomeVal)
	}
	subject_2 := cfg.handler
	if subject_2.Tag == lisette.OptionSome {
		mux.Handle("/", subject_2.SomeVal)
	}
	opt_3 := lisette.MakeOptionSome[http.Handler](mux)
	var unwrap_4 http.Handler
	if opt_3.Tag == lisette.OptionSome {
		unwrap_4 = opt_3.SomeVal
	}
	opt_5 := lisette.MakeOptionSome(slog.NewLogLogger(cfg.logger.Handler(), slog.LevelError))
	var unwrap_6 *log.Logger
	if opt_5.Tag == lisette.OptionSome {
		unwrap_6 = opt_5.SomeVal
	}
	return &Server{
		srv: &http.Server{
			Addr:              cfg.addr,
			Handler:           unwrap_4,
			ReadHeaderTimeout: cfg.read_header_timeout,
			ReadTimeout:       cfg.read_timeout,
			WriteTimeout:      cfg.write_timeout,
			IdleTimeout:       cfg.idle_timeout,
			ErrorLog:          unwrap_6,
		},
		shutdown_timeout: cfg.shutdown_timeout,
		ready:            ready,
		logger:           cfg.logger,
		shutdown_hooks:   cfg.shutdown_hooks,
	}
}

func (s Server) Handler() http.Handler {
	raw_1 := s.srv.Handler
	option_2 := lisette.OptionFromNilable[http.Handler](raw_1, lisette.IsNilInterface(raw_1))
	v_3 := option_2
	if v_3.Tag == lisette.OptionSome {
		return v_3.SomeVal
	}
	return nil
}

func (s *Server) Start() error {
	s.logger.Info("server starting", "addr", s.srv.Addr)
	ret_2 := s.srv.ListenAndServe()
	var result_3 lisette.Result[struct{}, error]
	if ret_2 != nil {
		result_3 = lisette.MakeResultErr[struct{}, error](ret_2)
	} else {
		result_3 = lisette.MakeResultOk[struct{}, error](struct{}{})
	}
	subject_1 := result_3
	if subject_1.Tag == lisette.ResultOk {
		return nil
	}
	e := subject_1.ErrVal
	if errors.Is(e, http.ErrServerClosed) {
		return nil
	}
	callee_4 := s.logger.Error
	callee_4("server error", "error", e.Error())
	return e
}

func (s *Server) Run() error {
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()
	return s.run_with_context(ctx)
}

func (s *Server) run_with_context(ctx context.Context) error {
	start_err := make(chan error, 1)
	go func() {
		ret_2 := s.Start()
		var result_3 lisette.Result[struct{}, error]
		if ret_2 != nil {
			result_3 = lisette.MakeResultErr[struct{}, error](ret_2)
		} else {
			result_3 = lisette.MakeResultOk[struct{}, error](struct{}{})
		}
		subject_1 := result_3
		if subject_1.Tag == lisette.ResultErr {
			_ = lisette.ChannelSend(start_err, subject_1.ErrVal)
		}
	}()
	done := ctx.Done()
	select {
	case e, ok := <-start_err:
		if ok {
			return e
		}
	case _, ok := <-done:
		_ = ok
	}
	s.ready.Store(false)
	return s.Shutdown(context.Background())
}

func (s *Server) Shutdown(ctx context.Context) error {
	s.logger.Info("server shutting down")
	timeout_ctx, cancel := context.WithTimeout(ctx, s.shutdown_timeout)
	defer cancel()
	ret_1 := s.srv.Shutdown(timeout_ctx)
	var result_2 lisette.Result[struct{}, error]
	if ret_1 != nil {
		result_2 = lisette.MakeResultErr[struct{}, error](ret_1)
	} else {
		result_2 = lisette.MakeResultOk[struct{}, error](struct{}{})
	}
	check_3 := result_2
	if check_3.Tag != lisette.ResultOk {
		return check_3.ErrVal
	}
	errs := ([]error)(nil)
	for _, hook := range s.shutdown_hooks {
		ret_5 := hook(timeout_ctx)
		var result_6 lisette.Result[struct{}, error]
		if ret_5 != nil {
			result_6 = lisette.MakeResultErr[struct{}, error](ret_5)
		} else {
			result_6 = lisette.MakeResultOk[struct{}, error](struct{}{})
		}
		subject_4 := result_6
		if subject_4.Tag == lisette.ResultErr {
			errs = append(errs, subject_4.ErrVal)
		}
	}
	raw_8 := errors.Join(errs...)
	option_9 := lisette.OptionFromNilable[error](raw_8, lisette.IsNilInterface(raw_8))
	subject_7 := option_9
	if subject_7.Tag == lisette.OptionSome {
		return subject_7.SomeVal
	}
	return nil
}