Skip to content

Modern Docker Management, Designed for Everyone

11.6 KB
Raw Blame
package query

import (
	"cmp"
	"context"
	"fmt"
	"log/slog"
	"time"

	"github.com/danielgtaylor/huma/v2"
	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/getarcaneapp/arcane/types/v2/vulnerability"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/handlerutil"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
)

// Handler serves the vulnerability results and risk endpoints.
type Handler struct {
	service *Service
}

func NewHandler(service *Service) *Handler {
	return &Handler{service: service}
}

type GetScanResultInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
	ImageID       string `path:"imageId" doc:"Image ID"`
}

type GetScanSummaryInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
	ImageID       string `path:"imageId" doc:"Image ID"`
}

type GetScanSummariesInput struct {
	EnvironmentID string                             `path:"id" doc:"Environment ID"`
	Body          vulnerability.ScanSummariesRequest `doc:"Batch scan summary request"`
}

type ListImageVulnerabilitiesInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
	ImageID       string `path:"imageId" doc:"Image ID"`
	Search        string `query:"search" doc:"Search query"`
	Sort          string `query:"sort" doc:"Sort field"`
	Order         string `query:"order" doc:"Sort order"`
	Start         int    `query:"start" doc:"Start offset"`
	Limit         int    `query:"limit" doc:"Limit"`

	Severity string `query:"severity" doc:"Comma-separated severity filter"`
}

type GetEnvironmentSummaryInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
}

type GetRiskOverviewInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
}

type ListAllVulnerabilitiesInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
	Search        string `query:"search" doc:"Search query"`
	Sort          string `query:"sort" doc:"Sort field"`
	Order         string `query:"order" doc:"Sort order"`
	Start         int    `query:"start" doc:"Start offset"`
	Limit         int    `query:"limit" doc:"Limit"`

	Severity     string `query:"severity" doc:"Comma-separated severity filter"`
	ImageName    string `query:"imageName" doc:"Filter by image/repo name (substring)"`
	Ignored      bool   `query:"ignored" doc:"Show only ignored vulnerabilities instead of active ones"`
	FixAvailable bool   `query:"fixAvailable" doc:"Show only vulnerabilities with a fixed version"`
}

// ExportVulnerabilitiesInput carries the list filters accepted by the CSV export.
type ExportVulnerabilitiesInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
	Search        string `query:"search" doc:"Search query"`
	Sort          string `query:"sort" doc:"Sort field"`
	Order         string `query:"order" doc:"Sort order"`

	Severity     string `query:"severity" doc:"Comma-separated severity filter"`
	ImageName    string `query:"imageName" doc:"Filter by image/repo name (substring)"`
	Ignored      bool   `query:"ignored" doc:"Export only ignored vulnerabilities instead of active ones"`
	FixAvailable bool   `query:"fixAvailable" doc:"Export only vulnerabilities with a fixed version"`
}

type ListAllVulnerabilityImageOptionsInput struct {
	EnvironmentID string `path:"id" doc:"Environment ID"`
	Severity      string `query:"severity" doc:"Comma-separated severity filter"`
}

// GetScanSummaries retrieves scan summaries for a list of image IDs.
func (h *Handler) GetScanSummaries(ctx context.Context, input *GetScanSummariesInput) (*handlerutil.Out[vulnerability.ScanSummariesResponse], error) {
	if len(input.Body.ImageIDs) == 0 {
		return &handlerutil.Out[vulnerability.ScanSummariesResponse]{
			Body: base.ApiResponse[vulnerability.ScanSummariesResponse]{
				Success: true,
				Data: vulnerability.ScanSummariesResponse{
					Summaries: map[string]*vulnerability.ScanSummary{},
				},
			},
		}, nil
	}

	summaries, err := h.service.GetScanSummariesByImageIDs(ctx, input.Body.ImageIDs)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to scan image for vulnerabilities: " + err.Error())
	}

	return &handlerutil.Out[vulnerability.ScanSummariesResponse]{
		Body: base.ApiResponse[vulnerability.ScanSummariesResponse]{
			Success: true,
			Data: vulnerability.ScanSummariesResponse{
				Summaries: summaries,
			},
		},
	}, nil
}

