Tasks

// Call chain on first request:
//   1. http.ListenAndServe          (server.go ~3300)
//   2. (*Server).ListenAndServe     (server.go ~3300)
//   3. (*Server).Serve              (server.go ~3070) — accept loop
//   4. go (*conn).serve             (server.go ~1900) — per-conn goroutine
//   5. serverHandler.ServeHTTP      (server.go ~3000) — bridge
//   6. (*ServeMux).ServeHTTP        (server.go ~2700)
//   7. hello (our handler)
package main

import (
    "fmt"
    "log"
    "net/http"
)

func hello(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "hello")
}

func main() {
    http.HandleFunc("/", hello)
    log.Println("listening :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "context"
    "errors"
    "fmt"
    "net/http"
    "time"
)

func main() {
    client := &http.Client{Timeout: 5 * time.Second}
    start := time.Now()
    resp, err := client.Get("https://httpbin.org/delay/10")
    elapsed := time.Since(start)
    if err != nil {
        fmt.Printf("err after %v: %v\n", elapsed, err)
        fmt.Printf("is DeadlineExceeded? %v\n", errors.Is(err, context.DeadlineExceeded))
        // url.Error wraps the context error; errors.Is unwraps it.
        return
    }
    defer resp.Body.Close()
    fmt.Printf("ok in %v: %d\n", elapsed, resp.StatusCode)
}

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
        id := r.PathValue("id")
        fmt.Fprintf(w, "user %s\n", id)
    })
    mux.HandleFunc("POST /users", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusCreated)
        fmt.Fprintln(w, "created")
    })
    log.Fatal(http.ListenAndServe(":8080", mux))
}

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "runtime"
)

func main() {
    client := &http.Client{}
    for i := 0; i < 100; i++ {
        resp, err := client.Get("http://localhost:8080/")
        if err != nil {
            log.Fatal(err)
        }
        // Senior decision: defer comes AFTER nil check; drain BEFORE close so the
        // Transport can park the conn back in the idle pool. Forgetting either
        // half leaks a TCP connection and a readLoop goroutine.
        _, _ = io.Copy(io.Discard, resp.Body)
        resp.Body.Close()
    }
    fmt.Println("goroutines:", runtime.NumGoroutine())
}

package main

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

func main() {
    tr := &http.Transport{
        MaxIdleConns:        200,
        MaxIdleConnsPerHost: 100,
        IdleConnTimeout:     90 * time.Second,
    }
    client := &http.Client{Transport: tr, Timeout: 10 * time.Second}

    var reused, total int64
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            trace := &httptrace.ClientTrace{
                GotConn: func(info httptrace.GotConnInfo) {
                    atomic.AddInt64(&total, 1)
                    if info.Reused {
                        atomic.AddInt64(&reused, 1)
                    }
                },
            }
            ctx := httptrace.WithClientTrace(context.Background(), trace)
            req, _ := http.NewRequestWithContext(ctx, "GET", "http://localhost:8080/", nil)
            resp, err := client.Do(req)
            if err != nil {
                return
            }
            io.Copy(io.Discard, resp.Body)
            resp.Body.Close()
        }()
    }
    wg.Wait()
    fmt.Printf("reuse: %d/%d (%.1f%%)\n", reused, total, 100*float64(reused)/float64(total))
}

package main

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

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/slow", func(w http.ResponseWriter, r *http.Request) {
        select {
        case <-time.After(5 * time.Second):
            w.Write([]byte("done\n"))
        case <-r.Context().Done():
            // Senior decision: respect ctx so Shutdown can unblock us.
            http.Error(w, "shutting down", http.StatusServiceUnavailable)
        }
    })

    srv := &http.Server{Addr: ":8080", Handler: mux}

    ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
    defer stop()

    go func() {
        if err := srv.ListenAndServe(); !errors.Is(err, http.ErrServerClosed) {
            log.Fatalf("listen: %v", err)
        }
    }()

    <-ctx.Done()
    log.Println("shutting down")
    shutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    if err := srv.Shutdown(shutdownCtx); err != nil {
        log.Fatalf("shutdown: %v", err)
    }
    log.Println("bye")
}

package main

import (
    "log"
    "net/http"
    "time"
)

type Middleware func(http.Handler) http.Handler

func Chain(mws ...Middleware) Middleware {
    return func(final http.Handler) http.Handler {
        for i := len(mws) - 1; i >= 0; i-- {
            final = mws[i](final)
        }
        return final
    }
}

type statusWriter struct {
    http.ResponseWriter
    status int
}

func (s *statusWriter) WriteHeader(c int) { s.status = c; s.ResponseWriter.WriteHeader(c) }

func Logging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        sw := &statusWriter{ResponseWriter: w, status: 200}
        start := time.Now()
        next.ServeHTTP(sw, r)
        log.Printf("%s %s %d %v", r.Method, r.URL.Path, sw.status, time.Since(start))
    })
}

