Files
narratio/internal/app/execution_command.go

147 lines
6.8 KiB
Go
Raw Normal View History

package app
import (
"context"
"errors"
"fmt"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"go.maximumdirect.net/commandkit"
)
type executionInput struct {
Selection configurationSelection
From, Through, Stage commandkit.Supplied[string]
Force commandkit.Supplied[bool]
Artifacts commandkit.Supplied[[]string]
PreviousSession commandkit.Supplied[string]
plan BoundedPlan
selectedArtifacts []string
}
type runReport struct {
Campaign string `json:"campaign"`
SessionID string `json:"session_id"`
RunID string `json:"run_id"`
Stages []string `json:"stages"`
Executed []string `json:"executed"`
Skipped []string `json:"skipped"`
ArtifactTargets []string `json:"artifact_targets"`
StageResults []RunStageResult `json:"stage_results"`
AvailableArtifacts []RunArtifact `json:"available_artifacts"`
Complete bool `json:"complete"`
}
func checkExecutionInput(input *executionInput) error {
if err := checkConfigurationSelection(input.Selection); err != nil {
return err
}
if input.Stage.Set && (input.From.Set || input.Through.Set) {
return fmt.Errorf("--stage cannot be combined with --from or --through")
}
for _, field := range []struct {
name string
value commandkit.Supplied[string]
}{{"stage", input.Stage}, {"from", input.From}, {"through", input.Through}} {
if field.value.Set && field.value.Value == "" {
return fmt.Errorf("--%s requires a stage name", field.name)
}
}
from, through := input.From.Value, input.Through.Value
if input.Stage.Set {
from, through = input.Stage.Value, input.Stage.Value
}
plan, err := BuildBoundedPlan(from, through)
if err != nil {
return err
}
selected, err := normalizeArtifactNames(input.Artifacts.Value)
if err != nil {
return err
}
if len(selected) > 0 && !plan.Contains("analyze") && !plan.Contains("publish") {
return fmt.Errorf("--artifacts requires a selected range containing analyze or publish")
}
input.plan, input.selectedArtifacts = plan, selected
return nil
}
func executionCommand(name, summary string, regenerate bool, deps commandDependencies, executor pipelineExecutor) commandkit.Command {
spec := executionCommandSpec(name, summary, regenerate)
spec.Run = func(invocation commandkit.Invocation, input *executionInput) commandkit.Outcome {
report, err := executeSelectedPipeline(invocation.Context, input, deps, executor)
if report != nil {
err = errors.Join(err, invocation.Reporter().Report(commandkit.Report{Value: report}))
}
return operationOutcome(err)
}
return commandkit.NewCommand(spec)
}
func executionCommandSpec(name, summary string, regenerate bool) commandkit.CommandSpec[*executionInput] {
common := newConfigurationFlags(func(input **executionInput) *configurationSelection { return &(*input).Selection })
flags := []commandkit.Flag[*executionInput]{common.Config, common.Overlay, common.Campaign, common.CampaignFile, common.SessionFile, common.PartyFile, common.SecretsDir,
commandkit.ValueFlag(commandkit.FlagMeta{Name: "previous-session-id", Usage: "Assert the previous session identity."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).PreviousSession = value }),
commandkit.RepeatFlag(commandkit.FlagMeta{Name: "artifacts", Usage: "Analysis artifact or family targets (repeatable or comma-separated)."}, []string(nil), stringValue, func(input **executionInput, value commandkit.Supplied[[]string]) { (*input).Artifacts = value }),
}
if !regenerate {
flags = append(flags,
commandkit.ValueFlag(commandkit.FlagMeta{Name: "stage", Usage: "Select one canonical pipeline stage."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).Stage = value }),
commandkit.ValueFlag(commandkit.FlagMeta{Name: "from", Usage: "First pipeline stage, inclusive."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).From = value }),
commandkit.ValueFlag(commandkit.FlagMeta{Name: "through", Usage: "Last pipeline stage, inclusive."}, nil, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).Through = value }),
commandkit.BoolFlag(commandkit.FlagMeta{Name: "force", Usage: "Rerun selected stages."}, false, func(input **executionInput, value commandkit.Supplied[bool]) { (*input).Force = value }),
)
}
return commandkit.CommandSpec[*executionInput]{
Name: name, Summary: summary, NewInput: func() *executionInput { return &executionInput{} }, Flags: flags,
Arguments: []commandkit.Argument[*executionInput]{commandkit.ValueArgument(commandkit.ArgumentMeta{Name: "SESSION", Usage: "Session identity."}, true, stringValue, func(input **executionInput, value commandkit.Supplied[string]) { (*input).Selection.Session = value })},
CheckInput: func(input *executionInput) error {
if regenerate {
input.From = commandkit.Supplied[string]{Value: "extract", Set: true}
input.Through = commandkit.Supplied[string]{Value: "analyze", Set: true}
input.Force = commandkit.Supplied[bool]{Value: true, Set: true}
}
return checkExecutionInput(input)
},
}
}
func executeSelectedPipeline(ctx context.Context, input *executionInput, deps commandDependencies, executor pipelineExecutor) (report *runReport, err error) {
invocationDeps := normalizeCommandDependencies(deps)
invocationDeps.secretsBootstrap = &secretsBootstrap{}
acquired := newConfigurationAcquisition(input.Selection, invocationDeps)
acquired.previousSessionID = input.PreviousSession.Value
defer func() {
err = errors.Join(err, acquired.Close())
if report != nil {
report.Complete = err == nil
}
}()
cfg, err := acquired.Domain(ctx)
if err != nil {
return nil, err
}
if err := config.Validate(cfg); err != nil {
return nil, err
}
selected, err := normalizeArtifactSelection(cfg, input.selectedArtifacts)
if err != nil {
return nil, &inputError{message: err.Error(), cause: err}
}
effective, err := resolveEffectiveArtifacts(cfg, selected)
if err != nil {
return nil, &inputError{message: err.Error(), cause: err}
}
if err := ctx.Err(); err != nil {
return nil, err
}
summary, err := executor(ctx, cfg, input.plan, RunOptions{Force: input.Force.Value, SelectedArtifacts: selected, EffectiveArtifacts: effective})
if summary == nil {
if err == nil {
err = fmt.Errorf("pipeline execution returned no run summary")
}
return nil, err
}
return &runReport{Campaign: config.CampaignID(cfg.Campaign), SessionID: summary.SessionID, RunID: summary.RunID, Stages: input.plan.Names(), Executed: summary.Executed, Skipped: summary.Skipped, ArtifactTargets: effective.Keys(), StageResults: summary.StageResults, AvailableArtifacts: summary.AvailableArtifacts, Complete: err == nil}, err
}