LokiStack/backend/controllers/collector.go

package controllers

import (
	"strconv"

	"lokistack/dto"
	"lokistack/models"
	"lokistack/services"
	"lokistack/utils"

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

type CollectorController struct {
	service *services.CollectorService
}

func NewCollectorController() *CollectorController {
	return &CollectorController{service: services.NewCollectorService()}
}

// RenderJobsYAML 把结构化采集项渲染成可编辑 YAML（前端切到 YAML 模式时调用）。
func (ctrl *CollectorController) RenderJobsYAML(c *gin.Context) {
	var req struct {
		Jobs []models.ScrapeJob `json:"jobs"`
	}
	if !utils.BindAndValidate(c, &req) {
		return
	}
	text, err := services.RenderJobsYAML(req.Jobs)
	if err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"yaml": text})
}

// ParseJobsYAML 把用户编辑的 YAML 解析回结构化采集项（切回表单 / 保存前调用）。
func (ctrl *CollectorController) ParseJobsYAML(c *gin.Context) {
	var req struct {
		YAML string `json:"yaml"`
	}
	if !utils.BindAndValidate(c, &req) {
		return
	}
	jobs, err := services.ParseJobsYAML(req.YAML)
	if err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"jobs": jobs})
}

func (ctrl *CollectorController) Create(c *gin.Context) {
	var req dto.CreateCollectorRequest
	if !utils.BindAndValidate(c, &req) {
		return
	}
	collector, err := ctrl.service.Create(&services.CreateCollectorRequest{
		Name: req.Name, Type: req.Type, LokiDeploymentID: req.LokiDeploymentID,
		HostID: req.HostID, ClusterID: req.ClusterID, TargetDeployment: req.TargetDeployment,
		Namespace: req.Namespace, LogPath: req.LogPath, Labels: req.Labels,
		ScrapeJobs: req.ScrapeJobs, TargetNamespaces: req.TargetNamespaces,
	})
	if err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, models.SanitizedJSON(collector))
}

func (ctrl *CollectorController) Get(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	collector, err := ctrl.service.Get(uint(id))
	if err != nil {
		utils.NotFound(c, "采集器不存在")
		return
	}
	utils.Success(c, models.SanitizedJSON(collector))
}

func (ctrl *CollectorController) List(c *gin.Context) {
	page, pageSize := utils.Pagination(c)
	collectors, total, err := ctrl.service.List(page, pageSize)
	if err != nil {
		utils.Error(c, 500, err.Error())
		return
	}
	utils.Success(c, utils.PageData{
		List: models.SanitizedJSON(collectors), Total: total, Page: page, PageSize: pageSize,
	})
}

func (ctrl *CollectorController) Update(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	var updates map[string]interface{}
	if !utils.BindAndValidate(c, &updates) {
		return
	}
	if err := ctrl.service.Update(uint(id), updates); err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"message": "更新成功"})
}

func (ctrl *CollectorController) Delete(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	if err := ctrl.service.Delete(uint(id)); err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, gin.H{"message": "删除成功"})
}

func (ctrl *CollectorController) Install(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	go ctrl.service.Install(uint(id))
	utils.Success(c, gin.H{"message": "已开始部署采集器"})
}

// Preview 渲染「当前配置 + 本次改动」的 promtail.yaml，只预览不落库。
// 供结构化编辑器里的「预览 YAML」按钮使用：用户能先看到将要写到目标机的配置，
// 保存前就发现路径/正则写错，而不是点了部署才发现采集起不来。
func (ctrl *CollectorController) Preview(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	var updates map[string]interface{}
	if !utils.BindAndValidate(c, &updates) {
		return
	}
	out, err := ctrl.service.PreviewConfig(uint(id), updates)
	if err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, out)
}

func (ctrl *CollectorController) Uninstall(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	go ctrl.service.Uninstall(uint(id))
	utils.Success(c, gin.H{"message": "已开始卸载采集器"})
}

// Logs 返回采集器最近的运行日志（主机：docker logs / journalctl；K8s：Pod 日志）。
// 主机模式下采集器日志原来只能登机器看 docker logs / journalctl，容器化后这是
// 顺带拿到的能力，排「采集器起没起来、在报什么错」不用再 SSH。
func (ctrl *CollectorController) Logs(c *gin.Context) {
	id, err := utils.IntParam(c, "id")
	if err != nil {
		utils.BadRequest(c, "ID 无效")
		return
	}
	tail := 200
	if v := c.Query("tail"); v != "" {
		if n, convErr := strconv.Atoi(v); convErr == nil && n > 0 {
			tail = n
		}
	}
	out, err := ctrl.service.CollectorLogs(uint(id), tail)
	if err != nil {
		utils.Error(c, 400, err.Error())
		return
	}
	utils.Success(c, out)
}