How to use context in HTTP request handling

Introduction

This comprehensive tutorial explores the powerful context package in Golang, focusing on effective HTTP request handling techniques. Context is a crucial mechanism for managing request lifecycles, controlling timeouts, and implementing graceful cancellation in web applications. Developers will learn how to leverage context to build more robust and efficient network services.

Context Basics

What is Context?

In Go programming, context is a powerful mechanism for managing request lifecycle, cancellation signals, and passing request-scoped values across API boundaries. The context.Context interface provides a standardized way to handle timeouts, cancellations, and request-specific data propagation.

Core Characteristics of Context

Context in Go has several key characteristics:

Context Lifecycle Flow

graph TD
    A[Create Root Context] --> B[Derive Child Contexts]
    B --> C[Add Timeout/Deadline]
    B --> D[Attach Request Values]
    C & D --> E[Propagate Context]
    E --> F[Cancel or Complete]

Creating Contexts

Basic Context Creation

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // Background context - root of all contexts
    ctx := context.Background()

    // Context with cancellation
    ctxWithCancel, cancel := context.WithCancel(ctx)
    defer cancel()

    // Context with timeout
    ctxWithTimeout, timeoutCancel := context.WithTimeout(ctx, 5*time.Second)
    defer timeoutCancel()

    // Context with deadline
    deadline := time.Now().Add(10 * time.Second)
    ctxWithDeadline, deadlineCancel := context.WithDeadline(ctx, deadline)
    defer deadlineCancel()
}

Context Use Cases

1. HTTP Request Handling
2. Database Query Management
3. Microservice Communication
4. Graceful Shutdown of Long-Running Tasks

Best Practices

• Always pass context as the first parameter
• Never store contexts in structs
• Use context.TODO() only during initial development
• Always call cancellation functions to prevent resource leaks

Brought to you by LabEx - Empowering Developers Through Practical Learning.

HTTP Request Handling

Context in HTTP Servers

Context plays a crucial role in managing HTTP requests, providing mechanisms for timeout control, request cancellation, and passing request-scoped values.

HTTP Server Context Workflow

graph TD
    A[Incoming HTTP Request] --> B[Create Request Context]
    B --> C[Add Request Timeout]
    B --> D[Attach Request Values]
    C & D --> E[Process Request]
    E --> F[Complete or Cancel]

Basic HTTP Server with Context

package main

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

func handleRequest(w http.ResponseWriter, r *http.Request) {
    // Create a context with timeout
    ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
    defer cancel()

    // Simulate long-running task
    select {
    case <-time.After(3 * time.Second):
        fmt.Fprintln(w, "Request processed successfully")
    case <-ctx.Done():
        if ctx.Err() == context.DeadlineExceeded {
            http.Error(w, "Request timed out", http.StatusGatewayTimeout)
        }
    }
}

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

Context Handling Patterns

Advanced Context Techniques

Passing Request-Scoped Values

func handleAuthenticatedRequest(w http.ResponseWriter, r *http.Request) {
    // Create context with user information
    ctx := context.WithValue(r.Context(), "user", "john_doe")

    // Pass context to downstream functions
    processUserRequest(ctx)
}

func processUserRequest(ctx context.Context) {
    // Retrieve user from context
    user := ctx.Value("user").(string)
    fmt.Println("Processing request for user:", user)
}

Error Handling and Cancellation

func performLongTask(ctx context.Context) error {
    // Check for cancellation periodically
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // Perform task
            time.Sleep(100 * time.Millisecond)
        }
    }
}

Best Practices

1. Always use r.Context() in HTTP handlers
2. Set reasonable timeouts
3. Propagate context to downstream functions
4. Handle context cancellation gracefully

Powered by LabEx - Transforming Learning into Expertise.

Advanced Context Patterns

Context Composition and Inheritance

Context in Go allows for sophisticated composition and inheritance strategies that enable complex request management and resource coordination.

Context Composition Strategies

graph TD
    A[Root Context] --> B[Parent Context]
    B --> C[Child Context 1]
    B --> D[Child Context 2]
    C --> E[Grandchild Context]
    D --> F[Grandchild Context]

Concurrent Request Handling

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func fetchData(ctx context.Context, id int, results chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()

    select {
    case <-time.After(time.Duration(id) * time.Second):
        select {
        case <-ctx.Done():
            fmt.Printf("Request %d cancelled\n", id)
            return
        case results <- fmt.Sprintf("Data for ID %d", id):
        }
    case <-ctx.Done():
        fmt.Printf("Request %d cancelled before completion\n", id)
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    results := make(chan string, 3)
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go fetchData(ctx, i, results, &wg)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    for result := range results {
        fmt.Println(result)
    }
}

Context Pattern Comparison

Custom Context Implementation

type CustomContext struct {
    context.Context
    correlationID string
}

func WithCorrelationID(parent context.Context, correlationID string) *CustomContext {
    return &CustomContext{
        Context:       parent,
        correlationID: correlationID,
    }
}

func (c *CustomContext) CorrelationID() string {
    return c.correlationID
}

Context Propagation in Microservices

func makeServiceCall(ctx context.Context, url string) error {
    // Propagate existing context to service call
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return err
    }

    resp, err := http.DefaultClient.Do(req)
    // Handle response
    return err
}

Advanced Cancellation Techniques

func orchestrateTask(ctx context.Context) error {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    errChan := make(chan error, 3)

    go func() {
        errChan <- performSubTask1(ctx)
    }()

    go func() {
        errChan <- performSubTask2(ctx)
    }()

    select {
    case err := <-errChan:
        cancel() // Cancel all other tasks
        return err
    case <-ctx.Done():
        return ctx.Err()
    }
}

Best Practices for Advanced Context Usage

1. Use context for cross-cutting concerns
2. Implement graceful degradation
3. Avoid over-complicating context usage
4. Always respect context cancellation

Empowered by LabEx - Elevating Technical Expertise.

Summary

By mastering context in Golang HTTP request handling, developers can create more responsive and resilient web applications. The tutorial has covered essential context patterns, demonstrating how to manage request lifecycles, implement timeouts, and handle concurrent operations effectively. Understanding these techniques empowers developers to write more sophisticated and performant network services in Golang.