github.com/squaremo/docker@v1.3.2-0.20150516120342-42cfc9554972/integration-cli/docker_cli_wait_test.go (about)

     1  package main
     2  
     3  import (
     4  	"bytes"
     5  	"os/exec"
     6  	"strings"
     7  	"time"
     8  
     9  	"github.com/go-check/check"
    10  )
    11  
    12  // non-blocking wait with 0 exit code
    13  func (s *DockerSuite) TestWaitNonBlockedExitZero(c *check.C) {
    14  
    15  	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sh", "-c", "true")
    16  	out, _, err := runCommandWithOutput(runCmd)
    17  	if err != nil {
    18  		c.Fatal(out, err)
    19  	}
    20  	containerID := strings.TrimSpace(out)
    21  
    22  	status := "true"
    23  	for i := 0; status != "false"; i++ {
    24  		runCmd = exec.Command(dockerBinary, "inspect", "--format='{{.State.Running}}'", containerID)
    25  		status, _, err = runCommandWithOutput(runCmd)
    26  		if err != nil {
    27  			c.Fatal(status, err)
    28  		}
    29  		status = strings.TrimSpace(status)
    30  
    31  		time.Sleep(time.Second)
    32  		if i >= 60 {
    33  			c.Fatal("Container should have stopped by now")
    34  		}
    35  	}
    36  
    37  	runCmd = exec.Command(dockerBinary, "wait", containerID)
    38  	out, _, err = runCommandWithOutput(runCmd)
    39  
    40  	if err != nil || strings.TrimSpace(out) != "0" {
    41  		c.Fatal("failed to set up container", out, err)
    42  	}
    43  
    44  }
    45  
    46  // blocking wait with 0 exit code
    47  func (s *DockerSuite) TestWaitBlockedExitZero(c *check.C) {
    48  	out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "trap 'exit 0' TERM; while true; do sleep 0.01; done")
    49  	containerID := strings.TrimSpace(out)
    50  
    51  	if err := waitRun(containerID); err != nil {
    52  		c.Fatal(err)
    53  	}
    54  
    55  	chWait := make(chan string)
    56  	go func() {
    57  		out, _, _ := runCommandWithOutput(exec.Command(dockerBinary, "wait", containerID))
    58  		chWait <- out
    59  	}()
    60  
    61  	time.Sleep(100 * time.Millisecond)
    62  	dockerCmd(c, "stop", containerID)
    63  
    64  	select {
    65  	case status := <-chWait:
    66  		if strings.TrimSpace(status) != "0" {
    67  			c.Fatalf("expected exit 0, got %s", status)
    68  		}
    69  	case <-time.After(2 * time.Second):
    70  		c.Fatal("timeout waiting for `docker wait` to exit")
    71  	}
    72  
    73  }
    74  
    75  // non-blocking wait with random exit code
    76  func (s *DockerSuite) TestWaitNonBlockedExitRandom(c *check.C) {
    77  
    78  	runCmd := exec.Command(dockerBinary, "run", "-d", "busybox", "sh", "-c", "exit 99")
    79  	out, _, err := runCommandWithOutput(runCmd)
    80  	if err != nil {
    81  		c.Fatal(out, err)
    82  	}
    83  	containerID := strings.TrimSpace(out)
    84  
    85  	status := "true"
    86  	for i := 0; status != "false"; i++ {
    87  		runCmd = exec.Command(dockerBinary, "inspect", "--format='{{.State.Running}}'", containerID)
    88  		status, _, err = runCommandWithOutput(runCmd)
    89  		if err != nil {
    90  			c.Fatal(status, err)
    91  		}
    92  		status = strings.TrimSpace(status)
    93  
    94  		time.Sleep(time.Second)
    95  		if i >= 60 {
    96  			c.Fatal("Container should have stopped by now")
    97  		}
    98  	}
    99  
   100  	runCmd = exec.Command(dockerBinary, "wait", containerID)
   101  	out, _, err = runCommandWithOutput(runCmd)
   102  
   103  	if err != nil || strings.TrimSpace(out) != "99" {
   104  		c.Fatal("failed to set up container", out, err)
   105  	}
   106  
   107  }
   108  
   109  // blocking wait with random exit code
   110  func (s *DockerSuite) TestWaitBlockedExitRandom(c *check.C) {
   111  	out, _ := dockerCmd(c, "run", "-d", "busybox", "/bin/sh", "-c", "trap 'exit 99' TERM; while true; do sleep 0.01; done")
   112  	containerID := strings.TrimSpace(out)
   113  	if err := waitRun(containerID); err != nil {
   114  		c.Fatal(err)
   115  	}
   116  	if err := waitRun(containerID); err != nil {
   117  		c.Fatal(err)
   118  	}
   119  
   120  	chWait := make(chan error)
   121  	waitCmd := exec.Command(dockerBinary, "wait", containerID)
   122  	waitCmdOut := bytes.NewBuffer(nil)
   123  	waitCmd.Stdout = waitCmdOut
   124  	if err := waitCmd.Start(); err != nil {
   125  		c.Fatal(err)
   126  	}
   127  
   128  	go func() {
   129  		chWait <- waitCmd.Wait()
   130  	}()
   131  
   132  	dockerCmd(c, "stop", containerID)
   133  
   134  	select {
   135  	case err := <-chWait:
   136  		if err != nil {
   137  			c.Fatal(err)
   138  		}
   139  		status, err := waitCmdOut.ReadString('\n')
   140  		if err != nil {
   141  			c.Fatal(err)
   142  		}
   143  		if strings.TrimSpace(status) != "99" {
   144  			c.Fatalf("expected exit 99, got %s", status)
   145  		}
   146  	case <-time.After(2 * time.Second):
   147  		waitCmd.Process.Kill()
   148  		c.Fatal("timeout waiting for `docker wait` to exit")
   149  	}
   150  }