272 lines
9.4 KiB
Go
272 lines
9.4 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
|
|
"gitea.maximumdirect.net/eric/narratio/internal/config"
|
|
configkit "go.maximumdirect.net/configkit"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type configDiffFlags struct {
|
|
pipelinePath singletonStringFlag
|
|
campaignPath singletonStringFlag
|
|
campaignFilePath singletonStringFlag
|
|
secretsDir singletonStringFlag
|
|
}
|
|
|
|
type configDiffRequest struct {
|
|
leftOverlay string
|
|
rightOverlay string
|
|
flags configDiffFlags
|
|
}
|
|
|
|
type configDiffResolved struct {
|
|
left *inspectionConfig
|
|
right *inspectionConfig
|
|
}
|
|
|
|
// ConfigDiff compares two explicitly selected overlays through the same
|
|
// read-only configuration resolution boundary used by config validate, show,
|
|
// and sources. Differences describe normalized effective values rather than
|
|
// the layout of root, import, or overlay files.
|
|
func ConfigDiff(ctx context.Context, args []string, out io.Writer) error {
|
|
return configDiffWithDependencies(ctx, args, out, commandDependencies{})
|
|
}
|
|
|
|
func configDiffWithDependencies(_ context.Context, args []string, out io.Writer, deps commandDependencies) error {
|
|
request, err := parseConfigDiffRequest(args, out)
|
|
if err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
resolved, err := resolveConfigDiff(request, deps)
|
|
if err != nil {
|
|
return fmt.Errorf("config diff: %w", err)
|
|
}
|
|
differences, err := config.DiffEffectivePipelines(resolved.left.Pipeline, resolved.right.Pipeline)
|
|
if err != nil {
|
|
return fmt.Errorf("config diff: %w", err)
|
|
}
|
|
if len(differences) == 0 {
|
|
_, err := fmt.Fprintln(out, "no differences")
|
|
return err
|
|
}
|
|
for _, difference := range differences {
|
|
kind := "changed"
|
|
if !difference.Left.Present {
|
|
kind = "added"
|
|
}
|
|
if !difference.Right.Present {
|
|
kind = "removed"
|
|
}
|
|
fields := []string{kind, difference.Path.String()}
|
|
if difference.Left.Present {
|
|
value, err := compactSnapshot(difference.Left)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fields = append(fields, value)
|
|
}
|
|
if difference.Right.Present {
|
|
value, err := compactSnapshot(difference.Right)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
fields = append(fields, value)
|
|
}
|
|
if difference.HiddenChanged {
|
|
fields = append(fields, "hidden_changed=true")
|
|
}
|
|
if _, err := fmt.Fprintln(out, strings.Join(fields, "\t")); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func parseConfigDiffRequest(args []string, out io.Writer) (configDiffRequest, error) {
|
|
overlays, flagArgs := splitConfigDiffArguments(args)
|
|
fs := flag.NewFlagSet("config diff", flag.ContinueOnError)
|
|
fs.SetOutput(out)
|
|
var request configDiffRequest
|
|
request.flags.pipelinePath.name = "config"
|
|
request.flags.campaignPath.name = "campaign"
|
|
request.flags.campaignFilePath.name = "campaign-file"
|
|
request.flags.secretsDir.name = "secrets-dir"
|
|
fs.Var(&request.flags.pipelinePath, "config", "path to pipeline.yml (optional; defaults searched)")
|
|
fs.Var(&request.flags.campaignPath, "campaign", "campaign ID")
|
|
fs.Var(&request.flags.campaignFilePath, "campaign-file", "path to campaign.yml")
|
|
fs.Var(&request.flags.secretsDir, "secrets-dir", "secrets directory (optional; defaults to /usr/local/etc/narratio/secrets)")
|
|
fs.Usage = func() {
|
|
fmt.Fprintln(out, "Usage: narratio config diff <left-overlay> <right-overlay> [--config <pipeline.yml>] [--campaign <id> | --campaign-file <campaign.yml>] [--secrets-dir <path>]")
|
|
fmt.Fprintln(out)
|
|
fmt.Fprintln(out, "Compares fully resolved overlays without a session, workspace, manifest, adapters, or external services.")
|
|
fmt.Fprintln(out)
|
|
fmt.Fprintln(out, "Flags:")
|
|
fs.PrintDefaults()
|
|
}
|
|
if err := fs.Parse(flagArgs); err != nil {
|
|
return configDiffRequest{}, fmt.Errorf("config diff: invalid flags: %w", err)
|
|
}
|
|
overlays = append(overlays, fs.Args()...)
|
|
if len(overlays) != 2 || strings.TrimSpace(overlays[0]) == "" || strings.TrimSpace(overlays[1]) == "" {
|
|
return configDiffRequest{}, fmt.Errorf("config diff: exactly two non-empty overlay names are required")
|
|
}
|
|
if overlays[0] == overlays[1] {
|
|
return configDiffRequest{}, fmt.Errorf("config diff: overlay names must differ")
|
|
}
|
|
if request.flags.campaignPath.set && request.flags.campaignFilePath.set {
|
|
return configDiffRequest{}, fmt.Errorf("config diff: --campaign and --campaign-file are mutually exclusive")
|
|
}
|
|
request.leftOverlay = overlays[0]
|
|
request.rightOverlay = overlays[1]
|
|
return request, nil
|
|
}
|
|
|
|
// splitConfigDiffArguments accepts the documented positional-first syntax and
|
|
// also permits flags before or between overlay names. Values belonging to the
|
|
// supported string flags stay with their flag so they are not mistaken for
|
|
// overlay names.
|
|
func splitConfigDiffArguments(args []string) (overlays, flagArgs []string) {
|
|
for index := 0; index < len(args); index++ {
|
|
argument := args[index]
|
|
if !strings.HasPrefix(argument, "-") || argument == "-" {
|
|
overlays = append(overlays, argument)
|
|
continue
|
|
}
|
|
flagArgs = append(flagArgs, argument)
|
|
name, hasValue := strings.CutPrefix(argument, "--")
|
|
if !hasValue {
|
|
continue
|
|
}
|
|
name, _, hasInlineValue := strings.Cut(name, "=")
|
|
if hasInlineValue || !configDiffStringFlag(name) || index+1 >= len(args) {
|
|
continue
|
|
}
|
|
index++
|
|
flagArgs = append(flagArgs, args[index])
|
|
}
|
|
return overlays, flagArgs
|
|
}
|
|
|
|
func configDiffStringFlag(name string) bool {
|
|
switch name {
|
|
case "config", "campaign", "campaign-file", "secrets-dir":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func resolveConfigDiff(request configDiffRequest, deps commandDependencies) (*configDiffResolved, error) {
|
|
deps = normalizeCommandDependencies(deps)
|
|
pipelinePath, leftPipeline, err := loadPipelineConfigWithDependencies(request.flags.pipelinePath.value, config.PipelineLoadOptions{Overlay: &request.leftOverlay}, request.flags.secretsDir.pointer(), deps)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("load left pipeline overlay: %w", err)
|
|
}
|
|
_, rightPipeline, err := loadPipelineConfigWithDependencies(pipelinePath, config.PipelineLoadOptions{Overlay: &request.rightOverlay}, request.flags.secretsDir.pointer(), deps)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("load right pipeline overlay: %w", err)
|
|
}
|
|
needsCampaign := pipelineHasArtifactFamilies(leftPipeline) || pipelineHasArtifactFamilies(rightPipeline)
|
|
hasCampaignSelection := request.flags.campaignPath.set || request.flags.campaignFilePath.set
|
|
if !needsCampaign && !hasCampaignSelection {
|
|
if err := validateInspectionPipeline(pipelinePath, leftPipeline); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := validateInspectionPipeline(pipelinePath, rightPipeline); err != nil {
|
|
return nil, err
|
|
}
|
|
return &configDiffResolved{
|
|
left: &inspectionConfig{PipelinePath: pipelinePath, Pipeline: leftPipeline},
|
|
right: &inspectionConfig{PipelinePath: pipelinePath, Pipeline: rightPipeline},
|
|
}, nil
|
|
}
|
|
|
|
campaignPath, err := resolveSharedDiffCampaignPath(leftPipeline, rightPipeline, request.flags)
|
|
if err != nil {
|
|
if needsCampaign {
|
|
return nil, fmt.Errorf("pipeline.scriptorium.artifact_families requires one shared campaign: %w", err)
|
|
}
|
|
return nil, err
|
|
}
|
|
campaign, err := config.LoadCampaign(campaignPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if request.flags.campaignPath.set && !request.flags.campaignFilePath.set {
|
|
if got := config.CampaignID(campaign); got != request.flags.campaignPath.value {
|
|
return nil, fmt.Errorf("campaign config %q invalid: campaign_id %q does not match selected campaign %q", campaignPath, got, request.flags.campaignPath.value)
|
|
}
|
|
}
|
|
leftLoaded, err := config.LoadPipelineCampaign(pipelinePath, leftPipeline, campaignPath, campaign)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rightLoaded, err := config.LoadPipelineCampaignWithParty(pipelinePath, rightPipeline, campaignPath, campaign, leftLoaded.Party)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := validateInspectionPipeline(leftLoaded.PipelinePath, leftLoaded.Pipeline); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := validateInspectionPipeline(rightLoaded.PipelinePath, rightLoaded.Pipeline); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := validateInspectionCampaign(campaignPath, campaign); err != nil {
|
|
return nil, err
|
|
}
|
|
return &configDiffResolved{
|
|
left: &inspectionConfig{
|
|
PipelinePath: leftLoaded.PipelinePath,
|
|
Pipeline: leftLoaded.Pipeline,
|
|
CampaignPath: leftLoaded.CampaignPath,
|
|
Campaign: campaign,
|
|
Party: leftLoaded.Party,
|
|
},
|
|
right: &inspectionConfig{
|
|
PipelinePath: rightLoaded.PipelinePath,
|
|
Pipeline: rightLoaded.Pipeline,
|
|
CampaignPath: rightLoaded.CampaignPath,
|
|
Campaign: campaign,
|
|
Party: rightLoaded.Party,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func resolveSharedDiffCampaignPath(left, right *config.PipelineConfig, flags configDiffFlags) (string, error) {
|
|
leftPath, leftErr := resolveCampaignConfigPath(left, flags.campaignPath.value, flags.campaignFilePath.value)
|
|
if leftErr != nil {
|
|
return "", leftErr
|
|
}
|
|
rightPath, rightErr := resolveCampaignConfigPath(right, flags.campaignPath.value, flags.campaignFilePath.value)
|
|
if rightErr != nil {
|
|
return "", rightErr
|
|
}
|
|
if leftPath != rightPath {
|
|
return "", fmt.Errorf("overlay selections resolve different campaign files; specify --campaign-file to compare one campaign")
|
|
}
|
|
return leftPath, nil
|
|
}
|
|
|
|
func compactSnapshot(snapshot configkit.ValueSnapshot) (string, error) {
|
|
var value any
|
|
if err := yaml.Unmarshal([]byte(snapshot.YAML), &value); err != nil {
|
|
return "", fmt.Errorf("decode safe diff value: %w", err)
|
|
}
|
|
encoded, err := json.Marshal(value)
|
|
if err != nil {
|
|
return "", fmt.Errorf("encode safe diff value: %w", err)
|
|
}
|
|
return string(encoded), nil
|
|
}
|