func (listPoolsInTheSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error {
t := cmd.Table{Headers: cmd.Row([]string{"Pools", "Teams"})}
url, err := cmd.GetURL("/docker/pool")
if err != nil {
return err
}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
var pools []Pool
err = json.Unmarshal(body, &pools)
for _, p := range pools {
t.AddRow(cmd.Row([]string{p.Name, strings.Join(p.Teams, ", ")}))
}
t.Sort()
ctx.Stdout.Write(t.Bytes())
return nil
}
func (listNodesInTheSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL("/node")
if err != nil {
return err
}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
var nodes []map[string]string
err = json.Unmarshal(body, &nodes)
t := cmd.Table{Headers: cmd.Row([]string{"Address"})}
for _, n := range nodes {
t.AddRow(cmd.Row([]string{n["Address"]}))
}
t.Sort()
ctx.Stdout.Write(t.Bytes())
return nil
}
func (listPoolsInTheSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error {
t := cmd.Table{Headers: cmd.Row([]string{"Pools", "Teams", "Public"})}
url, err := cmd.GetURL("/pool")
if err != nil {
return err
}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
var pools []provision.Pool
err = json.Unmarshal(body, &pools)
for _, p := range pools {
public := ""
if p.Public {
public = " X "
}
defaultFlag := ""
if p.Default {
defaultFlag = " (default)"
}
t.AddRow(cmd.Row([]string{p.Name + defaultFlag, strings.Join(p.Teams, ", "), public}))
}
t.Sort()
ctx.Stdout.Write(t.Bytes())
return nil
}
func (poolList) Run(context *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL("/pools")
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()
var pools ListPoolResponse
err = json.NewDecoder(resp.Body).Decode(&pools)
if err != nil {
return err
}
t := cmd.Table{Headers: cmd.Row([]string{"Team", "Pools"})}
for _, pool := range pools.PoolsByTeam {
t.AddRow(cmd.Row([]string{pool.Team, strings.Join(pool.Pools, ", ")}))
}
t.Sort()
context.Stdout.Write(t.Bytes())
tp := cmd.Table{Headers: cmd.Row([]string{"Public Pools"})}
for _, pool := range pools.PublicPools {
tp.AddRow(cmd.Row([]string{pool.Name}))
}
tp.Sort()
context.Stdout.Write([]byte("\n"))
context.Stdout.Write(tp.Bytes())
return nil
}
func (listNodesInTheSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL("/docker/node")
if err != nil {
return err
}
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return err
}
resp, err := client.Do(req)
if err != nil {
return err
}
var result map[string]interface{}
err = json.NewDecoder(resp.Body).Decode(&result)
if err != nil {
return err
}
machineMap := map[string]map[string]interface{}{}
if result["machines"] != nil {
machines := result["machines"].([]interface{})
for _, m := range machines {
machine := m.(map[string]interface{})
machineMap[machine["Address"].(string)] = m.(map[string]interface{})
}
}
t := cmd.Table{Headers: cmd.Row([]string{"Address", "IaaS ID", "Status", "Metadata"}), LineSeparator: true}
var nodes []interface{}
if result["nodes"] != nil {
nodes = result["nodes"].([]interface{})
}
for _, n := range nodes {
node := n.(map[string]interface{})
addr := node["Address"].(string)
status := node["Status"].(string)
result := []string{}
metadataField, _ := node["Metadata"]
if metadataField != nil {
metadata := metadataField.(map[string]interface{})
for key, value := range metadata {
result = append(result, fmt.Sprintf("%s=%s", key, value.(string)))
}
}
sort.Strings(result)
m, ok := machineMap[urlToHost(addr)]
var iaasId string
if ok {
iaasId = m["Id"].(string)
}
t.AddRow(cmd.Row([]string{addr, iaasId, status, strings.Join(result, "\n")}))
}
t.Sort()
ctx.Stdout.Write(t.Bytes())
return nil
}
func (listNodesInTheSchedulerCmd) Run(ctx *cmd.Context, client *cmd.Client) error {
t := cmd.Table{Headers: cmd.Row([]string{"ID", "Address", "Team"})}
nodes, err := listNodesInTheScheduler()
if err != nil {
return err
}
for _, n := range nodes {
t.AddRow(cmd.Row([]string{n.ID, n.Address, strings.Join(n.Teams, ", ")}))
}
t.Sort()
ctx.Stdout.Write(t.Bytes())
return nil
}
func (c *dockerLogInfo) Run(context *cmd.Context, client *cmd.Client) error {
u, err := cmd.GetURL("/docker/logs")
if err != nil {
return err
}
request, err := http.NewRequest("GET", u, nil)
if err != nil {
return err
}
response, err := client.Do(request)
if err != nil {
return err
}
defer response.Body.Close()
var conf map[string]container.DockerLogConfig
err = json.NewDecoder(response.Body).Decode(&conf)
if err != nil {
return err
}
baseConf := conf[""]
delete(conf, "")
t := cmd.Table{Headers: cmd.Row([]string{"Name", "Value"})}
fmt.Fprintf(context.Stdout, "Log driver [default]: %s\n", baseConf.Driver)
for optName, optValue := range baseConf.LogOpts {
t.AddRow(cmd.Row([]string{optName, optValue}))
}
if t.Rows() > 0 {
t.Sort()
context.Stdout.Write(t.Bytes())
}
poolNames := make([]string, 0, len(baseConf.LogOpts))
for poolName := range conf {
poolNames = append(poolNames, poolName)
}
sort.Strings(poolNames)
for _, poolName := range poolNames {
poolConf := conf[poolName]
t := cmd.Table{Headers: cmd.Row([]string{"Name", "Value"})}
fmt.Fprintf(context.Stdout, "\nLog driver [pool %s]: %s\n", poolName, poolConf.Driver)
for optName, optValue := range poolConf.LogOpts {
t.AddRow(cmd.Row([]string{optName, optValue}))
}
if t.Rows() > 0 {
t.Sort()
context.Stdout.Write(t.Bytes())
}
}
return nil
}
func (c *dockerLogInfo) Run(context *cmd.Context, client *cmd.Client) error {
url, err := cmd.GetURL("/docker/logs")
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
}
defer response.Body.Close()
var conf provision.ScopedConfig
err = json.NewDecoder(response.Body).Decode(&conf)
if err != nil {
return err
}
t := cmd.Table{Headers: cmd.Row([]string{"Name", "Value"})}
for _, envVar := range conf.Envs {
if envVar.Name == container.DockerLogDriverConfig {
fmt.Fprintf(context.Stdout, "Log driver [default]: %s\n", envVar.Value)
continue
}
t.AddRow(cmd.Row([]string{envVar.Name, fmt.Sprintf("%v", envVar.Value)}))
}
if t.Rows() > 0 {
t.Sort()
context.Stdout.Write(t.Bytes())
}
sort.Sort(provision.ConfigPoolEntryList(conf.Pools))
for _, pool := range conf.Pools {
t := cmd.Table{Headers: cmd.Row([]string{"Name", "Value"})}
for _, envVar := range pool.Envs {
if envVar.Name == container.DockerLogDriverConfig {
fmt.Fprintf(context.Stdout, "\nLog driver [pool %s]: %s\n", pool.Name, envVar.Value)
continue
}
t.AddRow(cmd.Row([]string{envVar.Name, fmt.Sprintf("%v", envVar.Value)}))
}
if t.Rows() > 0 {
t.Sort()
context.Stdout.Write(t.Bytes())
}
}
return nil
}