mirror of
https://github.com/kemko/nomad.git
synced 2026-01-02 00:15:43 +03:00
bb142af5d6
This adds a `nomad alloc stop` command that can be used to stop and force migrate an allocation to a different node. This is built on top of the AllocUpdateDesiredTransitionRequest and explicitly limits the scope of access to that transition to expose it under the alloc-lifecycle ACL. The API returns the follow up eval that can be used as part of monitoring in the CLI or parsed and used in an external tool.
129 lines
3.0 KiB
Go
129 lines
3.0 KiB
Go
package command
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
type AllocStopCommand struct {
|
|
Meta
|
|
}
|
|
|
|
func (a *AllocStopCommand) Help() string {
|
|
helpText := `
|
|
Usage: nomad alloc stop [options] <allocation>
|
|
Alias: nomad stop
|
|
|
|
stop an existing allocation. This command is used to signal a specific alloc
|
|
to shut down. When the allocation has been shut down, it will then be
|
|
rescheduled. An interactive monitoring session will display log lines as the
|
|
allocation completes shutting down. It is safe to exit the monitor early with
|
|
ctrl-c.
|
|
|
|
General Options:
|
|
|
|
` + generalOptionsUsage() + `
|
|
|
|
Stop Specific Options:
|
|
|
|
-detach
|
|
Return immediately instead of entering monitor mode. After the
|
|
stop command is submitted, a new evaluation ID is printed to the
|
|
screen, which can be used to examine the rescheduling evaluation using the
|
|
eval-status command.
|
|
|
|
-verbose
|
|
Show full information.
|
|
`
|
|
return strings.TrimSpace(helpText)
|
|
}
|
|
|
|
func (c *AllocStopCommand) Name() string { return "alloc stop" }
|
|
|
|
func (c *AllocStopCommand) Run(args []string) int {
|
|
var detach, verbose bool
|
|
|
|
flags := c.Meta.FlagSet(c.Name(), FlagSetClient)
|
|
flags.Usage = func() { c.Ui.Output(c.Help()) }
|
|
flags.BoolVar(&detach, "detach", false, "")
|
|
flags.BoolVar(&verbose, "verbose", false, "")
|
|
|
|
if err := flags.Parse(args); err != nil {
|
|
return 1
|
|
}
|
|
|
|
// Check that we got exactly one alloc
|
|
args = flags.Args()
|
|
if len(args) != 1 {
|
|
c.Ui.Error("This command takes one argument: <alloc-id>")
|
|
c.Ui.Error(commandErrorText(c))
|
|
return 1
|
|
}
|
|
|
|
allocID := args[0]
|
|
|
|
// Truncate the id unless full length is requested
|
|
length := shortId
|
|
if verbose {
|
|
length = fullId
|
|
}
|
|
|
|
// Query the allocation info
|
|
if len(allocID) == 1 {
|
|
c.Ui.Error(fmt.Sprintf("Alloc ID must contain at least two characters."))
|
|
return 1
|
|
}
|
|
|
|
allocID = sanitizeUUIDPrefix(allocID)
|
|
|
|
// Get the HTTP client
|
|
client, err := c.Meta.Client()
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error initializing client: %s", err))
|
|
return 1
|
|
}
|
|
|
|
allocs, _, err := client.Allocations().PrefixList(allocID)
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error querying allocation: %v", err))
|
|
return 1
|
|
}
|
|
|
|
if len(allocs) == 0 {
|
|
c.Ui.Error(fmt.Sprintf("No allocation(s) with prefix or id %q found", allocID))
|
|
return 1
|
|
}
|
|
|
|
if len(allocs) > 1 {
|
|
// Format the allocs
|
|
out := formatAllocListStubs(allocs, verbose, length)
|
|
c.Ui.Error(fmt.Sprintf("Prefix matched multiple allocations\n\n%s", out))
|
|
return 1
|
|
}
|
|
|
|
// Prefix lookup matched a single allocation
|
|
alloc, _, err := client.Allocations().Info(allocs[0].ID, nil)
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error querying allocation: %s", err))
|
|
return 1
|
|
}
|
|
|
|
resp, err := client.Allocations().Stop(alloc, nil)
|
|
if err != nil {
|
|
c.Ui.Error(fmt.Sprintf("Error stopping allocation: %s", err))
|
|
return 1
|
|
}
|
|
|
|
if detach {
|
|
c.Ui.Output(resp.EvalID)
|
|
return 0
|
|
}
|
|
|
|
mon := newMonitor(c.Ui, client, length)
|
|
return mon.monitor(resp.EvalID, false)
|
|
}
|
|
|
|
func (a *AllocStopCommand) Synopsis() string {
|
|
return "Stop and reschedule a running allocation"
|
|
}
|