Worker and HTTP server graceful shutdown

I am trying to create a worker and an HTTP server which start independently, and listen for terminations and exit gracefully upon completion.

For some reason, the worker starts, but the HTTP server does not, until the SIGTERM event is sent. Only after the sigterm event is sent, then the http server starts. Where is the problem with the following?

Output

https://gosamples.dev is the best
https://gosamples.dev is the best
https://gosamples.dev is the best
^C2023/05/27 15:07:52 Listening on HTTP server port:
Process finished with the exit code 0

Code

package main

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

func main() {
    ctx, cancel := context.WithCancel(context.Background())

    go func() {
        signals := make(chan os.Signal, 1)
        signal.Notify(signals, os.Interrupt, syscall.SIGTERM)
        <-signals

        cancel()
    }()

    var wg sync.WaitGroup

    wg.Add(1)
    go func() {
        if err := myWorker(ctx); err != nil {
            cancel()
        }
        wg.Done()
    }()

    wg.Add(1)
    go func() {
        if err := startServer(ctx); err != nil {
            cancel()
        }
        wg.Done()
    }()

    wg.Wait()
}

func myWorker(ctx context.Context) error {
    shouldStop := false

    go func() {
        <-ctx.Done()
        shouldStop = true
    }()

    for !shouldStop {
        fmt.Println("https://gosamples.dev is the best")
        time.Sleep(1 * time.Second)
    }

    return nil
}

func startServer(ctx context.Context) error {
    var srv http.Server

    go func() {
        <-ctx.Done() // Wait for the context to be done

        // Shutdown the server
        if err := srv.Shutdown(context.Background()); err != nil {
            // Error from closing listeners, or context timeout:
            log.Printf("HTTP server Shutdown: %v", err)
        }
    }()

    if err := srv.ListenAndServe(); err != http.ErrServerClosed {
        // Error starting or closing listener:
        return fmt.Errorf("HTTP server ListenAndServe: %w", err)
    }

    log.Printf("Listening on HTTP server port: %s", srv.Addr)

    http.HandleFunc("/readiness", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(200)
    })
    http.HandleFunc("/liveness", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(200)
    })

    return nil
}

If I read your code correctly, you start the server before you are defining your route handlers. This means that when the server starts, it does not know about your /readiness and /liveness endpoints because you have not added them yet. As a result, the server starts, but it does not do anything because it has no routes to handle.

Then, you do not define the Addr field in your http.Server instance. ListenAndServe() uses the address defined in the Addr field of the http.Server instance it is called on. If it is empty, it defaults to ":http", but this is not explicitly stated in your code which could lead to confusion.

> I moved srv.ListenAndServe to the very end of startServer. What did I missed?

The issue isn't where srv.ListenAndServe is located in the function, but rather how the http.Server is configured and when the HTTP handlers are set up.

In the original code, you are setting up the HTTP handlers after the server has started. Handlers need to be set up before starting the server because once the server is running, it will not pick up any new handlers that are defined later.

And the log statement log.Printf("Listening on HTTP server port: %s", srv.Addr) is after srv.ListenAndServe(), which is a blocking call. This means that the log statement will only run after the server has stopped, which is why you only see it after sending the SIGTERM signal.

Try and reorganize your startServer function like this:

func startServer(ctx context.Context) error {
	srv := &http.Server{
		Addr: ":8080", // Define the address where you want the server to listen
	}

	http.HandleFunc("/readiness", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	})
	http.HandleFunc("/liveness", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(200)
	})

	go func() {
		<-ctx.Done() // Wait for the context to be done

		// Shutdown the server
		if err := srv.Shutdown(context.Background()); err != nil {
			// Error from closing listeners, or context timeout:
			log.Printf("HTTP server Shutdown: %v", err)
		}
	}()

	log.Printf("Listening on HTTP server port: %s", srv.Addr)

	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		// Error starting or closing listener:
		return fmt.Errorf("HTTP server ListenAndServe: %w", err)
	}

	return nil
}

In this modified version of your startServer function, the server now knows about your /readiness and /liveness endpoints because they are defined before the server starts.
The HTTP handlers are set up before the server starts, and the log statement is printed before the server starts. This should solve your problem and allow the server to start and handle requests as expected. Also, now the server knows where to listen as Addr is explicitly defined.