Files
dokku/plugins/ps/subcommands.go
T
Jose Diaz-Gonzalez db45f8608b feat: add --clear and --replace flags to ps:scale
The `ps:scale` command merges the specified process types into the existing formation, so replacing an entire formation from the CLI required reading the current scale, diffing it, and issuing a second call to zero out each unlisted process type. The `--replace` flag treats the specified process types as the whole formation and sets the process count for every unspecified process type to zero, while the `--clear` flag resets the formation to the scale a newly created app has. The two flags cannot be combined, `--replace` requires at least one process type, and `--clear` accepts none. Process types cleared this way are now scaled down as part of the same command rather than being left running with a stale formation.
2026-09-02 14:55:16 -04:00

264 lines
6.7 KiB
Go

package ps
import (
"errors"
"fmt"
"path/filepath"
"strings"
"github.com/dokku/dokku/plugins/common"
"github.com/gofrs/flock"
)
// CommandInspect displays a sanitized version of docker inspect for an app
func CommandInspect(appName string) error {
if err := common.VerifyAppName(appName); err != nil {
return err
}
scheduler := common.GetAppScheduler(appName)
_, err := common.CallPlugnTrigger(common.PlugnTriggerInput{
Trigger: "scheduler-inspect",
Args: []string{scheduler, appName},
StreamStdio: true,
})
return err
}
// CommandRebuild rebuilds an app from source
func CommandRebuild(appName string, allApps bool, parallelCount int) error {
if allApps {
return common.RunCommandAgainstAllApps(Rebuild, "rebuild", parallelCount)
}
if err := common.VerifyAppName(appName); err != nil {
return err
}
return Rebuild(appName)
}
// CommandReport displays a ps report for one or more apps
func CommandReport(appName string, format string, infoFlag string) error {
if len(appName) == 0 {
apps, err := common.DokkuApps()
if err != nil {
if errors.Is(err, common.NoAppsExist) {
common.LogWarn(err.Error())
return nil
}
return err
}
for _, appName := range apps {
if err := ReportSingleApp(appName, format, infoFlag); err != nil {
return err
}
}
return nil
}
return ReportSingleApp(appName, format, infoFlag)
}
// CommandRestart restarts an app
func CommandRestart(appName string, processName string, allApps bool, parallelCount int) error {
if allApps {
if processName != "" {
return errors.New("Unable to restart all apps when specifying a process name")
}
return common.RunCommandAgainstAllApps(Restart, "restart", parallelCount)
}
if err := common.VerifyAppName(appName); err != nil {
return err
}
if processName != "" {
return RestartProcess(appName, processName)
}
return Restart(appName)
}
// CommandRestore starts previously running apps e.g. after reboot
func CommandRestore(appName string, allApps bool, parallelCount int) error {
_, err := common.CallPlugnTrigger(common.PlugnTriggerInput{
Trigger: "pre-restore",
StreamStdio: true,
})
if err != nil {
return fmt.Errorf("Error running pre-restore: %s", err)
}
if allApps {
if err := restorePrep(); err != nil {
return err
}
return common.RunCommandAgainstAllApps(Restore, "restore", parallelCount)
}
if appName == "" {
common.LogWarn("Restore specified without app, assuming --all")
if err := restorePrep(); err != nil {
return err
}
return common.RunCommandAgainstAllApps(Restore, "restore", parallelCount)
}
if err := common.VerifyAppName(appName); err != nil {
return err
}
return Restore(appName)
}
// CommandRetire ensures old containers are retired
func CommandRetire(appName string) error {
lockFile := filepath.Join(common.GetDataDirectory("ps"), "retire")
scheduler := ""
if appName == "" {
scheduler = common.GetGlobalScheduler()
} else {
scheduler = common.GetAppScheduler(appName)
}
fileLock := flock.New(lockFile)
locked, err := fileLock.TryLock()
if err != nil {
return &RetireLockFailed{&err}
}
defer fileLock.Unlock()
if !locked {
return &RetireLockFailed{}
}
common.LogInfo1("Retiring old containers and images")
_, err = common.CallPlugnTrigger(common.PlugnTriggerInput{
Trigger: "scheduler-retire",
Args: []string{scheduler, appName},
StreamStdio: true,
})
if err != nil {
return fmt.Errorf("Error retiring containers: %w", err)
}
common.LogInfo1("Retiring expired run and cron containers")
_, err = common.CallPlugnTrigger(common.PlugnTriggerInput{
Trigger: "scheduler-run-retire",
StreamStdio: true,
})
if err != nil {
return fmt.Errorf("Error retiring expired run containers: %w", err)
}
return err
}
// CommandScaleInput is the input for the CommandScale function
type CommandScaleInput struct {
// AppName is the name of the app to scale
AppName string
// Clear is a flag to reset the formation to the default scale
Clear bool
// Format is the format to display the formation in
Format string
// ProcessTuples is a list of process tuples to scale
ProcessTuples []string
// Replace is a flag to replace the formation with the specified process tuples
Replace bool
// SkipDeploy is a flag to skip the deploy phase
SkipDeploy bool
}
// CommandScale gets or sets how many instances of a given process to run
func CommandScale(input CommandScaleInput) error {
if err := common.VerifyAppName(input.AppName); err != nil {
return err
}
if input.Clear && input.Replace {
return errors.New("The --clear and --replace flags cannot be specified together")
}
if input.Clear && len(input.ProcessTuples) > 0 {
return errors.New("Process types cannot be specified when using the --clear flag, use --replace to set the entire formation")
}
if input.Replace && len(input.ProcessTuples) == 0 {
return errors.New("Must specify at least one process type when using the --replace flag, use --clear to reset the formation")
}
if !input.Clear && len(input.ProcessTuples) == 0 {
return scaleReport(input.AppName, input.Format)
}
if !canScaleApp(input.AppName) {
return fmt.Errorf("App %s contains an app.json file with a formations key and cannot be manually scaled", input.AppName)
}
processTuples := input.ProcessTuples
if input.Clear {
var err error
processTuples, err = defaultProcessTuples(input.AppName)
if err != nil {
return err
}
common.LogInfo1(fmt.Sprintf("Resetting %s processes to the default scale", input.AppName))
} else {
common.LogInfo1(fmt.Sprintf("Scaling %s processes: %s", input.AppName, strings.Join(processTuples, " ")))
}
return scaleSet(scaleSetInput{
appName: input.AppName,
skipDeploy: input.SkipDeploy,
clearExisting: input.Clear || input.Replace,
processTuples: processTuples,
deployOnlyChanged: true,
})
}
// CommandSet sets or clears a ps property for an app
func CommandSet(appName string, property string, value string) error {
if property == "restart-policy" && value != "" && !isValidRestartPolicy(value) {
return errors.New("Invalid restart-policy specified")
}
common.CommandPropertySet("ps", appName, property, value, DefaultProperties, GlobalProperties)
return nil
}
// CommandStart starts an app
func CommandStart(appName string, allApps bool, parallelCount int) error {
if allApps {
return common.RunCommandAgainstAllApps(Start, "start", parallelCount)
}
if err := common.VerifyAppName(appName); err != nil {
return err
}
return Start(appName)
}
// CommandStop stops an app
func CommandStop(appName string, allApps bool, parallelCount int) error {
if allApps {
return common.RunCommandAgainstAllApps(Stop, "stop", parallelCount)
}
if err := common.VerifyAppName(appName); err != nil {
return err
}
return Stop(appName)
}