func Auth(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("Authorization") != "Bearer dev" {
            http.Error(w, "unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func main() {
    h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("hello\n"))
    })
    wrapped := Chain(Logging, Auth)(h)
    http.Handle("/", wrapped)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package proxytime

import (
    "fmt"
    "io"
    "net/http"
    "net/http/httptest"
    "strings"
    "testing"
)

type Service struct {
    UpstreamURL string
    Client      *http.Client
}

func (s *Service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    resp, err := s.Client.Get(s.UpstreamURL + "/now")
    if err != nil {
        http.Error(w, "upstream failed", http.StatusBadGateway)
        return
    }
    defer resp.Body.Close()
    b, _ := io.ReadAll(resp.Body)
    fmt.Fprintf(w, "now: %s", strings.TrimSpace(string(b)))
}

func TestProxyTime(t *testing.T) {
    upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/now" {
            t.Errorf("unexpected path %s", r.URL.Path)
        }
        fmt.Fprint(w, "1700000000")
    }))
    defer upstream.Close()

    s := &Service{UpstreamURL: upstream.URL, Client: upstream.Client()}
    rec := httptest.NewRecorder()
    req := httptest.NewRequest("GET", "/", nil)
    s.ServeHTTP(rec, req)

    if got, want := rec.Body.String(), "now: 1700000000"; got != want {
        t.Errorf("body = %q, want %q", got, want)
    }
}

package main

import (
    "context"
    "crypto/rand"
    "encoding/hex"
    "log/slog"
    "net/http"
    "os"
)

type ctxKey struct{}

var reqIDKey = ctxKey{}

func newID() string {
    var b [16]byte
    _, _ = rand.Read(b[:])
    return hex.EncodeToString(b[:])
}

func WithRequestID(ctx context.Context, id string) context.Context {
    return context.WithValue(ctx, reqIDKey, id)
}

func RequestIDFromContext(ctx context.Context) string {
    if v, ok := ctx.Value(reqIDKey).(string); ok {
        return v
    }
    return ""
}

func RequestID(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        id := r.Header.Get("X-Request-ID")
        if id == "" {
            id = newID()
        }
        w.Header().Set("X-Request-ID", id)
        ctx := WithRequestID(r.Context(), id)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func main() {
    logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        logger.InfoContext(r.Context(), "hit", "req_id", RequestIDFromContext(r.Context()))
        w.Write([]byte("ok\n"))
    })
    http.ListenAndServe(":8080", RequestID(mux))
}

package main

import (
    "encoding/json"
    "errors"
    "fmt"
    "log"
    "net/http"
    "strings"
)

type Widget struct {
    ID   string `json:"id"`
    Name string `json:"name"`
    Qty  int    `json:"qty"`
}

func (w Widget) Validate() error {
    if w.ID == "" {
        return errors.New("id required")
    }
    if w.Qty < 0 {
        return errors.New("qty must be >= 0")
    }
    return nil
}

func create(w http.ResponseWriter, r *http.Request) {
    r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
    dec := json.NewDecoder(r.Body)
    dec.DisallowUnknownFields()

    var widget Widget
    if err := dec.Decode(&widget); err != nil {
        // MaxBytesReader returns a *http.MaxBytesError on 1.19+.
        var maxErr *http.MaxBytesError
        if errors.As(err, &maxErr) {
            http.Error(w, "request too large", http.StatusRequestEntityTooLarge)
            return
        }
        http.Error(w, fmt.Sprintf("bad json: %v", err), http.StatusBadRequest)
        return
    }
    if dec.More() {
        http.Error(w, "trailing data", http.StatusBadRequest)
        return
    }
    if err := widget.Validate(); err != nil {
        http.Error(w, err.Error(), http.StatusUnprocessableEntity)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(map[string]string{"id": widget.ID})
    _ = strings.Builder{}
}

func main() {
    http.HandleFunc("POST /widgets", create)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "log"
    "net"
    "net/http"
    _ "net/http/pprof"
    "time"
)

func main() {
    // Start pprof on its own listener so it doesn't share fates with the main server.
    go func() {
        log.Println(http.ListenAndServe("127.0.0.1:6060", nil))
    }()

    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("ok\n"))
    })

    srv := &http.Server{
        Addr:              ":8080",
        Handler:           mux,
        ReadHeaderTimeout: 5 * time.Second,
        ReadTimeout:       30 * time.Second,
        WriteTimeout:      30 * time.Second,
        IdleTimeout:       120 * time.Second,
        MaxHeaderBytes:    1 << 14, // 16 KB
    }

    // Bind explicitly so we can log the resolved address.
    ln, err := net.Listen("tcp", srv.Addr)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("listening %s", ln.Addr())
    log.Fatal(srv.Serve(ln))
}

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "strings"
)

