Files
notarius/internal/cli/pipeline_commands.go

144 lines
6.2 KiB
Go

package cli
import (
"context"
"errors"
"fmt"
"sort"
"strings"
"text/template"
"gitea.maximumdirect.net/eric/notarius/internal/core/config"
"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
"gitea.maximumdirect.net/eric/notarius/internal/preflight"
"go.maximumdirect.net/ckconfig"
"go.maximumdirect.net/commandkit"
"go.maximumdirect.net/configkit"
"go.maximumdirect.net/promptkit"
)
type pipelineInspectionInput struct {
Selection ckconfig.Selection
PipelineID string
}
func configurationSelectionFlags[I any](destination func(*I) *ckconfig.Selection) []commandkit.Flag[I] {
return []commandkit.Flag[I]{
commandkit.ValueFlag(commandkit.FlagMeta{Name: "config", Usage: "Select the application configuration.", Completion: commandkit.CompleteFiles()}, (*string)(nil), func(value string) (string, error) {
if strings.TrimSpace(value) == "" {
return "", fmt.Errorf("--config must not be empty")
}
return value, nil
}, func(input *I, value commandkit.Supplied[string]) { destination(input).Config = value }),
commandkit.ValueFlag(commandkit.FlagMeta{Name: "overlay", Usage: "Select a configuration overlay.", Completion: commandkit.CompleteFiles()}, (*string)(nil), func(value string) (string, error) { return value, nil }, func(input *I, value commandkit.Supplied[string]) { destination(input).Overlay = value }),
commandkit.RepeatFlag(commandkit.FlagMeta{Name: "set", Usage: "Override POINTER=JSON."}, []configkit.Override(nil), parseConfigurationOverride, func(input *I, value commandkit.Supplied[[]configkit.Override]) {
destination(input).Overrides = value.Value
}),
}
}
func parseConfigurationOverride(raw string) (configkit.Override, error) {
pointer, encoded, ok := strings.Cut(raw, "=")
if !ok {
return configkit.Override{}, fmt.Errorf("override requires POINTER=JSON")
}
path, err := configkit.ParsePath(pointer)
if err != nil {
return configkit.Override{}, err
}
value, err := commandkit.ParseCLIJSON(encoded)
if err != nil {
return configkit.Override{}, err
}
return configkit.Override{Path: path, Value: value, Flag: "--set"}, nil
}
func pipelineCommands(newState func() *nativeLoaders, catalog func() (pipeline.ModuleCatalog, error)) commandkit.Command {
command := func(operation, summary string) commandkit.Command {
var arguments []commandkit.Argument[pipelineInspectionInput]
if operation != "list" {
arguments = []commandkit.Argument[pipelineInspectionInput]{commandkit.ValueArgument(commandkit.ArgumentMeta{Name: "pipeline-id", Usage: "Configured pipeline identifier."}, true, func(value string) (string, error) {
value = strings.TrimSpace(value)
if value == "" {
return "", fmt.Errorf("pipeline id must not be empty")
}
return value, nil
}, func(input *pipelineInspectionInput, value commandkit.Supplied[string]) {
input.PipelineID = value.Value
})}
}
return commandkit.NewCommand(commandkit.CommandSpec[pipelineInspectionInput]{Name: operation, Summary: summary,
Flags: configurationSelectionFlags(func(input *pipelineInspectionInput) *ckconfig.Selection { return &input.Selection }), Arguments: arguments,
CheckInput: func(input pipelineInspectionInput) error { return checkConfigSelection(input.Selection) },
Run: func(invocation commandkit.Invocation, input pipelineInspectionInput) commandkit.Outcome {
state := newState()
result, err := state.application(invocation.Context, input.Selection)
if err != nil {
return pipelineConfigurationFailure(err)
}
if operation == "list" {
ids := make([]string, 0, len(result.Config.Pipelines))
for id := range result.Config.Pipelines {
ids = append(ids, id)
}
sort.Strings(ids)
return reportPipelineInspection(invocation, commandkit.Report{Value: ids})
}
loaded, err := config.FromResult(result)
if err != nil {
return pipelineInvalidConfiguration(err)
}
modules, err := catalog()
if err != nil {
return commandkit.Failure(err.Error()).WithCause(err)
}
effective, err := loaded.RuntimeConfig().Resolve(config.ResolveInput{PipelineID: input.PipelineID, Catalog: modules})
if err != nil {
return pipelineInvalidConfiguration(err)
}
if operation == "show" {
return reportPipelineInspection(invocation, commandkit.Report{Value: describePipeline(effective.ResolvedPipeline, modules)})
}
var engine *promptkit.Engine
if preflight.RequiresEngine(effective.ResolvedPipeline) {
engine, err = state.engine(invocation.Context, input.Selection)
if err != nil {
return pipelineConfigurationFailure(fmt.Errorf("pipeline %q native resources: %w", input.PipelineID, err))
}
}
if err := preflight.Validate(invocation.Context, effective.ResolvedPipeline, modules, engine); err != nil {
return pipelineInvalidConfiguration(err)
}
return reportPipelineInspection(invocation, commandkit.Report{Value: struct {
Pipeline string `json:"pipeline"`
Valid bool `json:"valid"`
}{input.PipelineID, true}, TextTemplate: pipelineValidationTemplate})
},
})
}
return commandkit.Group("pipeline", "Inspect, validate, or execute configured pipelines.", command("list", "List configured pipeline identifiers."), command("show", "Show a resolved pipeline composition."), command("validate", "Validate known pipeline dependencies offline."))
}
var pipelineValidationTemplate = template.Must(commandkit.ParseTextTemplate("pipeline-validation", "Pipeline {{printf \"%q\" .Pipeline}} is valid.\n", nil))
func reportPipelineInspection(invocation commandkit.Invocation, report commandkit.Report) commandkit.Outcome {
if err := invocation.Reporter().Report(report); err != nil {
return commandkit.Failure("Could not report pipeline inspection.").WithCause(err)
}
return commandkit.Success()
}
func pipelineConfigurationFailure(err error) commandkit.Outcome {
if ckconfig.ClassifyConfigurationError(err) == commandkit.OutcomeUsage {
return commandkit.Usage(err.Error()).WithCause(err)
}
return commandkit.Failure(err.Error()).WithCause(err)
}
func pipelineInvalidConfiguration(err error) commandkit.Outcome {
if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
return commandkit.Failure(err.Error()).WithCause(err)
}
return commandkit.Usage(err.Error()).WithCause(err)
}