Лекція 11. Архітектура та маршрутизація фреймворку Gin

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    // Створюємо Engine з вбудованими middleware (Logger + Recovery)
    r := gin.Default()

    // Реєструємо простий GET-маршрут
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "pong",
        })
    })

    // Запускаємо сервер на порту 8080
    r.Run(":8080")
}

curl http://localhost:8080/ping

{
  "message": "pong"
}

// 1. gin.Default() — з вбудованими Logger та Recovery middleware
r := gin.Default()

// 2. gin.New() — чистий Engine без middleware
r := gin.New()
r.Use(gin.Logger())    // Додаємо логування вручну
r.Use(gin.Recovery())  // Додаємо panic recovery вручну

r := gin.New()

// Максимальний розмір тіла запиту (за замовчуванням 32 MB)
r.MaxMultipartMemory = 8 << 20 // 8 MB

// Увімкнення автоматичного редиректу /users/ → /users
r.RedirectTrailingSlash = true

// Автоматичне виправлення регістру шляху (USERS → users)
r.RedirectFixedPath = true

// Обробка OPTIONS запитів для CORS
r.HandleMethodNotAllowed = true

// Кастомна функція обробки 404
r.NoRoute(func(c *gin.Context) {
    c.JSON(http.StatusNotFound, gin.H{"error": "route not found"})
})

// Кастомна функція обробки 405 (Method Not Allowed)
r.NoMethod(func(c *gin.Context) {
    c.JSON(http.StatusMethodNotAllowed, gin.H{"error": "method not allowed"})
})

package main

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

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    
    r.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"status": "ok"})
    })

    // Створюємо http.Server з таймаутами
    srv := &http.Server{
        Addr:           ":8080",
        Handler:        r,
        ReadTimeout:    10 * time.Second,
        WriteTimeout:   10 * time.Second,
        MaxHeaderBytes: 1 << 20, // 1 MB
    }

    // Запускаємо сервер в окремій горутині
    go func() {
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server failed: %v", err)
        }
    }()

    log.Println("Server started on :8080")

    // Graceful Shutdown: чекаємо сигналу завершення
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    log.Println("Shutting down server...")

    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Server forced to shutdown: %v", err)
    }

    log.Println("Server stopped gracefully")
}

type Context struct {
    Request  *http.Request      // Оригінальний HTTP-запит
    Writer   ResponseWriter     // Обгортка над http.ResponseWriter
    Params   Params             // Параметри шляху (/users/:id)
    Keys     map[string]any     // Контекстні дані між middleware
    Errors   errorMsgs          // Накопичені помилки
    // ... внутрішні поля
}

r := gin.Default()

// Параметр :id обов'язковий
r.GET("/users/:id", func(c *gin.Context) {
    userID := c.Param("id")
    c.JSON(http.StatusOK, gin.H{
        "user_id": userID,
    })
})

// Параметр *filepath захоплює весь залишок шляху
r.GET("/files/*filepath", func(c *gin.Context) {
    path := c.Param("filepath")
    c.String(http.StatusOK, "Requested file: %s", path)
})

GET /users/42        → user_id = "42"
GET /files/docs/readme.md → filepath = "/docs/readme.md"

r.GET("/search", func(c *gin.Context) {
    // Обов'язковий параметр (порожній рядок, якщо відсутній)
    query := c.Query("q")
    
    // Параметр зі значенням за замовчуванням
    page := c.DefaultQuery("page", "1")
    
    // Параметр з перевіркою наявності
    if sort, exists := c.GetQuery("sort"); exists {
        c.String(http.StatusOK, "Query: %s, Page: %s, Sort: %s", query, page, sort)
    } else {
        c.String(http.StatusOK, "Query: %s, Page: %s", query, page)
    }
})

GET /search?q=golang             → q="golang", page="1"
GET /search?q=gin&page=3         → q="gin", page="3"
GET /search?q=api&sort=date      → q="api", sort="date"

r.POST("/login", func(c *gin.Context) {
    username := c.PostForm("username")
    password := c.DefaultPostForm("password", "guest")
    
    c.JSON(http.StatusOK, gin.H{
        "username": username,
        "password": password,
    })
})

r.GET("/headers", func(c *gin.Context) {
    userAgent := c.GetHeader("User-Agent")
    authToken := c.GetHeader("Authorization")
    
    c.JSON(http.StatusOK, gin.H{
        "user_agent": userAgent,
        "auth_token": authToken,
    })
})

type User struct {
    ID       int    `json:"id"`
    Username string `json:"username"`
    Email    string `json:"email"`
}

r.GET("/users/:id", func(c *gin.Context) {
    user := User{
        ID:       123,
        Username: "john_doe",
        Email:    "john@example.com",
    }
    
    c.JSON(http.StatusOK, user)
})

