func Action(c *cli.Context) {
	if len(c.Args()) < 1 {
		fmt.Println("ERROR: Please specify a a task\n\n")
		cli.ShowAppHelp(c)
		return
	}

	task := c.Args()[0]

	tplVars := c.GlobalString("vars")
	cfgPath := c.GlobalString("config")
	env := c.GlobalString("environment")
	host := c.GlobalString("host")

	vars := parseVars(tplVars)
	file, err := ioutil.ReadFile(cfgPath)
	if err != nil {
		fmt.Printf("ERROR: could not find the config file: %s\n\n", cfgPath)
		cli.ShowAppHelp(c)
		return
	}

	cfg := LoadConfig(file, vars, env)
	if host != "" {
		Run(task, []string{host}, cfg)
	} else {
		Run(task, cfg.DeployEnvs[env].Hosts, cfg)
	}
}

// GetCmd extracts cmd from command line
func GetCmd(c *cli.Context) (cmd string) {
	argc := len(c.Args())
	if argc >= 2 {
		if cl.fifoFile == "" || argc > 2 {
			fmt.Println("Too Many Arguments (Command Must Be the Last One Parameter) !")
			cli.ShowAppHelp(c)
			os.Exit(1)
		}
	loop:
		for _, arg := range c.Args() {
			if arg != cl.fifoFile {
				cmd = arg
				break loop
			}
		}
	} else if argc == 1 && c.Args()[0] == cl.fifoFile || argc == 0 {
		cmd = getPipe(PIPEUSEDBYCMD)
		return
		fmt.Println("Command Must Be the Last One Parameter!")
		cli.ShowAppHelp(c)
		os.Exit(1)
	} else {
		cmd = c.Args()[argc-1]
	}
	return
}

func runApp(c *cli.Context) {
	uri := "amqp://guest:[email protected]" + c.String("server") + ":5672"

	queueName := queueBaseName
	queueDurability := c.Bool("durable")

	if c.String("queuesuffix") != "" {
		queueName = fmt.Sprintf("%s-%s", queueBaseName, c.String("queuesuffix"))
	}

	if c.Int("consumer") > -1 && c.Int("producer") != 0 {
		fmt.Println("Error: Cannot specify both producer and consumer options together")
		fmt.Println()
		cli.ShowAppHelp(c)
		os.Exit(1)
	} else if c.Int("consumer") > -1 {
		fmt.Println("Running in consumer mode")
		config := ConsumerConfig{uri, c.Bool("quiet")}
		makeConsumers(config, queueName, queueDurability, c.Int("concurrency"), c.Int("consumer"))
	} else if c.Int("producer") != 0 {
		fmt.Println("Running in producer mode")
		config := ProducerConfig{uri, c.Bool("quiet"), c.Int("bytes"), c.Bool("wait-for-ack")}
		makeProducers(config, queueName, queueDurability, c.Int("concurrency"), c.Int("producer"), c.Int("wait"))
	} else {
		cli.ShowAppHelp(c)
		os.Exit(0)
	}
}

func run(c *cli.Context) {

	user := c.String("User")
	if 0 == len(user) {
		cli.ShowAppHelp(c)
		log.Fatal("User must be provided")
	}

	text := c.String("Text")
	if 0 == len(text) {
		cli.ShowAppHelp(c)
		log.Fatal("Text must be provided")
	}

	amqpUri := c.String("AmqpUri")
	amqpExchange := c.String("AmqpExchange")
	amqpType := "direct"
	key := c.String("AmqpKey")
	amqpService := xmpptoamqp.NewAmqpService(&amqpUri, nil, nil, nil)
	amqpService.ExchangeDeclare(&amqpExchange, &amqpType)
	amqpService.Send(&amqpExchange, &key, &user, &text)

	log.WithFields(log.Fields{
		"user": c.String("User"),
	}).Info("Chat sent")

}

