mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
102 lines
2.1 KiB
Go
102 lines
2.1 KiB
Go
package docker
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func closeWrap(args ...io.Closer) error {
|
|
e := false
|
|
ret := fmt.Errorf("Error closing elements")
|
|
for _, c := range args {
|
|
if err := c.Close(); err != nil {
|
|
e = true
|
|
ret = fmt.Errorf("%s\n%s", ret, err)
|
|
}
|
|
}
|
|
if e {
|
|
return ret
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func setTimeout(t *testing.T, msg string, d time.Duration, f func()) {
|
|
c := make(chan bool)
|
|
|
|
// Make sure we are not too long
|
|
go func() {
|
|
time.Sleep(d)
|
|
c <- true
|
|
}()
|
|
go func() {
|
|
f()
|
|
c <- false
|
|
}()
|
|
if <-c {
|
|
t.Fatal(msg)
|
|
}
|
|
}
|
|
|
|
func assertPipe(input, output string, r io.Reader, w io.Writer, count int) error {
|
|
for i := 0; i < count; i++ {
|
|
if _, err := w.Write([]byte(input)); err != nil {
|
|
return err
|
|
}
|
|
o, err := bufio.NewReader(r).ReadString('\n')
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if strings.Trim(o, " \r\n") != output {
|
|
return fmt.Errorf("Unexpected output. Expected [%s], received [%s]", output, o)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Expected behaviour: the process dies when the client disconnects
|
|
func TestRunDisconnect(t *testing.T) {
|
|
runtime, err := newTestRuntime()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer nuke(runtime)
|
|
|
|
srv := &Server{runtime: runtime}
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
stdout, stdoutPipe := io.Pipe()
|
|
c1 := make(chan struct{})
|
|
go func() {
|
|
if err := srv.CmdRun(stdin, stdoutPipe, "-i", GetTestImage(runtime).Id, "/bin/cat"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
close(c1)
|
|
}()
|
|
|
|
setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 15); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
|
|
// Close pipes (simulate disconnect)
|
|
if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// as the pipes are close, we expect the process to die,
|
|
// therefore CmdRun to unblock. Wait for CmdRun
|
|
setTimeout(t, "Waiting for CmdRun timed out", 2*time.Second, func() {
|
|
<-c1
|
|
})
|
|
|
|
// Check the status of the container
|
|
container := runtime.containers.Back().Value.(*Container)
|
|
if container.State.Running {
|
|
t.Fatalf("/bin/cat is still running after closing stdin")
|
|
}
|
|
}
|