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 cmdRackParams(c *cli.Context) {
system, err := rackClient(c).GetSystem()
if err != nil {
stdcli.Error(err)
return
}
params, err := rackClient(c).ListParameters(system.Name)
if err != nil {
stdcli.Error(err)
return
}
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()
}
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 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 displayFormation(c *cli.Context, app string) {
formation, err := rackClient(c).ListFormation(app)
if err != nil {
stdcli.Error(err)
return
}
pss, err := rackClient(c).GetProcesses(app, false)
if err != nil {
stdcli.Error(err)
return
}
running := map[string]int{}
for _, ps := range pss {
if ps.Id != "pending" {
running[ps.Name] += 1
}
}
t := stdcli.NewTable("NAME", "DESIRED", "RUNNING", "MEMORY")
for _, f := range formation {
t.AddRow(f.Name, fmt.Sprintf("%d", f.Count), fmt.Sprintf("%d", running[f.Name]), fmt.Sprintf("%d", f.Memory))
}
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 cmdInstancesList(c *cli.Context) error {
if len(c.Args()) > 0 {
return stdcli.ExitError(fmt.Errorf("`convox instances` does not take arguments. Perhaps you meant `convox instances ssh`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
instances, err := rackClient(c).GetInstances()
if err != nil {
return stdcli.ExitError(err)
}
t := stdcli.NewTable("ID", "AGENT", "STATUS", "STARTED", "PS", "CPU", "MEM")
for _, i := range instances {
agent := "off"
if i.Agent {
agent = "on"
}
t.AddRow(i.Id, agent, i.Status,
humanizeTime(i.Started),
strconv.Itoa(i.Processes),
fmt.Sprintf("%0.2f%%", i.Cpu*100),
fmt.Sprintf("%0.2f%%", i.Memory*100))
}
t.Print()
return nil
}
func displayProcesses(ps []client.Process, showApp bool) {
var t *stdcli.Table
if showApp {
t = stdcli.NewTable("ID", "APP", "NAME", "RELEASE", "STARTED", "COMMAND")
} else {
t = stdcli.NewTable("ID", "NAME", "RELEASE", "STARTED", "COMMAND")
}
for _, p := range ps {
if showApp {
t.AddRow(prettyId(p), p.App, p.Name, p.Release, humanizeTime(p.Started), p.Command)
} else {
t.AddRow(prettyId(p), p.Name, p.Release, humanizeTime(p.Started), p.Command)
}
}
t.Print()
}
func displayProcesses(ps []client.Process) {
t := stdcli.NewTable("ID", "NAME", "RELEASE", "STARTED", "COMMAND")
for _, p := range ps {
t.AddRow(prettyId(p), p.Name, p.Release, humanizeTime(p.Started), p.Command)
}
t.Print()
}
func displayProcessesStats(ps []client.Process, fm client.Formation) {
t := stdcli.NewTable("ID", "NAME", "RELEASE", "CPU %", "MEM", "MEM %", "STARTED", "COMMAND")
for _, p := range ps {
for _, f := range fm {
if f.Name != p.Name {
continue
}
t.AddRow(prettyId(p), p.Name, p.Release, fmt.Sprintf("%0.2f%%", p.Cpu), fmt.Sprintf("%0.1fMB/%dMB", p.Memory*float64(f.Memory), f.Memory), fmt.Sprintf("%0.2f%%", p.Memory*100), humanizeTime(p.Started), p.Command)
}
}
t.Print()
}
func cmdRackReleases(c *cli.Context) {
system, err := rackClient(c).GetSystem()
if err != nil {
stdcli.Error(err)
return
}
pendingVersion := system.Version
releases, err := rackClient(c).GetSystemReleases()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("VERSION", "UPDATED", "STATUS")
for i, r := range releases {
status := ""
if system.Status == "updating" && i == 0 {
pendingVersion = r.Id
status = "updating"
}
if system.Version == r.Id {
status = "active"
}
t.AddRow(r.Id, humanizeTime(r.Created), status)
}
t.Print()
next, err := version.Next(system.Version)
if err != nil {
return
}
if next > pendingVersion {
// if strings.Compare(next, pendingVersion) == 1 {
fmt.Println()
fmt.Printf("New version available: %s\n", next)
}
}
func cmdRegistryList(c *cli.Context) {
registries, err := rackClient(c).ListRegistries()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("SERVER")
for _, reg := range *registries {
t.AddRow(reg.ServerAddress)
}
t.Print()
}
func cmdCertsList(c *cli.Context) {
certs, err := rackClient(c).ListCertificates()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("ID", "DOMAIN", "EXPIRES")
for _, cert := range certs {
t.AddRow(cert.Id, cert.Domain, humanizeTime(cert.Expiration))
}
t.Print()
}
func cmdServices(c *cli.Context) {
services, err := rackClient(c).ListServices()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("NAME", "TYPE", "STATUS")
for _, service := range services {
t.AddRow(service.Name, service.Type, service.Status)
}
t.Print()
}
func cmdApps(c *cli.Context) {
apps, err := rackClient(c).GetApps()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("APP", "STATUS")
for _, app := range apps {
t.AddRow(app.Name, app.Status)
}
t.Print()
}
func cmdRacks(c *cli.Context) {
racks, err := rackClient(c).Racks()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("RACK", "STATUS")
for _, rack := range racks {
name := rack.Name
if rack.Organization != nil {
name = fmt.Sprintf("%s/%s", rack.Organization.Name, name)
}
t.AddRow(name, rack.Status)
}
t.Print()
}
func cmdInstancesList(c *cli.Context) {
instances, err := rackClient(c).GetInstances()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("ID", "IP", "STATUS", "PROCESSES", "CPU", "MEM")
for _, i := range instances {
t.AddRow(i.Id, i.Ip, i.Status, strconv.Itoa(i.Processes),
fmt.Sprintf("%0.2f%%", i.Cpu*100),
fmt.Sprintf("%0.2f%%", i.Memory*100))
}
t.Print()
}
func TestTableOutput(t *testing.T) {
buf := &bytes.Buffer{}
tb := stdcli.NewTable("FOO", "BAR")
tb.Output = buf
tb.AddRow("foo bar", "foo bar baz qux")
tb.AddRow("bar foo baz", "foo")
tb.Print()
lines := strings.Split(buf.String(), "\n")
assert.Equal(t, 4, len(lines))
assert.Equal(t, "FOO BAR", lines[0])
assert.Equal(t, "foo bar foo bar baz qux", lines[1])
assert.Equal(t, "bar foo baz foo", lines[2])
assert.Equal(t, "", lines[3])
}
func cmdRacks(c *cli.Context) error {
if len(c.Args()) > 0 {
return stdcli.Error(fmt.Errorf("`convox racks` does not take arguments. Perhaps you meant `convox racks`?"))
}
racks, err := rackClient(c).Racks()
if err != nil {
return stdcli.Error(err)
}
t := stdcli.NewTable("RACK", "STATUS")
for _, rack := range racks {
name := rack.Name
if rack.Organization != nil {
name = fmt.Sprintf("%s/%s", rack.Organization.Name, name)
}
t.AddRow(name, rack.Status)
}
t.Print()
return nil
}
func cmdReleases(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 releases` does not take arguments. Perhaps you meant `convox registries info`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
a, err := rackClient(c).GetApp(app)
if err != nil {
return stdcli.ExitError(err)
}
releases, err := rackClient(c).GetReleases(app)
if err != nil {
return stdcli.ExitError(err)
}
t := stdcli.NewTable("ID", "CREATED", "BUILD", "STATUS")
for _, r := range releases {
status := ""
if a.Release == r.Id {
status = "active"
}
t.AddRow(r.Id, humanizeTime(r.Created), r.Build, status)
}
t.Print()
return nil
}
func cmdSSLList(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
ssls, err := rackClient(c).ListSSL(app)
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("TARGET", "EXPIRES", "DOMAIN")
for _, ssl := range *ssls {
t.AddRow(fmt.Sprintf("%s:%d", ssl.Process, ssl.Port), humanizeTime(ssl.Expiration), ssl.Domain)
}
t.Print()
}
func displayFormation(c *cli.Context, app string) {
formation, err := rackClient(c).ListFormation(app)
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("NAME", "COUNT", "MEMORY", "PORTS")
for _, f := range formation {
ports := []string{}
for _, p := range f.Ports {
ports = append(ports, strconv.Itoa(p))
}
t.AddRow(f.Name, fmt.Sprintf("%d", f.Count), fmt.Sprintf("%d", f.Memory), strings.Join(ports, " "))
}
t.Print()
}
func cmdSSLList(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
ssls, err := rackClient(c).ListSSL(app)
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("PORT", "EXPIRES", "DOMAINS")
for _, ssl := range *ssls {
t.AddRow(ssl.Port, humanizeTime(ssl.Expiration), ssl.Name)
}
t.Print()
}
func cmdReleases(c *cli.Context) {
_, app, err := stdcli.DirApp(c, ".")
if err != nil {
stdcli.Error(err)
return
}
a, err := rackClient(c).GetApp(app)
if err != nil {
stdcli.Error(err)
return
}
releases, err := rackClient(c).GetReleases(app)
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("ID", "CREATED", "STATUS")
for _, r := range releases {
status := ""
if a.Release == r.Id {
status = "active"
}
t.AddRow(r.Id, humanizeTime(r.Created), status)
}
t.Print()
}
func cmdApps(c *cli.Context) error {
if len(c.Args()) > 0 {
return stdcli.ExitError(fmt.Errorf("`convox apps` does not take arguments. Perhaps you meant `convox apps create`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
apps, err := rackClient(c).GetApps()
if err != nil {
return stdcli.ExitError(err)
}
t := stdcli.NewTable("APP", "STATUS")
for _, app := range apps {
t.AddRow(app.Name, app.Status)
}
t.Print()
return nil
}
func cmdServices(c *cli.Context) error {
if len(c.Args()) > 0 {
return stdcli.ExitError(fmt.Errorf("`convox services` does not take arguments. Perhaps you meant `convox services create`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
services, err := rackClient(c).GetServices()
if err != nil {
return stdcli.ExitError(err)
}
t := stdcli.NewTable("NAME", "TYPE", "STATUS")
for _, service := range services {
t.AddRow(service.Name, service.Type, service.Status)
}
t.Print()
return nil
}
func cmdBuilds(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 builds` does not take arguments. Perhaps you meant `convox builds create`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
builds, err := rackClient(c).GetBuilds(app)
if err != nil {
return stdcli.ExitError(err)
}
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()
return nil
}
func cmdCertsList(c *cli.Context) error {
if len(c.Args()) > 0 {
return stdcli.ExitError(fmt.Errorf("`convox certs` does not take arguments. Perhaps you meant `convox certs generate`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
certs, err := rackClient(c).ListCertificates()
if err != nil {
return stdcli.ExitError(err)
}
t := stdcli.NewTable("ID", "DOMAIN", "EXPIRES")
for _, cert := range certs {
t.AddRow(cert.Id, cert.Domain, humanizeTime(cert.Expiration))
}
t.Print()
return nil
}
func cmdRegistryList(c *cli.Context) error {
if len(c.Args()) > 0 {
return stdcli.ExitError(fmt.Errorf("`convox registries` does not take arguments. Perhaps you meant `convox registries add`?"))
}
if c.Bool("help") {
stdcli.Usage(c, "")
return nil
}
registries, err := rackClient(c).ListRegistries()
if err != nil {
return stdcli.ExitError(err)
}
t := stdcli.NewTable("SERVER")
for _, reg := range *registries {
t.AddRow(reg.ServerAddress)
}
t.Print()
return nil
}
func cmdInstancesList(c *cli.Context) {
instances, err := rackClient(c).GetInstances()
if err != nil {
stdcli.Error(err)
return
}
t := stdcli.NewTable("ID", "AGENT", "STATUS", "STARTED", "PS", "CPU", "MEM")
for _, i := range instances {
agent := "off"
if i.Agent {
agent = "on"
}
t.AddRow(i.Id, agent, i.Status,
humanizeTime(i.Started),
strconv.Itoa(i.Processes),
fmt.Sprintf("%0.2f%%", i.Cpu*100),
fmt.Sprintf("%0.2f%%", i.Memory*100))
}
t.Print()
}