func main() {
	cli.AppHelpTemplate = AppHelpTemplate
	cli.CommandHelpTemplate = CommandHelpTemplate
	cli.SubcommandHelpTemplate = SubcommandHelpTemplate
	cli.VersionPrinter = printVersion

	app := cli.NewApp()
	app.Name = "buildkite-agent"
	app.Version = agent.Version()
	app.Commands = []cli.Command{
		clicommand.AgentStartCommand,
		{
			Name:  "artifact",
			Usage: "Upload/download artifacts from Buildkite jobs",
			Subcommands: []cli.Command{
				clicommand.ArtifactUploadCommand,
				clicommand.ArtifactDownloadCommand,
				clicommand.ArtifactShasumCommand,
			},
		},
		{
			Name:  "meta-data",
			Usage: "Get/set data from Buildkite jobs",
			Subcommands: []cli.Command{
				clicommand.MetaDataSetCommand,
				clicommand.MetaDataGetCommand,
				clicommand.MetaDataExistsCommand,
			},
		},
		{
			Name:  "pipeline",
			Usage: "Make changes to the pipeline of the currently running build",
			Subcommands: []cli.Command{
				clicommand.PipelineUploadCommand,
			},
		},
		clicommand.BootstrapCommand,
	}

	// When no sub command is used
	app.Action = func(c *cli.Context) {
		cli.ShowAppHelp(c)
		os.Exit(1)
	}

	// When a sub command can't be found
	app.CommandNotFound = func(c *cli.Context, command string) {
		cli.ShowAppHelp(c)
		os.Exit(1)
	}

	app.Run(os.Args)
}

func common(c *cli.Context) error {
	if c.GlobalString("seed") == "" {
		cli.ShowAppHelp(c)
		os.Exit(1)
	}
	if c.GlobalInt("sequence") == 0 {
		cli.ShowAppHelp(c)
		os.Exit(1)
	}
	key = parseSeed(c.String("seed"))
	return nil
}

func ServiceMaint(c *cli.Context) {
	// Get client
	cfg, err := NewAppConfig(c)
	if err != nil {
		log.Errorf("Failed to get client: %v", err)
		return
	}
	action := c.Args().First()
	service := c.Args().Tail()[0]
	reason := ""

	if len(c.Args().Tail()) > 1 {
		reason = c.Args().Tail()[1]
	}

	switch action {
	case "enable":
		if err = cfg.client.Agent().EnableServiceMaintenance(service, reason); err != nil {
			log.Errorf("Error setting maintenance mode: %v", err)
			return
		}
	case "disable":
		if err = cfg.client.Agent().DisableServiceMaintenance(service); err != nil {
			log.Errorf("Error disabling maintenance mode: %v", err)
			return
		}
	default:
		cli.ShowAppHelp(c)
		return
	}

	log.Println("Success")
}

func NewApp() *cli.App {
	cmds, err := parseCommands()
	if err != nil {
		log.Fatal(err)
	}

	app := cli.NewApp()
	app.Name = "gotask"
	app.Usage = "Build tool in Go"
	app.Version = Version
	app.Commands = cmds
	app.Flags = []cli.Flag{
		compileFlag{Usage: "compile the task binary to pkg.task but do not run it"},
	}
	app.Action = func(c *cli.Context) {
		if c.Bool("c") || c.Bool("compile") {
			err := compileTasks()
			if err != nil {
				log.Fatal(err)
			}

			return
		}

		if len(c.Args()) == 0 {
			cli.ShowAppHelp(c)
		}
	}

	return app
}

// GenerateDoc generating new documentation
func GenerateDoc(c *cli.Context) {
	md := c.String("input")
	html := c.String("output")
	t := c.String("template")
	path := c.String("path")
	sidebar := c.String("sidebar")

	if md == "" {
		cli.ShowAppHelp(c)
		return
	}

	fmt.Println("Begin generate")
	sb, _ := NewSidebar(sidebar)
	parent := &Dir{sidebar: sb}

	dir, err := NewDir(md, html, t, path)
	if err != nil {
		fmt.Printf("Error read dir %s\n \t%s\n", dir.mdDir, err.Error())
	}
	err = dir.read()

	if err != nil {
		fmt.Printf("Error read dir %s\n \t%s\n", dir.mdDir, err.Error())
	}
	err = dir.write(parent)

	if err != nil {
		fmt.Printf("Error write dir %s\n", dir.htmlDir)
	}

	fmt.Println("End generate")
}