type Person struct {
    XMLName xml.Name `xml:"person"`
    Name    string   `xml:"name"`
    Age     int      `xml:"age"`
}

r.GET("/xml", func(c *gin.Context) {
    person := Person{Name: "John", Age: 30}
    c.XML(http.StatusOK, person)
})

// Відповідь:
// <?xml version="1.0" encoding="UTF-8"?>
// <person><name>John</name><age>30</age></person>

r.GET("/protobuf", func(c *gin.Context) {
    user := &pb.User{Id: 1, Name: "Alice"}
    c.ProtoBuf(http.StatusOK, user)
})

r.GET("/pure-json", func(c *gin.Context) {
    c.PureJSON(http.StatusOK, gin.H{
        "html": "<b>Bold text</b>",
        "url":  "https://example.com?param=value&other=123",
    })
})

// Звичайний JSON:  {"html":"\u003cb\u003eBold text\u003c/b\u003e", ...}
// PureJSON:        {"html":"<b>Bold text</b>", ...}

// Middleware для додавання інформації про користувача
func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        
        // Симуляція перевірки токена
        if token == "valid-token" {
            c.Set("user_id", 42)
            c.Set("username", "john_doe")
            c.Next() // Передаємо керування далі
        } else {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
                "error": "unauthorized",
            })
        }
    }
}

// Handler, що використовує дані з контексту
r.Use(AuthMiddleware())
r.GET("/profile", func(c *gin.Context) {
    userID, _ := c.Get("user_id")
    username := c.MustGet("username").(string)
    
    c.JSON(http.StatusOK, gin.H{
        "user_id":  userID,
        "username": username,
    })
})

r.GET("/raw", func(c *gin.Context) {
    // Доступ до оригінального http.Request
    method := c.Request.Method
    url := c.Request.URL.String()
    
    // Доступ до ResponseWriter
    c.Writer.WriteHeader(http.StatusOK)
    c.Writer.Write([]byte("Direct write"))
    
    c.String(http.StatusOK, "Method: %s, URL: %s", method, url)
})

r := gin.Default()

r.GET("/resource", handlerFunc)       // Читання ресурсу
r.POST("/resource", handlerFunc)      // Створення ресурсу
r.PUT("/resource/:id", handlerFunc)   // Повна заміна ресурсу
r.PATCH("/resource/:id", handlerFunc) // Часткове оновлення
r.DELETE("/resource/:id", handlerFunc)// Видалення
r.OPTIONS("/resource", handlerFunc)   // Опції CORS
r.HEAD("/resource", handlerFunc)      // Лише заголовки (без тіла)

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()
        c.Next() // Виконати наступні handler
        latency := time.Since(t)
        log.Printf("Request took %v", latency)
    }
}

func Auth() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        if token != "valid" {
            c.AbortWithStatus(http.StatusUnauthorized)
            return
        }
        c.Next()
    }
}

r.GET("/admin", Logger(), Auth(), func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"message": "admin panel"})
})

r := gin.Default()

// Група для публічних ендпоінтів
public := r.Group("/api/v1")
{
    public.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"status": "ok"})
    })
    
    public.POST("/register", func(c *gin.Context) {
        c.JSON(http.StatusCreated, gin.H{"message": "user registered"})
    })
}

// Група для приватних ендпоінтів із middleware авторизації
private := r.Group("/api/v1")
private.Use(AuthMiddleware()) // Застосовуємо middleware лише до цієї групи
{
    private.GET("/profile", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "user profile"})
    })
    
    private.POST("/logout", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "logged out"})
    })
}

r := gin.Default()

api := r.Group("/api")
{
    v1 := api.Group("/v1")
    {
        users := v1.Group("/users")
        {
            users.GET("", listUsers)
            users.GET("/:id", getUser)
            users.POST("", createUser)
            users.PUT("/:id", updateUser)
            users.DELETE("/:id", deleteUser)
        }
        
        products := v1.Group("/products")
        {
            products.GET("", listProducts)
            products.GET("/:id", getProduct)
        }
    }
    
    v2 := api.Group("/v2")
    {
        v2.GET("/users", listUsersV2)
    }
}

GET    /api/v1/users
GET    /api/v1/users/:id
POST   /api/v1/users
PUT    /api/v1/users/:id
DELETE /api/v1/users/:id
GET    /api/v1/products
GET    /api/v1/products/:id
GET    /api/v2/users

r := gin.New() // Без вбудованих middleware

// Глобальний middleware для всіх запитів
r.Use(gin.Logger())
r.Use(gin.Recovery())

// CORS лише для API
api := r.Group("/api")
api.Use(CorsMiddleware())
{
    // Авторизація лише для /api/admin
    admin := api.Group("/admin")
    admin.Use(AuthMiddleware())
    {
        admin.GET("/users", listUsers)
        admin.DELETE("/users/:id", deleteUser)
    }
}