// GetScanResult retrieves the vulnerability scan result for an image.
func (h *Handler) GetScanResult(ctx context.Context, input *GetScanResultInput) (*handlerutil.Out[vulnerability.ScanResult], error) {
	result, err := h.service.GetScanResult(ctx, input.EnvironmentID, input.ImageID)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability scan: " + err.Error())
	}

	if result == nil {
		return nil, huma.Error404NotFound("Vulnerability scan not found")
	}

	return &handlerutil.Out[vulnerability.ScanResult]{
		Body: base.ApiResponse[vulnerability.ScanResult]{
			Success: true,
			Data:    *result,
		},
	}, nil
}

// GetScanSummary retrieves just the vulnerability summary for an image.
func (h *Handler) GetScanSummary(ctx context.Context, input *GetScanSummaryInput) (*handlerutil.Out[vulnerability.ScanSummary], error) {
	summary, err := h.service.GetScanSummary(ctx, input.ImageID)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability scan: " + err.Error())
	}

	if summary == nil {
		return nil, huma.Error404NotFound("Vulnerability scan not found")
	}

	return &handlerutil.Out[vulnerability.ScanSummary]{
		Body: base.ApiResponse[vulnerability.ScanSummary]{
			Success: true,
			Data:    *summary,
		},
	}, nil
}

// ListImageVulnerabilities returns a paginated list of vulnerabilities for an image.
func (h *Handler) ListImageVulnerabilities(ctx context.Context, input *ListImageVulnerabilitiesInput) (*handlerutil.Page[vulnerability.Vulnerability], error) {
	params := handlerutil.PaginationParams(input.Start, cmp.Or(input.Limit, 20), input.Sort, input.Order, input.Search)
	if input.Severity != "" {
		params.Filters["severity"] = input.Severity
	}

	items, paginationResp, err := h.service.ListVulnerabilities(ctx, input.ImageID, params)
	if err != nil {
		apiErr := common.ToAPIError(err)
		return nil, huma.NewError(apiErr.HTTPStatus(), apiErr.Message)
	}

	if items == nil {
		items = []vulnerability.Vulnerability{}
	}

	return &handlerutil.Page[vulnerability.Vulnerability]{
		Body: base.Paginated[vulnerability.Vulnerability]{
			Success:    true,
			Data:       items,
			Pagination: handlerutil.PaginationResponse(paginationResp),
		},
	}, nil
}

// GetRiskOverview returns the vulnerability risk overview for the environment.
func (h *Handler) GetRiskOverview(ctx context.Context, input *GetRiskOverviewInput) (*handlerutil.Out[vulnerability.RiskOverview], error) {
	overview, err := h.service.GetRiskOverview(ctx, input.EnvironmentID)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability risk overview: " + err.Error())
	}

	return &handlerutil.Out[vulnerability.RiskOverview]{
		Body: base.ApiResponse[vulnerability.RiskOverview]{
			Success: true,
			Data:    *overview,
		},
	}, nil
}

// GetEnvironmentSummary returns aggregated vulnerability info for the current environment.
func (h *Handler) GetEnvironmentSummary(ctx context.Context, input *GetEnvironmentSummaryInput) (*handlerutil.Out[vulnerability.EnvironmentVulnerabilitySummary], error) {
	summary, err := h.service.GetEnvironmentSummary(ctx)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability scan: " + err.Error())
	}

	return &handlerutil.Out[vulnerability.EnvironmentVulnerabilitySummary]{
		Body: base.ApiResponse[vulnerability.EnvironmentVulnerabilitySummary]{
			Success: true,
			Data:    *summary,
		},
	}, nil
}

