275 lines
7.3 KiB
Go
275 lines
7.3 KiB
Go
package handlers
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"os/exec"
|
|
"strconv"
|
|
"time"
|
|
|
|
"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/grpcsrv/commander"
|
|
"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/models"
|
|
"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/repository"
|
|
"gitea.d3m0k1d.ru/d3m0k1d/HellreigN/backend/internal/service"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type JobsHandlers struct {
|
|
tracker *commander.ConnTracker
|
|
svc *service.ScriptService
|
|
whereami string
|
|
jobRepo *repository.JobRepository
|
|
}
|
|
|
|
func NewJobsHandlers(tracker *commander.ConnTracker, svc *service.ScriptService, whereami string, jobRepo *repository.JobRepository) JobsHandlers {
|
|
return JobsHandlers{tracker: tracker, svc: svc, whereami: whereami, jobRepo: jobRepo}
|
|
}
|
|
|
|
// AddJobIn is the request body for creating a job.
|
|
type AddJobIn struct {
|
|
Command string `json:"command" binding:"required"`
|
|
InterpreterID int64 `json:"interpreter_id"`
|
|
Stdin *string `json:"stdin"`
|
|
AgentID string `json:"agent_id" binding:"required"`
|
|
}
|
|
|
|
// AddJobOut is the response body for a submitted job.
|
|
type AddJobOut struct {
|
|
ID int64 `json:"id"`
|
|
Command []string `json:"command"`
|
|
WaitURL string `json:"wait_url"`
|
|
}
|
|
|
|
// JobResult is the response body for a completed job.
|
|
type JobResult struct {
|
|
ID int64 `json:"id"`
|
|
Command []string `json:"command"`
|
|
Stdin *string `json:"stdin"`
|
|
Stdout string `json:"stdout"`
|
|
Stderr string `json:"stderr"`
|
|
Status int32 `json:"status"`
|
|
}
|
|
|
|
// AddJob submits a job to an agent and returns a wait_url for the result.
|
|
// @Summary Submit a job to an agent
|
|
// @Description Sends a command to the specified agent and returns a URL to wait for the result
|
|
// @Tags jobs
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param body body AddJobIn true "Job request"
|
|
// @Success 201 {object} AddJobOut
|
|
// @Router /jobs [post]
|
|
func (h *JobsHandlers) AddJob(c *gin.Context) {
|
|
var in AddJobIn
|
|
if err := c.Bind(&in); err != nil {
|
|
c.Error(err)
|
|
return
|
|
}
|
|
|
|
result, err := h.runCommand(c, in.AgentID, in.InterpreterID, in.Command, in.Stdin)
|
|
if err != nil {
|
|
c.Error(err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusCreated, result)
|
|
}
|
|
|
|
// runCommand resolves command, submits a job to the agent, and returns AddJobOut.
|
|
// Shared between jobs and scripts handlers.
|
|
func (h *JobsHandlers) runCommand(
|
|
c *gin.Context,
|
|
agentID string,
|
|
interpID int64,
|
|
command string,
|
|
stdin *string,
|
|
) (*AddJobOut, error) {
|
|
agent, ok := h.tracker.GetAgent(agentID)
|
|
if !ok {
|
|
return nil, fmt.Errorf("agent not found")
|
|
}
|
|
|
|
cmd, err := resolveCommand(c, h.svc, interpID, command)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
jid, err := agent.AddJob(models.JobForInsert{
|
|
Command: cmd,
|
|
Stdin: stdin,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
waitURL := fmt.Sprintf("%s/api/v1/jobs/%d/wait", h.whereami, jid)
|
|
|
|
return &AddJobOut{
|
|
ID: jid,
|
|
Command: cmd,
|
|
WaitURL: waitURL,
|
|
}, nil
|
|
}
|
|
|
|
// WaitJob waits for a submitted job to complete (long-poll).
|
|
// First checks the database; if already finished, returns immediately.
|
|
// Otherwise waits on the agent for the result.
|
|
// @Summary Wait for job result
|
|
// @Description Long-polls for a job result. Returns immediately if the job is already finished.
|
|
// @Tags jobs
|
|
// @Accept json
|
|
// @Produce json
|
|
// @Param id path int true "Job ID"
|
|
// @Success 200 {object} JobResult
|
|
// @Failure 400 {object} map[string]string
|
|
// @Failure 404 {object} map[string]string
|
|
// @Router /jobs/{id}/wait [post]
|
|
func (h *JobsHandlers) WaitJob(c *gin.Context) {
|
|
jid, err := strconv.ParseInt(c.Param("id"), 10, 64)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid job id"})
|
|
return
|
|
}
|
|
|
|
// Check database first
|
|
job, err := h.jobRepo.GetJobByID(c.Request.Context(), jid)
|
|
if err != nil {
|
|
if errors.Is(err, repository.ErrNotFound) {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "job not found"})
|
|
return
|
|
}
|
|
c.Error(err)
|
|
return
|
|
}
|
|
|
|
// If job is already completed (has output or non-zero status), return immediately
|
|
if job.Status != nil || job.Stdout != nil || job.Stderr != nil {
|
|
c.JSON(http.StatusOK, JobResult{
|
|
ID: job.ID,
|
|
Command: job.Command,
|
|
Stdin: job.Stdin,
|
|
Stdout: *job.Stdout,
|
|
Stderr: *job.Stderr,
|
|
Status: *job.Status,
|
|
})
|
|
return
|
|
}
|
|
|
|
// Job is still pending — wait on the agent
|
|
agent, ok := h.tracker.GetAgent(job.AgentID)
|
|
if !ok {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "agent not found"})
|
|
return
|
|
}
|
|
|
|
ajob, err := agent.WaitJob(jid)
|
|
if err != nil {
|
|
c.Error(err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, JobResult{
|
|
ID: ajob.ID,
|
|
Command: ajob.Command,
|
|
Stdin: ajob.Stdin,
|
|
Stdout: *ajob.Stdout,
|
|
Stderr: *ajob.Stderr,
|
|
Status: *ajob.Status,
|
|
})
|
|
}
|
|
|
|
func resolveCommand(c *gin.Context, svc *service.ScriptService, interpID int64, cmd string) ([]string, error) {
|
|
if interpID == 0 {
|
|
return []string{"sh", "-c", cmd}, nil
|
|
}
|
|
|
|
command, err := svc.ResolveCommand(c.Request.Context(), interpID, cmd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return command, nil
|
|
}
|
|
|
|
// @Summary Check command path
|
|
// @Description Validates that a command binary exists on the system
|
|
// @Tags jobs
|
|
// @Accept json
|
|
// @Param body body CheckCmdIn true "Command to check"
|
|
// @Success 200 {object} CheckCmdOut
|
|
// @Failure 404 {object} map[string]string
|
|
// @Router /jobs/check_cmd [post]
|
|
func (h *JobsHandlers) CheckCmd(c *gin.Context) {
|
|
var in struct {
|
|
Command string `json:"command" binding:"required"`
|
|
}
|
|
if err := c.Bind(&in); err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid request"})
|
|
return
|
|
}
|
|
|
|
if _, err := exec.LookPath(in.Command); err != nil {
|
|
if errors.Is(err, exec.ErrNotFound) {
|
|
c.JSON(http.StatusNotFound, gin.H{"error": "command not found"})
|
|
return
|
|
}
|
|
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, CheckCmdOut{Exists: true})
|
|
}
|
|
|
|
type CheckCmdIn struct {
|
|
Command string `json:"command" binding:"required" example:"bash"`
|
|
}
|
|
type CheckCmdOut struct {
|
|
Exists bool `json:"exists"`
|
|
}
|
|
|
|
// JobMetricsOut is the response body for the job metrics endpoint.
|
|
type JobMetricsOut struct {
|
|
Total int `json:"total"`
|
|
Success int `json:"success"`
|
|
Failed int `json:"failed"`
|
|
Pending int `json:"pending"`
|
|
Period string `json:"period"`
|
|
}
|
|
|
|
// GetJobMetrics returns job success metrics over a parameterized period.
|
|
// @Summary Get job metrics
|
|
// @Description Returns total, successful, failed, and pending job counts over the given period
|
|
// @Tags jobs
|
|
// @Produce json
|
|
// @Param period query string false "Time period (e.g. 1h, 24h, 7d)" default(24h)
|
|
// @Param agent_id query string false "Filter by agent ID"
|
|
// @Success 200 {object} JobMetricsOut
|
|
// @Failure 400 {object} map[string]string
|
|
// @Security Bearer
|
|
// @Router /jobs/metrics [get]
|
|
func (h *JobsHandlers) GetJobMetrics(c *gin.Context) {
|
|
periodStr := c.DefaultQuery("period", "24h")
|
|
period, err := time.ParseDuration(periodStr)
|
|
if err != nil {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid period, use Go duration format (e.g. 1h, 24h, 7d)"})
|
|
return
|
|
}
|
|
|
|
agentID := c.Query("agent_id")
|
|
since := time.Now().Add(-period)
|
|
metrics, err := h.jobRepo.GetJobMetrics(c.Request.Context(), since, agentID)
|
|
if err != nil {
|
|
c.Error(err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusOK, JobMetricsOut{
|
|
Total: metrics.Total,
|
|
Success: metrics.Success,
|
|
Failed: metrics.Failed,
|
|
Pending: metrics.Pending,
|
|
Period: periodStr,
|
|
})
|
|
}
|