Initial commit

Initial commit of basic working version. Need to cleanup code in a few
places, and document, and test.

Author: grubernaut

.gitignore

@@ -0,0 +1,2 @@
+.idea/*
+.imi

README.md

@@ -0,0 +1,48 @@
+Consul DSH
+==========
+
+`go get -u github.com/grubernaut/cdsh`
+
+The remote shell `exec` for consul services.
+
+### Quick How-to
+
+```
+cdsh --server <consul-server-address> --service <consul-service> --user <username> '<bash command to execute>'
+```
+
+**Note:** 
+Be sure that you're actually able to SSH to the target consul service. (SSH Keys, Host key verification, etc)
+
+### Options
+
+* `--server` / `-s`: Consul server to query against (Required)
+* `--service` / `-S`: Target service to run command against
+* `--user` / `-u`: Remote user to connect as. If unspecified, defaults to current local user
+
+More options are likely to come in the future, such as `--tag` `--token`, `--node`, etc...
+
+If `--service` is left unspecified, `cdsh` will return a list of all available services. This will likely be changed
+in the future to a separate flag entirely.
+
+### Doesn't Consul have a native `exec` command?
+
+While consul _does_ have a native `exec` command, there are a couple issues with using `consul exec`.
+
+> Agents are informed about the new job using the event system, which propagates messages via the gossip protocol. As a 
+> result, delivery is best-effort, and there is no guarantee of execution.
+> ...
+> While events are purely gossip driven, remote execution relies on the KV store as a message broker.  
+
+Using Consul K/V as a message broker _definitely_ has it's benefits, but there are often times in daily operations work,
+where a user might want to know immediately if they cannot connect to a service.
+
+However, the main concern with using `consul exec` is as follows:
+
+> Verbose output warning: use care to make sure that your command does not produce a large volume of output. Writes to
+> the KV store for this output go through the Consul servers and the Raft consensus algorithm, so having a large number
+> of nodes in the cluster flow a large amount of data through the KV store could make the cluster unavailable.
+
+There are quite a few times where I've needed to fetch fairly verbose log output from N-servers, and pipe the output to
+a file for further analysis. Using DSH completely abstracts the command output from Consul K/V, allowing the user to run
+fairly verbose commands without worry.

cdsh

@@ -0,0 +1,32 @@
+package main
+
+import "gopkg.in/urfave/cli.v2"
+
+func setFlags() []cli.Flag {
+	return []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "verbose",
+			Value:   false,
+			Aliases: []string{"v"},
+			Usage:   "Verbose output",
+		},
+		&cli.StringFlag{
+			Name:    "server",
+			Value:   "",
+			Aliases: []string{"s"},
+			Usage:   "Consul Server Address",
+		},
+		&cli.StringFlag{
+			Name:    "service",
+			Value:   "",
+			Aliases: []string{"S"},
+			Usage:   "Target Consul Service",
+		},
+		&cli.StringFlag{
+			Name:    "user",
+			Value:   "",
+			Aliases: []string{"u"},
+			Usage:   "Remote User to connect as",
+		},
+	}
+}

flags.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"os"
+
+	"gopkg.in/urfave/cli.v2"
+)
+
+func main() {
+	cli.VersionFlag = &cli.BoolFlag{
+		Name:    "version",
+		Usage:   "print the version",
+		Aliases: []string{"V"},
+		Value:   false,
+	}
+
+	app := &cli.App{
+		Name:  "cdsh",
+		Usage: "Consul DSH",
+		Flags: setFlags(),
+		Action: func(c *cli.Context) error {
+			return run(c)
+		},
+	}
+	app.Run(os.Args)
+}

main.go

@@ -0,0 +1,160 @@
+package main
+
+import (
+	"container/list"
+	"fmt"
+
+	"os"
+
+	"github.com/grubernaut/gdsh/dsh"
+	consul "github.com/hashicorp/consul/api"
+	"gopkg.in/urfave/cli.v2"
+)
+
+func run(c *cli.Context) error {
+	// If a service isn't requested, exit
+	if c.NArg() < 1 {
+		fmt.Printf("Error: Remote command not specified\n")
+		return cli.ShowAppHelp(c)
+	}
+
+	// Create ExecOpts
+	opts := defaultDSHConfig()
+	// Set opts.Verbose output
+	opts.Verbose = false
+	if c.Bool("verbose") {
+		fmt.Printf("Verbose flag on\n")
+		opts.Verbose = true
+	}
+
+	// Find Consul server, env-var takes priority
+	consulServer := c.String("server")
+	if os.Getenv("CONSUL_SERVER") != "" {
+		consulServer = os.Getenv("CONSUL_SERVER")
+	}
+	// Can't be empty, we need servers
+	if consulServer == "" {
+		fmt.Printf("Error: consul-server not supplied\n")
+		return cli.ShowAppHelp(c)
+	}
+
+	// Create a consul client
+	client, err := consulClient(consulServer)
+	if err != nil {
+		return cli.Exit(fmt.Sprintf(
+			"Error creating consul agent: %s\n", err,
+		), 1)
+	}
+
+	// Parse requested service, if empty return a list of available services
+	service := c.String("service")
+	if service == "" {
+		fmt.Printf("No service specified. Available services:\n")
+		avail, err := consulServices(client)
+		if err != nil {
+			return cli.Exit(fmt.Sprintf(
+				"Error querying Consul services: %s\n", err,
+			), 1)
+		}
+		for k := range avail {
+			fmt.Printf("%s\n", k)
+		}
+		return nil
+	}
+
+	// Add consul services to linked list
+	machineList, err := populateList(client, service, c.String("user"))
+	if err != nil {
+		return cli.Exit(fmt.Sprintf(
+			"Error populating DSH machine list: %s\n", err,
+		), 1)
+	}
+	opts.MachineList = machineList
+
+	// Set remote commands to all trailing args
+	for _, v := range c.Args().Slice() {
+		// Initialize remote command
+		if opts.RemoteCommand == "" && v != "" {
+			opts.RemoteCommand = v
+			continue
+		}
+		opts.RemoteCommand = fmt.Sprintf("%s %s", opts.RemoteCommand, v)
+	}
+
+	// Execute DSH!
+	if err := opts.Execute(); err != nil {
+		return cli.Exit(fmt.Sprintf("Error executing: %s", err), 1)
+	}
+	return nil
+}
+
+// Default GDSH config
+// TODO: Make these configurable
+func defaultDSHConfig() dsh.ExecOpts {
+	opts := dsh.ExecOpts{
+		ConcurrentShell: true,
+		RemoteShell:     "ssh",
+		ShowNames:       true,
+	}
+	return opts
+}
+
+// Returns all available consul services
+func consulServices(client *consul.Client) (map[string][]string, error) {
+	// Create catalog
+	catalog := client.Catalog()
+	services, _, err := catalog.Services(nil)
+	if err != nil {
+		return nil, err
+	}
+	return services, nil
+}
+
+// Returns a Consul Client
+func consulClient(server string) (*consul.Client, error) {
+	// Create Consul Client
+	config := consul.DefaultConfig()
+	config.Address = server
+	return consul.NewClient(config)
+}
+
+// Populates doubly linked machine list, with a list of requested consul services's addresses
+func populateList(client *consul.Client, service string, user string) (*list.List, error) {
+	// Create consul agent
+	agent := client.Agent()
+	services, err := agent.Services()
+	if err != nil {
+		return nil, fmt.Errorf("Error querying consul services: %s", err)
+	}
+
+	serviceList := list.New()
+	for _, v := range services {
+		if v.Service == service {
+			remoteAddr := v.Address
+			if user != "" {
+				remoteAddr = fmt.Sprintf("%s@%s", user, remoteAddr)
+			}
+			addList(serviceList, remoteAddr)
+		}
+	}
+
+	return serviceList, nil
+}
+
+// Populates linked list with a supplied string element, ensuring no duplicates or nil values are stored
+func addList(llist *list.List, elem string) {
+	if elem == "" {
+		return
+	}
+	if llist.Len() == 0 {
+		llist.PushFront(elem)
+		return
+	}
+	// Verify no items match currently
+	for e := llist.Front(); e != nil; e = e.Next() {
+		if e.Value == elem {
+			return
+		}
+	}
+	llist.PushBack(elem)
+}