FilesExpand file tree

 docs

/

cli.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

200 lines (176 loc) · 4.47 KB

 docs

/

cli.go

Copy path

Top

File metadata and controls

• Code
• Blame

200 lines (176 loc) · 4.47 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

package cli

import (

"errors"

"fmt"

"io"

"os"

"reflect"

"strings"

flag "github.com/docker/docker/pkg/mflag"

)

// Cli represents a command line interface.

type Cli struct {

Stderr io.Writer

handlers []Handler

Usage func()

}

// Handler holds the different commands Cli will call

// It should have methods with names starting with `Cmd` like:

// func (h myHandler) CmdFoo(args ...string) error

type Handler interface{}

// Initializer can be optionally implemented by a Handler to

// initialize before each call to one of its commands.

type Initializer interface {

Initialize() error

}

// New instantiates a ready-to-use Cli.

func New(handlers ...Handler) *Cli {

// make the generic Cli object the first cli handler

// in order to handle `docker help` appropriately

cli := new(Cli)

cli.handlers = append([]Handler{cli}, handlers...)

return cli

}

// initErr is an error returned upon initialization of a handler implementing Initializer.

type initErr struct{ error }

func (err initErr) Error() string {

return err.Error()

}

func (cli *Cli) command(args ...string) (func(...string) error, error) {

for _, c := range cli.handlers {

if c == nil {

continue

}

camelArgs := make([]string, len(args))

for i, s := range args {

if len(s) == 0 {

return nil, errors.New("empty command")

}

camelArgs[i] = strings.ToUpper(s[:1]) + strings.ToLower(s[1:])

}

methodName := "Cmd" + strings.Join(camelArgs, "")

method := reflect.ValueOf(c).MethodByName(methodName)

if method.IsValid() {

if c, ok := c.(Initializer); ok {

if err := c.Initialize(); err != nil {

return nil, initErr{err}

}

}

return method.Interface().(func(...string) error), nil

}

}

return nil, errors.New("command not found")

}

// Run executes the specified command.

func (cli *Cli) Run(args ...string) error {

if len(args) > 1 {

command, err := cli.command(args[:2]...)

switch err := err.(type) {

case nil:

return command(args[2:]...)

case initErr:

return err.error

}

}

if len(args) > 0 {

command, err := cli.command(args[0])

switch err := err.(type) {

case nil:

return command(args[1:]...)

case initErr:

return err.error

}

cli.noSuchCommand(args[0])

}

return cli.CmdHelp()

}

func (cli *Cli) noSuchCommand(command string) {

if cli.Stderr == nil {

cli.Stderr = os.Stderr

}

fmt.Fprintf(cli.Stderr, "docker: '%s' is not a docker command.\nSee 'docker --help'.\n", command)

os.Exit(1)

}

// CmdHelp displays information on a Docker command.

//

// If more than one command is specified, information is only shown for the first command.

//

// Usage: docker help COMMAND or docker COMMAND --help

func (cli *Cli) CmdHelp(args ...string) error {

if len(args) > 1 {

command, err := cli.command(args[:2]...)

switch err := err.(type) {

case nil:

command("--help")

return nil

case initErr:

return err.error

}

}

if len(args) > 0 {

command, err := cli.command(args[0])

switch err := err.(type) {

case nil:

command("--help")

return nil

case initErr:

return err.error

}

cli.noSuchCommand(args[0])

}

if cli.Usage == nil {

flag.Usage()

} else {

cli.Usage()

}

return nil

}

// Subcmd is a subcommand of the main "docker" command.

// A subcommand represents an action that can be performed

// from the Docker command line client.

//

// To see all available subcommands, run "docker --help".

func Subcmd(name string, synopses []string, description string, exitOnError bool) *flag.FlagSet {

var errorHandling flag.ErrorHandling

if exitOnError {

errorHandling = flag.ExitOnError

} else {

errorHandling = flag.ContinueOnError

}

flags := flag.NewFlagSet(name, errorHandling)

flags.Usage = func() {

flags.ShortUsage()

flags.PrintDefaults()

}

flags.ShortUsage = func() {

options := ""

if flags.FlagCountUndeprecated() > 0 {

options = " [OPTIONS]"

}

if len(synopses) == 0 {

synopses = []string{""}

}

// Allow for multiple command usage synopses.

for i, synopsis := range synopses {

lead := "\t"

if i == 0 {

// First line needs the word 'Usage'.

lead = "Usage:\t"

}

if synopsis != "" {

synopsis = " " + synopsis

}

fmt.Fprintf(flags.Out(), "\n%sdocker %s%s%s", lead, name, options, synopsis)

}

fmt.Fprintf(flags.Out(), "\n\n%s\n", description)

}

return flags

}

// An StatusError reports an unsuccessful exit by a command.

type StatusError struct {

Status string

StatusCode int

}

func (e StatusError) Error() string {

return fmt.Sprintf("Status: %s, Code: %d", e.Status, e.StatusCode)

}