Files
narratio/internal/app/configuration_acquisition.go

260 lines
7.3 KiB
Go
Raw Normal View History

package app
import (
"context"
"errors"
"fmt"
"path/filepath"
"strings"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"go.maximumdirect.net/commandkit"
)
// 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
}
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 a.deps.secretsBootstrap.load(a.deps.loadSecretsDir, a.deps.diagnostics)
}
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)},
selectedString(a.selection.SecretsDir), a.deps)
if err != nil {
return nil, err
}
if err := ctx.Err(); err != nil {
return nil, err
}
a.pipeline, a.pipelinePath = cfg, path
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.LoadCampaign(path)
if err != nil {
return nil, err
}
if err := ctx.Err(); err != nil {
return nil, err
}
if a.selection.Campaign.Set && config.CampaignID(cfg) != a.selection.Campaign.Value {
return nil, &config.SessionIdentityError{Source: path, Field: "campaign_id", Expected: a.selection.Campaign.Value, Actual: config.CampaignID(cfg)}
}
a.campaign, a.campaignPath = cfg, 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))
if err != nil {
return nil, err
}
if err := ctx.Err(); err != nil {
return nil, err
}
a.party = &party
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)
if err != nil {
return nil, err
}
if err := ctx.Err(); err != nil {
return nil, err
}
a.session = &acquiredSession{Config: session, Path: path, Source: config.SessionSource{Source: "session_config", LocalPath: path}}
return session, nil
}
session, path, err := config.DiscoverSession(config.DefaultSessionConfigSearchPaths, opts)
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}}
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)
if err != nil {
if loaded != nil && loaded.cleanup != nil {
err = errors.Join(err, loaded.cleanup())
}
return nil, err
}
a.session = loaded
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
}
base, err := config.LoadPipelineCampaignWithParty(a.pipelinePath, pipeline, a.campaignPath, campaign, *party)
if err != nil {
return nil, err
}
cfg, err := config.ResolveLoadedPipelineCampaign(base, a.session.Path, session, a.session.Source)
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()
}