func ToggleMaintenanceMode(c *cli.Context) {
	cfg, err := NewAppConfig(c)
	if err != nil {
		log.Errorf("Failed to get client: %v", err)
		return
	}

	action := c.Args().First()

	switch action {
	case "enable":
		if err = cfg.client.Agent().EnableNodeMaintenance(c.String("reason")); err != nil {
			log.Errorf("Could not set maintenance mode: %v", err)
			return
		}
	case "disable":
		if err = cfg.client.Agent().DisableNodeMaintenance(); err != nil {
			log.Errorf("Could not unset maintenance mode: %v", err)
			return
		}
	default:
		log.Warningf("Must choose either enable or disable")
		cli.ShowAppHelp(c)
		return
	}
	log.Println("Success")
}

func main() {
	app := cli.NewApp()
	app.Name = "seita"
	app.Usage = "Enshrine and retrieve project skeletons"
	app.EnableBashCompletion = true
	app.Authors = []cli.Author{
		{
			Name:  "Ilkka Laukkanen",
			Email: "[email protected]",
		},
	}
	app.Commands = []cli.Command{
		{
			Name:    "put",
			Aliases: []string{"p"},
			Usage:   "Offer up this project as a skeleton",
			Action:  command.Put,
		},
		{
			Name:    "make",
			Aliases: []string{"m"},
			Usage:   "Make a new project based on a skeleton",
			Action:  command.Make,
			Before:  requireArgs("get", 1),
		},
		{
			Name:    "config",
			Aliases: []string{"c"},
			Usage:   "Manipulate configuration",
			Subcommands: []cli.Command{
				{
					Name:    "set",
					Aliases: []string{"s"},
					Usage:   "Set configuration variable value",
					Action:  config.Set,
					Before:  requireArgs("set", 2),
				},
				{
					Name:    "get",
					Aliases: []string{"g"},
					Usage:   "Get configuration variable value",
					Action:  config.Get,
					Before:  requireArgs("get", 1),
				},
				{
					Name:    "list",
					Aliases: []string{"l"},
					Usage:   "List configuration variables",
					Action:  config.List,
				},
			},
		},
	}

	app.Action = func(c *cli.Context) {
		cli.ShowAppHelp(c)
	}

	app.RunAndExitOnError()
}

func UpdateACL(c *cli.Context) {
	if len(c.String("id")) > 1 {
		log.Errorln("--id is required!")
		cli.ShowAppHelp(c)
		return
	}

	cfg, err := NewAppConfig(c)
	if err != nil {
		log.Errorf("Failed to get client: %v", err)
		return
	}

	_, err = cfg.client.ACL().Update(&api.ACLEntry{
		Name:  c.String("name"),
		Type:  c.String("type"),
		Rules: c.Args().First(),
		ID:    c.String("id"),
	}, cfg.writeOpts)

	if err != nil {
		log.Errorf("Could not update ACL: %v", err)
		return
	}

	fmt.Println("Success")
}

