2026-11-20 05:29:27 +00:00
package app
import (
"context"
"errors"
"fmt"
"strings"
"time"
"gitea.maximumdirect.net/eric/narratio/internal/adapters/storage"
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"go.maximumdirect.net/commandkit"
)
type lockCommandInput struct {
Selection configurationSelection
PreviousSession commandkit . Supplied [ string ]
Source commandkit . Supplied [ string ]
Reason commandkit . Supplied [ string ]
Force commandkit . Supplied [ bool ]
}
type lockCommandReport struct {
Campaign string ` json:"campaign" `
SessionID string ` json:"session_id" `
Operation string ` json:"operation" `
Source string ` json:"source,omitempty" `
Result string ` json:"result" `
Complete bool ` json:"complete" `
Locks [ ] lockListEntry ` json:"locks" `
}
type lockListEntry struct {
Source string ` json:"source" `
Reason string ` json:"reason,omitempty" `
CreatedAt time . Time ` json:"created_at" `
ConfiguredForPublish bool ` json:"configured_for_publish" `
}
func lockCommand ( operation string , deps commandDependencies ) commandkit . Command {
common := newConfigurationFlags ( func ( input * * lockCommandInput ) * configurationSelection { return & ( * input ) . Selection } )
flags := [ ] commandkit . Flag [ * lockCommandInput ] { common . Config , common . Overlay , common . Campaign , common . CampaignFile , common . SessionFile , common . PartyFile , common . SecretsDir ,
commandkit . ValueFlag ( commandkit . FlagMeta { Name : "previous-session-id" , Usage : "Assert the previous session identity." } , nil , stringValue , func ( input * * lockCommandInput , value commandkit . Supplied [ string ] ) { ( * input ) . PreviousSession = value } ) ,
}
if operation == "add" {
flags = append ( flags ,
commandkit . ValueFlag ( commandkit . FlagMeta { Name : "reason" , Usage : "Reason for the publish lock." } , nil , stringValue , func ( input * * lockCommandInput , value commandkit . Supplied [ string ] ) { ( * input ) . Reason = value } ) ,
commandkit . BoolFlag ( commandkit . FlagMeta { Name : "force" , Usage : "Replace an existing lock conditionally." } , false , func ( input * * lockCommandInput , value commandkit . Supplied [ bool ] ) { ( * input ) . Force = value } ) ,
)
}
arguments := [ ] commandkit . Argument [ * lockCommandInput ] { commandkit . ValueArgument ( commandkit . ArgumentMeta { Name : "SESSION" , Usage : "Session identity." } , true , stringValue , func ( input * * lockCommandInput , value commandkit . Supplied [ string ] ) { ( * input ) . Selection . Session = value } ) }
if operation != "list" {
arguments = append ( arguments , commandkit . ValueArgument ( commandkit . ArgumentMeta { Name : "SOURCE" , Usage : "Canonical publish source identity." } , true , stringValue , func ( input * * lockCommandInput , value commandkit . Supplied [ string ] ) { ( * input ) . Source = value } ) )
}
return commandkit . NewCommand ( commandkit . CommandSpec [ * lockCommandInput ] { Name : operation , Summary : "Manage independent remote publication locks." , NewInput : func ( ) * lockCommandInput { return & lockCommandInput { } } , Flags : flags , Arguments : arguments ,
CheckInput : func ( input * lockCommandInput ) error {
if err := checkConfigurationSelection ( input . Selection ) ; err != nil {
return err
}
if operation != "list" {
_ , err := artifacts . NewRemoteLock ( input . Source . Value , strings . TrimSpace ( input . Reason . Value ) , nowUTC ( ) )
return err
}
return nil
} ,
Run : func ( invocation commandkit . Invocation , input * lockCommandInput ) commandkit . Outcome {
2026-11-20 05:59:09 +00:00
report , err := executeLockCommand ( invocation . Context , input , operation , withCommandReporting ( deps , invocation ) )
2026-11-20 05:29:27 +00:00
if report != nil {
err = errors . Join ( err , invocation . Reporter ( ) . Report ( commandkit . Report { Value : report } ) )
}
return operationOutcome ( err )
} ,
} )
}
func executeLockCommand ( ctx context . Context , input * lockCommandInput , operation string , deps commandDependencies ) ( report * lockCommandReport , 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 = & lockCommandReport { SessionID : input . Selection . Session . Value , Operation : operation , Source : input . Source . Value , Result : "not_applied" }
cfg , err := acquired . Domain ( ctx )
if err != nil {
return report , err
}
report . Campaign = config . CampaignID ( cfg . Campaign )
if err := config . Validate ( cfg ) ; err != nil {
return report , err
}
2026-11-20 06:32:47 +00:00
store , err := newCommandObjectStoreWithDependencies ( ctx , cfg , deps )
2026-11-20 05:29:27 +00:00
if err != nil {
return report , err
}
prefix , err := artifacts . ResolvePublishSessionPrefix ( cfg , nil )
if err != nil {
return report , err
}
if operation == "list" {
locks , err := artifacts . ListRemoteLocks ( ctx , store , prefix )
if err != nil {
return report , err
}
selected := map [ string ] bool { }
for _ , rule := range cfg . PublicationOutputs ( ) {
selected [ rule . Source ] = true
}
report . Locks = make ( [ ] lockListEntry , 0 , len ( locks ) )
for _ , lock := range locks {
report . Locks = append ( report . Locks , lockListEntry { Source : lock . Source , Reason : lock . Reason , CreatedAt : lock . CreatedAt , ConfiguredForPublish : selected [ lock . Source ] } )
}
report . Complete = true
report . Result = "listed"
return report , nil
}
result , err := applyRemoteLockMutation ( ctx , store , prefix , operation , input . Source . Value , input . Reason . Value , input . Force . Value )
report . Result = result
report . Complete = err == nil
return report , err
}
func applyRemoteLockMutation ( ctx context . Context , store storage . ObjectStore , prefix , operation , source , reason string , force bool ) ( string , error ) {
if operation == "remove" {
current , err := artifacts . LookupRemoteLock ( ctx , store , prefix , source )
if err != nil {
return "not_applied" , err
}
if err := artifacts . RemoveRemoteLock ( ctx , store , prefix , source ) ; err != nil {
return "not_applied" , err
}
if ! current . Present {
return "not_locked" , nil
}
return "unlocked" , nil
}
lock , err := artifacts . NewRemoteLock ( source , strings . TrimSpace ( reason ) , nowUTC ( ) )
if err != nil {
return "not_applied" , err
}
if ! force {
current , err := artifacts . LookupRemoteLock ( ctx , store , prefix , source )
if err != nil {
return "not_applied" , err
}
if current . Present {
return "already_locked" , fmt . Errorf ( "remote lock for %q already exists; pass --force to update" , source )
}
}
if err := artifacts . AddRemoteLock ( ctx , store , prefix , lock , force ) ; err != nil {
if errors . Is ( err , storage . ErrConditionNotMet ) {
return "not_applied" , fmt . Errorf ( "remote lock for %q changed concurrently; retry: %w" , source , err )
}
return "not_applied" , err
}
return "locked" , nil
}