Merge pull request #18 from namshi/local-execution

Allowing local execution

Author: odino

README.md

@@ -1,16 +1,16 @@
 # godo
 
-Remote execution level 9000: **go** and **do**
+Local and remote execution level 9000: **go** and **do**
 stuff.
 
 ![example](https://raw.githubusercontent.com/namshi/godo/master/images/gif-example.gif)
 
 `godo` is a very simple yet powerful tool that
 let's you specify a list of repetitive / useful
-commands you run on remote hosts, and run them
-with ease, without having to remember them or,
-worse, login on each server and execute them
-manually.
+commands you run on remote hosts or even locally,
+and run them with ease, without having to remember
+them or, even worse, login on each server and
+execute them manually.
 
 ## Installation
 
@@ -75,6 +75,10 @@ commands:
   nginx-logs:
     target: web
     exec: "sudo tail -10f /var/log/nginx/access.log"
+  my-uptime:
+    target:       local
+    exec:         "uptime"  
+    description:  "Retrieves uptime info for the current machine"  
 hostfile: "/home/YOU/.ssh/known_hosts"
 timeout: 2
 ```
@@ -115,9 +119,12 @@ godo uptime @ db
 godo uptime@db
 ```
 
-Godo provides a special group, called `all`, that
-represents all servers, so you can always run
-something like `godo uptime @ all`.
+Godo provides some special groups:
+
+* `all`, represents all servers, so you can
+always run something like `godo uptime @ all`
+* `local`, which references the current machine,
+so you will be running the command locally (`godo uptime @ local`)
 
 ## Additional documentation
 

src/cli/cli.go

@@ -54,6 +54,11 @@ func addCommands(app *cli.App) {
 
 		if command, ok := cfg.Commands[cmd]; ok {
 			fmt.Printf("Executing '%s'", info(cmd))
+
+			if target == "" {
+				target = command.Target
+			}
+
 			runCommand(command, cfg, target)
 		} else {
 			printAvailableCommands(app, cfg.Commands, c)
@@ -125,18 +130,23 @@ func addTargetFromServer(targets map[string]config.Server, target string, cfg co
 // we simply look at the configuration of the
 // command.
 //
-// A target can be a server or a group of servers.
+// A target can be a server, group of servers
+// or a special alias.
+//
+// The supported aliases are
+// - all: will execute the command on all servers
+// - local: instead of executing the command remotely
+//          it will execute it on the current machine
 func getTargets(command config.Command, cfg config.Config, target string) map[string]config.Server {
 	targets := make(map[string]config.Server)
 
 	if target == "all" {
 		targets = cfg.Servers
-	} else if target != "" {
+	} else if target == "local" {
+		targets["local"] = config.Server{}
+	} else {
 		addTargetFromGroups(targets, target, cfg)
 		addTargetFromServer(targets, target, cfg)
-	} else {
-		addTargetFromGroups(targets, command.Target, cfg)
-		addTargetFromServer(targets, command.Target, cfg)
 	}
 
 	return targets
@@ -154,10 +164,10 @@ func runCommand(command config.Command, cfg config.Config, target string) {
 	}
 
 	if len(targets) > 0 {
-		fmt.Printf("\nExecuting on server %s", info(strings.Join(targetNames, ", ")))
+		fmt.Printf("\nExecuting on server '%s'", info(strings.Join(targetNames, ", ")))
 		fmt.Println()
 		fmt.Println()
-		exec.ExecuteRemoteCommands(command.Exec, targets, cfg)
+		exec.ExecuteCommands(command.Exec, targets, cfg)
 	} else {
 		fmt.Printf(err("\nNo target server / group with the name '%s' could be found, maybe a typo?"), target)
 	}

src/exec/exec.go

@@ -4,7 +4,10 @@
 package exec
 
 import (
+	"fmt"
 	gossh "github.com/coreos/fleet/Godeps/_workspace/src/golang.org/x/crypto/ssh"
+	"github.com/mgutz/ansi"
+	goexec "os/exec"
 	"sync"
 	"time"
 
@@ -13,14 +16,68 @@ import (
 	"github.com/namshi/godo/src/ssh"
 )
 
+// Checks whether a command needs
+// to be run locally or remotely.
+//
+// If the only server is "local"
+// then it means that we need to
+// simply run the command on this
+// local machine.
+func isLocalCommand(servers map[string]config.Server) bool {
+	if len(servers) == 1 {
+		if _, ok := servers["local"]; ok {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Executes the command on the given
+// servers.
+//
+// The main goal of this method is to
+// figure out whether this command needs
+// to be executed locally or remotely,
+// and go ahead with the proper execution
+// strategy.
+func ExecuteCommands(command string, servers map[string]config.Server, cfg config.Config) {
+	if isLocalCommand(servers) {
+		executeLocalCommand(command)
+	} else {
+		executeRemoteCommands(command, servers, cfg)
+	}
+}
+
+// Executes a command locally.
+func executeLocalCommand(command string) {
+	cmd := goexec.Command(command)
+	stdout, stderr := log.GetRemoteLoggers("local")
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+
+	err := cmd.Start()
+
+	// failed to spawn new process
+	if err != nil {
+		fmt.Println(ansi.Color(err.Error(), "red+h"))
+	}
+
+	// Failed to execute?
+	err = cmd.Wait()
+	if err != nil {
+		fmt.Println(ansi.Color(err.Error(), "red+h"))
+	}
+}
+
 // Executes the given command on a series
 // of servers.
 //
 // We will launch N goroutins based on how
 // many commands we need to remotely execute,
 // and stop the execution once everyone is
 // done.
-func ExecuteRemoteCommands(command string, servers map[string]config.Server, cfg config.Config) {
+func executeRemoteCommands(command string, servers map[string]config.Server, cfg config.Config) {
 	var wg sync.WaitGroup
 	wg.Add(len(servers))
 
@@ -29,7 +86,7 @@ func ExecuteRemoteCommands(command string, servers map[string]config.Server, cfg
 			c := &ssh.Config{Address: serverConfig.Address, Alias: server, Tunnel: serverConfig.Tunnel, User: serverConfig.User, Hostfile: cfg.Hostfile}
 			c.Timeout = time.Duration(cfg.Timeout) * time.Second
 			session, _ := ssh.CreateClient(c).NewSession()
-			ExecuteRemoteCommand(command, session, server)
+			executeRemoteCommand(command, session, server)
 			defer wg.Done()
 		}(server, serverConfig)
 	}
@@ -39,7 +96,7 @@ func ExecuteRemoteCommands(command string, servers map[string]config.Server, cfg
 
 // Executes the given command through SSH,
 // connecting with the given config.
-func ExecuteRemoteCommand(command string, session *gossh.Session, server string) {
+func executeRemoteCommand(command string, session *gossh.Session, server string) {
 	stdout, stderr := log.GetRemoteLoggers(server)
 	session.Stdout = stdout
 	session.Stderr = stderr