commands.go 80 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862
  1. package client
  2. import (
  3. "bufio"
  4. "bytes"
  5. "encoding/base64"
  6. "encoding/json"
  7. "errors"
  8. "fmt"
  9. "io"
  10. "io/ioutil"
  11. "net/http"
  12. "net/url"
  13. "os"
  14. "os/exec"
  15. "path"
  16. "path/filepath"
  17. "runtime"
  18. "sort"
  19. "strconv"
  20. "strings"
  21. "sync"
  22. "text/tabwriter"
  23. "text/template"
  24. "time"
  25. log "github.com/Sirupsen/logrus"
  26. "github.com/docker/docker/api"
  27. "github.com/docker/docker/api/types"
  28. "github.com/docker/docker/autogen/dockerversion"
  29. "github.com/docker/docker/engine"
  30. "github.com/docker/docker/graph"
  31. "github.com/docker/docker/nat"
  32. "github.com/docker/docker/opts"
  33. "github.com/docker/docker/pkg/archive"
  34. "github.com/docker/docker/pkg/common"
  35. "github.com/docker/docker/pkg/fileutils"
  36. "github.com/docker/docker/pkg/homedir"
  37. flag "github.com/docker/docker/pkg/mflag"
  38. "github.com/docker/docker/pkg/networkfs/resolvconf"
  39. "github.com/docker/docker/pkg/parsers"
  40. "github.com/docker/docker/pkg/parsers/filters"
  41. "github.com/docker/docker/pkg/progressreader"
  42. "github.com/docker/docker/pkg/promise"
  43. "github.com/docker/docker/pkg/signal"
  44. "github.com/docker/docker/pkg/symlink"
  45. "github.com/docker/docker/pkg/term"
  46. "github.com/docker/docker/pkg/timeutils"
  47. "github.com/docker/docker/pkg/units"
  48. "github.com/docker/docker/pkg/urlutil"
  49. "github.com/docker/docker/registry"
  50. "github.com/docker/docker/runconfig"
  51. "github.com/docker/docker/utils"
  52. )
  53. const (
  54. tarHeaderSize = 512
  55. )
  56. func (cli *DockerCli) CmdHelp(args ...string) error {
  57. if len(args) > 1 {
  58. method, exists := cli.getMethod(args[:2]...)
  59. if exists {
  60. method("--help")
  61. return nil
  62. }
  63. }
  64. if len(args) > 0 {
  65. method, exists := cli.getMethod(args[0])
  66. if !exists {
  67. fmt.Fprintf(cli.err, "docker: '%s' is not a docker command. See 'docker --help'.\n", args[0])
  68. os.Exit(1)
  69. } else {
  70. method("--help")
  71. return nil
  72. }
  73. }
  74. flag.Usage()
  75. return nil
  76. }
  77. func (cli *DockerCli) CmdBuild(args ...string) error {
  78. cmd := cli.Subcmd("build", "PATH | URL | -", "Build a new image from the source code at PATH", true)
  79. tag := cmd.String([]string{"t", "-tag"}, "", "Repository name (and optionally a tag) for the image")
  80. suppressOutput := cmd.Bool([]string{"q", "-quiet"}, false, "Suppress the verbose output generated by the containers")
  81. noCache := cmd.Bool([]string{"#no-cache", "-no-cache"}, false, "Do not use cache when building the image")
  82. rm := cmd.Bool([]string{"#rm", "-rm"}, true, "Remove intermediate containers after a successful build")
  83. forceRm := cmd.Bool([]string{"-force-rm"}, false, "Always remove intermediate containers")
  84. pull := cmd.Bool([]string{"-pull"}, false, "Always attempt to pull a newer version of the image")
  85. dockerfileName := cmd.String([]string{"f", "-file"}, "", "Name of the Dockerfile (Default is 'PATH/Dockerfile')")
  86. cmd.Require(flag.Exact, 1)
  87. utils.ParseFlags(cmd, args, true)
  88. var (
  89. context archive.Archive
  90. isRemote bool
  91. err error
  92. )
  93. _, err = exec.LookPath("git")
  94. hasGit := err == nil
  95. if cmd.Arg(0) == "-" {
  96. // As a special case, 'docker build -' will build from either an empty context with the
  97. // contents of stdin as a Dockerfile, or a tar-ed context from stdin.
  98. buf := bufio.NewReader(cli.in)
  99. magic, err := buf.Peek(tarHeaderSize)
  100. if err != nil && err != io.EOF {
  101. return fmt.Errorf("failed to peek context header from STDIN: %v", err)
  102. }
  103. if !archive.IsArchive(magic) {
  104. dockerfile, err := ioutil.ReadAll(buf)
  105. if err != nil {
  106. return fmt.Errorf("failed to read Dockerfile from STDIN: %v", err)
  107. }
  108. // -f option has no meaning when we're reading it from stdin,
  109. // so just use our default Dockerfile name
  110. *dockerfileName = api.DefaultDockerfileName
  111. context, err = archive.Generate(*dockerfileName, string(dockerfile))
  112. } else {
  113. context = ioutil.NopCloser(buf)
  114. }
  115. } else if urlutil.IsURL(cmd.Arg(0)) && (!urlutil.IsGitURL(cmd.Arg(0)) || !hasGit) {
  116. isRemote = true
  117. } else {
  118. root := cmd.Arg(0)
  119. if urlutil.IsGitURL(root) {
  120. remoteURL := cmd.Arg(0)
  121. if !urlutil.IsGitTransport(remoteURL) {
  122. remoteURL = "https://" + remoteURL
  123. }
  124. root, err = ioutil.TempDir("", "docker-build-git")
  125. if err != nil {
  126. return err
  127. }
  128. defer os.RemoveAll(root)
  129. if output, err := exec.Command("git", "clone", "--recursive", remoteURL, root).CombinedOutput(); err != nil {
  130. return fmt.Errorf("Error trying to use git: %s (%s)", err, output)
  131. }
  132. }
  133. if _, err := os.Stat(root); err != nil {
  134. return err
  135. }
  136. absRoot, err := filepath.Abs(root)
  137. if err != nil {
  138. return err
  139. }
  140. filename := *dockerfileName // path to Dockerfile
  141. if *dockerfileName == "" {
  142. // No -f/--file was specified so use the default
  143. *dockerfileName = api.DefaultDockerfileName
  144. filename = filepath.Join(absRoot, *dockerfileName)
  145. // Just to be nice ;-) look for 'dockerfile' too but only
  146. // use it if we found it, otherwise ignore this check
  147. if _, err = os.Lstat(filename); os.IsNotExist(err) {
  148. tmpFN := path.Join(absRoot, strings.ToLower(*dockerfileName))
  149. if _, err = os.Lstat(tmpFN); err == nil {
  150. *dockerfileName = strings.ToLower(*dockerfileName)
  151. filename = tmpFN
  152. }
  153. }
  154. }
  155. origDockerfile := *dockerfileName // used for error msg
  156. if filename, err = filepath.Abs(filename); err != nil {
  157. return err
  158. }
  159. // Verify that 'filename' is within the build context
  160. filename, err = symlink.FollowSymlinkInScope(filename, absRoot)
  161. if err != nil {
  162. return fmt.Errorf("The Dockerfile (%s) must be within the build context (%s)", origDockerfile, root)
  163. }
  164. // Now reset the dockerfileName to be relative to the build context
  165. *dockerfileName, err = filepath.Rel(absRoot, filename)
  166. if err != nil {
  167. return err
  168. }
  169. // And canonicalize dockerfile name to a platform-independent one
  170. *dockerfileName, err = archive.CanonicalTarNameForPath(*dockerfileName)
  171. if err != nil {
  172. return fmt.Errorf("Cannot canonicalize dockerfile path %s: %v", dockerfileName, err)
  173. }
  174. if _, err = os.Lstat(filename); os.IsNotExist(err) {
  175. return fmt.Errorf("Cannot locate Dockerfile: %s", origDockerfile)
  176. }
  177. var includes = []string{"."}
  178. excludes, err := utils.ReadDockerIgnore(path.Join(root, ".dockerignore"))
  179. if err != nil {
  180. return err
  181. }
  182. // If .dockerignore mentions .dockerignore or the Dockerfile
  183. // then make sure we send both files over to the daemon
  184. // because Dockerfile is, obviously, needed no matter what, and
  185. // .dockerignore is needed to know if either one needs to be
  186. // removed. The deamon will remove them for us, if needed, after it
  187. // parses the Dockerfile.
  188. keepThem1, _ := fileutils.Matches(".dockerignore", excludes)
  189. keepThem2, _ := fileutils.Matches(*dockerfileName, excludes)
  190. if keepThem1 || keepThem2 {
  191. includes = append(includes, ".dockerignore", *dockerfileName)
  192. }
  193. if err = utils.ValidateContextDirectory(root, excludes); err != nil {
  194. return fmt.Errorf("Error checking context is accessible: '%s'. Please check permissions and try again.", err)
  195. }
  196. options := &archive.TarOptions{
  197. Compression: archive.Uncompressed,
  198. ExcludePatterns: excludes,
  199. IncludeFiles: includes,
  200. }
  201. context, err = archive.TarWithOptions(root, options)
  202. if err != nil {
  203. return err
  204. }
  205. }
  206. var body io.Reader
  207. // Setup an upload progress bar
  208. // FIXME: ProgressReader shouldn't be this annoying to use
  209. if context != nil {
  210. sf := utils.NewStreamFormatter(false)
  211. body = progressreader.New(progressreader.Config{
  212. In: context,
  213. Out: cli.out,
  214. Formatter: sf,
  215. NewLines: true,
  216. ID: "",
  217. Action: "Sending build context to Docker daemon",
  218. })
  219. }
  220. // Send the build context
  221. v := &url.Values{}
  222. //Check if the given image name can be resolved
  223. if *tag != "" {
  224. repository, tag := parsers.ParseRepositoryTag(*tag)
  225. if err := registry.ValidateRepositoryName(repository); err != nil {
  226. return err
  227. }
  228. if len(tag) > 0 {
  229. if err := graph.ValidateTagName(tag); err != nil {
  230. return err
  231. }
  232. }
  233. }
  234. v.Set("t", *tag)
  235. if *suppressOutput {
  236. v.Set("q", "1")
  237. }
  238. if isRemote {
  239. v.Set("remote", cmd.Arg(0))
  240. }
  241. if *noCache {
  242. v.Set("nocache", "1")
  243. }
  244. if *rm {
  245. v.Set("rm", "1")
  246. } else {
  247. v.Set("rm", "0")
  248. }
  249. if *forceRm {
  250. v.Set("forcerm", "1")
  251. }
  252. if *pull {
  253. v.Set("pull", "1")
  254. }
  255. v.Set("dockerfile", *dockerfileName)
  256. cli.LoadConfigFile()
  257. headers := http.Header(make(map[string][]string))
  258. buf, err := json.Marshal(cli.configFile)
  259. if err != nil {
  260. return err
  261. }
  262. headers.Add("X-Registry-Config", base64.URLEncoding.EncodeToString(buf))
  263. if context != nil {
  264. headers.Set("Content-Type", "application/tar")
  265. }
  266. err = cli.stream("POST", fmt.Sprintf("/build?%s", v.Encode()), body, cli.out, headers)
  267. if jerr, ok := err.(*utils.JSONError); ok {
  268. // If no error code is set, default to 1
  269. if jerr.Code == 0 {
  270. jerr.Code = 1
  271. }
  272. return &utils.StatusError{Status: jerr.Message, StatusCode: jerr.Code}
  273. }
  274. return err
  275. }
  276. // 'docker login': login / register a user to registry service.
  277. func (cli *DockerCli) CmdLogin(args ...string) error {
  278. cmd := cli.Subcmd("login", "[SERVER]", "Register or log in to a Docker registry server, if no server is\nspecified \""+registry.IndexServerAddress()+"\" is the default.", true)
  279. cmd.Require(flag.Max, 1)
  280. var username, password, email string
  281. cmd.StringVar(&username, []string{"u", "-username"}, "", "Username")
  282. cmd.StringVar(&password, []string{"p", "-password"}, "", "Password")
  283. cmd.StringVar(&email, []string{"e", "-email"}, "", "Email")
  284. utils.ParseFlags(cmd, args, true)
  285. serverAddress := registry.IndexServerAddress()
  286. if len(cmd.Args()) > 0 {
  287. serverAddress = cmd.Arg(0)
  288. }
  289. promptDefault := func(prompt string, configDefault string) {
  290. if configDefault == "" {
  291. fmt.Fprintf(cli.out, "%s: ", prompt)
  292. } else {
  293. fmt.Fprintf(cli.out, "%s (%s): ", prompt, configDefault)
  294. }
  295. }
  296. readInput := func(in io.Reader, out io.Writer) string {
  297. reader := bufio.NewReader(in)
  298. line, _, err := reader.ReadLine()
  299. if err != nil {
  300. fmt.Fprintln(out, err.Error())
  301. os.Exit(1)
  302. }
  303. return string(line)
  304. }
  305. cli.LoadConfigFile()
  306. authconfig, ok := cli.configFile.Configs[serverAddress]
  307. if !ok {
  308. authconfig = registry.AuthConfig{}
  309. }
  310. if username == "" {
  311. promptDefault("Username", authconfig.Username)
  312. username = readInput(cli.in, cli.out)
  313. username = strings.Trim(username, " ")
  314. if username == "" {
  315. username = authconfig.Username
  316. }
  317. }
  318. // Assume that a different username means they may not want to use
  319. // the password or email from the config file, so prompt them
  320. if username != authconfig.Username {
  321. if password == "" {
  322. oldState, err := term.SaveState(cli.inFd)
  323. if err != nil {
  324. return err
  325. }
  326. fmt.Fprintf(cli.out, "Password: ")
  327. term.DisableEcho(cli.inFd, oldState)
  328. password = readInput(cli.in, cli.out)
  329. fmt.Fprint(cli.out, "\n")
  330. term.RestoreTerminal(cli.inFd, oldState)
  331. if password == "" {
  332. return fmt.Errorf("Error : Password Required")
  333. }
  334. }
  335. if email == "" {
  336. promptDefault("Email", authconfig.Email)
  337. email = readInput(cli.in, cli.out)
  338. if email == "" {
  339. email = authconfig.Email
  340. }
  341. }
  342. } else {
  343. // However, if they don't override the username use the
  344. // password or email from the cmd line if specified. IOW, allow
  345. // then to change/override them. And if not specified, just
  346. // use what's in the config file
  347. if password == "" {
  348. password = authconfig.Password
  349. }
  350. if email == "" {
  351. email = authconfig.Email
  352. }
  353. }
  354. authconfig.Username = username
  355. authconfig.Password = password
  356. authconfig.Email = email
  357. authconfig.ServerAddress = serverAddress
  358. cli.configFile.Configs[serverAddress] = authconfig
  359. stream, statusCode, err := cli.call("POST", "/auth", cli.configFile.Configs[serverAddress], false)
  360. if statusCode == 401 {
  361. delete(cli.configFile.Configs, serverAddress)
  362. registry.SaveConfig(cli.configFile)
  363. return err
  364. }
  365. if err != nil {
  366. return err
  367. }
  368. var out2 engine.Env
  369. err = out2.Decode(stream)
  370. if err != nil {
  371. cli.configFile, _ = registry.LoadConfig(homedir.Get())
  372. return err
  373. }
  374. registry.SaveConfig(cli.configFile)
  375. fmt.Fprintf(cli.out, "WARNING: login credentials saved in %s.\n", path.Join(homedir.Get(), registry.CONFIGFILE))
  376. if out2.Get("Status") != "" {
  377. fmt.Fprintf(cli.out, "%s\n", out2.Get("Status"))
  378. }
  379. return nil
  380. }
  381. // log out from a Docker registry
  382. func (cli *DockerCli) CmdLogout(args ...string) error {
  383. cmd := cli.Subcmd("logout", "[SERVER]", "Log out from a Docker registry, if no server is\nspecified \""+registry.IndexServerAddress()+"\" is the default.", true)
  384. cmd.Require(flag.Max, 1)
  385. utils.ParseFlags(cmd, args, false)
  386. serverAddress := registry.IndexServerAddress()
  387. if len(cmd.Args()) > 0 {
  388. serverAddress = cmd.Arg(0)
  389. }
  390. cli.LoadConfigFile()
  391. if _, ok := cli.configFile.Configs[serverAddress]; !ok {
  392. fmt.Fprintf(cli.out, "Not logged in to %s\n", serverAddress)
  393. } else {
  394. fmt.Fprintf(cli.out, "Remove login credentials for %s\n", serverAddress)
  395. delete(cli.configFile.Configs, serverAddress)
  396. if err := registry.SaveConfig(cli.configFile); err != nil {
  397. return fmt.Errorf("Failed to save docker config: %v", err)
  398. }
  399. }
  400. return nil
  401. }
  402. // 'docker wait': block until a container stops
  403. func (cli *DockerCli) CmdWait(args ...string) error {
  404. cmd := cli.Subcmd("wait", "CONTAINER [CONTAINER...]", "Block until a container stops, then print its exit code.", true)
  405. cmd.Require(flag.Min, 1)
  406. utils.ParseFlags(cmd, args, true)
  407. var encounteredError error
  408. for _, name := range cmd.Args() {
  409. status, err := waitForExit(cli, name)
  410. if err != nil {
  411. fmt.Fprintf(cli.err, "%s\n", err)
  412. encounteredError = fmt.Errorf("Error: failed to wait one or more containers")
  413. } else {
  414. fmt.Fprintf(cli.out, "%d\n", status)
  415. }
  416. }
  417. return encounteredError
  418. }
  419. // 'docker version': show version information
  420. func (cli *DockerCli) CmdVersion(args ...string) error {
  421. cmd := cli.Subcmd("version", "", "Show the Docker version information.", true)
  422. cmd.Require(flag.Exact, 0)
  423. utils.ParseFlags(cmd, args, false)
  424. if dockerversion.VERSION != "" {
  425. fmt.Fprintf(cli.out, "Client version: %s\n", dockerversion.VERSION)
  426. }
  427. fmt.Fprintf(cli.out, "Client API version: %s\n", api.APIVERSION)
  428. fmt.Fprintf(cli.out, "Go version (client): %s\n", runtime.Version())
  429. if dockerversion.GITCOMMIT != "" {
  430. fmt.Fprintf(cli.out, "Git commit (client): %s\n", dockerversion.GITCOMMIT)
  431. }
  432. fmt.Fprintf(cli.out, "OS/Arch (client): %s/%s\n", runtime.GOOS, runtime.GOARCH)
  433. body, _, err := readBody(cli.call("GET", "/version", nil, false))
  434. if err != nil {
  435. return err
  436. }
  437. out := engine.NewOutput()
  438. remoteVersion, err := out.AddEnv()
  439. if err != nil {
  440. log.Errorf("Error reading remote version: %s", err)
  441. return err
  442. }
  443. if _, err := out.Write(body); err != nil {
  444. log.Errorf("Error reading remote version: %s", err)
  445. return err
  446. }
  447. out.Close()
  448. fmt.Fprintf(cli.out, "Server version: %s\n", remoteVersion.Get("Version"))
  449. if apiVersion := remoteVersion.Get("ApiVersion"); apiVersion != "" {
  450. fmt.Fprintf(cli.out, "Server API version: %s\n", apiVersion)
  451. }
  452. fmt.Fprintf(cli.out, "Go version (server): %s\n", remoteVersion.Get("GoVersion"))
  453. fmt.Fprintf(cli.out, "Git commit (server): %s\n", remoteVersion.Get("GitCommit"))
  454. fmt.Fprintf(cli.out, "OS/Arch (server): %s/%s\n", remoteVersion.Get("Os"), remoteVersion.Get("Arch"))
  455. return nil
  456. }
  457. // 'docker info': display system-wide information.
  458. func (cli *DockerCli) CmdInfo(args ...string) error {
  459. cmd := cli.Subcmd("info", "", "Display system-wide information", true)
  460. cmd.Require(flag.Exact, 0)
  461. utils.ParseFlags(cmd, args, false)
  462. body, _, err := readBody(cli.call("GET", "/info", nil, false))
  463. if err != nil {
  464. return err
  465. }
  466. out := engine.NewOutput()
  467. remoteInfo, err := out.AddEnv()
  468. if err != nil {
  469. return err
  470. }
  471. if _, err := out.Write(body); err != nil {
  472. log.Errorf("Error reading remote info: %s", err)
  473. return err
  474. }
  475. out.Close()
  476. if remoteInfo.Exists("Containers") {
  477. fmt.Fprintf(cli.out, "Containers: %d\n", remoteInfo.GetInt("Containers"))
  478. }
  479. if remoteInfo.Exists("Images") {
  480. fmt.Fprintf(cli.out, "Images: %d\n", remoteInfo.GetInt("Images"))
  481. }
  482. if remoteInfo.Exists("Driver") {
  483. fmt.Fprintf(cli.out, "Storage Driver: %s\n", remoteInfo.Get("Driver"))
  484. }
  485. if remoteInfo.Exists("DriverStatus") {
  486. var driverStatus [][2]string
  487. if err := remoteInfo.GetJson("DriverStatus", &driverStatus); err != nil {
  488. return err
  489. }
  490. for _, pair := range driverStatus {
  491. fmt.Fprintf(cli.out, " %s: %s\n", pair[0], pair[1])
  492. }
  493. }
  494. if remoteInfo.Exists("ExecutionDriver") {
  495. fmt.Fprintf(cli.out, "Execution Driver: %s\n", remoteInfo.Get("ExecutionDriver"))
  496. }
  497. if remoteInfo.Exists("KernelVersion") {
  498. fmt.Fprintf(cli.out, "Kernel Version: %s\n", remoteInfo.Get("KernelVersion"))
  499. }
  500. if remoteInfo.Exists("OperatingSystem") {
  501. fmt.Fprintf(cli.out, "Operating System: %s\n", remoteInfo.Get("OperatingSystem"))
  502. }
  503. if remoteInfo.Exists("NCPU") {
  504. fmt.Fprintf(cli.out, "CPUs: %d\n", remoteInfo.GetInt("NCPU"))
  505. }
  506. if remoteInfo.Exists("MemTotal") {
  507. fmt.Fprintf(cli.out, "Total Memory: %s\n", units.BytesSize(float64(remoteInfo.GetInt64("MemTotal"))))
  508. }
  509. if remoteInfo.Exists("Name") {
  510. fmt.Fprintf(cli.out, "Name: %s\n", remoteInfo.Get("Name"))
  511. }
  512. if remoteInfo.Exists("ID") {
  513. fmt.Fprintf(cli.out, "ID: %s\n", remoteInfo.Get("ID"))
  514. }
  515. if remoteInfo.GetBool("Debug") || os.Getenv("DEBUG") != "" {
  516. if remoteInfo.Exists("Debug") {
  517. fmt.Fprintf(cli.out, "Debug mode (server): %v\n", remoteInfo.GetBool("Debug"))
  518. }
  519. fmt.Fprintf(cli.out, "Debug mode (client): %v\n", os.Getenv("DEBUG") != "")
  520. if remoteInfo.Exists("NFd") {
  521. fmt.Fprintf(cli.out, "Fds: %d\n", remoteInfo.GetInt("NFd"))
  522. }
  523. if remoteInfo.Exists("NGoroutines") {
  524. fmt.Fprintf(cli.out, "Goroutines: %d\n", remoteInfo.GetInt("NGoroutines"))
  525. }
  526. if remoteInfo.Exists("SystemTime") {
  527. t, err := remoteInfo.GetTime("SystemTime")
  528. if err != nil {
  529. log.Errorf("Error reading system time: %v", err)
  530. } else {
  531. fmt.Fprintf(cli.out, "System Time: %s\n", t.Format(time.UnixDate))
  532. }
  533. }
  534. if remoteInfo.Exists("NEventsListener") {
  535. fmt.Fprintf(cli.out, "EventsListeners: %d\n", remoteInfo.GetInt("NEventsListener"))
  536. }
  537. if initSha1 := remoteInfo.Get("InitSha1"); initSha1 != "" {
  538. fmt.Fprintf(cli.out, "Init SHA1: %s\n", initSha1)
  539. }
  540. if initPath := remoteInfo.Get("InitPath"); initPath != "" {
  541. fmt.Fprintf(cli.out, "Init Path: %s\n", initPath)
  542. }
  543. if root := remoteInfo.Get("DockerRootDir"); root != "" {
  544. fmt.Fprintf(cli.out, "Docker Root Dir: %s\n", root)
  545. }
  546. }
  547. if remoteInfo.Exists("HttpProxy") {
  548. fmt.Fprintf(cli.out, "Http Proxy: %s\n", remoteInfo.Get("HttpProxy"))
  549. }
  550. if remoteInfo.Exists("HttpsProxy") {
  551. fmt.Fprintf(cli.out, "Https Proxy: %s\n", remoteInfo.Get("HttpsProxy"))
  552. }
  553. if remoteInfo.Exists("NoProxy") {
  554. fmt.Fprintf(cli.out, "No Proxy: %s\n", remoteInfo.Get("NoProxy"))
  555. }
  556. if len(remoteInfo.GetList("IndexServerAddress")) != 0 {
  557. cli.LoadConfigFile()
  558. u := cli.configFile.Configs[remoteInfo.Get("IndexServerAddress")].Username
  559. if len(u) > 0 {
  560. fmt.Fprintf(cli.out, "Username: %v\n", u)
  561. fmt.Fprintf(cli.out, "Registry: %v\n", remoteInfo.GetList("IndexServerAddress"))
  562. }
  563. }
  564. if remoteInfo.Exists("MemoryLimit") && !remoteInfo.GetBool("MemoryLimit") {
  565. fmt.Fprintf(cli.err, "WARNING: No memory limit support\n")
  566. }
  567. if remoteInfo.Exists("SwapLimit") && !remoteInfo.GetBool("SwapLimit") {
  568. fmt.Fprintf(cli.err, "WARNING: No swap limit support\n")
  569. }
  570. if remoteInfo.Exists("IPv4Forwarding") && !remoteInfo.GetBool("IPv4Forwarding") {
  571. fmt.Fprintf(cli.err, "WARNING: IPv4 forwarding is disabled.\n")
  572. }
  573. if remoteInfo.Exists("Labels") {
  574. fmt.Fprintln(cli.out, "Labels:")
  575. for _, attribute := range remoteInfo.GetList("Labels") {
  576. fmt.Fprintf(cli.out, " %s\n", attribute)
  577. }
  578. }
  579. return nil
  580. }
  581. func (cli *DockerCli) CmdStop(args ...string) error {
  582. cmd := cli.Subcmd("stop", "CONTAINER [CONTAINER...]", "Stop a running container by sending SIGTERM and then SIGKILL after a\ngrace period", true)
  583. nSeconds := cmd.Int([]string{"t", "-time"}, 10, "Seconds to wait for stop before killing it")
  584. cmd.Require(flag.Min, 1)
  585. utils.ParseFlags(cmd, args, true)
  586. v := url.Values{}
  587. v.Set("t", strconv.Itoa(*nSeconds))
  588. var encounteredError error
  589. for _, name := range cmd.Args() {
  590. _, _, err := readBody(cli.call("POST", "/containers/"+name+"/stop?"+v.Encode(), nil, false))
  591. if err != nil {
  592. fmt.Fprintf(cli.err, "%s\n", err)
  593. encounteredError = fmt.Errorf("Error: failed to stop one or more containers")
  594. } else {
  595. fmt.Fprintf(cli.out, "%s\n", name)
  596. }
  597. }
  598. return encounteredError
  599. }
  600. func (cli *DockerCli) CmdRestart(args ...string) error {
  601. cmd := cli.Subcmd("restart", "CONTAINER [CONTAINER...]", "Restart a running container", true)
  602. nSeconds := cmd.Int([]string{"t", "-time"}, 10, "Seconds to wait for stop before killing the container")
  603. cmd.Require(flag.Min, 1)
  604. utils.ParseFlags(cmd, args, true)
  605. v := url.Values{}
  606. v.Set("t", strconv.Itoa(*nSeconds))
  607. var encounteredError error
  608. for _, name := range cmd.Args() {
  609. _, _, err := readBody(cli.call("POST", "/containers/"+name+"/restart?"+v.Encode(), nil, false))
  610. if err != nil {
  611. fmt.Fprintf(cli.err, "%s\n", err)
  612. encounteredError = fmt.Errorf("Error: failed to restart one or more containers")
  613. } else {
  614. fmt.Fprintf(cli.out, "%s\n", name)
  615. }
  616. }
  617. return encounteredError
  618. }
  619. func (cli *DockerCli) forwardAllSignals(cid string) chan os.Signal {
  620. sigc := make(chan os.Signal, 128)
  621. signal.CatchAll(sigc)
  622. go func() {
  623. for s := range sigc {
  624. if s == signal.SIGCHLD {
  625. continue
  626. }
  627. var sig string
  628. for sigStr, sigN := range signal.SignalMap {
  629. if sigN == s {
  630. sig = sigStr
  631. break
  632. }
  633. }
  634. if sig == "" {
  635. log.Errorf("Unsupported signal: %v. Discarding.", s)
  636. }
  637. if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%s", cid, sig), nil, false)); err != nil {
  638. log.Debugf("Error sending signal: %s", err)
  639. }
  640. }
  641. }()
  642. return sigc
  643. }
  644. func (cli *DockerCli) CmdStart(args ...string) error {
  645. var (
  646. cErr chan error
  647. tty bool
  648. cmd = cli.Subcmd("start", "CONTAINER [CONTAINER...]", "Start one or more stopped containers", true)
  649. attach = cmd.Bool([]string{"a", "-attach"}, false, "Attach STDOUT/STDERR and forward signals")
  650. openStdin = cmd.Bool([]string{"i", "-interactive"}, false, "Attach container's STDIN")
  651. )
  652. cmd.Require(flag.Min, 1)
  653. utils.ParseFlags(cmd, args, true)
  654. hijacked := make(chan io.Closer)
  655. // Block the return until the chan gets closed
  656. defer func() {
  657. log.Debugf("CmdStart() returned, defer waiting for hijack to finish.")
  658. if _, ok := <-hijacked; ok {
  659. log.Errorf("Hijack did not finish (chan still open)")
  660. }
  661. if *openStdin || *attach {
  662. cli.in.Close()
  663. }
  664. }()
  665. if *attach || *openStdin {
  666. if cmd.NArg() > 1 {
  667. return fmt.Errorf("You cannot start and attach multiple containers at once.")
  668. }
  669. stream, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil, false)
  670. if err != nil {
  671. return err
  672. }
  673. env := engine.Env{}
  674. if err := env.Decode(stream); err != nil {
  675. return err
  676. }
  677. config := env.GetSubEnv("Config")
  678. tty = config.GetBool("Tty")
  679. if !tty {
  680. sigc := cli.forwardAllSignals(cmd.Arg(0))
  681. defer signal.StopCatch(sigc)
  682. }
  683. var in io.ReadCloser
  684. v := url.Values{}
  685. v.Set("stream", "1")
  686. if *openStdin && config.GetBool("OpenStdin") {
  687. v.Set("stdin", "1")
  688. in = cli.in
  689. }
  690. v.Set("stdout", "1")
  691. v.Set("stderr", "1")
  692. cErr = promise.Go(func() error {
  693. return cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), tty, in, cli.out, cli.err, hijacked, nil)
  694. })
  695. } else {
  696. close(hijacked)
  697. }
  698. // Acknowledge the hijack before starting
  699. select {
  700. case closer := <-hijacked:
  701. // Make sure that the hijack gets closed when returning (results
  702. // in closing the hijack chan and freeing server's goroutines)
  703. if closer != nil {
  704. defer closer.Close()
  705. }
  706. case err := <-cErr:
  707. if err != nil {
  708. return err
  709. }
  710. }
  711. var encounteredError error
  712. for _, name := range cmd.Args() {
  713. _, _, err := readBody(cli.call("POST", "/containers/"+name+"/start", nil, false))
  714. if err != nil {
  715. if !*attach && !*openStdin {
  716. // attach and openStdin is false means it could be starting multiple containers
  717. // when a container start failed, show the error message and start next
  718. fmt.Fprintf(cli.err, "%s\n", err)
  719. encounteredError = fmt.Errorf("Error: failed to start one or more containers")
  720. } else {
  721. encounteredError = err
  722. }
  723. } else {
  724. if !*attach && !*openStdin {
  725. fmt.Fprintf(cli.out, "%s\n", name)
  726. }
  727. }
  728. }
  729. if encounteredError != nil {
  730. return encounteredError
  731. }
  732. if *openStdin || *attach {
  733. if tty && cli.isTerminalOut {
  734. if err := cli.monitorTtySize(cmd.Arg(0), false); err != nil {
  735. log.Errorf("Error monitoring TTY size: %s", err)
  736. }
  737. }
  738. if attchErr := <-cErr; attchErr != nil {
  739. return attchErr
  740. }
  741. _, status, err := getExitCode(cli, cmd.Arg(0))
  742. if err != nil {
  743. return err
  744. }
  745. if status != 0 {
  746. return &utils.StatusError{StatusCode: status}
  747. }
  748. }
  749. return nil
  750. }
  751. func (cli *DockerCli) CmdUnpause(args ...string) error {
  752. cmd := cli.Subcmd("unpause", "CONTAINER [CONTAINER...]", "Unpause all processes within a container", true)
  753. cmd.Require(flag.Min, 1)
  754. utils.ParseFlags(cmd, args, false)
  755. var encounteredError error
  756. for _, name := range cmd.Args() {
  757. if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/unpause", name), nil, false)); err != nil {
  758. fmt.Fprintf(cli.err, "%s\n", err)
  759. encounteredError = fmt.Errorf("Error: failed to unpause container named %s", name)
  760. } else {
  761. fmt.Fprintf(cli.out, "%s\n", name)
  762. }
  763. }
  764. return encounteredError
  765. }
  766. func (cli *DockerCli) CmdPause(args ...string) error {
  767. cmd := cli.Subcmd("pause", "CONTAINER [CONTAINER...]", "Pause all processes within a container", true)
  768. cmd.Require(flag.Min, 1)
  769. utils.ParseFlags(cmd, args, false)
  770. var encounteredError error
  771. for _, name := range cmd.Args() {
  772. if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/pause", name), nil, false)); err != nil {
  773. fmt.Fprintf(cli.err, "%s\n", err)
  774. encounteredError = fmt.Errorf("Error: failed to pause container named %s", name)
  775. } else {
  776. fmt.Fprintf(cli.out, "%s\n", name)
  777. }
  778. }
  779. return encounteredError
  780. }
  781. func (cli *DockerCli) CmdRename(args ...string) error {
  782. cmd := cli.Subcmd("rename", "OLD_NAME NEW_NAME", "Rename a container", true)
  783. if err := cmd.Parse(args); err != nil {
  784. return nil
  785. }
  786. if cmd.NArg() != 2 {
  787. cmd.Usage()
  788. return nil
  789. }
  790. old_name := cmd.Arg(0)
  791. new_name := cmd.Arg(1)
  792. if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/rename?name=%s", old_name, new_name), nil, false)); err != nil {
  793. fmt.Fprintf(cli.err, "%s\n", err)
  794. return fmt.Errorf("Error: failed to rename container named %s", old_name)
  795. }
  796. return nil
  797. }
  798. func (cli *DockerCli) CmdInspect(args ...string) error {
  799. cmd := cli.Subcmd("inspect", "CONTAINER|IMAGE [CONTAINER|IMAGE...]", "Return low-level information on a container or image", true)
  800. tmplStr := cmd.String([]string{"f", "#format", "-format"}, "", "Format the output using the given go template")
  801. cmd.Require(flag.Min, 1)
  802. utils.ParseFlags(cmd, args, true)
  803. var tmpl *template.Template
  804. if *tmplStr != "" {
  805. var err error
  806. if tmpl, err = template.New("").Funcs(funcMap).Parse(*tmplStr); err != nil {
  807. fmt.Fprintf(cli.err, "Template parsing error: %v\n", err)
  808. return &utils.StatusError{StatusCode: 64,
  809. Status: "Template parsing error: " + err.Error()}
  810. }
  811. }
  812. indented := new(bytes.Buffer)
  813. indented.WriteByte('[')
  814. status := 0
  815. for _, name := range cmd.Args() {
  816. obj, _, err := readBody(cli.call("GET", "/containers/"+name+"/json", nil, false))
  817. if err != nil {
  818. if strings.Contains(err.Error(), "Too many") {
  819. fmt.Fprintf(cli.err, "Error: %v", err)
  820. status = 1
  821. continue
  822. }
  823. obj, _, err = readBody(cli.call("GET", "/images/"+name+"/json", nil, false))
  824. if err != nil {
  825. if strings.Contains(err.Error(), "No such") {
  826. fmt.Fprintf(cli.err, "Error: No such image or container: %s\n", name)
  827. } else {
  828. fmt.Fprintf(cli.err, "%s", err)
  829. }
  830. status = 1
  831. continue
  832. }
  833. }
  834. if tmpl == nil {
  835. if err = json.Indent(indented, obj, "", " "); err != nil {
  836. fmt.Fprintf(cli.err, "%s\n", err)
  837. status = 1
  838. continue
  839. }
  840. } else {
  841. // Has template, will render
  842. var value interface{}
  843. if err := json.Unmarshal(obj, &value); err != nil {
  844. fmt.Fprintf(cli.err, "%s\n", err)
  845. status = 1
  846. continue
  847. }
  848. if err := tmpl.Execute(cli.out, value); err != nil {
  849. return err
  850. }
  851. cli.out.Write([]byte{'\n'})
  852. }
  853. indented.WriteString(",")
  854. }
  855. if indented.Len() > 1 {
  856. // Remove trailing ','
  857. indented.Truncate(indented.Len() - 1)
  858. }
  859. indented.WriteString("]\n")
  860. if tmpl == nil {
  861. if _, err := io.Copy(cli.out, indented); err != nil {
  862. return err
  863. }
  864. }
  865. if status != 0 {
  866. return &utils.StatusError{StatusCode: status}
  867. }
  868. return nil
  869. }
  870. func (cli *DockerCli) CmdTop(args ...string) error {
  871. cmd := cli.Subcmd("top", "CONTAINER [ps OPTIONS]", "Display the running processes of a container", true)
  872. cmd.Require(flag.Min, 1)
  873. utils.ParseFlags(cmd, args, true)
  874. val := url.Values{}
  875. if cmd.NArg() > 1 {
  876. val.Set("ps_args", strings.Join(cmd.Args()[1:], " "))
  877. }
  878. stream, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/top?"+val.Encode(), nil, false)
  879. if err != nil {
  880. return err
  881. }
  882. var procs engine.Env
  883. if err := procs.Decode(stream); err != nil {
  884. return err
  885. }
  886. w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
  887. fmt.Fprintln(w, strings.Join(procs.GetList("Titles"), "\t"))
  888. processes := [][]string{}
  889. if err := procs.GetJson("Processes", &processes); err != nil {
  890. return err
  891. }
  892. for _, proc := range processes {
  893. fmt.Fprintln(w, strings.Join(proc, "\t"))
  894. }
  895. w.Flush()
  896. return nil
  897. }
  898. func (cli *DockerCli) CmdPort(args ...string) error {
  899. cmd := cli.Subcmd("port", "CONTAINER [PRIVATE_PORT[/PROTO]]", "List port mappings for the CONTAINER, or lookup the public-facing port that\nis NAT-ed to the PRIVATE_PORT", true)
  900. cmd.Require(flag.Min, 1)
  901. utils.ParseFlags(cmd, args, true)
  902. stream, _, err := cli.call("GET", "/containers/"+cmd.Arg(0)+"/json", nil, false)
  903. if err != nil {
  904. return err
  905. }
  906. env := engine.Env{}
  907. if err := env.Decode(stream); err != nil {
  908. return err
  909. }
  910. ports := nat.PortMap{}
  911. if err := env.GetSubEnv("NetworkSettings").GetJson("Ports", &ports); err != nil {
  912. return err
  913. }
  914. if cmd.NArg() == 2 {
  915. var (
  916. port = cmd.Arg(1)
  917. proto = "tcp"
  918. parts = strings.SplitN(port, "/", 2)
  919. )
  920. if len(parts) == 2 && len(parts[1]) != 0 {
  921. port = parts[0]
  922. proto = parts[1]
  923. }
  924. natPort := port + "/" + proto
  925. if frontends, exists := ports[nat.Port(port+"/"+proto)]; exists && frontends != nil {
  926. for _, frontend := range frontends {
  927. fmt.Fprintf(cli.out, "%s:%s\n", frontend.HostIp, frontend.HostPort)
  928. }
  929. return nil
  930. }
  931. return fmt.Errorf("Error: No public port '%s' published for %s", natPort, cmd.Arg(0))
  932. }
  933. for from, frontends := range ports {
  934. for _, frontend := range frontends {
  935. fmt.Fprintf(cli.out, "%s -> %s:%s\n", from, frontend.HostIp, frontend.HostPort)
  936. }
  937. }
  938. return nil
  939. }
  940. // 'docker rmi IMAGE' removes all images with the name IMAGE
  941. func (cli *DockerCli) CmdRmi(args ...string) error {
  942. var (
  943. cmd = cli.Subcmd("rmi", "IMAGE [IMAGE...]", "Remove one or more images", true)
  944. force = cmd.Bool([]string{"f", "-force"}, false, "Force removal of the image")
  945. noprune = cmd.Bool([]string{"-no-prune"}, false, "Do not delete untagged parents")
  946. )
  947. cmd.Require(flag.Min, 1)
  948. utils.ParseFlags(cmd, args, true)
  949. v := url.Values{}
  950. if *force {
  951. v.Set("force", "1")
  952. }
  953. if *noprune {
  954. v.Set("noprune", "1")
  955. }
  956. var encounteredError error
  957. for _, name := range cmd.Args() {
  958. body, _, err := readBody(cli.call("DELETE", "/images/"+name+"?"+v.Encode(), nil, false))
  959. if err != nil {
  960. fmt.Fprintf(cli.err, "%s\n", err)
  961. encounteredError = fmt.Errorf("Error: failed to remove one or more images")
  962. } else {
  963. outs := engine.NewTable("Created", 0)
  964. if _, err := outs.ReadListFrom(body); err != nil {
  965. fmt.Fprintf(cli.err, "%s\n", err)
  966. encounteredError = fmt.Errorf("Error: failed to remove one or more images")
  967. continue
  968. }
  969. for _, out := range outs.Data {
  970. if out.Get("Deleted") != "" {
  971. fmt.Fprintf(cli.out, "Deleted: %s\n", out.Get("Deleted"))
  972. } else {
  973. fmt.Fprintf(cli.out, "Untagged: %s\n", out.Get("Untagged"))
  974. }
  975. }
  976. }
  977. }
  978. return encounteredError
  979. }
  980. func (cli *DockerCli) CmdHistory(args ...string) error {
  981. cmd := cli.Subcmd("history", "IMAGE", "Show the history of an image", true)
  982. quiet := cmd.Bool([]string{"q", "-quiet"}, false, "Only show numeric IDs")
  983. noTrunc := cmd.Bool([]string{"#notrunc", "-no-trunc"}, false, "Don't truncate output")
  984. cmd.Require(flag.Exact, 1)
  985. utils.ParseFlags(cmd, args, true)
  986. body, _, err := readBody(cli.call("GET", "/images/"+cmd.Arg(0)+"/history", nil, false))
  987. if err != nil {
  988. return err
  989. }
  990. outs := engine.NewTable("Created", 0)
  991. if _, err := outs.ReadListFrom(body); err != nil {
  992. return err
  993. }
  994. w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
  995. if !*quiet {
  996. fmt.Fprintln(w, "IMAGE\tCREATED\tCREATED BY\tSIZE")
  997. }
  998. for _, out := range outs.Data {
  999. outID := out.Get("Id")
  1000. if !*quiet {
  1001. if *noTrunc {
  1002. fmt.Fprintf(w, "%s\t", outID)
  1003. } else {
  1004. fmt.Fprintf(w, "%s\t", common.TruncateID(outID))
  1005. }
  1006. fmt.Fprintf(w, "%s ago\t", units.HumanDuration(time.Now().UTC().Sub(time.Unix(out.GetInt64("Created"), 0))))
  1007. if *noTrunc {
  1008. fmt.Fprintf(w, "%s\t", out.Get("CreatedBy"))
  1009. } else {
  1010. fmt.Fprintf(w, "%s\t", utils.Trunc(out.Get("CreatedBy"), 45))
  1011. }
  1012. fmt.Fprintf(w, "%s\n", units.HumanSize(float64(out.GetInt64("Size"))))
  1013. } else {
  1014. if *noTrunc {
  1015. fmt.Fprintln(w, outID)
  1016. } else {
  1017. fmt.Fprintln(w, common.TruncateID(outID))
  1018. }
  1019. }
  1020. }
  1021. w.Flush()
  1022. return nil
  1023. }
  1024. func (cli *DockerCli) CmdRm(args ...string) error {
  1025. cmd := cli.Subcmd("rm", "CONTAINER [CONTAINER...]", "Remove one or more containers", true)
  1026. v := cmd.Bool([]string{"v", "-volumes"}, false, "Remove the volumes associated with the container")
  1027. link := cmd.Bool([]string{"l", "#link", "-link"}, false, "Remove the specified link")
  1028. force := cmd.Bool([]string{"f", "-force"}, false, "Force the removal of a running container (uses SIGKILL)")
  1029. cmd.Require(flag.Min, 1)
  1030. utils.ParseFlags(cmd, args, true)
  1031. val := url.Values{}
  1032. if *v {
  1033. val.Set("v", "1")
  1034. }
  1035. if *link {
  1036. val.Set("link", "1")
  1037. }
  1038. if *force {
  1039. val.Set("force", "1")
  1040. }
  1041. var encounteredError error
  1042. for _, name := range cmd.Args() {
  1043. _, _, err := readBody(cli.call("DELETE", "/containers/"+name+"?"+val.Encode(), nil, false))
  1044. if err != nil {
  1045. fmt.Fprintf(cli.err, "%s\n", err)
  1046. encounteredError = fmt.Errorf("Error: failed to remove one or more containers")
  1047. } else {
  1048. fmt.Fprintf(cli.out, "%s\n", name)
  1049. }
  1050. }
  1051. return encounteredError
  1052. }
  1053. // 'docker kill NAME' kills a running container
  1054. func (cli *DockerCli) CmdKill(args ...string) error {
  1055. cmd := cli.Subcmd("kill", "CONTAINER [CONTAINER...]", "Kill a running container using SIGKILL or a specified signal", true)
  1056. signal := cmd.String([]string{"s", "-signal"}, "KILL", "Signal to send to the container")
  1057. cmd.Require(flag.Min, 1)
  1058. utils.ParseFlags(cmd, args, true)
  1059. var encounteredError error
  1060. for _, name := range cmd.Args() {
  1061. if _, _, err := readBody(cli.call("POST", fmt.Sprintf("/containers/%s/kill?signal=%s", name, *signal), nil, false)); err != nil {
  1062. fmt.Fprintf(cli.err, "%s\n", err)
  1063. encounteredError = fmt.Errorf("Error: failed to kill one or more containers")
  1064. } else {
  1065. fmt.Fprintf(cli.out, "%s\n", name)
  1066. }
  1067. }
  1068. return encounteredError
  1069. }
  1070. func (cli *DockerCli) CmdImport(args ...string) error {
  1071. cmd := cli.Subcmd("import", "URL|- [REPOSITORY[:TAG]]", "Create an empty filesystem image and import the contents of the\ntarball (.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz) into it, then\noptionally tag it.", true)
  1072. flChanges := opts.NewListOpts(nil)
  1073. cmd.Var(&flChanges, []string{"c", "-change"}, "Apply Dockerfile instruction to the created image")
  1074. cmd.Require(flag.Min, 1)
  1075. utils.ParseFlags(cmd, args, true)
  1076. var (
  1077. v = url.Values{}
  1078. src = cmd.Arg(0)
  1079. repository = cmd.Arg(1)
  1080. )
  1081. v.Set("fromSrc", src)
  1082. v.Set("repo", repository)
  1083. for _, change := range flChanges.GetAll() {
  1084. v.Add("changes", change)
  1085. }
  1086. if cmd.NArg() == 3 {
  1087. fmt.Fprintf(cli.err, "[DEPRECATED] The format 'URL|- [REPOSITORY [TAG]]' has been deprecated. Please use URL|- [REPOSITORY[:TAG]]\n")
  1088. v.Set("tag", cmd.Arg(2))
  1089. }
  1090. if repository != "" {
  1091. //Check if the given image name can be resolved
  1092. repo, _ := parsers.ParseRepositoryTag(repository)
  1093. if err := registry.ValidateRepositoryName(repo); err != nil {
  1094. return err
  1095. }
  1096. }
  1097. var in io.Reader
  1098. if src == "-" {
  1099. in = cli.in
  1100. }
  1101. return cli.stream("POST", "/images/create?"+v.Encode(), in, cli.out, nil)
  1102. }
  1103. func (cli *DockerCli) CmdPush(args ...string) error {
  1104. cmd := cli.Subcmd("push", "NAME[:TAG]", "Push an image or a repository to the registry", true)
  1105. cmd.Require(flag.Exact, 1)
  1106. utils.ParseFlags(cmd, args, true)
  1107. name := cmd.Arg(0)
  1108. cli.LoadConfigFile()
  1109. remote, tag := parsers.ParseRepositoryTag(name)
  1110. // Resolve the Repository name from fqn to RepositoryInfo
  1111. repoInfo, err := registry.ParseRepositoryInfo(remote)
  1112. if err != nil {
  1113. return err
  1114. }
  1115. // Resolve the Auth config relevant for this server
  1116. authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)
  1117. // If we're not using a custom registry, we know the restrictions
  1118. // applied to repository names and can warn the user in advance.
  1119. // Custom repositories can have different rules, and we must also
  1120. // allow pushing by image ID.
  1121. if repoInfo.Official {
  1122. username := authConfig.Username
  1123. if username == "" {
  1124. username = "<user>"
  1125. }
  1126. return fmt.Errorf("You cannot push a \"root\" repository. Please rename your repository to <user>/<repo> (ex: %s/%s)", username, repoInfo.LocalName)
  1127. }
  1128. v := url.Values{}
  1129. v.Set("tag", tag)
  1130. push := func(authConfig registry.AuthConfig) error {
  1131. buf, err := json.Marshal(authConfig)
  1132. if err != nil {
  1133. return err
  1134. }
  1135. registryAuthHeader := []string{
  1136. base64.URLEncoding.EncodeToString(buf),
  1137. }
  1138. return cli.stream("POST", "/images/"+remote+"/push?"+v.Encode(), nil, cli.out, map[string][]string{
  1139. "X-Registry-Auth": registryAuthHeader,
  1140. })
  1141. }
  1142. if err := push(authConfig); err != nil {
  1143. if strings.Contains(err.Error(), "Status 401") {
  1144. fmt.Fprintln(cli.out, "\nPlease login prior to push:")
  1145. if err := cli.CmdLogin(repoInfo.Index.GetAuthConfigKey()); err != nil {
  1146. return err
  1147. }
  1148. authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)
  1149. return push(authConfig)
  1150. }
  1151. return err
  1152. }
  1153. return nil
  1154. }
  1155. func (cli *DockerCli) CmdPull(args ...string) error {
  1156. cmd := cli.Subcmd("pull", "NAME[:TAG|@DIGEST]", "Pull an image or a repository from the registry", true)
  1157. allTags := cmd.Bool([]string{"a", "-all-tags"}, false, "Download all tagged images in the repository")
  1158. cmd.Require(flag.Exact, 1)
  1159. utils.ParseFlags(cmd, args, true)
  1160. var (
  1161. v = url.Values{}
  1162. remote = cmd.Arg(0)
  1163. newRemote = remote
  1164. )
  1165. taglessRemote, tag := parsers.ParseRepositoryTag(remote)
  1166. if tag == "" && !*allTags {
  1167. newRemote = utils.ImageReference(taglessRemote, graph.DEFAULTTAG)
  1168. }
  1169. if tag != "" && *allTags {
  1170. return fmt.Errorf("tag can't be used with --all-tags/-a")
  1171. }
  1172. v.Set("fromImage", newRemote)
  1173. // Resolve the Repository name from fqn to RepositoryInfo
  1174. repoInfo, err := registry.ParseRepositoryInfo(taglessRemote)
  1175. if err != nil {
  1176. return err
  1177. }
  1178. cli.LoadConfigFile()
  1179. // Resolve the Auth config relevant for this server
  1180. authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)
  1181. pull := func(authConfig registry.AuthConfig) error {
  1182. buf, err := json.Marshal(authConfig)
  1183. if err != nil {
  1184. return err
  1185. }
  1186. registryAuthHeader := []string{
  1187. base64.URLEncoding.EncodeToString(buf),
  1188. }
  1189. return cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.out, map[string][]string{
  1190. "X-Registry-Auth": registryAuthHeader,
  1191. })
  1192. }
  1193. if err := pull(authConfig); err != nil {
  1194. if strings.Contains(err.Error(), "Status 401") {
  1195. fmt.Fprintln(cli.out, "\nPlease login prior to pull:")
  1196. if err := cli.CmdLogin(repoInfo.Index.GetAuthConfigKey()); err != nil {
  1197. return err
  1198. }
  1199. authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)
  1200. return pull(authConfig)
  1201. }
  1202. return err
  1203. }
  1204. return nil
  1205. }
  1206. func (cli *DockerCli) CmdImages(args ...string) error {
  1207. cmd := cli.Subcmd("images", "[REPOSITORY]", "List images", true)
  1208. quiet := cmd.Bool([]string{"q", "-quiet"}, false, "Only show numeric IDs")
  1209. all := cmd.Bool([]string{"a", "-all"}, false, "Show all images (default hides intermediate images)")
  1210. noTrunc := cmd.Bool([]string{"#notrunc", "-no-trunc"}, false, "Don't truncate output")
  1211. showDigests := cmd.Bool([]string{"-digests"}, false, "Show digests")
  1212. // FIXME: --viz and --tree are deprecated. Remove them in a future version.
  1213. flViz := cmd.Bool([]string{"#v", "#viz", "#-viz"}, false, "Output graph in graphviz format")
  1214. flTree := cmd.Bool([]string{"#t", "#tree", "#-tree"}, false, "Output graph in tree format")
  1215. flFilter := opts.NewListOpts(nil)
  1216. cmd.Var(&flFilter, []string{"f", "-filter"}, "Filter output based on conditions provided")
  1217. cmd.Require(flag.Max, 1)
  1218. utils.ParseFlags(cmd, args, true)
  1219. // Consolidate all filter flags, and sanity check them early.
  1220. // They'll get process in the daemon/server.
  1221. imageFilterArgs := filters.Args{}
  1222. for _, f := range flFilter.GetAll() {
  1223. var err error
  1224. imageFilterArgs, err = filters.ParseFlag(f, imageFilterArgs)
  1225. if err != nil {
  1226. return err
  1227. }
  1228. }
  1229. matchName := cmd.Arg(0)
  1230. // FIXME: --viz and --tree are deprecated. Remove them in a future version.
  1231. if *flViz || *flTree {
  1232. v := url.Values{
  1233. "all": []string{"1"},
  1234. }
  1235. if len(imageFilterArgs) > 0 {
  1236. filterJson, err := filters.ToParam(imageFilterArgs)
  1237. if err != nil {
  1238. return err
  1239. }
  1240. v.Set("filters", filterJson)
  1241. }
  1242. body, _, err := readBody(cli.call("GET", "/images/json?"+v.Encode(), nil, false))
  1243. if err != nil {
  1244. return err
  1245. }
  1246. outs := engine.NewTable("Created", 0)
  1247. if _, err := outs.ReadListFrom(body); err != nil {
  1248. return err
  1249. }
  1250. var (
  1251. printNode func(cli *DockerCli, noTrunc bool, image *engine.Env, prefix string)
  1252. startImage *engine.Env
  1253. roots = engine.NewTable("Created", outs.Len())
  1254. byParent = make(map[string]*engine.Table)
  1255. )
  1256. for _, image := range outs.Data {
  1257. if image.Get("ParentId") == "" {
  1258. roots.Add(image)
  1259. } else {
  1260. if children, exists := byParent[image.Get("ParentId")]; exists {
  1261. children.Add(image)
  1262. } else {
  1263. byParent[image.Get("ParentId")] = engine.NewTable("Created", 1)
  1264. byParent[image.Get("ParentId")].Add(image)
  1265. }
  1266. }
  1267. if matchName != "" {
  1268. if matchName == image.Get("Id") || matchName == common.TruncateID(image.Get("Id")) {
  1269. startImage = image
  1270. }
  1271. for _, repotag := range image.GetList("RepoTags") {
  1272. if repotag == matchName {
  1273. startImage = image
  1274. }
  1275. }
  1276. }
  1277. }
  1278. if *flViz {
  1279. fmt.Fprintf(cli.out, "digraph docker {\n")
  1280. printNode = (*DockerCli).printVizNode
  1281. } else {
  1282. printNode = (*DockerCli).printTreeNode
  1283. }
  1284. if startImage != nil {
  1285. root := engine.NewTable("Created", 1)
  1286. root.Add(startImage)
  1287. cli.WalkTree(*noTrunc, root, byParent, "", printNode)
  1288. } else if matchName == "" {
  1289. cli.WalkTree(*noTrunc, roots, byParent, "", printNode)
  1290. }
  1291. if *flViz {
  1292. fmt.Fprintf(cli.out, " base [style=invisible]\n}\n")
  1293. }
  1294. } else {
  1295. v := url.Values{}
  1296. if len(imageFilterArgs) > 0 {
  1297. filterJson, err := filters.ToParam(imageFilterArgs)
  1298. if err != nil {
  1299. return err
  1300. }
  1301. v.Set("filters", filterJson)
  1302. }
  1303. if cmd.NArg() == 1 {
  1304. // FIXME rename this parameter, to not be confused with the filters flag
  1305. v.Set("filter", matchName)
  1306. }
  1307. if *all {
  1308. v.Set("all", "1")
  1309. }
  1310. body, _, err := readBody(cli.call("GET", "/images/json?"+v.Encode(), nil, false))
  1311. if err != nil {
  1312. return err
  1313. }
  1314. outs := engine.NewTable("Created", 0)
  1315. if _, err := outs.ReadListFrom(body); err != nil {
  1316. return err
  1317. }
  1318. w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
  1319. if !*quiet {
  1320. if *showDigests {
  1321. fmt.Fprintln(w, "REPOSITORY\tTAG\tDIGEST\tIMAGE ID\tCREATED\tVIRTUAL SIZE")
  1322. } else {
  1323. fmt.Fprintln(w, "REPOSITORY\tTAG\tIMAGE ID\tCREATED\tVIRTUAL SIZE")
  1324. }
  1325. }
  1326. for _, out := range outs.Data {
  1327. outID := out.Get("Id")
  1328. if !*noTrunc {
  1329. outID = common.TruncateID(outID)
  1330. }
  1331. // Tags referring to this image ID.
  1332. for _, repotag := range out.GetList("RepoTags") {
  1333. repo, tag := parsers.ParseRepositoryTag(repotag)
  1334. if !*quiet {
  1335. if *showDigests {
  1336. fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s ago\t%s\n", repo, tag, "<none>", outID, units.HumanDuration(time.Now().UTC().Sub(time.Unix(out.GetInt64("Created"), 0))), units.HumanSize(float64(out.GetInt64("VirtualSize"))))
  1337. } else {
  1338. fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\n", repo, tag, outID, units.HumanDuration(time.Now().UTC().Sub(time.Unix(out.GetInt64("Created"), 0))), units.HumanSize(float64(out.GetInt64("VirtualSize"))))
  1339. }
  1340. } else {
  1341. fmt.Fprintln(w, outID)
  1342. }
  1343. }
  1344. // Digests referring to this image ID.
  1345. for _, repoDigest := range out.GetList("RepoDigests") {
  1346. repo, digest := parsers.ParseRepositoryTag(repoDigest)
  1347. if !*quiet {
  1348. if *showDigests {
  1349. fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s ago\t%s\n", repo, "<none>", digest, outID, units.HumanDuration(time.Now().UTC().Sub(time.Unix(out.GetInt64("Created"), 0))), units.HumanSize(float64(out.GetInt64("VirtualSize"))))
  1350. } else {
  1351. fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\n", repo, "<none>", outID, units.HumanDuration(time.Now().UTC().Sub(time.Unix(out.GetInt64("Created"), 0))), units.HumanSize(float64(out.GetInt64("VirtualSize"))))
  1352. }
  1353. } else {
  1354. fmt.Fprintln(w, outID)
  1355. }
  1356. }
  1357. }
  1358. if !*quiet {
  1359. w.Flush()
  1360. }
  1361. }
  1362. return nil
  1363. }
  1364. // FIXME: --viz and --tree are deprecated. Remove them in a future version.
  1365. func (cli *DockerCli) WalkTree(noTrunc bool, images *engine.Table, byParent map[string]*engine.Table, prefix string, printNode func(cli *DockerCli, noTrunc bool, image *engine.Env, prefix string)) {
  1366. length := images.Len()
  1367. if length > 1 {
  1368. for index, image := range images.Data {
  1369. if index+1 == length {
  1370. printNode(cli, noTrunc, image, prefix+"└─")
  1371. if subimages, exists := byParent[image.Get("Id")]; exists {
  1372. cli.WalkTree(noTrunc, subimages, byParent, prefix+" ", printNode)
  1373. }
  1374. } else {
  1375. printNode(cli, noTrunc, image, prefix+"\u251C─")
  1376. if subimages, exists := byParent[image.Get("Id")]; exists {
  1377. cli.WalkTree(noTrunc, subimages, byParent, prefix+"\u2502 ", printNode)
  1378. }
  1379. }
  1380. }
  1381. } else {
  1382. for _, image := range images.Data {
  1383. printNode(cli, noTrunc, image, prefix+"└─")
  1384. if subimages, exists := byParent[image.Get("Id")]; exists {
  1385. cli.WalkTree(noTrunc, subimages, byParent, prefix+" ", printNode)
  1386. }
  1387. }
  1388. }
  1389. }
  1390. // FIXME: --viz and --tree are deprecated. Remove them in a future version.
  1391. func (cli *DockerCli) printVizNode(noTrunc bool, image *engine.Env, prefix string) {
  1392. var (
  1393. imageID string
  1394. parentID string
  1395. )
  1396. if noTrunc {
  1397. imageID = image.Get("Id")
  1398. parentID = image.Get("ParentId")
  1399. } else {
  1400. imageID = common.TruncateID(image.Get("Id"))
  1401. parentID = common.TruncateID(image.Get("ParentId"))
  1402. }
  1403. if parentID == "" {
  1404. fmt.Fprintf(cli.out, " base -> \"%s\" [style=invis]\n", imageID)
  1405. } else {
  1406. fmt.Fprintf(cli.out, " \"%s\" -> \"%s\"\n", parentID, imageID)
  1407. }
  1408. if image.GetList("RepoTags")[0] != "<none>:<none>" {
  1409. fmt.Fprintf(cli.out, " \"%s\" [label=\"%s\\n%s\",shape=box,fillcolor=\"paleturquoise\",style=\"filled,rounded\"];\n",
  1410. imageID, imageID, strings.Join(image.GetList("RepoTags"), "\\n"))
  1411. }
  1412. }
  1413. // FIXME: --viz and --tree are deprecated. Remove them in a future version.
  1414. func (cli *DockerCli) printTreeNode(noTrunc bool, image *engine.Env, prefix string) {
  1415. var imageID string
  1416. if noTrunc {
  1417. imageID = image.Get("Id")
  1418. } else {
  1419. imageID = common.TruncateID(image.Get("Id"))
  1420. }
  1421. fmt.Fprintf(cli.out, "%s%s Virtual Size: %s", prefix, imageID, units.HumanSize(float64(image.GetInt64("VirtualSize"))))
  1422. if image.GetList("RepoTags")[0] != "<none>:<none>" {
  1423. fmt.Fprintf(cli.out, " Tags: %s\n", strings.Join(image.GetList("RepoTags"), ", "))
  1424. } else {
  1425. fmt.Fprint(cli.out, "\n")
  1426. }
  1427. }
  1428. func (cli *DockerCli) CmdPs(args ...string) error {
  1429. var (
  1430. err error
  1431. psFilterArgs = filters.Args{}
  1432. v = url.Values{}
  1433. cmd = cli.Subcmd("ps", "", "List containers", true)
  1434. quiet = cmd.Bool([]string{"q", "-quiet"}, false, "Only display numeric IDs")
  1435. size = cmd.Bool([]string{"s", "-size"}, false, "Display total file sizes")
  1436. all = cmd.Bool([]string{"a", "-all"}, false, "Show all containers (default shows just running)")
  1437. noTrunc = cmd.Bool([]string{"#notrunc", "-no-trunc"}, false, "Don't truncate output")
  1438. nLatest = cmd.Bool([]string{"l", "-latest"}, false, "Show the latest created container, include non-running")
  1439. since = cmd.String([]string{"#sinceId", "#-since-id", "-since"}, "", "Show created since Id or Name, include non-running")
  1440. before = cmd.String([]string{"#beforeId", "#-before-id", "-before"}, "", "Show only container created before Id or Name")
  1441. last = cmd.Int([]string{"n"}, -1, "Show n last created containers, include non-running")
  1442. flFilter = opts.NewListOpts(nil)
  1443. )
  1444. cmd.Require(flag.Exact, 0)
  1445. cmd.Var(&flFilter, []string{"f", "-filter"}, "Filter output based on conditions provided")
  1446. utils.ParseFlags(cmd, args, true)
  1447. if *last == -1 && *nLatest {
  1448. *last = 1
  1449. }
  1450. if *all {
  1451. v.Set("all", "1")
  1452. }
  1453. if *last != -1 {
  1454. v.Set("limit", strconv.Itoa(*last))
  1455. }
  1456. if *since != "" {
  1457. v.Set("since", *since)
  1458. }
  1459. if *before != "" {
  1460. v.Set("before", *before)
  1461. }
  1462. if *size {
  1463. v.Set("size", "1")
  1464. }
  1465. // Consolidate all filter flags, and sanity check them.
  1466. // They'll get processed in the daemon/server.
  1467. for _, f := range flFilter.GetAll() {
  1468. if psFilterArgs, err = filters.ParseFlag(f, psFilterArgs); err != nil {
  1469. return err
  1470. }
  1471. }
  1472. if len(psFilterArgs) > 0 {
  1473. filterJson, err := filters.ToParam(psFilterArgs)
  1474. if err != nil {
  1475. return err
  1476. }
  1477. v.Set("filters", filterJson)
  1478. }
  1479. body, _, err := readBody(cli.call("GET", "/containers/json?"+v.Encode(), nil, false))
  1480. if err != nil {
  1481. return err
  1482. }
  1483. outs := engine.NewTable("Created", 0)
  1484. if _, err := outs.ReadListFrom(body); err != nil {
  1485. return err
  1486. }
  1487. w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
  1488. if !*quiet {
  1489. fmt.Fprint(w, "CONTAINER ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tPORTS\tNAMES")
  1490. if *size {
  1491. fmt.Fprintln(w, "\tSIZE")
  1492. } else {
  1493. fmt.Fprint(w, "\n")
  1494. }
  1495. }
  1496. stripNamePrefix := func(ss []string) []string {
  1497. for i, s := range ss {
  1498. ss[i] = s[1:]
  1499. }
  1500. return ss
  1501. }
  1502. for _, out := range outs.Data {
  1503. outID := out.Get("Id")
  1504. if !*noTrunc {
  1505. outID = common.TruncateID(outID)
  1506. }
  1507. if *quiet {
  1508. fmt.Fprintln(w, outID)
  1509. continue
  1510. }
  1511. var (
  1512. outNames = stripNamePrefix(out.GetList("Names"))
  1513. outCommand = strconv.Quote(out.Get("Command"))
  1514. ports = engine.NewTable("", 0)
  1515. )
  1516. if !*noTrunc {
  1517. outCommand = utils.Trunc(outCommand, 20)
  1518. // only display the default name for the container with notrunc is passed
  1519. for _, name := range outNames {
  1520. if len(strings.Split(name, "/")) == 1 {
  1521. outNames = []string{name}
  1522. break
  1523. }
  1524. }
  1525. }
  1526. ports.ReadListFrom([]byte(out.Get("Ports")))
  1527. image := out.Get("Image")
  1528. if image == "" {
  1529. image = "<no image>"
  1530. }
  1531. fmt.Fprintf(w, "%s\t%s\t%s\t%s ago\t%s\t%s\t%s\t", outID, image, outCommand,
  1532. units.HumanDuration(time.Now().UTC().Sub(time.Unix(out.GetInt64("Created"), 0))),
  1533. out.Get("Status"), api.DisplayablePorts(ports), strings.Join(outNames, ","))
  1534. if *size {
  1535. if out.GetInt("SizeRootFs") > 0 {
  1536. fmt.Fprintf(w, "%s (virtual %s)\n", units.HumanSize(float64(out.GetInt64("SizeRw"))), units.HumanSize(float64(out.GetInt64("SizeRootFs"))))
  1537. } else {
  1538. fmt.Fprintf(w, "%s\n", units.HumanSize(float64(out.GetInt64("SizeRw"))))
  1539. }
  1540. continue
  1541. }
  1542. fmt.Fprint(w, "\n")
  1543. }
  1544. if !*quiet {
  1545. w.Flush()
  1546. }
  1547. return nil
  1548. }
  1549. func (cli *DockerCli) CmdCommit(args ...string) error {
  1550. cmd := cli.Subcmd("commit", "CONTAINER [REPOSITORY[:TAG]]", "Create a new image from a container's changes", true)
  1551. flPause := cmd.Bool([]string{"p", "-pause"}, true, "Pause container during commit")
  1552. flComment := cmd.String([]string{"m", "-message"}, "", "Commit message")
  1553. flAuthor := cmd.String([]string{"a", "#author", "-author"}, "", "Author (e.g., \"John Hannibal Smith <hannibal@a-team.com>\")")
  1554. flChanges := opts.NewListOpts(nil)
  1555. cmd.Var(&flChanges, []string{"c", "-change"}, "Apply Dockerfile instruction to the created image")
  1556. // FIXME: --run is deprecated, it will be replaced with inline Dockerfile commands.
  1557. flConfig := cmd.String([]string{"#run", "#-run"}, "", "This option is deprecated and will be removed in a future version in favor of inline Dockerfile-compatible commands")
  1558. cmd.Require(flag.Max, 2)
  1559. cmd.Require(flag.Min, 1)
  1560. utils.ParseFlags(cmd, args, true)
  1561. var (
  1562. name = cmd.Arg(0)
  1563. repository, tag = parsers.ParseRepositoryTag(cmd.Arg(1))
  1564. )
  1565. //Check if the given image name can be resolved
  1566. if repository != "" {
  1567. if err := registry.ValidateRepositoryName(repository); err != nil {
  1568. return err
  1569. }
  1570. }
  1571. v := url.Values{}
  1572. v.Set("container", name)
  1573. v.Set("repo", repository)
  1574. v.Set("tag", tag)
  1575. v.Set("comment", *flComment)
  1576. v.Set("author", *flAuthor)
  1577. for _, change := range flChanges.GetAll() {
  1578. v.Add("changes", change)
  1579. }
  1580. if *flPause != true {
  1581. v.Set("pause", "0")
  1582. }
  1583. var (
  1584. config *runconfig.Config
  1585. env engine.Env
  1586. )
  1587. if *flConfig != "" {
  1588. config = &runconfig.Config{}
  1589. if err := json.Unmarshal([]byte(*flConfig), config); err != nil {
  1590. return err
  1591. }
  1592. }
  1593. stream, _, err := cli.call("POST", "/commit?"+v.Encode(), config, false)
  1594. if err != nil {
  1595. return err
  1596. }
  1597. if err := env.Decode(stream); err != nil {
  1598. return err
  1599. }
  1600. fmt.Fprintf(cli.out, "%s\n", env.Get("Id"))
  1601. return nil
  1602. }
  1603. func (cli *DockerCli) CmdEvents(args ...string) error {
  1604. cmd := cli.Subcmd("events", "", "Get real time events from the server", true)
  1605. since := cmd.String([]string{"#since", "-since"}, "", "Show all events created since timestamp")
  1606. until := cmd.String([]string{"-until"}, "", "Stream events until this timestamp")
  1607. flFilter := opts.NewListOpts(nil)
  1608. cmd.Var(&flFilter, []string{"f", "-filter"}, "Filter output based on conditions provided")
  1609. cmd.Require(flag.Exact, 0)
  1610. utils.ParseFlags(cmd, args, true)
  1611. var (
  1612. v = url.Values{}
  1613. loc = time.FixedZone(time.Now().Zone())
  1614. eventFilterArgs = filters.Args{}
  1615. )
  1616. // Consolidate all filter flags, and sanity check them early.
  1617. // They'll get process in the daemon/server.
  1618. for _, f := range flFilter.GetAll() {
  1619. var err error
  1620. eventFilterArgs, err = filters.ParseFlag(f, eventFilterArgs)
  1621. if err != nil {
  1622. return err
  1623. }
  1624. }
  1625. var setTime = func(key, value string) {
  1626. format := timeutils.RFC3339NanoFixed
  1627. if len(value) < len(format) {
  1628. format = format[:len(value)]
  1629. }
  1630. if t, err := time.ParseInLocation(format, value, loc); err == nil {
  1631. v.Set(key, strconv.FormatInt(t.Unix(), 10))
  1632. } else {
  1633. v.Set(key, value)
  1634. }
  1635. }
  1636. if *since != "" {
  1637. setTime("since", *since)
  1638. }
  1639. if *until != "" {
  1640. setTime("until", *until)
  1641. }
  1642. if len(eventFilterArgs) > 0 {
  1643. filterJson, err := filters.ToParam(eventFilterArgs)
  1644. if err != nil {
  1645. return err
  1646. }
  1647. v.Set("filters", filterJson)
  1648. }
  1649. if err := cli.stream("GET", "/events?"+v.Encode(), nil, cli.out, nil); err != nil {
  1650. return err
  1651. }
  1652. return nil
  1653. }
  1654. func (cli *DockerCli) CmdExport(args ...string) error {
  1655. cmd := cli.Subcmd("export", "CONTAINER", "Export the contents of a filesystem as a tar archive to STDOUT", true)
  1656. cmd.Require(flag.Exact, 1)
  1657. utils.ParseFlags(cmd, args, true)
  1658. if err := cli.stream("GET", "/containers/"+cmd.Arg(0)+"/export", nil, cli.out, nil); err != nil {
  1659. return err
  1660. }
  1661. return nil
  1662. }
  1663. func (cli *DockerCli) CmdDiff(args ...string) error {
  1664. cmd := cli.Subcmd("diff", "CONTAINER", "Inspect changes on a container's filesystem", true)
  1665. cmd.Require(flag.Exact, 1)
  1666. utils.ParseFlags(cmd, args, true)
  1667. body, _, err := readBody(cli.call("GET", "/containers/"+cmd.Arg(0)+"/changes", nil, false))
  1668. if err != nil {
  1669. return err
  1670. }
  1671. outs := engine.NewTable("", 0)
  1672. if _, err := outs.ReadListFrom(body); err != nil {
  1673. return err
  1674. }
  1675. for _, change := range outs.Data {
  1676. var kind string
  1677. switch change.GetInt("Kind") {
  1678. case archive.ChangeModify:
  1679. kind = "C"
  1680. case archive.ChangeAdd:
  1681. kind = "A"
  1682. case archive.ChangeDelete:
  1683. kind = "D"
  1684. }
  1685. fmt.Fprintf(cli.out, "%s %s\n", kind, change.Get("Path"))
  1686. }
  1687. return nil
  1688. }
  1689. func (cli *DockerCli) CmdLogs(args ...string) error {
  1690. var (
  1691. cmd = cli.Subcmd("logs", "CONTAINER", "Fetch the logs of a container", true)
  1692. follow = cmd.Bool([]string{"f", "-follow"}, false, "Follow log output")
  1693. times = cmd.Bool([]string{"t", "-timestamps"}, false, "Show timestamps")
  1694. tail = cmd.String([]string{"-tail"}, "all", "Number of lines to show from the end of the logs")
  1695. )
  1696. cmd.Require(flag.Exact, 1)
  1697. utils.ParseFlags(cmd, args, true)
  1698. name := cmd.Arg(0)
  1699. stream, _, err := cli.call("GET", "/containers/"+name+"/json", nil, false)
  1700. if err != nil {
  1701. return err
  1702. }
  1703. env := engine.Env{}
  1704. if err := env.Decode(stream); err != nil {
  1705. return err
  1706. }
  1707. v := url.Values{}
  1708. v.Set("stdout", "1")
  1709. v.Set("stderr", "1")
  1710. if *times {
  1711. v.Set("timestamps", "1")
  1712. }
  1713. if *follow {
  1714. v.Set("follow", "1")
  1715. }
  1716. v.Set("tail", *tail)
  1717. return cli.streamHelper("GET", "/containers/"+name+"/logs?"+v.Encode(), env.GetSubEnv("Config").GetBool("Tty"), nil, cli.out, cli.err, nil)
  1718. }
  1719. func (cli *DockerCli) CmdAttach(args ...string) error {
  1720. var (
  1721. cmd = cli.Subcmd("attach", "CONTAINER", "Attach to a running container", true)
  1722. noStdin = cmd.Bool([]string{"#nostdin", "-no-stdin"}, false, "Do not attach STDIN")
  1723. proxy = cmd.Bool([]string{"#sig-proxy", "-sig-proxy"}, true, "Proxy all received signals to the process")
  1724. )
  1725. cmd.Require(flag.Exact, 1)
  1726. utils.ParseFlags(cmd, args, true)
  1727. name := cmd.Arg(0)
  1728. stream, _, err := cli.call("GET", "/containers/"+name+"/json", nil, false)
  1729. if err != nil {
  1730. return err
  1731. }
  1732. env := engine.Env{}
  1733. if err := env.Decode(stream); err != nil {
  1734. return err
  1735. }
  1736. if !env.GetSubEnv("State").GetBool("Running") {
  1737. return fmt.Errorf("You cannot attach to a stopped container, start it first")
  1738. }
  1739. var (
  1740. config = env.GetSubEnv("Config")
  1741. tty = config.GetBool("Tty")
  1742. )
  1743. if err := cli.CheckTtyInput(!*noStdin, tty); err != nil {
  1744. return err
  1745. }
  1746. if tty && cli.isTerminalOut {
  1747. if err := cli.monitorTtySize(cmd.Arg(0), false); err != nil {
  1748. log.Debugf("Error monitoring TTY size: %s", err)
  1749. }
  1750. }
  1751. var in io.ReadCloser
  1752. v := url.Values{}
  1753. v.Set("stream", "1")
  1754. if !*noStdin && config.GetBool("OpenStdin") {
  1755. v.Set("stdin", "1")
  1756. in = cli.in
  1757. }
  1758. v.Set("stdout", "1")
  1759. v.Set("stderr", "1")
  1760. if *proxy && !tty {
  1761. sigc := cli.forwardAllSignals(cmd.Arg(0))
  1762. defer signal.StopCatch(sigc)
  1763. }
  1764. if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), tty, in, cli.out, cli.err, nil, nil); err != nil {
  1765. return err
  1766. }
  1767. _, status, err := getExitCode(cli, cmd.Arg(0))
  1768. if err != nil {
  1769. return err
  1770. }
  1771. if status != 0 {
  1772. return &utils.StatusError{StatusCode: status}
  1773. }
  1774. return nil
  1775. }
  1776. func (cli *DockerCli) CmdSearch(args ...string) error {
  1777. cmd := cli.Subcmd("search", "TERM", "Search the Docker Hub for images", true)
  1778. noTrunc := cmd.Bool([]string{"#notrunc", "-no-trunc"}, false, "Don't truncate output")
  1779. trusted := cmd.Bool([]string{"#t", "#trusted", "#-trusted"}, false, "Only show trusted builds")
  1780. automated := cmd.Bool([]string{"-automated"}, false, "Only show automated builds")
  1781. stars := cmd.Int([]string{"s", "#stars", "-stars"}, 0, "Only displays with at least x stars")
  1782. cmd.Require(flag.Exact, 1)
  1783. utils.ParseFlags(cmd, args, true)
  1784. v := url.Values{}
  1785. v.Set("term", cmd.Arg(0))
  1786. body, _, err := readBody(cli.call("GET", "/images/search?"+v.Encode(), nil, true))
  1787. if err != nil {
  1788. return err
  1789. }
  1790. outs := engine.NewTable("star_count", 0)
  1791. if _, err := outs.ReadListFrom(body); err != nil {
  1792. return err
  1793. }
  1794. w := tabwriter.NewWriter(cli.out, 10, 1, 3, ' ', 0)
  1795. fmt.Fprintf(w, "NAME\tDESCRIPTION\tSTARS\tOFFICIAL\tAUTOMATED\n")
  1796. for _, out := range outs.Data {
  1797. if ((*automated || *trusted) && (!out.GetBool("is_trusted") && !out.GetBool("is_automated"))) || (*stars > out.GetInt("star_count")) {
  1798. continue
  1799. }
  1800. desc := strings.Replace(out.Get("description"), "\n", " ", -1)
  1801. desc = strings.Replace(desc, "\r", " ", -1)
  1802. if !*noTrunc && len(desc) > 45 {
  1803. desc = utils.Trunc(desc, 42) + "..."
  1804. }
  1805. fmt.Fprintf(w, "%s\t%s\t%d\t", out.Get("name"), desc, out.GetInt("star_count"))
  1806. if out.GetBool("is_official") {
  1807. fmt.Fprint(w, "[OK]")
  1808. }
  1809. fmt.Fprint(w, "\t")
  1810. if out.GetBool("is_automated") || out.GetBool("is_trusted") {
  1811. fmt.Fprint(w, "[OK]")
  1812. }
  1813. fmt.Fprint(w, "\n")
  1814. }
  1815. w.Flush()
  1816. return nil
  1817. }
  1818. // Ports type - Used to parse multiple -p flags
  1819. type ports []int
  1820. func (cli *DockerCli) CmdTag(args ...string) error {
  1821. cmd := cli.Subcmd("tag", "IMAGE[:TAG] [REGISTRYHOST/][USERNAME/]NAME[:TAG]", "Tag an image into a repository", true)
  1822. force := cmd.Bool([]string{"f", "#force", "-force"}, false, "Force")
  1823. cmd.Require(flag.Exact, 2)
  1824. utils.ParseFlags(cmd, args, true)
  1825. var (
  1826. repository, tag = parsers.ParseRepositoryTag(cmd.Arg(1))
  1827. v = url.Values{}
  1828. )
  1829. //Check if the given image name can be resolved
  1830. if err := registry.ValidateRepositoryName(repository); err != nil {
  1831. return err
  1832. }
  1833. v.Set("repo", repository)
  1834. v.Set("tag", tag)
  1835. if *force {
  1836. v.Set("force", "1")
  1837. }
  1838. if _, _, err := readBody(cli.call("POST", "/images/"+cmd.Arg(0)+"/tag?"+v.Encode(), nil, false)); err != nil {
  1839. return err
  1840. }
  1841. return nil
  1842. }
  1843. func (cli *DockerCli) pullImage(image string) error {
  1844. return cli.pullImageCustomOut(image, cli.out)
  1845. }
  1846. func (cli *DockerCli) pullImageCustomOut(image string, out io.Writer) error {
  1847. v := url.Values{}
  1848. repos, tag := parsers.ParseRepositoryTag(image)
  1849. // pull only the image tagged 'latest' if no tag was specified
  1850. if tag == "" {
  1851. tag = graph.DEFAULTTAG
  1852. }
  1853. v.Set("fromImage", repos)
  1854. v.Set("tag", tag)
  1855. // Resolve the Repository name from fqn to RepositoryInfo
  1856. repoInfo, err := registry.ParseRepositoryInfo(repos)
  1857. if err != nil {
  1858. return err
  1859. }
  1860. // Load the auth config file, to be able to pull the image
  1861. cli.LoadConfigFile()
  1862. // Resolve the Auth config relevant for this server
  1863. authConfig := cli.configFile.ResolveAuthConfig(repoInfo.Index)
  1864. buf, err := json.Marshal(authConfig)
  1865. if err != nil {
  1866. return err
  1867. }
  1868. registryAuthHeader := []string{
  1869. base64.URLEncoding.EncodeToString(buf),
  1870. }
  1871. if err = cli.stream("POST", "/images/create?"+v.Encode(), nil, out, map[string][]string{"X-Registry-Auth": registryAuthHeader}); err != nil {
  1872. return err
  1873. }
  1874. return nil
  1875. }
  1876. type cidFile struct {
  1877. path string
  1878. file *os.File
  1879. written bool
  1880. }
  1881. func newCIDFile(path string) (*cidFile, error) {
  1882. if _, err := os.Stat(path); err == nil {
  1883. return nil, fmt.Errorf("Container ID file found, make sure the other container isn't running or delete %s", path)
  1884. }
  1885. f, err := os.Create(path)
  1886. if err != nil {
  1887. return nil, fmt.Errorf("Failed to create the container ID file: %s", err)
  1888. }
  1889. return &cidFile{path: path, file: f}, nil
  1890. }
  1891. func (cid *cidFile) Close() error {
  1892. cid.file.Close()
  1893. if !cid.written {
  1894. if err := os.Remove(cid.path); err != nil {
  1895. return fmt.Errorf("failed to remove the CID file '%s': %s \n", cid.path, err)
  1896. }
  1897. }
  1898. return nil
  1899. }
  1900. func (cid *cidFile) Write(id string) error {
  1901. if _, err := cid.file.Write([]byte(id)); err != nil {
  1902. return fmt.Errorf("Failed to write the container ID to the file: %s", err)
  1903. }
  1904. cid.written = true
  1905. return nil
  1906. }
  1907. func (cli *DockerCli) createContainer(config *runconfig.Config, hostConfig *runconfig.HostConfig, cidfile, name string) (*types.ContainerCreateResponse, error) {
  1908. containerValues := url.Values{}
  1909. if name != "" {
  1910. containerValues.Set("name", name)
  1911. }
  1912. mergedConfig := runconfig.MergeConfigs(config, hostConfig)
  1913. var containerIDFile *cidFile
  1914. if cidfile != "" {
  1915. var err error
  1916. if containerIDFile, err = newCIDFile(cidfile); err != nil {
  1917. return nil, err
  1918. }
  1919. defer containerIDFile.Close()
  1920. }
  1921. //create the container
  1922. stream, statusCode, err := cli.call("POST", "/containers/create?"+containerValues.Encode(), mergedConfig, false)
  1923. //if image not found try to pull it
  1924. if statusCode == 404 {
  1925. repo, tag := parsers.ParseRepositoryTag(config.Image)
  1926. if tag == "" {
  1927. tag = graph.DEFAULTTAG
  1928. }
  1929. fmt.Fprintf(cli.err, "Unable to find image '%s' locally\n", utils.ImageReference(repo, tag))
  1930. // we don't want to write to stdout anything apart from container.ID
  1931. if err = cli.pullImageCustomOut(config.Image, cli.err); err != nil {
  1932. return nil, err
  1933. }
  1934. // Retry
  1935. if stream, _, err = cli.call("POST", "/containers/create?"+containerValues.Encode(), mergedConfig, false); err != nil {
  1936. return nil, err
  1937. }
  1938. } else if err != nil {
  1939. return nil, err
  1940. }
  1941. var response types.ContainerCreateResponse
  1942. if err := json.NewDecoder(stream).Decode(&response); err != nil {
  1943. return nil, err
  1944. }
  1945. for _, warning := range response.Warnings {
  1946. fmt.Fprintf(cli.err, "WARNING: %s\n", warning)
  1947. }
  1948. if containerIDFile != nil {
  1949. if err = containerIDFile.Write(response.ID); err != nil {
  1950. return nil, err
  1951. }
  1952. }
  1953. return &response, nil
  1954. }
  1955. func (cli *DockerCli) CmdCreate(args ...string) error {
  1956. cmd := cli.Subcmd("create", "IMAGE [COMMAND] [ARG...]", "Create a new container", true)
  1957. // These are flags not stored in Config/HostConfig
  1958. var (
  1959. flName = cmd.String([]string{"-name"}, "", "Assign a name to the container")
  1960. )
  1961. config, hostConfig, cmd, err := runconfig.Parse(cmd, args)
  1962. if err != nil {
  1963. utils.ReportError(cmd, err.Error(), true)
  1964. }
  1965. if config.Image == "" {
  1966. cmd.Usage()
  1967. return nil
  1968. }
  1969. response, err := cli.createContainer(config, hostConfig, hostConfig.ContainerIDFile, *flName)
  1970. if err != nil {
  1971. return err
  1972. }
  1973. fmt.Fprintf(cli.out, "%s\n", response.ID)
  1974. return nil
  1975. }
  1976. func (cli *DockerCli) CmdRun(args ...string) error {
  1977. // FIXME: just use runconfig.Parse already
  1978. cmd := cli.Subcmd("run", "IMAGE [COMMAND] [ARG...]", "Run a command in a new container", true)
  1979. // These are flags not stored in Config/HostConfig
  1980. var (
  1981. flAutoRemove = cmd.Bool([]string{"#rm", "-rm"}, false, "Automatically remove the container when it exits")
  1982. flDetach = cmd.Bool([]string{"d", "-detach"}, false, "Run container in background and print container ID")
  1983. flSigProxy = cmd.Bool([]string{"#sig-proxy", "-sig-proxy"}, true, "Proxy received signals to the process")
  1984. flName = cmd.String([]string{"#name", "-name"}, "", "Assign a name to the container")
  1985. flAttach *opts.ListOpts
  1986. ErrConflictAttachDetach = fmt.Errorf("Conflicting options: -a and -d")
  1987. ErrConflictRestartPolicyAndAutoRemove = fmt.Errorf("Conflicting options: --restart and --rm")
  1988. ErrConflictDetachAutoRemove = fmt.Errorf("Conflicting options: --rm and -d")
  1989. )
  1990. config, hostConfig, cmd, err := runconfig.Parse(cmd, args)
  1991. // just in case the Parse does not exit
  1992. if err != nil {
  1993. utils.ReportError(cmd, err.Error(), true)
  1994. }
  1995. if len(hostConfig.Dns) > 0 {
  1996. // check the DNS settings passed via --dns against
  1997. // localhost regexp to warn if they are trying to
  1998. // set a DNS to a localhost address
  1999. for _, dnsIP := range hostConfig.Dns {
  2000. if resolvconf.IsLocalhost(dnsIP) {
  2001. fmt.Fprintf(cli.err, "WARNING: Localhost DNS setting (--dns=%s) may fail in containers.\n", dnsIP)
  2002. break
  2003. }
  2004. }
  2005. }
  2006. if config.Image == "" {
  2007. cmd.Usage()
  2008. return nil
  2009. }
  2010. if !*flDetach {
  2011. if err := cli.CheckTtyInput(config.AttachStdin, config.Tty); err != nil {
  2012. return err
  2013. }
  2014. } else {
  2015. if fl := cmd.Lookup("-attach"); fl != nil {
  2016. flAttach = fl.Value.(*opts.ListOpts)
  2017. if flAttach.Len() != 0 {
  2018. return ErrConflictAttachDetach
  2019. }
  2020. }
  2021. if *flAutoRemove {
  2022. return ErrConflictDetachAutoRemove
  2023. }
  2024. config.AttachStdin = false
  2025. config.AttachStdout = false
  2026. config.AttachStderr = false
  2027. config.StdinOnce = false
  2028. }
  2029. // Disable flSigProxy when in TTY mode
  2030. sigProxy := *flSigProxy
  2031. if config.Tty {
  2032. sigProxy = false
  2033. }
  2034. createResponse, err := cli.createContainer(config, hostConfig, hostConfig.ContainerIDFile, *flName)
  2035. if err != nil {
  2036. return err
  2037. }
  2038. if sigProxy {
  2039. sigc := cli.forwardAllSignals(createResponse.ID)
  2040. defer signal.StopCatch(sigc)
  2041. }
  2042. var (
  2043. waitDisplayId chan struct{}
  2044. errCh chan error
  2045. )
  2046. if !config.AttachStdout && !config.AttachStderr {
  2047. // Make this asynchronous to allow the client to write to stdin before having to read the ID
  2048. waitDisplayId = make(chan struct{})
  2049. go func() {
  2050. defer close(waitDisplayId)
  2051. fmt.Fprintf(cli.out, "%s\n", createResponse.ID)
  2052. }()
  2053. }
  2054. if *flAutoRemove && (hostConfig.RestartPolicy.Name == "always" || hostConfig.RestartPolicy.Name == "on-failure") {
  2055. return ErrConflictRestartPolicyAndAutoRemove
  2056. }
  2057. // We need to instantiate the chan because the select needs it. It can
  2058. // be closed but can't be uninitialized.
  2059. hijacked := make(chan io.Closer)
  2060. // Block the return until the chan gets closed
  2061. defer func() {
  2062. log.Debugf("End of CmdRun(), Waiting for hijack to finish.")
  2063. if _, ok := <-hijacked; ok {
  2064. log.Errorf("Hijack did not finish (chan still open)")
  2065. }
  2066. }()
  2067. if config.AttachStdin || config.AttachStdout || config.AttachStderr {
  2068. var (
  2069. out, stderr io.Writer
  2070. in io.ReadCloser
  2071. v = url.Values{}
  2072. )
  2073. v.Set("stream", "1")
  2074. if config.AttachStdin {
  2075. v.Set("stdin", "1")
  2076. in = cli.in
  2077. }
  2078. if config.AttachStdout {
  2079. v.Set("stdout", "1")
  2080. out = cli.out
  2081. }
  2082. if config.AttachStderr {
  2083. v.Set("stderr", "1")
  2084. if config.Tty {
  2085. stderr = cli.out
  2086. } else {
  2087. stderr = cli.err
  2088. }
  2089. }
  2090. errCh = promise.Go(func() error {
  2091. return cli.hijack("POST", "/containers/"+createResponse.ID+"/attach?"+v.Encode(), config.Tty, in, out, stderr, hijacked, nil)
  2092. })
  2093. } else {
  2094. close(hijacked)
  2095. }
  2096. // Acknowledge the hijack before starting
  2097. select {
  2098. case closer := <-hijacked:
  2099. // Make sure that the hijack gets closed when returning (results
  2100. // in closing the hijack chan and freeing server's goroutines)
  2101. if closer != nil {
  2102. defer closer.Close()
  2103. }
  2104. case err := <-errCh:
  2105. if err != nil {
  2106. log.Debugf("Error hijack: %s", err)
  2107. return err
  2108. }
  2109. }
  2110. //start the container
  2111. if _, _, err = readBody(cli.call("POST", "/containers/"+createResponse.ID+"/start", nil, false)); err != nil {
  2112. return err
  2113. }
  2114. if (config.AttachStdin || config.AttachStdout || config.AttachStderr) && config.Tty && cli.isTerminalOut {
  2115. if err := cli.monitorTtySize(createResponse.ID, false); err != nil {
  2116. log.Errorf("Error monitoring TTY size: %s", err)
  2117. }
  2118. }
  2119. if errCh != nil {
  2120. if err := <-errCh; err != nil {
  2121. log.Debugf("Error hijack: %s", err)
  2122. return err
  2123. }
  2124. }
  2125. // Detached mode: wait for the id to be displayed and return.
  2126. if !config.AttachStdout && !config.AttachStderr {
  2127. // Detached mode
  2128. <-waitDisplayId
  2129. return nil
  2130. }
  2131. var status int
  2132. // Attached mode
  2133. if *flAutoRemove {
  2134. // Autoremove: wait for the container to finish, retrieve
  2135. // the exit code and remove the container
  2136. if _, _, err := readBody(cli.call("POST", "/containers/"+createResponse.ID+"/wait", nil, false)); err != nil {
  2137. return err
  2138. }
  2139. if _, status, err = getExitCode(cli, createResponse.ID); err != nil {
  2140. return err
  2141. }
  2142. if _, _, err := readBody(cli.call("DELETE", "/containers/"+createResponse.ID+"?v=1", nil, false)); err != nil {
  2143. return err
  2144. }
  2145. } else {
  2146. // No Autoremove: Simply retrieve the exit code
  2147. if !config.Tty {
  2148. // In non-TTY mode, we can't detach, so we must wait for container exit
  2149. if status, err = waitForExit(cli, createResponse.ID); err != nil {
  2150. return err
  2151. }
  2152. } else {
  2153. // In TTY mode, there is a race: if the process dies too slowly, the state could
  2154. // be updated after the getExitCode call and result in the wrong exit code being reported
  2155. if _, status, err = getExitCode(cli, createResponse.ID); err != nil {
  2156. return err
  2157. }
  2158. }
  2159. }
  2160. if status != 0 {
  2161. return &utils.StatusError{StatusCode: status}
  2162. }
  2163. return nil
  2164. }
  2165. func (cli *DockerCli) CmdCp(args ...string) error {
  2166. cmd := cli.Subcmd("cp", "CONTAINER:PATH HOSTPATH|-", "Copy files/folders from the PATH to the HOSTPATH. Use '-' to write the data\nas a tar file to STDOUT.", true)
  2167. cmd.Require(flag.Exact, 2)
  2168. utils.ParseFlags(cmd, args, true)
  2169. var copyData engine.Env
  2170. info := strings.Split(cmd.Arg(0), ":")
  2171. if len(info) != 2 {
  2172. return fmt.Errorf("Error: Path not specified")
  2173. }
  2174. copyData.Set("Resource", info[1])
  2175. copyData.Set("HostPath", cmd.Arg(1))
  2176. stream, statusCode, err := cli.call("POST", "/containers/"+info[0]+"/copy", copyData, false)
  2177. if stream != nil {
  2178. defer stream.Close()
  2179. }
  2180. if statusCode == 404 {
  2181. return fmt.Errorf("No such container: %v", info[0])
  2182. }
  2183. if err != nil {
  2184. return err
  2185. }
  2186. if statusCode == 200 {
  2187. dest := copyData.Get("HostPath")
  2188. if dest == "-" {
  2189. _, err = io.Copy(cli.out, stream)
  2190. } else {
  2191. err = archive.Untar(stream, dest, &archive.TarOptions{NoLchown: true})
  2192. }
  2193. if err != nil {
  2194. return err
  2195. }
  2196. }
  2197. return nil
  2198. }
  2199. func (cli *DockerCli) CmdSave(args ...string) error {
  2200. cmd := cli.Subcmd("save", "IMAGE [IMAGE...]", "Save an image(s) to a tar archive (streamed to STDOUT by default)", true)
  2201. outfile := cmd.String([]string{"o", "-output"}, "", "Write to an file, instead of STDOUT")
  2202. cmd.Require(flag.Min, 1)
  2203. utils.ParseFlags(cmd, args, true)
  2204. var (
  2205. output io.Writer = cli.out
  2206. err error
  2207. )
  2208. if *outfile != "" {
  2209. output, err = os.Create(*outfile)
  2210. if err != nil {
  2211. return err
  2212. }
  2213. } else if cli.isTerminalOut {
  2214. return errors.New("Cowardly refusing to save to a terminal. Use the -o flag or redirect.")
  2215. }
  2216. if len(cmd.Args()) == 1 {
  2217. image := cmd.Arg(0)
  2218. if err := cli.stream("GET", "/images/"+image+"/get", nil, output, nil); err != nil {
  2219. return err
  2220. }
  2221. } else {
  2222. v := url.Values{}
  2223. for _, arg := range cmd.Args() {
  2224. v.Add("names", arg)
  2225. }
  2226. if err := cli.stream("GET", "/images/get?"+v.Encode(), nil, output, nil); err != nil {
  2227. return err
  2228. }
  2229. }
  2230. return nil
  2231. }
  2232. func (cli *DockerCli) CmdLoad(args ...string) error {
  2233. cmd := cli.Subcmd("load", "", "Load an image from a tar archive on STDIN", true)
  2234. infile := cmd.String([]string{"i", "-input"}, "", "Read from a tar archive file, instead of STDIN")
  2235. cmd.Require(flag.Exact, 0)
  2236. utils.ParseFlags(cmd, args, true)
  2237. var (
  2238. input io.Reader = cli.in
  2239. err error
  2240. )
  2241. if *infile != "" {
  2242. input, err = os.Open(*infile)
  2243. if err != nil {
  2244. return err
  2245. }
  2246. }
  2247. if err := cli.stream("POST", "/images/load", input, cli.out, nil); err != nil {
  2248. return err
  2249. }
  2250. return nil
  2251. }
  2252. func (cli *DockerCli) CmdExec(args ...string) error {
  2253. cmd := cli.Subcmd("exec", "CONTAINER COMMAND [ARG...]", "Run a command in a running container", true)
  2254. execConfig, err := runconfig.ParseExec(cmd, args)
  2255. // just in case the ParseExec does not exit
  2256. if execConfig.Container == "" || err != nil {
  2257. return &utils.StatusError{StatusCode: 1}
  2258. }
  2259. stream, _, err := cli.call("POST", "/containers/"+execConfig.Container+"/exec", execConfig, false)
  2260. if err != nil {
  2261. return err
  2262. }
  2263. var execResult engine.Env
  2264. if err := execResult.Decode(stream); err != nil {
  2265. return err
  2266. }
  2267. execID := execResult.Get("Id")
  2268. if execID == "" {
  2269. fmt.Fprintf(cli.out, "exec ID empty")
  2270. return nil
  2271. }
  2272. if !execConfig.Detach {
  2273. if err := cli.CheckTtyInput(execConfig.AttachStdin, execConfig.Tty); err != nil {
  2274. return err
  2275. }
  2276. } else {
  2277. if _, _, err := readBody(cli.call("POST", "/exec/"+execID+"/start", execConfig, false)); err != nil {
  2278. return err
  2279. }
  2280. // For now don't print this - wait for when we support exec wait()
  2281. // fmt.Fprintf(cli.out, "%s\n", execID)
  2282. return nil
  2283. }
  2284. // Interactive exec requested.
  2285. var (
  2286. out, stderr io.Writer
  2287. in io.ReadCloser
  2288. hijacked = make(chan io.Closer)
  2289. errCh chan error
  2290. )
  2291. // Block the return until the chan gets closed
  2292. defer func() {
  2293. log.Debugf("End of CmdExec(), Waiting for hijack to finish.")
  2294. if _, ok := <-hijacked; ok {
  2295. log.Errorf("Hijack did not finish (chan still open)")
  2296. }
  2297. }()
  2298. if execConfig.AttachStdin {
  2299. in = cli.in
  2300. }
  2301. if execConfig.AttachStdout {
  2302. out = cli.out
  2303. }
  2304. if execConfig.AttachStderr {
  2305. if execConfig.Tty {
  2306. stderr = cli.out
  2307. } else {
  2308. stderr = cli.err
  2309. }
  2310. }
  2311. errCh = promise.Go(func() error {
  2312. return cli.hijack("POST", "/exec/"+execID+"/start", execConfig.Tty, in, out, stderr, hijacked, execConfig)
  2313. })
  2314. // Acknowledge the hijack before starting
  2315. select {
  2316. case closer := <-hijacked:
  2317. // Make sure that hijack gets closed when returning. (result
  2318. // in closing hijack chan and freeing server's goroutines.
  2319. if closer != nil {
  2320. defer closer.Close()
  2321. }
  2322. case err := <-errCh:
  2323. if err != nil {
  2324. log.Debugf("Error hijack: %s", err)
  2325. return err
  2326. }
  2327. }
  2328. if execConfig.Tty && cli.isTerminalIn {
  2329. if err := cli.monitorTtySize(execID, true); err != nil {
  2330. log.Errorf("Error monitoring TTY size: %s", err)
  2331. }
  2332. }
  2333. if err := <-errCh; err != nil {
  2334. log.Debugf("Error hijack: %s", err)
  2335. return err
  2336. }
  2337. var status int
  2338. if _, status, err = getExecExitCode(cli, execID); err != nil {
  2339. return err
  2340. }
  2341. if status != 0 {
  2342. return &utils.StatusError{StatusCode: status}
  2343. }
  2344. return nil
  2345. }
  2346. type containerStats struct {
  2347. Name string
  2348. CpuPercentage float64
  2349. Memory float64
  2350. MemoryLimit float64
  2351. MemoryPercentage float64
  2352. NetworkRx float64
  2353. NetworkTx float64
  2354. mu sync.RWMutex
  2355. err error
  2356. }
  2357. func (s *containerStats) Collect(cli *DockerCli) {
  2358. stream, _, err := cli.call("GET", "/containers/"+s.Name+"/stats", nil, false)
  2359. if err != nil {
  2360. s.err = err
  2361. return
  2362. }
  2363. defer stream.Close()
  2364. var (
  2365. previousCpu uint64
  2366. previousSystem uint64
  2367. start = true
  2368. dec = json.NewDecoder(stream)
  2369. u = make(chan error, 1)
  2370. )
  2371. go func() {
  2372. for {
  2373. var v *types.Stats
  2374. if err := dec.Decode(&v); err != nil {
  2375. u <- err
  2376. return
  2377. }
  2378. var (
  2379. memPercent = float64(v.MemoryStats.Usage) / float64(v.MemoryStats.Limit) * 100.0
  2380. cpuPercent = 0.0
  2381. )
  2382. if !start {
  2383. cpuPercent = calculateCpuPercent(previousCpu, previousSystem, v)
  2384. }
  2385. start = false
  2386. s.mu.Lock()
  2387. s.CpuPercentage = cpuPercent
  2388. s.Memory = float64(v.MemoryStats.Usage)
  2389. s.MemoryLimit = float64(v.MemoryStats.Limit)
  2390. s.MemoryPercentage = memPercent
  2391. s.NetworkRx = float64(v.Network.RxBytes)
  2392. s.NetworkTx = float64(v.Network.TxBytes)
  2393. s.mu.Unlock()
  2394. previousCpu = v.CpuStats.CpuUsage.TotalUsage
  2395. previousSystem = v.CpuStats.SystemUsage
  2396. u <- nil
  2397. }
  2398. }()
  2399. for {
  2400. select {
  2401. case <-time.After(2 * time.Second):
  2402. // zero out the values if we have not received an update within
  2403. // the specified duration.
  2404. s.mu.Lock()
  2405. s.CpuPercentage = 0
  2406. s.Memory = 0
  2407. s.MemoryPercentage = 0
  2408. s.mu.Unlock()
  2409. case err := <-u:
  2410. if err != nil {
  2411. s.mu.Lock()
  2412. s.err = err
  2413. s.mu.Unlock()
  2414. return
  2415. }
  2416. }
  2417. }
  2418. }
  2419. func (s *containerStats) Display(w io.Writer) error {
  2420. s.mu.RLock()
  2421. defer s.mu.RUnlock()
  2422. if s.err != nil {
  2423. return s.err
  2424. }
  2425. fmt.Fprintf(w, "%s\t%.2f%%\t%s/%s\t%.2f%%\t%s/%s\n",
  2426. s.Name,
  2427. s.CpuPercentage,
  2428. units.BytesSize(s.Memory), units.BytesSize(s.MemoryLimit),
  2429. s.MemoryPercentage,
  2430. units.BytesSize(s.NetworkRx), units.BytesSize(s.NetworkTx))
  2431. return nil
  2432. }
  2433. func (cli *DockerCli) CmdStats(args ...string) error {
  2434. cmd := cli.Subcmd("stats", "CONTAINER [CONTAINER...]", "Display a live stream of one or more containers' resource usage statistics", true)
  2435. cmd.Require(flag.Min, 1)
  2436. utils.ParseFlags(cmd, args, true)
  2437. names := cmd.Args()
  2438. sort.Strings(names)
  2439. var (
  2440. cStats []*containerStats
  2441. w = tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
  2442. )
  2443. printHeader := func() {
  2444. fmt.Fprint(cli.out, "\033[2J")
  2445. fmt.Fprint(cli.out, "\033[H")
  2446. fmt.Fprintln(w, "CONTAINER\tCPU %\tMEM USAGE/LIMIT\tMEM %\tNET I/O")
  2447. }
  2448. for _, n := range names {
  2449. s := &containerStats{Name: n}
  2450. cStats = append(cStats, s)
  2451. go s.Collect(cli)
  2452. }
  2453. // do a quick pause so that any failed connections for containers that do not exist are able to be
  2454. // evicted before we display the initial or default values.
  2455. time.Sleep(500 * time.Millisecond)
  2456. var errs []string
  2457. for _, c := range cStats {
  2458. c.mu.Lock()
  2459. if c.err != nil {
  2460. errs = append(errs, fmt.Sprintf("%s: %v", c.Name, c.err))
  2461. }
  2462. c.mu.Unlock()
  2463. }
  2464. if len(errs) > 0 {
  2465. return fmt.Errorf("%s", strings.Join(errs, ", "))
  2466. }
  2467. for _ = range time.Tick(500 * time.Millisecond) {
  2468. printHeader()
  2469. toRemove := []int{}
  2470. for i, s := range cStats {
  2471. if err := s.Display(w); err != nil {
  2472. toRemove = append(toRemove, i)
  2473. }
  2474. }
  2475. for j := len(toRemove) - 1; j >= 0; j-- {
  2476. i := toRemove[j]
  2477. cStats = append(cStats[:i], cStats[i+1:]...)
  2478. }
  2479. if len(cStats) == 0 {
  2480. return nil
  2481. }
  2482. w.Flush()
  2483. }
  2484. return nil
  2485. }
  2486. func calculateCpuPercent(previousCpu, previousSystem uint64, v *types.Stats) float64 {
  2487. var (
  2488. cpuPercent = 0.0
  2489. // calculate the change for the cpu usage of the container in between readings
  2490. cpuDelta = float64(v.CpuStats.CpuUsage.TotalUsage - previousCpu)
  2491. // calculate the change for the entire system between readings
  2492. systemDelta = float64(v.CpuStats.SystemUsage - previousSystem)
  2493. )
  2494. if systemDelta > 0.0 && cpuDelta > 0.0 {
  2495. cpuPercent = (cpuDelta / systemDelta) * float64(len(v.CpuStats.CpuUsage.PercpuUsage)) * 100.0
  2496. }
  2497. return cpuPercent
  2498. }