func cmdEnvUnset(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) == 0 {
stdcli.Error(errors.New("No variable specified"))
return
}
if len(c.Args()) > 1 {
stdcli.Error(errors.New("Only 1 variable can be unset at a time"))
return
}
key := c.Args()[0]
_, err = rackClient(c).DeleteEnvironment(app, key)
if err != nil {
stdcli.Error(err)
return
}
}
func cmdReleaseInfo(c *cli.Context) {
if len(c.Args()) < 1 {
stdcli.Usage(c, "release info")
return
}
release := c.Args()[0]
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
r, err := rackClient(c).GetRelease(app, release)
if err != nil {
stdcli.Error(err)
return
}
fmt.Printf("Id %s\n", r.Id)
fmt.Printf("Build %s\n", r.Build)
fmt.Printf("Created %s\n", r.Created)
fmt.Printf("Env ")
fmt.Println(strings.Replace(r.Env, "\n", "\n ", -1))
}
func cmdEnvGet(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) == 0 {
stdcli.Error(errors.New("No variable specified"))
return
}
if len(c.Args()) > 1 {
stdcli.Error(errors.New("Only 1 variable can be retrieved at a time"))
return
}
variable := c.Args()[0]
env, err := rackClient(c).GetEnvironment(app)
if err != nil {
stdcli.Error(err)
return
}
fmt.Println(env[variable])
}
func cmdAppCreate(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) > 0 {
app = c.Args()[0]
}
if app == "" {
stdcli.Error(fmt.Errorf("must specify an app name"))
return
}
fmt.Printf("Creating app %s... ", app)
_, err = rackClient(c).CreateApp(app)
if err != nil {
stdcli.Error(err)
return
}
fmt.Println("CREATING")
}
func cmdSSLDelete(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) != 1 {
stdcli.Usage(c, "delete")
return
}
target := c.Args()[0]
parts := strings.Split(target, ":")
if len(parts) != 2 {
stdcli.Error(fmt.Errorf("target must be process:port"))
return
}
fmt.Printf("Deleting SSL listener %s... ", target)
_, err = rackClient(c).DeleteSSL(app, parts[0], parts[1])
if err != nil {
stdcli.Error(err)
return
}
fmt.Println("Done.")
}
func cmdScale(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
count := c.String("count")
memory := c.String("memory")
if len(c.Args()) == 0 && count == "" && memory == "" {
displayFormation(c, app)
return
}
if len(c.Args()) != 1 || (count == "" && memory == "") {
stdcli.Usage(c, "scale")
return
}
process := c.Args()[0]
err = rackClient(c).SetFormation(app, process, count, memory)
if err != nil {
stdcli.Error(err)
return
}
displayFormation(c, app)
}
func cmdAppParamsSet(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.ExitError(err)
}
params := map[string]string{}
for _, arg := range c.Args() {
parts := strings.SplitN(arg, "=", 2)
if len(parts) != 2 {
return stdcli.ExitError(fmt.Errorf("invalid argument: %s", arg))
}
params[parts[0]] = parts[1]
}
fmt.Print("Updating parameters... ")
err = rackClient(c).SetParameters(app, params)
if err != nil {
return stdcli.ExitError(err)
}
fmt.Println("OK")
return nil
}
func cmdBuilds(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
builds, err := rackClient(c).GetBuilds(app)
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("ID", "STATUS", "RELEASE", "STARTED", "ELAPSED", "DESC")
for _, build := range builds {
started := humanizeTime(build.Started)
elapsed := stdcli.Duration(build.Started, build.Ended)
if build.Ended.IsZero() {
elapsed = ""
}
t.AddRow(build.Id, build.Status, build.Release, started, elapsed, build.Description)
}
t.Print()
}
func cmdExec(c *cli.Context) {
fd := os.Stdin.Fd()
stdinState, err := terminal.GetState(int(fd))
defer terminal.Restore(int(fd), stdinState)
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) < 2 {
stdcli.Usage(c, "exec")
return
}
ps := c.Args()[0]
code, err := rackClient(c).ExecProcessAttached(app, ps, strings.Join(c.Args()[1:], " "), os.Stdin, os.Stdout)
terminal.Restore(int(fd), stdinState)
if err != nil {
stdcli.Error(err)
return
}
os.Exit(code)
}
func cmdPs(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.ExitError(err)
}
ps, err := rackClient(c).GetProcesses(app, c.Bool("stats"))
if err != nil {
return stdcli.ExitError(err)
}
if c.Bool("stats") {
fm, err := rackClient(c).ListFormation(app)
if err != nil {
return stdcli.ExitError(err)
}
displayProcessesStats(ps, fm)
return nil
}
displayProcesses(ps)
return nil
}
func cmdInit(c *cli.Context) error {
ep := stdcli.QOSEventProperties{Start: time.Now()}
distinctId, err := currentId()
if err != nil {
stdcli.QOSEventSend("cli-init", distinctId, stdcli.QOSEventProperties{Error: err})
}
wd := "."
if len(c.Args()) > 0 {
wd = c.Args()[0]
}
dir, _, err := stdcli.DirApp(c, wd)
if err != nil {
return stdcli.QOSEventSend("cli-init", distinctId, stdcli.QOSEventProperties{Error: err})
}
// TODO parse the Dockerfile and build a docker-compose.yml
if exists("docker-compose.yml") {
return stdcli.Error(fmt.Errorf("Cannot initialize a project that already contains a docker-compose.yml"))
}
err = initApplication(dir)
if err != nil {
return stdcli.QOSEventSend("cli-init", distinctId, stdcli.QOSEventProperties{Error: err})
}
return stdcli.QOSEventSend("cli-init", distinctId, ep)
}
func cmdRun(c *cli.Context) error {
if c.Bool("detach") {
return cmdRunDetached(c)
}
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.Error(err)
}
if len(c.Args()) < 2 {
stdcli.Usage(c, "run")
return nil
}
ps := c.Args()[0]
err = validateProcessId(c, app, ps)
if err != nil {
return stdcli.Error(err)
}
args := strings.Join(c.Args()[1:], " ")
release := c.String("release")
code, err := runAttached(c, app, ps, args, release)
if err != nil {
return stdcli.Error(err)
}
return cli.NewExitError("", code)
}
func cmdBuildsInfo(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.Error(err)
}
if len(c.Args()) != 1 {
stdcli.Usage(c, "info")
return nil
}
build := c.Args()[0]
b, err := rackClient(c).GetBuild(app, build)
if err != nil {
return stdcli.Error(err)
}
fmt.Printf("Build %s\n", b.Id)
fmt.Printf("Status %s\n", b.Status)
fmt.Printf("Release %s\n", b.Release)
fmt.Printf("Description %s\n", b.Description)
fmt.Printf("Started %s\n", humanizeTime(b.Started))
fmt.Printf("Elapsed %s\n", stdcli.Duration(b.Started, b.Ended))
return nil
}
func cmdBuildsCreate(c *cli.Context) {
wd := "."
if len(c.Args()) > 0 {
wd = c.Args()[0]
}
dir, app, err := stdcli.DirApp(c, wd)
if err != nil {
stdcli.Error(err)
return
}
_, err = rackClient(c).GetApp(app)
if err != nil {
stdcli.Error(err)
return
}
release, err := executeBuild(c, dir, app)
if err != nil {
stdcli.Error(err)
return
}
fmt.Printf("Release: %s\n", release)
}
func cmdSSLList(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.ExitError(err)
}
if len(c.Args()) > 0 {
return stdcli.ExitError(fmt.Errorf("`convox ssl` does not take arguments. Perhaps you meant `convox ssl update`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
ssls, err := rackClient(c).ListSSL(app)
if err != nil {
return stdcli.ExitError(err)
}
t := stdcli.NewTable("TARGET", "CERTIFICATE", "DOMAIN", "EXPIRES")
for _, ssl := range *ssls {
t.AddRow(fmt.Sprintf("%s:%d", ssl.Process, ssl.Port), ssl.Certificate, ssl.Domain, humanizeTime(ssl.Expiration))
}
t.Print()
return nil
}
func cmdPsInfo(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) != 1 {
stdcli.Usage(c, "info")
return
}
id := c.Args()[0]
p, err := rackClient(c).GetProcess(app, id)
if err != nil {
stdcli.Error(err)
return
}
fmt.Printf("Id %s\n", p.Id)
fmt.Printf("Name %s\n", p.Name)
fmt.Printf("Release %s\n", p.Release)
fmt.Printf("Size %d\n", p.Size)
fmt.Printf("CPU %0.2f%%\n", p.Cpu)
fmt.Printf("Memory %0.2f%%\n", p.Memory*100)
fmt.Printf("Started %s\n", humanizeTime(p.Started))
fmt.Printf("Command %s\n", p.Command)
}
func cmdSSLUpdate(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.ExitError(err)
}
if len(c.Args()) < 2 {
stdcli.Usage(c, "update")
return nil
}
target := c.Args()[0]
parts := strings.Split(target, ":")
if len(parts) != 2 {
return stdcli.ExitError(fmt.Errorf("target must be process:port"))
}
fmt.Printf("Updating certificate... ")
_, err = rackClient(c).UpdateSSL(app, parts[0], parts[1], c.Args()[1])
if err != nil {
return stdcli.ExitError(err)
}
fmt.Println("OK")
return nil
}
func cmdPs(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
ps, err := rackClient(c).GetProcesses(app, c.Bool("stats"))
if err != nil {
stdcli.Error(err)
return
}
if c.Bool("stats") {
t := stdcli.NewTable("ID", "NAME", "RELEASE", "CPU", "MEM", "STARTED", "COMMAND")
for _, p := range ps {
t.AddRow(p.Id, p.Name, p.Release, fmt.Sprintf("%0.2f%%", p.Cpu*100), fmt.Sprintf("%0.2f%%", p.Memory*100), humanizeTime(p.Started), p.Command)
}
t.Print()
} else {
t := stdcli.NewTable("ID", "NAME", "RELEASE", "STARTED", "COMMAND")
for _, p := range ps {
t.AddRow(p.Id, p.Name, p.Release, humanizeTime(p.Started), p.Command)
}
t.Print()
}
}
func cmdAppParams(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.ExitError(err)
}
params, err := rackClient(c).ListParameters(app)
if err != nil {
return stdcli.ExitError(err)
}
keys := []string{}
for key, _ := range params {
keys = append(keys, key)
}
sort.Strings(keys)
t := stdcli.NewTable("NAME", "VALUE")
for _, key := range keys {
t.AddRow(key, params[key])
}
t.Print()
return nil
}
func cmdPsStop(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) != 1 {
stdcli.Usage(c, "stop")
return
}
id := c.Args()[0]
fmt.Printf("Stopping %s... ", id)
_, err = rackClient(c).StopProcess(app, id)
if err != nil {
stdcli.Error(err)
return
}
fmt.Println("OK")
}
func cmdAppCreate(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.ExitError(err)
}
if len(c.Args()) > 0 {
app = c.Args()[0]
}
if app == "" {
return stdcli.ExitError(fmt.Errorf("must specify an app name"))
}
fmt.Printf("Creating app %s... ", app)
_, err = rackClient(c).CreateApp(app)
if err != nil {
return stdcli.ExitError(err)
}
fmt.Println("CREATING")
if c.Bool("wait") {
fmt.Printf("Waiting for %s... ", app)
if err := waitForAppRunning(c, app); err != nil {
stdcli.ExitError(err)
}
fmt.Println("OK")
}
return nil
}
func cmdRun(c *cli.Context) {
if c.Bool("detach") {
cmdRunDetached(c)
return
}
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) < 2 {
stdcli.Usage(c, "run")
return
}
ps := c.Args()[0]
args := strings.Join(c.Args()[1:], " ")
code, err := runAttached(c, app, ps, args)
if err != nil {
stdcli.Error(err)
return
}
os.Exit(code)
}
func cmdReleasePromote(c *cli.Context) error {
if len(c.Args()) < 1 {
stdcli.Usage(c, "releases promote")
return nil
}
release := c.Args()[0]
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.ExitError(err)
}
fmt.Printf("Promoting %s... ", release)
_, err = rackClient(c).PromoteRelease(app, release)
if err != nil {
return stdcli.ExitError(err)
}
fmt.Println("UPDATING")
if c.Bool("wait") {
fmt.Printf("Waiting for stabilization... ")
if err := waitForReleasePromotion(c, app, release); err != nil {
return stdcli.ExitError(err)
}
fmt.Println("OK")
}
return nil
}
func cmdRunDetached(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) < 1 {
stdcli.Usage(c, "run")
return
}
ps := c.Args()[0]
command := ""
if len(c.Args()) > 1 {
args := c.Args()[1:]
command = strings.Join(args, " ")
}
fmt.Printf("Running `%s` on %s... ", command, ps)
err = rackClient(c).RunProcessDetached(app, ps, command)
if err != nil {
stdcli.Error(err)
return
}
fmt.Println("OK")
}
func cmdReleasePromote(c *cli.Context) {
if len(c.Args()) < 1 {
stdcli.Usage(c, "release promote")
return
}
release := c.Args()[0]
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
fmt.Printf("Promoting %s... ", release)
_, err = rackClient(c).PromoteRelease(app, release)
if err != nil {
stdcli.Error(err)
return
}
fmt.Println("UPDATING")
}
func cmdSSLDelete(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) != 1 {
stdcli.Usage(c, "delete")
return
}
port := c.Args()[0]
fmt.Printf("Deleting SSL listener on port %s... ", port)
_, err = rackClient(c).DeleteSSL(app, port)
if err != nil {
stdcli.Error(err)
return
}
fmt.Println("Done.")
}
func cmdEnvList(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
if len(c.Args()) > 0 {
stdcli.Error(fmt.Errorf("`convox env` does not take arguments. Perhaps you meant `convox env set`?"))
}
env, err := rackClient(c).GetEnvironment(app)
if err != nil {
stdcli.Error(err)
return
}
keys := []string{}
for key, _ := range env {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
fmt.Printf("%s=%s\n", key, env[key])
}
}
func cmdEnvList(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
env, err := rackClient(c).GetEnvironment(app)
if err != nil {
stdcli.Error(err)
return
}
keys := []string{}
for key, _ := range env {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
fmt.Printf("%s=%s\n", key, env[key])
}
}
func cmdInit(c *cli.Context) {
wd := "."
if len(c.Args()) > 0 {
wd = c.Args()[0]
}
dir, _, err := stdcli.DirApp(c, wd)
if err != nil {
stdcli.Error(err)
return
}
changed, err := manifest.Init(dir)
if err != nil {
stdcli.Error(err)
return
}
if len(changed) > 0 {
fmt.Printf("Generated: %s\n", strings.Join(changed, ", "))
}
}
func cmdAppCreate(c *cli.Context) error {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
return stdcli.Error(err)
}
if len(c.Args()) > 0 {
app = c.Args()[0]
}
if app == "" {
return stdcli.Error(fmt.Errorf("must specify an app name"))
}
stdcli.Startf("Creating app <app>%s</app>", app)
_, err = rackClient(c).CreateApp(app)
if err != nil {
return stdcli.Error(err)
}
stdcli.Wait("CREATING")
if c.Bool("wait") {
stdcli.Startf("Waiting for <app>%s</app>", app)
if err := waitForAppRunning(c, app); err != nil {
stdcli.Error(err)
}
stdcli.OK()
}
return nil
}