一个为用途而建的健康检查值得保留

package main

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"runtime"
	"sync/atomic"
	"time"
)

func must(err error) {
	if err != nil {
		panic(err)
	}
}

func check(ok bool, message string) {
	if !ok {
		panic(message)
	}
}

func main() {
	var mode, dependencyCalls atomic.Int64
	var started, draining atomic.Bool
	canceled := make(chan struct{}, 1)
	dependency := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		dependencyCalls.Add(1)
		switch mode.Load() {
		case 1:
			w.WriteHeader(503)
		case 2:
			<-r.Context().Done()
			canceled <- struct{}{}
		default:
			w.WriteHeader(204)
		}
	}))
	defer dependency.Close()
	transport := &http.Transport{}
	defer transport.CloseIdleConnections()
	client := &http.Client{Transport: transport, Timeout: 2 * time.Second,
		CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse },
	}
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
		w.Header().Set("Cache-Control", "no-store")
		if r.Method != "GET" {
			w.Header().Set("Allow", "GET")
			w.WriteHeader(405)
			return
		}
		ready := false
		switch r.URL.Path {
		case "/livez":
			ready = true // No shared-dependency restart policy.
		case "/startupz":
			ready = started.Load()
		case "/readyz":
			if started.Load() && !draining.Load() {
				ctx, cancel := context.WithTimeout(r.Context(), 100*time.Millisecond)
				defer cancel()
				request, err := http.NewRequestWithContext(ctx, "GET", dependency.URL, nil)
				must(err)
				response, err := client.Do(request)
				if err == nil {
					ready = response.StatusCode == 204
					must(response.Body.Close())
				}
			}
		default:
			w.WriteHeader(404)
			return
		}
		if !ready {
			w.WriteHeader(503)
			return
		}
		w.WriteHeader(200)
	}))
	defer server.Close()
	probe := func(method, route string, status int, calls int64) {
		before := dependencyCalls.Load()
		request, err := http.NewRequest(method, server.URL+route, nil)
		must(err)
		response, err := client.Do(request)
		must(err)
		_, readError := io.Copy(io.Discard, response.Body)
		closeError := response.Body.Close()
		must(readError)
		must(closeError)
		check(response.Proto == "HTTP/1.1" && response.StatusCode == status, "wrong probe status")
		check(response.Header.Get("Cache-Control") == "no-store", "probe response must not be cached")
		check(dependencyCalls.Load() == before+calls, "unexpected dependency work")
		if status == 405 {
			check(response.Header.Get("Allow") == "GET", "method contract missing")
		}
		fmt.Printf("%s: %d, dependency calls=%d\n", route, status, dependencyCalls.Load())
	}
	probe("GET", "/livez", 200, 0)
	probe("GET", "/startupz", 503, 0)
	probe("GET", "/readyz", 503, 0)
	started.Store(true)
	probe("GET", "/startupz", 200, 0)
	probe("GET", "/readyz", 200, 1)
	mode.Store(1)
	probe("GET", "/livez", 200, 0)
	probe("GET", "/readyz", 503, 1)
	mode.Store(2)
	probe("GET", "/readyz", 503, 1)
	select {
	case <-canceled:
		fmt.Println("deadline canceled the stalled dependency request")
	case <-time.After(time.Second):
		panic("dependency did not observe cancellation")
	}
	mode.Store(0)
	probe("GET", "/readyz", 200, 1)
	draining.Store(true)
	probe("GET", "/readyz", 503, 0)
	probe("GET", "/livez", 200, 0)
	draining.Store(false)
	probe("GET", "/readyz", 200, 1)
	probe("POST", "/readyz", 405, 0)
	probe("GET", "/unknown", 404, 0)
	check(dependencyCalls.Load() == 5, "only five readiness checks should query the dependency")
	fmt.Println("PASS: fourteen probes; live, starting, unready, stalled, draining, and recovered")
	fmt.Println(runtime.Version())
}