package cli import ( "fmt" "sort" "strings" "gitea.maximumdirect.net/eric/notarius/internal/core/config" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" "gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline" ) type cliReferenceRequest struct { Selector cliReferenceSelector Source string } type cliReferenceUnbindRequest struct { Selector cliReferenceSelector } type cliReferenceSelector struct { Scope cliReferenceSelectorScope LaneID string Stage pipeline.ModuleStage SlotName string } type cliReferenceSelectorScope uint8 const ( cliReferenceScopePipeline cliReferenceSelectorScope = iota cliReferenceScopeLane cliReferenceScopeChunk cliReferenceScopeBinding ) func parseReferenceFlags(values []string) ([]cliReferenceRequest, error) { if len(values) == 0 { return nil, nil } requests := make([]cliReferenceRequest, 0, len(values)) for _, raw := range values { name, source, ok := strings.Cut(raw, "=") if !ok { return nil, fmt.Errorf("--reference must use slot=path, lane.slot=path, or lane.stage.slot=path") } if strings.TrimSpace(source) == "" { return nil, fmt.Errorf("--reference path must not be empty; use --without-reference to unbind") } selector, err := parseReferenceSelector(name, "--reference") if err != nil { return nil, err } requests = append(requests, cliReferenceRequest{ Selector: selector, Source: strings.TrimSpace(source), }) } return requests, nil } func parseReferenceUnbindFlags(values []string) ([]cliReferenceUnbindRequest, error) { if len(values) == 0 { return nil, nil } requests := make([]cliReferenceUnbindRequest, 0, len(values)) for _, raw := range values { if strings.Contains(raw, "=") { return nil, fmt.Errorf("--without-reference must use a reference selector without =path") } selector, err := parseReferenceSelector(raw, "--without-reference") if err != nil { return nil, err } requests = append(requests, cliReferenceUnbindRequest{ Selector: selector, }) } return requests, nil } func parseReferenceSelector(raw string, flagName string) (cliReferenceSelector, error) { selector := strings.TrimSpace(raw) if selector == "" { return cliReferenceSelector{}, fmt.Errorf("%s reference slot must not be empty", flagName) } parts := strings.Split(selector, ".") for _, part := range parts { if strings.TrimSpace(part) == "" { return cliReferenceSelector{}, fmt.Errorf("%s must use non-empty reference selector values", flagName) } } switch len(parts) { case 1: return cliReferenceSelector{Scope: cliReferenceScopePipeline, SlotName: strings.TrimSpace(parts[0])}, nil case 2: first := strings.TrimSpace(parts[0]) slotName := strings.TrimSpace(parts[1]) if first == string(pipeline.StageChunk) { return cliReferenceSelector{Scope: cliReferenceScopeChunk, Stage: pipeline.StageChunk, SlotName: slotName}, nil } return cliReferenceSelector{Scope: cliReferenceScopeLane, LaneID: first, SlotName: slotName}, nil case 3: laneID := strings.TrimSpace(parts[0]) stage := pipeline.ModuleStage(strings.TrimSpace(parts[1])) slotName := strings.TrimSpace(parts[2]) if stage != pipeline.StageExtract && stage != pipeline.StageMerge && stage != pipeline.StageNormalize { return cliReferenceSelector{}, fmt.Errorf("%s lane-qualified selector must use lane.extract.slot, lane.merge.slot, or lane.normalize.slot", flagName) } return cliReferenceSelector{Scope: cliReferenceScopeBinding, LaneID: laneID, Stage: stage, SlotName: slotName}, nil default: return cliReferenceSelector{}, fmt.Errorf("%s must use slot, chunk.slot, lane.slot, lane.extract.slot, lane.merge.slot, or lane.normalize.slot", flagName) } } func resolveCLIReferenceRequests( cfg config.Config, pipelineID string, only []string, catalog pipeline.ModuleCatalog, referenceRequests []cliReferenceRequest, unbindRequests []cliReferenceUnbindRequest, ) ([]pipeline.ReferenceBinding, []pipeline.ReferenceUnbind, error) { if len(referenceRequests) == 0 && len(unbindRequests) == 0 { return nil, nil, nil } targets, err := selectedReferenceTargets(cfg, pipelineID, only, catalog) if err != nil { return nil, nil, err } // Broad CLI selectors are only presentation syntax. Collapse them into one // highest-specificity action per concrete framework target before pipeline // resolution so the generic reference contract stays stage-and-lane exact. actions := make(map[cliReferenceTargetKey]resolvedCLIReferenceAction) for _, request := range referenceRequests { matches, err := resolveCLIReferenceTargets(targets, request.Selector) if err != nil { return nil, nil, err } for _, target := range matches { candidate := resolvedCLIReferenceAction{ kind: cliReferenceActionBind, selector: request.Selector, target: target, slotName: request.Selector.SlotName, source: request.Source, specificity: request.Selector.specificity(), } if err := mergeCLIReferenceAction(actions, candidate); err != nil { return nil, nil, err } } } for _, request := range unbindRequests { matches, err := resolveCLIReferenceTargets(targets, request.Selector) if err != nil { return nil, nil, err } for _, target := range matches { candidate := resolvedCLIReferenceAction{ kind: cliReferenceActionUnbind, selector: request.Selector, target: target, slotName: request.Selector.SlotName, specificity: request.Selector.specificity(), } if err := mergeCLIReferenceAction(actions, candidate); err != nil { return nil, nil, err } } } resolved := make([]resolvedCLIReferenceAction, 0, len(actions)) for _, action := range actions { resolved = append(resolved, action) } sort.Slice(resolved, func(i, j int) bool { left, right := resolved[i], resolved[j] if left.target.laneID != right.target.laneID { return left.target.laneID < right.target.laneID } if left.target.stage != right.target.stage { return referenceStageOrder(left.target.stage) < referenceStageOrder(right.target.stage) } return left.slotName < right.slotName }) overrides := make([]pipeline.ReferenceBinding, 0, len(resolved)) unbinds := make([]pipeline.ReferenceUnbind, 0, len(resolved)) for _, action := range resolved { switch action.kind { case cliReferenceActionBind: overrides = append(overrides, pipeline.ReferenceBinding{ Stage: action.target.stage, LaneID: action.target.laneID, SlotName: action.slotName, Source: action.source, BindingSource: contracts.ReferenceBindingSourceCLI, }) case cliReferenceActionUnbind: unbinds = append(unbinds, pipeline.ReferenceUnbind{ Stage: action.target.stage, LaneID: action.target.laneID, SlotName: action.slotName, }) } } return overrides, unbinds, nil } type cliReferenceActionKind uint8 const ( cliReferenceActionBind cliReferenceActionKind = iota cliReferenceActionUnbind ) type cliReferenceTargetKey struct { stage pipeline.ModuleStage laneID string slotName string } type resolvedCLIReferenceAction struct { kind cliReferenceActionKind selector cliReferenceSelector target selectedReferenceTarget slotName string source string specificity int } func mergeCLIReferenceAction(actions map[cliReferenceTargetKey]resolvedCLIReferenceAction, candidate resolvedCLIReferenceAction) error { key := cliReferenceTargetKey{stage: candidate.target.stage, laneID: candidate.target.laneID, slotName: candidate.slotName} current, ok := actions[key] if !ok || candidate.specificity > current.specificity { actions[key] = candidate return nil } if candidate.specificity < current.specificity { return nil } if candidate.kind != current.kind { return fmt.Errorf("reference target %q slot %q is both bound by %q and unbound by %q at the same specificity", targetLabel(candidate.target), candidate.slotName, current.selector.String(), candidate.selector.String()) } actions[key] = candidate return nil } func (selector cliReferenceSelector) specificity() int { switch selector.Scope { case cliReferenceScopePipeline: return 0 case cliReferenceScopeLane: return 1 case cliReferenceScopeChunk, cliReferenceScopeBinding: return 2 default: return -1 } } func (selector cliReferenceSelector) String() string { switch selector.Scope { case cliReferenceScopePipeline: return selector.SlotName case cliReferenceScopeLane: return selector.LaneID + "." + selector.SlotName case cliReferenceScopeChunk: return "chunk." + selector.SlotName case cliReferenceScopeBinding: return selector.LaneID + "." + string(selector.Stage) + "." + selector.SlotName default: return selector.SlotName } } type selectedReferenceTarget struct { laneID string stage pipeline.ModuleStage module string slots map[string]struct{} } func selectedReferenceTargets(cfg config.Config, pipelineID string, only []string, catalog pipeline.ModuleCatalog) ([]selectedReferenceTarget, error) { profile, ok := lookupCLIReferencePipeline(cfg.Pipelines, pipelineID) if !ok { return nil, fmt.Errorf("pipeline %q is not configured", strings.TrimSpace(pipelineID)) } if profile.Steps != nil && len(only) > 0 { return nil, fmt.Errorf("pipeline %q lane selection is not supported for explicit ordered steps", strings.TrimSpace(pipelineID)) } lanesByID := make(map[string]pipeline.ArtifactLaneProfile, len(profile.Artifacts)) addLanes := func(values map[string]pipeline.ArtifactLaneProfile) error { for rawLaneID, lane := range values { laneID := strings.TrimSpace(rawLaneID) if laneID == "" { return fmt.Errorf("pipeline %q artifact lane id must not be empty", strings.TrimSpace(pipelineID)) } if _, ok := lanesByID[laneID]; ok { return fmt.Errorf("pipeline %q artifact lane %q is duplicated after trimming", strings.TrimSpace(pipelineID), laneID) } lanesByID[laneID] = lane } return nil } if profile.Steps == nil { if err := addLanes(profile.Artifacts); err != nil { return nil, err } } else { for _, step := range profile.Steps { if err := addLanes(step.Artifacts); err != nil { return nil, err } } } selectedIDs := make([]string, 0, len(lanesByID)) if len(only) == 0 { for laneID := range lanesByID { selectedIDs = append(selectedIDs, laneID) } } else { seen := make(map[string]struct{}, len(only)) for _, rawLaneID := range only { laneID := strings.TrimSpace(rawLaneID) if laneID == "" { return nil, fmt.Errorf("pipeline %q selected artifact lane id must not be empty", strings.TrimSpace(pipelineID)) } if _, ok := lanesByID[laneID]; !ok { return nil, fmt.Errorf("pipeline %q selected artifact lane %q is not declared", strings.TrimSpace(pipelineID), laneID) } if _, ok := seen[laneID]; !ok { selectedIDs = append(selectedIDs, laneID) seen[laneID] = struct{}{} } } } sort.Strings(selectedIDs) targets := make([]selectedReferenceTarget, 0, 1+len(selectedIDs)*3) chunk := pipeline.Binding(profile.Chunk.Module) chunk.Module = strings.TrimSpace(profile.Chunk.Module) if chunk.Module == "" { chunk.Module = pipeline.DefaultChunkModule } chunkSpec, err := cliReferenceChunkerSpec(catalog, chunk.Module) if err != nil { return nil, fmt.Errorf("pipeline %q chunk module %q: %w", strings.TrimSpace(pipelineID), chunk.Module, err) } targets = append(targets, selectedReferenceTarget{ stage: pipeline.StageChunk, module: chunk.Module, slots: referenceSlotSet(chunkSpec.ReferenceSlots), }) for _, laneID := range selectedIDs { lane := lanesByID[laneID] extractModule := strings.TrimSpace(lane.Extract.Module) if extractModule == "" { return nil, fmt.Errorf("pipeline %q lane %q extract module must not be empty", strings.TrimSpace(pipelineID), laneID) } extractSpec, err := cliReferenceExtractorSpec(catalog, extractModule) if err != nil { return nil, fmt.Errorf("pipeline %q lane %q extract module %q: %w", strings.TrimSpace(pipelineID), laneID, extractModule, err) } artifactKind := extractSpec.ArtifactKind if artifactKind == "" { return nil, fmt.Errorf("pipeline %q lane %q extract module %q does not declare an artifact kind", strings.TrimSpace(pipelineID), laneID, extractModule) } targets = append(targets, selectedReferenceTarget{ laneID: laneID, stage: pipeline.StageExtract, module: extractModule, slots: referenceSlotSet(extractSpec.ReferenceSlots), }) mergeModule := strings.TrimSpace(lane.Merge.Module) if mergeModule == "" { mergeModule = pipeline.DefaultMergeModule } mergeSpec, err := cliReferenceMergerSpec(catalog, mergeModule, artifactKind) if err != nil { return nil, fmt.Errorf("pipeline %q lane %q merge module %q: %w", strings.TrimSpace(pipelineID), laneID, mergeModule, err) } targets = append(targets, selectedReferenceTarget{ laneID: laneID, stage: pipeline.StageMerge, module: mergeModule, slots: referenceSlotSet(mergeSpec.ReferenceSlots), }) normalizeModule := strings.TrimSpace(lane.Normalize.Module) if normalizeModule == "" { normalizeModule = pipeline.DefaultNormalizeModule } normalizeSpec, err := cliReferenceNormalizerSpec(catalog, normalizeModule, artifactKind) if err != nil { return nil, fmt.Errorf("pipeline %q lane %q normalize module %q: %w", strings.TrimSpace(pipelineID), laneID, normalizeModule, err) } targets = append(targets, selectedReferenceTarget{ laneID: laneID, stage: pipeline.StageNormalize, module: normalizeModule, slots: referenceSlotSet(normalizeSpec.ReferenceSlots), }) } return targets, nil } func lookupCLIReferencePipeline(profiles map[string]pipeline.PipelineProfile, pipelineID string) (pipeline.PipelineProfile, bool) { pipelineID = strings.TrimSpace(pipelineID) for rawID, profile := range profiles { if strings.TrimSpace(rawID) == pipelineID { return profile, true } } return pipeline.PipelineProfile{}, false } func cliReferenceChunkerSpec(catalog pipeline.ModuleCatalog, module string) (pipeline.ModuleSpec, error) { if catalog.Chunkers == nil { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } spec, ok := catalog.Chunkers.Spec(module) if !ok { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } return spec, nil } func cliReferenceExtractorSpec(catalog pipeline.ModuleCatalog, module string) (pipeline.ModuleSpec, error) { if catalog.Extractors == nil { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } spec, ok := catalog.Extractors.Spec(module) if !ok { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } return spec, nil } func cliReferenceMergerSpec(catalog pipeline.ModuleCatalog, module string, kind contracts.ArtifactKind) (pipeline.ModuleSpec, error) { if catalog.Mergers == nil { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } registered := catalog.Mergers.RegisteredArtifactKinds(module) if len(registered) == 0 { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } spec, ok := catalog.Mergers.SpecForArtifact(module, kind) if !ok { return pipeline.ModuleSpec{}, cliReferenceArtifactVariantError("merger", module, kind, registered) } return spec, nil } func cliReferenceNormalizerSpec(catalog pipeline.ModuleCatalog, module string, kind contracts.ArtifactKind) (pipeline.ModuleSpec, error) { if catalog.Normalizers == nil { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } registered := catalog.Normalizers.RegisteredArtifactKinds(module) if len(registered) == 0 { return pipeline.ModuleSpec{}, fmt.Errorf("module %q is not registered", module) } spec, ok := catalog.Normalizers.SpecForArtifact(module, kind) if !ok { return pipeline.ModuleSpec{}, cliReferenceArtifactVariantError("normalizer", module, kind, registered) } return spec, nil } func cliReferenceArtifactVariantError(moduleType string, module string, kind contracts.ArtifactKind, registered []contracts.ArtifactKind) error { values := make([]string, len(registered)) for i, value := range registered { values[i] = string(value) } if len(values) == 0 { return fmt.Errorf("%s %q has no typed variant for artifact kind %q", moduleType, module, kind) } return fmt.Errorf("%s %q has no typed variant for artifact kind %q; registered kinds: %s", moduleType, module, kind, strings.Join(values, ", ")) } func referenceSlotSet(slots []contracts.ReferenceSlot) map[string]struct{} { slotSet := make(map[string]struct{}, len(slots)) for _, slot := range slots { slotSet[slot.Name] = struct{}{} } return slotSet } func resolveCLIReferenceTargets(targets []selectedReferenceTarget, selector cliReferenceSelector) ([]selectedReferenceTarget, error) { slotName := strings.TrimSpace(selector.SlotName) if slotName == "" { return nil, fmt.Errorf("reference slot must not be empty") } switch selector.Scope { case cliReferenceScopePipeline: matches := make([]selectedReferenceTarget, 0, len(targets)) for _, target := range targets { if _, ok := target.slots[slotName]; ok { matches = append(matches, target) } } if len(matches) == 0 { return nil, fmt.Errorf("reference slot %q is not declared by any selected target", slotName) } return matches, nil case cliReferenceScopeChunk: for _, target := range targets { if target.stage != pipeline.StageChunk { continue } if _, ok := target.slots[slotName]; !ok { return nil, fmt.Errorf("reference slot %q is not declared by chunk module %q", slotName, target.module) } return []selectedReferenceTarget{target}, nil } return nil, fmt.Errorf("reference chunk target is not selected") case cliReferenceScopeLane: laneSelected := false matches := make([]selectedReferenceTarget, 0, 3) for _, target := range targets { if target.laneID != selector.LaneID { continue } laneSelected = true if _, ok := target.slots[slotName]; ok { matches = append(matches, target) } } if !laneSelected { return nil, fmt.Errorf("reference lane %q is not selected", selector.LaneID) } if len(matches) == 0 { return nil, fmt.Errorf("reference slot %q is not declared by selected lane %q", slotName, selector.LaneID) } return matches, nil case cliReferenceScopeBinding: laneSelected := false for _, target := range targets { if target.laneID != selector.LaneID { continue } laneSelected = true if target.stage != selector.Stage { continue } if _, ok := target.slots[slotName]; !ok { return nil, fmt.Errorf("reference slot %q is not declared by selected %s target %q", slotName, selector.Stage, targetLabel(target)) } return []selectedReferenceTarget{target}, nil } if !laneSelected { return nil, fmt.Errorf("reference lane %q is not selected", selector.LaneID) } return nil, fmt.Errorf("reference %s target is not selected for lane %q", selector.Stage, selector.LaneID) default: return nil, fmt.Errorf("reference selector has unknown scope") } } func targetLabel(target selectedReferenceTarget) string { if target.stage == pipeline.StageChunk { return "chunk" } return target.laneID + "." + string(target.stage) } func referenceStageOrder(stage pipeline.ModuleStage) int { switch stage { case pipeline.StageChunk: return 0 case pipeline.StageExtract: return 1 case pipeline.StageMerge: return 2 case pipeline.StageNormalize: return 3 default: return 4 } }