2013-03-30 13:55:47 +00:00
|
|
|
package docker
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
|
|
|
"fmt"
|
|
|
|
"io"
|
2013-06-25 01:22:02 +00:00
|
|
|
"io/ioutil"
|
2013-03-30 13:55:47 +00:00
|
|
|
"strings"
|
|
|
|
"testing"
|
|
|
|
"time"
|
2014-03-27 19:16:03 +00:00
|
|
|
|
2014-07-24 22:19:50 +00:00
|
|
|
"github.com/docker/docker/api/client"
|
|
|
|
"github.com/docker/docker/daemon"
|
2014-07-24 20:37:44 +00:00
|
|
|
"github.com/docker/docker/pkg/log"
|
2014-07-24 22:19:50 +00:00
|
|
|
"github.com/docker/docker/pkg/term"
|
|
|
|
"github.com/docker/docker/utils"
|
2014-09-26 21:24:04 +00:00
|
|
|
"github.com/docker/libtrust"
|
2013-03-30 13:55:47 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
2014-04-17 21:43:01 +00:00
|
|
|
func setRaw(t *testing.T, c *daemon.Container) *term.State {
|
2013-11-29 17:57:59 +00:00
|
|
|
pty, err := c.GetPtyMaster()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
state, err := term.MakeRaw(pty.Fd())
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
return state
|
|
|
|
}
|
|
|
|
|
2014-04-17 21:43:01 +00:00
|
|
|
func unsetRaw(t *testing.T, c *daemon.Container, state *term.State) {
|
2013-11-29 17:57:59 +00:00
|
|
|
pty, err := c.GetPtyMaster()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
term.RestoreTerminal(pty.Fd(), state)
|
|
|
|
}
|
|
|
|
|
2014-04-17 21:43:01 +00:00
|
|
|
func waitContainerStart(t *testing.T, timeout time.Duration) *daemon.Container {
|
|
|
|
var container *daemon.Container
|
2013-11-29 17:57:59 +00:00
|
|
|
|
|
|
|
setTimeout(t, "Waiting for the container to be started timed out", timeout, func() {
|
|
|
|
for {
|
2014-04-17 21:43:01 +00:00
|
|
|
l := globalDaemon.List()
|
2014-08-31 15:20:35 +00:00
|
|
|
if len(l) == 1 && l[0].IsRunning() {
|
2013-11-29 17:57:59 +00:00
|
|
|
container = l[0]
|
|
|
|
break
|
|
|
|
}
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
if container == nil {
|
|
|
|
t.Fatal("An error occured while waiting for the container to start")
|
|
|
|
}
|
|
|
|
|
|
|
|
return container
|
|
|
|
}
|
|
|
|
|
2013-04-01 03:52:35 +00:00
|
|
|
func setTimeout(t *testing.T, msg string, d time.Duration, f func()) {
|
2013-03-30 13:55:47 +00:00
|
|
|
c := make(chan bool)
|
|
|
|
|
|
|
|
// Make sure we are not too long
|
|
|
|
go func() {
|
|
|
|
time.Sleep(d)
|
|
|
|
c <- true
|
|
|
|
}()
|
2013-04-01 03:52:35 +00:00
|
|
|
go func() {
|
|
|
|
f()
|
|
|
|
c <- false
|
|
|
|
}()
|
2013-07-18 14:54:58 +00:00
|
|
|
if <-c && msg != "" {
|
2013-04-01 03:52:35 +00:00
|
|
|
t.Fatal(msg)
|
2013-03-30 13:55:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-22 04:42:36 +00:00
|
|
|
func expectPipe(expected string, r io.Reader) error {
|
|
|
|
o, err := bufio.NewReader(r).ReadString('\n')
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if strings.Trim(o, " \r\n") != expected {
|
|
|
|
return fmt.Errorf("Unexpected output. Expected [%s], received [%s]", expected, o)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-03-30 13:55:47 +00:00
|
|
|
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
|
|
|
|
}
|
2014-01-22 04:42:36 +00:00
|
|
|
if err := expectPipe(output, r); err != nil {
|
2013-03-30 13:55:47 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2013-07-24 00:27:49 +00:00
|
|
|
// Expected behaviour: the process dies when the client disconnects
|
|
|
|
func TestRunDisconnect(t *testing.T) {
|
|
|
|
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-07-24 00:27:49 +00:00
|
|
|
|
2014-09-26 21:24:04 +00:00
|
|
|
cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-07-24 00:27:49 +00:00
|
|
|
|
|
|
|
c1 := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
// We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
|
// fact that CmdRun returns.
|
|
|
|
cli.CmdRun("-i", unitTestImageID, "/bin/cat")
|
|
|
|
close(c1)
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
2013-11-29 00:12:45 +00:00
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil {
|
2013-07-24 00:27:49 +00:00
|
|
|
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
|
|
|
|
})
|
|
|
|
|
|
|
|
// Client disconnect after run -i should cause stdin to be closed, which should
|
|
|
|
// cause /bin/cat to exit.
|
|
|
|
setTimeout(t, "Waiting for /bin/cat to exit timed out", 2*time.Second, func() {
|
2014-04-17 21:43:01 +00:00
|
|
|
container := globalDaemon.List()[0]
|
2014-08-31 15:20:35 +00:00
|
|
|
container.WaitStop(-1 * time.Second)
|
|
|
|
if container.IsRunning() {
|
2013-07-24 00:27:49 +00:00
|
|
|
t.Fatalf("/bin/cat is still running after closing stdin")
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2013-11-29 18:17:25 +00:00
|
|
|
// Expected behaviour: the process stay alive when the client disconnects
|
|
|
|
// but the client detaches.
|
2013-07-24 00:27:49 +00:00
|
|
|
func TestRunDisconnectTty(t *testing.T) {
|
|
|
|
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-07-24 00:27:49 +00:00
|
|
|
|
2014-09-26 21:24:04 +00:00
|
|
|
cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-07-24 00:27:49 +00:00
|
|
|
|
|
|
|
c1 := make(chan struct{})
|
|
|
|
go func() {
|
2013-11-29 18:17:25 +00:00
|
|
|
defer close(c1)
|
2013-07-24 00:27:49 +00:00
|
|
|
// We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
|
// fact that CmdRun returns.
|
|
|
|
if err := cli.CmdRun("-i", "-t", unitTestImageID, "/bin/cat"); err != nil {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Debugf("Error CmdRun: %s", err)
|
2013-07-24 00:27:49 +00:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
2013-11-29 18:17:25 +00:00
|
|
|
container := waitContainerStart(t, 10*time.Second)
|
2013-07-24 00:27:49 +00:00
|
|
|
|
2013-11-29 18:17:25 +00:00
|
|
|
state := setRaw(t, container)
|
|
|
|
defer unsetRaw(t, container, state)
|
2013-07-24 00:27:49 +00:00
|
|
|
|
2013-11-29 18:17:25 +00:00
|
|
|
// Client disconnect after run -i should keep stdin out in TTY mode
|
2013-11-12 20:16:51 +00:00
|
|
|
setTimeout(t, "Read/Write assertion timed out", 2*time.Second, func() {
|
2013-11-29 00:12:45 +00:00
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil {
|
2013-07-24 00:27:49 +00:00
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
// Close pipes (simulate disconnect)
|
|
|
|
if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2013-11-29 18:17:25 +00:00
|
|
|
// wait for CmdRun to return
|
|
|
|
setTimeout(t, "Waiting for CmdRun timed out", 5*time.Second, func() {
|
|
|
|
<-c1
|
|
|
|
})
|
|
|
|
|
2013-07-24 00:27:49 +00:00
|
|
|
// In tty mode, we expect the process to stay alive even after client's stdin closes.
|
|
|
|
|
|
|
|
// Give some time to monitor to do his thing
|
2014-08-31 15:20:35 +00:00
|
|
|
container.WaitStop(500 * time.Millisecond)
|
|
|
|
if !container.IsRunning() {
|
2013-07-24 00:27:49 +00:00
|
|
|
t.Fatalf("/bin/cat should still be running after closing stdin (tty mode)")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-20 18:31:00 +00:00
|
|
|
// TestRunDetach checks attaching and detaching with the escape sequence.
|
|
|
|
func TestRunDetach(t *testing.T) {
|
|
|
|
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2014-09-26 21:24:04 +00:00
|
|
|
cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-09-20 18:31:00 +00:00
|
|
|
|
|
|
|
ch := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
defer close(ch)
|
|
|
|
cli.CmdRun("-i", "-t", unitTestImageID, "cat")
|
|
|
|
}()
|
|
|
|
|
2013-11-29 18:17:25 +00:00
|
|
|
container := waitContainerStart(t, 10*time.Second)
|
|
|
|
|
|
|
|
state := setRaw(t, container)
|
|
|
|
defer unsetRaw(t, container, state)
|
|
|
|
|
2013-09-20 18:31:00 +00:00
|
|
|
setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
|
2013-11-29 00:12:45 +00:00
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil {
|
2013-09-20 18:31:00 +00:00
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
|
2013-11-29 18:17:25 +00:00
|
|
|
stdinPipe.Write([]byte{16})
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
stdinPipe.Write([]byte{17})
|
2013-09-20 18:31:00 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
// wait for CmdRun to return
|
2013-10-01 22:59:52 +00:00
|
|
|
setTimeout(t, "Waiting for CmdRun timed out", 15*time.Second, func() {
|
2013-09-20 18:31:00 +00:00
|
|
|
<-ch
|
|
|
|
})
|
2013-11-29 18:17:25 +00:00
|
|
|
closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2013-09-20 20:36:19 +00:00
|
|
|
time.Sleep(500 * time.Millisecond)
|
2014-08-31 15:20:35 +00:00
|
|
|
if !container.IsRunning() {
|
2013-09-20 20:36:19 +00:00
|
|
|
t.Fatal("The detached container should be still running")
|
|
|
|
}
|
|
|
|
|
|
|
|
setTimeout(t, "Waiting for container to die timed out", 20*time.Second, func() {
|
2013-09-20 18:31:00 +00:00
|
|
|
container.Kill()
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:59:59 +00:00
|
|
|
// TestAttachDetach checks that attach in tty mode can be detached using the long container ID
|
2013-09-20 18:31:00 +00:00
|
|
|
func TestAttachDetach(t *testing.T) {
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2014-09-26 21:24:04 +00:00
|
|
|
cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2013-10-09 01:42:53 +00:00
|
|
|
ch := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
defer close(ch)
|
2013-09-20 18:31:00 +00:00
|
|
|
if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-10-09 01:42:53 +00:00
|
|
|
}()
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2013-11-29 17:57:59 +00:00
|
|
|
container := waitContainerStart(t, 10*time.Second)
|
2013-11-29 15:39:51 +00:00
|
|
|
|
2013-10-09 01:42:53 +00:00
|
|
|
setTimeout(t, "Reading container's id timed out", 10*time.Second, func() {
|
|
|
|
buf := make([]byte, 1024)
|
|
|
|
n, err := stdout.Read(buf)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
2013-10-25 01:59:59 +00:00
|
|
|
if strings.Trim(string(buf[:n]), " \r\n") != container.ID {
|
|
|
|
t.Fatalf("Wrong ID received. Expect %s, received %s", container.ID, buf[:n])
|
2013-10-09 01:42:53 +00:00
|
|
|
}
|
|
|
|
})
|
|
|
|
setTimeout(t, "Starting container timed out", 10*time.Second, func() {
|
|
|
|
<-ch
|
|
|
|
})
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2013-11-29 17:57:59 +00:00
|
|
|
state := setRaw(t, container)
|
|
|
|
defer unsetRaw(t, container, state)
|
2013-11-29 15:42:26 +00:00
|
|
|
|
2013-09-20 18:31:00 +00:00
|
|
|
stdin, stdinPipe = io.Pipe()
|
|
|
|
stdout, stdoutPipe = io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
cli = client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2013-10-09 01:42:53 +00:00
|
|
|
ch = make(chan struct{})
|
2013-09-20 18:31:00 +00:00
|
|
|
go func() {
|
|
|
|
defer close(ch)
|
2013-10-25 01:59:59 +00:00
|
|
|
if err := cli.CmdAttach(container.ID); err != nil {
|
|
|
|
if err != io.ErrClosedPipe {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
|
2013-11-29 00:12:45 +00:00
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil {
|
2013-10-25 01:59:59 +00:00
|
|
|
if err != io.ErrClosedPipe {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
|
2013-11-29 17:11:20 +00:00
|
|
|
stdinPipe.Write([]byte{16})
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
stdinPipe.Write([]byte{17})
|
2013-10-25 01:59:59 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
// wait for CmdRun to return
|
|
|
|
setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() {
|
|
|
|
<-ch
|
|
|
|
})
|
|
|
|
|
2013-11-29 17:11:20 +00:00
|
|
|
closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
|
|
|
|
|
2013-10-25 01:59:59 +00:00
|
|
|
time.Sleep(500 * time.Millisecond)
|
2014-08-31 15:20:35 +00:00
|
|
|
if !container.IsRunning() {
|
2013-10-25 01:59:59 +00:00
|
|
|
t.Fatal("The detached container should be still running")
|
|
|
|
}
|
|
|
|
|
|
|
|
setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() {
|
|
|
|
container.Kill()
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// TestAttachDetachTruncatedID checks that attach in tty mode can be detached
|
|
|
|
func TestAttachDetachTruncatedID(t *testing.T) {
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-10-25 01:59:59 +00:00
|
|
|
|
2014-09-26 21:24:04 +00:00
|
|
|
cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-10-25 01:59:59 +00:00
|
|
|
|
2013-11-29 18:17:25 +00:00
|
|
|
// Discard the CmdRun output
|
2013-10-25 01:59:59 +00:00
|
|
|
go stdout.Read(make([]byte, 1024))
|
|
|
|
setTimeout(t, "Starting container timed out", 2*time.Second, func() {
|
|
|
|
if err := cli.CmdRun("-i", "-t", "-d", unitTestImageID, "cat"); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2013-11-29 18:03:36 +00:00
|
|
|
container := waitContainerStart(t, 10*time.Second)
|
|
|
|
|
|
|
|
state := setRaw(t, container)
|
|
|
|
defer unsetRaw(t, container, state)
|
2013-10-25 01:59:59 +00:00
|
|
|
|
|
|
|
stdin, stdinPipe = io.Pipe()
|
|
|
|
stdout, stdoutPipe = io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
cli = client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-10-25 01:59:59 +00:00
|
|
|
|
|
|
|
ch := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
defer close(ch)
|
|
|
|
if err := cli.CmdAttach(utils.TruncateID(container.ID)); err != nil {
|
2013-10-09 01:42:53 +00:00
|
|
|
if err != io.ErrClosedPipe {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-09-20 18:31:00 +00:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
|
2013-11-29 00:12:45 +00:00
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil {
|
2013-10-09 01:42:53 +00:00
|
|
|
if err != io.ErrClosedPipe {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-09-20 18:31:00 +00:00
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
setTimeout(t, "Escape sequence timeout", 5*time.Second, func() {
|
2013-11-29 18:03:36 +00:00
|
|
|
stdinPipe.Write([]byte{16})
|
|
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
stdinPipe.Write([]byte{17})
|
2013-09-20 18:31:00 +00:00
|
|
|
})
|
|
|
|
|
|
|
|
// wait for CmdRun to return
|
2013-10-01 22:59:52 +00:00
|
|
|
setTimeout(t, "Waiting for CmdAttach timed out", 15*time.Second, func() {
|
2013-09-20 18:31:00 +00:00
|
|
|
<-ch
|
|
|
|
})
|
2013-11-29 18:03:36 +00:00
|
|
|
closeWrap(stdin, stdinPipe, stdout, stdoutPipe)
|
2013-09-20 18:31:00 +00:00
|
|
|
|
2013-09-20 20:36:19 +00:00
|
|
|
time.Sleep(500 * time.Millisecond)
|
2014-08-31 15:20:35 +00:00
|
|
|
if !container.IsRunning() {
|
2013-09-20 20:36:19 +00:00
|
|
|
t.Fatal("The detached container should be still running")
|
|
|
|
}
|
|
|
|
|
2013-09-20 18:31:00 +00:00
|
|
|
setTimeout(t, "Waiting for container to die timedout", 5*time.Second, func() {
|
|
|
|
container.Kill()
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2013-07-24 00:27:49 +00:00
|
|
|
// Expected behaviour, the process stays alive when the client disconnects
|
|
|
|
func TestAttachDisconnect(t *testing.T) {
|
|
|
|
stdin, stdinPipe := io.Pipe()
|
|
|
|
stdout, stdoutPipe := io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-07-24 00:27:49 +00:00
|
|
|
|
2014-09-26 21:24:04 +00:00
|
|
|
cli := client.NewDockerCli(stdin, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-07-24 00:27:49 +00:00
|
|
|
|
|
|
|
go func() {
|
|
|
|
// Start a process in daemon mode
|
|
|
|
if err := cli.CmdRun("-d", "-i", unitTestImageID, "/bin/cat"); err != nil {
|
2014-07-24 20:37:44 +00:00
|
|
|
log.Debugf("Error CmdRun: %s", err)
|
2013-07-24 00:27:49 +00:00
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "Waiting for CmdRun timed out", 10*time.Second, func() {
|
|
|
|
if _, err := bufio.NewReader(stdout).ReadString('\n'); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
setTimeout(t, "Waiting for the container to be started timed out", 10*time.Second, func() {
|
|
|
|
for {
|
2014-04-17 21:43:01 +00:00
|
|
|
l := globalDaemon.List()
|
2014-08-31 15:20:35 +00:00
|
|
|
if len(l) == 1 && l[0].IsRunning() {
|
2013-07-24 00:27:49 +00:00
|
|
|
break
|
|
|
|
}
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2014-04-17 21:43:01 +00:00
|
|
|
container := globalDaemon.List()[0]
|
2013-07-24 00:27:49 +00:00
|
|
|
|
|
|
|
// Attach to it
|
|
|
|
c1 := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
// We're simulating a disconnect so the return value doesn't matter. What matters is the
|
|
|
|
// fact that CmdAttach returns.
|
|
|
|
cli.CmdAttach(container.ID)
|
|
|
|
close(c1)
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "First read/write assertion timed out", 2*time.Second, func() {
|
2013-11-29 00:12:45 +00:00
|
|
|
if err := assertPipe("hello\n", "hello", stdout, stdinPipe, 150); err != nil {
|
2013-07-24 00:27:49 +00:00
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
// Close pipes (client disconnects)
|
|
|
|
if err := closeWrap(stdin, stdinPipe, stdout, stdoutPipe); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for attach to finish, the client disconnected, therefore, Attach finished his job
|
|
|
|
setTimeout(t, "Waiting for CmdAttach timed out", 2*time.Second, func() {
|
|
|
|
<-c1
|
|
|
|
})
|
|
|
|
|
|
|
|
// We closed stdin, expect /bin/cat to still be running
|
|
|
|
// Wait a little bit to make sure container.monitor() did his thing
|
2014-09-26 21:24:04 +00:00
|
|
|
_, err = container.WaitStop(500 * time.Millisecond)
|
2014-08-31 15:20:35 +00:00
|
|
|
if err == nil || !container.IsRunning() {
|
2013-07-24 00:27:49 +00:00
|
|
|
t.Fatalf("/bin/cat is not running after closing stdin")
|
|
|
|
}
|
|
|
|
|
2013-08-12 17:53:06 +00:00
|
|
|
// Try to avoid the timeout in destroy. Best effort, don't check error
|
2013-07-24 00:27:49 +00:00
|
|
|
cStdin, _ := container.StdinPipe()
|
|
|
|
cStdin.Close()
|
2014-08-31 15:20:35 +00:00
|
|
|
container.WaitStop(-1 * time.Second)
|
2013-07-24 00:27:49 +00:00
|
|
|
}
|
2013-08-15 18:48:05 +00:00
|
|
|
|
|
|
|
// Expected behaviour: container gets deleted automatically after exit
|
|
|
|
func TestRunAutoRemove(t *testing.T) {
|
2013-10-16 21:46:16 +00:00
|
|
|
t.Skip("Fixme. Skipping test for now, race condition")
|
2013-08-15 18:48:05 +00:00
|
|
|
stdout, stdoutPipe := io.Pipe()
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
cli := client.NewDockerCli(nil, stdoutPipe, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-08-15 18:48:05 +00:00
|
|
|
|
|
|
|
c := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
defer close(c)
|
2014-03-13 17:46:02 +00:00
|
|
|
if err := cli.CmdRun("--rm", unitTestImageID, "hostname"); err != nil {
|
2013-08-15 18:48:05 +00:00
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
var temporaryContainerID string
|
|
|
|
setTimeout(t, "Reading command output time out", 2*time.Second, func() {
|
|
|
|
cmdOutput, err := bufio.NewReader(stdout).ReadString('\n')
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
temporaryContainerID = cmdOutput
|
|
|
|
if err := closeWrap(stdout, stdoutPipe); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
2013-10-09 01:42:53 +00:00
|
|
|
setTimeout(t, "CmdRun timed out", 10*time.Second, func() {
|
2013-08-15 18:48:05 +00:00
|
|
|
<-c
|
|
|
|
})
|
|
|
|
|
|
|
|
time.Sleep(500 * time.Millisecond)
|
|
|
|
|
2014-04-17 21:43:01 +00:00
|
|
|
if len(globalDaemon.List()) > 0 {
|
2013-08-15 18:48:05 +00:00
|
|
|
t.Fatalf("failed to remove container automatically: container %s still exists", temporaryContainerID)
|
|
|
|
}
|
|
|
|
}
|
2013-11-04 20:23:35 +00:00
|
|
|
|
2013-10-18 23:06:25 +00:00
|
|
|
// Expected behaviour: error out when attempting to bind mount non-existing source paths
|
|
|
|
func TestRunErrorBindNonExistingSource(t *testing.T) {
|
2014-09-26 21:24:04 +00:00
|
|
|
key, err := libtrust.GenerateECP256PrivateKey()
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
2013-10-18 23:06:25 +00:00
|
|
|
|
2014-09-26 21:24:04 +00:00
|
|
|
cli := client.NewDockerCli(nil, nil, ioutil.Discard, key, testDaemonProto, testDaemonAddr, nil)
|
2013-11-14 06:10:20 +00:00
|
|
|
defer cleanup(globalEngine, t)
|
2013-10-18 23:06:25 +00:00
|
|
|
|
|
|
|
c := make(chan struct{})
|
|
|
|
go func() {
|
|
|
|
defer close(c)
|
2013-11-29 18:17:04 +00:00
|
|
|
// This check is made at runtime, can't be "unit tested"
|
2013-10-18 23:06:25 +00:00
|
|
|
if err := cli.CmdRun("-v", "/i/dont/exist:/tmp", unitTestImageID, "echo 'should fail'"); err == nil {
|
|
|
|
t.Fatal("should have failed to run when using /i/dont/exist as a source for the bind mount")
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
|
|
|
|
setTimeout(t, "CmdRun timed out", 5*time.Second, func() {
|
|
|
|
<-c
|
|
|
|
})
|
|
|
|
}
|