2013-03-14 09:26:46 +00:00
package docker
2013-02-14 01:10:00 +00:00
import (
2013-06-15 16:38:18 +00:00
"archive/tar"
2013-02-14 01:28:13 +00:00
"bytes"
"encoding/json"
2013-04-22 16:17:47 +00:00
"flag"
2013-02-14 01:10:00 +00:00
"fmt"
2013-03-15 00:43:59 +00:00
"github.com/dotcloud/docker/auth"
2013-04-29 13:12:18 +00:00
"github.com/dotcloud/docker/term"
2013-05-14 22:37:35 +00:00
"github.com/dotcloud/docker/utils"
2013-02-14 01:28:13 +00:00
"io"
2013-04-22 16:17:47 +00:00
"io/ioutil"
2013-04-23 16:20:53 +00:00
"net"
2013-03-13 18:33:48 +00:00
"net/http"
2013-04-23 16:20:53 +00:00
"net/http/httputil"
2013-03-14 01:37:00 +00:00
"net/url"
2013-05-08 22:26:44 +00:00
"os"
2013-05-24 18:07:32 +00:00
"os/signal"
2013-04-06 01:00:10 +00:00
"path/filepath"
2013-05-13 09:48:27 +00:00
"reflect"
2013-02-28 19:52:22 +00:00
"strconv"
2013-02-14 01:28:13 +00:00
"strings"
2013-05-24 18:07:32 +00:00
"syscall"
2013-02-14 01:28:13 +00:00
"text/tabwriter"
"time"
2013-03-28 19:11:47 +00:00
"unicode"
2013-02-14 01:10:00 +00:00
)
2013-07-01 23:57:58 +00:00
const VERSION = "0.4.8"
2013-02-14 01:10:00 +00:00
2013-04-11 19:58:23 +00:00
var (
2013-06-04 18:00:22 +00:00
GITCOMMIT string
2013-04-11 19:58:23 +00:00
)
2013-04-01 18:12:56 +00:00
2013-05-23 16:32:39 +00:00
func ( cli * DockerCli ) getMethod ( name string ) ( reflect . Method , bool ) {
methodName := "Cmd" + strings . ToUpper ( name [ : 1 ] ) + strings . ToLower ( name [ 1 : ] )
return reflect . TypeOf ( cli ) . MethodByName ( methodName )
}
2013-06-18 18:59:56 +00:00
func ParseCommands ( proto , addr string , args ... string ) error {
2013-06-24 21:15:52 +00:00
cli := NewDockerCli ( os . Stdin , os . Stdout , os . Stderr , proto , addr )
2013-04-22 16:17:47 +00:00
if len ( args ) > 0 {
2013-05-23 16:32:39 +00:00
method , exists := cli . getMethod ( args [ 0 ] )
2013-04-22 16:17:47 +00:00
if ! exists {
2013-04-23 16:20:53 +00:00
fmt . Println ( "Error: Command not found:" , args [ 0 ] )
2013-05-23 16:32:39 +00:00
return cli . CmdHelp ( args [ 1 : ] ... )
2013-04-22 16:17:47 +00:00
}
2013-05-13 09:48:27 +00:00
ret := method . Func . CallSlice ( [ ] reflect . Value {
reflect . ValueOf ( cli ) ,
2013-05-15 14:16:46 +00:00
reflect . ValueOf ( args [ 1 : ] ) ,
2013-05-13 09:48:27 +00:00
} ) [ 0 ] . Interface ( )
if ret == nil {
return nil
2013-04-22 16:17:47 +00:00
}
2013-05-13 09:48:27 +00:00
return ret . ( error )
2013-04-22 16:17:47 +00:00
}
2013-05-13 09:48:27 +00:00
return cli . CmdHelp ( args ... )
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdHelp ( args ... string ) error {
2013-05-23 16:32:39 +00:00
if len ( args ) > 0 {
method , exists := cli . getMethod ( args [ 0 ] )
if ! exists {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "Error: Command not found: %s\n" , args [ 0 ] )
2013-05-23 16:32:39 +00:00
} else {
method . Func . CallSlice ( [ ] reflect . Value {
reflect . ValueOf ( cli ) ,
reflect . ValueOf ( [ ] string { "--help" } ) ,
} ) [ 0 ] . Interface ( )
return nil
}
}
2013-07-09 10:55:28 +00:00
help := fmt . Sprintf ( " Usage : docker [ OPTIONS ] COMMAND [ arg ... ] \ n - H = [ tcp : //%s:%d]: tcp://host:port to bind/connect to or unix://path/to/socket to use\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n", DEFAULTHTTPHOST, DEFAULTHTTPPORT)
2013-06-24 21:15:52 +00:00
for _ , command := range [ ] [ ] string {
2013-05-30 14:08:26 +00:00
{ "attach" , "Attach to a running container" } ,
{ "build" , "Build a container from a Dockerfile" } ,
{ "commit" , "Create a new image from a container's changes" } ,
{ "diff" , "Inspect changes on a container's filesystem" } ,
{ "export" , "Stream the contents of a container as a tar archive" } ,
{ "history" , "Show the history of an image" } ,
{ "images" , "List images" } ,
{ "import" , "Create a new filesystem image from the contents of a tarball" } ,
{ "info" , "Display system-wide information" } ,
{ "insert" , "Insert a file in an image" } ,
{ "inspect" , "Return low-level information on a container" } ,
{ "kill" , "Kill a running container" } ,
{ "login" , "Register or Login to the docker registry server" } ,
{ "logs" , "Fetch the logs of a container" } ,
{ "port" , "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT" } ,
{ "ps" , "List containers" } ,
{ "pull" , "Pull an image or a repository from the docker registry server" } ,
{ "push" , "Push an image or a repository to the docker registry server" } ,
{ "restart" , "Restart a running container" } ,
{ "rm" , "Remove a container" } ,
{ "rmi" , "Remove an image" } ,
{ "run" , "Run a command in a new container" } ,
{ "search" , "Search for an image in the docker index" } ,
{ "start" , "Start a stopped container" } ,
{ "stop" , "Stop a running container" } ,
{ "tag" , "Tag an image into a repository" } ,
{ "version" , "Show the docker version information" } ,
2013-06-02 21:40:56 +00:00
{ "wait" , "Block until a container stops, then print its exit code" } ,
2013-02-14 01:10:00 +00:00
} {
2013-05-30 14:08:26 +00:00
help += fmt . Sprintf ( " %-10.10s%s\n" , command [ 0 ] , command [ 1 ] )
2013-02-14 01:10:00 +00:00
}
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s\n" , help )
2013-04-22 16:17:47 +00:00
return nil
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdInsert ( args ... string ) error {
2013-05-07 17:23:50 +00:00
cmd := Subcmd ( "insert" , "IMAGE URL PATH" , "Insert a file from URL in the IMAGE at PATH" )
2013-04-24 20:37:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 3 {
cmd . Usage ( )
return nil
}
2013-05-07 17:23:50 +00:00
v := url . Values { }
v . Set ( "url" , cmd . Arg ( 1 ) )
v . Set ( "path" , cmd . Arg ( 2 ) )
2013-04-24 22:14:10 +00:00
2013-06-24 21:15:52 +00:00
if err := cli . stream ( "POST" , "/images/" + cmd . Arg ( 0 ) + "/insert?" + v . Encode ( ) , nil , cli . out ) ; err != nil {
2013-04-24 20:37:00 +00:00
return err
}
return nil
}
2013-06-15 16:38:18 +00:00
// mkBuildContext returns an archive of an empty context with the contents
// of `dockerfile` at the path ./Dockerfile
2013-06-15 18:07:49 +00:00
func mkBuildContext ( dockerfile string , files [ ] [ 2 ] string ) ( Archive , error ) {
2013-06-15 16:38:18 +00:00
buf := new ( bytes . Buffer )
tw := tar . NewWriter ( buf )
2013-06-15 18:07:49 +00:00
files = append ( files , [ 2 ] string { "Dockerfile" , dockerfile } )
for _ , file := range files {
name , content := file [ 0 ] , file [ 1 ]
hdr := & tar . Header {
Name : name ,
Size : int64 ( len ( content ) ) ,
}
if err := tw . WriteHeader ( hdr ) ; err != nil {
return nil , err
}
if _ , err := tw . Write ( [ ] byte ( content ) ) ; err != nil {
return nil , err
}
2013-06-15 16:38:18 +00:00
}
if err := tw . Close ( ) ; err != nil {
return nil , err
}
return buf , nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdBuild ( args ... string ) error {
2013-06-13 17:50:55 +00:00
cmd := Subcmd ( "build" , "[OPTIONS] PATH | URL | -" , "Build a new container image from the source code at PATH" )
2013-05-30 19:35:19 +00:00
tag := cmd . String ( "t" , "" , "Tag to be applied to the resulting image in case of success" )
2013-04-24 18:03:01 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-05-30 01:18:57 +00:00
if cmd . NArg ( ) != 1 {
cmd . Usage ( )
return nil
}
2013-05-23 03:07:26 +00:00
2013-05-19 17:46:24 +00:00
var (
2013-06-21 05:02:36 +00:00
context Archive
isRemote bool
err error
2013-05-19 17:46:24 +00:00
)
2013-05-07 17:23:50 +00:00
2013-05-30 01:18:57 +00:00
if cmd . Arg ( 0 ) == "-" {
2013-06-15 16:38:18 +00:00
// As a special case, 'docker build -' will build from an empty context with the
// contents of stdin as a Dockerfile
2013-06-24 21:15:52 +00:00
dockerfile , err := ioutil . ReadAll ( cli . in )
2013-05-28 22:22:34 +00:00
if err != nil {
return err
}
2013-06-15 18:07:49 +00:00
context , err = mkBuildContext ( string ( dockerfile ) , nil )
2013-06-21 05:02:36 +00:00
} else if utils . IsURL ( cmd . Arg ( 0 ) ) || utils . IsGIT ( cmd . Arg ( 0 ) ) {
isRemote = true
2013-06-15 16:38:18 +00:00
} else {
context , err = Tar ( cmd . Arg ( 0 ) , Uncompressed )
2013-05-24 01:32:56 +00:00
}
2013-06-21 05:02:36 +00:00
var body io . Reader
2013-06-18 01:26:41 +00:00
// Setup an upload progress bar
// FIXME: ProgressReader shouldn't be this annoyning to use
2013-06-21 05:02:36 +00:00
if context != nil {
sf := utils . NewStreamFormatter ( false )
2013-06-24 21:15:52 +00:00
body = utils . ProgressReader ( ioutil . NopCloser ( context ) , 0 , cli . err , sf . FormatProgress ( "Uploading context" , "%v bytes%0.0s%0.0s" ) , sf )
2013-05-30 01:18:57 +00:00
}
2013-06-15 16:38:18 +00:00
// Upload the build context
2013-05-30 19:08:21 +00:00
v := & url . Values { }
v . Set ( "t" , * tag )
2013-06-06 23:09:46 +00:00
if isRemote {
v . Set ( "remote" , cmd . Arg ( 0 ) )
}
2013-06-21 03:25:59 +00:00
req , err := http . NewRequest ( "POST" , fmt . Sprintf ( "/v%g/build?%s" , APIVERSION , v . Encode ( ) ) , body )
2013-05-24 01:32:56 +00:00
if err != nil {
2013-05-23 03:07:26 +00:00
return err
}
2013-06-21 05:02:36 +00:00
if context != nil {
req . Header . Set ( "Content-Type" , "application/tar" )
2013-05-28 20:38:40 +00:00
}
2013-06-18 18:59:56 +00:00
dial , err := net . Dial ( cli . proto , cli . addr )
if err != nil {
return err
}
clientconn := httputil . NewClientConn ( dial , nil )
resp , err := clientconn . Do ( req )
defer clientconn . Close ( )
2013-05-23 03:07:26 +00:00
if err != nil {
return err
}
defer resp . Body . Close ( )
2013-05-24 01:32:56 +00:00
// Check for errors
2013-05-23 03:07:26 +00:00
if resp . StatusCode < 200 || resp . StatusCode >= 400 {
body , err := ioutil . ReadAll ( resp . Body )
2013-05-19 17:46:24 +00:00
if err != nil {
return err
}
2013-06-10 15:06:52 +00:00
if len ( body ) == 0 {
return fmt . Errorf ( "Error: %s" , http . StatusText ( resp . StatusCode ) )
}
return fmt . Errorf ( "Error: %s" , body )
2013-04-25 18:20:45 +00:00
}
2013-05-23 03:07:26 +00:00
2013-05-24 01:32:56 +00:00
// Output the result
2013-06-24 21:15:52 +00:00
if _ , err := io . Copy ( cli . out , resp . Body ) ; err != nil {
2013-04-25 18:20:45 +00:00
return err
}
2013-05-23 03:07:26 +00:00
2013-04-25 18:20:45 +00:00
return nil
2013-04-24 18:03:01 +00:00
}
2013-03-15 00:43:59 +00:00
// 'docker login': login / register a user to registry service.
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdLogin ( args ... string ) error {
2013-04-05 03:19:06 +00:00
var readStringOnRawTerminal = func ( stdin io . Reader , stdout io . Writer , echo bool ) string {
2013-03-28 19:11:47 +00:00
char := make ( [ ] byte , 1 )
buffer := make ( [ ] byte , 64 )
var i = 0
for i < len ( buffer ) {
n , err := stdin . Read ( char )
if n > 0 {
if char [ 0 ] == '\r' || char [ 0 ] == '\n' {
2013-04-11 02:08:46 +00:00
stdout . Write ( [ ] byte { '\r' , '\n' } )
2013-03-28 19:11:47 +00:00
break
} else if char [ 0 ] == 127 || char [ 0 ] == '\b' {
if i > 0 {
if echo {
stdout . Write ( [ ] byte { '\b' , ' ' , '\b' } )
}
i --
}
} else if ! unicode . IsSpace ( rune ( char [ 0 ] ) ) &&
! unicode . IsControl ( rune ( char [ 0 ] ) ) {
if echo {
stdout . Write ( char )
}
buffer [ i ] = char [ 0 ]
i ++
}
}
if err != nil {
if err != io . EOF {
2013-04-11 02:08:46 +00:00
fmt . Fprintf ( stdout , "Read error: %v\r\n" , err )
2013-03-28 19:11:47 +00:00
}
break
}
}
return string ( buffer [ : i ] )
}
2013-04-05 03:19:06 +00:00
var readAndEchoString = func ( stdin io . Reader , stdout io . Writer ) string {
2013-03-28 19:11:47 +00:00
return readStringOnRawTerminal ( stdin , stdout , true )
}
2013-04-05 03:19:06 +00:00
var readString = func ( stdin io . Reader , stdout io . Writer ) string {
2013-03-28 19:11:47 +00:00
return readStringOnRawTerminal ( stdin , stdout , false )
}
2013-06-24 21:59:37 +00:00
oldState , err := term . SetRawTerminal ( cli . terminalFd )
2013-05-06 11:34:31 +00:00
if err != nil {
return err
}
2013-06-24 21:59:37 +00:00
defer term . RestoreTerminal ( cli . terminalFd , oldState )
2013-04-03 19:25:19 +00:00
2013-05-06 11:34:31 +00:00
cmd := Subcmd ( "login" , "" , "Register or Login to the docker registry server" )
2013-03-15 14:49:27 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-03-28 19:11:47 +00:00
2013-06-24 21:15:52 +00:00
var (
username string
password string
email string
)
2013-03-15 00:43:59 +00:00
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Username (%s):" , cli . authConfig . Username )
username = readAndEchoString ( cli . in , cli . out )
2013-03-15 00:43:59 +00:00
if username == "" {
2013-05-30 15:39:43 +00:00
username = cli . authConfig . Username
2013-03-15 00:43:59 +00:00
}
2013-05-30 15:39:43 +00:00
if username != cli . authConfig . Username {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Password: " )
password = readString ( cli . in , cli . out )
2013-03-15 00:43:59 +00:00
2013-03-15 14:49:27 +00:00
if password == "" {
2013-03-29 15:19:42 +00:00
return fmt . Errorf ( "Error : Password Required" )
2013-03-15 14:49:27 +00:00
}
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Email (%s): " , cli . authConfig . Email )
email = readAndEchoString ( cli . in , cli . out )
2013-03-15 00:43:59 +00:00
if email == "" {
2013-05-30 15:39:43 +00:00
email = cli . authConfig . Email
2013-03-15 00:43:59 +00:00
}
} else {
2013-06-14 13:38:51 +00:00
password = cli . authConfig . Password
2013-05-30 15:39:43 +00:00
email = cli . authConfig . Email
2013-03-15 00:43:59 +00:00
}
2013-06-24 21:59:37 +00:00
term . RestoreTerminal ( cli . terminalFd , oldState )
2013-05-06 11:34:31 +00:00
2013-05-30 15:39:43 +00:00
cli . authConfig . Username = username
cli . authConfig . Password = password
cli . authConfig . Email = email
2013-05-06 11:34:31 +00:00
2013-06-14 13:38:51 +00:00
body , statusCode , err := cli . call ( "POST" , "/auth" , cli . authConfig )
if statusCode == 401 {
cli . authConfig . Username = ""
cli . authConfig . Password = ""
cli . authConfig . Email = ""
auth . SaveConfig ( cli . authConfig )
return err
}
2013-03-15 00:43:59 +00:00
if err != nil {
2013-05-06 11:34:31 +00:00
return err
}
2013-06-04 18:00:22 +00:00
var out2 APIAuth
2013-05-08 21:57:14 +00:00
err = json . Unmarshal ( body , & out2 )
2013-05-06 11:34:31 +00:00
if err != nil {
2013-05-30 15:39:43 +00:00
auth . LoadConfig ( os . Getenv ( "HOME" ) )
2013-05-06 11:34:31 +00:00
return err
2013-03-15 00:43:59 +00:00
}
2013-05-30 15:39:43 +00:00
auth . SaveConfig ( cli . authConfig )
2013-05-06 11:34:31 +00:00
if out2 . Status != "" {
2013-06-27 04:33:55 +00:00
fmt . Fprintf ( cli . out , "%s\n" , out2 . Status )
2013-03-15 03:21:03 +00:00
}
2013-03-15 00:43:59 +00:00
return nil
}
2013-02-26 19:43:54 +00:00
// 'docker wait': block until a container stops
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdWait ( args ... string ) error {
2013-04-24 12:01:40 +00:00
cmd := Subcmd ( "wait" , "CONTAINER [CONTAINER...]" , "Block until a container stops, then print its exit code." )
2013-02-26 19:43:54 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) < 1 {
cmd . Usage ( )
return nil
}
for _ , name := range cmd . Args ( ) {
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "POST" , "/containers/" + name + "/wait" , nil )
2013-04-24 12:01:40 +00:00
if err != nil {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s" , err )
2013-02-26 19:43:54 +00:00
} else {
2013-06-04 18:00:22 +00:00
var out APIWait
2013-04-24 12:01:40 +00:00
err = json . Unmarshal ( body , & out )
if err != nil {
return err
}
2013-06-27 04:33:55 +00:00
fmt . Fprintf ( cli . out , "%d\n" , out . StatusCode )
2013-02-26 19:43:54 +00:00
}
}
return nil
}
2013-03-13 00:34:15 +00:00
// 'docker version': show version information
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdVersion ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "version" , "" , "Show the docker version information." )
if err := cmd . Parse ( args ) ; err != nil {
return nil
2013-04-19 04:08:33 +00:00
}
2013-05-15 14:16:46 +00:00
2013-04-22 16:17:47 +00:00
if cmd . NArg ( ) > 0 {
cmd . Usage ( )
return nil
}
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/version" , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
return err
2013-04-11 19:58:23 +00:00
}
2013-04-22 16:17:47 +00:00
2013-06-04 18:00:22 +00:00
var out APIVersion
2013-04-22 16:17:47 +00:00
err = json . Unmarshal ( body , & out )
if err != nil {
2013-05-14 22:37:35 +00:00
utils . Debugf ( "Error unmarshal: body: %s, err: %s\n" , body , err )
2013-04-22 16:17:47 +00:00
return err
}
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Client version: %s\n" , VERSION )
fmt . Fprintf ( cli . out , "Server version: %s\n" , out . Version )
2013-05-31 22:53:57 +00:00
if out . GitCommit != "" {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Git commit: %s\n" , out . GitCommit )
2013-05-02 16:36:23 +00:00
}
2013-05-31 22:53:57 +00:00
if out . GoVersion != "" {
2013-06-27 04:33:55 +00:00
fmt . Fprintf ( cli . out , "Go version: %s\n" , out . GoVersion )
2013-04-11 19:58:23 +00:00
}
2013-03-13 00:34:15 +00:00
return nil
}
2013-02-14 01:10:00 +00:00
// 'docker info': display system-wide information.
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdInfo ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "info" , "" , "Display system-wide information" )
2013-03-11 23:11:46 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-03-12 15:59:32 +00:00
if cmd . NArg ( ) > 0 {
2013-03-11 23:11:46 +00:00
cmd . Usage ( )
return nil
2013-03-12 11:24:26 +00:00
}
2013-03-30 17:33:10 +00:00
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/info" , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
return err
2013-03-30 17:33:10 +00:00
}
2013-05-08 23:40:48 +00:00
2013-06-04 18:00:22 +00:00
var out APIInfo
2013-05-31 22:53:57 +00:00
if err := json . Unmarshal ( body , & out ) ; err != nil {
2013-04-22 16:17:47 +00:00
return err
}
2013-05-31 22:53:57 +00:00
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Containers: %d\n" , out . Containers )
fmt . Fprintf ( cli . out , "Images: %d\n" , out . Images )
2013-05-31 22:53:57 +00:00
if out . Debug || os . Getenv ( "DEBUG" ) != "" {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Debug mode (server): %v\n" , out . Debug )
fmt . Fprintf ( cli . out , "Debug mode (client): %v\n" , os . Getenv ( "DEBUG" ) != "" )
fmt . Fprintf ( cli . out , "Fds: %d\n" , out . NFd )
fmt . Fprintf ( cli . out , "Goroutines: %d\n" , out . NGoroutines )
2013-05-31 22:53:57 +00:00
}
if ! out . MemoryLimit {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "WARNING: No memory limit support\n" )
2013-05-31 22:53:57 +00:00
}
if ! out . SwapLimit {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "WARNING: No swap limit support\n" )
2013-03-30 17:33:10 +00:00
}
2013-02-14 01:10:00 +00:00
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdStop ( args ... string ) error {
2013-05-02 16:36:23 +00:00
cmd := Subcmd ( "stop" , "[OPTIONS] CONTAINER [CONTAINER...]" , "Stop a running container" )
2013-04-16 16:43:44 +00:00
nSeconds := cmd . Int ( "t" , 10 , "wait t seconds before killing the container" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) < 1 {
cmd . Usage ( )
return nil
}
2013-04-22 16:17:47 +00:00
2013-05-02 16:36:23 +00:00
v := url . Values { }
v . Set ( "t" , strconv . Itoa ( * nSeconds ) )
2013-02-14 01:10:00 +00:00
for _ , name := range cmd . Args ( ) {
2013-05-13 09:48:27 +00:00
_ , _ , err := cli . call ( "POST" , "/containers/" + name + "/stop?" + v . Encode ( ) , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-02-14 01:10:00 +00:00
} else {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "%s\n" , name )
2013-02-14 21:49:05 +00:00
}
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdRestart ( args ... string ) error {
2013-05-02 16:36:23 +00:00
cmd := Subcmd ( "restart" , "[OPTIONS] CONTAINER [CONTAINER...]" , "Restart a running container" )
2013-04-16 16:43:44 +00:00
nSeconds := cmd . Int ( "t" , 10 , "wait t seconds before killing the container" )
2013-02-14 21:49:05 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) < 1 {
cmd . Usage ( )
return nil
}
2013-04-22 16:17:47 +00:00
2013-05-02 16:36:23 +00:00
v := url . Values { }
v . Set ( "t" , strconv . Itoa ( * nSeconds ) )
2013-02-14 21:49:05 +00:00
for _ , name := range cmd . Args ( ) {
2013-05-13 09:48:27 +00:00
_ , _ , err := cli . call ( "POST" , "/containers/" + name + "/restart?" + v . Encode ( ) , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-02-14 21:49:05 +00:00
} else {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "%s\n" , name )
2013-02-14 21:49:05 +00:00
}
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdStart ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "start" , "CONTAINER [CONTAINER...]" , "Restart a stopped container" )
2013-02-14 21:49:05 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) < 1 {
cmd . Usage ( )
return nil
}
2013-04-22 16:17:47 +00:00
for _ , name := range args {
2013-05-13 09:48:27 +00:00
_ , _ , err := cli . call ( "POST" , "/containers/" + name + "/start" , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-02-14 21:49:05 +00:00
} else {
2013-06-27 04:33:55 +00:00
fmt . Fprintf ( cli . out , "%s\n" , name )
2013-02-14 01:10:00 +00:00
}
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdInspect ( args ... string ) error {
2013-06-06 15:22:54 +00:00
cmd := Subcmd ( "inspect" , "CONTAINER|IMAGE [CONTAINER|IMAGE...]" , "Return low-level information on a container/image" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-06-06 15:22:54 +00:00
if cmd . NArg ( ) < 1 {
2013-02-14 01:10:00 +00:00
cmd . Usage ( )
return nil
}
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "[" )
2013-06-06 15:45:08 +00:00
for i , name := range args {
if i > 0 {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "," )
2013-06-06 15:45:08 +00:00
}
2013-06-06 15:22:54 +00:00
obj , _ , err := cli . call ( "GET" , "/containers/" + name + "/json" , nil )
2013-04-24 12:01:40 +00:00
if err != nil {
2013-06-06 15:22:54 +00:00
obj , _ , err = cli . call ( "GET" , "/images/" + name + "/json" , nil )
if err != nil {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-06-06 15:22:54 +00:00
continue
}
2013-04-24 12:01:40 +00:00
}
2013-05-09 01:46:39 +00:00
2013-06-06 15:22:54 +00:00
indented := new ( bytes . Buffer )
if err = json . Indent ( indented , obj , "" , " " ) ; err != nil {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-06-06 15:22:54 +00:00
continue
}
2013-06-24 21:15:52 +00:00
if _ , err := io . Copy ( cli . out , indented ) ; err != nil {
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-06-06 15:22:54 +00:00
}
2013-02-14 01:10:00 +00:00
}
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "]" )
2013-02-14 01:10:00 +00:00
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdPort ( args ... string ) error {
2013-04-23 16:20:53 +00:00
cmd := Subcmd ( "port" , "CONTAINER PRIVATE_PORT" , "Lookup the public-facing port which is NAT-ed to PRIVATE_PORT" )
2013-03-06 08:39:03 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 2 {
cmd . Usage ( )
return nil
}
2013-05-08 16:06:43 +00:00
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/containers/" + cmd . Arg ( 0 ) + "/json" , nil )
2013-04-23 16:20:53 +00:00
if err != nil {
return err
}
2013-05-08 16:06:43 +00:00
var out Container
2013-04-23 16:20:53 +00:00
err = json . Unmarshal ( body , & out )
if err != nil {
return err
2013-03-06 08:39:03 +00:00
}
2013-05-08 16:06:43 +00:00
if frontend , exists := out . NetworkSettings . PortMapping [ cmd . Arg ( 1 ) ] ; exists {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "%s\n" , frontend )
2013-03-06 08:39:03 +00:00
} else {
2013-06-10 15:06:52 +00:00
return fmt . Errorf ( "Error: No private port '%s' allocated on %s" , cmd . Arg ( 1 ) , cmd . Arg ( 0 ) )
2013-03-06 08:39:03 +00:00
}
return nil
}
2013-04-11 16:46:47 +00:00
// 'docker rmi IMAGE' removes all images with the name IMAGE
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdRmi ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "rmi" , "IMAGE [IMAGE...]" , "Remove an image" )
2013-03-26 01:35:31 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) < 1 {
2013-03-13 18:14:37 +00:00
cmd . Usage ( )
return nil
}
2013-04-22 16:17:47 +00:00
2013-03-13 18:14:37 +00:00
for _ , name := range cmd . Args ( ) {
2013-05-31 14:37:02 +00:00
body , _ , err := cli . call ( "DELETE" , "/images/" + name , nil )
2013-04-11 00:23:42 +00:00
if err != nil {
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . err , "%s" , err )
2013-04-22 16:17:47 +00:00
} else {
2013-06-10 21:05:54 +00:00
var outs [ ] APIRmi
2013-05-31 14:37:02 +00:00
err = json . Unmarshal ( body , & outs )
if err != nil {
return err
}
for _ , out := range outs {
if out . Deleted != "" {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "Deleted: %s\n" , out . Deleted )
2013-05-31 14:37:02 +00:00
} else {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "Untagged: %s\n" , out . Untagged )
2013-05-31 14:37:02 +00:00
}
}
2013-03-13 18:14:37 +00:00
}
}
return nil
}
2013-02-14 01:10:00 +00:00
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdHistory ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "history" , "IMAGE" , "Show the history of an image" )
2013-03-26 01:33:56 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 1 {
2013-03-22 04:42:18 +00:00
cmd . Usage ( )
return nil
}
2013-04-22 16:17:47 +00:00
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/images/" + cmd . Arg ( 0 ) + "/history" , nil )
2013-03-22 04:42:18 +00:00
if err != nil {
return err
}
2013-04-22 16:17:47 +00:00
2013-06-04 18:00:22 +00:00
var outs [ ] APIHistory
2013-04-22 16:17:47 +00:00
err = json . Unmarshal ( body , & outs )
2013-03-22 04:42:18 +00:00
if err != nil {
return err
}
2013-06-24 21:15:52 +00:00
w := tabwriter . NewWriter ( cli . out , 20 , 1 , 3 , ' ' , 0 )
2013-03-30 07:23:12 +00:00
fmt . Fprintln ( w , "ID\tCREATED\tCREATED BY" )
2013-04-22 16:17:47 +00:00
for _ , out := range outs {
2013-06-18 17:31:07 +00:00
if out . Tags != nil {
out . ID = out . Tags [ 0 ]
}
fmt . Fprintf ( w , "%s \t%s ago\t%s\n" , out . ID , utils . HumanDuration ( time . Now ( ) . Sub ( time . Unix ( out . Created , 0 ) ) ) , out . CreatedBy )
2013-04-22 16:17:47 +00:00
}
w . Flush ( )
return nil
2013-03-22 04:42:18 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdRm ( args ... string ) error {
2013-05-06 09:52:15 +00:00
cmd := Subcmd ( "rm" , "[OPTIONS] CONTAINER [CONTAINER...]" , "Remove a container" )
2013-04-12 16:23:57 +00:00
v := cmd . Bool ( "v" , false , "Remove the volumes associated to the container" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-11 14:27:01 +00:00
if cmd . NArg ( ) < 1 {
cmd . Usage ( )
return nil
}
2013-05-06 09:52:15 +00:00
val := url . Values { }
2013-04-12 16:23:57 +00:00
if * v {
2013-05-06 09:52:15 +00:00
val . Set ( "v" , "1" )
}
for _ , name := range cmd . Args ( ) {
2013-05-13 09:48:27 +00:00
_ , _ , err := cli . call ( "DELETE" , "/containers/" + name + "?" + val . Encode ( ) , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-04-22 16:17:47 +00:00
} else {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "%s\n" , name )
2013-04-12 16:23:57 +00:00
}
}
2013-02-14 01:10:00 +00:00
return nil
}
// 'docker kill NAME' kills a running container
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdKill ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "kill" , "CONTAINER [CONTAINER...]" , "Kill a running container" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-12 10:26:31 +00:00
if cmd . NArg ( ) < 1 {
cmd . Usage ( )
return nil
}
2013-04-22 16:17:47 +00:00
for _ , name := range args {
2013-05-13 09:48:27 +00:00
_ , _ , err := cli . call ( "POST" , "/containers/" + name + "/kill" , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-04-22 16:17:47 +00:00
} else {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "%s\n" , name )
2013-02-14 01:10:00 +00:00
}
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdImport ( args ... string ) error {
2013-04-30 15:04:31 +00:00
cmd := Subcmd ( "import" , "URL|- [REPOSITORY [TAG]]" , "Create a new filesystem image from the contents of a tarball" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-12 10:26:31 +00:00
if cmd . NArg ( ) < 1 {
cmd . Usage ( )
return nil
}
2013-04-30 15:04:31 +00:00
src , repository , tag := cmd . Arg ( 0 ) , cmd . Arg ( 1 ) , cmd . Arg ( 2 )
v := url . Values { }
v . Set ( "repo" , repository )
v . Set ( "tag" , tag )
2013-05-06 09:31:22 +00:00
v . Set ( "fromSrc" , src )
2013-04-30 15:04:31 +00:00
2013-06-24 21:15:52 +00:00
err := cli . stream ( "POST" , "/images/create?" + v . Encode ( ) , cli . in , cli . out )
2013-02-14 01:10:00 +00:00
if err != nil {
return err
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdPush ( args ... string ) error {
2013-05-07 17:23:50 +00:00
cmd := Subcmd ( "push" , "[OPTION] NAME" , "Push an image or a repository to the registry" )
2013-03-21 10:53:27 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-05-06 11:34:31 +00:00
name := cmd . Arg ( 0 )
2013-03-22 13:38:54 +00:00
2013-05-06 11:34:31 +00:00
if name == "" {
2013-03-21 10:53:27 +00:00
cmd . Usage ( )
return nil
}
2013-07-05 19:20:58 +00:00
if err := cli . checkIfLogged ( "push" ) ; err != nil {
2013-05-06 11:34:31 +00:00
return err
}
2013-07-05 19:20:58 +00:00
// If we're not using a custom registry, we know the restrictions
// applied to repository names and can warn the user in advance.
// Custom repositories can have different rules, and we must also
// allow pushing by image ID.
if len ( strings . SplitN ( name , "/" , 2 ) ) == 1 {
return fmt . Errorf ( "Impossible to push a \"root\" repository. Please rename your repository in <user>/<repo> (ex: %s/%s)" , cli . authConfig . Username , name )
2013-03-22 13:38:54 +00:00
}
2013-06-03 17:51:52 +00:00
buf , err := json . Marshal ( cli . authConfig )
if err != nil {
return err
2013-03-22 13:38:54 +00:00
}
2013-05-07 17:23:50 +00:00
v := url . Values { }
2013-06-24 21:15:52 +00:00
if err := cli . stream ( "POST" , "/images/" + name + "/push?" + v . Encode ( ) , bytes . NewBuffer ( buf ) , cli . out ) ; err != nil {
2013-03-22 10:10:09 +00:00
return err
}
return nil
2013-03-21 10:53:27 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdPull ( args ... string ) error {
2013-04-23 16:20:53 +00:00
cmd := Subcmd ( "pull" , "NAME" , "Pull an image or a repository from the registry" )
2013-04-15 18:17:03 +00:00
tag := cmd . String ( "t" , "" , "Download tagged image in repository" )
2013-03-21 10:53:27 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-23 16:20:53 +00:00
if cmd . NArg ( ) != 1 {
2013-03-21 10:53:27 +00:00
cmd . Usage ( )
return nil
}
2013-03-22 08:25:27 +00:00
2013-07-09 15:06:10 +00:00
remote , parsedTag := utils . ParseRepositoryTag ( cmd . Arg ( 0 ) )
2013-07-09 00:20:41 +00:00
* tag = parsedTag
2013-04-30 13:55:24 +00:00
2013-05-06 09:31:22 +00:00
v := url . Values { }
2013-05-07 17:23:50 +00:00
v . Set ( "fromImage" , remote )
v . Set ( "tag" , * tag )
2013-03-22 08:25:27 +00:00
2013-06-24 21:15:52 +00:00
if err := cli . stream ( "POST" , "/images/create?" + v . Encode ( ) , nil , cli . out ) ; err != nil {
2013-03-22 10:10:09 +00:00
return err
}
2013-04-23 16:20:53 +00:00
2013-03-22 10:10:09 +00:00
return nil
2013-03-21 10:53:27 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdImages ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "images" , "[OPTIONS] [NAME]" , "List images" )
2013-02-14 01:10:00 +00:00
quiet := cmd . Bool ( "q" , false , "only show numeric IDs" )
2013-04-22 16:17:47 +00:00
all := cmd . Bool ( "a" , false , "show all images" )
2013-05-13 10:26:18 +00:00
noTrunc := cmd . Bool ( "notrunc" , false , "Don't truncate output" )
2013-05-01 05:39:48 +00:00
flViz := cmd . Bool ( "viz" , false , "output graph in graphviz format" )
2013-04-23 16:20:53 +00:00
2013-03-11 22:08:22 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-02-14 01:10:00 +00:00
if cmd . NArg ( ) > 1 {
cmd . Usage ( )
return nil
}
2013-05-01 05:39:48 +00:00
if * flViz {
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/images/viz" , false )
2013-05-09 21:10:26 +00:00
if err != nil {
2013-05-07 17:23:50 +00:00
return err
2013-05-01 05:39:48 +00:00
}
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "%s" , body )
2013-05-01 05:39:48 +00:00
} else {
2013-05-07 17:23:50 +00:00
v := url . Values { }
2013-05-01 05:39:48 +00:00
if cmd . NArg ( ) == 1 {
2013-05-07 17:23:50 +00:00
v . Set ( "filter" , cmd . Arg ( 0 ) )
2013-05-01 05:39:48 +00:00
}
2013-05-07 17:23:50 +00:00
if * all {
v . Set ( "all" , "1" )
2013-05-01 05:39:48 +00:00
}
2013-04-22 16:17:47 +00:00
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/images/json?" + v . Encode ( ) , nil )
2013-05-01 05:39:48 +00:00
if err != nil {
return err
}
2013-04-22 16:17:47 +00:00
2013-06-04 18:00:22 +00:00
var outs [ ] APIImages
2013-05-07 17:23:50 +00:00
err = json . Unmarshal ( body , & outs )
if err != nil {
return err
2013-02-14 01:10:00 +00:00
}
2013-05-07 17:23:50 +00:00
2013-06-24 21:15:52 +00:00
w := tabwriter . NewWriter ( cli . out , 20 , 1 , 3 , ' ' , 0 )
2013-04-22 16:17:47 +00:00
if ! * quiet {
2013-05-13 13:10:26 +00:00
fmt . Fprintln ( w , "REPOSITORY\tTAG\tID\tCREATED\tSIZE" )
2013-03-22 00:35:49 +00:00
}
2013-04-22 16:17:47 +00:00
2013-05-07 17:23:50 +00:00
for _ , out := range outs {
2013-05-13 10:18:55 +00:00
if out . Repository == "" {
out . Repository = "<none>"
}
if out . Tag == "" {
out . Tag = "<none>"
}
2013-05-07 17:23:50 +00:00
if ! * quiet {
2013-05-13 10:26:18 +00:00
fmt . Fprintf ( w , "%s\t%s\t" , out . Repository , out . Tag )
if * noTrunc {
2013-06-04 18:00:22 +00:00
fmt . Fprintf ( w , "%s\t" , out . ID )
2013-05-13 10:26:18 +00:00
} else {
2013-06-04 18:00:22 +00:00
fmt . Fprintf ( w , "%s\t" , utils . TruncateID ( out . ID ) )
2013-05-13 10:26:18 +00:00
}
2013-05-22 13:41:29 +00:00
fmt . Fprintf ( w , "%s ago\t" , utils . HumanDuration ( time . Now ( ) . Sub ( time . Unix ( out . Created , 0 ) ) ) )
2013-06-14 10:05:01 +00:00
if out . VirtualSize > 0 {
fmt . Fprintf ( w , "%s (virtual %s)\n" , utils . HumanSize ( out . Size ) , utils . HumanSize ( out . VirtualSize ) )
2013-05-22 13:41:29 +00:00
} else {
fmt . Fprintf ( w , "%s\n" , utils . HumanSize ( out . Size ) )
}
2013-05-07 17:23:50 +00:00
} else {
2013-05-13 10:26:18 +00:00
if * noTrunc {
2013-06-04 18:00:22 +00:00
fmt . Fprintln ( w , out . ID )
2013-05-13 10:26:18 +00:00
} else {
2013-06-04 18:00:22 +00:00
fmt . Fprintln ( w , utils . TruncateID ( out . ID ) )
2013-05-13 10:26:18 +00:00
}
2013-03-22 00:35:49 +00:00
}
}
2013-05-07 17:23:50 +00:00
2013-05-01 05:39:48 +00:00
if ! * quiet {
w . Flush ( )
}
2013-02-14 01:10:00 +00:00
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdPs ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "ps" , "[OPTIONS]" , "List containers" )
2013-02-14 01:10:00 +00:00
quiet := cmd . Bool ( "q" , false , "Only display numeric IDs" )
2013-06-20 14:19:50 +00:00
size := cmd . Bool ( "s" , false , "Display sizes" )
2013-04-22 16:17:47 +00:00
all := cmd . Bool ( "a" , false , "Show all containers. Only running containers are shown by default." )
noTrunc := cmd . Bool ( "notrunc" , false , "Don't truncate output" )
nLatest := cmd . Bool ( "l" , false , "Show only the latest created container, include non-running ones." )
2013-05-08 16:28:11 +00:00
since := cmd . String ( "sinceId" , "" , "Show only containers created since Id, include non-running ones." )
before := cmd . String ( "beforeId" , "" , "Show only container created before Id, include non-running ones." )
2013-04-22 16:17:47 +00:00
last := cmd . Int ( "n" , - 1 , "Show n last created containers, include non-running ones." )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-22 16:17:47 +00:00
v := url . Values { }
if * last == - 1 && * nLatest {
* last = 1
}
if * all {
2013-04-26 13:08:33 +00:00
v . Set ( "all" , "1" )
2013-04-22 16:17:47 +00:00
}
if * last != - 1 {
2013-05-08 15:35:50 +00:00
v . Set ( "limit" , strconv . Itoa ( * last ) )
2013-04-22 16:17:47 +00:00
}
2013-05-08 16:28:11 +00:00
if * since != "" {
v . Set ( "since" , * since )
}
if * before != "" {
v . Set ( "before" , * before )
}
2013-06-20 14:19:50 +00:00
if * size {
v . Set ( "size" , "1" )
}
2013-04-23 16:20:53 +00:00
2013-05-28 16:08:05 +00:00
body , _ , err := cli . call ( "GET" , "/containers/json?" + v . Encode ( ) , nil )
2013-04-22 16:17:47 +00:00
if err != nil {
return err
}
2013-06-04 18:00:22 +00:00
var outs [ ] APIContainers
2013-04-22 16:17:47 +00:00
err = json . Unmarshal ( body , & outs )
if err != nil {
return err
2013-04-10 17:30:57 +00:00
}
2013-06-24 21:15:52 +00:00
w := tabwriter . NewWriter ( cli . out , 20 , 1 , 3 , ' ' , 0 )
2013-02-14 01:28:13 +00:00
if ! * quiet {
2013-06-20 14:19:50 +00:00
fmt . Fprint ( w , "ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tPORTS" )
if * size {
fmt . Fprintln ( w , "\tSIZE" )
} else {
fmt . Fprint ( w , "\n" )
}
2013-02-14 01:10:00 +00:00
}
2013-04-22 16:17:47 +00:00
for _ , out := range outs {
2013-02-14 01:10:00 +00:00
if ! * quiet {
2013-05-13 10:18:55 +00:00
if * noTrunc {
2013-06-05 16:01:36 +00:00
fmt . Fprintf ( w , "%s\t%s\t%s\t%s ago\t%s\t%s\t" , out . ID , out . Image , out . Command , utils . HumanDuration ( time . Now ( ) . Sub ( time . Unix ( out . Created , 0 ) ) ) , out . Status , out . Ports )
2013-05-22 13:41:29 +00:00
} else {
2013-06-05 16:01:36 +00:00
fmt . Fprintf ( w , "%s\t%s\t%s\t%s ago\t%s\t%s\t" , utils . TruncateID ( out . ID ) , out . Image , utils . Trunc ( out . Command , 20 ) , utils . HumanDuration ( time . Now ( ) . Sub ( time . Unix ( out . Created , 0 ) ) ) , out . Status , out . Ports )
2013-05-22 13:41:29 +00:00
}
2013-06-20 14:19:50 +00:00
if * size {
if out . SizeRootFs > 0 {
fmt . Fprintf ( w , "%s (virtual %s)\n" , utils . HumanSize ( out . SizeRw ) , utils . HumanSize ( out . SizeRootFs ) )
} else {
fmt . Fprintf ( w , "%s\n" , utils . HumanSize ( out . SizeRw ) )
}
2013-05-13 13:10:26 +00:00
} else {
2013-06-20 14:19:50 +00:00
fmt . Fprint ( w , "\n" )
2013-05-13 13:10:26 +00:00
}
2013-02-14 01:10:00 +00:00
} else {
2013-05-13 10:18:55 +00:00
if * noTrunc {
2013-06-04 18:00:22 +00:00
fmt . Fprintln ( w , out . ID )
2013-05-13 10:18:55 +00:00
} else {
2013-06-04 18:00:22 +00:00
fmt . Fprintln ( w , utils . TruncateID ( out . ID ) )
2013-05-13 10:18:55 +00:00
}
2013-02-14 01:10:00 +00:00
}
}
2013-04-22 16:17:47 +00:00
2013-02-14 01:28:13 +00:00
if ! * quiet {
2013-02-14 01:10:00 +00:00
w . Flush ( )
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdCommit ( args ... string ) error {
2013-04-24 14:06:03 +00:00
cmd := Subcmd ( "commit" , "[OPTIONS] CONTAINER [REPOSITORY [TAG]]" , "Create a new image from a container's changes" )
2013-03-29 00:12:23 +00:00
flComment := cmd . String ( "m" , "" , "Commit message" )
2013-04-18 03:13:11 +00:00
flAuthor := cmd . String ( "author" , "" , "Author (eg. \"John Hannibal Smith <hannibal@a-team.com>\"" )
2013-05-01 19:45:45 +00:00
flConfig := cmd . String ( "run" , "" , "Config automatically applied when the image is run. " + ` (ex: { "Cmd": ["cat", "/world"], "PortSpecs": ["22"]}') ` )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-24 14:06:03 +00:00
name , repository , tag := cmd . Arg ( 0 ) , cmd . Arg ( 1 ) , cmd . Arg ( 2 )
if name == "" {
2013-02-14 01:10:00 +00:00
cmd . Usage ( )
return nil
}
2013-04-25 23:48:31 +00:00
2013-04-24 14:06:03 +00:00
v := url . Values { }
2013-05-07 15:19:41 +00:00
v . Set ( "container" , name )
2013-04-24 14:06:03 +00:00
v . Set ( "repo" , repository )
v . Set ( "tag" , tag )
v . Set ( "comment" , * flComment )
2013-05-02 16:36:23 +00:00
v . Set ( "author" , * flAuthor )
2013-05-01 22:19:55 +00:00
var config * Config
2013-04-25 23:48:31 +00:00
if * flConfig != "" {
2013-05-01 22:19:55 +00:00
config = & Config { }
2013-04-26 17:48:33 +00:00
if err := json . Unmarshal ( [ ] byte ( * flConfig ) , config ) ; err != nil {
return err
}
2013-04-25 23:48:31 +00:00
}
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "POST" , "/commit?" + v . Encode ( ) , config )
2013-03-22 03:07:37 +00:00
if err != nil {
return err
2013-04-24 22:24:14 +00:00
}
2013-06-04 18:00:22 +00:00
apiID := & APIID { }
err = json . Unmarshal ( body , apiID )
2013-03-22 03:07:37 +00:00
if err != nil {
return err
2013-02-14 01:10:00 +00:00
}
2013-04-24 14:06:03 +00:00
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "%s\n" , apiID . ID )
2013-03-22 03:07:37 +00:00
return nil
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdExport ( args ... string ) error {
2013-04-24 14:32:51 +00:00
cmd := Subcmd ( "export" , "CONTAINER" , "Export the contents of a filesystem as a tar archive" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-24 14:32:51 +00:00
if cmd . NArg ( ) != 1 {
cmd . Usage ( )
2013-02-14 01:10:00 +00:00
return nil
}
2013-04-24 14:32:51 +00:00
2013-06-24 21:15:52 +00:00
if err := cli . stream ( "GET" , "/containers/" + cmd . Arg ( 0 ) + "/export" , nil , cli . out ) ; err != nil {
2013-04-24 14:32:51 +00:00
return err
}
return nil
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdDiff ( args ... string ) error {
2013-04-24 12:01:40 +00:00
cmd := Subcmd ( "diff" , "CONTAINER" , "Inspect changes on a container's filesystem" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-24 12:01:40 +00:00
if cmd . NArg ( ) != 1 {
2013-04-12 10:26:31 +00:00
cmd . Usage ( )
return nil
2013-02-14 01:10:00 +00:00
}
2013-04-24 12:01:40 +00:00
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/containers/" + cmd . Arg ( 0 ) + "/changes" , nil )
2013-04-24 12:01:40 +00:00
if err != nil {
return err
}
2013-05-10 04:53:28 +00:00
changes := [ ] Change { }
2013-04-24 12:01:40 +00:00
err = json . Unmarshal ( body , & changes )
if err != nil {
return err
}
for _ , change := range changes {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . out , "%s\n" , change . String ( ) )
2013-02-14 01:10:00 +00:00
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdLogs ( args ... string ) error {
2013-04-22 16:17:47 +00:00
cmd := Subcmd ( "logs" , "CONTAINER" , "Fetch the logs of a container" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 1 {
cmd . Usage ( )
return nil
}
2013-04-22 16:17:47 +00:00
2013-06-24 21:15:52 +00:00
if err := cli . hijack ( "POST" , "/containers/" + cmd . Arg ( 0 ) + "/attach?logs=1&stdout=1" , false , nil , cli . out ) ; err != nil {
2013-05-27 16:07:05 +00:00
return err
}
2013-06-24 21:15:52 +00:00
if err := cli . hijack ( "POST" , "/containers/" + cmd . Arg ( 0 ) + "/attach?logs=1&stderr=1" , false , nil , cli . err ) ; err != nil {
2013-04-22 16:17:47 +00:00
return err
2013-02-14 01:10:00 +00:00
}
2013-04-22 16:17:47 +00:00
return nil
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdAttach ( args ... string ) error {
2013-04-26 13:08:33 +00:00
cmd := Subcmd ( "attach" , "CONTAINER" , "Attach to a running container" )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 1 {
cmd . Usage ( )
return nil
}
2013-04-02 19:18:20 +00:00
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/containers/" + cmd . Arg ( 0 ) + "/json" , nil )
2013-04-29 15:46:41 +00:00
if err != nil {
return err
2013-02-14 01:10:00 +00:00
}
2013-04-02 19:18:20 +00:00
2013-05-10 04:53:28 +00:00
container := & Container { }
err = json . Unmarshal ( body , container )
2013-04-29 15:46:41 +00:00
if err != nil {
return err
2013-04-19 21:18:03 +00:00
}
2013-06-17 22:40:04 +00:00
if ! container . State . Running {
return fmt . Errorf ( "Impossible to attach to a stopped container, start it first" )
}
2013-06-13 19:57:35 +00:00
if container . Config . Tty {
2013-06-24 21:59:37 +00:00
if err := cli . monitorTtySize ( cmd . Arg ( 0 ) ) ; err != nil {
return err
}
2013-06-13 19:57:35 +00:00
}
2013-06-17 21:44:35 +00:00
2013-05-02 03:07:06 +00:00
v := url . Values { }
v . Set ( "stream" , "1" )
v . Set ( "stdin" , "1" )
2013-05-29 11:40:54 +00:00
v . Set ( "stdout" , "1" )
2013-06-17 21:44:35 +00:00
v . Set ( "stderr" , "1" )
2013-06-24 21:59:37 +00:00
if err := cli . hijack ( "POST" , "/containers/" + cmd . Arg ( 0 ) + "/attach?" + v . Encode ( ) , container . Config . Tty , cli . in , cli . out ) ; err != nil {
2013-06-17 21:44:35 +00:00
return err
2013-04-05 04:51:40 +00:00
}
2013-04-26 13:08:33 +00:00
return nil
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdSearch ( args ... string ) error {
2013-05-07 18:37:35 +00:00
cmd := Subcmd ( "search" , "NAME" , "Search the docker index for images" )
2013-07-08 17:20:13 +00:00
noTrunc := cmd . Bool ( "notrunc" , false , "Don't truncate output" )
2013-05-07 10:49:08 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 1 {
cmd . Usage ( )
return nil
}
2013-05-07 18:59:04 +00:00
2013-05-07 18:37:35 +00:00
v := url . Values { }
2013-05-07 18:59:04 +00:00
v . Set ( "term" , cmd . Arg ( 0 ) )
2013-05-13 09:48:27 +00:00
body , _ , err := cli . call ( "GET" , "/images/search?" + v . Encode ( ) , nil )
2013-05-07 18:59:04 +00:00
if err != nil {
return err
}
2013-06-04 18:00:22 +00:00
outs := [ ] APISearch { }
2013-05-07 18:59:04 +00:00
err = json . Unmarshal ( body , & outs )
2013-05-07 10:49:08 +00:00
if err != nil {
return err
}
2013-06-24 21:15:52 +00:00
fmt . Fprintf ( cli . out , "Found %d results matching your query (\"%s\")\n" , len ( outs ) , cmd . Arg ( 0 ) )
2013-07-08 17:20:13 +00:00
w := tabwriter . NewWriter ( cli . out , 33 , 1 , 3 , ' ' , 0 )
2013-05-07 10:49:08 +00:00
fmt . Fprintf ( w , "NAME\tDESCRIPTION\n" )
2013-07-08 17:20:13 +00:00
_ , width := cli . getTtySize ( )
if width == 0 {
width = 45
} else {
width = width - 33 //remote the first column
}
2013-05-07 18:37:35 +00:00
for _ , out := range outs {
2013-06-07 13:09:24 +00:00
desc := strings . Replace ( out . Description , "\n" , " " , - 1 )
desc = strings . Replace ( desc , "\r" , " " , - 1 )
2013-07-08 17:20:13 +00:00
if ! * noTrunc && len ( desc ) > width {
desc = utils . Trunc ( desc , width - 3 ) + "..."
2013-06-07 13:09:24 +00:00
}
fmt . Fprintf ( w , "%s\t%s\n" , out . Name , desc )
2013-05-07 10:49:08 +00:00
}
w . Flush ( )
return nil
}
2013-02-28 19:52:22 +00:00
// Ports type - Used to parse multiple -p flags
type ports [ ] int
2013-03-23 03:36:34 +00:00
// ListOpts type
type ListOpts [ ] string
func ( opts * ListOpts ) String ( ) string {
return fmt . Sprint ( * opts )
}
func ( opts * ListOpts ) Set ( value string ) error {
* opts = append ( * opts , value )
return nil
}
2013-04-03 01:07:16 +00:00
// AttachOpts stores arguments to 'docker run -a', eg. which streams to attach to
type AttachOpts map [ string ] bool
2013-04-03 14:06:35 +00:00
func NewAttachOpts ( ) AttachOpts {
return make ( AttachOpts )
2013-04-03 01:07:16 +00:00
}
2013-04-03 14:06:35 +00:00
func ( opts AttachOpts ) String ( ) string {
// Cast to underlying map type to avoid infinite recursion
return fmt . Sprintf ( "%v" , map [ string ] bool ( opts ) )
2013-04-03 01:07:16 +00:00
}
2013-04-03 14:06:35 +00:00
func ( opts AttachOpts ) Set ( val string ) error {
2013-04-03 01:07:16 +00:00
if val != "stdin" && val != "stdout" && val != "stderr" {
return fmt . Errorf ( "Unsupported stream name: %s" , val )
}
2013-04-03 14:06:35 +00:00
opts [ val ] = true
2013-04-03 01:07:16 +00:00
return nil
}
2013-04-03 14:06:35 +00:00
func ( opts AttachOpts ) Get ( val string ) bool {
if res , exists := opts [ val ] ; exists {
2013-04-03 01:07:16 +00:00
return res
}
return false
}
2013-04-06 01:00:10 +00:00
// PathOpts stores a unique set of absolute paths
2013-04-10 23:09:34 +00:00
type PathOpts map [ string ] struct { }
2013-04-06 01:00:10 +00:00
func NewPathOpts ( ) PathOpts {
return make ( PathOpts )
}
func ( opts PathOpts ) String ( ) string {
2013-04-10 23:09:34 +00:00
return fmt . Sprintf ( "%v" , map [ string ] struct { } ( opts ) )
2013-04-06 01:00:10 +00:00
}
func ( opts PathOpts ) Set ( val string ) error {
if ! filepath . IsAbs ( val ) {
return fmt . Errorf ( "%s is not an absolute path" , val )
}
2013-04-10 23:09:34 +00:00
opts [ filepath . Clean ( val ) ] = struct { } { }
2013-04-06 01:00:10 +00:00
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdTag ( args ... string ) error {
2013-04-23 16:20:53 +00:00
cmd := Subcmd ( "tag" , "[OPTIONS] IMAGE REPOSITORY [TAG]" , "Tag an image into a repository" )
2013-03-23 01:27:18 +00:00
force := cmd . Bool ( "f" , false , "Force" )
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-04-23 16:20:53 +00:00
if cmd . NArg ( ) != 2 && cmd . NArg ( ) != 3 {
2013-03-23 01:27:18 +00:00
cmd . Usage ( )
return nil
}
2013-04-23 16:20:53 +00:00
v := url . Values { }
v . Set ( "repo" , cmd . Arg ( 1 ) )
if cmd . NArg ( ) == 3 {
v . Set ( "tag" , cmd . Arg ( 2 ) )
}
if * force {
2013-04-26 13:08:33 +00:00
v . Set ( "force" , "1" )
2013-04-23 16:20:53 +00:00
}
2013-05-13 09:48:27 +00:00
if _ , _ , err := cli . call ( "POST" , "/images/" + cmd . Arg ( 0 ) + "/tag?" + v . Encode ( ) , nil ) ; err != nil {
2013-04-23 16:20:53 +00:00
return err
}
return nil
2013-03-23 01:27:18 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdRun ( args ... string ) error {
2013-05-13 23:39:54 +00:00
config , hostConfig , cmd , err := ParseRun ( args , nil )
2013-03-23 19:16:58 +00:00
if err != nil {
return err
2013-02-14 01:10:00 +00:00
}
2013-03-23 19:39:09 +00:00
if config . Image == "" {
2013-04-23 16:20:53 +00:00
cmd . Usage ( )
return nil
2013-03-23 19:16:58 +00:00
}
2013-04-06 02:48:49 +00:00
2013-05-02 03:07:06 +00:00
//create the container
2013-05-13 09:48:27 +00:00
body , statusCode , err := cli . call ( "POST" , "/containers/create" , config )
2013-05-02 03:07:06 +00:00
//if image not found try to pull it
if statusCode == 404 {
2013-05-06 09:31:22 +00:00
v := url . Values { }
2013-07-09 23:45:32 +00:00
repos , tag := utils . ParseRepositoryTag ( config . Image )
v . Set ( "fromImage" , repos )
v . Set ( "tag" , tag )
2013-06-24 21:15:52 +00:00
err = cli . stream ( "POST" , "/images/create?" + v . Encode ( ) , nil , cli . err )
2013-05-02 03:07:06 +00:00
if err != nil {
return err
}
2013-05-13 09:48:27 +00:00
body , _ , err = cli . call ( "POST" , "/containers/create" , config )
2013-05-06 09:31:22 +00:00
if err != nil {
return err
}
2013-05-02 03:07:06 +00:00
}
if err != nil {
2013-04-02 06:52:20 +00:00
return err
2013-04-05 04:51:40 +00:00
}
2013-04-24 22:14:10 +00:00
2013-06-24 21:15:52 +00:00
runResult := & APIRun { }
err = json . Unmarshal ( body , runResult )
2013-02-14 01:10:00 +00:00
if err != nil {
2013-05-02 03:07:06 +00:00
return err
2013-02-14 01:10:00 +00:00
}
2013-05-02 03:07:06 +00:00
2013-06-24 21:15:52 +00:00
for _ , warning := range runResult . Warnings {
2013-06-27 22:25:31 +00:00
fmt . Fprintf ( cli . err , "WARNING: %s\n" , warning )
2013-05-02 16:36:23 +00:00
}
2013-05-02 03:07:06 +00:00
//start the container
2013-05-13 23:39:54 +00:00
if _ , _ , err = cli . call ( "POST" , "/containers/" + runResult . ID + "/start" , hostConfig ) ; err != nil {
2013-04-02 06:52:20 +00:00
return err
2013-02-14 01:10:00 +00:00
}
2013-05-07 20:15:21 +00:00
2013-06-27 19:48:25 +00:00
var wait chan struct { }
2013-06-04 22:24:25 +00:00
if ! config . AttachStdout && ! config . AttachStderr {
2013-06-25 01:22:02 +00:00
// Make this asynchrone in order to let the client write to stdin before having to read the ID
2013-06-27 19:48:25 +00:00
wait = make ( chan struct { } )
go func ( ) {
defer close ( wait )
fmt . Fprintf ( cli . out , "%s\n" , runResult . ID )
} ( )
2013-06-24 19:12:06 +00:00
}
2013-06-25 01:22:02 +00:00
2013-06-24 19:12:06 +00:00
if config . AttachStdin || config . AttachStdout || config . AttachStderr {
2013-06-13 19:57:35 +00:00
if config . Tty {
2013-06-24 21:59:37 +00:00
if err := cli . monitorTtySize ( runResult . ID ) ; err != nil {
return err
}
2013-06-13 19:57:35 +00:00
}
2013-05-29 11:40:54 +00:00
v := url . Values { }
v . Set ( "logs" , "1" )
v . Set ( "stream" , "1" )
if config . AttachStdin {
v . Set ( "stdin" , "1" )
}
if config . AttachStdout {
v . Set ( "stdout" , "1" )
}
2013-06-17 22:45:08 +00:00
if config . AttachStderr {
2013-05-29 11:40:54 +00:00
v . Set ( "stderr" , "1" )
}
2013-06-25 01:22:02 +00:00
2013-06-24 21:59:37 +00:00
if err := cli . hijack ( "POST" , "/containers/" + runResult . ID + "/attach?" + v . Encode ( ) , config . Tty , cli . in , cli . out ) ; err != nil {
2013-06-17 22:45:08 +00:00
utils . Debugf ( "Error hijack: %s" , err )
return err
2013-05-02 03:07:06 +00:00
}
2013-05-07 19:36:24 +00:00
}
2013-06-27 19:48:25 +00:00
if ! config . AttachStdout && ! config . AttachStderr {
<- wait
}
2013-05-02 03:07:06 +00:00
return nil
2013-02-14 01:10:00 +00:00
}
2013-04-23 16:20:53 +00:00
2013-07-05 19:20:58 +00:00
func ( cli * DockerCli ) checkIfLogged ( action string ) error {
2013-05-24 12:43:24 +00:00
// If condition AND the login failed
2013-07-05 19:20:58 +00:00
if cli . authConfig . Username == "" {
2013-05-24 12:43:24 +00:00
if err := cli . CmdLogin ( "" ) ; err != nil {
2013-05-30 15:39:43 +00:00
return err
2013-05-17 13:23:12 +00:00
}
2013-05-30 15:39:43 +00:00
if cli . authConfig . Username == "" {
return fmt . Errorf ( "Please login prior to %s. ('docker login')" , action )
2013-05-17 13:23:12 +00:00
}
}
2013-05-30 15:39:43 +00:00
return nil
2013-05-17 13:23:12 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) call ( method , path string , data interface { } ) ( [ ] byte , int , error ) {
2013-05-02 03:07:06 +00:00
var params io . Reader
2013-04-23 16:20:53 +00:00
if data != nil {
buf , err := json . Marshal ( data )
if err != nil {
2013-05-02 03:07:06 +00:00
return nil , - 1 , err
2013-04-23 16:20:53 +00:00
}
2013-05-02 03:07:06 +00:00
params = bytes . NewBuffer ( buf )
2013-04-22 16:17:47 +00:00
}
2013-05-07 15:19:41 +00:00
2013-06-18 18:59:56 +00:00
req , err := http . NewRequest ( method , fmt . Sprintf ( "/v%g%s" , APIVERSION , path ) , params )
2013-04-22 16:17:47 +00:00
if err != nil {
2013-05-02 03:07:06 +00:00
return nil , - 1 , err
2013-04-22 16:17:47 +00:00
}
2013-05-09 18:24:49 +00:00
req . Header . Set ( "User-Agent" , "Docker-Client/" + VERSION )
2013-04-23 16:20:53 +00:00
if data != nil {
req . Header . Set ( "Content-Type" , "application/json" )
2013-05-02 03:07:06 +00:00
} else if method == "POST" {
req . Header . Set ( "Content-Type" , "plain/text" )
2013-04-22 16:17:47 +00:00
}
2013-06-18 18:59:56 +00:00
dial , err := net . Dial ( cli . proto , cli . addr )
if err != nil {
return nil , - 1 , err
}
clientconn := httputil . NewClientConn ( dial , nil )
resp , err := clientconn . Do ( req )
defer clientconn . Close ( )
2013-05-02 03:07:06 +00:00
if err != nil {
2013-05-09 18:24:49 +00:00
if strings . Contains ( err . Error ( ) , "connection refused" ) {
return nil , - 1 , fmt . Errorf ( "Can't connect to docker daemon. Is 'docker -d' running on this host?" )
}
2013-05-02 03:07:06 +00:00
return nil , - 1 , err
}
defer resp . Body . Close ( )
body , err := ioutil . ReadAll ( resp . Body )
if err != nil {
return nil , - 1 , err
}
2013-05-09 19:42:29 +00:00
if resp . StatusCode < 200 || resp . StatusCode >= 400 {
2013-06-10 15:06:52 +00:00
if len ( body ) == 0 {
return nil , resp . StatusCode , fmt . Errorf ( "Error: %s" , http . StatusText ( resp . StatusCode ) )
}
return nil , resp . StatusCode , fmt . Errorf ( "Error: %s" , body )
2013-02-14 01:10:00 +00:00
}
2013-05-02 03:07:06 +00:00
return body , resp . StatusCode , nil
}
2013-04-22 18:16:32 +00:00
2013-05-16 19:09:06 +00:00
func ( cli * DockerCli ) stream ( method , path string , in io . Reader , out io . Writer ) error {
if ( method == "POST" || method == "PUT" ) && in == nil {
in = bytes . NewReader ( [ ] byte { } )
}
2013-06-18 18:59:56 +00:00
req , err := http . NewRequest ( method , fmt . Sprintf ( "/v%g%s" , APIVERSION , path ) , in )
2013-05-09 21:28:03 +00:00
if err != nil {
return err
}
req . Header . Set ( "User-Agent" , "Docker-Client/" + VERSION )
if method == "POST" {
req . Header . Set ( "Content-Type" , "plain/text" )
}
2013-06-18 18:59:56 +00:00
dial , err := net . Dial ( cli . proto , cli . addr )
if err != nil {
return err
}
clientconn := httputil . NewClientConn ( dial , nil )
resp , err := clientconn . Do ( req )
defer clientconn . Close ( )
2013-05-09 21:28:03 +00:00
if err != nil {
if strings . Contains ( err . Error ( ) , "connection refused" ) {
return fmt . Errorf ( "Can't connect to docker daemon. Is 'docker -d' running on this host?" )
}
return err
}
defer resp . Body . Close ( )
2013-06-21 01:18:36 +00:00
2013-05-13 09:38:13 +00:00
if resp . StatusCode < 200 || resp . StatusCode >= 400 {
body , err := ioutil . ReadAll ( resp . Body )
if err != nil {
return err
}
2013-06-10 15:06:52 +00:00
if len ( body ) == 0 {
return fmt . Errorf ( "Error :%s" , http . StatusText ( resp . StatusCode ) )
}
return fmt . Errorf ( "Error: %s" , body )
2013-05-13 09:38:13 +00:00
}
2013-05-23 15:16:35 +00:00
if resp . Header . Get ( "Content-Type" ) == "application/json" {
dec := json . NewDecoder ( resp . Body )
for {
2013-06-04 18:00:22 +00:00
var m utils . JSONMessage
2013-05-23 15:16:35 +00:00
if err := dec . Decode ( & m ) ; err == io . EOF {
break
} else if err != nil {
return err
}
2013-05-24 14:43:52 +00:00
if m . Progress != "" {
2013-06-04 16:09:08 +00:00
fmt . Fprintf ( out , "%s %s\r" , m . Status , m . Progress )
2013-05-25 14:12:02 +00:00
} else if m . Error != "" {
return fmt . Errorf ( m . Error )
2013-05-24 14:43:52 +00:00
} else {
2013-05-23 15:16:35 +00:00
fmt . Fprintf ( out , "%s\n" , m . Status )
}
}
} else {
if _ , err := io . Copy ( out , resp . Body ) ; err != nil {
return err
}
2013-04-22 18:16:32 +00:00
}
2013-04-02 19:21:35 +00:00
return nil
2013-02-14 01:10:00 +00:00
}
2013-06-24 21:59:37 +00:00
func ( cli * DockerCli ) hijack ( method , path string , setRawTerminal bool , in io . ReadCloser , out io . Writer ) error {
2013-06-21 01:18:36 +00:00
2013-06-04 18:00:22 +00:00
req , err := http . NewRequest ( method , fmt . Sprintf ( "/v%g%s" , APIVERSION , path ) , nil )
2013-05-02 03:07:06 +00:00
if err != nil {
return err
2013-03-21 09:04:10 +00:00
}
2013-06-21 01:18:36 +00:00
req . Header . Set ( "User-Agent" , "Docker-Client/" + VERSION )
2013-05-07 17:23:50 +00:00
req . Header . Set ( "Content-Type" , "plain/text" )
2013-06-21 01:18:36 +00:00
2013-06-18 18:59:56 +00:00
dial , err := net . Dial ( cli . proto , cli . addr )
2013-02-14 01:10:00 +00:00
if err != nil {
2013-04-23 16:20:53 +00:00
return err
2013-04-22 16:17:47 +00:00
}
2013-04-23 16:20:53 +00:00
clientconn := httputil . NewClientConn ( dial , nil )
defer clientconn . Close ( )
2013-06-21 01:18:36 +00:00
// Server hijacks the connection, error 'connection closed' expected
clientconn . Do ( req )
2013-05-06 09:31:22 +00:00
rwc , br := clientconn . Hijack ( )
2013-04-23 16:20:53 +00:00
defer rwc . Close ( )
2013-05-14 22:37:35 +00:00
receiveStdout := utils . Go ( func ( ) error {
2013-05-29 11:40:54 +00:00
_ , err := io . Copy ( out , br )
2013-05-06 09:31:22 +00:00
return err
} )
2013-06-24 21:59:37 +00:00
if in != nil && setRawTerminal && cli . isTerminal && os . Getenv ( "NORAW" ) == "" {
oldState , err := term . SetRawTerminal ( cli . terminalFd )
2013-06-04 13:51:12 +00:00
if err != nil {
2013-04-29 13:12:18 +00:00
return err
}
2013-06-24 21:59:37 +00:00
defer term . RestoreTerminal ( cli . terminalFd , oldState )
2013-02-14 01:10:00 +00:00
}
2013-06-25 01:22:02 +00:00
2013-05-14 22:37:35 +00:00
sendStdin := utils . Go ( func ( ) error {
2013-06-24 21:59:37 +00:00
if in != nil {
io . Copy ( rwc , in )
}
2013-06-27 12:57:19 +00:00
if tcpc , ok := rwc . ( * net . TCPConn ) ; ok {
if err := tcpc . CloseWrite ( ) ; err != nil {
utils . Debugf ( "Couldn't send EOF: %s\n" , err )
}
} else if unixc , ok := rwc . ( * net . UnixConn ) ; ok {
if err := unixc . CloseWrite ( ) ; err != nil {
utils . Debugf ( "Couldn't send EOF: %s\n" , err )
}
2013-05-07 20:15:21 +00:00
}
2013-06-13 19:57:35 +00:00
// Discard errors due to pipe interruption
return nil
2013-04-23 16:20:53 +00:00
} )
if err := <- receiveStdout ; err != nil {
2013-06-13 19:57:35 +00:00
utils . Debugf ( "Error receiveStdout: %s" , err )
2013-04-23 16:20:53 +00:00
return err
2013-02-14 01:10:00 +00:00
}
2013-05-10 05:28:52 +00:00
2013-06-24 21:59:37 +00:00
if ! cli . isTerminal {
2013-04-23 16:20:53 +00:00
if err := <- sendStdin ; err != nil {
2013-06-13 19:57:35 +00:00
utils . Debugf ( "Error sendStdin: %s" , err )
2013-04-23 16:20:53 +00:00
return err
}
}
return nil
2013-02-14 01:10:00 +00:00
}
2013-07-08 17:20:13 +00:00
func ( cli * DockerCli ) getTtySize ( ) ( int , int ) {
2013-06-24 21:59:37 +00:00
if ! cli . isTerminal {
2013-07-08 17:20:13 +00:00
return 0 , 0
2013-06-24 21:59:37 +00:00
}
ws , err := term . GetWinsize ( cli . terminalFd )
2013-05-24 21:44:16 +00:00
if err != nil {
utils . Debugf ( "Error getting size: %s" , err )
2013-07-08 18:19:12 +00:00
if ws == nil {
return 0 , 0
}
2013-05-24 21:44:16 +00:00
}
2013-07-08 17:20:13 +00:00
return int ( ws . Height ) , int ( ws . Width )
}
func ( cli * DockerCli ) resizeTty ( id string ) {
height , width := cli . getTtySize ( )
if height == 0 && width == 0 {
return
}
2013-05-24 21:44:16 +00:00
v := url . Values { }
2013-07-08 17:20:13 +00:00
v . Set ( "h" , strconv . Itoa ( height ) )
v . Set ( "w" , strconv . Itoa ( width ) )
2013-05-24 21:44:16 +00:00
if _ , _ , err := cli . call ( "POST" , "/containers/" + id + "/resize?" + v . Encode ( ) , nil ) ; err != nil {
utils . Debugf ( "Error resize: %s" , err )
}
}
2013-06-24 21:59:37 +00:00
func ( cli * DockerCli ) monitorTtySize ( id string ) error {
if ! cli . isTerminal {
return fmt . Errorf ( "Impossible to monitor size on non-tty" )
}
2013-05-24 21:44:16 +00:00
cli . resizeTty ( id )
c := make ( chan os . Signal , 1 )
signal . Notify ( c , syscall . SIGWINCH )
go func ( ) {
for sig := range c {
if sig == syscall . SIGWINCH {
cli . resizeTty ( id )
}
}
} ( )
2013-06-24 21:59:37 +00:00
return nil
2013-05-24 21:44:16 +00:00
}
2013-04-22 16:17:47 +00:00
func Subcmd ( name , signature , description string ) * flag . FlagSet {
flags := flag . NewFlagSet ( name , flag . ContinueOnError )
flags . Usage = func ( ) {
2013-06-24 21:15:52 +00:00
// FIXME: use custom stdout or return error
fmt . Fprintf ( os . Stdout , "\nUsage: docker %s %s\n\n%s\n\n" , name , signature , description )
2013-04-22 16:17:47 +00:00
flags . PrintDefaults ( )
}
return flags
2013-02-14 01:10:00 +00:00
}
2013-05-13 09:48:27 +00:00
2013-06-24 21:15:52 +00:00
func NewDockerCli ( in io . ReadCloser , out , err io . Writer , proto , addr string ) * DockerCli {
2013-06-24 21:59:37 +00:00
var (
2013-07-02 22:27:22 +00:00
isTerminal = false
2013-06-24 21:59:37 +00:00
terminalFd uintptr
)
if in != nil {
if file , ok := in . ( * os . File ) ; ok {
terminalFd = file . Fd ( )
isTerminal = term . IsTerminal ( terminalFd )
}
}
if err == nil {
err = out
}
2013-05-30 15:39:43 +00:00
authConfig , _ := auth . LoadConfig ( os . Getenv ( "HOME" ) )
2013-06-24 21:15:52 +00:00
return & DockerCli {
proto : proto ,
addr : addr ,
authConfig : authConfig ,
in : in ,
out : out ,
err : err ,
2013-06-24 21:59:37 +00:00
isTerminal : isTerminal ,
terminalFd : terminalFd ,
2013-06-24 21:15:52 +00:00
}
2013-05-13 09:48:27 +00:00
}
2013-05-15 14:16:46 +00:00
type DockerCli struct {
2013-06-18 18:59:56 +00:00
proto string
addr string
2013-05-30 15:39:43 +00:00
authConfig * auth . AuthConfig
2013-06-24 21:15:52 +00:00
in io . ReadCloser
out io . Writer
err io . Writer
2013-06-24 21:59:37 +00:00
isTerminal bool
terminalFd uintptr
2013-05-13 09:48:27 +00:00
}