package app import ( "context" "crypto/sha256" "encoding/hex" "errors" "fmt" "os" "path/filepath" "strings" "gitea.maximumdirect.net/eric/narratio/internal/adapters/storage" "gitea.maximumdirect.net/eric/narratio/internal/artifacts" "gitea.maximumdirect.net/eric/narratio/internal/config" "gitea.maximumdirect.net/eric/narratio/internal/fileops" ) type pipelineCampaignConfig = config.LoadedPipelineCampaign type commandConfig struct { Config *config.Config cleanup func() error } func (c *commandConfig) Close() error { if c == nil || c.cleanup == nil { return nil } cleanup := c.cleanup c.cleanup = nil return cleanup() } func retainedCommandConfig(cfg *config.Config) *commandConfig { return &commandConfig{Config: cfg} } func loadCommandConfigWithDependencies(ctx context.Context, pipelineFlag, campaignFlag, campaignFileFlag, sessionFlag string, sessionOpts config.SessionLoadOptions, secretsDir *string, deps commandDependencies) (loaded *commandConfig, err error) { deps = normalizeCommandDependencies(deps) var cleanup func() error defer func() { if err == nil || cleanup == nil { return } if cleanupErr := cleanup(); cleanupErr != nil { err = errors.Join(err, cleanupErr) } }() base, err := loadPipelineCampaignConfigWithDependencies(pipelineFlag, campaignFlag, campaignFileFlag, config.PipelineLoadOptions{Overlay: sessionOpts.Overlay}, secretsDir, deps) if err != nil { return nil, err } if explicitSession := strings.TrimSpace(sessionFlag); explicitSession != "" { cfg, err := config.LoadSessionWithPipelineCampaignOptions(*base, explicitSession, sessionOpts) if err != nil { return nil, err } return retainedCommandConfig(cfg), nil } discoveredSession, discoveredPath, err := config.DiscoverSession(config.DefaultSessionConfigSearchPaths, sessionOpts) if err != nil { return nil, err } if discoveredSession != nil { cfg, err := config.ResolveLoadedPipelineCampaign(*base, discoveredPath, discoveredSession, config.SessionSource{Source: "session_config", LocalPath: discoveredPath}) if err != nil { return nil, err } return retainedCommandConfig(cfg), nil } sessionID := strings.TrimSpace(sessionOpts.SessionID) if sessionID == "" { return nil, missingSessionConfigError(config.DefaultSessionConfigSearchPaths, "remote session loading requires a session_id") } rootPrefix := "" if base.Pipeline.Storage.S3 != nil { rootPrefix = base.Pipeline.Storage.S3.RootPrefix } sessionPrefix := artifacts.S3SessionPrefix(rootPrefix, config.CampaignID(base.Campaign), sessionID) remoteKey := artifacts.S3SessionConfigKey(sessionPrefix) partialCfg, err := config.ResolveLoadedPipelineCampaign(*base, "", nil, config.SessionSource{}) if err != nil { return nil, err } store, err := newCommandObjectStoreWithDependencies(ctx, partialCfg, nil, deps) if err != nil { return nil, missingSessionConfigError(config.DefaultSessionConfigSearchPaths, fmt.Sprintf("remote session %q unavailable: %v", remoteKey, err)) } sessionInfo, checksum, err := findRemoteSessionConfig(ctx, store, sessionPrefix, remoteKey, config.CampaignID(base.Campaign), sessionID) if err != nil { return nil, missingSessionConfigError(config.DefaultSessionConfigSearchPaths, err.Error()) } remoteKey = sessionInfo.Key sessionTempPath, err := deps.downloadObjectToTemp(ctx, store, remoteKey, "narratio-session-*.yml") if err != nil { return nil, missingSessionConfigError(config.DefaultSessionConfigSearchPaths, fmt.Sprintf("remote session %q download failed: %v", remoteKey, err)) } cleanup = func() error { if err := fileops.RemoveAllUnderRoot(filepath.Dir(sessionTempPath), sessionTempPath); err != nil { return fmt.Errorf("remove downloaded remote session config: %w", err) } return nil } sessionBytes, err := os.ReadFile(sessionTempPath) if err != nil { return nil, fmt.Errorf("read downloaded remote session config: %w", err) } if checksum != "" { digest := sha256.Sum256(sessionBytes) if !strings.EqualFold(hex.EncodeToString(digest[:]), checksum) || int64(len(sessionBytes)) != sessionInfo.Size { return nil, fmt.Errorf("remote session %q does not match its committed checksum or size", remoteKey) } } sessionCfg, err := config.LoadSessionBytesWithOptions("s3://"+s3BucketName(base.Pipeline)+"/"+remoteKey, sessionBytes, sessionOpts) if err != nil { return nil, err } cfg, err := config.ResolveLoadedPipelineCampaign( *base, sessionTempPath, sessionCfg, config.SessionSource{ Source: "session_config.s3", LocalPath: sessionTempPath, S3Bucket: s3BucketName(base.Pipeline), S3Key: remoteKey, S3Size: sessionInfo.Size, S3ETag: sessionInfo.ETag, }, ) if err != nil { return nil, err } loaded = &commandConfig{Config: cfg, cleanup: cleanup} cleanup = nil return loaded, nil } func loadPipelineCampaignConfigWithDependencies(pipelineFlag, campaignFlag, campaignFileFlag string, pipelineOpts config.PipelineLoadOptions, secretsDir *string, deps commandDependencies) (*pipelineCampaignConfig, error) { deps = normalizeCommandDependencies(deps) loadedPipelinePath, pipelineCfg, err := loadPipelineConfigWithDependencies(pipelineFlag, pipelineOpts, secretsDir, deps) if err != nil { return nil, err } resolvedCampaignPath, err := resolveCampaignConfigPath(pipelineCfg, campaignFlag, campaignFileFlag) if err != nil { return nil, err } campaignCfg, err := config.LoadCampaign(resolvedCampaignPath) if err != nil { return nil, err } if selectedID := strings.TrimSpace(campaignFlag); selectedID != "" && strings.TrimSpace(campaignFileFlag) == "" { if got := config.CampaignID(campaignCfg); got != selectedID { return nil, fmt.Errorf("campaign config %q invalid: campaign_id %q does not match selected campaign %q", resolvedCampaignPath, got, selectedID) } } loaded, err := config.LoadPipelineCampaign(loadedPipelinePath, pipelineCfg, resolvedCampaignPath, campaignCfg) if err != nil { return nil, err } return &loaded, nil } func loadPipelineConfigWithDependencies(pipelineFlag string, opts config.PipelineLoadOptions, secretsDir *string, deps commandDependencies) (string, *config.PipelineConfig, error) { deps = normalizeCommandDependencies(deps) if !deps.secretsBootstrap.selectionSet { deps.secretsBootstrap.selection = secretsDir deps.secretsBootstrap.selectionSet = true } if err := deps.secretsBootstrap.load(deps.loadSecretsDir, deps.diagnostics); err != nil { return "", nil, err } opts.Search = deps.pipelineSearch pipelineCfg, err := deps.loadPipelineConfig(strings.TrimSpace(pipelineFlag), opts) if err != nil { return "", nil, err } resolvedPipelinePath := config.EffectivePipelineRootPath(pipelineCfg) if resolvedPipelinePath == "" { resolvedPipelinePath = strings.TrimSpace(pipelineFlag) } return resolvedPipelinePath, pipelineCfg, nil } func findRemoteSessionConfig(ctx context.Context, store storage.ObjectStore, sessionPrefix, remoteKey, campaign, sessionID string) (storage.ObjectInfo, string, error) { authored, err := store.Exists(ctx, remoteKey) if err != nil { return storage.ObjectInfo{}, "", fmt.Errorf("check authored session %q: %w", remoteKey, err) } var selected *artifacts.RemoteArtifact if !authored { current, err := artifacts.LoadCurrentState(ctx, store, sessionPrefix, artifacts.CurrentStateValidation{ExpectedCampaign: campaign, ExpectedSessionID: sessionID, ValidateRunID: true}) if err == nil { for _, item := range current.Commit.Artifacts { if item.Type == artifacts.RemoteArtifactTypeRunFile && item.Source == "run:prepare/inputs/session.yml" { identity, err := artifacts.ParseImmutableRunObjectKey(sessionPrefix, item.DestinationKey) if err != nil || "run:"+identity.RelativePath != item.Source { return storage.ObjectInfo{}, "", fmt.Errorf("committed session source does not match its object key") } copy := item selected = © remoteKey = item.DestinationKey break } } } else if !errors.Is(err, artifacts.ErrCurrentCommitPointerMissing) { return storage.ObjectInfo{}, "", fmt.Errorf("load remote session selection: %w", err) } } objects, err := store.List(ctx, sessionPrefix) if err != nil { return storage.ObjectInfo{}, "", fmt.Errorf("remote session %q list failed: %w", remoteKey, err) } for _, obj := range objects { if obj.Key == remoteKey { if selected != nil { if obj.Size != selected.Size || strings.TrimSpace(obj.ETag) != selected.Generation { return storage.ObjectInfo{}, "", fmt.Errorf("remote session %q differs from committed object identity", remoteKey) } return obj, selected.SHA256, nil } return obj, "", nil } } return storage.ObjectInfo{}, "", fmt.Errorf("remote session %q not found", remoteKey) } func s3BucketName(cfg *config.PipelineConfig) string { if cfg == nil || cfg.Storage.S3 == nil { return "" } return strings.TrimSpace(cfg.Storage.S3.Bucket) }