func getOpts(context *cli.Context) (string, string, string, string, string) {
	etcdURI := context.String("etcd-uri")
	redisURI := context.String("redis-uri")
	redisQueue := context.String("redis-queue")
	deployStateUri := context.String("deploy-state-uri")
	cluster := context.String("cluster")

	if etcdURI == "" || redisURI == "" || redisQueue == "" || deployStateUri == "" || cluster == "" {
		cli.ShowAppHelp(context)

		if etcdURI == "" {
			color.Red("  Missing required flag --etcd-uri or GOVERNATOR_ETCD_URI")
		}
		if redisURI == "" {
			color.Red("  Missing required flag --redis-uri or GOVERNATOR_REDIS_URI")
		}
		if redisQueue == "" {
			color.Red("  Missing required flag --redis-queue or GOVERNATOR_REDIS_QUEUE")
		}
		if deployStateUri == "" {
			color.Red("  Missing required flag --deploy-state-uri or DEPLOY_STATE_URI")
		}
		if cluster == "" {
			color.Red("  Missing required flag --cluster or CLUSTER")
		}
		os.Exit(1)
	}

	return etcdURI, redisURI, redisQueue, deployStateUri, cluster
}

func errExit(ctx *cli.Context, err error, help bool) {
	fmt.Fprintf(os.Stderr, "\nError: %v\n\n", err)
	if help {
		cli.ShowAppHelp(ctx)
	}
	os.Exit(1)
}

func main() {
	app := cli.NewApp()
	app.Name = "rabbitmq-cli-consumer"
	app.Usage = "Consume RabbitMQ easily to any cli program"
	app.Author = "Richard van den Brand"
	app.Email = "[email protected]"
	app.Version = "1.1.0"
	app.Flags = []cli.Flag{
		cli.StringFlag{
			Name:  "executable, e",
			Usage: "Location of executable",
		},
		cli.StringFlag{
			Name:  "configuration, c",
			Usage: "Location of configuration file",
		},
		cli.BoolFlag{
			Name:  "verbose, V",
			Usage: "Enable verbose mode (logs to stdout and stderr)",
		},
	}
	app.Action = func(c *cli.Context) {
		if c.String("configuration") == "" && c.String("executable") == "" {
			cli.ShowAppHelp(c)
			os.Exit(1)
		}

		verbose := c.Bool("verbose")

		logger := log.New(os.Stderr, "", log.Ldate|log.Ltime)
		cfg, err := config.LoadAndParse(c.String("configuration"))

		command.Cconf = cfg

		if err != nil {
			logger.Fatalf("Failed parsing configuration: %s\n", err)
		}

		errLogger, err := createLogger(cfg.Logs.Error, verbose, os.Stderr)
		if err != nil {
			logger.Fatalf("Failed creating error log: %s", err)
		}

		infLogger, err := createLogger(cfg.Logs.Info, verbose, os.Stdout)
		if err != nil {
			logger.Fatalf("Failed creating info log: %s", err)
		}

		factory := command.Factory(c.String("executable"))

		client, err := consumer.New(cfg, factory, errLogger, infLogger)
		if err != nil {
			errLogger.Fatalf("Failed creating consumer: %s", err)
		}

		client.Consume()
	}

	app.Run(os.Args)
}

func GetKvKey(c *cli.Context) {
	if !c.Args().Present() {
		cli.ShowAppHelp(c)
		return
	}

	// Get client
	cfg, err := NewAppConfig(c)
	if err != nil {
		log.Errorf("Failed to get client: %v", err)
		return
	}

	kv := cfg.client.KV()
	var results []*api.KVPair
	for _, a := range append([]string{c.Args().First()}, c.Args().Tail()...) {
		if c.Bool("recurse") {
			pairs, _, err := kv.List(a, cfg.queryOpts)
			if err != nil {
				log.Debugf("Could not list keys: %v", err)
				continue
			}

			for _, p := range pairs {
				results = append(results, p)
			}
			continue
		}

		pair, _, err := kv.Get(a, cfg.queryOpts)
		if err != nil {
			log.Debugf("Could not retrieve key: %v", err)
			continue
		}
		if pair != nil {
			results = append(results, pair)
		}
	}

	if len(results) > 0 {
		if c.GlobalBool("verbose") {
			for _, r := range results {
				bytes, err := marshalPrettyKey(r)
				if err != nil {
					log.Debugf("Could not marshal JSON: %v\n", err)
				}
				fmt.Println(string(bytes))
			}
			return
		}

		for _, r := range results {
			fmt.Printf("%s\n", r.Value)
		}

		return
	}

	log.Errorln("Key not found")
}

