Files
narratio/internal/app/configuration_acquisition.go

299 lines
9.0 KiB
Go

package app
import (
"context"
"errors"
"fmt"
"path/filepath"
"strings"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"go.maximumdirect.net/commandkit"
configkit "go.maximumdirect.net/configkit"
)
// configurationAcquisition belongs to one parsed selection, including one side
// of a comparison. It acquires only reached documents and retains native results.
type configurationAcquisition struct {
selection configurationSelection
deps commandDependencies
pipeline *config.PipelineConfig
pipelinePath string
campaign *config.CampaignConfig
campaignPath string
party *config.ResolvedParty
session *acquiredSession
previousSessionID string
domain *config.Config
catalog *config.ArtifactCatalog
pipelineOverrides []configkit.Override
}
func newConfigurationAcquisition(selection configurationSelection, deps commandDependencies) *configurationAcquisition {
return &configurationAcquisition{selection: selection, deps: normalizeCommandDependencies(deps)}
}
func selectedString(value commandkit.Supplied[string]) *string {
if !value.Set {
return nil
}
result := value.Value
return &result
}
func checkConfigurationSelection(selection configurationSelection) error {
for _, field := range []struct {
name string
value commandkit.Supplied[string]
}{
{"config", selection.Config}, {"campaign", selection.Campaign},
{"campaign-file", selection.CampaignFile}, {"session", selection.Session},
{"session-file", selection.SessionFile}, {"party-file", selection.PartyFile},
{"secrets-dir", selection.SecretsDir},
} {
if field.value.Set && strings.TrimSpace(field.value.Value) == "" {
return &inputError{message: fmt.Sprintf("--%s requires a non-empty value", field.name)}
}
}
return nil
}
func (a *configurationAcquisition) bootstrap(ctx context.Context) error {
if err := ctx.Err(); err != nil {
return err
}
if err := checkConfigurationSelection(a.selection); err != nil {
return err
}
if !a.deps.secretsBootstrap.selectionSet {
a.deps.secretsBootstrap.selection = selectedString(a.selection.SecretsDir)
a.deps.secretsBootstrap.selectionSet = true
}
return errors.Join(a.deps.secretsBootstrap.load(a.deps.loadSecretsDir, a.deps.diagnostics), ctx.Err())
}
func (a *configurationAcquisition) Pipeline(ctx context.Context) (*config.PipelineConfig, error) {
if err := a.bootstrap(ctx); err != nil {
return nil, err
}
if a.pipeline != nil {
return a.pipeline, nil
}
path, cfg, err := loadPipelineConfigWithDependencies(a.selection.Config.Value,
config.PipelineLoadOptions{Overlay: selectedString(a.selection.Overlay), Overrides: a.pipelineOverrides},
selectedString(a.selection.SecretsDir), a.deps)
err = errors.Join(err, ctx.Err())
if err != nil {
return nil, err
}
a.pipeline, a.pipelinePath = cfg, path
if a.deps.reporter != nil {
a.deps.reporter.Info("selected pipeline configuration", "source", path, "overlay", a.selection.Overlay.Value)
}
return cfg, nil
}
func (a *configurationAcquisition) Campaign(ctx context.Context) (*config.CampaignConfig, error) {
if err := a.bootstrap(ctx); err != nil {
return nil, err
}
if a.campaign != nil {
return a.campaign, nil
}
path := a.selection.CampaignFile.Value
if !a.selection.CampaignFile.Set {
pipeline, err := a.Pipeline(ctx)
if err != nil {
return nil, err
}
path, err = resolveCampaignConfigPath(pipeline, a.selection.Campaign.Value, "")
if err != nil {
return nil, err
}
}
path, err := filepath.Abs(path)
if err != nil {
return nil, err
}
cfg, err := config.LoadCampaignWithIdentity(path, a.selection.Campaign.Value)
err = errors.Join(err, ctx.Err())
if err != nil {
return nil, err
}
a.campaign, a.campaignPath = cfg, path
if a.deps.reporter != nil {
a.deps.reporter.Info("selected campaign configuration", "campaign", config.CampaignID(cfg), "source", path)
}
return cfg, nil
}
func (a *configurationAcquisition) Party(ctx context.Context) (*config.ResolvedParty, error) {
if err := a.bootstrap(ctx); err != nil {
return nil, err
}
if a.party != nil {
return a.party, nil
}
var campaign *config.CampaignConfig
if !a.selection.PartyFile.Set {
var err error
campaign, err = a.Campaign(ctx)
if err != nil {
return nil, err
}
}
party, err := config.ResolveParty(a.campaignPath, campaign, selectedString(a.selection.PartyFile))
err = errors.Join(err, ctx.Err())
if err != nil {
return nil, err
}
a.party = &party
if a.deps.reporter != nil {
a.deps.reporter.Info("selected party configuration", "source", party.Source.Path)
}
return a.party, nil
}
func (a *configurationAcquisition) Session(ctx context.Context) (*config.SessionConfig, error) {
if err := a.bootstrap(ctx); err != nil {
return nil, err
}
if a.session != nil {
return a.session.Config, nil
}
campaign, err := a.Campaign(ctx)
if err != nil {
return nil, err
}
base := &config.LoadedPipelineCampaign{Campaign: campaign, CampaignPath: a.campaignPath}
opts := config.SessionLoadOptions{Campaign: campaign, CampaignPath: a.campaignPath, SessionID: a.selection.Session.Value, PreviousSessionID: a.previousSessionID}
// Local inspection needs no pipeline or derived catalog. Remote discovery
// acquires storage configuration only after local absence is established.
if a.selection.SessionFile.Set {
path, err := filepath.Abs(a.selection.SessionFile.Value)
if err != nil {
return nil, err
}
session, err := config.LoadSessionWithOptions(path, opts)
err = errors.Join(err, ctx.Err())
if err != nil {
return nil, err
}
a.session = &acquiredSession{Config: session, Path: path, Source: config.SessionSource{Source: "session_config", LocalPath: path}}
if a.deps.reporter != nil {
a.deps.reporter.Info("selected session configuration", "session", session.SessionID, "source", path)
}
return session, nil
}
session, path, err := config.DiscoverSession(config.DefaultSessionConfigSearchPaths, opts)
err = errors.Join(err, ctx.Err())
if err != nil {
return nil, err
}
if session != nil {
if err := ctx.Err(); err != nil {
return nil, err
}
a.session = &acquiredSession{Config: session, Path: path, Source: config.SessionSource{Source: "session_config", LocalPath: path}}
if a.deps.reporter != nil {
a.deps.reporter.Info("selected session configuration", "session", session.SessionID, "source", path)
}
return session, nil
}
if a.selection.Session.Value == "" {
return nil, missingSessionConfigError(config.DefaultSessionConfigSearchPaths, "remote session loading requires a session identity")
}
pipeline, err := a.Pipeline(ctx)
if err != nil {
return nil, err
}
base.Pipeline, base.PipelinePath = pipeline, a.pipelinePath
loaded, err := loadRemoteSessionConfig(ctx, base, opts, a.deps)
err = errors.Join(err, ctx.Err())
if err != nil {
if loaded != nil && loaded.cleanup != nil {
err = errors.Join(err, loaded.cleanup())
}
return nil, err
}
a.session = loaded
if a.deps.reporter != nil {
a.deps.reporter.Info("selected session configuration", "session", loaded.Config.SessionID, "source", loaded.Source.Source, "key", loaded.Source.S3Key)
}
if err := ctx.Err(); err != nil {
return nil, errors.Join(err, a.Close())
}
return loaded.Config, nil
}
func (a *configurationAcquisition) Domain(ctx context.Context) (*config.Config, error) {
if err := a.bootstrap(ctx); err != nil {
return nil, err
}
if a.domain != nil {
return a.domain, nil
}
pipeline, err := a.Pipeline(ctx)
if err != nil {
return nil, err
}
campaign, err := a.Campaign(ctx)
if err != nil {
return nil, err
}
session, err := a.Session(ctx)
if err != nil {
return nil, err
}
party, err := a.Party(ctx)
if err != nil {
return nil, err
}
catalog, err := a.Catalog(ctx)
if err != nil {
return nil, err
}
base := config.LoadedPipelineCampaign{PipelinePath: a.pipelinePath, Pipeline: pipeline, CampaignPath: a.campaignPath, Campaign: campaign, Party: *party, ArtifactCatalog: catalog}
cfg, err := config.ResolveLoadedPipelineCampaign(base, a.session.Path, session, a.session.Source)
err = errors.Join(err, ctx.Err())
if err != nil {
return nil, err
}
a.domain = cfg
return cfg, nil
}
func (a *configurationAcquisition) Close() error {
if a.session == nil || a.session.cleanup == nil {
return nil
}
cleanup := a.session.cleanup
a.session.cleanup = nil
return cleanup()
}
func (a *configurationAcquisition) Catalog(ctx context.Context) (*config.ArtifactCatalog, error) {
pipeline, err := a.Pipeline(ctx)
if err != nil {
return nil, err
}
if a.catalog != nil {
return a.catalog, nil
}
var party config.ResolvedParty
if a.party != nil || a.selection.PartyFile.Set || a.selection.Campaign.Set || a.selection.CampaignFile.Set || (pipeline.Scriptorium != nil && len(pipeline.Scriptorium.ArtifactFamilies) != 0) {
selected, err := a.Party(ctx)
if err != nil {
return nil, err
}
party = *selected
}
catalog, err := config.DeriveArtifactCatalog(pipeline, party)
err = errors.Join(err, ctx.Err())
if err != nil {
return nil, err
}
a.catalog = catalog
return catalog, nil
}