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-08-03 23:43:20 +00:00
"bufio"
2013-02-14 01:28:13 +00:00
"bytes"
2013-09-03 18:45:49 +00:00
"encoding/base64"
2013-02-14 01:28:13 +00:00
"encoding/json"
2013-09-20 18:31:00 +00:00
"errors"
2013-04-22 16:17:47 +00:00
"flag"
2013-02-14 01:10:00 +00:00
"fmt"
2013-10-31 23:57:45 +00:00
"github.com/dotcloud/docker/archive"
2013-03-15 00:43:59 +00:00
"github.com/dotcloud/docker/auth"
2013-12-08 07:41:53 +00:00
"github.com/dotcloud/docker/engine"
2013-09-03 18:45:49 +00:00
"github.com/dotcloud/docker/registry"
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-11-21 01:41:25 +00:00
"path"
2013-05-13 09:48:27 +00:00
"reflect"
2013-10-17 23:22:14 +00:00
"regexp"
2013-08-19 12:05:47 +00:00
"runtime"
2013-08-27 22:20:35 +00:00
"sort"
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"
2013-11-27 23:07:15 +00:00
"text/template"
2013-02-14 01:28:13 +00:00
"time"
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-08-26 15:45:52 +00:00
VERSION string
2013-04-11 19:58:23 +00:00
)
2013-04-01 18:12:56 +00:00
2013-09-20 18:31:00 +00:00
var (
ErrConnectionRefused = errors . New ( "Can't connect to docker daemon. Is 'docker -d' running on this host?" )
)
2013-09-23 00:06:31 +00:00
func ( cli * DockerCli ) getMethod ( name string ) ( func ( ... string ) error , bool ) {
2013-05-23 16:32:39 +00:00
methodName := "Cmd" + strings . ToUpper ( name [ : 1 ] ) + strings . ToLower ( name [ 1 : ] )
2013-09-23 00:06:31 +00:00
method := reflect . ValueOf ( cli ) . MethodByName ( methodName )
if ! method . IsValid ( ) {
return nil , false
}
return method . Interface ( ) . ( func ( ... string ) error ) , true
2013-05-23 16:32:39 +00:00
}
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-09-23 00:06:31 +00:00
return method ( args [ 1 : ] ... )
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 {
2013-09-23 00:06:31 +00:00
method ( "--help" )
2013-05-23 16:32:39 +00:00
return nil
}
}
2013-08-21 09:08:32 +00:00
help := fmt . Sprintf ( "Usage: docker [OPTIONS] COMMAND [arg...]\n -H=[unix://%s]: 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" , DEFAULTUNIXSOCKET )
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" } ,
2013-07-17 04:07:41 +00:00
{ "cp" , "Copy files/folders from the containers filesystem to the host path" } ,
2013-05-30 14:08:26 +00:00
{ "diff" , "Inspect changes on a container's filesystem" } ,
2013-07-10 12:55:05 +00:00
{ "events" , "Get real time events from the server" } ,
2013-05-30 14:08:26 +00:00
{ "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" } ,
2013-09-02 16:06:17 +00:00
{ "load" , "Load an image from a tar archive" } ,
2013-05-30 14:08:26 +00:00
{ "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" } ,
2013-07-17 17:46:11 +00:00
{ "rm" , "Remove one or more containers" } ,
{ "rmi" , "Remove one or more images" } ,
2013-05-30 14:08:26 +00:00
{ "run" , "Run a command in a new container" } ,
2013-09-02 16:06:17 +00:00
{ "save" , "Save an image to a tar archive" } ,
2013-05-30 14:08:26 +00:00
{ "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" } ,
2013-10-20 06:15:36 +00:00
{ "top" , "Lookup the running processes of a container" } ,
2013-05-30 14:08:26 +00:00
{ "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-11-21 01:41:25 +00:00
cmd := cli . 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-09-20 08:55:17 +00:00
return cli . stream ( "POST" , "/images/" + cmd . Arg ( 0 ) + "/insert?" + v . Encode ( ) , nil , cli . out , nil )
2013-04-24 20:37:00 +00:00
}
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-11-14 06:08:08 +00:00
func MkBuildContext ( dockerfile string , files [ ] [ 2 ] string ) ( archive . 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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "build" , "[OPTIONS] PATH | URL | -" , "Build a new container image from the source code at PATH" )
2013-07-31 15:32:08 +00:00
tag := cmd . String ( "t" , "" , "Repository name (and optionally a tag) to be applied to the resulting image in case of success" )
2013-07-12 00:12:25 +00:00
suppressOutput := cmd . Bool ( "q" , false , "Suppress verbose build output" )
2013-08-02 16:18:54 +00:00
noCache := cmd . Bool ( "no-cache" , false , "Do not use cache when building the image" )
2013-09-10 18:39:47 +00:00
rm := cmd . Bool ( "rm" , false , "Remove intermediate containers after a successful build" )
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-10-31 23:57:45 +00:00
context archive . Archive
2013-06-21 05:02:36 +00:00
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-11-14 06:08:08 +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 {
2013-09-03 18:45:49 +00:00
if _ , err := os . Stat ( cmd . Arg ( 0 ) ) ; err != nil {
2013-07-22 14:52:05 +00:00
return err
}
2013-12-02 05:52:45 +00:00
filename := path . Join ( cmd . Arg ( 0 ) , "Dockerfile" )
if _ , err = os . Stat ( filename ) ; os . IsNotExist ( err ) {
return fmt . Errorf ( "no Dockerfile found in %s" , cmd . Arg ( 0 ) )
}
2013-10-31 23:57:45 +00:00
context , err = archive . Tar ( cmd . Arg ( 0 ) , archive . 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
2013-08-12 17:53:06 +00:00
// FIXME: ProgressReader shouldn't be this annoying to use
2013-06-21 05:02:36 +00:00
if context != nil {
sf := utils . NewStreamFormatter ( false )
2013-11-28 20:16:57 +00:00
body = utils . ProgressReader ( ioutil . NopCloser ( context ) , 0 , cli . err , sf , true , "" , "Uploading context" )
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-07-12 00:12:25 +00:00
if * suppressOutput {
v . Set ( "q" , "1" )
}
2013-06-06 23:09:46 +00:00
if isRemote {
v . Set ( "remote" , cmd . Arg ( 0 ) )
}
2013-08-02 16:18:54 +00:00
if * noCache {
v . Set ( "nocache" , "1" )
}
2013-09-10 18:39:47 +00:00
if * rm {
v . Set ( "rm" , "1" )
}
2013-10-12 12:14:52 +00:00
headers := http . Header ( make ( map [ string ] [ ] string ) )
2013-06-21 05:02:36 +00:00
if context != nil {
2013-10-12 12:14:52 +00:00
headers . Set ( "Content-Type" , "application/tar" )
2013-06-18 18:59:56 +00:00
}
2013-10-12 12:14:52 +00:00
err = cli . stream ( "POST" , fmt . Sprintf ( "/build?%s" , v . Encode ( ) ) , body , cli . out , headers )
if jerr , ok := err . ( * utils . JSONError ) ; ok {
return & utils . StatusError { Status : jerr . Message , StatusCode : jerr . Code }
2013-05-23 03:07:26 +00:00
}
2013-10-12 12:14:52 +00:00
return err
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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "login" , "[OPTIONS] [SERVER]" , "Register or Login to a docker registry server, if no server is specified \"" + auth . IndexServerAddress ( ) + "\" is the default." )
2013-08-03 23:43:20 +00:00
2013-08-18 05:28:05 +00:00
var username , password , email string
cmd . StringVar ( & username , "u" , "" , "username" )
cmd . StringVar ( & password , "p" , "" , "password" )
cmd . StringVar ( & email , "e" , "" , "email" )
2013-06-22 00:37:02 +00:00
err := cmd . Parse ( args )
2013-05-06 11:34:31 +00:00
if err != nil {
2013-03-15 14:49:27 +00:00
return nil
2013-05-06 11:34:31 +00:00
}
2013-09-03 18:45:49 +00:00
serverAddress := auth . IndexServerAddress ( )
if len ( cmd . Args ( ) ) > 0 {
serverAddress , err = registry . ExpandAndVerifyRegistryUrl ( cmd . Arg ( 0 ) )
if err != nil {
return err
}
fmt . Fprintf ( cli . out , "Login against server at %s\n" , serverAddress )
}
2013-04-03 19:25:19 +00:00
2013-08-03 23:43:20 +00:00
promptDefault := func ( prompt string , configDefault string ) {
2013-07-27 17:00:36 +00:00
if configDefault == "" {
fmt . Fprintf ( cli . out , "%s: " , prompt )
} else {
fmt . Fprintf ( cli . out , "%s (%s): " , prompt , configDefault )
}
}
2013-08-04 00:27:15 +00:00
readInput := func ( in io . Reader , out io . Writer ) string {
2013-08-03 23:43:20 +00:00
reader := bufio . NewReader ( in )
2013-09-01 23:12:07 +00:00
line , _ , err := reader . ReadLine ( )
2013-08-03 23:43:20 +00:00
if err != nil {
2013-08-04 00:27:15 +00:00
fmt . Fprintln ( out , err . Error ( ) )
os . Exit ( 1 )
2013-08-03 23:43:20 +00:00
}
2013-09-01 23:12:07 +00:00
return string ( line )
2013-08-03 23:43:20 +00:00
}
2013-09-01 23:12:07 +00:00
cli . LoadConfigFile ( )
2013-10-08 04:46:29 +00:00
authconfig , ok := cli . configFile . Configs [ serverAddress ]
2013-07-23 15:04:31 +00:00
if ! ok {
authconfig = auth . AuthConfig { }
}
2013-08-03 23:43:20 +00:00
if username == "" {
2013-07-27 17:17:57 +00:00
promptDefault ( "Username" , authconfig . Username )
2013-08-04 00:27:15 +00:00
username = readInput ( cli . in , cli . out )
2013-06-21 10:00:25 +00:00
if username == "" {
2013-07-23 15:04:31 +00:00
username = authconfig . Username
2013-06-21 10:00:25 +00:00
}
2013-03-15 00:43:59 +00:00
}
2013-07-23 15:04:31 +00:00
if username != authconfig . Username {
2013-08-03 23:43:20 +00:00
if password == "" {
oldState , _ := term . SaveState ( cli . terminalFd )
2013-07-01 12:31:16 +00:00
fmt . Fprintf ( cli . out , "Password: " )
2013-08-18 04:29:37 +00:00
term . DisableEcho ( cli . terminalFd , oldState )
2013-08-04 00:27:15 +00:00
password = readInput ( cli . in , cli . out )
2013-08-04 04:30:07 +00:00
fmt . Fprint ( cli . out , "\n" )
2013-08-03 23:43:20 +00:00
term . RestoreTerminal ( cli . terminalFd , oldState )
2013-06-21 10:00:25 +00:00
if password == "" {
return fmt . Errorf ( "Error : Password Required" )
}
2013-03-15 14:49:27 +00:00
}
2013-08-03 23:43:20 +00:00
if email == "" {
2013-07-27 17:17:57 +00:00
promptDefault ( "Email" , authconfig . Email )
2013-08-04 00:27:15 +00:00
email = readInput ( cli . in , cli . out )
2013-06-21 10:00:25 +00:00
if email == "" {
2013-07-23 15:04:31 +00:00
email = authconfig . Email
2013-06-21 10:00:25 +00:00
}
2013-03-15 00:43:59 +00:00
}
} else {
2013-07-23 15:04:31 +00:00
password = authconfig . Password
email = authconfig . Email
2013-03-15 00:43:59 +00:00
}
2013-07-23 15:04:31 +00:00
authconfig . Username = username
authconfig . Password = password
authconfig . Email = email
2013-09-03 18:45:49 +00:00
authconfig . ServerAddress = serverAddress
cli . configFile . Configs [ serverAddress ] = authconfig
2013-05-06 11:34:31 +00:00
2013-09-03 18:45:49 +00:00
body , statusCode , err := cli . call ( "POST" , "/auth" , cli . configFile . Configs [ serverAddress ] )
2013-06-14 13:38:51 +00:00
if statusCode == 401 {
2013-09-03 18:45:49 +00:00
delete ( cli . configFile . Configs , serverAddress )
2013-07-23 15:04:31 +00:00
auth . SaveConfig ( cli . configFile )
2013-06-14 13:38:51 +00:00
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-07-23 15:04:31 +00:00
cli . configFile , _ = auth . LoadConfig ( os . Getenv ( "HOME" ) )
2013-05-06 11:34:31 +00:00
return err
2013-03-15 00:43:59 +00:00
}
2013-07-23 15:04:31 +00:00
auth . SaveConfig ( cli . configFile )
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-11-21 01:41:25 +00:00
cmd := cli . 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
}
2013-11-11 22:44:51 +00:00
var encounteredError error
2013-02-26 19:43:54 +00:00
for _ , name := range cmd . Args ( ) {
2013-09-05 23:54:03 +00:00
status , err := waitForExit ( cli , name )
2013-04-24 12:01:40 +00:00
if err != nil {
2013-11-11 22:44:51 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
encounteredError = fmt . Errorf ( "Error: failed to wait one or more containers" )
2013-02-26 19:43:54 +00:00
} else {
2013-09-05 23:54:03 +00:00
fmt . Fprintf ( cli . out , "%d\n" , status )
2013-02-26 19:43:54 +00:00
}
}
2013-11-11 22:44:51 +00:00
return encounteredError
2013-02-26 19:43:54 +00:00
}
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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "version" , "" , "Show the docker version information." )
2013-04-22 16:17:47 +00:00
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-08-30 00:46:43 +00:00
if VERSION != "" {
fmt . Fprintf ( cli . out , "Client version: %s\n" , VERSION )
}
2013-08-19 12:05:47 +00:00
fmt . Fprintf ( cli . out , "Go version (client): %s\n" , runtime . Version ( ) )
if GITCOMMIT != "" {
fmt . Fprintf ( cli . out , "Git commit (client): %s\n" , GITCOMMIT )
}
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-12-08 07:41:53 +00:00
out := engine . NewOutput ( )
remoteVersion , err := out . AddEnv ( )
2013-04-22 16:17:47 +00:00
if err != nil {
2013-12-08 07:41:53 +00:00
utils . Errorf ( "Error reading remote version: %s\n" , err )
2013-04-22 16:17:47 +00:00
return err
}
2013-12-08 07:41:53 +00:00
if _ , err := out . Write ( body ) ; err != nil {
utils . Errorf ( "Error reading remote version: %s\n" , err )
return err
2013-04-11 19:58:23 +00:00
}
2013-12-08 07:41:53 +00:00
out . Close ( )
fmt . Fprintf ( cli . out , "Server version: %s\n" , remoteVersion . Get ( "Version" ) )
fmt . Fprintf ( cli . out , "Git commit (server): %s\n" , remoteVersion . Get ( "GitCommit" ) )
fmt . Fprintf ( cli . out , "Go version (server): %s\n" , remoteVersion . Get ( "GoVersion" ) )
2013-07-03 17:11:00 +00:00
release := utils . GetReleaseVersion ( )
if release != "" {
fmt . Fprintf ( cli . out , "Last stable version: %s" , release )
2013-12-08 07:41:53 +00:00
if ( VERSION != "" || remoteVersion . Exists ( "Version" ) ) && ( strings . Trim ( VERSION , "-dev" ) != release || strings . Trim ( remoteVersion . Get ( "Version" ) , "-dev" ) != release ) {
2013-07-03 17:11:00 +00:00
fmt . Fprintf ( cli . out , ", please update docker" )
}
fmt . Fprintf ( cli . out , "\n" )
}
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-11-21 01:41:25 +00:00
cmd := cli . 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-11-15 09:24:48 +00:00
fmt . Fprintf ( cli . out , "Driver: %s\n" , out . Driver )
2013-11-15 10:04:02 +00:00
for _ , pair := range out . DriverStatus {
fmt . Fprintf ( cli . out , " %s: %s\n" , pair [ 0 ] , pair [ 1 ] )
}
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-07-19 16:36:23 +00:00
fmt . Fprintf ( cli . out , "LXC Version: %s\n" , out . LXCVersion )
2013-07-10 12:55:05 +00:00
fmt . Fprintf ( cli . out , "EventsListeners: %d\n" , out . NEventsListener )
2013-07-24 13:35:38 +00:00
fmt . Fprintf ( cli . out , "Kernel Version: %s\n" , out . KernelVersion )
2013-05-31 22:53:57 +00:00
}
2013-07-22 20:09:11 +00:00
2013-07-22 18:42:31 +00:00
if len ( out . IndexServerAddress ) != 0 {
2013-08-16 14:29:40 +00:00
cli . LoadConfigFile ( )
2013-07-22 18:42:31 +00:00
u := cli . configFile . Configs [ out . IndexServerAddress ] . Username
if len ( u ) > 0 {
fmt . Fprintf ( cli . out , "Username: %v\n" , u )
fmt . Fprintf ( cli . out , "Registry: %v\n" , out . IndexServerAddress )
}
2013-07-01 23:05:05 +00:00
}
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-08-03 22:06:58 +00:00
if ! out . IPv4Forwarding {
fmt . Fprintf ( cli . err , "WARNING: IPv4 forwarding is disabled.\n" )
}
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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "stop" , "[OPTIONS] CONTAINER [CONTAINER...]" , "Stop a running container (Send SIGTERM, and then SIGKILL after grace period)" )
2013-07-21 23:00:18 +00:00
nSeconds := cmd . Int ( "t" , 10 , "Number of seconds to wait for the container to stop before killing it." )
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-11-11 22:44:51 +00:00
var encounteredError error
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-11-11 22:44:51 +00:00
encounteredError = fmt . Errorf ( "Error: failed to stop one or more containers" )
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
}
}
2013-11-11 22:44:51 +00:00
return encounteredError
2013-02-14 21:49:05 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdRestart ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "restart" , "[OPTIONS] CONTAINER [CONTAINER...]" , "Restart a running container" )
2013-07-17 17:46:11 +00:00
nSeconds := cmd . Int ( "t" , 10 , "Number of seconds to try to stop for before killing the container. Once killed it will then be restarted. Default=10" )
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-11-11 22:44:51 +00:00
var encounteredError error
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-11-11 22:44:51 +00:00
encounteredError = fmt . Errorf ( "Error: failed to restart one or more containers" )
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
}
}
2013-11-11 22:44:51 +00:00
return encounteredError
2013-02-14 21:49:05 +00:00
}
2013-10-29 18:59:08 +00:00
func ( cli * DockerCli ) forwardAllSignals ( cid string ) chan os . Signal {
2013-10-08 19:15:29 +00:00
sigc := make ( chan os . Signal , 1 )
utils . CatchAll ( sigc )
go func ( ) {
for s := range sigc {
2013-11-12 15:06:54 +00:00
if s == syscall . SIGCHLD {
continue
}
2013-10-08 19:15:29 +00:00
if _ , _ , err := cli . call ( "POST" , fmt . Sprintf ( "/containers/%s/kill?signal=%d" , cid , s ) , nil ) ; err != nil {
utils . Debugf ( "Error sending signal: %s" , err )
}
}
} ( )
2013-10-29 18:59:08 +00:00
return sigc
2013-10-08 19:15:29 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdStart ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "start" , "CONTAINER [CONTAINER...]" , "Restart a stopped container" )
2013-09-12 06:50:26 +00:00
attach := cmd . Bool ( "a" , false , "Attach container's stdout/stderr and forward all signals to the process" )
openStdin := cmd . Bool ( "i" , false , "Attach container's stdin" )
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-09-12 06:50:26 +00:00
var cErr chan error
2013-11-20 17:27:43 +00:00
var tty bool
2013-09-12 06:50:26 +00:00
if * attach || * openStdin {
if cmd . NArg ( ) > 1 {
return fmt . Errorf ( "Impossible to start and attach multiple containers at once." )
}
body , _ , err := cli . call ( "GET" , "/containers/" + cmd . Arg ( 0 ) + "/json" , nil )
if err != nil {
return err
}
container := & Container { }
err = json . Unmarshal ( body , container )
if err != nil {
return err
}
2013-11-20 17:27:43 +00:00
tty = container . Config . Tty
2013-09-12 06:50:26 +00:00
if ! container . Config . Tty {
2013-10-29 18:59:08 +00:00
sigc := cli . forwardAllSignals ( cmd . Arg ( 0 ) )
defer utils . StopCatch ( sigc )
2013-09-12 06:50:26 +00:00
}
2013-10-26 00:17:33 +00:00
var in io . ReadCloser
2013-09-12 06:50:26 +00:00
v := url . Values { }
v . Set ( "stream" , "1" )
if * openStdin && container . Config . OpenStdin {
v . Set ( "stdin" , "1" )
2013-10-26 00:17:33 +00:00
in = cli . in
2013-09-12 06:50:26 +00:00
}
v . Set ( "stdout" , "1" )
v . Set ( "stderr" , "1" )
cErr = utils . Go ( func ( ) error {
2013-10-26 00:17:33 +00:00
return cli . hijack ( "POST" , "/containers/" + cmd . Arg ( 0 ) + "/attach?" + v . Encode ( ) , container . Config . Tty , in , cli . out , cli . err , nil )
2013-09-12 06:50:26 +00:00
} )
}
2013-08-23 15:59:11 +00:00
var encounteredError error
2013-09-12 06:50:26 +00:00
for _ , name := range cmd . 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-09-12 06:50:26 +00:00
if ! * attach || ! * openStdin {
fmt . Fprintf ( cli . err , "%s\n" , err )
encounteredError = fmt . Errorf ( "Error: failed to start one or more containers" )
}
2013-02-14 21:49:05 +00:00
} else {
2013-09-12 06:50:26 +00:00
if ! * attach || ! * openStdin {
fmt . Fprintf ( cli . out , "%s\n" , name )
}
2013-02-14 01:10:00 +00:00
}
}
2013-09-12 06:50:26 +00:00
if encounteredError != nil {
if * openStdin || * attach {
cli . in . Close ( )
<- cErr
}
return encounteredError
}
2013-11-20 17:27:43 +00:00
2013-09-12 06:50:26 +00:00
if * openStdin || * attach {
2013-11-20 17:27:43 +00:00
if tty && cli . isTerminal {
if err := cli . monitorTtySize ( cmd . Arg ( 0 ) ) ; err != nil {
utils . Errorf ( "Error monitoring TTY size: %s\n" , err )
}
}
2013-09-12 06:50:26 +00:00
return <- cErr
}
return nil
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdInspect ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "inspect" , "CONTAINER|IMAGE [CONTAINER|IMAGE...]" , "Return low-level information on a container/image" )
2013-11-27 23:07:15 +00:00
tmplStr := cmd . String ( "format" , "" , "Format the output using the given go template." )
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-10-17 23:40:43 +00:00
2013-11-27 23:07:15 +00:00
var tmpl * template . Template
if * tmplStr != "" {
var err error
if tmpl , err = template . New ( "" ) . Parse ( * tmplStr ) ; err != nil {
fmt . Fprintf ( cli . err , "Template parsing error: %v\n" , err )
return & utils . StatusError { StatusCode : 64 ,
Status : "Template parsing error: " + err . Error ( ) }
}
}
2013-10-17 23:40:43 +00:00
indented := new ( bytes . Buffer )
2013-11-27 23:07:15 +00:00
indented . WriteByte ( '[' )
2013-10-17 23:45:18 +00:00
status := 0
2013-10-17 23:40:43 +00:00
2013-11-27 23:07:15 +00:00
for _ , name := range cmd . Args ( ) {
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-11-01 01:44:16 +00:00
if strings . Contains ( err . Error ( ) , "No such" ) {
fmt . Fprintf ( cli . err , "Error: No such image or container: %s\n" , name )
} else {
fmt . Fprintf ( cli . err , "%s" , err )
}
2013-10-17 23:45:18 +00:00
status = 1
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-11-27 23:07:15 +00:00
if tmpl == nil {
if err = json . Indent ( indented , obj , "" , " " ) ; err != nil {
fmt . Fprintf ( cli . err , "%s\n" , err )
status = 1
continue
}
} else {
// Has template, will render
var value interface { }
if err := json . Unmarshal ( obj , & value ) ; err != nil {
fmt . Fprintf ( cli . err , "%s\n" , err )
status = 1
continue
}
if err := tmpl . Execute ( cli . out , value ) ; err != nil {
return err
}
cli . out . Write ( [ ] byte { '\n' } )
2013-06-06 15:22:54 +00:00
}
2013-10-17 23:40:43 +00:00
indented . WriteString ( "," )
}
2013-11-27 23:07:15 +00:00
if indented . Len ( ) > 1 {
2013-11-01 01:44:16 +00:00
// Remove trailing ','
2013-11-01 01:39:44 +00:00
indented . Truncate ( indented . Len ( ) - 1 )
}
2013-11-27 23:07:15 +00:00
indented . WriteByte ( ']' )
if tmpl == nil {
if _ , err := io . Copy ( cli . out , indented ) ; err != nil {
return err
}
2013-02-14 01:10:00 +00:00
}
2013-11-27 23:07:15 +00:00
2013-10-17 23:45:18 +00:00
if status != 0 {
2013-10-12 12:14:52 +00:00
return & utils . StatusError { StatusCode : status }
2013-10-17 23:45:18 +00:00
}
2013-02-14 01:10:00 +00:00
return nil
}
2013-07-01 15:19:42 +00:00
func ( cli * DockerCli ) CmdTop ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "top" , "CONTAINER [ps OPTIONS]" , "Lookup the running processes of a container" )
2013-06-28 15:51:58 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-07-19 10:06:32 +00:00
if cmd . NArg ( ) == 0 {
2013-06-28 15:51:58 +00:00
cmd . Usage ( )
return nil
}
2013-07-19 10:06:32 +00:00
val := url . Values { }
if cmd . NArg ( ) > 1 {
val . Set ( "ps_args" , strings . Join ( cmd . Args ( ) [ 1 : ] , " " ) )
}
body , _ , err := cli . call ( "GET" , "/containers/" + cmd . Arg ( 0 ) + "/top?" + val . Encode ( ) , nil )
2013-06-28 15:51:58 +00:00
if err != nil {
return err
}
2013-07-19 10:06:32 +00:00
procs := APITop { }
2013-06-28 15:51:58 +00:00
err = json . Unmarshal ( body , & procs )
if err != nil {
return err
}
w := tabwriter . NewWriter ( cli . out , 20 , 1 , 3 , ' ' , 0 )
2013-07-19 10:06:32 +00:00
fmt . Fprintln ( w , strings . Join ( procs . Titles , "\t" ) )
for _ , proc := range procs . Processes {
fmt . Fprintln ( w , strings . Join ( proc , "\t" ) )
2013-06-28 15:51:58 +00:00
}
w . Flush ( )
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdPort ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . 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-07-11 18:30:08 +00:00
port := cmd . Arg ( 1 )
2013-10-23 23:41:59 +00:00
proto := "tcp"
2013-07-11 18:30:08 +00:00
parts := strings . SplitN ( port , "/" , 2 )
if len ( parts ) == 2 && len ( parts [ 1 ] ) != 0 {
port = parts [ 0 ]
2013-10-23 23:41:59 +00:00
proto = parts [ 1 ]
2013-07-11 18:30:08 +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
2013-11-30 00:45:20 +00:00
if frontends , exists := out . NetworkSettings . Ports [ Port ( port + "/" + proto ) ] ; exists && frontends != nil {
for _ , frontend := range frontends {
fmt . Fprintf ( cli . out , "%s:%s\n" , frontend . HostIp , frontend . HostPort )
2013-10-23 23:41:59 +00:00
}
2013-03-06 08:39:03 +00:00
} else {
2013-11-30 00:45:20 +00:00
return fmt . Errorf ( "Error: No public port '%s' published for %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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "rmi" , "IMAGE [IMAGE...]" , "Remove one or more images" )
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-11-11 22:44:51 +00:00
var encounteredError error
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-11-11 22:44:51 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
encounteredError = fmt . Errorf ( "Error: failed to remove one or more images" )
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 {
2013-11-11 22:44:51 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
encounteredError = fmt . Errorf ( "Error: failed to remove one or more images" )
continue
2013-05-31 14:37:02 +00:00
}
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
}
}
2013-11-11 22:44:51 +00:00
return encounteredError
2013-03-13 18:14:37 +00:00
}
2013-02-14 01:10:00 +00:00
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdHistory ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "history" , "[OPTIONS] IMAGE" , "Show the history of an image" )
2013-10-18 23:39:40 +00:00
quiet := cmd . Bool ( "q" , false , "only show numeric IDs" )
noTrunc := cmd . Bool ( "notrunc" , false , "Don't truncate output" )
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-10-18 23:39:40 +00:00
2013-06-24 21:15:52 +00:00
w := tabwriter . NewWriter ( cli . out , 20 , 1 , 3 , ' ' , 0 )
2013-10-18 23:39:40 +00:00
if ! * quiet {
2013-10-22 12:22:24 +00:00
fmt . Fprintln ( w , "IMAGE\tCREATED\tCREATED BY\tSIZE" )
2013-10-18 23:39:40 +00:00
}
2013-04-22 16:17:47 +00:00
for _ , out := range outs {
2013-10-18 23:39:40 +00:00
if ! * quiet {
if * noTrunc {
fmt . Fprintf ( w , "%s\t" , out . ID )
} else {
fmt . Fprintf ( w , "%s\t" , utils . TruncateID ( out . ID ) )
}
2013-11-22 00:41:41 +00:00
fmt . Fprintf ( w , "%s ago\t" , utils . HumanDuration ( time . Now ( ) . UTC ( ) . Sub ( time . Unix ( out . Created , 0 ) ) ) )
2013-10-18 23:39:40 +00:00
if * noTrunc {
fmt . Fprintf ( w , "%s\t" , out . CreatedBy )
} else {
fmt . Fprintf ( w , "%s\t" , utils . Trunc ( out . CreatedBy , 45 ) )
}
fmt . Fprintf ( w , "%s\n" , utils . HumanSize ( out . Size ) )
} else {
if * noTrunc {
fmt . Fprintln ( w , out . ID )
} else {
fmt . Fprintln ( w , utils . TruncateID ( out . ID ) )
}
2013-06-18 17:31:07 +00:00
}
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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "rm" , "[OPTIONS] CONTAINER [CONTAINER...]" , "Remove one or more containers" )
2013-04-12 16:23:57 +00:00
v := cmd . Bool ( "v" , false , "Remove the volumes associated to the container" )
2013-10-05 02:25:15 +00:00
link := cmd . Bool ( "link" , false , "Remove the specified link and not the underlying 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" )
}
2013-10-05 02:25:15 +00:00
if * link {
val . Set ( "link" , "1" )
}
2013-11-11 22:44:51 +00:00
var encounteredError error
2013-05-06 09:52:15 +00:00
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-11-11 22:44:51 +00:00
encounteredError = fmt . Errorf ( "Error: failed to remove one or more containers" )
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-11-11 22:44:51 +00:00
return encounteredError
2013-02-14 01:10:00 +00:00
}
// 'docker kill NAME' kills a running container
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdKill ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "kill" , "CONTAINER [CONTAINER...]" , "Kill a running container (send SIGKILL)" )
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
2013-11-11 22:44:51 +00:00
var encounteredError error
2013-04-22 16:17:47 +00:00
for _ , name := range args {
2013-11-11 17:15:51 +00:00
if _ , _ , err := cli . call ( "POST" , "/containers/" + name + "/kill" , nil ) ; err != nil {
2013-06-25 17:39:11 +00:00
fmt . Fprintf ( cli . err , "%s\n" , err )
2013-11-11 22:44:51 +00:00
encounteredError = fmt . Errorf ( "Error: failed to kill one or more containers" )
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
}
}
2013-11-11 22:44:51 +00:00
return encounteredError
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdImport ( args ... string ) error {
2013-11-16 10:49:42 +00:00
cmd := cli . Subcmd ( "import" , "URL|- [REPOSITORY[:TAG]]" , "Create an empty filesystem image and import the contents of the tarball (.tar, .tar.gz, .tgz, .bzip, .tar.xz, .txz) into it, then optionally tag it." )
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-11-08 01:30:51 +00:00
var src , repository , tag string
if cmd . NArg ( ) == 3 {
fmt . Fprintf ( cli . err , "[DEPRECATED] The format 'URL|- [REPOSITORY [TAG]]' as been deprecated. Please use URL|- [REPOSITORY[:TAG]]\n" )
src , repository , tag = cmd . Arg ( 0 ) , cmd . Arg ( 1 ) , cmd . Arg ( 2 )
} else {
src = cmd . Arg ( 0 )
repository , tag = utils . ParseRepositoryTag ( cmd . Arg ( 1 ) )
}
2013-04-30 15:04:31 +00:00
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-09-16 01:40:29 +00:00
var in io . Reader
if src == "-" {
in = cli . in
2013-02-14 01:10:00 +00:00
}
2013-09-16 01:40:29 +00:00
return cli . stream ( "POST" , "/images/create?" + v . Encode ( ) , in , cli . out , nil )
2013-02-14 01:10:00 +00:00
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdPush ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "push" , "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-08-16 14:29:40 +00:00
cli . LoadConfigFile ( )
2013-09-03 18:45:49 +00:00
// Resolve the Repository name from fqn to endpoint + name
endpoint , _ , err := registry . ResolveRepositoryName ( name )
if err != nil {
return err
}
// Resolve the Auth config relevant for this server
authConfig := cli . configFile . ResolveAuthConfig ( endpoint )
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.
2013-05-06 11:34:31 +00:00
if len ( strings . SplitN ( name , "/" , 2 ) ) == 1 {
2013-08-16 14:29:40 +00:00
username := cli . configFile . Configs [ auth . IndexServerAddress ( ) ] . Username
if username == "" {
username = "<user>"
}
return fmt . Errorf ( "Impossible to push a \"root\" repository. Please rename your repository in <user>/<repo> (ex: %s/%s)" , username , name )
2013-03-22 13:38:54 +00:00
}
2013-07-24 03:01:24 +00:00
v := url . Values { }
2013-09-03 18:45:49 +00:00
push := func ( authConfig auth . AuthConfig ) error {
buf , err := json . Marshal ( authConfig )
2013-07-24 03:01:24 +00:00
if err != nil {
return err
}
2013-08-30 19:46:19 +00:00
registryAuthHeader := [ ] string {
2013-08-30 20:49:37 +00:00
base64 . URLEncoding . EncodeToString ( buf ) ,
2013-08-30 19:46:19 +00:00
}
2013-07-24 03:01:24 +00:00
2013-08-30 19:46:19 +00:00
return cli . stream ( "POST" , "/images/" + name + "/push?" + v . Encode ( ) , nil , cli . out , map [ string ] [ ] string {
"X-Registry-Auth" : registryAuthHeader ,
} )
2013-03-22 13:38:54 +00:00
}
2013-09-03 18:45:49 +00:00
if err := push ( authConfig ) ; err != nil {
if err . Error ( ) == registry . ErrLoginRequired . Error ( ) {
2013-08-13 13:51:49 +00:00
fmt . Fprintln ( cli . out , "\nPlease login prior to push:" )
2013-09-03 18:45:49 +00:00
if err := cli . CmdLogin ( endpoint ) ; err != nil {
2013-08-13 13:51:49 +00:00
return err
2013-07-24 03:01:24 +00:00
}
2013-09-03 18:45:49 +00:00
authConfig := cli . configFile . ResolveAuthConfig ( endpoint )
return push ( authConfig )
2013-07-24 03:01:24 +00:00
}
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-11-21 01:41:25 +00:00
cmd := cli . 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-12 17:42:54 +00:00
if * tag == "" {
* tag = parsedTag
}
2013-04-30 13:55:24 +00:00
2013-09-03 18:45:49 +00:00
// Resolve the Repository name from fqn to endpoint + name
endpoint , _ , err := registry . ResolveRepositoryName ( remote )
if err != nil {
return err
}
cli . LoadConfigFile ( )
// Resolve the Auth config relevant for this server
authConfig := cli . configFile . ResolveAuthConfig ( endpoint )
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-09-03 18:45:49 +00:00
pull := func ( authConfig auth . AuthConfig ) error {
buf , err := json . Marshal ( authConfig )
if err != nil {
return err
}
2013-08-30 19:46:19 +00:00
registryAuthHeader := [ ] string {
2013-08-30 20:49:37 +00:00
base64 . URLEncoding . EncodeToString ( buf ) ,
2013-08-30 19:46:19 +00:00
}
2013-09-03 18:45:49 +00:00
2013-08-30 19:46:19 +00:00
return cli . stream ( "POST" , "/images/create?" + v . Encode ( ) , nil , cli . out , map [ string ] [ ] string {
"X-Registry-Auth" : registryAuthHeader ,
} )
2013-09-03 18:45:49 +00:00
}
if err := pull ( authConfig ) ; err != nil {
if err . Error ( ) == registry . ErrLoginRequired . Error ( ) {
fmt . Fprintln ( cli . out , "\nPlease login prior to push:" )
if err := cli . CmdLogin ( endpoint ) ; err != nil {
return err
}
authConfig := cli . configFile . ResolveAuthConfig ( endpoint )
return pull ( authConfig )
}
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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "images" , "[OPTIONS] [NAME]" , "List images" )
2013-02-14 01:10:00 +00:00
quiet := cmd . Bool ( "q" , false , "only show numeric IDs" )
2013-11-16 10:45:30 +00:00
all := cmd . Bool ( "a" , false , "show all images (by default filter out the intermediate images used to build)" )
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-10-09 14:38:39 +00:00
flTree := cmd . Bool ( "tree" , false , "output graph in tree 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
2013-12-09 18:43:58 +00:00
filter := cmd . Arg ( 0 )
2013-10-08 13:41:44 +00:00
2013-12-09 18:43:58 +00:00
if * flViz || * flTree {
2013-10-09 14:38:39 +00:00
body , _ , err := cli . call ( "GET" , "/images/json?all=1" , nil )
if err != nil {
return err
}
var outs [ ] APIImages
2013-11-12 20:25:35 +00:00
if err := json . Unmarshal ( body , & outs ) ; err != nil {
2013-10-09 14:38:39 +00:00
return err
}
2013-11-12 20:25:35 +00:00
var (
2013-12-09 18:43:58 +00:00
printNode func ( cli * DockerCli , noTrunc bool , image APIImages , prefix string )
startImage APIImages
2013-11-12 20:25:35 +00:00
roots [ ] APIImages
byParent = make ( map [ string ] [ ] APIImages )
)
2013-10-09 14:38:39 +00:00
for _ , image := range outs {
if image . ParentId == "" {
roots = append ( roots , image )
} else {
if children , exists := byParent [ image . ParentId ] ; exists {
byParent [ image . ParentId ] = append ( children , image )
} else {
byParent [ image . ParentId ] = [ ] APIImages { image }
}
}
2013-12-09 18:43:58 +00:00
if filter != "" {
if filter == image . ID || filter == utils . TruncateID ( image . ID ) {
2013-10-09 14:38:39 +00:00
startImage = image
}
for _ , repotag := range image . RepoTags {
2013-12-09 18:43:58 +00:00
if repotag == filter {
2013-10-09 14:38:39 +00:00
startImage = image
}
}
}
}
2013-12-09 18:43:58 +00:00
if * flViz {
fmt . Fprintf ( cli . out , "digraph docker {\n" )
printNode = ( * DockerCli ) . printVizNode
2013-10-09 14:38:39 +00:00
} else {
2013-12-09 18:43:58 +00:00
printNode = ( * DockerCli ) . printTreeNode
}
if startImage . ID != "" {
cli . WalkTree ( * noTrunc , & [ ] APIImages { startImage } , byParent , "" , printNode )
} else if filter == "" {
cli . WalkTree ( * noTrunc , & roots , byParent , "" , printNode )
}
if * flViz {
fmt . Fprintf ( cli . out , " base [style=invisible]\n}\n" )
2013-10-09 14:38:39 +00:00
}
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-12-09 18:43:58 +00:00
v . Set ( "filter" , filter )
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-12-05 22:03:23 +00:00
fmt . Fprintln ( w , "REPOSITORY\tTAG\tIMAGE ID\tCREATED\tVIRTUAL SIZE" )
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-10-06 05:44:04 +00:00
for _ , repotag := range out . RepoTags {
2013-05-13 10:18:55 +00:00
2013-11-11 21:54:17 +00:00
repo , tag := utils . ParseRepositoryTag ( repotag )
2013-10-17 18:40:38 +00:00
2013-10-06 05:44:04 +00:00
if ! * noTrunc {
out . ID = utils . TruncateID ( out . ID )
}
2013-10-17 18:40:38 +00:00
2013-10-06 05:44:04 +00:00
if ! * quiet {
2013-12-05 22:03:23 +00:00
fmt . Fprintf ( w , "%s\t%s\t%s\t%s ago\t%s\n" , repo , tag , out . ID , utils . HumanDuration ( time . Now ( ) . UTC ( ) . Sub ( time . Unix ( out . Created , 0 ) ) ) , utils . HumanSize ( out . VirtualSize ) )
2013-05-22 13:41:29 +00:00
} else {
2013-10-06 05:44:04 +00:00
fmt . Fprintln ( w , out . ID )
2013-05-22 13:41:29 +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-12-09 18:43:58 +00:00
func ( cli * DockerCli ) WalkTree ( noTrunc bool , images * [ ] APIImages , byParent map [ string ] [ ] APIImages , prefix string , printNode func ( cli * DockerCli , noTrunc bool , image APIImages , prefix string ) ) {
length := len ( * images )
if length > 1 {
for index , image := range * images {
2013-10-09 14:38:39 +00:00
if index + 1 == length {
2013-12-09 18:43:58 +00:00
printNode ( cli , noTrunc , image , prefix + "└─" )
2013-10-09 14:38:39 +00:00
if subimages , exists := byParent [ image . ID ] ; exists {
2013-12-09 18:43:58 +00:00
cli . WalkTree ( noTrunc , & subimages , byParent , prefix + " " , printNode )
2013-10-09 14:38:39 +00:00
}
} else {
2013-12-09 18:43:58 +00:00
printNode ( cli , noTrunc , image , prefix + "|─" )
2013-10-09 14:38:39 +00:00
if subimages , exists := byParent [ image . ID ] ; exists {
2013-12-09 18:43:58 +00:00
cli . WalkTree ( noTrunc , & subimages , byParent , prefix + "| " , printNode )
2013-10-09 14:38:39 +00:00
}
}
}
} else {
2013-12-09 18:43:58 +00:00
for _ , image := range * images {
printNode ( cli , noTrunc , image , prefix + "└─" )
2013-10-09 14:38:39 +00:00
if subimages , exists := byParent [ image . ID ] ; exists {
2013-12-09 18:43:58 +00:00
cli . WalkTree ( noTrunc , & subimages , byParent , prefix + " " , printNode )
2013-10-09 14:38:39 +00:00
}
}
}
}
2013-12-09 18:43:58 +00:00
func ( cli * DockerCli ) printVizNode ( noTrunc bool , image APIImages , prefix string ) {
var (
imageID string
parentID string
)
if noTrunc {
imageID = image . ID
parentID = image . ParentId
} else {
imageID = utils . TruncateID ( image . ID )
parentID = utils . TruncateID ( image . ParentId )
}
if image . ParentId == "" {
fmt . Fprintf ( cli . out , " base -> \"%s\" [style=invis]\n" , imageID )
} else {
fmt . Fprintf ( cli . out , " \"%s\" -> \"%s\"\n" , parentID , imageID )
}
if image . RepoTags [ 0 ] != "<none>:<none>" {
fmt . Fprintf ( cli . out , " \"%s\" [label=\"%s\\n%s\",shape=box,fillcolor=\"paleturquoise\",style=\"filled,rounded\"];\n" ,
imageID , imageID , strings . Join ( image . RepoTags , "\\n" ) )
}
}
func ( cli * DockerCli ) printTreeNode ( noTrunc bool , image APIImages , prefix string ) {
2013-10-09 14:38:39 +00:00
var imageID string
2013-12-09 18:43:58 +00:00
if noTrunc {
2013-10-09 14:38:39 +00:00
imageID = image . ID
} else {
imageID = utils . TruncateID ( image . ID )
}
2013-12-10 00:59:42 +00:00
fmt . Fprintf ( cli . out , "%s%s Virtual Size: %s" , prefix , imageID , utils . HumanSize ( image . VirtualSize ) )
2013-10-09 14:38:39 +00:00
if image . RepoTags [ 0 ] != "<none>:<none>" {
2013-11-11 21:54:17 +00:00
fmt . Fprintf ( cli . out , " Tags: %s\n" , strings . Join ( image . RepoTags , ", " ) )
2013-10-09 14:38:39 +00:00
} else {
2013-10-27 23:42:09 +00:00
fmt . Fprint ( cli . out , "\n" )
2013-10-09 14:38:39 +00:00
}
}
2013-08-27 22:20:35 +00:00
func displayablePorts ( ports [ ] APIPort ) string {
result := [ ] string { }
for _ , port := range ports {
2013-10-05 02:25:15 +00:00
if port . IP == "" {
result = append ( result , fmt . Sprintf ( "%d/%s" , port . PublicPort , port . Type ) )
2013-08-27 22:20:35 +00:00
} else {
2013-10-05 02:25:15 +00:00
result = append ( result , fmt . Sprintf ( "%s:%d->%d/%s" , port . IP , port . PublicPort , port . PrivatePort , port . Type ) )
2013-08-27 22:20:35 +00:00
}
}
sort . Strings ( result )
return strings . Join ( result , ", " )
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdPs ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . 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-10-22 12:22:24 +00:00
fmt . Fprint ( w , "CONTAINER ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tPORTS\tNAMES" )
2013-06-20 14:19:50 +00:00
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-10-17 18:40:38 +00:00
if ! * noTrunc {
out . ID = utils . TruncateID ( out . ID )
2013-10-05 02:25:15 +00:00
}
2013-10-28 23:58:59 +00:00
// Remove the leading / from the names
for i := 0 ; i < len ( out . Names ) ; i ++ {
out . Names [ i ] = out . Names [ i ] [ 1 : ]
}
2013-02-14 01:10:00 +00:00
if ! * quiet {
2013-10-17 18:40:38 +00:00
if ! * noTrunc {
out . Command = utils . Trunc ( out . Command , 20 )
2013-05-22 13:41:29 +00:00
}
2013-11-22 00:41:41 +00:00
fmt . Fprintf ( w , "%s\t%s\t%s\t%s ago\t%s\t%s\t%s\t" , out . ID , out . Image , out . Command , utils . HumanDuration ( time . Now ( ) . UTC ( ) . Sub ( time . Unix ( out . Created , 0 ) ) ) , out . Status , displayablePorts ( out . Ports ) , strings . Join ( out . Names , "," ) )
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-10-17 18:40:38 +00:00
fmt . Fprintln ( w , out . ID )
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-11-21 01:41:25 +00:00
cmd := cli . 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-11-16 11:11:34 +00:00
flConfig := cmd . String ( "run" , "" , "Config automatically applied when the image is run. " + ` (ex: -run=' { "Cmd": ["cat", "/world"], "PortSpecs": ["22"]}') ` )
2013-02-14 01:10:00 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
2013-11-08 01:30:51 +00:00
var name , repository , tag string
if cmd . NArg ( ) == 3 {
fmt . Fprintf ( cli . err , "[DEPRECATED] The format 'CONTAINER [REPOSITORY [TAG]]' as been deprecated. Please use CONTAINER [REPOSITORY[:TAG]]\n" )
name , repository , tag = cmd . Arg ( 0 ) , cmd . Arg ( 1 ) , cmd . Arg ( 2 )
} else {
name = cmd . Arg ( 0 )
repository , tag = utils . ParseRepositoryTag ( cmd . Arg ( 1 ) )
}
2013-10-30 06:26:13 +00:00
2013-04-24 14:06:03 +00:00
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-07-10 12:55:05 +00:00
func ( cli * DockerCli ) CmdEvents ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "events" , "[OPTIONS]" , "Get real time events from the server" )
2013-10-22 11:48:10 +00:00
since := cmd . String ( "since" , "" , "Show previously created events and then stream." )
2013-07-10 12:55:05 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 0 {
cmd . Usage ( )
return nil
}
2013-07-12 16:29:23 +00:00
v := url . Values { }
if * since != "" {
2013-10-22 11:48:10 +00:00
loc := time . FixedZone ( time . Now ( ) . Zone ( ) )
format := "2006-01-02 15:04:05 -0700 MST"
if len ( * since ) < len ( format ) {
format = format [ : len ( * since ) ]
}
if t , err := time . ParseInLocation ( format , * since , loc ) ; err == nil {
v . Set ( "since" , strconv . FormatInt ( t . Unix ( ) , 10 ) )
} else {
v . Set ( "since" , * since )
}
2013-07-12 16:29:23 +00:00
}
2013-08-30 19:46:19 +00:00
if err := cli . stream ( "GET" , "/events?" + v . Encode ( ) , nil , cli . out , nil ) ; err != nil {
2013-07-10 12:55:05 +00:00
return err
}
return nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdExport ( args ... string ) error {
2013-11-16 10:33:17 +00:00
cmd := cli . Subcmd ( "export" , "CONTAINER" , "Export the contents of a filesystem as a tar archive to STDOUT" )
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-08-30 19:46:19 +00:00
if err := cli . stream ( "GET" , "/containers/" + cmd . Arg ( 0 ) + "/export" , nil , cli . out , nil ) ; 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-11-21 01:41:25 +00:00
cmd := cli . 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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "logs" , "CONTAINER" , "Fetch the logs of a container" )
2013-12-03 20:35:22 +00:00
follow := cmd . Bool ( "f" , false , "Follow log output" )
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-10-17 23:22:14 +00:00
name := cmd . Arg ( 0 )
2013-11-01 00:58:15 +00:00
body , _ , err := cli . call ( "GET" , "/containers/" + name + "/json" , nil )
if err != nil {
return err
}
container := & Container { }
err = json . Unmarshal ( body , container )
if err != nil {
return err
}
2013-04-22 16:17:47 +00:00
2013-12-03 06:18:01 +00:00
v := url . Values { }
v . Set ( "logs" , "1" )
v . Set ( "stdout" , "1" )
v . Set ( "stderr" , "1" )
2013-12-03 20:35:22 +00:00
if * follow && container . State . Running {
2013-12-03 06:18:01 +00:00
v . Set ( "stream" , "1" )
}
if err := cli . hijack ( "POST" , "/containers/" + name + "/attach?" + v . Encode ( ) , container . Config . Tty , nil , cli . out , cli . err , nil ) ; 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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "attach" , "[OPTIONS] CONTAINER" , "Attach to a running container" )
2013-09-12 06:50:26 +00:00
noStdin := cmd . Bool ( "nostdin" , false , "Do not attach stdin" )
2013-10-29 01:23:41 +00:00
proxy := cmd . Bool ( "sig-proxy" , true , "Proxify all received signal to the process (even in non-tty mode)" )
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-10-05 02:25:15 +00:00
name := cmd . Arg ( 0 )
body , _ , err := cli . call ( "GET" , "/containers/" + name + "/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-11-21 20:21:03 +00:00
if ! container . State . IsRunning ( ) {
2013-06-17 22:40:04 +00:00
return fmt . Errorf ( "Impossible to attach to a stopped container, start it first" )
}
2013-10-24 21:54:04 +00:00
if container . Config . Tty && cli . isTerminal {
2013-06-24 21:59:37 +00:00
if err := cli . monitorTtySize ( cmd . Arg ( 0 ) ) ; err != nil {
2013-10-24 21:54:04 +00:00
utils . Debugf ( "Error monitoring TTY size: %s" , err )
2013-06-24 21:59:37 +00:00
}
2013-06-13 19:57:35 +00:00
}
2013-06-17 21:44:35 +00:00
2013-10-26 00:17:33 +00:00
var in io . ReadCloser
2013-05-02 03:07:06 +00:00
v := url . Values { }
v . Set ( "stream" , "1" )
2013-09-12 06:50:26 +00:00
if ! * noStdin && container . Config . OpenStdin {
v . Set ( "stdin" , "1" )
2013-10-26 00:17:33 +00:00
in = cli . in
2013-09-12 06:50:26 +00:00
}
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-09-12 06:50:26 +00:00
if * proxy && ! container . Config . Tty {
2013-10-29 18:59:08 +00:00
sigc := cli . forwardAllSignals ( cmd . Arg ( 0 ) )
defer utils . StopCatch ( sigc )
2013-09-12 06:50:26 +00:00
}
2013-10-26 00:17:33 +00:00
if err := cli . hijack ( "POST" , "/containers/" + cmd . Arg ( 0 ) + "/attach?" + v . Encode ( ) , container . Config . Tty , in , cli . out , cli . err , nil ) ; err != nil {
2013-06-17 21:44:35 +00:00
return err
2013-04-05 04:51:40 +00:00
}
2013-11-28 01:10:20 +00:00
_ , status , err := getExitCode ( cli , cmd . Arg ( 0 ) )
if err != nil {
return err
}
if status != 0 {
2013-10-12 12:14:52 +00:00
return & utils . StatusError { StatusCode : status }
2013-11-28 01:10:20 +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-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "search" , "TERM" , "Search the docker index for images" )
2013-07-08 17:20:13 +00:00
noTrunc := cmd . Bool ( "notrunc" , false , "Don't truncate output" )
2013-11-01 02:21:35 +00:00
trusted := cmd . Bool ( "trusted" , false , "Only show trusted builds" )
stars := cmd . Int ( "stars" , 0 , "Only displays with at least xxx stars" )
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-10-24 19:20:34 +00:00
outs := [ ] registry . SearchResult { }
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-10-24 19:20:34 +00:00
w := tabwriter . NewWriter ( cli . out , 10 , 1 , 3 , ' ' , 0 )
fmt . Fprintf ( w , "NAME\tDESCRIPTION\tSTARS\tOFFICIAL\tTRUSTED\n" )
2013-05-07 18:37:35 +00:00
for _ , out := range outs {
2013-11-01 02:21:35 +00:00
if ( * trusted && ! out . IsTrusted ) || ( * stars > out . StarCount ) {
continue
}
2013-06-07 13:09:24 +00:00
desc := strings . Replace ( out . Description , "\n" , " " , - 1 )
desc = strings . Replace ( desc , "\r" , " " , - 1 )
2013-11-04 23:34:51 +00:00
if ! * noTrunc && len ( desc ) > 45 {
desc = utils . Trunc ( desc , 42 ) + "..."
2013-06-07 13:09:24 +00:00
}
2013-10-24 19:20:34 +00:00
fmt . Fprintf ( w , "%s\t%s\t%d\t" , out . Name , desc , out . StarCount )
if out . IsOfficial {
fmt . Fprint ( w , "[OK]" )
}
fmt . Fprint ( w , "\t" )
if out . IsTrusted {
fmt . Fprint ( w , "[OK]" )
2013-06-07 13:09:24 +00:00
}
2013-10-24 19:20:34 +00:00
fmt . Fprint ( w , "\n" )
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-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdTag ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . 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
2013-11-08 01:30:51 +00:00
var repository , tag string
2013-10-30 06:26:13 +00:00
2013-11-08 01:30:51 +00:00
if cmd . NArg ( ) == 3 {
fmt . Fprintf ( cli . err , "[DEPRECATED] The format 'IMAGE [REPOSITORY [TAG]]' as been deprecated. Please use IMAGE [REPOSITORY[:TAG]]\n" )
repository , tag = cmd . Arg ( 1 ) , cmd . Arg ( 2 )
} else {
repository , tag = utils . ParseRepositoryTag ( cmd . Arg ( 1 ) )
}
v := url . Values { }
2013-10-30 06:26:13 +00:00
v . Set ( "repo" , repository )
v . Set ( "tag" , tag )
2013-04-23 16:20:53 +00:00
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-11-21 01:41:25 +00:00
//FIXME Only used in tests
func ParseRun ( args [ ] string , capabilities * Capabilities ) ( * Config , * HostConfig , * flag . FlagSet , error ) {
cmd := flag . NewFlagSet ( "run" , flag . ContinueOnError )
cmd . SetOutput ( ioutil . Discard )
cmd . Usage = nil
return parseRun ( cmd , args , capabilities )
}
func parseRun ( cmd * flag . FlagSet , args [ ] string , capabilities * Capabilities ) ( * Config , * HostConfig , * flag . FlagSet , error ) {
2013-11-22 18:12:27 +00:00
var (
// FIXME: use utils.ListOpts for attach and volumes?
2013-11-26 17:46:06 +00:00
flAttach = NewListOpts ( ValidateAttach )
flVolumes = NewListOpts ( ValidatePath )
flLinks = NewListOpts ( ValidateLink )
flEnv = NewListOpts ( ValidateEnv )
2013-11-22 18:12:27 +00:00
2013-11-26 17:46:06 +00:00
flPublish ListOpts
flExpose ListOpts
flDns ListOpts
flVolumesFrom ListOpts
flLxcOpts ListOpts
2013-11-22 18:12:27 +00:00
flAutoRemove = cmd . Bool ( "rm" , false , "Automatically remove the container when it exits (incompatible with -d)" )
flDetach = cmd . Bool ( "d" , false , "Detached mode: Run container in the background, print new container id" )
flNetwork = cmd . Bool ( "n" , true , "Enable networking for this container" )
flPrivileged = cmd . Bool ( "privileged" , false , "Give extended privileges to this container" )
flPublishAll = cmd . Bool ( "P" , false , "Publish all exposed ports to the host interfaces" )
flStdin = cmd . Bool ( "i" , false , "Keep stdin open even if not attached" )
flTty = cmd . Bool ( "t" , false , "Allocate a pseudo-tty" )
flContainerIDFile = cmd . String ( "cidfile" , "" , "Write the container ID to the file" )
flEntrypoint = cmd . String ( "entrypoint" , "" , "Overwrite the default entrypoint of the image" )
flHostname = cmd . String ( "h" , "" , "Container host name" )
flMemoryString = cmd . String ( "m" , "" , "Memory limit (format: <number><optional unit>, where unit = b, k, m or g)" )
flUser = cmd . String ( "u" , "" , "Username or UID" )
flWorkingDir = cmd . String ( "w" , "" , "Working directory inside the container" )
flCpuShares = cmd . Int64 ( "c" , 0 , "CPU shares (relative weight)" )
// For documentation purpose
_ = cmd . Bool ( "sig-proxy" , true , "Proxify all received signal to the process (even in non-tty mode)" )
_ = cmd . String ( "name" , "" , "Assign a name to the container" )
)
2013-11-21 01:41:25 +00:00
2013-11-26 17:46:06 +00:00
cmd . Var ( & flAttach , "a" , "Attach to stdin, stdout or stderr." )
cmd . Var ( & flVolumes , "v" , "Bind mount a volume (e.g. from the host: -v /host:/container, from docker: -v /container)" )
2013-11-26 08:05:46 +00:00
cmd . Var ( & flLinks , "link" , "Add link to another container (name:alias)" )
2013-11-26 17:46:06 +00:00
cmd . Var ( & flEnv , "e" , "Set environment variables" )
2013-11-21 01:41:25 +00:00
2013-11-22 18:36:49 +00:00
cmd . Var ( & flPublish , "p" , fmt . Sprintf ( "Publish a container's port to the host (format: %s) (use 'docker port' to see the actual mapping)" , PortSpecTemplateFormat ) )
2013-11-21 01:41:25 +00:00
cmd . Var ( & flExpose , "expose" , "Expose a port from the container without publishing it to your host" )
cmd . Var ( & flDns , "dns" , "Set custom dns servers" )
cmd . Var ( & flVolumesFrom , "volumes-from" , "Mount volumes from the specified container(s)" )
cmd . Var ( & flLxcOpts , "lxc-conf" , "Add custom lxc options -lxc-conf=\"lxc.cgroup.cpuset.cpus = 0,1\"" )
if err := cmd . Parse ( args ) ; err != nil {
return nil , nil , cmd , err
}
2013-11-22 18:12:27 +00:00
// Check if the kernel supports memory limit cgroup.
if capabilities != nil && * flMemoryString != "" && ! capabilities . MemoryLimit {
* flMemoryString = ""
}
// Validate input params
2013-11-26 17:46:06 +00:00
if * flDetach && flAttach . Len ( ) > 0 {
2013-11-21 01:41:25 +00:00
return nil , nil , cmd , ErrConflictAttachDetach
}
if * flWorkingDir != "" && ! path . IsAbs ( * flWorkingDir ) {
return nil , nil , cmd , ErrInvalidWorikingDirectory
}
if * flDetach && * flAutoRemove {
return nil , nil , cmd , ErrConflictDetachAutoRemove
}
// If neither -d or -a are set, attach to everything by default
2013-11-26 17:46:06 +00:00
if flAttach . Len ( ) == 0 && ! * flDetach {
2013-11-21 01:41:25 +00:00
if ! * flDetach {
flAttach . Set ( "stdout" )
flAttach . Set ( "stderr" )
if * flStdin {
flAttach . Set ( "stdin" )
}
}
}
var flMemory int64
if * flMemoryString != "" {
parsedMemory , err := utils . RAMInBytes ( * flMemoryString )
if err != nil {
return nil , nil , cmd , err
}
flMemory = parsedMemory
}
var binds [ ] string
// add any bind targets to the list of container volumes
2013-11-26 17:46:06 +00:00
for bind := range flVolumes . GetMap ( ) {
if arr := strings . Split ( bind , ":" ) ; len ( arr ) > 1 {
2013-11-21 01:41:25 +00:00
if arr [ 0 ] == "/" {
return nil , nil , cmd , fmt . Errorf ( "Invalid bind mount: source can't be '/'" )
}
dstDir := arr [ 1 ]
2013-11-26 17:46:06 +00:00
flVolumes . Set ( dstDir )
2013-11-21 01:41:25 +00:00
binds = append ( binds , bind )
2013-11-26 17:46:06 +00:00
flVolumes . Delete ( bind )
2013-11-21 01:41:25 +00:00
}
}
2013-11-22 18:12:27 +00:00
var (
parsedArgs = cmd . Args ( )
runCmd [ ] string
entrypoint [ ] string
image string
)
2013-11-21 01:41:25 +00:00
if len ( parsedArgs ) >= 1 {
image = cmd . Arg ( 0 )
}
if len ( parsedArgs ) > 1 {
runCmd = parsedArgs [ 1 : ]
}
if * flEntrypoint != "" {
entrypoint = [ ] string { * flEntrypoint }
}
lxcConf , err := parseLxcConfOpts ( flLxcOpts )
if err != nil {
return nil , nil , cmd , err
}
2013-11-22 18:12:27 +00:00
var (
domainname string
hostname = * flHostname
parts = strings . SplitN ( hostname , "." , 2 )
)
2013-11-21 01:41:25 +00:00
if len ( parts ) > 1 {
hostname = parts [ 0 ]
domainname = parts [ 1 ]
}
2013-11-26 17:46:06 +00:00
ports , portBindings , err := parsePortSpecs ( flPublish . GetAll ( ) )
2013-11-21 01:41:25 +00:00
if err != nil {
return nil , nil , cmd , err
}
// Merge in exposed ports to the map of published ports
2013-11-26 17:46:06 +00:00
for _ , e := range flExpose . GetAll ( ) {
2013-11-21 01:41:25 +00:00
if strings . Contains ( e , ":" ) {
return nil , nil , cmd , fmt . Errorf ( "Invalid port format for -expose: %s" , e )
}
p := NewPort ( splitProtoPort ( e ) )
if _ , exists := ports [ p ] ; ! exists {
ports [ p ] = struct { } { }
}
}
config := & Config {
Hostname : hostname ,
Domainname : domainname ,
PortSpecs : nil , // Deprecated
ExposedPorts : ports ,
User : * flUser ,
Tty : * flTty ,
NetworkDisabled : ! * flNetwork ,
OpenStdin : * flStdin ,
Memory : flMemory ,
CpuShares : * flCpuShares ,
2013-11-26 17:46:06 +00:00
AttachStdin : flAttach . Get ( "stdin" ) ,
AttachStdout : flAttach . Get ( "stdout" ) ,
AttachStderr : flAttach . Get ( "stderr" ) ,
Env : flEnv . GetAll ( ) ,
2013-11-21 01:41:25 +00:00
Cmd : runCmd ,
2013-11-26 17:46:06 +00:00
Dns : flDns . GetAll ( ) ,
2013-11-21 01:41:25 +00:00
Image : image ,
2013-11-26 17:46:06 +00:00
Volumes : flVolumes . GetMap ( ) ,
VolumesFrom : strings . Join ( flVolumesFrom . GetAll ( ) , "," ) ,
2013-11-21 01:41:25 +00:00
Entrypoint : entrypoint ,
WorkingDir : * flWorkingDir ,
}
hostConfig := & HostConfig {
Binds : binds ,
ContainerIDFile : * flContainerIDFile ,
LxcConf : lxcConf ,
Privileged : * flPrivileged ,
PortBindings : portBindings ,
2013-11-26 17:46:06 +00:00
Links : flLinks . GetAll ( ) ,
2013-11-21 01:41:25 +00:00
PublishAllPorts : * flPublishAll ,
}
if capabilities != nil && flMemory > 0 && ! capabilities . SwapLimit {
//fmt.Fprintf(stdout, "WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.\n")
config . MemorySwap = - 1
}
// When allocating stdin in attached mode, close stdin at client disconnect
if config . OpenStdin && config . AttachStdin {
config . StdinOnce = true
}
return config , hostConfig , cmd , nil
}
2013-05-15 14:16:46 +00:00
func ( cli * DockerCli ) CmdRun ( args ... string ) error {
2013-11-21 01:41:25 +00:00
config , hostConfig , cmd , err := parseRun ( cli . Subcmd ( "run" , "[OPTIONS] IMAGE [COMMAND] [ARG...]" , "Run a command in a new container" ) , 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-11-22 20:14:34 +00:00
// Retrieve relevant client-side config
var (
flName = cmd . Lookup ( "name" )
flRm = cmd . Lookup ( "rm" )
flSigProxy = cmd . Lookup ( "sig-proxy" )
autoRemove , _ = strconv . ParseBool ( flRm . Value . String ( ) )
sigProxy , _ = strconv . ParseBool ( flSigProxy . Value . String ( ) )
)
2013-09-26 21:52:37 +00:00
2013-11-22 20:14:34 +00:00
// Disable sigProxy in case on TTY
2013-10-29 01:23:41 +00:00
if config . Tty {
sigProxy = false
}
2013-10-08 19:15:29 +00:00
2013-11-22 20:14:34 +00:00
var containerIDFile io . WriteCloser
2013-07-11 22:11:44 +00:00
if len ( hostConfig . ContainerIDFile ) > 0 {
2013-11-22 20:14:34 +00:00
if _ , err := os . Stat ( hostConfig . ContainerIDFile ) ; err == nil {
2013-07-11 22:11:44 +00:00
return fmt . Errorf ( "cid file found, make sure the other container isn't running or delete %s" , hostConfig . ContainerIDFile )
}
2013-11-22 20:14:34 +00:00
if containerIDFile , err = os . Create ( hostConfig . ContainerIDFile ) ; err != nil {
2013-07-11 22:11:44 +00:00
return fmt . Errorf ( "failed to create the container ID file: %s" , err )
}
defer containerIDFile . Close ( )
}
2013-11-22 20:14:34 +00:00
2013-10-28 23:58:59 +00:00
containerValues := url . Values { }
2013-11-22 20:14:34 +00:00
if name := flName . Value . String ( ) ; name != "" {
2013-10-28 23:58:59 +00:00
containerValues . Set ( "name" , name )
}
2013-07-11 22:11:44 +00:00
2013-05-02 03:07:06 +00:00
//create the container
2013-10-28 23:58:59 +00:00
body , statusCode , err := cli . call ( "POST" , "/containers/create?" + containerValues . Encode ( ) , config )
2013-05-02 03:07:06 +00:00
//if image not found try to pull it
if statusCode == 404 {
2013-08-18 03:03:54 +00:00
_ , tag := utils . ParseRepositoryTag ( config . Image )
if tag == "" {
tag = DEFAULTTAG
}
2013-08-29 23:25:11 +00:00
fmt . Fprintf ( cli . err , "Unable to find image '%s' (tag: %s) locally\n" , config . Image , tag )
2013-08-18 03:03:54 +00:00
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-08-23 12:02:24 +00:00
// Resolve the Repository name from fqn to endpoint + name
2013-11-22 20:14:34 +00:00
endpoint , _ , err := registry . ResolveRepositoryName ( repos )
2013-08-23 12:02:24 +00:00
if err != nil {
return err
}
// Load the auth config file, to be able to pull the image
cli . LoadConfigFile ( )
// Resolve the Auth config relevant for this server
authConfig := cli . configFile . ResolveAuthConfig ( endpoint )
buf , err := json . Marshal ( authConfig )
if err != nil {
return err
}
2013-08-30 21:15:07 +00:00
registryAuthHeader := [ ] string {
base64 . URLEncoding . EncodeToString ( buf ) ,
}
2013-11-22 20:14:34 +00:00
if err = cli . stream ( "POST" , "/images/create?" + v . Encode ( ) , nil , cli . err , map [ string ] [ ] string { "X-Registry-Auth" : registryAuthHeader } ) ; err != nil {
2013-05-02 03:07:06 +00:00
return err
}
2013-11-22 20:14:34 +00:00
if body , _ , err = cli . call ( "POST" , "/containers/create?" + containerValues . Encode ( ) , config ) ; err != nil {
2013-05-06 09:31:22 +00:00
return err
}
2013-11-26 07:20:36 +00:00
} else 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-11-22 20:14:34 +00:00
var runResult APIRun
if err := json . Unmarshal ( body , & runResult ) ; 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-11-22 20:14:34 +00:00
2013-07-08 08:01:16 +00:00
if len ( hostConfig . ContainerIDFile ) > 0 {
2013-11-22 20:14:34 +00:00
if _ , err = containerIDFile . Write ( [ ] byte ( runResult . ID ) ) ; err != nil {
2013-07-08 08:01:16 +00:00
return fmt . Errorf ( "failed to write the container ID to the file: %s" , err )
}
}
2013-05-02 16:36:23 +00:00
2013-10-08 19:15:29 +00:00
if sigProxy {
2013-10-29 18:59:08 +00:00
sigc := cli . forwardAllSignals ( runResult . ID )
defer utils . StopCatch ( sigc )
2013-10-08 19:15:29 +00:00
}
2013-10-09 01:42:53 +00:00
var (
2013-11-22 20:14:34 +00:00
waitDisplayId chan struct { }
errCh chan error
2013-10-09 01:42:53 +00:00
)
2013-06-27 19:48:25 +00:00
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-11-22 20:14:34 +00:00
waitDisplayId = make ( chan struct { } )
2013-06-27 19:48:25 +00:00
go func ( ) {
2013-11-22 20:14:34 +00:00
defer close ( waitDisplayId )
2013-06-27 19:48:25 +00:00
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-11-22 22:09:37 +00:00
// We need to instanciate the chan because the select needs it. It can
// be closed but can't be uninitialized.
hijacked := make ( chan io . Closer )
2013-10-10 18:20:50 +00:00
2013-11-22 22:09:37 +00:00
// Block the return until the chan gets closed
defer func ( ) {
utils . Debugf ( "End of CmdRun(), Waiting for hijack to finish." )
if _ , ok := <- hijacked ; ok {
utils . Errorf ( "Hijack did not finish (chan still open)" )
}
} ( )
2013-05-29 11:40:54 +00:00
2013-06-24 19:12:06 +00:00
if config . AttachStdin || config . AttachStdout || config . AttachStderr {
2013-11-22 20:14:34 +00:00
var (
out , stderr io . Writer
in io . ReadCloser
v = url . Values { }
)
2013-05-29 11:40:54 +00:00
v . Set ( "stream" , "1" )
if config . AttachStdin {
v . Set ( "stdin" , "1" )
2013-10-26 00:17:33 +00:00
in = cli . in
2013-05-29 11:40:54 +00:00
}
if config . AttachStdout {
v . Set ( "stdout" , "1" )
2013-08-13 20:30:08 +00:00
out = cli . out
2013-05-29 11:40:54 +00:00
}
2013-06-17 22:45:08 +00:00
if config . AttachStderr {
2013-05-29 11:40:54 +00:00
v . Set ( "stderr" , "1" )
2013-09-10 01:14:23 +00:00
if config . Tty {
stderr = cli . out
} else {
stderr = cli . err
}
2013-05-29 11:40:54 +00:00
}
2013-06-25 01:22:02 +00:00
2013-10-09 01:42:53 +00:00
errCh = utils . Go ( func ( ) error {
2013-10-26 00:17:33 +00:00
return cli . hijack ( "POST" , "/containers/" + runResult . ID + "/attach?" + v . Encode ( ) , config . Tty , in , out , stderr , hijacked )
2013-10-09 01:42:53 +00:00
} )
2013-10-10 18:20:50 +00:00
} else {
close ( hijacked )
}
// Acknowledge the hijack before starting
select {
2013-11-22 22:09:37 +00:00
case closer := <- hijacked :
// Make sure that hijack gets closed when returning. (result
// in closing hijack chan and freeing server's goroutines.
if closer != nil {
defer closer . Close ( )
}
2013-10-10 18:20:50 +00:00
case err := <- errCh :
if err != nil {
utils . Debugf ( "Error hijack: %s" , err )
return err
}
2013-10-09 01:42:53 +00:00
}
//start the container
if _ , _ , err = cli . call ( "POST" , "/containers/" + runResult . ID + "/start" , hostConfig ) ; err != nil {
return err
}
2013-07-20 10:47:13 +00:00
2013-10-24 21:54:04 +00:00
if ( config . AttachStdin || config . AttachStdout || config . AttachStderr ) && config . Tty && cli . isTerminal {
2013-10-24 18:19:06 +00:00
if err := cli . monitorTtySize ( runResult . ID ) ; err != nil {
utils . Errorf ( "Error monitoring TTY size: %s\n" , err )
}
}
2013-10-09 01:42:53 +00:00
if errCh != nil {
if err := <- errCh ; 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
2013-11-22 20:14:34 +00:00
// Detached mode: wait for the id to be displayed and return.
2013-06-27 19:48:25 +00:00
if ! config . AttachStdout && ! config . AttachStderr {
2013-09-05 23:54:03 +00:00
// Detached mode
2013-11-22 20:14:34 +00:00
<- waitDisplayId
return nil
}
2013-11-22 19:23:48 +00:00
2013-11-22 20:14:34 +00:00
var status int
// Attached mode
if autoRemove {
// Autoremove: wait for the container to finish, retrieve
// the exit code and remove the container
if _ , _ , err := cli . call ( "POST" , "/containers/" + runResult . ID + "/wait" , nil ) ; err != nil {
2013-09-05 23:54:03 +00:00
return err
}
2013-11-22 20:14:34 +00:00
if _ , status , err = getExitCode ( cli , runResult . ID ) ; err != nil {
return err
2013-09-26 21:52:37 +00:00
}
2013-11-22 20:14:34 +00:00
if _ , _ , err := cli . call ( "DELETE" , "/containers/" + runResult . ID , nil ) ; err != nil {
return err
}
} else {
// No Autoremove: Simply retrieve the exit code
if _ , status , err = getExitCode ( cli , runResult . ID ) ; err != nil {
return err
2013-09-09 21:26:35 +00:00
}
2013-06-27 19:48:25 +00:00
}
2013-11-22 20:14:34 +00:00
if status != 0 {
2013-10-12 12:14:52 +00:00
return & utils . StatusError { StatusCode : status }
2013-11-22 20:14:34 +00:00
}
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-17 04:07:41 +00:00
func ( cli * DockerCli ) CmdCp ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "cp" , "CONTAINER:PATH HOSTPATH" , "Copy files/folders from the PATH to the HOSTPATH" )
2013-07-17 04:07:41 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return nil
}
if cmd . NArg ( ) != 2 {
cmd . Usage ( )
return nil
}
var copyData APICopy
info := strings . Split ( cmd . Arg ( 0 ) , ":" )
2013-08-24 23:28:36 +00:00
if len ( info ) != 2 {
2013-11-16 10:15:04 +00:00
return fmt . Errorf ( "Error: Path not specified" )
2013-08-24 23:28:36 +00:00
}
2013-07-17 04:07:41 +00:00
copyData . Resource = info [ 1 ]
copyData . HostPath = cmd . Arg ( 1 )
data , statusCode , err := cli . call ( "POST" , "/containers/" + info [ 0 ] + "/copy" , copyData )
if err != nil {
return err
}
if statusCode == 200 {
2013-07-17 14:25:49 +00:00
r := bytes . NewReader ( data )
2013-11-12 01:17:38 +00:00
if err := archive . Untar ( r , copyData . HostPath , nil ) ; err != nil {
2013-07-17 04:07:41 +00:00
return err
}
}
return nil
}
2013-09-02 16:06:17 +00:00
func ( cli * DockerCli ) CmdSave ( args ... string ) error {
2013-11-26 14:54:46 +00:00
cmd := cli . Subcmd ( "save" , "IMAGE" , "Save an image to a tar archive (streamed to stdout)" )
2013-09-02 16:06:17 +00:00
if err := cmd . Parse ( args ) ; err != nil {
2013-11-21 01:28:19 +00:00
return err
2013-09-02 16:06:17 +00:00
}
if cmd . NArg ( ) != 1 {
cmd . Usage ( )
return nil
}
image := cmd . Arg ( 0 )
if err := cli . stream ( "GET" , "/images/" + image + "/get" , nil , cli . out , nil ) ; err != nil {
return err
}
return nil
}
func ( cli * DockerCli ) CmdLoad ( args ... string ) error {
2013-11-21 01:41:25 +00:00
cmd := cli . Subcmd ( "load" , "SOURCE" , "Load an image from a tar archive" )
2013-11-21 01:28:19 +00:00
if err := cmd . Parse ( args ) ; err != nil {
return err
}
2013-09-02 16:06:17 +00:00
if cmd . NArg ( ) != 0 {
cmd . Usage ( )
return nil
}
2013-11-21 01:28:19 +00:00
if err := cli . stream ( "POST" , "/images/load" , cli . in , cli . out , nil ) ; err != nil {
return err
2013-09-02 16:06:17 +00:00
}
return nil
}
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-10-17 23:22:14 +00:00
// fixme: refactor client to support redirect
re := regexp . MustCompile ( "/+" )
path = re . ReplaceAllString ( path , "/" )
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-08-07 09:35:38 +00:00
req . Host = cli . addr
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 {
2013-08-15 13:44:11 +00:00
if strings . Contains ( err . Error ( ) , "connection refused" ) {
2013-09-20 18:31:00 +00:00
return nil , - 1 , ErrConnectionRefused
2013-08-15 13:44:11 +00:00
}
2013-06-18 18:59:56 +00:00
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" ) {
2013-09-20 18:31:00 +00:00
return nil , - 1 , ErrConnectionRefused
2013-05-09 18:24:49 +00:00
}
2013-05-02 03:07:06 +00:00
return nil , - 1 , err
}
defer resp . Body . Close ( )
2013-10-09 01:42:53 +00:00
2013-05-02 03:07:06 +00:00
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 ) )
}
2013-11-11 22:44:51 +00:00
return nil , resp . StatusCode , fmt . Errorf ( "Error: %s" , bytes . TrimSpace ( 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-08-30 19:46:19 +00:00
func ( cli * DockerCli ) stream ( method , path string , in io . Reader , out io . Writer , headers map [ string ] [ ] string ) error {
2013-05-16 19:09:06 +00:00
if ( method == "POST" || method == "PUT" ) && in == nil {
in = bytes . NewReader ( [ ] byte { } )
}
2013-10-17 23:22:14 +00:00
// fixme: refactor client to support redirect
re := regexp . MustCompile ( "/+" )
path = re . ReplaceAllString ( path , "/" )
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 )
2013-08-07 09:35:38 +00:00
req . Host = cli . addr
2013-05-09 21:28:03 +00:00
if method == "POST" {
req . Header . Set ( "Content-Type" , "plain/text" )
}
2013-08-30 19:46:19 +00:00
if headers != nil {
for k , v := range headers {
req . Header [ k ] = v
}
}
2013-06-18 18:59:56 +00:00
dial , err := net . Dial ( cli . proto , cli . addr )
if err != nil {
2013-08-15 13:44:11 +00:00
if strings . Contains ( err . Error ( ) , "connection refused" ) {
return fmt . Errorf ( "Can't connect to docker daemon. Is 'docker -d' running on this host?" )
}
2013-06-18 18:59:56 +00:00
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 ) )
}
2013-11-11 22:44:51 +00:00
return fmt . Errorf ( "Error: %s" , bytes . TrimSpace ( body ) )
2013-05-13 09:38:13 +00:00
}
2013-08-03 20:55:54 +00:00
if matchesContentType ( resp . Header . Get ( "Content-Type" ) , "application/json" ) {
2013-12-02 19:53:04 +00:00
return utils . DisplayJSONMessagesStream ( resp . Body , out , cli . terminalFd , cli . isTerminal )
2013-11-18 23:35:56 +00:00
}
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-11-22 22:09:37 +00:00
func ( cli * DockerCli ) hijack ( method , path string , setRawTerminal bool , in io . ReadCloser , stdout , stderr io . Writer , started chan io . Closer ) error {
defer func ( ) {
if started != nil {
close ( started )
}
} ( )
2013-10-17 23:22:14 +00:00
// fixme: refactor client to support redirect
re := regexp . MustCompile ( "/+" )
path = re . ReplaceAllString ( path , "/" )
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-08-07 09:35:38 +00:00
req . Host = cli . addr
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-08-15 13:44:11 +00:00
if strings . Contains ( err . Error ( ) , "connection refused" ) {
return fmt . Errorf ( "Can't connect to docker daemon. Is 'docker -d' running on this host?" )
}
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-10-10 18:20:50 +00:00
if started != nil {
2013-11-22 22:09:37 +00:00
started <- rwc
2013-10-10 18:20:50 +00:00
}
2013-09-10 01:14:23 +00:00
var receiveStdout chan error
2013-11-29 17:55:15 +00:00
var oldState * term . State
if in != nil && setRawTerminal && cli . isTerminal && os . Getenv ( "NORAW" ) == "" {
oldState , err = term . SetRawTerminal ( cli . terminalFd )
if err != nil {
return err
}
defer term . RestoreTerminal ( cli . terminalFd , oldState )
}
2013-12-05 01:08:14 +00:00
if stdout != nil || stderr != nil {
2013-09-10 01:14:23 +00:00
receiveStdout = utils . Go ( func ( ) ( err error ) {
2013-11-29 17:11:20 +00:00
defer func ( ) {
if in != nil {
2013-11-29 17:55:15 +00:00
if setRawTerminal && cli . isTerminal {
term . RestoreTerminal ( cli . terminalFd , oldState )
}
2013-11-29 17:11:20 +00:00
in . Close ( )
}
} ( )
2013-09-10 01:14:23 +00:00
// When TTY is ON, use regular copy
if setRawTerminal {
_ , err = io . Copy ( stdout , br )
} else {
_ , err = utils . StdCopy ( stdout , stderr , br )
}
2013-08-13 20:30:08 +00:00
utils . Debugf ( "[hijack] End of stdout" )
return err
} )
}
2013-05-06 09:31:22 +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-07-24 00:27:49 +00:00
utils . Debugf ( "[hijack] End of stdin" )
2013-06-24 21:59:37 +00:00
}
2013-06-27 12:57:19 +00:00
if tcpc , ok := rwc . ( * net . TCPConn ) ; ok {
if err := tcpc . CloseWrite ( ) ; err != nil {
2013-10-08 07:54:47 +00:00
utils . Errorf ( "Couldn't send EOF: %s\n" , err )
2013-06-27 12:57:19 +00:00
}
} else if unixc , ok := rwc . ( * net . UnixConn ) ; ok {
if err := unixc . CloseWrite ( ) ; err != nil {
2013-10-08 07:54:47 +00:00
utils . Errorf ( "Couldn't send EOF: %s\n" , err )
2013-06-27 12:57:19 +00:00
}
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
} )
2013-12-05 01:08:14 +00:00
if stdout != nil || stderr != nil {
2013-08-13 20:30:08 +00:00
if err := <- receiveStdout ; err != nil {
2013-10-08 07:54:47 +00:00
utils . Errorf ( "Error receiveStdout: %s" , err )
2013-08-13 20:30:08 +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-10-08 07:54:47 +00:00
utils . Errorf ( "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 {
2013-10-08 07:54:47 +00:00
utils . Errorf ( "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 {
2013-10-08 07:54:47 +00:00
utils . Errorf ( "Error resize: %s" , err )
2013-05-24 21:44:16 +00:00
}
}
2013-06-24 21:59:37 +00:00
func ( cli * DockerCli ) monitorTtySize ( id string ) error {
2013-05-24 21:44:16 +00:00
cli . resizeTty ( id )
2013-07-29 17:28:41 +00:00
sigchan := make ( chan os . Signal , 1 )
signal . Notify ( sigchan , syscall . SIGWINCH )
2013-05-24 21:44:16 +00:00
go func ( ) {
2013-08-10 00:42:20 +00:00
for _ = range sigchan {
2013-07-29 18:13:59 +00:00
cli . resizeTty ( id )
2013-05-24 21:44:16 +00:00
}
} ( )
2013-06-24 21:59:37 +00:00
return nil
2013-05-24 21:44:16 +00:00
}
2013-11-21 01:41:25 +00:00
func ( cli * DockerCli ) Subcmd ( name , signature , description string ) * flag . FlagSet {
2013-04-22 16:17:47 +00:00
flags := flag . NewFlagSet ( name , flag . ContinueOnError )
flags . Usage = func ( ) {
2013-11-21 01:41:25 +00:00
fmt . Fprintf ( cli . err , "\nUsage: docker %s %s\n\n%s\n\n" , name , signature , description )
2013-04-22 16:17:47 +00:00
flags . PrintDefaults ( )
2013-11-21 01:41:25 +00:00
os . Exit ( 2 )
2013-04-22 16:17:47 +00:00
}
return flags
2013-02-14 01:10:00 +00:00
}
2013-05-13 09:48:27 +00:00
2013-08-16 14:29:40 +00:00
func ( cli * DockerCli ) LoadConfigFile ( ) ( err error ) {
cli . configFile , err = auth . LoadConfig ( os . Getenv ( "HOME" ) )
if err != nil {
fmt . Fprintf ( cli . err , "WARNING: %s\n" , err )
}
return err
}
2013-09-05 23:54:03 +00:00
func waitForExit ( cli * DockerCli , containerId string ) ( int , error ) {
body , _ , err := cli . call ( "POST" , "/containers/" + containerId + "/wait" , nil )
if err != nil {
2013-09-20 18:31:00 +00:00
// If we can't connect, then the daemon probably died.
if err != ErrConnectionRefused {
return - 1 , err
}
return - 1 , nil
2013-09-05 23:54:03 +00:00
}
var out APIWait
if err := json . Unmarshal ( body , & out ) ; err != nil {
return - 1 , err
}
return out . StatusCode , nil
}
2013-10-09 21:38:52 +00:00
// getExitCode perform an inspect on the container. It returns
// the running state and the exit code.
func getExitCode ( cli * DockerCli , containerId string ) ( bool , int , error ) {
2013-09-20 18:31:00 +00:00
body , _ , err := cli . call ( "GET" , "/containers/" + containerId + "/json" , nil )
if err != nil {
// If we can't connect, then the daemon probably died.
if err != ErrConnectionRefused {
2013-10-09 21:38:52 +00:00
return false , - 1 , err
2013-09-20 18:31:00 +00:00
}
2013-10-09 21:38:52 +00:00
return false , - 1 , nil
2013-09-20 18:31:00 +00:00
}
c := & Container { }
if err := json . Unmarshal ( body , c ) ; err != nil {
2013-10-09 21:38:52 +00:00
return false , - 1 , err
2013-09-20 18:31:00 +00:00
}
2013-11-21 20:21:03 +00:00
return c . State . IsRunning ( ) , c . State . GetExitCode ( ) , nil
2013-09-20 18:31:00 +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-06-24 21:15:52 +00:00
return & DockerCli {
proto : proto ,
addr : addr ,
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-07-23 15:04:31 +00:00
configFile * auth . ConfigFile
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
}