185 lines
7.5 KiB
Go
185 lines
7.5 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), additional ...commandkit.Command) 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 pipelineResourceFailure(err)
|
|
}
|
|
return reportPipelineInspection(invocation, commandkit.Report{Value: struct {
|
|
Pipeline string `json:"pipeline"`
|
|
Valid bool `json:"valid"`
|
|
}{input.PipelineID, true}, TextTemplate: pipelineValidationTemplate})
|
|
},
|
|
})
|
|
}
|
|
children := []commandkit.Command{command("list", "List configured pipeline identifiers."), command("show", "Show a resolved pipeline composition."), command("validate", "Validate known pipeline dependencies offline.")}
|
|
return commandkit.Group("pipeline", "Inspect, validate, or execute configured pipelines.", append(children, additional...)...)
|
|
}
|
|
|
|
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.")
|
|
}
|
|
return commandkit.Success()
|
|
}
|
|
|
|
func pipelineConfigurationFailure(err error) commandkit.Outcome {
|
|
outcome := commandkit.Failure(err.Error()).WithCause(err)
|
|
if ckconfig.ClassifyConfigurationError(err) == commandkit.OutcomeUsage {
|
|
outcome = commandkit.Usage(err.Error()).WithCause(err)
|
|
}
|
|
var load *configkit.LoadError
|
|
if errors.As(err, &load) {
|
|
_, explanation := ckconfig.AdaptDiagnostics(err.Error()+"\n", load.Sources(), load.Diagnostics())
|
|
outcome = outcome.WithExplanation(explanation.Message, explanation.Details...)
|
|
}
|
|
return outcome
|
|
}
|
|
|
|
func pipelineResourceFailure(err error) commandkit.Outcome {
|
|
if preflightInputError(err) {
|
|
return commandkit.Usage(err.Error()).WithCause(err)
|
|
}
|
|
return pipelineConfigurationFailure(err)
|
|
}
|
|
|
|
// Only identifiable missing native selections are invalid preflight input.
|
|
// Unknown failures and any operational branch of a joined error remain failures.
|
|
func preflightInputError(err error) bool {
|
|
if err == nil || errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
|
|
return false
|
|
}
|
|
if _, ok := err.(*preflight.SelectionError); ok {
|
|
return true
|
|
}
|
|
if joined, ok := err.(interface{ Unwrap() []error }); ok {
|
|
found := false
|
|
for _, child := range joined.Unwrap() {
|
|
if child != nil {
|
|
found = true
|
|
if !preflightInputError(child) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return found
|
|
}
|
|
if wrapped, ok := err.(interface{ Unwrap() error }); ok {
|
|
return preflightInputError(wrapped.Unwrap())
|
|
}
|
|
return false
|
|
}
|
|
|
|
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)
|
|
}
|