mirror of
https://github.com/status-im/consul.git
synced 2025-01-26 05:29:55 +00:00
a49711b8bf
This patch refactors the commands that use the mitchellh/cli library to populate the command line flag set in both the Run() and the Help() method. Earlier versions of the mitchellh/cli library relied on the Run() method to populuate the flagset for generating the usage screen. This has changed in later versions and was previously solved with a small monkey patch to the library to restore the old behavior. However, this makes upgrading the library difficult since the patch has to be restored every time. This patch addresses this by moving the command line flags into an initFlags() method where appropriate and also moving all variables for the flags from the Run() method into the command itself. Fixes #3536
120 lines
2.8 KiB
Go
120 lines
2.8 KiB
Go
package command
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
|
|
"github.com/hashicorp/consul/api"
|
|
"github.com/hashicorp/consul/snapshot"
|
|
)
|
|
|
|
// SnapshotSaveCommand is a Command implementation that is used to save the
|
|
// state of the Consul servers for disaster recovery.
|
|
type SnapshotSaveCommand struct {
|
|
BaseCommand
|
|
}
|
|
|
|
func (c *SnapshotSaveCommand) Help() string {
|
|
c.InitFlagSet()
|
|
return c.HelpCommand(`
|
|
Usage: consul snapshot save [options] FILE
|
|
|
|
Retrieves an atomic, point-in-time snapshot of the state of the Consul servers
|
|
which includes key/value entries, service catalog, prepared queries, sessions,
|
|
and ACLs.
|
|
|
|
If ACLs are enabled, a management token must be supplied in order to perform
|
|
snapshot operations.
|
|
|
|
To create a snapshot from the leader server and save it to "backup.snap":
|
|
|
|
$ consul snapshot save backup.snap
|
|
|
|
To create a potentially stale snapshot from any available server (useful if no
|
|
leader is available):
|
|
|
|
$ consul snapshot save -stale backup.snap
|
|
|
|
For a full list of options and examples, please see the Consul documentation.
|
|
|
|
`)
|
|
}
|
|
|
|
func (c *SnapshotSaveCommand) Run(args []string) int {
|
|
c.InitFlagSet()
|
|
if err := c.FlagSet.Parse(args); err != nil {
|
|
return 1
|
|
}
|
|
|
|
var file string
|
|
|
|
args = c.FlagSet.Args()
|
|
switch len(args) {
|
|
case 0:
|
|
c.UI.Error("Missing FILE argument")
|
|
return 1
|
|
case 1:
|
|
file = args[0]
|
|
default:
|
|
c.UI.Error(fmt.Sprintf("Too many arguments (expected 1, got %d)", len(args)))
|
|
return 1
|
|
}
|
|
|
|
// Create and test the HTTP client
|
|
client, err := c.HTTPClient()
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error connecting to Consul agent: %s", err))
|
|
return 1
|
|
}
|
|
|
|
// Take the snapshot.
|
|
snap, qm, err := client.Snapshot().Save(&api.QueryOptions{
|
|
AllowStale: c.HTTPStale(),
|
|
})
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error saving snapshot: %s", err))
|
|
return 1
|
|
}
|
|
defer snap.Close()
|
|
|
|
// Save the file.
|
|
f, err := os.Create(file)
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error creating snapshot file: %s", err))
|
|
return 1
|
|
}
|
|
if _, err := io.Copy(f, snap); err != nil {
|
|
f.Close()
|
|
c.UI.Error(fmt.Sprintf("Error writing snapshot file: %s", err))
|
|
return 1
|
|
}
|
|
if err := f.Close(); err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error closing snapshot file after writing: %s", err))
|
|
return 1
|
|
}
|
|
|
|
// Read it back to verify.
|
|
f, err = os.Open(file)
|
|
if err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error opening snapshot file for verify: %s", err))
|
|
return 1
|
|
}
|
|
if _, err := snapshot.Verify(f); err != nil {
|
|
f.Close()
|
|
c.UI.Error(fmt.Sprintf("Error verifying snapshot file: %s", err))
|
|
return 1
|
|
}
|
|
if err := f.Close(); err != nil {
|
|
c.UI.Error(fmt.Sprintf("Error closing snapshot file after verify: %s", err))
|
|
return 1
|
|
}
|
|
|
|
c.UI.Info(fmt.Sprintf("Saved and verified snapshot to index %d", qm.LastIndex))
|
|
return 0
|
|
}
|
|
|
|
func (c *SnapshotSaveCommand) Synopsis() string {
|
|
return "Saves snapshot of Consul server state"
|
|
}
|