func main() {
loadConfig()
// Don't print date, etc. and print to stdout
log.DefaultLogger = log.New(os.Stdout, "", log.INFO)
log.DefaultLogger.SetFlags(0)
app := cli.NewApp()
app.Name = "galaxy"
app.Usage = "galaxy cli"
app.Version = buildVersion
app.Flags = []cli.Flag{
cli.StringFlag{Name: "registry", Value: "", Usage: "host:port[,host:port,..]"},
cli.StringFlag{Name: "env", Value: "", Usage: "environment (dev, test, prod, etc.)"},
cli.StringFlag{Name: "pool", Value: "", Usage: "pool (web, worker, etc.)"},
}
app.Commands = []cli.Command{
{
Name: "app",
Usage: "list the apps currently created",
Action: appList,
Description: "app",
},
{
Name: "app:backup",
Usage: "backup app configs to a file or stdout",
Action: appBackup,
Description: "app:backup [app[,app2]]",
Flags: []cli.Flag{
cli.StringFlag{Name: "file", Usage: "backup filename"},
},
},
{
Name: "app:restore",
Usage: "restore an app's config",
Action: appRestore,
Description: "app:restore [app[,app2]]",
Flags: []cli.Flag{
cli.StringFlag{Name: "file", Usage: "backup filename"},
cli.BoolFlag{Name: "force", Usage: "force overwrite of existing config"},
},
},
{
Name: "app:create",
Usage: "create a new app",
Action: appCreate,
Description: "app:create",
},
{
Name: "app:delete",
Usage: "delete a new app",
Action: appDelete,
Description: "app:delete",
},
{
Name: "app:deploy",
Usage: "deploy a new version of an app",
Action: appDeploy,
Description: "app:deploy <app> <version>",
Flags: []cli.Flag{
cli.BoolFlag{Name: "force", Usage: "force pulling the image"},
},
},
{
Name: "app:restart",
Usage: "restart an app",
Action: appRestart,
Description: "app:restart <app>",
},
{
Name: "app:run",
Usage: "run a command in a container",
Action: appRun,
Description: "app:run <app> <command>",
},
{
Name: "app:shell",
Usage: "run a bash shell in a container",
Action: appShell,
Description: "app:shell <app>",
},
{
Name: "config",
Usage: "list the config values for an app",
Action: configList,
Description: "config <app>",
},
{
Name: "config:set",
Usage: "set one or more configuration variables",
Action: configSet,
Description: "config:set <app> KEY=VALUE [KEY=VALUE ...]",
},
{
Name: "config:unset",
Usage: "unset one or more configuration variables",
Action: configUnset,
Description: "config:unset <app> KEY [KEY ...]",
},
{
Name: "config:get",
Usage: "display the config value for an app",
Action: configGet,
Description: "config:get <app> KEY [KEY ...]",
},
{
Name: "pool",
Usage: "list the pools",
Action: poolList,
Description: "pool",
},
{
Name: "pool:assign",
Usage: "assign an app to a pool",
Action: poolAssign,
Description: "pool:assign",
},
{
Name: "pool:unassign",
Usage: "unassign an app from a pool",
Action: poolUnassign,
Description: "pool:unassign",
},
{
Name: "pool:create",
Usage: "create a pool",
Action: poolCreate,
Description: "pool:create",
},
{
Name: "pool:delete",
Usage: "deletes a pool",
Action: poolDelete,
Description: "pool:delete",
Flags: []cli.Flag{
cli.BoolFlag{Name: "y", Usage: "skip confirmation"},
},
},
{
Name: "pg:psql",
Usage: "connect to database using psql",
Action: pgPsql,
Description: "pg:psql <app>",
},
}
app.Run(os.Args)
}
func main() {
flag.Int64Var(&stopCutoff, "cutoff", 10, "Seconds to wait before stopping old containers")
flag.StringVar(®istryURL, "registry", utils.GetEnv("GALAXY_REGISTRY_URL", "redis://127.0.0.1:6379"), "registry URL")
flag.StringVar(&env, "env", utils.GetEnv("GALAXY_ENV", ""), "Environment namespace")
flag.StringVar(&pool, "pool", utils.GetEnv("GALAXY_POOL", ""), "Pool namespace")
flag.StringVar(&hostIP, "host-ip", "127.0.0.1", "Host IP")
flag.StringVar(&shuttleAddr, "shuttle-addr", "", "Shuttle API addr (127.0.0.1:9090)")
flag.StringVar(&dns, "dns", "", "DNS addr to use for containers")
flag.BoolVar(&debug, "debug", false, "verbose logging")
flag.BoolVar(&version, "v", false, "display version info")
flag.Usage = func() {
println("Usage: commander [options] <command> [<args>]\n")
println("Available commands are:")
println(" agent Runs commander agent")
println(" app List all apps")
println(" app:assign Assign an app to a pool")
println(" app:create Create an app")
println(" app:deploy Deploy an app")
println(" app:delete Delete an app")
println(" app:restart Restart an app")
println(" app:run Run a command within an app on this host")
println(" app:shell Run a shell within an app on this host")
println(" app:start Starts one or more apps")
println(" app:stop Stops one or more apps")
println(" app:unassign Unassign an app from a pool")
println(" config List config for an app")
println(" config:get Get config values for an app")
println(" config:set Set config values for an app")
println(" config:unset Unset config values for an app")
println(" runtime List container runtime policies")
println(" runtime:set Set container runtime policies")
println(" hosts List hosts in an env and pool")
println("\nOptions:\n")
flag.PrintDefaults()
}
flag.Parse()
if version {
fmt.Println(buildVersion)
return
}
log.DefaultLogger = log.New(os.Stdout, "", log.INFO)
log.DefaultLogger.SetFlags(0)
if debug {
log.DefaultLogger.Level = log.DEBUG
}
if flag.NArg() < 1 {
fmt.Println("Need a command")
flag.Usage()
os.Exit(1)
}
initOrDie()
switch flag.Args()[0] {
case "dump":
if flag.NArg() < 2 {
fmt.Println("Usage: commander dump ENV")
os.Exit(1)
}
dump(flag.Arg(1))
return
case "restore":
if flag.NArg() < 2 {
fmt.Println("Usage: commander dump ENV FILE")
os.Exit(1)
}
restore(flag.Arg(1))
return
case "agent":
log.DefaultLogger.SetFlags(golog.LstdFlags)
loop = true
agentFs := flag.NewFlagSet("agent", flag.ExitOnError)
agentFs.Usage = func() {
println("Usage: commander agent [options]\n")
println(" Runs commander continuously\n\n")
println("Options:\n\n")
agentFs.PrintDefaults()
}
agentFs.Parse(flag.Args()[1:])
ensureEnv()
ensurePool()
case "app":
appFs := flag.NewFlagSet("app", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app\n")
println(" List all apps or apps in an environment\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
err := commander.AppList(configStore, env)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:assign":
appFs := flag.NewFlagSet("app:assign", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:assign <app>\n")
println(" Assign an app to a pool\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
ensurePool()
if appFs.NArg() != 1 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppAssign(configStore, appFs.Args()[0], env, pool)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:create":
appFs := flag.NewFlagSet("app:create", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:create <app>\n")
println(" Create an app in an environment\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
if appFs.NArg() == 0 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppCreate(configStore, appFs.Args()[0], env)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:delete":
appFs := flag.NewFlagSet("app:delete", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:delete <app>\n")
println(" Delete an app in an environment\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
if appFs.NArg() == 0 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppDelete(configStore, appFs.Args()[0], env)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:deploy":
appFs := flag.NewFlagSet("app:delete", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:deploy [-force] <app> <version>\n")
println(" Deploy an app in an environment\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
if appFs.NArg() != 2 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppDeploy(configStore, serviceRuntime, appFs.Args()[0], env, appFs.Args()[1])
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:restart":
appFs := flag.NewFlagSet("app:restart", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:restart <app>\n")
println(" Restart an app in an environment\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
if appFs.NArg() == 0 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppRestart(configStore, appFs.Args()[0], env)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:run":
appFs := flag.NewFlagSet("app:run", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:run <app> <cmd>\n")
println(" Restart an app in an environment\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
if appFs.NArg() < 2 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppRun(configStore, serviceRuntime, appFs.Args()[0], env, appFs.Args()[1:])
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:shell":
appFs := flag.NewFlagSet("app:shell", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:shell <app>\n")
println(" Run a shell for an app\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
ensurePool()
if appFs.NArg() != 1 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppShell(configStore, serviceRuntime, appFs.Args()[0], env, pool)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "app:start":
startFs := flag.NewFlagSet("app:start", flag.ExitOnError)
startFs.Usage = func() {
println("Usage: commander app:start [options] [<app>]*\n")
println(" Starts one or more apps. If no apps are specified, starts all apps.\n")
println("Options:\n")
startFs.PrintDefaults()
}
startFs.Parse(flag.Args()[1:])
apps = startFs.Args()
if len(apps) == 0 {
acs, err := configStore.ListApps(env)
if err != nil {
log.Fatalf("ERROR: Unable to list apps: %s", err)
}
for _, ac := range acs {
apps = append(apps, ac.Name())
}
}
break
case "app:status":
// FIXME: undocumented
statusFs := flag.NewFlagSet("app:status", flag.ExitOnError)
statusFs.Usage = func() {
println("Usage: commander app:status [options] [<app>]*\n")
println(" Lists status of running apps.\n")
println("Options:\n")
statusFs.PrintDefaults()
}
statusFs.Parse(flag.Args()[1:])
ensureEnv()
ensurePool()
err := discovery.Status(serviceRuntime, configStore, env, pool, hostIP)
if err != nil {
log.Fatalf("ERROR: Unable to list app status: %s", err)
}
return
case "app:stop":
stopFs := flag.NewFlagSet("app:stop", flag.ExitOnError)
stopFs.Usage = func() {
println("Usage: commander app:stop [options] [<app>]*\n")
println(" Stops one or more apps. If no apps are specified, stops all apps.\n")
println("Options:\n")
stopFs.PrintDefaults()
}
stopFs.Parse(flag.Args()[1:])
apps = stopFs.Args()
for _, app := range apps {
err := serviceRuntime.StopAllMatching(app)
if err != nil {
log.Fatalf("ERROR: Unable able to stop all containers: %s", err)
}
}
if len(apps) > 0 {
return
}
err := serviceRuntime.StopAll(env)
if err != nil {
log.Fatalf("ERROR: Unable able to stop all containers: %s", err)
}
return
case "app:unassign":
appFs := flag.NewFlagSet("app:unassign", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander app:unassign <app>\n")
println(" Unassign an app to a pool\n")
println("Options:\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
ensurePool()
if appFs.NArg() != 1 {
appFs.Usage()
os.Exit(1)
}
err := commander.AppUnassign(configStore, appFs.Args()[0], env, pool)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "hosts":
hostFs := flag.NewFlagSet("hosts", flag.ExitOnError)
hostFs.Usage = func() {
println("Usage: commander hosts\n")
println(" List hosts in an env and pool\n")
println("Options:\n")
hostFs.PrintDefaults()
}
err := hostFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
ensureEnv()
ensurePool()
err = commander.HostsList(configStore, env, pool)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "config":
configFs := flag.NewFlagSet("config", flag.ExitOnError)
usage := "Usage: commander config <app>"
configFs.Usage = func() {
println(usage)
println(" List config values for an app\n")
println("Options:\n")
configFs.PrintDefaults()
}
err := configFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
ensureEnv()
if configFs.NArg() != 1 {
log.Error("ERROR: Missing app name argument")
log.Printf("Usage: %s", usage)
os.Exit(1)
}
app := configFs.Args()[0]
err = commander.ConfigList(configStore, app, env)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "config:get":
configFs := flag.NewFlagSet("config:get", flag.ExitOnError)
configFs.Usage = func() {
println("Usage: commander config <app> KEY [KEY]*\n")
println(" Get config values for an app\n")
println("Options:\n")
configFs.PrintDefaults()
}
err := configFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
ensureEnv()
if configFs.NArg() == 0 {
log.Errorf("ERROR: Missing app name")
configFs.Usage()
os.Exit(1)
}
app := configFs.Args()[0]
err = commander.ConfigGet(configStore, app, env, configFs.Args()[1:])
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "config:set":
configFs := flag.NewFlagSet("config:set", flag.ExitOnError)
configFs.Usage = func() {
println("Usage: commander config <app> KEY=VALUE [KEY=VALUE]*\n")
println(" Set config values for an app\n")
println("Options:\n")
configFs.PrintDefaults()
}
err := configFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
ensureEnv()
if configFs.NArg() == 0 {
log.Errorf("ERROR: Missing app name")
configFs.Usage()
os.Exit(1)
}
app := configFs.Args()[0]
err = commander.ConfigSet(configStore, app, env, configFs.Args()[1:])
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "config:unset":
configFs := flag.NewFlagSet("config:unset", flag.ExitOnError)
configFs.Usage = func() {
println("Usage: commander config <app> KEY [KEY]*\n")
println(" Unset config values for an app\n")
println("Options:\n")
configFs.PrintDefaults()
}
err := configFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
ensureEnv()
if configFs.NArg() == 0 {
log.Errorf("ERROR: Missing app name")
configFs.Usage()
os.Exit(1)
}
app := configFs.Args()[0]
err = commander.ConfigUnset(configStore, app, env, configFs.Args()[1:])
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "runtime":
runtimeFs := flag.NewFlagSet("runtime", flag.ExitOnError)
runtimeFs.Usage = func() {
println("Usage: commander runtime\n")
println(" List container runtime policies\n")
println("Options:\n")
runtimeFs.PrintDefaults()
}
err := runtimeFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
app := ""
if runtimeFs.NArg() > 0 {
app = runtimeFs.Args()[0]
}
err = commander.RuntimeList(configStore, app, env, pool)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
return
case "runtime:set":
var ps int
var m string
var c string
var vhost string
var port string
var maint string
runtimeFs := flag.NewFlagSet("runtime:set", flag.ExitOnError)
runtimeFs.IntVar(&ps, "ps", 0, "Number of instances to run across all hosts")
runtimeFs.StringVar(&m, "m", "", "Memory limit (format: <number><optional unit>, where unit = b, k, m or g)")
runtimeFs.StringVar(&c, "c", "", "CPU shares (relative weight)")
runtimeFs.StringVar(&vhost, "vhost", "", "Virtual host for HTTP routing")
runtimeFs.StringVar(&port, "port", "", "Service port for service discovery")
runtimeFs.StringVar(&maint, "maint", "", "Enable or disable maintenance mode")
runtimeFs.Usage = func() {
println("Usage: commander runtime:set [-ps 1] [-m 100m] [-c 512] [-vhost x.y.z] [-port 8000] [-maint false] <app>\n")
println(" Set container runtime policies\n")
println("Options:\n")
runtimeFs.PrintDefaults()
}
err := runtimeFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
ensureEnv()
if ps != 0 || m != "" || c != "" || maint != "" {
ensurePool()
}
if runtimeFs.NArg() != 1 {
runtimeFs.Usage()
os.Exit(1)
}
app := runtimeFs.Args()[0]
_, err = utils.ParseMemory(m)
if err != nil {
log.Fatalf("ERROR: Bad memory option %s: %s", m, err)
}
updated, err := commander.RuntimeSet(configStore, app, env, pool, commander.RuntimeOptions{
Ps: ps,
Memory: m,
CPUShares: c,
VirtualHost: vhost,
Port: port,
MaintenanceMode: maint,
})
if err != nil {
log.Fatalf("ERROR: %s", err)
}
if !updated {
log.Fatalf("ERROR: Failed to set runtime options.")
}
if pool != "" {
log.Printf("Runtime options updated for %s in %s running on %s", app, env, pool)
} else {
log.Printf("Runtime options updated for %s in %s", app, env)
}
return
case "runtime:unset":
var ps, m, c, port bool
var vhost string
runtimeFs := flag.NewFlagSet("runtime:unset", flag.ExitOnError)
runtimeFs.BoolVar(&ps, "ps", false, "Number of instances to run across all hosts")
runtimeFs.BoolVar(&m, "m", false, "Memory limit")
runtimeFs.BoolVar(&c, "c", false, "CPU shares (relative weight)")
runtimeFs.StringVar(&vhost, "vhost", "", "Virtual host for HTTP routing")
runtimeFs.BoolVar(&port, "port", false, "Service port for service discovery")
runtimeFs.Usage = func() {
println("Usage: commander runtime:unset [-ps] [-m] [-c] [-vhost x.y.z] [-port] <app>\n")
println(" Reset and removes container runtime policies to defaults\n")
println("Options:\n")
runtimeFs.PrintDefaults()
}
err := runtimeFs.Parse(flag.Args()[1:])
if err != nil {
log.Fatalf("ERROR: Bad command line options: %s", err)
}
ensureEnv()
if ps || m || c {
ensurePool()
}
if runtimeFs.NArg() != 1 {
runtimeFs.Usage()
os.Exit(1)
}
app := runtimeFs.Args()[0]
options := commander.RuntimeOptions{
VirtualHost: vhost,
}
if ps {
options.Ps = -1
}
if m {
options.Memory = "-"
}
if c {
options.CPUShares = "-"
}
if port {
options.Port = "-"
}
updated, err := commander.RuntimeUnset(configStore, app, env, pool, options)
if err != nil {
log.Fatalf("ERROR: %s", err)
}
if !updated {
log.Fatalf("ERROR: Failed to set runtime options.")
}
if pool != "" {
log.Printf("Runtime options updated for %s in %s running on %s", app, env, pool)
} else {
log.Printf("Runtime options updated for %s in %s", app, env)
}
return
case "pool":
err := commander.ListPools(configStore, env)
if err != nil {
log.Fatal(err)
}
return
case "pool:create":
appFs := flag.NewFlagSet("pool:create", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander -env <env> pool:create <pool>\n")
println(" Create a pool in <env>\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
if pool == "" && appFs.NArg() > 0 {
pool = appFs.Arg(0)
} else {
ensurePool()
}
err := commander.PoolCreate(configStore, env, pool)
if err != nil {
log.Fatalf("ERROR: Could not create pool: %s", err)
}
fmt.Println("created pool:", pool)
return
case "pool:delete":
appFs := flag.NewFlagSet("pool:delete", flag.ExitOnError)
appFs.Usage = func() {
println("Usage: commander -env <env> pool:delete <pool>\n")
println(" Delete a pool from <env>\n")
appFs.PrintDefaults()
}
appFs.Parse(flag.Args()[1:])
ensureEnv()
if pool == "" && flag.NArg() > 1 {
pool = flag.Arg(1)
} else {
ensurePool()
}
err := commander.PoolDelete(configStore, env, pool)
if err != nil {
log.Fatalf("ERROR: Could not delete pool: %s", err)
return
}
fmt.Println("deleted pool:", pool)
return
default:
fmt.Println("Unknown command")
flag.Usage()
os.Exit(1)
}
ensureEnv()
ensurePool()
log.Printf("Starting commander %s", buildVersion)
log.Printf("env=%s pool=%s host-ip=%s registry=%s shuttle-addr=%s dns=%s cutoff=%ds",
env, pool, hostIP, registryURL, shuttleAddr, dns, stopCutoff)
defer func() {
configStore.DeleteHost(env, pool, config.HostInfo{
HostIP: hostIP,
})
}()
for app, ch := range workerChans {
if len(apps) == 0 || utils.StringInSlice(app, apps) {
wg.Add(1)
go restartContainers(app, ch)
ch <- "deploy"
}
}
if loop {
wg.Add(1)
go heartbeatHost()
go discovery.Register(serviceRuntime, configStore, env, pool, hostIP, shuttleAddr)
cancelChan := make(chan struct{})
// do we need to cancel ever?
restartChan := configStore.Watch(env, cancelChan)
monitorService(restartChan)
}
// TODO: do we still need a WaitGroup?
wg.Wait()
}
func main() {
loadConfig()
// Don't print date, etc. and print to stdout
log.DefaultLogger = log.New(os.Stdout, "", log.INFO)
log.DefaultLogger.SetFlags(0)
// declare one superset of flags for stack operations, so we don't pollute the global flags
// TODO: these need to be broken up into proper sets for each command to
// prevent confusing help messages.
stackFlags := []cli.Flag{
cli.StringFlag{Name: "base", Usage: "base stack name"},
cli.StringFlag{Name: "keyname", Usage: "ssh keypair name"},
cli.StringFlag{Name: "ami", Usage: "ami id"},
cli.StringFlag{Name: "instance-type", Usage: "instance type"},
cli.IntFlag{Name: "volume-size", Usage: "stack instance volume size in GB", Value: 100},
cli.StringFlag{Name: "parameters", Usage: "template parameters in json"},
cli.StringFlag{Name: "ssl-cert", Usage: "SSL certificate name"},
cli.StringFlag{Name: "policy", Usage: "stack policy"},
cli.StringFlag{Name: "region", Usage: "aws region"},
cli.IntFlag{Name: "availability-zones", Usage: "number of availability zones to run a pool in"},
cli.BoolFlag{Name: "elb", Usage: "add an ELB when creating a stack"},
cli.StringFlag{Name: "http-health-check", Usage: "ELB health check address", Value: "HTTP:9090/_config"},
cli.IntFlag{Name: "http-port", Usage: "instance http port for ELB listeners"},
cli.StringFlag{Name: "template", Usage: "provide a template file"},
cli.IntFlag{Name: "min-size", Usage: "minimum pool size"},
cli.IntFlag{Name: "max-size", Usage: "maximum pool size"},
cli.IntFlag{Name: "desired-size", Usage: "desired pool size"},
cli.BoolFlag{Name: "print", Usage: "print new template and exit [noop]"},
cli.BoolFlag{Name: "auto-update", Usage: "add an ASG UpdatePolicy"},
cli.IntFlag{Name: "scale-adj", Usage: "number of instances to add/remove when scaling"},
cli.IntFlag{Name: "scale-up-delay", Usage: "minutes to wait for scaling up"},
cli.IntFlag{Name: "scale-down-delay", Usage: "minutes to wait for scaling down"},
cli.IntFlag{Name: "scale-up-cpu", Usage: "cpu threshold for scaling up"},
cli.IntFlag{Name: "scale-down-cpu", Usage: "cpu threshold for scaling down"},
cli.IntFlag{Name: "update-min", Usage: "minimum instances in service during auto-update", Value: 1},
cli.IntFlag{Name: "update-batch", Usage: "max instance instances to auto-update at once", Value: 1},
cli.DurationFlag{Name: "update-pause", Usage: "Pause time between auto-update actions (0s-5m30s)", Value: 5 * time.Minute},
}
app := cli.NewApp()
app.Name = "galaxy"
app.Usage = "galaxy cli"
app.Version = buildVersion
app.Flags = []cli.Flag{
cli.StringFlag{Name: "registry", Value: "", Usage: "host:port[,host:port,..]"},
cli.StringFlag{Name: "env", Value: "", Usage: "environment (dev, test, prod, etc.)"},
cli.StringFlag{Name: "pool", Value: "", Usage: "pool (web, worker, etc.)"},
}
app.Commands = []cli.Command{
{
Name: "init",
Usage: "initialize the galaxy infrastructure",
Action: stackInit,
Description: "stack:init <stack_name>",
Flags: []cli.Flag{
cli.StringFlag{Name: "template", Usage: "template file"},
cli.StringFlag{Name: "region", Usage: "AWS Region"},
cli.BoolFlag{Name: "print", Usage: "print template and exit"},
},
},
{
Name: "app",
Usage: "list the apps currently created",
Action: appList,
Description: "app",
},
{
Name: "app:backup",
Usage: "backup app configs to a file or stdout",
Action: appBackup,
Description: "app:backup [app[,app2]]",
Flags: []cli.Flag{
cli.StringFlag{Name: "file", Usage: "backup filename"},
},
},
{
Name: "app:restore",
Usage: "restore an app's config",
Action: appRestore,
Description: "app:restore [app[,app2]]",
Flags: []cli.Flag{
cli.StringFlag{Name: "file", Usage: "backup filename"},
cli.BoolFlag{Name: "force", Usage: "force overwrite of existing config"},
},
},
{
Name: "app:create",
Usage: "create a new app",
Action: appCreate,
Description: "app:create",
},
{
Name: "app:delete",
Usage: "delete a new app",
Action: appDelete,
Description: "app:delete",
},
{
Name: "app:deploy",
Usage: "deploy a new version of an app",
Action: appDeploy,
Description: "app:deploy <app> <version>",
Flags: []cli.Flag{
cli.BoolFlag{Name: "force", Usage: "force pulling the image"},
},
},
{
Name: "app:restart",
Usage: "restart an app",
Action: appRestart,
Description: "app:restart <app>",
},
{
Name: "app:run",
Usage: "run a command in a container",
Action: appRun,
Description: "app:run <app> <command>",
},
{
Name: "app:shell",
Usage: "run a bash shell in a container",
Action: appShell,
Description: "app:shell <app>",
},
{
Name: "config",
Usage: "list the config values for an app",
Action: configList,
Description: "config <app>",
},
{
Name: "config:set",
Usage: "set one or more configuration variables",
Action: configSet,
Description: "config:set <app> KEY=VALUE [KEY=VALUE ...]",
},
{
Name: "config:unset",
Usage: "unset one or more configuration variables",
Action: configUnset,
Description: "config:unset <app> KEY [KEY ...]",
},
{
Name: "config:get",
Usage: "display the config value for an app",
Action: configGet,
Description: "config:get <app> KEY [KEY ...]",
},
{
Name: "pool",
Usage: "list the pools",
Action: poolList,
Description: "pool",
},
{
Name: "pool:assign",
Usage: "assign an app to a pool",
Action: poolAssign,
Description: "pool:assign",
},
{
Name: "pool:unassign",
Usage: "unassign an app from a pool",
Action: poolUnassign,
Description: "pool:unassign",
},
{
Name: "pool:create",
Usage: "create a pool",
Action: poolCreate,
Description: "pool:create",
Flags: stackFlags,
},
{
Name: "pool:update",
Usage: "update a pool's stack",
Action: poolUpdate,
Description: "pool:update",
Flags: stackFlags,
},
{
Name: "pool:delete",
Usage: "deletes a pool",
Action: poolDelete,
Description: "pool:delete",
Flags: []cli.Flag{
cli.BoolFlag{Name: "y", Usage: "skip confirmation"},
},
},
{
Name: "pg:psql",
Usage: "connect to database using psql",
Action: pgPsql,
Description: "pg:psql <app>",
},
{
Name: "stack:template",
Usage: "print the cloudformation template to stdout",
Action: stackTemplate,
Description: "stack:template <stack_name>",
},
{
Name: "stack:update",
Usage: "update the base stack directly by name. Requires a template.",
Action: stackUpdate,
Description: "stack:update <stack_name>",
Flags: stackFlags,
},
{
Name: "stack:delete",
Usage: "delete a stack",
Action: stackDelete,
Description: "stack:delete <stack_name>",
Flags: []cli.Flag{
cli.BoolFlag{Name: "y", Usage: "skip confirmation"},
cli.StringFlag{Name: "region", Usage: "aws region"},
},
},
{
Name: "stack:pool_create",
Usage: "create a pool stack directly",
Action: stackCreatePool,
Description: "stack:pool_create",
Flags: stackFlags,
},
{
Name: "stack:pool_update",
Usage: "update a pool's stack",
Action: stackUpdatePool,
Description: "stack:pool_update",
Flags: stackFlags,
},
{
Name: "stack:events",
Usage: "list recent events for a stack",
Action: stackListEvents,
Description: "stack:events",
},
{
Name: "stack",
Usage: "list all stacks",
Action: stackList,
Description: "stack",
Flags: stackFlags,
},
}
app.Run(os.Args)
}