func MyMiddleware() gin.HandlerFunc {
    // Код ініціалізації (виконується один раз при реєстрації)
    
    return func(c *gin.Context) {
        // Код, що виконується перед обробкою запиту
        
        c.Next() // Передаємо керування наступному handler
        
        // Код, що виконується після обробки запиту
    }
}

import (
    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
)

func RequestIDMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Генеруємо унікальний ID
        requestID := uuid.New().String()
        
        // Зберігаємо в контексті
        c.Set("request_id", requestID)
        
        // Додаємо в заголовок відповіді
        c.Header("X-Request-ID", requestID)
        
        c.Next()
    }
}

// Використання
r := gin.New()
r.Use(RequestIDMiddleware())

r.GET("/test", func(c *gin.Context) {
    reqID := c.MustGet("request_id").(string)
    c.JSON(200, gin.H{"request_id": reqID})
})

import (
    "net/http"
    "sync"
    "time"

    "github.com/gin-gonic/gin"
    "golang.org/x/time/rate"
)

func RateLimitMiddleware(requestsPerSecond int) gin.HandlerFunc {
    type client struct {
        limiter  *rate.Limiter
        lastSeen time.Time
    }

    var (
        mu      sync.Mutex
        clients = make(map[string]*client)
    )

    // Горутина для очищення застарілих клієнтів
    go func() {
        for {
            time.Sleep(time.Minute)
            mu.Lock()
            for ip, c := range clients {
                if time.Since(c.lastSeen) > 3*time.Minute {
                    delete(clients, ip)
                }
            }
            mu.Unlock()
        }
    }()

    return func(c *gin.Context) {
        ip := c.ClientIP()

        mu.Lock()
        if _, exists := clients[ip]; !exists {
            clients[ip] = &client{
                limiter: rate.NewLimiter(rate.Limit(requestsPerSecond), requestsPerSecond),
            }
        }
        clients[ip].lastSeen = time.Now()
        limiter := clients[ip].limiter
        mu.Unlock()

        if !limiter.Allow() {
            c.AbortWithStatusJSON(http.StatusTooManyRequests, gin.H{
                "error": "rate limit exceeded",
            })
            return
        }

        c.Next()
    }
}

// Використання: максимум 10 запитів на секунду
r.Use(RateLimitMiddleware(10))

func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
        c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
        c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
        c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")

        // Обробка preflight-запиту (OPTIONS)
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(http.StatusNoContent)
            return
        }

        c.Next()
    }
}

import (
    "log"
    "time"

    "github.com/gin-gonic/gin"
)

func CustomLogger() gin.HandlerFunc {
    return func(c *gin.Context) {
        startTime := time.Now()
        path := c.Request.URL.Path
        method := c.Request.Method

        c.Next() // Виконуємо запит

        latency := time.Since(startTime)
        statusCode := c.Writer.Status()
        clientIP := c.ClientIP()

        log.Printf("[%s] %s %s %d %v %s",
            method,
            path,
            clientIP,
            statusCode,
            latency,
            c.Errors.ByType(gin.ErrorTypePrivate).String(),
        )
    }
}

import (
    "context"
    "net/http"
    "time"

    "github.com/gin-gonic/gin"
)

func TimeoutMiddleware(timeout time.Duration) gin.HandlerFunc {
    return func(c *gin.Context) {
        ctx, cancel := context.WithTimeout(c.Request.Context(), timeout)
        defer cancel()

        // Замінюємо контекст запиту
        c.Request = c.Request.WithContext(ctx)

        // Канал для сигналу завершення
        finished := make(chan struct{})
        
        go func() {
            c.Next()
            close(finished)
        }()

        select {
        case <-finished:
            // Handler завершився вчасно
        case <-ctx.Done():
            // Таймаут вичерпано
            c.AbortWithStatusJSON(http.StatusRequestTimeout, gin.H{
                "error": "request timeout",
            })
        }
    }
}

// Використання: максимум 5 секунд на обробку запиту
r.Use(TimeoutMiddleware(5 * time.Second))

func MiddlewareA() gin.HandlerFunc {
    return func(c *gin.Context) {
        log.Println("A: before Next")
        c.Next()
        log.Println("A: after Next")
    }
}

func MiddlewareB() gin.HandlerFunc {
    return func(c *gin.Context) {
        log.Println("B: before Abort")
        c.Abort()
        log.Println("B: after Abort") // Це виконається!
    }
}

func Handler() gin.HandlerFunc {
    return func(c *gin.Context) {
        log.Println("Handler executed") // Це НЕ виконається
    }
}

r.GET("/test", MiddlewareA(), MiddlewareB(), Handler())

A: before Next
B: before Abort
B: after Abort
A: after Next