1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// Copyright 2014, 2015 Canonical Ltd.
// Licensed under the AGPLv3, see LICENCE file for details.
package action
import (
"bytes"
"fmt"
"strings"
"text/tabwriter"
"github.com/juju/cmd"
errors "github.com/juju/errors"
"github.com/juju/utils"
"gopkg.in/juju/names.v2"
"launchpad.net/gnuflag"
"github.com/juju/juju/apiserver/params"
"github.com/juju/juju/cmd/modelcmd"
)
func NewListCommand() cmd.Command {
return modelcmd.Wrap(&listCommand{})
}
// listCommand lists actions defined by the charm of a given service.
type listCommand struct {
ActionCommandBase
applicationTag names.ApplicationTag
fullSchema bool
out cmd.Output
}
const listDoc = `
List the actions available to run on the target application, with a short
description. To show the full schema for the actions, use --schema.
For more information, see also the 'run-action' command, which executes actions.
`
// Set up the output.
func (c *listCommand) SetFlags(f *gnuflag.FlagSet) {
c.out.AddFlags(f, "smart", cmd.DefaultFormatters)
f.BoolVar(&c.fullSchema, "schema", false, "Display the full action schema")
}
func (c *listCommand) Info() *cmd.Info {
return &cmd.Info{
Name: "actions",
Args: "<application name>",
Purpose: "List actions defined for a service.",
Doc: listDoc,
Aliases: []string{"list-actions"},
}
}
// Init validates the service name and any other options.
func (c *listCommand) Init(args []string) error {
switch len(args) {
case 0:
return errors.New("no application name specified")
case 1:
svcName := args[0]
if !names.IsValidApplication(svcName) {
return errors.Errorf("invalid application name %q", svcName)
}
c.applicationTag = names.NewApplicationTag(svcName)
return nil
default:
return cmd.CheckEmpty(args[1:])
}
}
// Run grabs the Actions spec from the api. It then sets up a sensible
// output format for the map.
func (c *listCommand) Run(ctx *cmd.Context) error {
api, err := c.NewActionAPIClient()
if err != nil {
return err
}
defer api.Close()
actions, err := api.ApplicationCharmActions(params.Entity{c.applicationTag.String()})
if err != nil {
return err
}
if len(actions) == 0 {
return c.out.Write(ctx, "No actions defined for "+c.applicationTag.Id())
}
if c.fullSchema {
verboseSpecs := make(map[string]interface{})
for k, v := range actions {
verboseSpecs[k] = v.Params
}
return c.out.Write(ctx, verboseSpecs)
}
shortOutput := make(map[string]string)
var sortedNames []string
for name, action := range actions {
shortOutput[name] = action.Description
if shortOutput[name] == "" {
shortOutput[name] = "No description"
}
sortedNames = append(sortedNames, name)
}
utils.SortStringsNaturally(sortedNames)
return c.printTabular(ctx, shortOutput, sortedNames)
}
// printTabular prints the list of actions in tabular format
func (c *listCommand) printTabular(ctx *cmd.Context, actions map[string]string, sortedNames []string) error {
var out bytes.Buffer
const (
// To format things into columns.
minwidth = 0
tabwidth = 2
padding = 2
padchar = ' '
flags = 0
)
tw := tabwriter.NewWriter(&out, minwidth, tabwidth, padding, padchar, flags)
fmt.Fprintf(tw, "%s\t%s\n", "ACTION", "DESCRIPTION")
for _, name := range sortedNames {
fmt.Fprintf(tw, "%s\t%s\n", name, strings.TrimSpace(actions[name]))
}
tw.Flush()
return c.out.Write(ctx, string(out.Bytes()))
}
|