server.go

package main

import (
	"context"
	"errors"
	"fmt"
	"log/slog"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

func (app *application) serve() error {
	srv := &http.Server{
		Addr:    fmt.Sprintf(":%d", app.config.port),
		Handler: app.routes(),

		IdleTimeout:  time.Minute,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
		ErrorLog:     slog.NewLogLogger(app.logger.Handler(), slog.LevelError),
	}
	shutdownError := make(chan error)
	go func() {
		// We use a buffered channel because signal.Notify sends signals asynchronously.
		// Unbuffered channels do not store values — they require a receiver to be ready
		// at the exact same time the value is sent.
		//
		// If we used an unbuffered channel, and a signal arrived before our goroutine
		// started receiving from the channel, the signal delivery could block or be missed.
		//
		// A buffered channel (size 1) allows the signal to be stored temporarily until
		// our goroutine reads it.

		quit := make(chan os.Signal, 1)
		signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
		s := <-quit
		app.logger.Info("caught signal", "signal", s.String())
		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
		defer cancel()
		err := srv.Shutdown(ctx)
		if err != nil {
			shutdownError <- err
		}
		app.logger.Info("completing background tasks", "addr", srv.Addr)
		app.wg.Wait()
		shutdownError <- nil

	}()

	app.logger.Info("starting server", "addr", srv.Addr, "env", app.config.env)
	err := srv.ListenAndServe()
	if !errors.Is(err, http.ErrServerClosed) {
		return err
	}
	err = <-shutdownError
	if err != nil {
		return err
	}
	app.logger.Info("stopped server", "addr", srv.Addr)
	return nil

}