120 lines
3.3 KiB
Go
120 lines
3.3 KiB
Go
package app
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
|
|
"gitea.maximumdirect.net/eric/narratio/internal/config"
|
|
"gitea.maximumdirect.net/eric/narratio/internal/manifest"
|
|
)
|
|
|
|
func buildHelperArtifactCatalog(cfg *config.Config, m *manifest.Manifest) (*artifacts.ArtifactCatalog, error) {
|
|
configured := artifacts.ConfiguredArtifactDefinitions(nil)
|
|
if cfg.Pipeline.Scriptorium != nil {
|
|
configured = artifacts.ConfiguredArtifactDefinitions(cfg.ConcreteArtifacts())
|
|
}
|
|
extractionDefinitions := artifacts.ExtractionDefinitionsFromConfig(cfg.Pipeline.Notarius)
|
|
effective, err := artifacts.ResolveEffectiveArtifactSet(configured, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
catalog, err := artifacts.BootstrapRuntimeCatalog(configured, effective, extractionDefinitions)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
paths := artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root).SessionPathsFor(cfg.Session.Campaign, cfg.Session.SessionID)
|
|
if cfg.Pipeline.Notarius != nil && cfg.Pipeline.Notarius.Enabled {
|
|
catalog.HydrateExtractionArtifacts(paths, m, extractionDefinitions)
|
|
}
|
|
catalog.HydrateAnalyzeArtifacts(paths, m, configured)
|
|
return catalog, nil
|
|
}
|
|
|
|
func remoteLockSourceSet(locks []artifacts.RemoteLock) map[string]struct{} {
|
|
out := make(map[string]struct{}, len(locks))
|
|
for _, lock := range locks {
|
|
out[lock.Source] = struct{}{}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func committedPublishOutputOutcomes(m *manifest.Manifest) map[string]string {
|
|
out := map[string]string{}
|
|
if m == nil || m.Stages["publish"] == nil {
|
|
return out
|
|
}
|
|
raw := m.Stages["publish"].Metadata["publish_output_outcomes"]
|
|
appendOutcome := func(item map[string]any) {
|
|
source, sourceOK := item["source"].(string)
|
|
status, statusOK := item["status"].(string)
|
|
if sourceOK && statusOK && isPublishOutputOutcome(status) {
|
|
out[source] = status
|
|
}
|
|
}
|
|
switch items := raw.(type) {
|
|
case []any:
|
|
for _, rawItem := range items {
|
|
if item, ok := rawItem.(map[string]any); ok {
|
|
appendOutcome(item)
|
|
}
|
|
}
|
|
case []map[string]any:
|
|
for _, item := range items {
|
|
appendOutcome(item)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func isPublishOutputOutcome(status string) bool {
|
|
switch status {
|
|
case "published", "carried_locked", "locked_unpublished", "optional_missing", "unselected":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func committedPublishedOutputs(commit *artifacts.RemoteCommitManifest) map[string]artifacts.RemoteArtifact {
|
|
out := map[string]artifacts.RemoteArtifact{}
|
|
if commit == nil {
|
|
return out
|
|
}
|
|
for _, artifact := range commit.Artifacts {
|
|
if artifact.Type != artifacts.RemoteArtifactTypePublishedOutput {
|
|
continue
|
|
}
|
|
if _, exists := out[artifact.Source]; !exists {
|
|
out[artifact.Source] = artifact
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func helperExtractionOutputSet(catalog *artifacts.ArtifactCatalog) map[string]struct{} {
|
|
out := map[string]struct{}{}
|
|
if catalog == nil {
|
|
return out
|
|
}
|
|
for _, entry := range catalog.ListExtraction() {
|
|
if strings.TrimSpace(entry.ExtractionKey) != "" {
|
|
out[entry.ExtractionKey] = struct{}{}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func helperConfiguredOutputPathMap(catalog *artifacts.ArtifactCatalog) map[string]string {
|
|
out := map[string]string{}
|
|
if catalog == nil {
|
|
return out
|
|
}
|
|
for _, entry := range catalog.ListConfigured() {
|
|
if strings.TrimSpace(entry.ConfiguredKey) == "" {
|
|
continue
|
|
}
|
|
out[entry.ConfiguredKey] = strings.TrimSpace(entry.CanonicalRelPath)
|
|
}
|
|
return out
|
|
}
|