WIP: Add a juju subcommand for backups.

cmd/juju/backup.go

@@ -0,0 +1,72 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package main
+
+import (
+	"fmt"
+
+	"github.com/juju/cmd"
+	"github.com/juju/juju/cmd/envcmd"
+	"github.com/juju/juju/juju"
+	"github.com/juju/juju/state/api"
+)
+
+type backupClient interface {
+	Backup(backupFilePath string) (string, error)
+}
+
+type BackupCommand struct {
+	/* XXX Shuld this really be an env-specific command? */
+	envcmd.EnvCommandBase
+	Filename string
+}
+
+var backupDoc = fmt.Sprintf(`
+This command will generate a backup of juju's state as a local gzipped tar
+file (.tar.gz).  If no filename is provided, one is generated with a name
+like this:
+
+  %s
+
+where <timestamp> is the timestamp of when the backup is generated.
+
+The filename of the generated archive will be printed upon success.
+`, fmt.Sprintf(api.BACKUP_FILENAME, "<timestamp>"))
+
+func (c *BackupCommand) Info() *cmd.Info {
+	return &cmd.Info{
+		Name:    "backup",
+		Args:    "[filename]",
+		Purpose: "create a backup of juju's state",
+		Doc:     backupDoc,
+	}
+}
+
+func (c *BackupCommand) Init(args []string) error {
+	filename, err := cmd.ZeroOrOneArgs(args)
+	if err == nil {
+		c.Filename = filename
+	}
+	return err
+}
+
+func (c *BackupCommand) run(ctx *cmd.Context, client backupClient) error {
+	filename, err := client.Backup(c.Filename)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintln(ctx.Stdout, filename)
+	return nil
+}
+
+func (c *BackupCommand) Run(ctx *cmd.Context) error {
+	client, err := juju.NewAPIClientFromName(c.EnvName)
+	if err != nil {
+		return err
+	}
+	defer client.Close()
+
+	return c.run(ctx, client)
+}

cmd/juju/backup_test.go

@@ -0,0 +1,105 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package main
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/juju/cmd"
+	gc "launchpad.net/gocheck"
+
+	"github.com/juju/juju/state/api"
+	"github.com/juju/juju/testing"
+)
+
+type BackupCommandSuite struct {
+	testing.BaseSuite
+}
+
+var _ = gc.Suite(&BackupCommandSuite{})
+
+// a fake client and command
+
+var fakeBackupFilename = fmt.Sprintf(api.BACKUP_FILENAME, 1402686077)
+
+type fakeBackupClient struct {
+	err error
+}
+
+func (c *fakeBackupClient) Backup(backupFilePath string) (string, error) {
+	if c.err != nil {
+		return "", c.err
+	}
+
+	if backupFilePath == "" {
+		backupFilePath = fakeBackupFilename
+	}
+	/* Don't actually do anything! */
+	return backupFilePath, c.err
+}
+
+type fakeBackupCommand struct {
+	BackupCommand
+	client fakeBackupClient
+}
+
+func (c *fakeBackupCommand) Run(ctx *cmd.Context) error {
+	return c.run(ctx, &c.client)
+}
+
+// help tests
+
+func (s *BackupCommandSuite) TestBackupHelp(c *gc.C) {
+	// Check the help output.
+
+	info := (&BackupCommand{}).Info()
+
+	expected := fmt.Sprintf(`
+usage: juju %s [options] %s
+purpose: %s
+
+options:
+...
+
+%s
+`, info.Args, info.Purpose, info.Doc)
+
+	ctx, err := testing.RunCommand(c, &BackupCommand{}, "--help")
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(testing.Stdout(ctx), gc.Matches, expected)
+}
+
+// options tests
+
+func (s *BackupCommandSuite) TestBackupDefaults(c *gc.C) {
+	client := fakeBackupClient{}
+	command := fakeBackupCommand{client: client}
+
+	ctx, err := testing.RunCommand(c, &command)
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(testing.Stdout(ctx), gc.Matches, fakeBackupFilename+"\n")
+}
+
+func (s *BackupCommandSuite) TestBackupFilename(c *gc.C) {
+	filename := "foo.tgz"
+	client := fakeBackupClient{}
+	command := fakeBackupCommand{client: client}
+
+	ctx, err := testing.RunCommand(c, &command, filename)
+
+	c.Assert(err, gc.IsNil)
+	c.Assert(testing.Stdout(ctx), gc.Matches, filename+"\n")
+}
+
+func (s *BackupCommandSuite) TestBackupError(c *gc.C) {
+	client := fakeBackupClient{err: errors.New("something went wrong")}
+	command := fakeBackupCommand{client: client}
+
+	_, err := testing.RunCommand(c, &command)
+
+	c.Assert(err, gc.NotNil)
+}

cmd/juju/main.go

@@ -144,6 +144,9 @@ func registerCommands(r commandRegistry, ctx *cmd.Context) {
 	// Manage users and access
 	r.Register(NewUserCommand())
 
+	// Manage backups.
+	r.Register(wrapEnvCommand(&BackupCommand{}))
+
 	// Manage state server availability.
 	r.Register(wrapEnvCommand(&EnsureAvailabilityCommand{}))
 }

cmd/juju/main_test.go

@@ -193,6 +193,7 @@ var commandNames = []string{
 	"api-endpoints",
 	"authorised-keys", // alias for authorized-keys
 	"authorized-keys",
+	"backup",
 	"bootstrap",
 	"debug-hooks",
 	"debug-log",

state/api/client.go

@@ -593,6 +593,13 @@ func (c *Client) DestroyEnvironment() error {
 	return c.call("DestroyEnvironment", nil, nil)
 }
 
+const BACKUP_FILENAME = "jujubackup-%d.tar.gz"
+
+func (c *Client) Backup(backupFilePath string) (string, error) {
+	/* XXX stub */
+	return backupFilePath, nil
+}
+
 // AddLocalCharm prepares the given charm with a local: schema in its
 // URL, and uploads it via the API server, returning the assigned
 // charm URL. If the API server does not support charm uploads, an