Merge pull request #15 from phase2/develop

Release 1.2.0

Author: febbraro

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 1.2.0
+
+ - Added Docker-based development support
+ - Trimmed output and added a global verbose flag to get it all back
+ - Refactored the entire codebase for better design
+ - Deprecated code cleanup
+
 ## 1.1.0
 
  - Renamed from `devtools` to `rig`.

Dockerfile

@@ -0,0 +1,9 @@
+FROM golang:1.7-alpine
+
+RUN apk add --no-cache \
+  ca-certificates \
+  git \
+  gcc \
+  musl-dev \
+  && go get github.com/tools/godep \
+  && go get github.com/mitchellh/gox

README.md

@@ -1,5 +1,9 @@
 # Rig - Outrigger CLI
 
+> A CLI for managing the Outrigger container-driven development stack.
+
+See the [documentation for more details](http://docs.outrigger.sh).
+
 Use this readme when you want to develop the Outrigger CLI.
 
 Setup
@@ -68,6 +72,19 @@ NOTE: the `-cgo` in the above command is only relevant for building on OSX as th
 to use the OSX DNS Resolver instead of the built in Go resolver. This is needed in order to resolve DNS names
 that end in things like *.vm*  Using `-cgo` for Linux and Windows architectures will result in a failed build.
 
+Developing Rig with Docker [Experimental]
+-----------------------------------------
+
+You can use the Docker integration within this repository to facilitate development in lieu of setting up a
+local golang environment. Using docker-compose, run the following commands:
+
+```bash
+docker-compose run --rm install
+docker-compose run --rm build
+```
+
+This will produce a working OSX binary with partially limited functionality at `build/darwin/rig`.
+
 Deploy to Homebrew
 ------------------
 
@@ -81,8 +98,3 @@ perform the following operations.
  - Prepare a new `brew` version via `brew-publish.sh`
     - Part of this will write a new formula into homebrew-outrigger
  - Commit & push the updated formula to publish the new version
-
-
-
-
-

build.sh

@@ -5,19 +5,21 @@
 go get github.com/tools/godep
 go get github.com/mitchellh/gox
 
+pushd cli
+
 godep restore
 
 # Build for platforms
-gox -cgo -osarch="Darwin/amd64" -output="build/darwin/rig"
-gox -osarch="Linux/amd64" -output="build/linux/rig"
-gox -osarch="Windows/amd64" -output="build/windows/rig"
+gox -osarch="Darwin/amd64" -output="../build/darwin/rig"
+gox -osarch="Linux/amd64" -output="../build/linux/rig"
+gox -osarch="Windows/amd64" -output="../build/windows/rig"
 
-# Bundle for GitHub
+popd
 
 # Get version
 VERSION=`build/darwin/rig --version 2>&1 | grep 'rig version' | awk '{print $3}'`
 
-# Create archives for publishing to github
+# Create archives for publishing to GitHub
 cp scripts/docker-machine-watch-rsync.sh build/darwin/.
 pushd build/darwin
 tar czf ../rig-${VERSION}-darwin-amd64.tar.gz rig docker-machine-watch-rsync.sh

Godeps/Godeps.json renamed to cli/Godeps/Godeps.json

@@ -0,0 +1,38 @@
+package commands
+
+import (
+	"flag"
+	"github.com/phase2/rig/cli/util"
+	"github.com/urfave/cli"
+)
+
+type RigCommand interface {
+	Commands() cli.Command
+}
+
+type BaseCommand struct {
+	RigCommand
+	out     *util.RigLogger
+	machine Machine
+}
+
+// Run before all commands to setup core services
+func (cmd *BaseCommand) Before(c *cli.Context) error {
+	cmd.out = util.Logger()
+	cmd.machine = Machine{Name: c.GlobalString("name"), out: util.Logger()}
+	return nil
+}
+
+func (cmd *BaseCommand) NewContext(name string, flags []cli.Flag, parent *cli.Context) *cli.Context {
+	flagSet := flag.NewFlagSet(name, flag.ContinueOnError)
+	for _, f := range flags {
+		f.Apply(flagSet)
+	}
+	return cli.NewContext(parent.App, flagSet, parent)
+}
+
+func (cmd *BaseCommand) SetContextFlag(ctx *cli.Context, name string, value string) {
+	if err := ctx.Set(name, value); err != nil {
+		cmd.out.Error.Fatal(err)
+	}
+}

Godeps/Readme renamed to cli/Godeps/Readme

@@ -1,4 +1,4 @@
-package main
+package commands
 
 import (
 	"fmt"
@@ -7,15 +7,19 @@ import (
 	"runtime"
 	"strings"
 
+	"github.com/phase2/rig/cli/util"
 	"github.com/urfave/cli"
 )
 
-type Config struct{}
+type Config struct {
+	BaseCommand
+}
 
 func (cmd *Config) Commands() cli.Command {
 	return cli.Command{
 		Name:   "config",
 		Usage:  "Echo the config to setup the Rig environment.  Run: eval \"$(rig config)\"",
+		Before: cmd.Before,
 		Action: cmd.Run,
 	}
 }
@@ -25,7 +29,7 @@ func (cmd *Config) Run(c *cli.Context) error {
 	if runtime.GOOS != "darwin" {
 		// Add stuff to PATH only once
 		path := os.Getenv("PATH")
-		dir, _ := GetExecutableDir()
+		dir, _ := util.GetExecutableDir()
 		if !strings.Contains(path, dir) {
 			fmt.Printf("export PATH=%s%c$PATH\n", dir, os.PathListSeparator)
 		}
@@ -36,13 +40,13 @@ func (cmd *Config) Run(c *cli.Context) error {
 		os.Stdout.Write(output)
 	}
 
-	if machine.Exists() {
+	if cmd.machine.Exists() {
 		// Setup new values if machine is running
-		if output, err := exec.Command("docker-machine", "env", machine.Name).Output(); err == nil {
+		if output, err := exec.Command("docker-machine", "env", cmd.machine.Name).Output(); err == nil {
 			os.Stdout.Write(output)
 		}
 	} else {
-		out.Error.Fatalf("No machine named '%s' exists.", machine.Name)
+		cmd.out.Error.Fatalf("No machine named '%s' exists.", cmd.machine.Name)
 	}
 
 	return nil

cli/commands/command.go

@@ -1,44 +1,48 @@
-package main
+package commands
 
 import (
 	"fmt"
 	"os"
 	"os/exec"
 	"runtime"
 
+	"github.com/phase2/rig/cli/util"
 	"github.com/urfave/cli"
 )
 
-type Dashboard struct{}
+type Dashboard struct {
+	BaseCommand
+}
 
 func (cmd *Dashboard) Commands() cli.Command {
 	return cli.Command{
 		Name:   "dashboard",
 		Usage:  "Start Dashboard services on the docker-machine",
+		Before: cmd.Before,
 		Action: cmd.Run,
 	}
 }
 
 func (cmd *Dashboard) Run(c *cli.Context) error {
-	if machine.IsRunning() {
-		out.Info.Println("Launching Dashboard")
-		cmd.LaunchDashboard(machine)
+	if cmd.machine.IsRunning() {
+		cmd.out.Info.Println("Launching Dashboard")
+		cmd.LaunchDashboard(cmd.machine)
 	} else {
-		out.Error.Fatalf("Machine '%s' is not running.", machine.Name)
+		cmd.out.Error.Fatalf("Machine '%s' is not running.", cmd.machine.Name)
 	}
 
 	return nil
 }
 
-func (cmd Dashboard) LaunchDashboard(machine Machine) {
+func (cmd *Dashboard) LaunchDashboard(machine Machine) {
 	machine.SetEnv()
 
 	home := os.Getenv("HOME")
 
-	StreamCommand(exec.Command("docker", "stop", "outrigger-dashboard"))
-	StreamCommand(exec.Command("docker", "rm", "outrigger-dashboard"))
+	exec.Command("docker", "stop", "outrigger-dashboard").Run()
+	exec.Command("docker", "rm", "outrigger-dashboard").Run()
 
-	dockerApiVersion, _ := GetDockerServerApiVersion()
+	dockerApiVersion, _ := util.GetDockerServerApiVersion(cmd.machine.Name)
 
 	args := []string{
 		"run",
@@ -53,13 +57,13 @@ func (cmd Dashboard) LaunchDashboard(machine Machine) {
 		"outrigger/dashboard:latest",
 	}
 
-	StreamCommand(exec.Command("docker", args...))
+	util.ForceStreamCommand(exec.Command("docker", args...))
 
 	if runtime.GOOS == "darwin" {
-		StreamCommand(exec.Command("open", "http://dashboard.outrigger.vm"))
+		exec.Command("open", "http://dashboard.outrigger.vm").Run()
 	} else if runtime.GOOS == "windows" {
-		StreamCommand(exec.Command("start", "http://dashboard.outrigger.vm"))
+		exec.Command("start", "http://dashboard.outrigger.vm").Run()
 	} else {
-		out.Info.Println("Outrigger Dashboard is now available at http://dashboard.outrigger.vm")
+		cmd.out.Info.Println("Outrigger Dashboard is now available at http://dashboard.outrigger.vm")
 	}
 }

config.go renamed to cli/commands/config.go

@@ -1,4 +1,4 @@
-package main
+package commands
 
 import (
 	"fmt"
@@ -9,7 +9,9 @@ import (
 	"github.com/urfave/cli"
 )
 
-type DataBackup struct{}
+type DataBackup struct {
+	BaseCommand
+}
 
 func (cmd *DataBackup) Commands() cli.Command {
 	return cli.Command{
@@ -27,43 +29,44 @@ func (cmd *DataBackup) Commands() cli.Command {
 				Usage: "Specify the local directory to store the backup zip.",
 			},
 		},
+		Before: cmd.Before,
 		Action: cmd.Run,
 	}
 }
 
 func (cmd *DataBackup) Run(c *cli.Context) error {
-	if !machine.Exists() {
-		out.Error.Fatalf("No machine named '%s' exists.", machine.Name)
+	if !cmd.machine.Exists() {
+		cmd.out.Error.Fatalf("No machine named '%s' exists.", cmd.machine.Name)
 	}
 
 	dataDir := c.String("data-dir")
 	backupDir := c.String("backup-dir")
-	backupFile := fmt.Sprintf("%s%c%s.tgz", backupDir, os.PathSeparator, machine.Name)
+	backupFile := fmt.Sprintf("%s%c%s.tgz", backupDir, os.PathSeparator, cmd.machine.Name)
 	if _, err := os.Stat(backupDir); err != nil {
-		out.Info.Printf("Creating backup directory: %s...", backupDir)
+		cmd.out.Info.Printf("Creating backup directory: %s...", backupDir)
 		if mkdirErr := exec.Command("mkdir", "-p", backupDir).Run(); mkdirErr != nil {
-			out.Error.Println(mkdirErr)
-			out.Error.Fatalf("Could not create backup directory %s", backupDir)
+			cmd.out.Error.Println(mkdirErr)
+			cmd.out.Error.Fatalf("Could not create backup directory %s", backupDir)
 		}
 	} else if _, err := os.Stat(backupFile); err == nil {
 		// If the backup dir already exists, make sure the backup file does not exist.
-		out.Error.Fatalf("Backup archive %s already exists.", backupFile)
+		cmd.out.Error.Fatalf("Backup archive %s already exists.", backupFile)
 	}
 
-	out.Info.Printf("Backing up %s on '%s' to %s...", dataDir, machine.Name, backupFile)
+	cmd.out.Info.Printf("Backing up %s on '%s' to %s...", dataDir, cmd.machine.Name, backupFile)
 
 	// Stream the archive to stdout and capture it in a local file so we don't waste
 	// space storing an archive on the VM filesystem. There may not be enough space.
 	archiveCmd := fmt.Sprintf("sudo tar czf - -C %s .", dataDir)
-	backup := exec.Command("docker-machine", "ssh", machine.Name, archiveCmd, ">", backupFile)
+	backup := exec.Command("docker-machine", "ssh", cmd.machine.Name, archiveCmd, ">", backupFile)
 	backup.Stderr = os.Stderr
 
 	color.Set(color.FgCyan)
 	err := backup.Run()
 	color.Unset()
 
 	if err != nil {
-		out.Warning.Println("There may have been problems. See above for any errors")
+		cmd.out.Warning.Println("There may have been problems. See above for any errors")
 	}
 
 	return nil