496 lines
17 KiB
Go
496 lines
17 KiB
Go
package config
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
|
|
configkit "go.maximumdirect.net/configkit"
|
|
)
|
|
|
|
// EffectivePipelineRootPath reports the absolute root pipeline path retained
|
|
// while resolving cfg. It is empty for a pipeline not loaded through the
|
|
// production loader.
|
|
func EffectivePipelineRootPath(cfg *PipelineConfig) string {
|
|
if cfg == nil || cfg.resolution == nil {
|
|
return ""
|
|
}
|
|
return cfg.resolution.rootPath
|
|
}
|
|
|
|
// EffectivePipelineImports reports the ordered, absolute import paths that
|
|
// contributed to cfg.
|
|
func EffectivePipelineImports(cfg *PipelineConfig) []string {
|
|
if cfg == nil || cfg.resolution == nil {
|
|
return nil
|
|
}
|
|
return append([]string(nil), cfg.resolution.imports...)
|
|
}
|
|
|
|
// NormalizedConfigurationPath returns a clean absolute path when possible for
|
|
// display-only configuration provenance.
|
|
func NormalizedConfigurationPath(path string) string {
|
|
return normalizedProvenancePath(path)
|
|
}
|
|
|
|
// EffectivePipelineSourceRecord identifies one effective logical field and a
|
|
// safe source that contributed to it. Generated values intentionally have two
|
|
// records: their family declaration and the canonical party that supplied the
|
|
// member-specific value.
|
|
type EffectivePipelineSourceRecord struct {
|
|
Path string
|
|
Role string
|
|
Source string
|
|
}
|
|
|
|
// EmptyImportSelection describes a native optional selection that acquired no source.
|
|
type EmptyImportSelection struct {
|
|
Source string
|
|
Path string
|
|
Selector string
|
|
Line int
|
|
Column int
|
|
}
|
|
|
|
func emptyImportSelections[T any](result *configkit.Result[T]) []EmptyImportSelection {
|
|
if result == nil {
|
|
return nil
|
|
}
|
|
var selections []EmptyImportSelection
|
|
for _, listed := range result.Sources() {
|
|
source, ok := result.Source(listed.ID)
|
|
if !ok {
|
|
continue
|
|
}
|
|
name := source.Path
|
|
if name == "" {
|
|
name = source.Label
|
|
}
|
|
for _, item := range source.EmptyImportSelections {
|
|
selections = append(selections, EmptyImportSelection{Source: name, Path: item.Path.String(), Selector: string(item.Selector), Line: item.Location.Line, Column: item.Location.Column})
|
|
}
|
|
}
|
|
return selections
|
|
}
|
|
|
|
// EffectiveEmptyImports reports only optional selections that acquired nothing.
|
|
func EffectiveEmptyImports(pipeline *PipelineConfig, campaign *CampaignConfig) []EmptyImportSelection {
|
|
var result []EmptyImportSelection
|
|
if pipeline != nil && pipeline.resolution != nil {
|
|
result = append(result, emptyImportSelections(pipeline.resolution.authoring)...)
|
|
}
|
|
if campaign != nil && campaign.resolution != nil {
|
|
result = append(result, emptyImportSelections(campaign.resolution.campaign)...)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// EffectivePipelineValueRecord identifies one normalized, secret-free
|
|
// effective configuration value. Values use deterministic compact JSON
|
|
// representations so command output can be compared without raw YAML layout.
|
|
type EffectivePipelineValueRecord struct {
|
|
Path string
|
|
Value string
|
|
}
|
|
|
|
// EffectivePipelineValues projects a fully resolved pipeline into sorted
|
|
// logical configuration values. Mappings are flattened, while sequences remain
|
|
// atomic values. The projection uses the same normalized effective mapping as
|
|
// config show and therefore excludes loader directives and family declarations.
|
|
func EffectivePipelineValues(cfg *PipelineConfig) ([]EffectivePipelineValueRecord, error) {
|
|
if cfg == nil {
|
|
return nil, fmt.Errorf("pipeline config is required")
|
|
}
|
|
return projectionValueRecords(projectEffectivePipeline(cfg))
|
|
}
|
|
|
|
// EffectivePipelineSources projects pipeline ownership after defaults and
|
|
// optional family expansion. It never includes effective values or raw secret
|
|
// material, only logical paths and source identifiers.
|
|
func EffectivePipelineSources(cfg *PipelineConfig, party ResolvedParty) ([]EffectivePipelineSourceRecord, error) {
|
|
if cfg == nil {
|
|
return nil, fmt.Errorf("pipeline config is required")
|
|
}
|
|
values, err := EffectivePipelineValues(cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
paths := make([]string, 0, len(values))
|
|
for _, value := range values {
|
|
paths = append(paths, value.Path)
|
|
}
|
|
owners, err := effectivePipelineOwners(cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
families := ArtifactFamilies(cfg)
|
|
publishCount := 0
|
|
if cfg.Publish != nil {
|
|
publishCount = len(cfg.Publish.Outputs)
|
|
}
|
|
records := make([]EffectivePipelineSourceRecord, 0, len(paths)+publishCount)
|
|
for _, path := range paths {
|
|
if path == "publish.outputs" {
|
|
continue
|
|
}
|
|
if familyKey, ok := generatedArtifactFamilyForPath(path, families); ok {
|
|
records = appendGeneratedArtifactSources(records, path, familyKey, families, owners, party)
|
|
continue
|
|
}
|
|
records = appendPipelineOwners(records, path, owners[path], cfg)
|
|
}
|
|
records = appendPublishOutputSources(records, cfg, families, party, owners)
|
|
sort.Slice(records, func(left, right int) bool {
|
|
if records[left].Path != records[right].Path {
|
|
return records[left].Path < records[right].Path
|
|
}
|
|
if records[left].Role != records[right].Role {
|
|
return records[left].Role < records[right].Role
|
|
}
|
|
return records[left].Source < records[right].Source
|
|
})
|
|
return records, nil
|
|
}
|
|
|
|
// EffectiveCampaignSources projects selected campaign and party ownership
|
|
// without retaining or rendering campaign values. Players are derived from the
|
|
// canonical party source.
|
|
func EffectiveCampaignSources(campaignPath string, campaign *CampaignConfig, party ResolvedParty) []EffectivePipelineSourceRecord {
|
|
if campaign == nil {
|
|
return nil
|
|
}
|
|
fields := []string{"campaign_id", "inputs.autocorrect_file", "inputs.glossary_file", "inputs.speakers_file", "inputs.party_file"}
|
|
if strings.TrimSpace(campaign.Inputs.SpellCatalogFile) != "" {
|
|
fields = append(fields, "inputs.spell_catalog_file")
|
|
}
|
|
var records []EffectivePipelineSourceRecord
|
|
for _, field := range fields {
|
|
sources := campaignDefinitionSources(campaign, configkit.Keys(strings.Split(field, ".")...))
|
|
if len(sources) == 0 {
|
|
sources = []string{campaignPath}
|
|
}
|
|
for _, source := range sources {
|
|
records = append(records, EffectivePipelineSourceRecord{Path: "campaign." + field, Role: "campaign", Source: normalizedProvenancePath(source)})
|
|
}
|
|
}
|
|
partySource := normalizedProvenancePath(party.Source.Path)
|
|
records = append(records,
|
|
EffectivePipelineSourceRecord{Path: "campaign.inputs.party_file", Role: "party", Source: partySource},
|
|
EffectivePipelineSourceRecord{Path: "derived.players", Role: "party", Source: partySource},
|
|
)
|
|
sort.Slice(records, func(left, right int) bool {
|
|
if records[left].Path != records[right].Path {
|
|
return records[left].Path < records[right].Path
|
|
}
|
|
if records[left].Role != records[right].Role {
|
|
return records[left].Role < records[right].Role
|
|
}
|
|
return records[left].Source < records[right].Source
|
|
})
|
|
return records
|
|
}
|
|
|
|
func campaignDefinitionSources(campaign *CampaignConfig, path configkit.Path) []string {
|
|
if campaign.resolution == nil || campaign.resolution.campaign == nil {
|
|
return nil
|
|
}
|
|
result := campaign.resolution.campaign
|
|
var ids []string
|
|
add := func(origin configkit.Origin) {
|
|
for _, location := range origin.Locations {
|
|
ids = append(ids, location.SourceID)
|
|
}
|
|
for _, step := range origin.Inheritance {
|
|
for _, location := range step.Locations {
|
|
ids = append(ids, location.SourceID)
|
|
}
|
|
}
|
|
}
|
|
if info, ok := result.Metadata().Lookup(path); ok {
|
|
add(info.Origin)
|
|
}
|
|
for _, change := range result.Metadata().History(path) {
|
|
if change.Origin.Layer == configkit.LayerMain || change.Origin.Layer == configkit.LayerOverlay {
|
|
add(change.Origin)
|
|
}
|
|
}
|
|
var sources []string
|
|
for _, id := range nonEmptySortedStrings(ids) {
|
|
if source, ok := result.Source(id); ok {
|
|
name := source.Path
|
|
if name == "" {
|
|
name = source.Label
|
|
}
|
|
sources = append(sources, name)
|
|
}
|
|
}
|
|
return nonEmptySortedStrings(sources)
|
|
}
|
|
|
|
// MarshalEffectivePipeline renders the validated, normalized pipeline as one
|
|
// deterministic YAML document. Composition declarations and runtime-only
|
|
// resolution data are excluded. Artifact family declarations are also omitted
|
|
// because a resolved pipeline exposes their concrete artifacts instead.
|
|
func MarshalEffectivePipeline(cfg *PipelineConfig) ([]byte, error) {
|
|
if cfg == nil {
|
|
return nil, fmt.Errorf("pipeline config is required")
|
|
}
|
|
|
|
var snapshot *configkit.Result[effectivePipelineProjection]
|
|
if cfg.resolution != nil {
|
|
snapshot = cfg.resolution.inspection
|
|
}
|
|
if snapshot == nil {
|
|
var err error
|
|
snapshot, err = newPipelineInspection(cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
var output bytes.Buffer
|
|
if err := snapshot.WriteEffective(&output); err != nil {
|
|
return nil, fmt.Errorf("serialize effective pipeline: %w", err)
|
|
}
|
|
return output.Bytes(), nil
|
|
}
|
|
|
|
func effectivePipelineOwners(cfg *PipelineConfig) (map[string][]string, error) {
|
|
owners := make(map[string][]string)
|
|
if cfg == nil || cfg.resolution == nil {
|
|
return owners, nil
|
|
}
|
|
paths, err := pipelineMetadataPaths(cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
pathsByID := pipelineSourcePaths(cfg)
|
|
for _, value := range paths {
|
|
info, ok := cfg.resolution.configkitMetadata.Lookup(configkit.Keys(value.segments...))
|
|
sources := []string{pipelineDefaultOwnershipSource}
|
|
if ok {
|
|
sources = ownershipSources(info.Origin, pathsByID)
|
|
if info.Origin.Layer == configkit.LayerResolution {
|
|
for _, change := range cfg.resolution.configkitMetadata.History(configkit.Keys(value.segments...)) {
|
|
if change.Origin.Layer == configkit.LayerMain || change.Origin.Layer == configkit.LayerOverlay {
|
|
sources = append(sources, ownershipSources(change.Origin, pathsByID)...)
|
|
}
|
|
}
|
|
sources = nonEmptySortedStrings(sources)
|
|
}
|
|
}
|
|
owners[value.record.Path] = sources
|
|
}
|
|
if cfg.Scriptorium != nil {
|
|
for key, artifact := range cfg.Scriptorium.Artifacts {
|
|
paths := artifactDependencyOwnershipPaths(key, artifact)
|
|
if sources := sourcesForPipelinePaths(owners, paths); len(sources) != 0 {
|
|
sort.Strings(sources)
|
|
owners["scriptorium.artifacts."+key+".depends_on"] = sources
|
|
}
|
|
}
|
|
}
|
|
return owners, nil
|
|
}
|
|
|
|
func artifactDependencyOwnershipPaths(artifactKey string, artifact ScriptoriumArtifactConfig) []string {
|
|
var paths []string
|
|
for _, dependency := range artifact.DependsOn {
|
|
for _, origin := range artifact.dependencyOrigins[dependency] {
|
|
prefix := "scriptorium.artifacts." + artifactKey
|
|
if origin.family != "" {
|
|
prefix = "scriptorium.artifact_families." + origin.family
|
|
}
|
|
switch {
|
|
case origin.inputName != "":
|
|
paths = append(paths, prefix+".inputs."+origin.inputName+".source")
|
|
case origin.family != "":
|
|
paths = append(paths, prefix+".member_dependencies")
|
|
default:
|
|
paths = append(paths, prefix+".depends_on")
|
|
}
|
|
}
|
|
}
|
|
return paths
|
|
}
|
|
|
|
func generatedArtifactFamilyForPath(path string, families ArtifactFamilyCatalog) (string, bool) {
|
|
const prefix = "scriptorium.artifacts."
|
|
if !strings.HasPrefix(path, prefix) {
|
|
return "", false
|
|
}
|
|
memberPath := strings.TrimPrefix(path, prefix)
|
|
memberKey, _, _ := strings.Cut(memberPath, ".")
|
|
member, exists := families.Members[memberKey]
|
|
if !exists {
|
|
return "", false
|
|
}
|
|
_, exists = families.Families[member.Family]
|
|
return member.Family, exists
|
|
}
|
|
|
|
func appendGeneratedArtifactSources(records []EffectivePipelineSourceRecord, path, familyKey string, families ArtifactFamilyCatalog, owners map[string][]string, party ResolvedParty) []EffectivePipelineSourceRecord {
|
|
for _, source := range generatedArtifactSources(path, familyKey, families, owners) {
|
|
role := "family"
|
|
if source == pipelineDefaultOwnershipSource {
|
|
role = "default"
|
|
}
|
|
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: role, Source: normalizedProvenanceSource(source)})
|
|
}
|
|
memberPath := strings.TrimPrefix(path, "scriptorium.artifacts.")
|
|
memberKey, _, _ := strings.Cut(memberPath, ".")
|
|
for _, source := range partyCharacterSources(party, families.Members[memberKey].CharacterID) {
|
|
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: "party", Source: normalizedProvenancePath(source)})
|
|
}
|
|
return records
|
|
}
|
|
|
|
func generatedArtifactSources(path, familyKey string, families ArtifactFamilyCatalog, owners map[string][]string) []string {
|
|
const artifactPrefix = "scriptorium.artifacts."
|
|
memberPath := strings.TrimPrefix(path, artifactPrefix)
|
|
_, suffix, _ := strings.Cut(memberPath, ".")
|
|
familyPrefix := "scriptorium.artifact_families." + familyKey + "."
|
|
candidates := []string{familyPrefix + suffix}
|
|
switch {
|
|
case suffix == "output_path":
|
|
candidates = []string{familyPrefix + "output_path_pattern"}
|
|
case suffix == "depends_on":
|
|
candidates = []string{path, familyPrefix + "depends_on", familyPrefix + "member_dependencies"}
|
|
case strings.HasPrefix(suffix, "vars."):
|
|
variable := strings.TrimPrefix(suffix, "vars.")
|
|
candidates = []string{familyPrefix + "vars." + variable, familyPrefix + "member_vars." + variable}
|
|
}
|
|
sources := sourcesForPipelinePaths(owners, candidates)
|
|
if len(sources) != 0 {
|
|
return sources
|
|
}
|
|
if family, ok := families.Families[familyKey]; ok && len(family.Sources) != 0 {
|
|
return append([]string(nil), family.Sources...)
|
|
}
|
|
return []string{pipelineDefaultOwnershipSource}
|
|
}
|
|
|
|
func sourcesForPipelinePaths(owners map[string][]string, paths []string) []string {
|
|
seen := make(map[string]struct{})
|
|
var sources []string
|
|
for _, path := range paths {
|
|
for _, source := range owners[path] {
|
|
if _, exists := seen[source]; exists {
|
|
continue
|
|
}
|
|
seen[source] = struct{}{}
|
|
sources = append(sources, source)
|
|
}
|
|
}
|
|
return sources
|
|
}
|
|
|
|
func appendPipelineOwners(records []EffectivePipelineSourceRecord, path string, sources []string, cfg *PipelineConfig) []EffectivePipelineSourceRecord {
|
|
if len(sources) == 0 {
|
|
sources = []string{pipelineDefaultOwnershipSource}
|
|
}
|
|
for _, source := range sources {
|
|
records = append(records, EffectivePipelineSourceRecord{
|
|
Path: path, Role: pipelineSourceRole(cfg, source), Source: normalizedProvenanceSource(source),
|
|
})
|
|
}
|
|
return records
|
|
}
|
|
|
|
func appendPublishOutputSources(records []EffectivePipelineSourceRecord, cfg *PipelineConfig, families ArtifactFamilyCatalog, party ResolvedParty, owners map[string][]string) []EffectivePipelineSourceRecord {
|
|
if cfg == nil || cfg.Publish == nil {
|
|
return records
|
|
}
|
|
generated := make(map[string]string)
|
|
for familyKey, family := range families.Families {
|
|
if family.Publish == nil || !family.Publish.Enabled {
|
|
continue
|
|
}
|
|
for _, key := range family.Members {
|
|
generated["narratio.artifact."+key] = familyKey
|
|
}
|
|
}
|
|
for index, output := range cfg.Publish.Outputs {
|
|
path := fmt.Sprintf("publish.outputs[%d]", index)
|
|
if familyKey, ok := generated[strings.TrimSpace(output.Source)]; ok {
|
|
records = appendGeneratedPublishSources(records, path, familyKey, families, owners, party)
|
|
continue
|
|
}
|
|
records = appendPipelineOwners(records, path, owners["publish.outputs"], cfg)
|
|
}
|
|
return records
|
|
}
|
|
|
|
func appendGeneratedPublishSources(records []EffectivePipelineSourceRecord, path, familyKey string, families ArtifactFamilyCatalog, owners map[string][]string, party ResolvedParty) []EffectivePipelineSourceRecord {
|
|
familyPrefix := "scriptorium.artifact_families." + familyKey + ".publish."
|
|
sources := sourcesForPipelinePaths(owners, []string{familyPrefix + "enabled", familyPrefix + "required", familyPrefix + "dest_pattern"})
|
|
if len(sources) == 0 {
|
|
if family, ok := families.Families[familyKey]; ok && len(family.Sources) != 0 {
|
|
sources = append([]string(nil), family.Sources...)
|
|
} else {
|
|
sources = []string{pipelineDefaultOwnershipSource}
|
|
}
|
|
}
|
|
for _, source := range sources {
|
|
role := "family"
|
|
if source == pipelineDefaultOwnershipSource {
|
|
role = "default"
|
|
}
|
|
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: role, Source: normalizedProvenanceSource(source)})
|
|
}
|
|
if source := normalizedProvenancePath(party.Source.Path); source != "" {
|
|
records = append(records, EffectivePipelineSourceRecord{Path: path, Role: "party", Source: source})
|
|
}
|
|
return records
|
|
}
|
|
|
|
func pipelineSourceRole(cfg *PipelineConfig, source string) string {
|
|
if source == pipelineDefaultOwnershipSource {
|
|
return "default"
|
|
}
|
|
if source == "resolution" {
|
|
return "resolution"
|
|
}
|
|
if cfg == nil || cfg.resolution == nil {
|
|
return "pipeline"
|
|
}
|
|
if source == cfg.resolution.rootPath {
|
|
return "root"
|
|
}
|
|
if cfg.resolution.selectedOverlay != nil && source == cfg.resolution.selectedOverlay.overlayPath {
|
|
return "overlay"
|
|
}
|
|
for _, imported := range cfg.resolution.imports {
|
|
if source == imported {
|
|
return "import"
|
|
}
|
|
}
|
|
return "pipeline"
|
|
}
|
|
|
|
func normalizedProvenanceSource(source string) string {
|
|
if source == pipelineDefaultOwnershipSource || source == "resolution" {
|
|
return source
|
|
}
|
|
return normalizedProvenancePath(source)
|
|
}
|
|
|
|
func normalizedProvenancePath(path string) string {
|
|
if strings.TrimSpace(path) == "" {
|
|
return ""
|
|
}
|
|
abs, err := filepath.Abs(path)
|
|
if err != nil {
|
|
return filepath.Clean(path)
|
|
}
|
|
return filepath.Clean(abs)
|
|
}
|
|
|
|
func campaignInputSourcePath(campaignPath, configuredPath string) string {
|
|
if filepath.IsAbs(configuredPath) {
|
|
return normalizedProvenancePath(configuredPath)
|
|
}
|
|
return normalizedProvenancePath(filepath.Join(filepath.Dir(campaignPath), configuredPath))
|
|
}
|