func main() {
    target, _ := url.Parse("http://localhost:9000")
    proxy := httputil.NewSingleHostReverseProxy(target)
    proxy.Rewrite = func(r *httputil.ProxyRequest) {
        r.SetURL(target)
        r.Out.URL.Path = strings.TrimPrefix(r.In.URL.Path, "/api")
        r.Out.Header.Set("X-Forwarded-Host", r.In.Host)
        r.SetXForwarded() // sets X-Forwarded-For/Proto from r.In
    }
    proxy.ModifyResponse = func(resp *http.Response) error {
        resp.Header.Set("X-Proxy", "senior-go")
        return nil
    }
    proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
        log.Printf("proxy err: %v", err)
        http.Error(w, "upstream unavailable", http.StatusBadGateway)
    }
    log.Fatal(http.ListenAndServe(":8080", proxy))
}

// Run with: GODEBUG=http2debug=2 go run main.go
package main

import (
    "fmt"
    "io"
    "net/http"
    "net/http/httptest"
)

func main() {
    srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "hello over h2")
    }))
    defer srv.Close()

    client := srv.Client() // already configured to trust the self-signed cert
    resp, err := client.Get(srv.URL)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Printf("proto=%s status=%d body=%s", resp.Proto, resp.StatusCode, body)
}

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func sse(w http.ResponseWriter, r *http.Request) {
    flusher, ok := w.(http.Flusher)
    if !ok {
        http.Error(w, "streaming unsupported", http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-r.Context().Done():
            log.Println("client gone")
            return
        case t := <-ticker.C:
            fmt.Fprintf(w, "data: %s\n\n", t.Format(time.RFC3339))
            flusher.Flush()
        }
    }
}

func main() {
    srv := &http.Server{
        Addr:         ":8080",
        Handler:      http.HandlerFunc(sse),
        WriteTimeout: 0, // SSE streams indefinitely; per-stream timeout via ctx
        IdleTimeout:  0,
    }
    log.Fatal(srv.ListenAndServe())
}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)

type Record struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Value int    `json:"value"`
}

func stream(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    flusher, _ := w.(http.Flusher)

    enc := json.NewEncoder(w)
    fmt.Fprint(w, "[")
    first := true
    for i := 0; i < 1_000_000; i++ {
        if !first {
            fmt.Fprint(w, ",")
        }
        first = false
        if err := enc.Encode(Record{ID: i, Name: "row", Value: i * 2}); err != nil {
            // client disconnected — silently bail
            return
        }
        if i%1000 == 0 && flusher != nil {
            flusher.Flush()
        }
    }
    fmt.Fprint(w, "]")
    if flusher != nil {
        flusher.Flush()
    }
}

func main() {
    http.HandleFunc("/stream", stream)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "context"
    "crypto/sha256"
    "log"
    "net/http"
    _ "net/http/pprof"
    "runtime/pprof"
)

func hashHandler(w http.ResponseWriter, r *http.Request) {
    pprof.Do(r.Context(), pprof.Labels("endpoint", "/hash"), func(ctx context.Context) {
        buf := make([]byte, 32)
        for i := 0; i < 100_000; i++ {
            h := sha256.Sum256(buf)
            buf = h[:]
        }
        w.Write(buf)
    })
}

func main() {
    go func() { log.Fatal(http.ListenAndServe("127.0.0.1:6060", nil)) }()

    // Background noise to make labels useful.
    go func() {
        buf := make([]byte, 32)
        for {
            h := sha256.Sum256(buf)
            buf = h[:]
        }
    }()

    http.HandleFunc("/hash", hashHandler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "bufio"
    "fmt"
    "log"
    "net/http"
    "strings"
)

func upgrade(w http.ResponseWriter, r *http.Request) {
    hj, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "hijack unsupported (HTTP/2?)", http.StatusInternalServerError)
        return
    }
    conn, bufrw, err := hj.Hijack()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer conn.Close()

    // Senior decision: hand-write the 101. Don't try to call WriteHeader after Hijack.
    fmt.Fprintf(bufrw, "HTTP/1.1 101 Switching Protocols\r\n")
    fmt.Fprintf(bufrw, "Upgrade: echo\r\n")
    fmt.Fprintf(bufrw, "Connection: Upgrade\r\n\r\n")
    bufrw.Flush()

    for {
        line, err := bufrw.ReadString('\n')
        if err != nil {
            log.Printf("client gone: %v", err)
            return
        }
        out := strings.ToUpper(strings.TrimRight(line, "\r\n"))
        fmt.Fprintf(bufrw, "%s\n", out)
        bufrw.Flush()
    }
}