func FireEvent(c *cli.Context) {
	if len(c.Args().First()) < 1 || len(c.Args().Tail()) < 1 {
		log.Errorln("name and payload are required")
		cli.ShowAppHelp(c)
		return
	}
	cfg, err := NewAppConfig(c)
	if err != nil {
		log.Errorf("Failed to get client: %v", err)
		return
	}

	event := &api.UserEvent{
		Name:          c.Args().First(),
		Payload:       []byte(c.Args().Tail()[0]),
		NodeFilter:    c.String("node"),
		ServiceFilter: c.String("service"),
		TagFilter:     c.String("tag"),
	}
	eid, _, err := cfg.client.Event().Fire(event, cfg.writeOpts)

	if err != nil {
		log.Errorf("Could not fire event: %v", err)
		return
	}
	fmt.Println(eid)
}

func main() {
	app := cli.NewApp()
	cli.AppHelpTemplate = appHelpTemplate
	app.Name = "multic"
	app.Version = "0.0.5"
	app.Usage = "Run shell commands in multiple directories."
	app.Flags = []cli.Flag{
		cli.BoolFlag{
			Name:  "list, l",
			Usage: "list configured directory groups",
		},
		cli.StringSliceFlag{
			Name:  "group, g",
			Value: &cli.StringSlice{},
			Usage: "specify a directory group",
		},
		cli.StringFlag{
			Name:  "configuration, c",
			Value: "~/.multic/config",
			Usage: "specify a configuration file",
		},
	}
	app.Action = func(ctx *cli.Context) {
		args := ctx.Args()
		config := config.LoadConfig(ctx.String("configuration"))
		if ctx.IsSet("list") {
			printDirectoryGroups(config)
		} else if len(args) == 0 {
			cli.ShowAppHelp(ctx)
		} else {
			run(config, ctx.StringSlice("group"), args)
		}
	}
	app.Run(os.Args)
}

func main() {
	app := cli.NewApp()
	app.Name = "swarm-bench"
	app.Usage = "Swarm Benchmarking Tool"
	app.Version = "0.1.0"
	app.Author = ""
	app.Email = ""
	app.Flags = []cli.Flag{
		cli.IntFlag{
			Name:  "concurrency, c",
			Value: 1,
			Usage: "Number of multiple requests to perform at a time. Default is one request at a time.",
		},
		cli.IntFlag{
			Name:  "requests, n",
			Value: 1,
			Usage: "Number of containers to start for the benchmarking session. The default is to just start a single container.",
		},
		cli.StringFlag{
			Name:  "image, i",
			Usage: "Image to use for benchmarking.",
		},
	}

	app.Action = func(c *cli.Context) {
		if c.String("image") == "" {
			cli.ShowAppHelp(c)
			os.Exit(1)
		}
		bench(c.Int("requests"), c.Int("concurrency"), c.String("image"))
	}

	app.Run(os.Args)
}

func run(c *cli.Context) {
	args := c.Args()
	if len(c.Args()) == 0 {
		cli.ShowAppHelp(c)
		os.Exit(1)
	}

	doSplay(c)

	suppressRegexpSlice := make(regexpSlice, len(c.StringSlice(`suppress-regexp`)))
	for i, s := range c.StringSlice(`suppress-regexp`) {
		suppressRegexpSlice[i] = regexp.MustCompile(s)
	}

	forceRegexpSlice := make(regexpSlice, len(c.StringSlice(`force-regexp`)))
	for i, s := range c.StringSlice(`force-regexp`) {
		forceRegexpSlice[i] = regexp.MustCompile(s)
	}

	var cmd *exec.Cmd
	if len(args) > 1 {
		cmd = exec.Command(args[0], args[1:len(args)]...)
	} else {
		cmd = exec.Command(args[0])
	}

	doCmd(c, cmd, forceRegexpSlice, suppressRegexpSlice)
}