Files
narratio/internal/app/session_state_command.go

309 lines
12 KiB
Go

package app
import (
"context"
"errors"
"sort"
"strings"
"gitea.maximumdirect.net/eric/narratio/internal/adapters/storage"
"gitea.maximumdirect.net/eric/narratio/internal/artifactpolicy"
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"gitea.maximumdirect.net/eric/narratio/internal/manifest"
"go.maximumdirect.net/commandkit"
)
type sessionStateReport struct {
Campaign string `json:"campaign"`
SessionID string `json:"session_id"`
SessionSource string `json:"session_source,omitempty"`
LocalManifest string `json:"local_manifest"`
Stages []sessionStageState `json:"stages"`
Artifacts []sessionArtifactState `json:"artifacts"`
Remote *sessionRemoteState `json:"remote,omitempty"`
Configuration string `json:"configuration"`
PersistedConfiguration string `json:"persisted_configuration,omitempty"`
LocalAudio *sessionAudioState `json:"local_audio,omitempty"`
RemoteAudio *sessionAudioState `json:"remote_audio,omitempty"`
Previous []sessionPreviousState `json:"previous_artifacts,omitempty"`
Findings []finding `json:"findings"`
}
type sessionAudioState struct {
State string `json:"state"`
Count int `json:"count"`
Prefix string `json:"prefix,omitempty"`
}
type sessionPreviousState struct {
Name string `json:"name"`
Required bool `json:"required"`
State string `json:"state"`
}
type sessionStageState struct {
Name string `json:"name"`
Status string `json:"status"`
SkipReason string `json:"skip_reason,omitempty"`
}
type sessionArtifactState struct {
artifactDefinitionReport
Availability string `json:"availability"`
Provenance string `json:"provenance,omitempty"`
}
type sessionRemoteState struct {
State string `json:"state"`
RunID string `json:"run_id,omitempty"`
ManifestKey string `json:"manifest_key,omitempty"`
Locks []sessionLockState `json:"locks"`
Outputs []sessionPublishedOutput `json:"outputs"`
}
type sessionLockState struct {
Source string `json:"source"`
Reason string `json:"reason,omitempty"`
}
type sessionPublishedOutput struct {
Source string `json:"source"`
Destination string `json:"destination"`
Required bool `json:"required"`
State string `json:"state"`
LockState string `json:"lock_state"`
Outcome string `json:"outcome,omitempty"`
DeclaredDestination string `json:"declared_destination,omitempty"`
DeclaredKey string `json:"declared_key,omitempty"`
OriginRun string `json:"origin_run,omitempty"`
Error string `json:"error,omitempty"`
}
func sessionStateCommand(name string, status bool, deps commandDependencies) commandkit.Command {
spec := sessionInspectionSpec(name, "Inspect session state without changing it.", !status)
spec.Run = func(invocation commandkit.Invocation, input *sessionInspectionInput) commandkit.Outcome {
report, err := inspectSelectedSessionState(invocation.Context, input, status, withCommandReporting(deps, invocation))
if report != nil {
err = errors.Join(err, invocation.Reporter().Report(commandkit.Report{Value: report}))
}
return operationOutcome(err)
}
return commandkit.NewCommand(spec)
}
func inspectSelectedSessionState(ctx context.Context, input *sessionInspectionInput, status bool, deps commandDependencies) (report *sessionStateReport, err error) {
deps = normalizeCommandDependencies(deps)
deps.secretsBootstrap = &secretsBootstrap{}
acquired := newConfigurationAcquisition(input.Selection, deps)
acquired.previousSessionID = input.PreviousSession.Value
defer func() { err = errors.Join(err, acquired.Close()) }()
report = &sessionStateReport{Campaign: input.Selection.Campaign.Value, SessionID: input.Selection.Session.Value, LocalManifest: "not_checked", Stages: []sessionStageState{}, Artifacts: []sessionArtifactState{}, Findings: []finding{}}
cfg, err := acquired.Domain(ctx)
if err != nil {
report.Findings = append(report.Findings, errorFinding("config", err.Error()))
return report, err
}
return inspectSessionState(ctx, cfg, status, status || input.Remote.Value, deps)
}
func inspectSessionState(ctx context.Context, cfg *config.Config, status, remote bool, deps commandDependencies) (*sessionStateReport, error) {
report := &sessionStateReport{Campaign: cfg.Session.Campaign, SessionID: cfg.Session.SessionID, SessionSource: sessionSourceSummary(cfg), LocalManifest: "missing", Stages: []sessionStageState{}, Artifacts: []sessionArtifactState{}, Findings: []finding{}}
var resultErr error
fail := func(category string, err error) {
if err != nil {
report.Findings = append(report.Findings, errorFinding(category, err.Error()))
resultErr = errors.Join(resultErr, err)
}
}
if err := config.Validate(cfg); err != nil {
fail("config", err)
return report, resultErr
}
report.Configuration = effectiveConfigSummary(cfg)
paths := artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root).SessionPathsFor(cfg.Session.Campaign, cfg.Session.SessionID)
local, err := loadLocalManifest(ctx, paths.ManifestPath)
if err != nil {
report.LocalManifest = "error"
fail("manifest", err)
} else if local != nil {
report.LocalManifest = "present"
report.PersistedConfiguration = persistedEffectiveConfigSummary(local.EffectiveConfig)
names := make([]string, 0, len(local.Stages))
for name := range local.Stages {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
record := local.Stages[name]
if record != nil {
report.Stages = append(report.Stages, sessionStageState{Name: name, Status: string(record.Status), SkipReason: inspectionSkipReason(record)})
}
}
}
catalog, catalogErr := buildHelperArtifactCatalog(cfg, local)
fail("artifacts", catalogErr)
definitions, definitionsErr := describeArtifactDefinitions(cfg.Pipeline, cfg.ArtifactCatalog)
fail("artifacts", definitionsErr)
if catalogErr == nil && definitionsErr == nil {
for _, definition := range definitions.Artifacts {
entry, _ := catalog.Lookup(definition.Source)
state := "unavailable"
if entry.Available {
state = "available"
}
if definition.Key == "" {
state = builtinArtifactInspectionState(local, entry)
}
report.Artifacts = append(report.Artifacts, sessionArtifactState{artifactDefinitionReport: definition, Availability: state, Provenance: entry.Provenance})
}
}
var store storage.ObjectStore
if remote {
report.Remote = &sessionRemoteState{State: "not_configured", Locks: []sessionLockState{}, Outputs: []sessionPublishedOutput{}}
store, err = objectStoreIfConfiguredWithDependencies(ctx, cfg, deps)
if err != nil {
report.Remote.State = "error"
fail("storage", err)
} else if store != nil {
current := inspectRemoteCurrentStateWithDependencies(ctx, cfg, store, deps)
if current.Err != nil {
if errors.Is(current.Err, artifacts.ErrCurrentCommitPointerMissing) {
report.Remote.State = "missing"
} else {
report.Remote.State = "error"
fail("remote", current.Err)
}
} else if current.State != nil {
report.Remote.State = "current"
report.Remote.RunID = current.State.RunID
report.Remote.ManifestKey = current.State.CurrentManifestKey
}
locks := inspectRemoteLocks(ctx, cfg, store)
fail("locks", locks.Err)
for _, lock := range locks.Locks {
report.Remote.Locks = append(report.Remote.Locks, sessionLockState{Source: lock.Source, Reason: lock.Reason})
}
if catalogErr == nil {
outputs, err := inspectPublishedOutputs(ctx, cfg, store, catalog, current.State, locks.Locks, locks.Err == nil, report.Remote.State)
report.Remote.Outputs = outputs
fail("publication", err)
}
}
}
if status {
for _, check := range inspectStableInputs(cfg) {
if check.Err != nil {
fail("inputs", check.Err)
} else {
report.Findings = append(report.Findings, infoFinding("inputs", check.Name+": "+check.Path))
}
}
audio := inspectLocalAudioPresence(cfg)
if audio.Checked {
report.LocalAudio = &sessionAudioState{State: "available", Count: len(audio.Paths)}
if audio.Err != nil {
report.LocalAudio.State = "unavailable"
fail("audio", audio.Err)
}
}
if cfg.Session.Inputs.AudioS3 != nil {
report.RemoteAudio = &sessionAudioState{State: "unavailable"}
if store != nil {
audio := inspectRemoteAudioPresence(ctx, cfg, store)
report.RemoteAudio.Count = len(audio.Keys)
report.RemoteAudio.Prefix = audio.Prefix
if audio.Err == nil {
report.RemoteAudio.State = "available"
} else {
fail("audio", audio.Err)
}
}
}
effective, err := resolveEffectiveArtifacts(cfg, nil)
fail("artifacts", err)
if err == nil {
previous := inspectPreviousArtifactReadiness(ctx, cfg, store, artifacts.CollectPreviousArtifactRequirements(configuredScriptoriumArtifacts(cfg), effective))
fail("previous", previous.Err)
for _, requirement := range previous.Requirements {
state := "ready"
if previous.Err != nil || previousRequirementSkipped(previous.SkippedMissing, requirement.Name) {
state = "unavailable"
}
report.Previous = append(report.Previous, sessionPreviousState{Name: requirement.Name, Required: requirement.Required, State: state})
}
}
}
return report, resultErr
}
// Built-in inspection reports manifest evidence without opening artifact payloads.
func builtinArtifactInspectionState(local *manifest.Manifest, entry artifacts.CatalogEntry) string {
if local == nil {
return "unavailable"
}
record := local.Stages[entry.ProducerStage]
if record == nil || record.Status != manifest.StatusSucceeded {
return "unavailable"
}
for _, output := range record.Outputs {
if output.Kind == entry.OutputKind {
return "recorded"
}
}
return "unavailable"
}
func inspectPublishedOutputs(ctx context.Context, cfg *config.Config, store storage.ObjectStore, catalog *artifacts.ArtifactCatalog, current *RemoteCurrentState, locks []artifacts.RemoteLock, locksKnown bool, remoteState string) ([]sessionPublishedOutput, error) {
rules := cfg.PublicationOutputs()
outputs := make([]sessionPublishedOutput, 0, len(rules))
locked := remoteLockSourceSet(locks)
configuredOutputs := helperConfiguredOutputPathMap(catalog)
extractionOutputs := helperExtractionOutputSet(catalog)
var declarations map[string]artifacts.RemoteArtifact
outcomes := map[string]string{}
if current != nil {
outcomes = committedPublishOutputOutcomes(current.Manifest)
declarations = committedPublishedOutputs(current.Commit)
}
var resultErr error
for _, rule := range rules {
destination, err := artifactpolicy.ResolvePublishedDestinationWithExtractions(strings.TrimSpace(rule.Source), rule.Dest, configuredOutputs, extractionOutputs)
_, isLocked := locked[rule.Source]
output := sessionPublishedOutput{Source: rule.Source, Destination: destination, Required: rule.Required == nil || *rule.Required, LockState: "unknown", State: "missing", Outcome: outcomes[rule.Source]}
if locksKnown {
output.LockState = "unlocked"
if isLocked {
output.LockState = "locked"
}
}
if remoteState == "error" {
output.State = "error"
}
if err == nil && current != nil && current.Commit != nil {
if declaration, ok := declarations[rule.Source]; ok {
identity, identityErr := artifacts.ParsePublishedOutputObjectKey(current.SessionPrefix, declaration.DestinationKey)
if identityErr != nil {
err = identityErr
} else {
output.DeclaredDestination = identity.Destination
output.DeclaredKey = declaration.DestinationKey
output.OriginRun = identity.RunID
exists, existsErr := store.Exists(ctx, declaration.DestinationKey)
err = existsErr
if exists && err == nil {
output.State = "published"
}
}
}
}
if err != nil {
output.State = "error"
output.Error = err.Error()
resultErr = errors.Join(resultErr, err)
}
outputs = append(outputs, output)
}
return outputs, resultErr
}
func inspectionSkipReason(record *manifest.StageRecord) string {
if record.Status == manifest.StatusSkipped && record.Error != nil {
return record.Error.Message
}
return ""
}