// ListAllVulnerabilities returns a paginated list of vulnerabilities across all images.
func (input *ListAllVulnerabilitiesInput) queryParams() pagination.QueryParams {
	params := handlerutil.PaginationParams(input.Start, cmp.Or(input.Limit, 20), input.Sort, input.Order, input.Search)
	if input.Severity != "" {
		params.Filters["severity"] = input.Severity
	}
	if input.ImageName != "" {
		params.Filters["imageName"] = input.ImageName
	}
	if input.Ignored {
		params.Filters["ignored"] = "true"
	}
	if input.FixAvailable {
		params.Filters["fixAvailable"] = "true"
	}
	return params
}

func (h *Handler) ListAllVulnerabilities(ctx context.Context, input *ListAllVulnerabilitiesInput) (*handlerutil.Page[vulnerability.VulnerabilityWithImage], error) {
	if _, ok := httpx.EnvironmentScopeFromContext(ctx); ok {
		body, err := h.service.AggregateVulnerabilities(ctx, input.queryParams())
		if err != nil {
			return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability scan: " + err.Error())
		}
		return &handlerutil.Page[vulnerability.VulnerabilityWithImage]{Body: body}, nil
	}
	items, paginationResp, err := h.service.ListAllVulnerabilities(ctx, input.EnvironmentID, input.queryParams())
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability scan: " + err.Error())
	}

	if items == nil {
		items = []vulnerability.VulnerabilityWithImage{}
	}

	return &handlerutil.Page[vulnerability.VulnerabilityWithImage]{
		Body: base.Paginated[vulnerability.VulnerabilityWithImage]{
			Success:    true,
			Data:       items,
			Pagination: handlerutil.PaginationResponse(paginationResp),
		},
	}, nil
}

// ExportVulnerabilities streams every vulnerability matching the filters as a CSV download.
func (h *Handler) ExportVulnerabilities(ctx context.Context, input *ExportVulnerabilitiesInput) (*huma.StreamResponse, error) {
	params := (&ListAllVulnerabilitiesInput{
		EnvironmentID: input.EnvironmentID,
		Search:        input.Search,
		Sort:          input.Sort,
		Order:         input.Order,
		Severity:      input.Severity,
		ImageName:     input.ImageName,
		Ignored:       input.Ignored,
		FixAvailable:  input.FixAvailable,
	}).queryParams()
	items, err := h.service.ExportVulnerabilities(ctx, input.EnvironmentID, params)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to export vulnerabilities: " + err.Error())
	}
	filename := fmt.Sprintf("vulnerabilities-%s-%s.csv", input.EnvironmentID, time.Now().UTC().Format("2006-01-02T15-04-05Z"))

	return &huma.StreamResponse{
		Body: func(humaCtx huma.Context) {
			humaCtx.SetHeader("Content-Type", "text/csv; charset=utf-8")
			humaCtx.SetHeader("Content-Disposition", fmt.Sprintf("attachment; filename=%q", filename))
			if writeVulnerabilitiesCSVErr := WriteVulnerabilitiesCSV(humaCtx.BodyWriter(), items); writeVulnerabilitiesCSVErr != nil {
				slog.ErrorContext(ctx, "failed to stream vulnerability export", "error", writeVulnerabilitiesCSVErr)
			}
		},
	}, nil
}

// ListAllVulnerabilityImageOptions returns available image options for vulnerability filtering.
func (h *Handler) ListAllVulnerabilityImageOptions(ctx context.Context, input *ListAllVulnerabilityImageOptionsInput) (*handlerutil.Out[[]string], error) {
	if _, ok := httpx.EnvironmentScopeFromContext(ctx); ok {
		body, err := h.service.AggregateImageOptions(ctx)
		if err != nil {
			return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability scan: " + err.Error())
		}
		return &handlerutil.Out[[]string]{Body: body}, nil
	}
	items, err := h.service.ListAllVulnerabilityImageOptions(ctx, input.Severity)
	if err != nil {
		return nil, huma.Error500InternalServerError("Failed to retrieve vulnerability scan: " + err.Error())
	}

	if items == nil {
		items = []string{}
	}

	return &handlerutil.Out[[]string]{
		Body: base.ApiResponse[[]string]{
			Success: true,
			Data:    items,
		},
	}, nil
}