func main() {
    http.HandleFunc("/upgrade", upgrade)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    c, _ := net.Dial("tcp", "127.0.0.1:8080")
    defer c.Close()
    fmt.Fprintf(c, "GET /upgrade HTTP/1.1\r\nHost: localhost\r\nUpgrade: echo\r\nConnection: Upgrade\r\n\r\n")
    br := bufio.NewReader(c)
    for i := 0; i < 6; i++ {
        line, _ := br.ReadString('\n')
        fmt.Print("< ", line)
        if i < 5 {
            fmt.Fprintf(c, "ping%d\n", i)
        }
    }
}

package main

import (
    "errors"
    "net/http"
    "sync"
    "sync/atomic"
    "time"
)

type state int32

const (
    closed state = iota
    open
    halfOpen
)

var ErrCircuitOpen = errors.New("circuit breaker open")

type cbTransport struct {
    next         http.RoundTripper
    failThresh   int32
    resetAfter   time.Duration

    mu       sync.Mutex
    state    state
    failures int32
    openedAt time.Time
}

func (c *cbTransport) allow() (allowed bool, probe bool) {
    c.mu.Lock()
    defer c.mu.Unlock()
    switch c.state {
    case closed:
        return true, false
    case open:
        if time.Since(c.openedAt) >= c.resetAfter {
            c.state = halfOpen
            return true, true // first request after timeout = probe
        }
        return false, false
    case halfOpen:
        // Block other concurrent requests while the probe is in flight.
        return false, false
    }
    return false, false
}

func (c *cbTransport) onResult(err error, status int, isProbe bool) {
    failed := err != nil || status >= 500
    c.mu.Lock()
    defer c.mu.Unlock()
    if failed {
        if isProbe {
            c.state = open
            c.openedAt = time.Now()
            return
        }
        c.failures++
        if c.failures >= c.failThresh {
            c.state = open
            c.openedAt = time.Now()
        }
        return
    }
    // success
    c.failures = 0
    c.state = closed
}

func (c *cbTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    allowed, probe := c.allow()
    if !allowed {
        return nil, ErrCircuitOpen
    }
    resp, err := c.next.RoundTrip(req)
    status := 0
    if resp != nil {
        status = resp.StatusCode
    }
    c.onResult(err, status, probe)
    return resp, err
}

func main() {
    tr := &cbTransport{
        next:       http.DefaultTransport,
        failThresh: 5,
        resetAfter: 30 * time.Second,
    }
    client := &http.Client{Transport: tr}
    _ = client
    // use atomic.Pointer if you want lock-free; the mutex version is plenty fast
    _ = atomic.Int32{}
}

package main

import (
    "context"
    "errors"
    "fmt"
    "io"
    "math/rand"
    "net/http"
    "time"
)

type retryTransport struct {
    next     http.RoundTripper
    max      int
    base     time.Duration
    cap      time.Duration
}

func isIdempotent(m string) bool {
    switch m {
    case http.MethodGet, http.MethodHead, http.MethodPut, http.MethodDelete, http.MethodOptions:
        return true
    }
    return false
}

func (rt *retryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    if !isIdempotent(req.Method) {
        return rt.next.RoundTrip(req)
    }
    if req.Body != nil && req.GetBody == nil {
        return nil, errors.New("retryTransport: request body without GetBody is not retryable")
    }

    var resp *http.Response
    var err error
    for attempt := 0; attempt <= rt.max; attempt++ {
        if attempt > 0 {
            // rewind body for the retry
            if req.GetBody != nil {
                newBody, gerr := req.GetBody()
                if gerr != nil {
                    return nil, fmt.Errorf("rewind body: %w", gerr)
                }
                req.Body = newBody
            }
            // full jitter: sleep = rand(0, min(cap, base*2^attempt))
            expo := rt.base << (attempt - 1)
            if expo > rt.cap {
                expo = rt.cap
            }
            sleep := time.Duration(rand.Int63n(int64(expo)))
            select {
            case <-time.After(sleep):
            case <-req.Context().Done():
                return nil, req.Context().Err()
            }
        }
        resp, err = rt.next.RoundTrip(req)
        if err == nil && resp.StatusCode < 500 {
            return resp, nil
        }
        if resp != nil {
            io.Copy(io.Discard, resp.Body) // drain so the conn can be reused
            resp.Body.Close()
        }
        // fall through to retry
    }
    if err != nil {
        return nil, err
    }
    return resp, nil
}

func main() {
    client := &http.Client{
        Transport: &retryTransport{
            next: http.DefaultTransport,
            max:  3,
            base: 100 * time.Millisecond,
            cap:  2 * time.Second,
        },
        Timeout: 10 * time.Second,
    }
    req, _ := http.NewRequestWithContext(context.Background(), "GET", "http://localhost:8080/flaky", nil)
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("err:", err)
        return
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(resp.StatusCode, string(body))
}