Files
kandev/apps/backend/internal/agent/docker/handlers.go
T
2026-05-04 21:11:22 +01:00

284 lines
9.1 KiB
Go

// Package docker provides Docker management HTTP handlers.
package docker
import (
"bufio"
"context"
"net/http"
"time"
"github.com/gin-gonic/gin"
"github.com/kandev/kandev/internal/common/logger"
"go.uber.org/zap"
)
// buildImageRequest is the JSON body for POST /api/v1/docker/build.
type buildImageRequest struct {
Dockerfile string `json:"dockerfile" binding:"required"`
Tag string `json:"tag" binding:"required"`
BuildArgs map[string]*string `json:"build_args,omitempty"`
}
// containerResponse is the JSON representation of a container in list responses.
type containerResponse struct {
ID string `json:"id"`
Name string `json:"name"`
Image string `json:"image"`
State string `json:"state"`
Status string `json:"status"`
StartedAt time.Time `json:"started_at"`
Labels map[string]string `json:"labels,omitempty"`
}
// stopContainerRequest is the optional JSON body for POST /api/v1/docker/containers/:id/stop.
type stopContainerRequest struct {
TimeoutSeconds int `json:"timeout_seconds,omitempty"`
}
// ClientProvider lazily resolves the Docker client. Returns nil if Docker is unavailable.
type ClientProvider func() *Client
// TaskTitleProvider resolves a task ID to its display title for container listings.
type TaskTitleProvider func(ctx context.Context, taskID string) (string, bool)
// RegisterDockerRoutes registers Docker management HTTP routes on the given router.
// The clientProvider lazily resolves the Docker client on each request.
func RegisterDockerRoutes(router *gin.Engine, clientProvider ClientProvider, taskTitleProvider TaskTitleProvider, log *logger.Logger) {
api := router.Group("/api/v1/docker")
api.POST("/build", handleBuildImage(clientProvider, log))
api.GET("/containers", handleListContainers(clientProvider, taskTitleProvider, log))
api.POST("/containers/:id/stop", handleStopContainer(clientProvider, log))
api.DELETE("/containers/:id", handleRemoveContainer(clientProvider, log))
}
// requireDocker resolves the Docker client and returns 503 if unavailable.
func requireDocker(c *gin.Context, clientProvider ClientProvider) *Client {
client := clientProvider()
if client == nil {
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "Docker is not available"})
return nil
}
return client
}
// handleBuildImage handles POST /api/v1/docker/build.
// It streams the Docker build output as JSON lines to the client.
func handleBuildImage(clientProvider ClientProvider, log *logger.Logger) gin.HandlerFunc {
return func(c *gin.Context) {
dockerClient := requireDocker(c, clientProvider)
if dockerClient == nil {
return
}
var req buildImageRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request: " + err.Error()})
return
}
reader, err := dockerClient.BuildImage(c.Request.Context(), req.Dockerfile, req.Tag, req.BuildArgs)
if err != nil {
log.Error("Failed to start image build", zap.String("tag", req.Tag), zap.Error(err))
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
defer func() {
if closeErr := reader.Close(); closeErr != nil {
log.Warn("Failed to close build reader", zap.Error(closeErr))
}
}()
streamBuildOutput(c, reader, log)
}
}
// streamBuildOutput reads from the Docker build output and streams it to the HTTP response.
func streamBuildOutput(c *gin.Context, reader interface{ Read([]byte) (int, error) }, log *logger.Logger) {
c.Header("Content-Type", "application/x-ndjson")
c.Status(http.StatusOK)
scanner := bufio.NewScanner(reader)
for scanner.Scan() {
line := scanner.Bytes()
if _, err := c.Writer.Write(line); err != nil {
log.Debug("Client disconnected during build stream", zap.Error(err))
return
}
if _, err := c.Writer.Write([]byte("\n")); err != nil {
log.Debug("Client disconnected during build stream", zap.Error(err))
return
}
c.Writer.Flush()
}
if err := scanner.Err(); err != nil {
log.Error("Error reading build output", zap.Error(err))
}
}
// handleListContainers handles GET /api/v1/docker/containers.
// Supports optional query params: image, labels (comma-separated key=value pairs).
func handleListContainers(clientProvider ClientProvider, taskTitleProvider TaskTitleProvider, log *logger.Logger) gin.HandlerFunc {
return func(c *gin.Context) {
dockerClient := requireDocker(c, clientProvider)
if dockerClient == nil {
return
}
labels := parseLabelsQuery(c)
addImageFilter(c, labels)
containers, err := dockerClient.ListContainers(c.Request.Context(), labels)
if err != nil {
log.Error("Failed to list containers", zap.Error(err))
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
resp := newContainerResponsesWithTaskTitles(c.Request.Context(), containers, taskTitleProvider)
c.JSON(http.StatusOK, gin.H{"containers": resp})
}
}
func newContainerResponses(containers []ContainerInfo) []containerResponse {
return newContainerResponsesWithTaskTitles(context.Background(), containers, nil)
}
func newContainerResponsesWithTaskTitles(ctx context.Context, containers []ContainerInfo, taskTitleProvider TaskTitleProvider) []containerResponse {
resp := make([]containerResponse, len(containers))
for i, ctr := range containers {
resp[i] = containerResponse{
ID: ctr.ID,
Name: ctr.Name,
Image: ctr.Image,
State: ctr.State,
Status: ctr.Status,
StartedAt: ctr.StartedAt,
Labels: labelsWithTaskTitle(ctx, ctr.Labels, taskTitleProvider),
}
}
return resp
}
func labelsWithTaskTitle(ctx context.Context, labels map[string]string, taskTitleProvider TaskTitleProvider) map[string]string {
if len(labels) == 0 {
return labels
}
result := make(map[string]string, len(labels)+1)
for key, value := range labels {
result[key] = value
}
if result["kandev.task_title"] != "" || taskTitleProvider == nil {
return result
}
title, ok := taskTitleProvider(ctx, result["kandev.task_id"])
if ok && title != "" {
result["kandev.task_title"] = title
}
return result
}
// parseLabelsQuery extracts label filters from the "labels" query parameter.
// Expected format: "key1=value1,key2=value2".
func parseLabelsQuery(c *gin.Context) map[string]string {
labels := make(map[string]string)
labelsParam := c.Query("labels")
if labelsParam == "" {
return labels
}
for _, pair := range splitNonEmpty(labelsParam, ',') {
parts := splitNonEmpty(pair, '=')
if len(parts) == 2 { //nolint:mnd
labels[parts[0]] = parts[1]
}
}
return labels
}
// splitNonEmpty splits a string by sep and returns only non-empty parts.
func splitNonEmpty(s string, sep byte) []string {
var parts []string
start := 0
for i := 0; i <= len(s); i++ {
if i == len(s) || s[i] == sep {
part := s[start:i]
if part != "" {
parts = append(parts, part)
}
start = i + 1
}
}
return parts
}
// addImageFilter adds the "image" query parameter as a label filter placeholder.
// Note: The Docker API uses the "ancestor" filter for image-based filtering,
// but our Client.ListContainers uses label filters. The image filter is applied
// as a label for consistency; callers should label containers with their image.
func addImageFilter(c *gin.Context, labels map[string]string) {
imageFilter := c.Query("image")
if imageFilter != "" {
labels["com.kandev.image"] = imageFilter
}
}
// handleStopContainer handles POST /api/v1/docker/containers/:id/stop.
func handleStopContainer(clientProvider ClientProvider, log *logger.Logger) gin.HandlerFunc {
return func(c *gin.Context) {
dockerClient := requireDocker(c, clientProvider)
if dockerClient == nil {
return
}
containerID := c.Param("id")
if containerID == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "container id is required"})
return
}
var req stopContainerRequest
// Bind is optional; ignore errors for empty body
_ = c.ShouldBindJSON(&req)
timeout := 30 * time.Second
if req.TimeoutSeconds > 0 {
timeout = time.Duration(req.TimeoutSeconds) * time.Second
}
if err := dockerClient.StopContainer(c.Request.Context(), containerID, timeout); err != nil {
log.Error("Failed to stop container", zap.String("id", containerID), zap.Error(err))
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{"status": "stopped"})
}
}
// handleRemoveContainer handles DELETE /api/v1/docker/containers/:id.
func handleRemoveContainer(clientProvider ClientProvider, log *logger.Logger) gin.HandlerFunc {
return func(c *gin.Context) {
dockerClient := requireDocker(c, clientProvider)
if dockerClient == nil {
return
}
containerID := c.Param("id")
if containerID == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "container id is required"})
return
}
if err := dockerClient.RemoveContainer(c.Request.Context(), containerID, true); err != nil {
log.Error("Failed to remove container", zap.String("id", containerID), zap.Error(err))
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
c.JSON(http.StatusOK, gin.H{"status": "removed"})
}
}