distributor/internal/app/run_output.go

package app

import (
	"fmt"
	"io"
	"strings"

	"gitea.maximumdirect.net/eric/distributor/internal/config"
	"gitea.maximumdirect.net/eric/distributor/internal/publish"
	"gitea.maximumdirect.net/eric/distributor/internal/storage"
)

func writePlanLine(w io.Writer, backend string, plan publish.Plan, planErr error) {
	if w == nil {
		return
	}
	if planErr != nil {
		destinationID := plan.DestinationID
		if destinationID == "" {
			destinationID = "unknown"
		}
		fmt.Fprintf(w, "  - bundle=%s destination=%s backend=%s%s action=error reason=%q\n", storage.DisplayPath(plan.BundlePath), destinationID, backend, pathMappingSummary(plan), planErr.Error())
		return
	}
	fmt.Fprintf(w, "  - bundle=%s destination=%s backend=%s%s action=%s outputs=%s reason=%q\n", storage.DisplayPath(plan.BundlePath), plan.DestinationID, backend, pathMappingSummary(plan), plan.Action, outputSummary(plan.Outputs), plan.Reason)
}

func pathMappingSummary(plan publish.Plan) string {
	if plan.PathMapping != config.PathMappingFixed {
		return ""
	}
	return fmt.Sprintf(" path_mapping=fixed target=%s", storage.DisplayPath(plan.DestinationBundlePath))
}

func writeErrorLine(w io.Writer, bundlePath, destinationID, backend string, err error) {
	if w == nil {
		return
	}
	fmt.Fprintf(w, "  - bundle=%s destination=%s backend=%s action=error reason=%q\n", storage.DisplayPath(bundlePath), destinationID, backend, err.Error())
}

func outputSummary(outputs []publish.Output) string {
	if len(outputs) == 0 {
		return "none"
	}
	paths := make([]string, 0, len(outputs))
	for _, output := range outputs {
		paths = append(paths, output.DestinationPath)
	}
	return strings.Join(paths, ",")
}

type runResult struct {
	DryRun    bool                `json:"dry_run"`
	Pipelines []runPipelineResult `json:"pipelines"`
	Actions   []runActionResult   `json:"actions"`
	Summary   runSummaryResult    `json:"summary"`
}

type runPipelineResult struct {
	ID            string   `json:"id"`
	SourceBackend string   `json:"source_backend"`
	BundleCount   int      `json:"bundle_count"`
	Destinations  []string `json:"destinations"`
}

type runActionResult struct {
	PipelineID      string            `json:"pipeline_id,omitempty"`
	DestinationID   string            `json:"destination_id"`
	Backend         string            `json:"backend"`
	BundleID        string            `json:"bundle_id,omitempty"`
	BundlePath      string            `json:"bundle_path"`
	DestinationPath string            `json:"destination_path"`
	PathMapping     string            `json:"path_mapping,omitempty"`
	Action          string            `json:"action"`
	PrimaryURL      string            `json:"primary_url,omitempty"`
	Reason          string            `json:"reason,omitempty"`
	Outputs         []runOutputResult `json:"outputs"`
}

type runOutputResult struct {
	Path       string `json:"path"`
	Kind       string `json:"kind"`
	SourcePath string `json:"source_path,omitempty"`
	Transform  string `json:"transform,omitempty"`
	URL        string `json:"url,omitempty"`
	SHA256     string `json:"sha256"`
	Size       int64  `json:"size"`
}

func runActionFromPlan(backend string, plan publish.Plan, planErr error) runActionResult {
	if planErr != nil {
		destinationID := plan.DestinationID
		if destinationID == "" {
			destinationID = "unknown"
		}
		return runActionResult{
			PipelineID:      plan.PipelineID,
			DestinationID:   destinationID,
			Backend:         backend,
			BundleID:        plan.BundleID,
			BundlePath:      storage.DisplayPath(plan.BundlePath),
			DestinationPath: storage.DisplayPath(plan.DestinationBundlePath),
			PathMapping:     plan.PathMapping,
			Action:          "error",
			PrimaryURL:      plan.PrimaryURL,
			Reason:          planErr.Error(),
			Outputs:         []runOutputResult{},
		}
	}
	return runActionResult{
		PipelineID:      plan.PipelineID,
		DestinationID:   plan.DestinationID,
		Backend:         backend,
		BundleID:        plan.BundleID,
		BundlePath:      storage.DisplayPath(plan.BundlePath),
		DestinationPath: storage.DisplayPath(plan.DestinationBundlePath),
		PathMapping:     plan.PathMapping,
		Action:          string(plan.Action),
		PrimaryURL:      plan.PrimaryURL,
		Reason:          plan.Reason,
		Outputs:         runOutputsFromPlan(plan.Outputs),
	}
}

func errorAction(pipelineID, destinationID, backend, bundlePath string, err error) runActionResult {
	return runActionResult{
		PipelineID:      pipelineID,
		DestinationID:   destinationID,
		Backend:         backend,
		BundlePath:      storage.DisplayPath(bundlePath),
		DestinationPath: storage.DisplayPath(bundlePath),
		Action:          "error",
		Reason:          err.Error(),
		Outputs:         []runOutputResult{},
	}
}

func runOutputsFromPlan(outputs []publish.Output) []runOutputResult {
	results := make([]runOutputResult, 0, len(outputs))
	for _, output := range outputs {
		stateOutput := output.StateOutputFile()
		results = append(results, runOutputResult{
			Path:       stateOutput.Path,
			Kind:       stateOutput.Kind,
			SourcePath: stateOutput.SourcePath,
			Transform:  stateOutput.Transform,
			URL:        stateOutput.URL,
			SHA256:     stateOutput.SHA256,
			Size:       stateOutput.Size,
		})
	}
	return results
}