package main
import (
"context"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"example.com/app/server"
)
func main() {
ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
defer stop()
mux := http.NewServeMux()
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
})
mux.HandleFunc("/slow", func(w http.ResponseWriter, r *http.Request) {
time.Sleep(3 * time.Second)
w.Write([]byte("done\n"))
})
srv := server.New(":8080", mux)
go func() {
log.Printf("listening on %s", srv.Addr())
if err := srv.Run(); err != nil {
log.Fatalf("server error: %v", err)
}
}()
<-ctx.Done()
stop() // restore default handler so a second Ctrl+C force-quits
log.Println("shutdown signal received, draining connections...")
if err := srv.Shutdown(10 * time.Second); err != nil {
log.Fatalf("graceful shutdown failed: %v", err)
}
log.Println("server stopped cleanly")
}
package server
import (
"context"
"errors"
"net/http"
"time"
)
type Server struct {
http *http.Server
}
func New(addr string, handler http.Handler) *Server {
return &Server{
http: &http.Server{
Addr: addr,
Handler: handler,
ReadHeaderTimeout: 5 * time.Second,
ReadTimeout: 15 * time.Second,
WriteTimeout: 30 * time.Second,
IdleTimeout: 60 * time.Second,
},
}
}
func (s *Server) Addr() string {
return s.http.Addr
}
func (s *Server) Run() error {
err := s.http.ListenAndServe()
if errors.Is(err, http.ErrServerClosed) {
return nil
}
return err
}
func (s *Server) Shutdown(timeout time.Duration) error {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return s.http.Shutdown(ctx)
}
This snippet shows the idiomatic way to shut down a Go HTTP server without dropping in-flight requests when the process receives a SIGINT (Ctrl+C) or SIGTERM (sent by orchestrators like Kubernetes or systemd). The core problem is that calling os.Exit or letting the process die abruptly severs open connections mid-response, corrupts streaming replies, and skips cleanup of database pools and other resources. A graceful shutdown instead stops accepting new connections, lets active handlers finish within a deadline, and only then exits.
In main.go, the entry point wires two lifecycle signals into a single context.Context via signal.NotifyContext. This returns a context that is cancelled the moment either signal arrives, which is cleaner than manually managing a chan os.Signal. The stop function returned by NotifyContext must be deferred so the signal handler is unregistered on exit. The server runs in its own goroutine because srv.ListenAndServe blocks until the server stops; the main goroutine then blocks on <-ctx.Done(), waking only when a signal fires or the listener errors.
The server package holds the construction and teardown logic. New builds an *http.Server with sane production timeouts — ReadHeaderTimeout guards against slow-loris attacks and IdleTimeout reaps idle keep-alive connections. The key method is Shutdown, which derives a fresh context.WithTimeout (the incoming signal context is already cancelled, so a new deadline is needed) and calls http.Server.Shutdown. That call closes listeners, then waits for active requests to complete or the timeout to elapse, returning context.DeadlineExceeded if handlers hang.
Note the treatment of http.ErrServerClosed in Run: ListenAndServe always returns a non-nil error, and ErrServerClosed specifically means shutdown was requested, so it is filtered out rather than treated as a crash. A common pitfall is choosing too short a shutdown deadline, which cuts off legitimate long requests; another is forgetting that new SIGINTs during shutdown are ignored unless a second handler is added to force-exit. This pattern is the baseline for any long-running Go service.
Related snips
package api
import (
"net/http"
"runtime/debug"
)Expose build metadata for debugging deploys
export interface RetryOptions {
retries: number;
baseMs: number;
maxMs: number;
signal?: AbortSignal;
onRetry?: (attempt: number, delay: number, err: unknown) => void;Exponential backoff with jitter for retries
class Product(models.Model):
name = models.CharField(max_length=200)
slug = models.SlugField(blank=True)
price = models.DecimalField(max_digits=10, decimal_places=2)
cost = models.DecimalField(max_digits=10, decimal_places=2)
margin = models.DecimalField(max_digits=5, decimal_places=2, blank=True)Django model signals vs overriding save
package dbutil
import (
"context"
"github.com/jackc/pgconn"Retry Postgres serialization failures with bounded attempts
use crossbeam::channel::unbounded;
use std::thread;
fn main() {
let (tx, rx) = unbounded();Crossbeam for advanced concurrent data structures
// Creating a Promise
const myPromise = new Promise((resolve, reject) => {
const success = true;
setTimeout(() => {
if (success) {Promises and async/await patterns for asynchronous JavaScript
Share this code
Here's the card — post it anywhere.
