func (c *teamList) Run(context *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/teams") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := client.Do(request) if err != nil { return err } if resp.StatusCode == http.StatusOK { defer resp.Body.Close() b, err := ioutil.ReadAll(resp.Body) if err != nil { return err } var teams []teamItem err = json.Unmarshal(b, &teams) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row{"Team", "Permissions"} table.LineSeparator = true for _, team := range teams { table.AddRow(cmd.Row{team.Name, strings.Join(team.Permissions, "\n")}) } fmt.Fprint(context.Stdout, table.String()) } return nil }
func (c serviceInfo) BuildPlansTable(serviceName string, ctx *cmd.Context, client *cmd.Client) error { ctx.Stdout.Write([]byte("\nPlans\n")) url, err := cmd.GetURL(fmt.Sprintf("/services/%s/plans", serviceName)) if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() result, err := ioutil.ReadAll(resp.Body) if err != nil { return err } var plans []map[string]string err = json.Unmarshal(result, &plans) if err != nil { return err } if len(plans) > 0 { table := cmd.NewTable() for _, plan := range plans { data := []string{plan["Name"], plan["Description"]} table.AddRow(cmd.Row(data)) } table.Headers = cmd.Row([]string{"Name", "Description"}) ctx.Stdout.Write(table.Bytes()) } return nil }
func (a *app) String() string { format := `Application: {{.Name}} Repository: {{.Repository}} Platform: {{.Platform}} Teams: {{.GetTeams}} Address: {{.Addr}} Owner: {{.Owner}} Team owner: {{.TeamOwner}} Deploys: {{.Deploys}} ` tmpl := template.Must(template.New("app").Parse(format)) units := cmd.NewTable() units.Headers = cmd.Row([]string{"Unit", "State"}) for _, unit := range a.Units { if unit.Name != "" { units.AddRow(cmd.Row([]string{unit.Name, unit.Status})) } } var buf bytes.Buffer tmpl.Execute(&buf, a) var suffix string if units.Rows() > 0 { suffix = fmt.Sprintf("Units:\n%s", units) } return buf.String() + suffix }
func (c *listUsers) Run(ctx *cmd.Context, client *cmd.Client) error { if c.userEmail != "" && c.role != "" { return errors.New("You cannot set more than one flag. Enter <tsuru user-list --help> for more information.") } url := fmt.Sprintf("/users?userEmail=%s&role=%s", c.userEmail, c.role) url, err := cmd.GetURL(url) if err != nil { return err } request, _ := http.NewRequest("GET", url, nil) resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() var users []cmd.APIUser err = json.NewDecoder(resp.Body).Decode(&users) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"User", "Roles"}) for _, u := range users { table.AddRow(cmd.Row([]string{ u.Email, strings.Join(u.RoleInstances(), "\n"), })) } table.LineSeparator = true table.Sort() ctx.Stdout.Write(table.Bytes()) return nil }
func (c *NodeContainerInfo) Run(context *cmd.Context, client *cmd.Client) error { u, err := cmd.GetURL("/docker/nodecontainers/" + context.Args[0]) if err != nil { return err } request, err := http.NewRequest("GET", u, nil) if err != nil { return err } rsp, err := client.Do(request) if err != nil { return err } var poolConfigs map[string]NodeContainerConfig err = json.NewDecoder(rsp.Body).Decode(&poolConfigs) if err != nil { return err } tbl := cmd.NewTable() tbl.LineSeparator = true tbl.Headers = cmd.Row{"Pool", "Config"} for poolName, config := range poolConfigs { data, err := json.MarshalIndent(config, "", " ") if err != nil { return err } if poolName == "" { poolName = emptyPoolLabel } tbl.AddRow(cmd.Row{poolName, string(data)}) } tbl.Sort() fmt.Fprint(context.Stdout, tbl.String()) return nil }
func (c *appList) Show(result []byte, context *cmd.Context) error { var apps []app err := json.Unmarshal(result, &apps) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"Application", "Units State Summary", "Address"}) for _, app := range apps { var available int var total int for _, unit := range app.Units { if unit.Name != "" { total++ if unit.Available() { available++ } } } summary := fmt.Sprintf("%d of %d units in-service", available, total) addrs := strings.Replace(app.Addr(), ", ", "\n", -1) table.AddRow(cmd.Row([]string{app.Name, summary, addrs})) } table.LineSeparator = true table.Sort() context.Stdout.Write(table.Bytes()) return nil }
func (c *machineList) Run(context *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/iaas/machines") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } var machines []iaas.Machine err = json.NewDecoder(response.Body).Decode(&machines) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"Id", "IaaS", "Address", "Creation Params"}) table.LineSeparator = true for _, machine := range machines { var params []string for k, v := range machine.CreationParams { params = append(params, fmt.Sprintf("%s=%s", k, v)) } sort.Strings(params) table.AddRow(cmd.Row([]string{machine.Id, machine.Iaas, machine.Address, strings.Join(params, "\n")})) } table.Sort() context.Stdout.Write(table.Bytes()) return nil }
func (c *listUsers) Run(ctx *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/users") if err != nil { return err } request, _ := http.NewRequest("GET", url, nil) resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() var users []user err = json.NewDecoder(resp.Body).Decode(&users) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"User", "Teams"}) for _, u := range users { table.AddRow(cmd.Row([]string{u.Email, strings.Join(u.Teams, ", ")})) } table.LineSeparator = true table.Sort() ctx.Stdout.Write(table.Bytes()) return nil }
func (c *templateList) Run(context *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/iaas/templates") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } var templates []iaas.Template err = json.NewDecoder(response.Body).Decode(&templates) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"Name", "IaaS", "Params"}) table.LineSeparator = true for _, template := range templates { var params []string for _, data := range template.Data { params = append(params, fmt.Sprintf("%s=%s", data.Name, data.Value)) } sort.Strings(params) table.AddRow(cmd.Row([]string{template.Name, template.IaaSName, strings.Join(params, "\n")})) } table.Sort() context.Stdout.Write(table.Bytes()) return nil }
func (c *planRoutersList) Run(context *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/plans/routers") if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } var routers []router.PlanRouter err = json.NewDecoder(response.Body).Decode(&routers) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row([]string{"Name", "Type"}) table.LineSeparator = true for _, router := range routers { table.AddRow(cmd.Row([]string{router.Name, router.Type})) } context.Stdout.Write(table.Bytes()) return nil }
func (c *roleList) Run(context *cmd.Context, client *cmd.Client) error { addr, err := cmd.GetURL("/roles") if err != nil { return err } request, err := http.NewRequest("GET", addr, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } result, err := ioutil.ReadAll(response.Body) if err != nil { return err } var roles []permission.Role err = json.Unmarshal(result, &roles) if err != nil { return err } table := cmd.NewTable() table.Headers = cmd.Row{"Role", "Context", "Permissions"} table.LineSeparator = true for _, r := range roles { table.AddRow(cmd.Row{r.Name, string(r.ContextType), strings.Join(r.SchemeNames, "\n")}) } fmt.Fprint(context.Stdout, table.String()) return nil }
func (c *roleInfo) Run(context *cmd.Context, client *cmd.Client) error { roleName := context.Args[0] addr, err := cmd.GetURL(fmt.Sprintf("/roles/%s", roleName)) if err != nil { return err } request, err := http.NewRequest("GET", addr, nil) if err != nil { return err } resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() result, err := ioutil.ReadAll(resp.Body) if err != nil { return err } var perm permission.Role err = json.Unmarshal(result, &perm) if err != nil { return err } tbl := cmd.NewTable() tbl.LineSeparator = true tbl.Headers = cmd.Row{"Name", "Permissions"} tbl.AddRow(cmd.Row{perm.Name, strings.Join(perm.SchemeNames, "\n")}) fmt.Fprintf(context.Stdout, tbl.String()) return nil }
func (c serviceInfo) BuildInstancesTable(serviceName string, ctx *cmd.Context, client *cmd.Client) error { url, err := cmd.GetURL("/services/" + serviceName) if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := client.Do(request) if err != nil { return err } defer resp.Body.Close() result, err := ioutil.ReadAll(resp.Body) if err != nil { return err } var instances []ServiceInstanceModel err = json.Unmarshal(result, &instances) if err != nil { return err } ctx.Stdout.Write([]byte(fmt.Sprintf("Info for \"%s\"\n\n", serviceName))) if len(instances) > 0 { ctx.Stdout.Write([]byte("Instances\n")) table := cmd.NewTable() extraHeaders := c.ExtraHeaders(instances) hasPlan := false var data []string var headers []string for _, instance := range instances { if instance.PlanName != "" { hasPlan = true } } for _, instance := range instances { apps := strings.Join(instance.Apps, ", ") if hasPlan { data = []string{instance.Name, instance.PlanName, apps} } else { data = []string{instance.Name, apps} } for _, h := range extraHeaders { data = append(data, instance.Info[h]) } table.AddRow(cmd.Row(data)) } if hasPlan { headers = []string{"Instances", "Plan", "Apps"} } else { headers = []string{"Instances", "Apps"} } headers = append(headers, extraHeaders...) table.Headers = cmd.Row(headers) ctx.Stdout.Write(table.Bytes()) } return nil }
func renderList(w io.Writer, permissions []*permissionData) { t := cmd.NewTable() t.Headers = cmd.Row{"Name", "Contexts"} for _, perm := range permissions { t.AddRow(cmd.Row{perm.Name, strings.Join(perm.Contexts, ", ")}) } fmt.Fprint(w, t.String()) }
func (*migrationListCmd) Run(context *cmd.Context, client *cmd.Client) error { migrations, err := migration.List() if err != nil { return err } tbl := cmd.NewTable() tbl.Headers = cmd.Row{"Name", "Mandatory?", "Executed?"} for _, m := range migrations { tbl.AddRow(cmd.Row{m.Name, strconv.FormatBool(!m.Optional), strconv.FormatBool(m.Ran)}) } fmt.Fprint(context.Stdout, tbl.String()) return nil }
func (c *NodeContainerList) Run(context *cmd.Context, client *cmd.Client) error { u, err := cmd.GetURL("/docker/nodecontainers") if err != nil { return err } request, err := http.NewRequest("GET", u, nil) if err != nil { return err } rsp, err := client.Do(request) if err != nil { return err } var all []NodeContainerConfigGroup err = json.NewDecoder(rsp.Body).Decode(&all) if err != nil { return err } if c.namesOnly { for _, entry := range all { fmt.Fprintln(context.Stdout, entry.Name) } return nil } tbl := cmd.NewTable() tbl.LineSeparator = true tbl.Headers = cmd.Row{"Name", "Pool Configs", "Image"} for _, entry := range all { var pools []string for poolName := range entry.ConfigPools { if poolName == "" { poolName = emptyPoolLabel } pools = append(pools, poolName) } sort.Strings(pools) var images []string for _, p := range pools { if p == emptyPoolLabel { p = "" } poolEntry := entry.ConfigPools[p] images = append(images, poolEntry.Image()) } tbl.AddRow(cmd.Row{entry.Name, strings.Join(pools, "\n"), strings.Join(images, "\n")}) } tbl.Sort() fmt.Fprint(context.Stdout, tbl.String()) return nil }
func (c *roleDefaultList) Run(context *cmd.Context, client *cmd.Client) error { addr, err := cmd.GetURL("/role/default") if err != nil { return err } request, err := http.NewRequest("GET", addr, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() result, err := ioutil.ReadAll(response.Body) if err != nil { return err } var roles []permission.Role err = json.Unmarshal(result, &roles) if err != nil { return err } rolesByEvent := map[string][]permission.Role{} for _, r := range roles { for _, evt := range r.Events { rolesByEvent[evt] = append(rolesByEvent[evt], r) } } tbl := cmd.NewTable() tbl.LineSeparator = true tbl.Headers = cmd.Row{"Event", "Description", "Roles"} for _, event := range permission.RoleEventMap { roles := rolesByEvent[event.String()] roleNames := make([]string, len(roles)) for i := range roles { roleNames[i] = roles[i].Name } tbl.AddRow(cmd.Row{event.String(), event.Description, strings.Join(roleNames, "\n")}) } tbl.Sort() fmt.Fprint(context.Stdout, tbl.String()) return nil }
func renderPlans(plans []tsuruapp.Plan, isBytes bool) string { table := cmd.NewTable() table.Headers = []string{"Name", "Memory", "Swap", "Cpu Share", "Router", "Default"} for _, p := range plans { var memory, swap string if isBytes { memory = fmt.Sprintf("%d", p.Memory) swap = fmt.Sprintf("%d", p.Swap) } else { memory = fmt.Sprintf("%d MB", p.Memory/1024/1024) swap = fmt.Sprintf("%d MB", p.Swap/1024/1024) } table.AddRow([]string{ p.Name, memory, swap, strconv.Itoa(p.CpuShare), p.Router, strconv.FormatBool(p.Default), }) } return table.String() }
func (a *app) String() string { format := `Application: %s Repository: %s Platform: %s Teams: %s Address: %s Owner: %s Deploys: %d ` teams := strings.Join(a.Teams, ", ") units := cmd.NewTable() units.Headers = cmd.Row([]string{"Unit", "State"}) for _, unit := range a.Units { if unit.Name != "" { units.AddRow(cmd.Row([]string{unit.Name, unit.State})) } } args := []interface{}{a.Name, a.Repository, a.Platform, teams, a.Addr(), a.Owner, a.Deploys} if units.Rows() > 0 { format += "Units:\n%s" args = append(args, units) } return fmt.Sprintf(format, args...) }
func (a *app) String() string { format := `Application: {{.Name}} Repository: {{.Repository}} Platform: {{.Platform}} Teams: {{.GetTeams}} Address: {{.Addr}} Owner: {{.Owner}} Team owner: {{.TeamOwner}} Deploys: {{.Deploys}} Pool: {{.Pool}}{{if .Lock.Locked}} {{.Lock.String}}{{end}} ` var buf bytes.Buffer tmpl := template.Must(template.New("app").Parse(format)) unitsByProcess := map[string][]unit{} for _, u := range a.Units { units := unitsByProcess[u.ProcessName] unitsByProcess[u.ProcessName] = append(units, u) } processes := make([]string, 0, len(unitsByProcess)) for process := range unitsByProcess { processes = append(processes, process) } sort.Strings(processes) titles := []string{"Unit", "State"} contMap := map[string]container{} if len(a.containers) > 0 { for _, cont := range a.containers { id := cont.ID if len(cont.ID) > 10 { id = id[:10] } contMap[id] = cont } titles = append(titles, []string{"Host", "Port", "IP"}...) } for _, process := range processes { units := unitsByProcess[process] unitsTable := cmd.NewTable() unitsTable.Headers = cmd.Row(titles) for _, unit := range units { if unit.Name == "" { continue } id := unit.Name if len(unit.Name) > 10 { id = id[:10] } row := []string{id, unit.Status} cont, ok := contMap[id] if ok { row = append(row, []string{cont.HostAddr, cont.HostPort, cont.IP}...) } unitsTable.AddRow(cmd.Row(row)) } if unitsTable.Rows() > 0 { if len(a.containers) > 0 { unitsTable.SortByColumn(2) } buf.WriteString("\n") processStr := "" if process != "" { processStr = fmt.Sprintf(" [%s]", process) } buf.WriteString(fmt.Sprintf("Units%s: %d\n", processStr, unitsTable.Rows())) buf.WriteString(unitsTable.String()) } } servicesTable := cmd.NewTable() servicesTable.Headers = []string{"Service", "Instance"} for _, service := range a.services { if len(service.Instances) == 0 { continue } servicesTable.AddRow([]string{service.Service, strings.Join(service.Instances, ", ")}) } if servicesTable.Rows() > 0 { buf.WriteString("\n") buf.WriteString(fmt.Sprintf("Service instances: %d\n", servicesTable.Rows())) buf.WriteString(servicesTable.String()) } if a.Plan.Name != "" { buf.WriteString("\n") buf.WriteString("App Plan:\n") buf.WriteString(renderPlans([]tsuruapp.Plan{a.Plan}, true)) } var tplBuffer bytes.Buffer tmpl.Execute(&tplBuffer, a) return tplBuffer.String() + buf.String() }
func (c *appDeployList) Run(context *cmd.Context, client *cmd.Client) error { appName, err := c.Guess() if err != nil { return err } url, err := cmd.GetURL(fmt.Sprintf("/deploys?app=%s&limit=10", appName)) if err != nil { return err } request, err := http.NewRequest("GET", url, nil) if err != nil { return err } response, err := client.Do(request) if err != nil { return err } if response.StatusCode == http.StatusNoContent { fmt.Fprintf(context.Stdout, "App %s has no deploy.\n", appName) return nil } defer response.Body.Close() result, err := ioutil.ReadAll(response.Body) if err != nil { return err } var deploys []tsuruapp.DeployData err = json.Unmarshal(result, &deploys) if err != nil { return err } sort.Sort(sort.Reverse(deployList(deploys))) table := cmd.NewTable() table.Headers = cmd.Row([]string{"Image (Rollback)", "Origin", "User", "Date (Duration)", "Error"}) for _, deploy := range deploys { timestamp := deploy.Timestamp.Local().Format(time.Stamp) seconds := deploy.Duration / time.Second minutes := seconds / 60 seconds = seconds % 60 if deploy.Origin == "git" { if len(deploy.Commit) > 7 { deploy.Commit = deploy.Commit[:7] } deploy.Origin = fmt.Sprintf("git (%s)", deploy.Commit) } timestamp = fmt.Sprintf("%s (%02d:%02d)", timestamp, minutes, seconds) if deploy.CanRollback { deploy.Image += " (*)" } rowData := []string{deploy.Image, deploy.Origin, deploy.User, timestamp, deploy.Error} if deploy.Error != "" { for i, el := range rowData { if el != "" { rowData[i] = cmd.Colorfy(el, "red", "", "") } } } table.LineSeparator = true table.AddRow(cmd.Row(rowData)) } context.Stdout.Write(table.Bytes()) return nil }