docker
/
docs
mirror of https://github.com/docker/docs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Make DockerCli use its own stdin/out/err instead of the os.Std*

This commit is contained in:
Guillaume J. Charmes 2013-06-24 14:15:52 -07:00
parent 25d1bc2c09
commit a749fb2130
3 changed files with 98 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
commands.go
View File

@ -40,7 +40,7 @@ func (cli *DockerCli) getMethod(name string) (reflect.Method, bool) {
} }
func ParseCommands(proto, addr string, args ...string) error { func ParseCommands(proto, addr string, args ...string) error {
cli := NewDockerCli(proto, addr) cli := NewDockerCli(os.Stdin, os.Stdout, os.Stderr, proto, addr)
if len(args) > 0 { if len(args) > 0 {
method, exists := cli.getMethod(args[0]) method, exists := cli.getMethod(args[0])
@ -64,7 +64,7 @@ func (cli *DockerCli) CmdHelp(args ...string) error {
if len(args) > 0 { if len(args) > 0 {
method, exists := cli.getMethod(args[0]) method, exists := cli.getMethod(args[0])
if !exists { if !exists {
fmt.Println("Error: Command not found:", args[0]) fmt.Fprintf(cli.err, "Error: Command not found: %s\n", args[0])
} else { } else {
method.Func.CallSlice([]reflect.Value{ method.Func.CallSlice([]reflect.Value{
reflect.ValueOf(cli), reflect.ValueOf(cli),
@ -74,7 +74,7 @@ func (cli *DockerCli) CmdHelp(args ...string) error {
} }
} }
help := fmt.Sprintf("Usage: docker [OPTIONS] COMMAND [arg...]\n -H=[tcp://%s:%d]: tcp://host:port to bind/connect to or unix://path/to/socker to use\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n", DEFAULTHTTPHOST, DEFAULTHTTPPORT) help := fmt.Sprintf("Usage: docker [OPTIONS] COMMAND [arg...]\n -H=[tcp://%s:%d]: tcp://host:port to bind/connect to or unix://path/to/socker to use\n\nA self-sufficient runtime for linux containers.\n\nCommands:\n", DEFAULTHTTPHOST, DEFAULTHTTPPORT)
for _, command := range [][2]string{ for _, command := range [][]string{
{"attach", "Attach to a running container"}, {"attach", "Attach to a running container"},
{"build", "Build a container from a Dockerfile"}, {"build", "Build a container from a Dockerfile"},
{"commit", "Create a new image from a container's changes"}, {"commit", "Create a new image from a container's changes"},
@ -106,7 +106,7 @@ func (cli *DockerCli) CmdHelp(args ...string) error {
} { } {
help += fmt.Sprintf(" %-10.10s%s\n", command[0], command[1]) help += fmt.Sprintf(" %-10.10s%s\n", command[0], command[1])
} }
fmt.Println(help) fmt.Fprintf(cli.err, "%s\n", help)
return nil return nil
} }
@ -124,7 +124,7 @@ func (cli *DockerCli) CmdInsert(args ...string) error {
v.Set("url", cmd.Arg(1)) v.Set("url", cmd.Arg(1))
v.Set("path", cmd.Arg(2)) v.Set("path", cmd.Arg(2))
if err := cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, os.Stdout); err != nil { if err := cli.stream("POST", "/images/"+cmd.Arg(0)+"/insert?"+v.Encode(), nil, cli.out); err != nil {
return err return err
} }
return nil return nil
@ -175,7 +175,7 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
if cmd.Arg(0) == "-" { if cmd.Arg(0) == "-" {
// As a special case, 'docker build -' will build from an empty context with the // As a special case, 'docker build -' will build from an empty context with the
// contents of stdin as a Dockerfile // contents of stdin as a Dockerfile
dockerfile, err := ioutil.ReadAll(os.Stdin) dockerfile, err := ioutil.ReadAll(cli.in)
if err != nil { if err != nil {
return err return err
} }
@ -190,7 +190,7 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
// FIXME: ProgressReader shouldn't be this annoyning to use // FIXME: ProgressReader shouldn't be this annoyning to use
if context != nil { if context != nil {
sf := utils.NewStreamFormatter(false) sf := utils.NewStreamFormatter(false)
body = utils.ProgressReader(ioutil.NopCloser(context), 0, os.Stderr, sf.FormatProgress("Uploading context", "%v bytes%0.0s%0.0s"), sf) body = utils.ProgressReader(ioutil.NopCloser(context), 0, cli.err, sf.FormatProgress("Uploading context", "%v bytes%0.0s%0.0s"), sf)
} }
// Upload the build context // Upload the build context
v := &url.Values{} v := &url.Values{}
@ -229,7 +229,7 @@ func (cli *DockerCli) CmdBuild(args ...string) error {
} }
// Output the result // Output the result
if _, err := io.Copy(os.Stdout, resp.Body); err != nil { if _, err := io.Copy(cli.out, resp.Body); err != nil {
return err return err
} }
@ -291,25 +291,27 @@ func (cli *DockerCli) CmdLogin(args ...string) error {
return nil return nil
} }
var username string var (
var password string username string
var email string password string
email string
)
fmt.Print("Username (", cli.authConfig.Username, "): ") fmt.Fprintf(cli.out, "Username (%s):", cli.authConfig.Username)
username = readAndEchoString(os.Stdin, os.Stdout) username = readAndEchoString(cli.in, cli.out)
if username == "" { if username == "" {
username = cli.authConfig.Username username = cli.authConfig.Username
} }
if username != cli.authConfig.Username { if username != cli.authConfig.Username {
fmt.Print("Password: ") fmt.Fprintf(cli.out, "Password: ")
password = readString(os.Stdin, os.Stdout) password = readString(cli.in, cli.out)
if password == "" { if password == "" {
return fmt.Errorf("Error : Password Required") return fmt.Errorf("Error : Password Required")
} }
fmt.Print("Email (", cli.authConfig.Email, "): ") fmt.Fprintf(cli.out, "Email (%s): ", cli.authConfig.Email)
email = readAndEchoString(os.Stdin, os.Stdout) email = readAndEchoString(cli.in, cli.out)
if email == "" { if email == "" {
email = cli.authConfig.Email email = cli.authConfig.Email
} }
@ -343,7 +345,7 @@ func (cli *DockerCli) CmdLogin(args ...string) error {
} }
auth.SaveConfig(cli.authConfig) auth.SaveConfig(cli.authConfig)
if out2.Status != "" { if out2.Status != "" {
fmt.Println(out2.Status) fmt.Fprintln(cli.out, "%s\n", out2.Status)
} }
return nil return nil
} }
@ -361,14 +363,14 @@ func (cli *DockerCli) CmdWait(args ...string) error {
for _, name := range cmd.Args() { for _, name := range cmd.Args() {
body, _, err := cli.call("POST", "/containers/"+name+"/wait", nil) body, _, err := cli.call("POST", "/containers/"+name+"/wait", nil)
if err != nil { if err != nil {
fmt.Printf("%s", err) fmt.Fprintf(cli.err, "%s", err)
} else { } else {
var out APIWait var out APIWait
err = json.Unmarshal(body, &out) err = json.Unmarshal(body, &out)
if err != nil { if err != nil {
return err return err
} }
fmt.Println(out.StatusCode) fmt.Fprintf(cli.out, "%s\n", out.StatusCode)
} }
} }
return nil return nil
@ -397,13 +399,13 @@ func (cli *DockerCli) CmdVersion(args ...string) error {
utils.Debugf("Error unmarshal: body: %s, err: %s\n", body, err) utils.Debugf("Error unmarshal: body: %s, err: %s\n", body, err)
return err return err
} }
fmt.Println("Client version:", VERSION) fmt.Fprintf(cli.out, "Client version: %s\n", VERSION)
fmt.Println("Server version:", out.Version) fmt.Fprintf(cli.out, "Server version: %s\n", out.Version)
if out.GitCommit != "" { if out.GitCommit != "" {
fmt.Println("Git commit:", out.GitCommit) fmt.Fprintf(cli.out, "Git commit: %s\n", out.GitCommit)
} }
if out.GoVersion != "" { if out.GoVersion != "" {
fmt.Println("Go version:", out.GoVersion) fmt.Fprintln(cli.out, "Go version: %s\n", out.GoVersion)
} }
return nil return nil
} }
@ -429,19 +431,19 @@ func (cli *DockerCli) CmdInfo(args ...string) error {
return err return err
} }
fmt.Printf("Containers: %d\n", out.Containers) fmt.Fprintf(cli.out, "Containers: %d\n", out.Containers)
fmt.Printf("Images: %d\n", out.Images) fmt.Fprintf(cli.out, "Images: %d\n", out.Images)
if out.Debug || os.Getenv("DEBUG") != "" { if out.Debug || os.Getenv("DEBUG") != "" {
fmt.Printf("Debug mode (server): %v\n", out.Debug) fmt.Fprintf(cli.out, "Debug mode (server): %v\n", out.Debug)
fmt.Printf("Debug mode (client): %v\n", os.Getenv("DEBUG") != "") fmt.Fprintf(cli.out, "Debug mode (client): %v\n", os.Getenv("DEBUG") != "")
fmt.Printf("Fds: %d\n", out.NFd) fmt.Fprintf(cli.out, "Fds: %d\n", out.NFd)
fmt.Printf("Goroutines: %d\n", out.NGoroutines) fmt.Fprintf(cli.out, "Goroutines: %d\n", out.NGoroutines)
} }
if !out.MemoryLimit { if !out.MemoryLimit {
fmt.Println("WARNING: No memory limit support") fmt.Fprintf(cli.err, "WARNING: No memory limit support\n")
} }
if !out.SwapLimit { if !out.SwapLimit {
fmt.Println("WARNING: No swap limit support") fmt.Fprintf(cli.err, "WARNING: No swap limit support\n")
} }
return nil return nil
} }
@ -463,9 +465,9 @@ func (cli *DockerCli) CmdStop(args ...string) error {
for _, name := range cmd.Args() { for _, name := range cmd.Args() {
_, _, err := cli.call("POST", "/containers/"+name+"/stop?"+v.Encode(), nil) _, _, err := cli.call("POST", "/containers/"+name+"/stop?"+v.Encode(), nil)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "%s", err) fmt.Fprintf(cli.err, "%s\n", err)
} else { } else {
fmt.Println(name) fmt.Fprintf(cli.out, "%s\n", name)
} }
} }
return nil return nil
@ -488,9 +490,9 @@ func (cli *DockerCli) CmdRestart(args ...string) error {
for _, name := range cmd.Args() { for _, name := range cmd.Args() {
_, _, err := cli.call("POST", "/containers/"+name+"/restart?"+v.Encode(), nil) _, _, err := cli.call("POST", "/containers/"+name+"/restart?"+v.Encode(), nil)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "%s", err) fmt.Fprintf(cli.err, "%s\n", err)
} else { } else {
fmt.Println(name) fmt.Fprintf(cli.out, "%s\n", name)
} }
} }
return nil return nil
@ -509,9 +511,9 @@ func (cli *DockerCli) CmdStart(args ...string) error {
for _, name := range args { for _, name := range args {
_, _, err := cli.call("POST", "/containers/"+name+"/start", nil) _, _, err := cli.call("POST", "/containers/"+name+"/start", nil)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "%s", err) fmt.Fprintf(cli.err, "%s\n", err)
} else { } else {
fmt.Println(name) fmt.Fprintln(cli.out, "%s\n", name)
} }
} }
return nil return nil
@ -526,30 +528,30 @@ func (cli *DockerCli) CmdInspect(args ...string) error {
cmd.Usage() cmd.Usage()
return nil return nil
} }
fmt.Printf("[") fmt.Fprintf(cli.out, "[")
for i, name := range args { for i, name := range args {
if i > 0 { if i > 0 {
fmt.Printf(",") fmt.Fprintf(cli.out, ",")
} }
obj, _, err := cli.call("GET", "/containers/"+name+"/json", nil) obj, _, err := cli.call("GET", "/containers/"+name+"/json", nil)
if err != nil { if err != nil {
obj, _, err = cli.call("GET", "/images/"+name+"/json", nil) obj, _, err = cli.call("GET", "/images/"+name+"/json", nil)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "%s", err) fmt.Fprintf(cli.err, "%s\n", err)
continue continue
} }
} }
indented := new(bytes.Buffer) indented := new(bytes.Buffer)
if err = json.Indent(indented, obj, "", " "); err != nil { if err = json.Indent(indented, obj, "", " "); err != nil {
fmt.Fprintf(os.Stderr, "%s", err) fmt.Fprintf(cli.err, "%s\n", err)
continue continue
} }
if _, err := io.Copy(os.Stdout, indented); err != nil { if _, err := io.Copy(cli.out, indented); err != nil {
fmt.Fprintf(os.Stderr, "%s", err) fmt.Fprintf(cli.err, "%s\n", err)
} }
} }
fmt.Printf("]") fmt.Fprintf(cli.out, "]")
return nil return nil
} }
@ -595,7 +597,7 @@ func (cli *DockerCli) CmdRmi(args ...string) error {
for _, name := range cmd.Args() { for _, name := range cmd.Args() {
body, _, err := cli.call("DELETE", "/images/"+name, nil) body, _, err := cli.call("DELETE", "/images/"+name, nil)
if err != nil { if err != nil {
fmt.Fprintf(os.Stderr, "%s", err) fmt.Fprintf(cli.err, "%s", err)
} else { } else {
var outs []APIRmi var outs []APIRmi
err = json.Unmarshal(body, &outs) err = json.Unmarshal(body, &outs)
@ -634,7 +636,7 @@ func (cli *DockerCli) CmdHistory(args ...string) error {
if err != nil { if err != nil {
return err return err
} }
w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
fmt.Fprintln(w, "ID\tCREATED\tCREATED BY") fmt.Fprintln(w, "ID\tCREATED\tCREATED BY")
for _, out := range outs { for _, out := range outs {
@ -710,7 +712,7 @@ func (cli *DockerCli) CmdImport(args ...string) error {
v.Set("tag", tag) v.Set("tag", tag)
v.Set("fromSrc", src) v.Set("fromSrc", src)
err := cli.stream("POST", "/images/create?"+v.Encode(), os.Stdin, os.Stdout) err := cli.stream("POST", "/images/create?"+v.Encode(), cli.in, cli.out)
if err != nil { if err != nil {
return err return err
} }
@ -754,7 +756,7 @@ func (cli *DockerCli) CmdPush(args ...string) error {
v := url.Values{} v := url.Values{}
v.Set("registry", *registry) v.Set("registry", *registry)
if err := cli.stream("POST", "/images/"+name+"/push?"+v.Encode(), bytes.NewBuffer(buf), os.Stdout); err != nil { if err := cli.stream("POST", "/images/"+name+"/push?"+v.Encode(), bytes.NewBuffer(buf), cli.out); err != nil {
return err return err
} }
return nil return nil
@ -785,7 +787,7 @@ func (cli *DockerCli) CmdPull(args ...string) error {
v.Set("tag", *tag) v.Set("tag", *tag)
v.Set("registry", *registry) v.Set("registry", *registry)
if err := cli.stream("POST", "/images/create?"+v.Encode(), nil, os.Stdout); err != nil { if err := cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.out); err != nil {
return err return err
} }
@ -833,7 +835,7 @@ func (cli *DockerCli) CmdImages(args ...string) error {
return err return err
} }
w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
if !*quiet { if !*quiet {
fmt.Fprintln(w, "REPOSITORY\tTAG\tID\tCREATED\tSIZE") fmt.Fprintln(w, "REPOSITORY\tTAG\tID\tCREATED\tSIZE")
} }
@ -919,7 +921,7 @@ func (cli *DockerCli) CmdPs(args ...string) error {
if err != nil { if err != nil {
return err return err
} }
w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
if !*quiet { if !*quiet {
fmt.Fprint(w, "ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tPORTS") fmt.Fprint(w, "ID\tIMAGE\tCOMMAND\tCREATED\tSTATUS\tPORTS")
if *size { if *size {
@ -1013,7 +1015,7 @@ func (cli *DockerCli) CmdExport(args ...string) error {
return nil return nil
} }
if err := cli.stream("GET", "/containers/"+cmd.Arg(0)+"/export", nil, os.Stdout); err != nil { if err := cli.stream("GET", "/containers/"+cmd.Arg(0)+"/export", nil, cli.out); err != nil {
return err return err
} }
return nil return nil
@ -1055,10 +1057,10 @@ func (cli *DockerCli) CmdLogs(args ...string) error {
return nil return nil
} }
if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stdout=1", false, nil, os.Stdout); err != nil { if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stdout=1", false, nil, cli.out); err != nil {
return err return err
} }
if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stderr=1", false, nil, os.Stderr); err != nil { if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?logs=1&stderr=1", false, nil, cli.err); err != nil {
return err return err
} }
return nil return nil
@ -1099,7 +1101,7 @@ func (cli *DockerCli) CmdAttach(args ...string) error {
v.Set("stdout", "1") v.Set("stdout", "1")
v.Set("stderr", "1") v.Set("stderr", "1")
if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), container.Config.Tty, os.Stdin, os.Stdout); err != nil { if err := cli.hijack("POST", "/containers/"+cmd.Arg(0)+"/attach?"+v.Encode(), container.Config.Tty, cli.in.(*os.File), cli.out); err != nil {
return err return err
} }
return nil return nil
@ -1127,8 +1129,8 @@ func (cli *DockerCli) CmdSearch(args ...string) error {
if err != nil { if err != nil {
return err return err
} }
fmt.Printf("Found %d results matching your query (\"%s\")\n", len(outs), cmd.Arg(0)) fmt.Fprintf(cli.out, "Found %d results matching your query (\"%s\")\n", len(outs), cmd.Arg(0))
w := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0) w := tabwriter.NewWriter(cli.out, 20, 1, 3, ' ', 0)
fmt.Fprintf(w, "NAME\tDESCRIPTION\n") fmt.Fprintf(w, "NAME\tDESCRIPTION\n")
for _, out := range outs { for _, out := range outs {
desc := strings.Replace(out.Description, "\n", " ", -1) desc := strings.Replace(out.Description, "\n", " ", -1)
@ -1246,7 +1248,7 @@ func (cli *DockerCli) CmdRun(args ...string) error {
if statusCode == 404 { if statusCode == 404 {
v := url.Values{} v := url.Values{}
v.Set("fromImage", config.Image) v.Set("fromImage", config.Image)
err = cli.stream("POST", "/images/create?"+v.Encode(), nil, os.Stderr) err = cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.err)
if err != nil { if err != nil {
return err return err
} }
@ -1259,28 +1261,28 @@ func (cli *DockerCli) CmdRun(args ...string) error {
return err return err
} }
out := &APIRun{} runResult := &APIRun{}
err = json.Unmarshal(body, out) err = json.Unmarshal(body, runResult)
if err != nil { if err != nil {
return err return err
} }
for _, warning := range out.Warnings { for _, warning := range runResult.Warnings {
fmt.Fprintln(os.Stderr, "WARNING: ", warning) fmt.Fprintln(cli.err, "WARNING: ", warning)
} }
//start the container //start the container
_, _, err = cli.call("POST", "/containers/"+out.ID+"/start", nil) _, _, err = cli.call("POST", "/containers/"+runResult.ID+"/start", nil)
if err != nil { if err != nil {
return err return err
} }
if !config.AttachStdout && !config.AttachStderr { if !config.AttachStdout && !config.AttachStderr {
fmt.Println(out.ID) fmt.Fprintf(cli.out, "%s\b", runResult.ID)
} }
if config.AttachStdin || config.AttachStdout || config.AttachStderr { if config.AttachStdin || config.AttachStdout || config.AttachStderr {
if config.Tty { if config.Tty {
cli.monitorTtySize(out.ID) cli.monitorTtySize(runResult.ID)
} }
v := url.Values{} v := url.Values{}
@ -1296,7 +1298,7 @@ func (cli *DockerCli) CmdRun(args ...string) error {
if config.AttachStderr { if config.AttachStderr {
v.Set("stderr", "1") v.Set("stderr", "1")
} }
if err := cli.hijack("POST", "/containers/"+out.ID+"/attach?"+v.Encode(), config.Tty, os.Stdin, os.Stdout); err != nil { if err := cli.hijack("POST", "/containers/"+runResult.ID+"/attach?"+v.Encode(), config.Tty, cli.in.(*os.File), cli.out); err != nil {
utils.Debugf("Error hijack: %s", err) utils.Debugf("Error hijack: %s", err)
return err return err
} }
@ -1515,19 +1517,30 @@ func (cli *DockerCli) monitorTtySize(id string) {
func Subcmd(name, signature, description string) *flag.FlagSet { func Subcmd(name, signature, description string) *flag.FlagSet {
flags := flag.NewFlagSet(name, flag.ContinueOnError) flags := flag.NewFlagSet(name, flag.ContinueOnError)
flags.Usage = func() { flags.Usage = func() {
fmt.Printf("\nUsage: docker %s %s\n\n%s\n\n", name, signature, description) // FIXME: use custom stdout or return error
fmt.Fprintf(os.Stdout, "\nUsage: docker %s %s\n\n%s\n\n", name, signature, description)
flags.PrintDefaults() flags.PrintDefaults()
} }
return flags return flags
} }
func NewDockerCli(proto, addr string) *DockerCli { func NewDockerCli(in io.ReadCloser, out, err io.Writer, proto, addr string) *DockerCli {
authConfig, _ := auth.LoadConfig(os.Getenv("HOME")) authConfig, _ := auth.LoadConfig(os.Getenv("HOME"))
return &DockerCli{proto, addr, authConfig} return &DockerCli{
proto: proto,
addr: addr,
authConfig: authConfig,
in: in,
out: out,
err: err,
}
} }
type DockerCli struct { type DockerCli struct {
proto string proto string
addr string addr string
authConfig *auth.AuthConfig authConfig *auth.AuthConfig
in io.ReadCloser
out io.Writer
err io.Writer
} }

10
commands_test.go
View File

@ -334,7 +334,8 @@ func TestRunDisconnectTty(t *testing.T) {
t.Fatalf("/bin/cat should still be running after closing stdin (tty mode)") t.Fatalf("/bin/cat should still be running after closing stdin (tty mode)")
} }
} }
*/
/*
// TestAttachStdin checks attaching to stdin without stdout and stderr. // TestAttachStdin checks attaching to stdin without stdout and stderr.
// 'docker run -i -a stdin' should sends the client's stdin to the command, // 'docker run -i -a stdin' should sends the client's stdin to the command,
// then detach from it and print the container id. // then detach from it and print the container id.
@ -345,6 +346,10 @@ func TestRunAttachStdin(t *testing.T) {
} }
defer nuke(runtime) defer nuke(runtime)
srv := &Server{runtime: runtime} srv := &Server{runtime: runtime}
// enableCors: false,
// lock: &sync.Mutex{},
// pullingPool: make(map[string]struct{}),
// pushingPool: make(map[string]struct{}),
stdin, stdinPipe := io.Pipe() stdin, stdinPipe := io.Pipe()
stdout, stdoutPipe := io.Pipe() stdout, stdoutPipe := io.Pipe()
@ -399,7 +404,8 @@ func TestRunAttachStdin(t *testing.T) {
} }
} }
} }
*/
/*
// Expected behaviour, the process stays alive when the client disconnects // Expected behaviour, the process stays alive when the client disconnects
func TestAttachDisconnect(t *testing.T) { func TestAttachDisconnect(t *testing.T) {
runtime, err := newTestRuntime() runtime, err := newTestRuntime()

10
runtime_test.go
View File

@ -16,9 +16,13 @@ import (
"time" "time"
) )
const unitTestImageName string = "docker-ut" const (
const unitTestImageId string = "e9aa60c60128cad1" unitTestImageName = "docker-ut"
const unitTestStoreBase string = "/var/lib/docker/unit-tests" unitTestImageId = "e9aa60c60128cad1"
unitTestStoreBase = "/var/lib/docker/unit-tests"
testDaemonAddr = "127.0.0.1:4270"
testDaemonProto = "tcp"
)
func nuke(runtime *Runtime) error { func nuke(runtime *Runtime) error {
var wg sync.WaitGroup var wg sync.WaitGroup