2014-02-25 16:17:48 +00:00
package main
import (
2014-08-12 09:36:49 +00:00
"bufio"
2014-10-17 18:06:05 +00:00
"bytes"
2014-02-25 16:17:48 +00:00
"fmt"
2014-06-26 11:03:23 +00:00
"io/ioutil"
2014-09-06 01:59:31 +00:00
"net"
2014-04-18 02:53:08 +00:00
"os"
2014-02-25 16:17:48 +00:00
"os/exec"
2014-08-28 00:25:10 +00:00
"path"
2014-07-30 02:22:50 +00:00
"path/filepath"
2014-02-17 23:14:30 +00:00
"reflect"
2014-04-18 01:58:20 +00:00
"regexp"
2014-04-18 02:53:08 +00:00
"sort"
2014-09-17 01:08:30 +00:00
"strconv"
2014-02-25 16:17:48 +00:00
"strings"
2014-04-18 02:46:03 +00:00
"sync"
2014-08-12 09:36:49 +00:00
"time"
2014-06-26 11:03:23 +00:00
2014-09-17 01:08:30 +00:00
"github.com/docker/docker/nat"
2015-03-23 06:27:04 +00:00
"github.com/docker/docker/pkg/resolvconf"
2015-04-18 16:46:47 +00:00
"github.com/go-check/check"
2014-02-25 16:17:48 +00:00
)
// "test123" should be printed by docker run
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEchoStdout ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "busybox" , "echo" , "test123" )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
if out != "test123\n" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "container should've printed 'test123'" )
2014-02-25 16:17:48 +00:00
}
}
// "test" should be printed
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEchoStdoutWithMemoryLimit ( c * check . C ) {
2014-11-26 18:19:10 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-m" , "16m" , "busybox" , "echo" , "test" )
2014-02-25 16:17:48 +00:00
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
2014-09-02 00:09:52 +00:00
out = strings . Trim ( out , "\r\n" )
if expected := "test" ; out != expected {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "container should've printed %q but printed %q" , expected , out )
2014-02-25 16:17:48 +00:00
}
}
2015-02-09 02:36:49 +00:00
// should run without memory swap
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithoutMemoryswapLimit ( c * check . C ) {
2015-02-09 02:36:49 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-m" , "16m" , "--memory-swap" , "-1" , "busybox" , "true" )
out , _ , err := runCommandWithOutput ( runCmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container, output: %q" , out )
2015-02-09 02:36:49 +00:00
}
}
2014-02-25 16:17:48 +00:00
// "test" should be printed
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEchoStdoutWitCPULimit ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-c" , "1000" , "busybox" , "echo" , "test" )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
if out != "test\n" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "container should've printed 'test'" )
2014-02-25 16:17:48 +00:00
}
}
// "test" should be printed
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEchoStdoutWithCPUAndMemoryLimit ( c * check . C ) {
2014-11-26 18:19:10 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-c" , "1000" , "-m" , "16m" , "busybox" , "echo" , "test" )
2014-02-25 16:17:48 +00:00
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
if out != "test\n" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "container should've printed 'test', got %q instead" , out )
2014-02-25 16:17:48 +00:00
}
}
2015-04-20 15:16:47 +00:00
// "test" should be printed
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEchoStdoutWitCPUQuota ( c * check . C ) {
2015-04-20 15:16:47 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "--cpu-quota" , "8000" , "--name" , "test" , "busybox" , "echo" , "test" )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-04-20 15:16:47 +00:00
}
out = strings . TrimSpace ( out )
if strings . Contains ( out , "Your kernel does not support CPU cfs quota" ) {
2015-04-18 16:46:47 +00:00
c . Skip ( "Your kernel does not support CPU cfs quota, skip this test" )
2015-04-20 15:16:47 +00:00
}
if out != "test" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "container should've printed 'test'" )
2015-04-20 15:16:47 +00:00
}
cmd := exec . Command ( dockerBinary , "inspect" , "-f" , "{{.HostConfig.CpuQuota}}" , "test" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to inspect container: %s, %v" , out , err )
2015-04-20 15:16:47 +00:00
}
out = strings . TrimSpace ( out )
if out != "8000" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "setting the CPU CFS quota failed" )
2015-04-20 15:16:47 +00:00
}
}
2014-02-25 16:17:48 +00:00
// "test" should be printed
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEchoNamedContainer ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "--name" , "testfoonamedcontainer" , "busybox" , "echo" , "test" )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
if out != "test\n" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "container should've printed 'test'" )
2014-02-25 16:17:48 +00:00
}
if err := deleteContainer ( "testfoonamedcontainer" ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Errorf ( "failed to remove the named container: %v" , err )
2014-02-25 16:17:48 +00:00
}
}
2014-04-29 05:22:54 +00:00
// docker run should not leak file descriptors
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunLeakyFileDescriptors ( c * check . C ) {
2014-04-29 05:22:54 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "busybox" , "ls" , "-C" , "/proc/self/fd" )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-04-29 05:22:54 +00:00
// normally, we should only get 0, 1, and 2, but 3 gets created by "ls" when it does "opendir" on the "fd" directory
if out != "0 1 2 3\n" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "container should've printed '0 1 2 3', not: %s" , out )
2014-04-29 05:22:54 +00:00
}
}
2015-03-11 05:09:09 +00:00
// it should be possible to lookup Google DNS
2014-02-25 16:17:48 +00:00
// this will fail when Internet access is unavailable
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunLookupGoogleDns ( c * check . C ) {
testRequires ( c , Network )
2015-02-20 06:56:02 +00:00
2015-03-11 05:09:09 +00:00
out , _ , _ , err := runCommandWithStdoutStderr ( exec . Command ( dockerBinary , "run" , "busybox" , "nslookup" , "google.com" ) )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
}
// the exit code should be 0
// some versions of lxc might make this test fail
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunExitCodeZero ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "busybox" , "true" )
2014-10-14 21:40:28 +00:00
if out , _ , err := runCommandWithOutput ( runCmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Errorf ( "container should've exited with exit code 0: %s, %v" , out , err )
2014-02-25 16:17:48 +00:00
}
}
// the exit code should be 1
// some versions of lxc might make this test fail
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunExitCodeOne ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "busybox" , "false" )
exitCode , err := runCommand ( runCmd )
if err != nil && ! strings . Contains ( "exit status 1" , fmt . Sprintf ( "%s" , err ) ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-02-25 16:17:48 +00:00
}
if exitCode != 1 {
2015-04-18 16:46:47 +00:00
c . Errorf ( "container should've exited with exit code 1" )
2014-02-25 16:17:48 +00:00
}
}
// it should be possible to pipe in data via stdin to a process running in a container
// some versions of lxc might make this test fail
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunStdinPipe ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( "bash" , "-c" , ` echo "blahblah" | docker run -i -a stdin busybox cat ` )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
2015-04-06 13:21:18 +00:00
out = strings . TrimSpace ( out )
2014-02-25 16:17:48 +00:00
inspectCmd := exec . Command ( dockerBinary , "inspect" , out )
2014-10-14 21:40:28 +00:00
if out , _ , err := runCommandWithOutput ( inspectCmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "out should've been a container id: %s %v" , out , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
waitCmd := exec . Command ( dockerBinary , "wait" , out )
2014-10-14 21:40:28 +00:00
if waitOut , _ , err := runCommandWithOutput ( waitCmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "error thrown while waiting for container: %s, %v" , waitOut , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
logsCmd := exec . Command ( dockerBinary , "logs" , out )
2014-10-14 21:40:28 +00:00
logsOut , _ , err := runCommandWithOutput ( logsCmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "error thrown while trying to get container logs: %s, %v" , logsOut , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
2015-04-06 13:21:18 +00:00
containerLogs := strings . TrimSpace ( logsOut )
2014-02-25 16:17:48 +00:00
if containerLogs != "blahblah" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "logs didn't print the container's logs %s" , containerLogs )
2014-02-25 16:17:48 +00:00
}
rmCmd := exec . Command ( dockerBinary , "rm" , out )
2014-10-14 21:40:28 +00:00
if out , _ , err = runCommandWithOutput ( rmCmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "rm failed to remove container: %s, %v" , out , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
}
// the container's ID should be printed when starting a container in detached mode
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunDetachedContainerIDPrinting ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-d" , "busybox" , "true" )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
2015-04-06 13:21:18 +00:00
out = strings . TrimSpace ( out )
2014-02-25 16:17:48 +00:00
inspectCmd := exec . Command ( dockerBinary , "inspect" , out )
2014-10-14 21:40:28 +00:00
if inspectOut , _ , err := runCommandWithOutput ( inspectCmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "out should've been a container id: %s %v" , inspectOut , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
waitCmd := exec . Command ( dockerBinary , "wait" , out )
2014-10-14 21:40:28 +00:00
if waitOut , _ , err := runCommandWithOutput ( waitCmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "error thrown while waiting for container: %s, %v" , waitOut , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
rmCmd := exec . Command ( dockerBinary , "rm" , out )
rmOut , _ , err := runCommandWithOutput ( rmCmd )
2014-10-14 21:40:28 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "rm failed to remove container: %s, %v" , rmOut , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
2015-04-06 13:21:18 +00:00
rmOut = strings . TrimSpace ( rmOut )
2014-02-25 16:17:48 +00:00
if rmOut != out {
2015-04-18 16:46:47 +00:00
c . Errorf ( "rm didn't print the container ID %s %s" , out , rmOut )
2014-02-25 16:17:48 +00:00
}
}
// the working directory should be set correctly
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWorkingDirectory ( c * check . C ) {
2014-02-25 16:17:48 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-w" , "/root" , "busybox" , "pwd" )
out , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
2014-09-12 13:51:21 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2014-09-12 13:51:21 +00:00
}
2014-02-25 16:17:48 +00:00
2015-04-06 13:21:18 +00:00
out = strings . TrimSpace ( out )
2014-02-25 16:17:48 +00:00
if out != "/root" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "-w failed to set working directory" )
2014-02-25 16:17:48 +00:00
}
runCmd = exec . Command ( dockerBinary , "run" , "--workdir" , "/root" , "busybox" , "pwd" )
out , _ , _ , err = runCommandWithStdoutStderr ( runCmd )
2014-10-14 21:40:28 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-10-14 21:40:28 +00:00
}
2014-02-25 16:17:48 +00:00
2015-04-06 13:21:18 +00:00
out = strings . TrimSpace ( out )
2014-02-25 16:17:48 +00:00
if out != "/root" {
2015-04-18 16:46:47 +00:00
c . Errorf ( "--workdir failed to set working directory" )
2014-02-25 16:17:48 +00:00
}
}
// pinging Google's DNS resolver should fail when we disable the networking
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithoutNetworking ( c * check . C ) {
2014-05-23 18:31:01 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "--net=none" , "busybox" , "ping" , "-c" , "1" , "8.8.8.8" )
2014-02-25 16:17:48 +00:00
out , _ , exitCode , err := runCommandWithStdoutStderr ( runCmd )
if err != nil && exitCode != 1 {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-02-25 16:17:48 +00:00
}
if exitCode != 1 {
2015-04-18 16:46:47 +00:00
c . Errorf ( "--net=none should've disabled the network; the container shouldn't have been able to ping 8.8.8.8" )
2014-02-25 16:17:48 +00:00
}
runCmd = exec . Command ( dockerBinary , "run" , "-n=false" , "busybox" , "ping" , "-c" , "1" , "8.8.8.8" )
out , _ , exitCode , err = runCommandWithStdoutStderr ( runCmd )
if err != nil && exitCode != 1 {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-02-25 16:17:48 +00:00
}
if exitCode != 1 {
2015-04-18 16:46:47 +00:00
c . Errorf ( "-n=false should've disabled the network; the container shouldn't have been able to ping 8.8.8.8" )
2014-02-25 16:17:48 +00:00
}
}
2014-03-31 17:41:40 +00:00
2015-01-14 07:25:58 +00:00
//test --link use container name to link target
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunLinksContainerWithContainerName ( c * check . C ) {
2015-01-18 03:21:45 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-i" , "-t" , "-d" , "--name" , "parent" , "busybox" )
2015-01-14 07:25:58 +00:00
out , _ , _ , err := runCommandWithStdoutStderr ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-01-14 07:25:58 +00:00
}
cmd = exec . Command ( dockerBinary , "inspect" , "-f" , "{{.NetworkSettings.IPAddress}}" , "parent" )
ip , _ , _ , err := runCommandWithStdoutStderr ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to inspect container: %v, output: %q" , err , ip )
2015-01-14 07:25:58 +00:00
}
ip = strings . TrimSpace ( ip )
cmd = exec . Command ( dockerBinary , "run" , "--link" , "parent:test" , "busybox" , "/bin/cat" , "/etc/hosts" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-01-14 07:25:58 +00:00
}
if ! strings . Contains ( out , ip + " test" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "use a container name to link target failed" )
2015-01-14 07:25:58 +00:00
}
}
//test --link use container id to link target
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunLinksContainerWithContainerId ( c * check . C ) {
2015-01-18 03:21:45 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-i" , "-t" , "-d" , "busybox" )
2015-01-14 07:25:58 +00:00
cID , _ , _ , err := runCommandWithStdoutStderr ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , cID )
2015-01-14 07:25:58 +00:00
}
cID = strings . TrimSpace ( cID )
cmd = exec . Command ( dockerBinary , "inspect" , "-f" , "{{.NetworkSettings.IPAddress}}" , cID )
ip , _ , _ , err := runCommandWithStdoutStderr ( cmd )
if err != nil {
2015-04-27 20:33:30 +00:00
c . Fatalf ( "failed to inspect container: %v, output: %q" , err , ip )
2015-01-14 07:25:58 +00:00
}
ip = strings . TrimSpace ( ip )
cmd = exec . Command ( dockerBinary , "run" , "--link" , cID + ":test" , "busybox" , "/bin/cat" , "/etc/hosts" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-01-14 07:25:58 +00:00
}
if ! strings . Contains ( out , ip + " test" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "use a container id to link target failed" )
2015-01-14 07:25:58 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunLinkToContainerNetMode ( c * check . C ) {
2015-03-17 14:50:12 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--name" , "test" , "-d" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-03-17 14:50:12 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--name" , "parent" , "-d" , "--net=container:test" , "busybox" , "top" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-03-17 14:50:12 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "-d" , "--link=parent:parent" , "busybox" , "top" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-03-17 14:50:12 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--name" , "child" , "-d" , "--net=container:parent" , "busybox" , "top" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-03-17 14:50:12 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "-d" , "--link=child:child" , "busybox" , "top" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-03-17 14:50:12 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunModeNetContainerHostname ( c * check . C ) {
testRequires ( c , ExecSupport )
2015-03-19 09:03:40 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-i" , "-d" , "--name" , "parent" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-03-19 09:03:40 +00:00
}
cmd = exec . Command ( dockerBinary , "exec" , "parent" , "cat" , "/etc/hostname" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to exec command: %v, output: %q" , err , out )
2015-03-19 09:03:40 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--net=container:parent" , "busybox" , "cat" , "/etc/hostname" )
out1 , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out1 )
2015-03-19 09:03:40 +00:00
}
if out1 != out {
2015-04-18 16:46:47 +00:00
c . Fatal ( "containers with shared net namespace should have same hostname" )
2015-03-19 09:03:40 +00:00
}
}
2014-03-31 17:41:40 +00:00
// Regression test for #4741
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithVolumesAsFiles ( c * check . C ) {
2014-03-31 17:41:40 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "--name" , "test-data" , "--volume" , "/etc/hosts:/target-file" , "busybox" , "true" )
out , stderr , exitCode , err := runCommandWithStdoutStderr ( runCmd )
if err != nil && exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatal ( "1" , out , stderr , err )
2014-03-31 17:41:40 +00:00
}
runCmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "test-data" , "busybox" , "cat" , "/target-file" )
out , stderr , exitCode , err = runCommandWithStdoutStderr ( runCmd )
if err != nil && exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatal ( "2" , out , stderr , err )
2014-03-31 17:41:40 +00:00
}
}
2014-03-31 19:10:19 +00:00
2014-04-03 14:27:07 +00:00
// Regression test for #4979
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithVolumesFromExited ( c * check . C ) {
2014-04-03 14:27:07 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "--name" , "test-data" , "--volume" , "/some/dir" , "busybox" , "touch" , "/some/dir/file" )
out , stderr , exitCode , err := runCommandWithStdoutStderr ( runCmd )
if err != nil && exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatal ( "1" , out , stderr , err )
2014-04-03 14:27:07 +00:00
}
runCmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "test-data" , "busybox" , "cat" , "/some/dir/file" )
out , stderr , exitCode , err = runCommandWithStdoutStderr ( runCmd )
if err != nil && exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatal ( "2" , out , stderr , err )
2014-04-03 14:27:07 +00:00
}
}
2015-03-30 18:35:37 +00:00
// Volume path is a symlink which also exists on the host, and the host side is a file not a dir
// But the volume call is just a normal volume, not a bind mount
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCreateVolumesInSymlinkDir ( c * check . C ) {
testRequires ( c , SameHostDaemon )
testRequires ( c , NativeExecDriver )
2015-03-30 18:35:37 +00:00
name := "test-volume-symlink"
dir , err := ioutil . TempDir ( "" , name )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-03-29 05:35:36 +00:00
}
2015-03-30 18:35:37 +00:00
defer os . RemoveAll ( dir )
f , err := os . OpenFile ( filepath . Join ( dir , "test" ) , os . O_CREATE , 0700 )
2015-03-29 05:35:36 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-03-30 18:35:37 +00:00
}
f . Close ( )
dockerFile := fmt . Sprintf ( "FROM busybox\nRUN mkdir -p %s\nRUN ln -s %s /test" , dir , dir )
if _ , err := buildImage ( name , dockerFile , false ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-03-30 18:35:37 +00:00
}
2015-04-18 16:46:47 +00:00
out , _ , err := runCommandWithOutput ( exec . Command ( dockerBinary , "run" , "-v" , "/test/test" , name ) )
if err != nil {
c . Fatalf ( "Failed with errors: %s, %v" , out , err )
}
2015-03-29 05:35:36 +00:00
}
2014-03-31 19:10:19 +00:00
// Regression test for #4830
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithRelativePath ( c * check . C ) {
2014-03-31 19:10:19 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-v" , "tmp:/other-tmp" , "busybox" , "true" )
if _ , _ , _ , err := runCommandWithStdoutStderr ( runCmd ) ; err == nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "relative path should result in an error" )
2014-03-31 19:10:19 +00:00
}
}
2014-04-08 01:23:22 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVolumesMountedAsReadonly ( c * check . C ) {
2014-04-08 01:23:22 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-v" , "/test:/test:ro" , "busybox" , "touch" , "/test/somefile" )
if code , err := runCommand ( cmd ) ; err == nil || code == 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "run should fail because volume is ro: exit code %d" , code )
2014-04-08 01:23:22 +00:00
}
}
2014-04-08 09:26:09 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVolumesFromInReadonlyMode ( c * check . C ) {
2014-04-08 09:26:09 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--name" , "parent" , "-v" , "/test" , "busybox" , "true" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-08 09:26:09 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent:ro" , "busybox" , "touch" , "/test/file" )
if code , err := runCommand ( cmd ) ; err == nil || code == 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "run should fail because volume is ro: exit code %d" , code )
2014-04-08 09:26:09 +00:00
}
}
// Regression test for #1201
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVolumesFromInReadWriteMode ( c * check . C ) {
2014-04-08 09:26:09 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--name" , "parent" , "-v" , "/test" , "busybox" , "true" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-08 09:26:09 +00:00
}
2014-10-03 20:55:39 +00:00
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent:rw" , "busybox" , "touch" , "/test/file" )
2014-10-03 22:33:11 +00:00
if out , _ , err := runCommandWithOutput ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "running --volumes-from parent:rw failed with output: %q\nerror: %v" , out , err )
2014-10-03 22:33:11 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent:bar" , "busybox" , "touch" , "/test/file" )
2014-12-18 14:57:36 +00:00
if out , _ , err := runCommandWithOutput ( cmd ) ; err == nil || ! strings . Contains ( out , "invalid mode for volumes-from: bar" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "running --volumes-from foo:bar should have failed with invalid mount mode: %q" , out )
2014-10-03 22:33:11 +00:00
}
2014-04-08 09:26:09 +00:00
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent" , "busybox" , "touch" , "/test/file" )
2014-10-03 22:33:11 +00:00
if out , _ , err := runCommandWithOutput ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "running --volumes-from parent failed with output: %q\nerror: %v" , out , err )
2014-04-08 09:26:09 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestVolumesFromGetsProperMode ( c * check . C ) {
2014-08-21 21:57:46 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--name" , "parent" , "-v" , "/test:/test:ro" , "busybox" , "true" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-21 21:57:46 +00:00
}
2015-04-20 17:54:47 +00:00
// Expect this "rw" mode to be be ignored since the inherited volume is "ro"
2014-08-21 21:57:46 +00:00
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent:rw" , "busybox" , "touch" , "/test/file" )
if _ , err := runCommand ( cmd ) ; err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected volumes-from to inherit read-only volume even when passing in `rw`" )
2014-08-28 14:18:08 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--name" , "parent2" , "-v" , "/test:/test:ro" , "busybox" , "true" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-28 14:18:08 +00:00
}
// Expect this to be read-only since both are "ro"
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent2:ro" , "busybox" , "touch" , "/test/file" )
if _ , err := runCommand ( cmd ) ; err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected volumes-from to inherit read-only volume even when passing in `ro`" )
2014-08-21 21:57:46 +00:00
}
}
2015-02-06 22:00:53 +00:00
// Test for GH#10618
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunNoDupVolumes ( c * check . C ) {
2015-02-25 02:50:55 +00:00
mountstr1 := randomUnixTmpDirPath ( "test1" ) + ":/someplace"
mountstr2 := randomUnixTmpDirPath ( "test2" ) + ":/someplace"
2015-02-09 16:17:41 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-v" , mountstr1 , "-v" , mountstr2 , "busybox" , "true" )
2015-02-06 22:00:53 +00:00
if out , _ , err := runCommandWithOutput ( cmd ) ; err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected error about duplicate volume definitions" )
2015-02-06 22:00:53 +00:00
} else {
if ! strings . Contains ( out , "Duplicate volume" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Expected 'duplicate volume' error, got %v" , err )
2015-02-06 22:00:53 +00:00
}
}
}
2014-04-08 09:26:09 +00:00
// Test for #1351
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunApplyVolumesFromBeforeVolumes ( c * check . C ) {
2014-04-08 09:26:09 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--name" , "parent" , "-v" , "/test" , "busybox" , "touch" , "/test/foo" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-08 09:26:09 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent" , "-v" , "/test" , "busybox" , "cat" , "/test/foo" )
2014-08-28 14:18:08 +00:00
if out , _ , err := runCommandWithOutput ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-04-08 09:26:09 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunMultipleVolumesFrom ( c * check . C ) {
2014-04-08 09:26:09 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--name" , "parent1" , "-v" , "/test" , "busybox" , "touch" , "/test/foo" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-08 09:26:09 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--name" , "parent2" , "-v" , "/other" , "busybox" , "touch" , "/other/bar" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-08 09:26:09 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "parent1" , "--volumes-from" , "parent2" ,
"busybox" , "sh" , "-c" , "cat /test/foo && cat /other/bar" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-08 09:26:09 +00:00
}
}
2014-04-18 01:58:20 +00:00
2014-04-18 21:35:16 +00:00
// this tests verifies the ID format for the container
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVerifyContainerID ( c * check . C ) {
2014-04-18 21:35:16 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "busybox" , "true" )
out , exit , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
if exit != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected exit code 0 received %d" , exit )
2014-04-18 21:35:16 +00:00
}
match , err := regexp . MatchString ( "^[0-9a-f]{64}$" , strings . TrimSuffix ( out , "\n" ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
if ! match {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Invalid container ID: %s" , out )
2014-04-18 21:35:16 +00:00
}
}
// Test that creating a container with a volume doesn't crash. Regression test for #995.
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCreateVolume ( c * check . C ) {
2014-04-18 21:35:16 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-v" , "/var/lib/data" , "busybox" , "true" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
}
2014-04-25 01:22:22 +00:00
// Test that creating a volume with a symlink in its path works correctly. Test for #5152.
// Note that this bug happens only with symlinks with a target that starts with '/'.
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCreateVolumeWithSymlink ( c * check . C ) {
2015-02-20 06:56:02 +00:00
image := "docker-test-createvolumewithsymlink"
buildCmd := exec . Command ( dockerBinary , "build" , "-t" , image , "-" )
2014-05-27 21:54:38 +00:00
buildCmd . Stdin = strings . NewReader ( ` FROM busybox
2015-01-23 12:17:05 +00:00
RUN ln - s home / bar ` )
2014-05-27 21:54:38 +00:00
buildCmd . Dir = workingDirectory
2014-04-25 01:22:22 +00:00
err := buildCmd . Run ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "could not build '%s': %v" , image , err )
2014-04-25 01:22:22 +00:00
}
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-v" , "/bar/foo" , "--name" , "test-createvolumewithsymlink" , image , "sh" , "-c" , "mount | grep -q /home/foo" )
2014-04-25 01:22:22 +00:00
exitCode , err := runCommand ( cmd )
if err != nil || exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "[run] err: %v, exitcode: %d" , err , exitCode )
2014-04-25 01:22:22 +00:00
}
var volPath string
2014-05-27 21:54:38 +00:00
cmd = exec . Command ( dockerBinary , "inspect" , "-f" , "{{range .Volumes}}{{.}}{{end}}" , "test-createvolumewithsymlink" )
2014-04-25 01:22:22 +00:00
volPath , exitCode , err = runCommandWithOutput ( cmd )
if err != nil || exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "[inspect] err: %v, exitcode: %d" , err , exitCode )
2014-04-25 01:22:22 +00:00
}
2014-05-27 21:54:38 +00:00
cmd = exec . Command ( dockerBinary , "rm" , "-v" , "test-createvolumewithsymlink" )
2014-04-25 01:22:22 +00:00
exitCode , err = runCommand ( cmd )
if err != nil || exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "[rm] err: %v, exitcode: %d" , err , exitCode )
2014-04-25 01:22:22 +00:00
}
f , err := os . Open ( volPath )
defer f . Close ( )
if ! os . IsNotExist ( err ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "[open] (expecting 'file does not exist' error) err: %v, volPath: %s" , err , volPath )
2014-04-25 01:22:22 +00:00
}
}
2014-05-27 21:49:43 +00:00
// Tests that a volume path that has a symlink exists in a container mounting it with `--volumes-from`.
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVolumesFromSymlinkPath ( c * check . C ) {
2014-11-17 16:05:49 +00:00
name := "docker-test-volumesfromsymlinkpath"
2015-02-20 06:56:02 +00:00
2014-11-17 16:05:49 +00:00
buildCmd := exec . Command ( dockerBinary , "build" , "-t" , name , "-" )
2014-05-27 21:49:43 +00:00
buildCmd . Stdin = strings . NewReader ( ` FROM busybox
2015-01-23 12:17:05 +00:00
RUN ln - s home / foo
2014-05-27 21:49:43 +00:00
VOLUME [ "/foo/bar" ] ` )
buildCmd . Dir = workingDirectory
err := buildCmd . Run ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "could not build 'docker-test-volumesfromsymlinkpath': %v" , err )
2014-05-27 21:49:43 +00:00
}
2014-11-17 16:05:49 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--name" , "test-volumesfromsymlinkpath" , name )
2014-05-27 21:49:43 +00:00
exitCode , err := runCommand ( cmd )
if err != nil || exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "[run] (volume) err: %v, exitcode: %d" , err , exitCode )
2014-05-27 21:49:43 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "test-volumesfromsymlinkpath" , "busybox" , "sh" , "-c" , "ls /foo | grep -q bar" )
exitCode , err = runCommand ( cmd )
if err != nil || exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "[run] err: %v, exitcode: %d" , err , exitCode )
2014-05-27 21:49:43 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunExitCode ( c * check . C ) {
2014-04-18 21:35:16 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "/bin/sh" , "-c" , "exit 72" )
exit , err := runCommand ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "should not have a non nil error" )
2014-04-18 21:35:16 +00:00
}
if exit != 72 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected exit code 72 received %d" , exit )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUserDefaultsToRoot ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "id" )
2014-04-18 21:35:16 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-04-18 21:35:16 +00:00
}
if ! strings . Contains ( out , "uid=0(root) gid=0(root)" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected root user got %s" , out )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUserByName ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-u" , "root" , "busybox" , "id" )
2014-04-18 21:35:16 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-04-18 21:35:16 +00:00
}
if ! strings . Contains ( out , "uid=0(root) gid=0(root)" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected root user got %s" , out )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUserByID ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-u" , "1" , "busybox" , "id" )
2014-04-18 21:35:16 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-04-18 21:35:16 +00:00
}
if ! strings . Contains ( out , "uid=1(daemon) gid=1(daemon)" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected daemon user got %s" , out )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUserByIDBig ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-u" , "2147483648" , "busybox" , "id" )
2014-05-17 18:43:31 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "No error, but must be." , out )
2014-05-17 18:43:31 +00:00
}
if ! strings . Contains ( out , "Uids and gids must be in range" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected error about uids range, got %s" , out )
2014-05-17 18:43:31 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUserByIDNegative ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-u" , "-1" , "busybox" , "id" )
2014-05-17 18:43:31 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "No error, but must be." , out )
2014-05-17 18:43:31 +00:00
}
if ! strings . Contains ( out , "Uids and gids must be in range" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected error about uids range, got %s" , out )
2014-05-17 18:43:31 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUserByIDZero ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-u" , "0" , "busybox" , "id" )
2014-05-17 18:43:31 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-05-17 18:43:31 +00:00
}
if ! strings . Contains ( out , "uid=0(root) gid=0(root) groups=10(wheel)" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected daemon user got %s" , out )
2014-05-17 18:43:31 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUserNotFound ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-u" , "notme" , "busybox" , "id" )
2014-04-18 21:35:16 +00:00
_ , err := runCommand ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "unknown user should cause container to fail" )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunTwoConcurrentContainers ( c * check . C ) {
2014-04-18 21:35:16 +00:00
group := sync . WaitGroup { }
group . Add ( 2 )
for i := 0 ; i < 2 ; i ++ {
go func ( ) {
defer group . Done ( )
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "sleep" , "2" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
} ( )
}
group . Wait ( )
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEnvironment ( c * check . C ) {
2014-07-31 18:45:32 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-h" , "testing" , "-e=FALSE=true" , "-e=TRUE" , "-e=TRICKY" , "-e=HOME=" , "busybox" , "env" )
2014-04-18 21:35:16 +00:00
cmd . Env = append ( os . Environ ( ) ,
"TRUE=false" ,
"TRICKY=tri\ncky\n" ,
)
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-04-18 21:35:16 +00:00
}
2015-01-20 00:32:29 +00:00
actualEnvLxc := strings . Split ( strings . TrimSpace ( out ) , "\n" )
actualEnv := [ ] string { }
for i := range actualEnvLxc {
if actualEnvLxc [ i ] != "container=lxc" {
actualEnv = append ( actualEnv , actualEnvLxc [ i ] )
}
}
2014-04-18 21:35:16 +00:00
sort . Strings ( actualEnv )
goodEnv := [ ] string {
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" ,
"HOSTNAME=testing" ,
"FALSE=true" ,
"TRUE=false" ,
"TRICKY=tri" ,
"cky" ,
"" ,
2014-02-23 03:06:37 +00:00
"HOME=/root" ,
2014-04-18 21:35:16 +00:00
}
sort . Strings ( goodEnv )
if len ( goodEnv ) != len ( actualEnv ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong environment: should be %d variables, not: %q\n" , len ( goodEnv ) , strings . Join ( actualEnv , ", " ) )
2014-04-18 21:35:16 +00:00
}
for i := range goodEnv {
if actualEnv [ i ] != goodEnv [ i ] {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong environment variable: should be %s, not %s" , goodEnv [ i ] , actualEnv [ i ] )
2014-04-18 21:35:16 +00:00
}
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEnvironmentErase ( c * check . C ) {
2015-01-16 20:57:08 +00:00
// Test to make sure that when we use -e on env vars that are
// not set in our local env that they're removed (if present) in
// the container
2015-02-20 06:56:02 +00:00
2015-01-16 20:57:08 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-e" , "FOO" , "-e" , "HOSTNAME" , "busybox" , "env" )
2015-03-07 09:03:44 +00:00
cmd . Env = appendBaseEnv ( [ ] string { } )
2015-02-12 19:20:48 +00:00
2015-01-16 20:57:08 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2015-01-16 20:57:08 +00:00
}
2015-01-20 00:32:29 +00:00
actualEnvLxc := strings . Split ( strings . TrimSpace ( out ) , "\n" )
actualEnv := [ ] string { }
for i := range actualEnvLxc {
if actualEnvLxc [ i ] != "container=lxc" {
actualEnv = append ( actualEnv , actualEnvLxc [ i ] )
}
}
2015-01-16 20:57:08 +00:00
sort . Strings ( actualEnv )
goodEnv := [ ] string {
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" ,
"HOME=/root" ,
}
sort . Strings ( goodEnv )
if len ( goodEnv ) != len ( actualEnv ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong environment: should be %d variables, not: %q\n" , len ( goodEnv ) , strings . Join ( actualEnv , ", " ) )
2015-01-16 20:57:08 +00:00
}
for i := range goodEnv {
if actualEnv [ i ] != goodEnv [ i ] {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong environment variable: should be %s, not %s" , goodEnv [ i ] , actualEnv [ i ] )
2015-01-16 20:57:08 +00:00
}
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEnvironmentOverride ( c * check . C ) {
2015-01-16 20:57:08 +00:00
// Test to make sure that when we use -e on env vars that are
// already in the env that we're overriding them
2015-02-20 06:56:02 +00:00
2015-01-16 20:57:08 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-e" , "HOSTNAME" , "-e" , "HOME=/root2" , "busybox" , "env" )
2015-03-07 09:03:44 +00:00
cmd . Env = appendBaseEnv ( [ ] string { "HOSTNAME=bar" } )
2015-02-12 19:20:48 +00:00
2015-01-16 20:57:08 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2015-01-16 20:57:08 +00:00
}
2015-01-20 00:32:29 +00:00
actualEnvLxc := strings . Split ( strings . TrimSpace ( out ) , "\n" )
actualEnv := [ ] string { }
for i := range actualEnvLxc {
if actualEnvLxc [ i ] != "container=lxc" {
actualEnv = append ( actualEnv , actualEnvLxc [ i ] )
}
}
2015-01-16 20:57:08 +00:00
sort . Strings ( actualEnv )
goodEnv := [ ] string {
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin" ,
"HOME=/root2" ,
"HOSTNAME=bar" ,
}
sort . Strings ( goodEnv )
if len ( goodEnv ) != len ( actualEnv ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong environment: should be %d variables, not: %q\n" , len ( goodEnv ) , strings . Join ( actualEnv , ", " ) )
2015-01-16 20:57:08 +00:00
}
for i := range goodEnv {
if actualEnv [ i ] != goodEnv [ i ] {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong environment variable: should be %s, not %s" , goodEnv [ i ] , actualEnv [ i ] )
2015-01-16 20:57:08 +00:00
}
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunContainerNetwork ( c * check . C ) {
2014-04-18 21:35:16 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "ping" , "-c" , "1" , "127.0.0.1" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
}
// Issue #4681
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunLoopbackWhenNetworkDisabled ( c * check . C ) {
2014-05-23 18:31:01 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--net=none" , "busybox" , "ping" , "-c" , "1" , "127.0.0.1" )
2014-04-18 21:35:16 +00:00
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunNetHostNotAllowedWithLinks ( c * check . C ) {
out , _ , err := runCommandWithOutput ( exec . Command ( dockerBinary , "run" , "--name" , "linked" , "busybox" , "true" ) )
if err != nil {
c . Fatalf ( "Failed with errors: %s, %v" , out , err )
}
2014-07-16 21:09:30 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--net=host" , "--link" , "linked:linked" , "busybox" , "true" )
2015-04-18 16:46:47 +00:00
_ , _ , err = runCommandWithOutput ( cmd )
2014-07-16 21:09:30 +00:00
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected error" )
2014-07-16 21:09:30 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunLoopbackOnlyExistsWhenNetworkingDisabled ( c * check . C ) {
2014-05-23 20:22:01 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--net=none" , "busybox" , "ip" , "-o" , "-4" , "a" , "show" , "up" )
2014-04-18 21:35:16 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-04-18 21:35:16 +00:00
}
2014-05-23 20:22:01 +00:00
var (
count = 0
parts = strings . Split ( out , "\n" )
)
for _ , l := range parts {
if l != "" {
count ++
}
2014-04-18 21:35:16 +00:00
}
2014-05-23 20:22:01 +00:00
if count != 1 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong interface count in container %d" , count )
2014-05-23 20:22:01 +00:00
}
if ! strings . HasPrefix ( out , "1: lo" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong interface in test container: expected [1: lo], got %s" , out )
2014-04-18 21:35:16 +00:00
}
}
2014-09-24 15:00:01 +00:00
// #7851 hostname outside container shows FQDN, inside only shortname
// For testing purposes it is not required to set host's hostname directly
// and use "--net=host" (as the original issue submitter did), as the same
// codepath is executed with "docker run -h <hostname>". Both were manually
// tested, but this testcase takes the simpler path of using "run -h .."
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunFullHostnameSet ( c * check . C ) {
2014-09-24 15:00:01 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-h" , "foo.bar.baz" , "busybox" , "hostname" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-09-24 15:00:01 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "foo.bar.baz" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected hostname 'foo.bar.baz', received %s" , actual )
2014-09-24 15:00:01 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunPrivilegedCanMknod ( c * check . C ) {
2014-04-18 21:35:16 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--privileged" , "busybox" , "sh" , "-c" , "mknod /tmp/sda b 8 0 && echo ok" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output ok received %s" , actual )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUnPrivilegedCanMknod ( c * check . C ) {
2014-04-18 21:35:16 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "sh" , "-c" , "mknod /tmp/sda b 8 0 && echo ok" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output ok received %s" , actual )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapDropInvalid ( c * check . C ) {
2014-07-10 23:38:11 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-drop=CHPASS" , "busybox" , "ls" )
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 23:38:11 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapDropCannotMknod ( c * check . C ) {
2014-07-10 21:51:15 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-drop=MKNOD" , "busybox" , "sh" , "-c" , "mknod /tmp/sda b 8 0 && echo ok" )
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 21:51:15 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual == "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output not ok received %s" , actual )
2014-07-10 21:51:15 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapDropCannotMknodLowerCase ( c * check . C ) {
2014-07-16 18:47:55 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-drop=mknod" , "busybox" , "sh" , "-c" , "mknod /tmp/sda b 8 0 && echo ok" )
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-16 18:47:55 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual == "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output not ok received %s" , actual )
2014-07-16 18:47:55 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapDropALLCannotMknod ( c * check . C ) {
2015-01-16 13:11:29 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-drop=ALL" , "--cap-add=SETGID" , "busybox" , "sh" , "-c" , "mknod /tmp/sda b 8 0 && echo ok" )
2014-07-10 22:31:01 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 22:31:01 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual == "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output not ok received %s" , actual )
2014-07-10 22:31:01 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapDropALLAddMknodCanMknod ( c * check . C ) {
2015-01-16 13:11:29 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-drop=ALL" , "--cap-add=MKNOD" , "--cap-add=SETGID" , "busybox" , "sh" , "-c" , "mknod /tmp/sda b 8 0 && echo ok" )
2014-07-10 23:02:39 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 23:02:39 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output ok received %s" , actual )
2014-07-10 23:02:39 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapAddInvalid ( c * check . C ) {
2014-07-10 23:38:11 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-add=CHPASS" , "busybox" , "ls" )
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 23:38:11 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapAddCanDownInterface ( c * check . C ) {
2014-07-10 21:51:15 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-add=NET_ADMIN" , "busybox" , "sh" , "-c" , "ip link set eth0 down && echo ok" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 21:51:15 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output ok received %s" , actual )
2014-07-10 21:51:15 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapAddALLCanDownInterface ( c * check . C ) {
2014-07-10 22:31:01 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-add=ALL" , "busybox" , "sh" , "-c" , "ip link set eth0 down && echo ok" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 22:31:01 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output ok received %s" , actual )
2014-07-10 22:31:01 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCapAddALLDropNetAdminCanDownInterface ( c * check . C ) {
2014-07-10 23:38:11 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cap-add=ALL" , "--cap-drop=NET_ADMIN" , "busybox" , "sh" , "-c" , "ip link set eth0 down && echo ok" )
2014-07-10 23:02:39 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-10 23:02:39 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual == "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output not ok received %s" , actual )
2014-07-10 23:02:39 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunPrivilegedCanMount ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--privileged" , "busybox" , "sh" , "-c" , "mount -t tmpfs none /tmp && echo ok" )
2014-04-18 21:35:16 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-04-18 21:35:16 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output ok received %s" , actual )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUnPrivilegedCannotMount ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "sh" , "-c" , "mount -t tmpfs none /tmp && echo ok" )
2014-04-18 21:35:16 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-04-18 21:35:16 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual == "ok" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output not ok received %s" , actual )
2014-04-18 21:35:16 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunSysNotWritableInNonPrivilegedContainers ( c * check . C ) {
2014-05-01 01:00:42 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "touch" , "/sys/kernel/profiling" )
2014-04-11 11:45:39 +00:00
if code , err := runCommand ( cmd ) ; err == nil || code == 0 {
2015-04-18 16:46:47 +00:00
c . Fatal ( "sys should not be writable in a non privileged container" )
2014-04-18 03:20:17 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunSysWritableInPrivilegedContainers ( c * check . C ) {
2014-05-01 01:00:42 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--privileged" , "busybox" , "touch" , "/sys/kernel/profiling" )
2014-04-11 11:45:39 +00:00
if code , err := runCommand ( cmd ) ; err != nil || code != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "sys should be writable in privileged container" )
2014-04-18 03:20:17 +00:00
}
2014-05-01 01:00:42 +00:00
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunProcNotWritableInNonPrivilegedContainers ( c * check . C ) {
2014-05-01 01:00:42 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "touch" , "/proc/sysrq-trigger" )
if code , err := runCommand ( cmd ) ; err == nil || code == 0 {
2015-04-18 16:46:47 +00:00
c . Fatal ( "proc should not be writable in a non privileged container" )
2014-05-01 01:00:42 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunProcWritableInPrivilegedContainers ( c * check . C ) {
2014-05-01 01:00:42 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--privileged" , "busybox" , "touch" , "/proc/sysrq-trigger" )
if code , err := runCommand ( cmd ) ; err != nil || code != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "proc should be writable in privileged container" )
2014-05-01 01:00:42 +00:00
}
2014-04-18 03:20:17 +00:00
}
2014-05-13 00:44:57 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithCpuset ( c * check . C ) {
2014-05-13 00:44:57 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cpuset" , "0" , "busybox" , "true" )
if code , err := runCommand ( cmd ) ; err != nil || code != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "container should run successfully with cpuset of 0: %s" , err )
2014-05-13 00:44:57 +00:00
}
}
2014-02-17 23:14:30 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithCpusetCpus ( c * check . C ) {
move resources from Config to HostConfig
Cgroup resources are host dependent, they should be in hostConfig.
For backward compatibility, we just copy it to hostConfig, and leave it in
Config for now, so there is no regressions, but the right way to use this
throught json is to put it in HostConfig, like:
{
"Hostname": "",
...
"HostConfig": {
"CpuShares": 512,
"Memory": 314572800,
...
}
}
As we will add CpusetMems, CpusetCpus is definitely a better name, but some
users are already using Cpuset in their http APIs, we also make it compatible.
The main idea is keep using Cpuset in Config Struct, and make it has the same
value as CpusetCpus, but not always, some scenarios:
- Users use --cpuset in docker command, it can setup cpuset.cpus and can
get Cpuset field from docker inspect or other http API which will get
config info.
- Users use --cpuset-cpus in docker command, ditto.
- Users use Cpuset field in their http APIs, ditto.
- Users use CpusetCpus field in their http APIs, they won't get Cpuset field
in Config info, because by then, they should already know what happens
to Cpuset.
Signed-off-by: Qiang Huang <h.huangqiang@huawei.com>
2015-03-11 01:31:18 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cpuset-cpus" , "0" , "busybox" , "true" )
if code , err := runCommand ( cmd ) ; err != nil || code != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "container should run successfully with cpuset-cpus of 0: %s" , err )
move resources from Config to HostConfig
Cgroup resources are host dependent, they should be in hostConfig.
For backward compatibility, we just copy it to hostConfig, and leave it in
Config for now, so there is no regressions, but the right way to use this
throught json is to put it in HostConfig, like:
{
"Hostname": "",
...
"HostConfig": {
"CpuShares": 512,
"Memory": 314572800,
...
}
}
As we will add CpusetMems, CpusetCpus is definitely a better name, but some
users are already using Cpuset in their http APIs, we also make it compatible.
The main idea is keep using Cpuset in Config Struct, and make it has the same
value as CpusetCpus, but not always, some scenarios:
- Users use --cpuset in docker command, it can setup cpuset.cpus and can
get Cpuset field from docker inspect or other http API which will get
config info.
- Users use --cpuset-cpus in docker command, ditto.
- Users use Cpuset field in their http APIs, ditto.
- Users use CpusetCpus field in their http APIs, they won't get Cpuset field
in Config info, because by then, they should already know what happens
to Cpuset.
Signed-off-by: Qiang Huang <h.huangqiang@huawei.com>
2015-03-11 01:31:18 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithCpusetMems ( c * check . C ) {
2015-04-15 01:33:46 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cpuset-mems" , "0" , "busybox" , "true" )
if code , err := runCommand ( cmd ) ; err != nil || code != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "container should run successfully with cpuset-mems of 0: %s" , err )
2015-04-15 01:33:46 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunDeviceNumbers ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "sh" , "-c" , "ls -l /dev/null" )
2014-02-17 23:14:30 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-02-17 23:14:30 +00:00
}
deviceLineFields := strings . Fields ( out )
deviceLineFields [ 6 ] = ""
deviceLineFields [ 7 ] = ""
deviceLineFields [ 8 ] = ""
expected := [ ] string { "crw-rw-rw-" , "1" , "root" , "root" , "1," , "3" , "" , "" , "" , "/dev/null" }
if ! ( reflect . DeepEqual ( deviceLineFields , expected ) ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output\ncrw-rw-rw- 1 root root 1, 3 May 24 13:29 /dev/null\n received\n %s\n" , out )
2014-02-17 23:14:30 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunThatCharacterDevicesActLikeCharacterDevices ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "sh" , "-c" , "dd if=/dev/zero of=/zero bs=1k count=5 2> /dev/null ; du -h /zero" )
2014-02-17 23:14:30 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-02-17 23:14:30 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual [ 0 ] == '0' {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected a new file called /zero to be create that is greater than 0 bytes long, but du says: %s" , actual )
2014-02-17 23:14:30 +00:00
}
}
2014-06-03 01:23:47 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUnprivilegedWithChroot ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "chroot" , "/" , "true" )
2014-06-03 01:23:47 +00:00
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-06-03 01:23:47 +00:00
}
}
2014-06-12 19:11:51 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAddingOptionalDevices ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--device" , "/dev/zero:/dev/nulo" , "busybox" , "sh" , "-c" , "ls /dev/nulo" )
2014-05-31 04:00:47 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-05-31 04:00:47 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "/dev/nulo" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output /dev/nulo, received %s" , actual )
2014-05-31 04:00:47 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunModeHostname ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2014-06-12 19:11:51 +00:00
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-h=testhostname" , "busybox" , "cat" , "/etc/hostname" )
2014-06-12 19:11:51 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-06-12 19:11:51 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != "testhostname" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected 'testhostname', but says: %q" , actual )
2014-06-12 19:11:51 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--net=host" , "busybox" , "cat" , "/etc/hostname" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-06-12 19:11:51 +00:00
}
hostname , err := os . Hostname ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-06-12 19:11:51 +00:00
}
if actual := strings . Trim ( out , "\r\n" ) ; actual != hostname {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected %q, but says: %q" , hostname , actual )
2014-06-12 19:11:51 +00:00
}
2014-06-24 16:53:53 +00:00
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunRootWorkdir ( c * check . C ) {
out , _ , err := runCommandWithOutput ( exec . Command ( dockerBinary , "run" , "--workdir" , "/" , "busybox" , "pwd" ) )
if err != nil {
c . Fatalf ( "Failed with errors: %s, %v" , out , err )
}
if out != "/\n" {
c . Fatalf ( "pwd returned %q (expected /\\n)" , s )
2014-06-24 16:53:53 +00:00
}
}
2014-06-26 17:50:18 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAllowBindMountingRoot ( c * check . C ) {
out , _ , err := runCommandWithOutput ( exec . Command ( dockerBinary , "run" , "-v" , "/:/host" , "busybox" , "ls" , "/host" ) )
if err != nil {
c . Fatalf ( "Failed with errors: %s, %v" , out , err )
}
2014-06-26 17:50:18 +00:00
}
2014-06-27 16:51:24 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunDisallowBindMountingRootToRoot ( c * check . C ) {
2014-06-27 16:51:24 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-v" , "/:/" , "busybox" , "ls" , "/host" )
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-06-27 16:51:24 +00:00
}
}
2014-06-26 11:03:23 +00:00
2015-01-09 17:06:48 +00:00
// Verify that a container gets default DNS when only localhost resolvers exist
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunDnsDefaultOptions ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-01-09 17:06:48 +00:00
// preserve original resolv.conf for restoring after test
2014-10-08 00:58:39 +00:00
origResolvConf , err := ioutil . ReadFile ( "/etc/resolv.conf" )
if os . IsNotExist ( err ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "/etc/resolv.conf does not exist" )
2014-10-08 00:58:39 +00:00
}
2015-01-09 17:06:48 +00:00
// defer restored original conf
2014-10-08 00:58:39 +00:00
defer func ( ) {
if err := ioutil . WriteFile ( "/etc/resolv.conf" , origResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-08 00:58:39 +00:00
}
} ( )
2015-01-09 17:06:48 +00:00
// test 3 cases: standard IPv4 localhost, commented out localhost, and IPv6 localhost
// 2 are removed from the file at container start, and the 3rd (commented out) one is ignored by
// GetNameservers(), leading to a replacement of nameservers with the default set
tmpResolvConf := [ ] byte ( "nameserver 127.0.0.1\n#nameserver 127.0.2.1\nnameserver ::1" )
if err := ioutil . WriteFile ( "/etc/resolv.conf" , tmpResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-01-09 17:06:48 +00:00
}
2014-06-26 11:03:23 +00:00
cmd := exec . Command ( dockerBinary , "run" , "busybox" , "cat" , "/etc/resolv.conf" )
actual , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , actual )
2014-06-26 11:03:23 +00:00
}
2015-01-09 17:06:48 +00:00
// check that the actual defaults are appended to the commented out
// localhost resolver (which should be preserved)
// NOTE: if we ever change the defaults from google dns, this will break
expected := "#nameserver 127.0.2.1\n\nnameserver 8.8.8.8\nnameserver 8.8.4.4"
2014-10-08 00:58:39 +00:00
if actual != expected {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected resolv.conf be: %q, but was: %q" , expected , actual )
2014-06-26 11:03:23 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunDnsOptions ( c * check . C ) {
2014-06-26 11:03:23 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--dns=127.0.0.1" , "--dns-search=mydomain" , "busybox" , "cat" , "/etc/resolv.conf" )
2015-03-10 14:22:29 +00:00
out , stderr , _ , err := runCommandWithStdoutStderr ( cmd )
2014-06-26 11:03:23 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-06-26 11:03:23 +00:00
}
2015-03-10 14:22:29 +00:00
// The client will get a warning on stderr when setting DNS to a localhost address; verify this:
if ! strings . Contains ( stderr , "Localhost DNS setting" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Expected warning on stderr about localhost resolver, but got %q" , stderr )
2015-03-10 14:22:29 +00:00
}
2014-06-26 11:03:23 +00:00
actual := strings . Replace ( strings . Trim ( out , "\r\n" ) , "\n" , " " , - 1 )
if actual != "nameserver 127.0.0.1 search mydomain" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected 'nameserver 127.0.0.1 search mydomain', but says: %q" , actual )
2014-06-26 11:03:23 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--dns=127.0.0.1" , "--dns-search=." , "busybox" , "cat" , "/etc/resolv.conf" )
2015-03-10 14:22:29 +00:00
out , _ , _ , err = runCommandWithStdoutStderr ( cmd )
2014-06-26 11:03:23 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-06-26 11:03:23 +00:00
}
actual = strings . Replace ( strings . Trim ( strings . Trim ( out , "\r\n" ) , " " ) , "\n" , " " , - 1 )
if actual != "nameserver 127.0.0.1" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected 'nameserver 127.0.0.1', but says: %q" , actual )
2014-06-26 11:03:23 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunDnsOptionsBasedOnHostResolvConf ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2014-10-07 22:35:32 +00:00
origResolvConf , err := ioutil . ReadFile ( "/etc/resolv.conf" )
2014-06-26 11:03:23 +00:00
if os . IsNotExist ( err ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "/etc/resolv.conf does not exist" )
2014-06-26 11:03:23 +00:00
}
2014-10-07 22:35:32 +00:00
hostNamservers := resolvconf . GetNameservers ( origResolvConf )
hostSearch := resolvconf . GetSearchDomains ( origResolvConf )
2014-06-26 11:03:23 +00:00
2015-02-19 04:06:23 +00:00
var out string
2014-06-26 11:03:23 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--dns=127.0.0.1" , "busybox" , "cat" , "/etc/resolv.conf" )
2015-03-10 14:22:29 +00:00
if out , _ , _ , err = runCommandWithStdoutStderr ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-06-26 11:03:23 +00:00
}
if actualNameservers := resolvconf . GetNameservers ( [ ] byte ( out ) ) ; string ( actualNameservers [ 0 ] ) != "127.0.0.1" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected '127.0.0.1', but says: %q" , string ( actualNameservers [ 0 ] ) )
2014-06-26 11:03:23 +00:00
}
actualSearch := resolvconf . GetSearchDomains ( [ ] byte ( out ) )
if len ( actualSearch ) != len ( hostSearch ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected %q search domain(s), but it has: %q" , len ( hostSearch ) , len ( actualSearch ) )
2014-06-26 11:03:23 +00:00
}
for i := range actualSearch {
if actualSearch [ i ] != hostSearch [ i ] {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected %q domain, but says: %q" , actualSearch [ i ] , hostSearch [ i ] )
2014-06-26 11:03:23 +00:00
}
}
cmd = exec . Command ( dockerBinary , "run" , "--dns-search=mydomain" , "busybox" , "cat" , "/etc/resolv.conf" )
2014-10-07 22:35:32 +00:00
if out , _ , err = runCommandWithOutput ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-06-26 11:03:23 +00:00
}
actualNameservers := resolvconf . GetNameservers ( [ ] byte ( out ) )
if len ( actualNameservers ) != len ( hostNamservers ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected %q nameserver(s), but it has: %q" , len ( hostNamservers ) , len ( actualNameservers ) )
2014-06-26 11:03:23 +00:00
}
for i := range actualNameservers {
if actualNameservers [ i ] != hostNamservers [ i ] {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected %q nameserver, but says: %q" , actualNameservers [ i ] , hostNamservers [ i ] )
2014-06-26 11:03:23 +00:00
}
}
if actualSearch = resolvconf . GetSearchDomains ( [ ] byte ( out ) ) ; string ( actualSearch [ 0 ] ) != "mydomain" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected 'mydomain', but says: %q" , string ( actualSearch [ 0 ] ) )
2014-10-07 22:35:32 +00:00
}
// test with file
tmpResolvConf := [ ] byte ( "search example.com\nnameserver 12.34.56.78\nnameserver 127.0.0.1" )
if err := ioutil . WriteFile ( "/etc/resolv.conf" , tmpResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-07 22:35:32 +00:00
}
// put the old resolvconf back
defer func ( ) {
if err := ioutil . WriteFile ( "/etc/resolv.conf" , origResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-07 22:35:32 +00:00
}
} ( )
resolvConf , err := ioutil . ReadFile ( "/etc/resolv.conf" )
if os . IsNotExist ( err ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "/etc/resolv.conf does not exist" )
2014-10-07 22:35:32 +00:00
}
hostNamservers = resolvconf . GetNameservers ( resolvConf )
hostSearch = resolvconf . GetSearchDomains ( resolvConf )
cmd = exec . Command ( dockerBinary , "run" , "busybox" , "cat" , "/etc/resolv.conf" )
if out , _ , err = runCommandWithOutput ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-10-07 22:35:32 +00:00
}
if actualNameservers = resolvconf . GetNameservers ( [ ] byte ( out ) ) ; string ( actualNameservers [ 0 ] ) != "12.34.56.78" || len ( actualNameservers ) != 1 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected '12.34.56.78', but has: %v" , actualNameservers )
2014-10-07 22:35:32 +00:00
}
actualSearch = resolvconf . GetSearchDomains ( [ ] byte ( out ) )
if len ( actualSearch ) != len ( hostSearch ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected %q search domain(s), but it has: %q" , len ( hostSearch ) , len ( actualSearch ) )
2014-10-07 22:35:32 +00:00
}
for i := range actualSearch {
if actualSearch [ i ] != hostSearch [ i ] {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected %q domain, but says: %q" , actualSearch [ i ] , hostSearch [ i ] )
2014-10-07 22:35:32 +00:00
}
2014-06-26 11:03:23 +00:00
}
}
2014-07-16 17:47:12 +00:00
2014-12-10 05:55:09 +00:00
// Test the file watch notifier on docker host's /etc/resolv.conf
// A go-routine is responsible for auto-updating containers which are
// stopped and have an unmodified copy of resolv.conf, as well as
// marking running containers as requiring an update on next restart
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunResolvconfUpdater ( c * check . C ) {
2015-03-05 05:22:01 +00:00
// Because overlay doesn't support inotify properly, we need to skip
// this test if the docker daemon has Storage Driver == overlay
2015-04-18 16:46:47 +00:00
testRequires ( c , SameHostDaemon , NotOverlay )
2014-12-10 05:55:09 +00:00
tmpResolvConf := [ ] byte ( "search pommesfrites.fr\nnameserver 12.34.56.78" )
tmpLocalhostResolvConf := [ ] byte ( "nameserver 127.0.0.1" )
//take a copy of resolv.conf for restoring after test completes
resolvConfSystem , err := ioutil . ReadFile ( "/etc/resolv.conf" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
2015-02-11 20:01:30 +00:00
// This test case is meant to test monitoring resolv.conf when it is
2015-04-18 16:46:47 +00:00
// a regular file not a bind mounc. So we unmount resolv.conf and replace
2015-02-11 20:01:30 +00:00
// it with a file containing the original settings.
cmd := exec . Command ( "umount" , "/etc/resolv.conf" )
if _ , err = runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-02-11 20:01:30 +00:00
}
2014-12-10 05:55:09 +00:00
//cleanup
defer func ( ) {
if err := ioutil . WriteFile ( "/etc/resolv.conf" , resolvConfSystem , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
} ( )
//1. test that a non-running container gets an updated resolv.conf
2015-02-11 20:01:30 +00:00
cmd = exec . Command ( dockerBinary , "run" , "--name='first'" , "busybox" , "true" )
2014-12-10 05:55:09 +00:00
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
containerID1 , err := getIDByName ( "first" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
// replace resolv.conf with our temporary copy
bytesResolvConf := [ ] byte ( tmpResolvConf )
if err := ioutil . WriteFile ( "/etc/resolv.conf" , bytesResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
time . Sleep ( time . Second / 2 )
// check for update in container
containerResolv , err := readContainerFile ( containerID1 , "resolv.conf" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
if ! bytes . Equal ( containerResolv , bytesResolvConf ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Stopped container does not have updated resolv.conf; expected %q, got %q" , tmpResolvConf , string ( containerResolv ) )
2014-12-10 05:55:09 +00:00
}
//2. test that a non-running container does not receive resolv.conf updates
// if it modified the container copy of the starting point resolv.conf
cmd = exec . Command ( dockerBinary , "run" , "--name='second'" , "busybox" , "sh" , "-c" , "echo 'search mylittlepony.com' >>/etc/resolv.conf" )
if _ , err = runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
containerID2 , err := getIDByName ( "second" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
containerResolvHashBefore , err := readContainerFile ( containerID2 , "resolv.conf.hash" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
//make a change to resolv.conf (in this case replacing our tmp copy with orig copy)
if err := ioutil . WriteFile ( "/etc/resolv.conf" , resolvConfSystem , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
time . Sleep ( time . Second / 2 )
containerResolvHashAfter , err := readContainerFile ( containerID2 , "resolv.conf.hash" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
if ! bytes . Equal ( containerResolvHashBefore , containerResolvHashAfter ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Stopped container with modified resolv.conf should not have been updated; expected hash: %v, new hash: %v" , containerResolvHashBefore , containerResolvHashAfter )
2014-12-10 05:55:09 +00:00
}
//3. test that a running container's resolv.conf is not modified while running
cmd = exec . Command ( dockerBinary , "run" , "-d" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
runningContainerID := strings . TrimSpace ( out )
containerResolvHashBefore , err = readContainerFile ( runningContainerID , "resolv.conf.hash" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
// replace resolv.conf
if err := ioutil . WriteFile ( "/etc/resolv.conf" , bytesResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
// make sure the updater has time to run to validate we really aren't
// getting updated
time . Sleep ( time . Second / 2 )
containerResolvHashAfter , err = readContainerFile ( runningContainerID , "resolv.conf.hash" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
if ! bytes . Equal ( containerResolvHashBefore , containerResolvHashAfter ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Running container's resolv.conf should not be updated; expected hash: %v, new hash: %v" , containerResolvHashBefore , containerResolvHashAfter )
2014-12-10 05:55:09 +00:00
}
//4. test that a running container's resolv.conf is updated upon restart
// (the above container is still running..)
cmd = exec . Command ( dockerBinary , "restart" , runningContainerID )
if _ , err = runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
// check for update in container
containerResolv , err = readContainerFile ( runningContainerID , "resolv.conf" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
if ! bytes . Equal ( containerResolv , bytesResolvConf ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Restarted container should have updated resolv.conf; expected %q, got %q" , tmpResolvConf , string ( containerResolv ) )
2014-12-10 05:55:09 +00:00
}
//5. test that additions of a localhost resolver are cleaned from
// host resolv.conf before updating container's resolv.conf copies
// replace resolv.conf with a localhost-only nameserver copy
bytesResolvConf = [ ] byte ( tmpLocalhostResolvConf )
if err = ioutil . WriteFile ( "/etc/resolv.conf" , bytesResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
time . Sleep ( time . Second / 2 )
// our first exited container ID should have been updated, but with default DNS
// after the cleanup of resolv.conf found only a localhost nameserver:
containerResolv , err = readContainerFile ( containerID1 , "resolv.conf" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-10 05:55:09 +00:00
}
expected := "\nnameserver 8.8.8.8\nnameserver 8.8.4.4"
if ! bytes . Equal ( containerResolv , [ ] byte ( expected ) ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container does not have cleaned/replaced DNS in resolv.conf; expected %q, got %q" , expected , string ( containerResolv ) )
2014-12-10 05:55:09 +00:00
}
2015-02-11 20:01:30 +00:00
//6. Test that replacing (as opposed to modifying) resolv.conf triggers an update
// of containers' resolv.conf.
// Restore the original resolv.conf
if err := ioutil . WriteFile ( "/etc/resolv.conf" , resolvConfSystem , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-02-11 20:01:30 +00:00
}
// Run the container so it picks up the old settings
cmd = exec . Command ( dockerBinary , "run" , "--name='third'" , "busybox" , "true" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-02-11 20:01:30 +00:00
}
containerID3 , err := getIDByName ( "third" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-02-11 20:01:30 +00:00
}
// Create a modified resolv.conf.aside and override resolv.conf with it
bytesResolvConf = [ ] byte ( tmpResolvConf )
if err := ioutil . WriteFile ( "/etc/resolv.conf.aside" , bytesResolvConf , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-02-11 20:01:30 +00:00
}
err = os . Rename ( "/etc/resolv.conf.aside" , "/etc/resolv.conf" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-02-11 20:01:30 +00:00
}
time . Sleep ( time . Second / 2 )
// check for update in container
containerResolv , err = readContainerFile ( containerID3 , "resolv.conf" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-02-11 20:01:30 +00:00
}
if ! bytes . Equal ( containerResolv , bytesResolvConf ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Stopped container does not have updated resolv.conf; expected\n%q\n got\n%q" , tmpResolvConf , string ( containerResolv ) )
2015-02-11 20:01:30 +00:00
}
2014-12-10 05:55:09 +00:00
//cleanup, restore original resolv.conf happens in defer func()
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAddHost ( c * check . C ) {
2014-09-13 04:35:59 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--add-host=extra:86.75.30.9" , "busybox" , "grep" , "extra" , "/etc/hosts" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-09-13 04:35:59 +00:00
}
actual := strings . Trim ( out , "\r\n" )
if actual != "86.75.30.9\textra" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected '86.75.30.9\textra', but says: %q" , actual )
2014-09-13 04:35:59 +00:00
}
}
2014-07-16 17:47:12 +00:00
// Regression test for #6983
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAttachStdErrOnlyTTYMode ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-t" , "-a" , "stderr" , "busybox" , "true" )
2014-07-16 17:47:12 +00:00
exitCode , err := runCommand ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-16 17:47:12 +00:00
} else if exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container should have exited with error code 0" )
2014-07-16 17:47:12 +00:00
}
}
// Regression test for #6983
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAttachStdOutOnlyTTYMode ( c * check . C ) {
2014-07-16 17:47:12 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-t" , "-a" , "stdout" , "busybox" , "true" )
exitCode , err := runCommand ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-16 17:47:12 +00:00
} else if exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container should have exited with error code 0" )
2014-07-16 17:47:12 +00:00
}
}
// Regression test for #6983
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAttachStdOutAndErrTTYMode ( c * check . C ) {
2015-02-20 06:56:02 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-t" , "-a" , "stdout" , "-a" , "stderr" , "busybox" , "true" )
2014-07-16 17:47:12 +00:00
exitCode , err := runCommand ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-16 17:47:12 +00:00
} else if exitCode != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container should have exited with error code 0" )
2014-07-16 17:47:12 +00:00
}
}
2014-07-17 06:15:23 +00:00
2015-01-28 21:03:21 +00:00
// Test for #10388 - this will run the same test as TestRunAttachStdOutAndErrTTYMode
// but using --attach instead of -a to make sure we read the flag correctly
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAttachWithDettach ( c * check . C ) {
2015-01-28 21:03:21 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--attach" , "stdout" , "busybox" , "true" )
_ , stderr , _ , err := runCommandWithStdoutStderr ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container should have exited with error code different than 0" )
2015-01-28 21:03:21 +00:00
} else if ! strings . Contains ( stderr , "Conflicting options: -a and -d" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Should have been returned an error with conflicting options -a and -d" )
2015-01-28 21:03:21 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunState ( c * check . C ) {
2014-07-17 06:15:23 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-17 06:15:23 +00:00
}
id := strings . TrimSpace ( out )
state , err := inspectField ( id , "State.Running" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-17 06:15:23 +00:00
}
if state != "true" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container state is 'not running'" )
2014-07-17 06:15:23 +00:00
}
pid1 , err := inspectField ( id , "State.Pid" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-17 06:15:23 +00:00
}
if pid1 == "0" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container state Pid 0" )
2014-07-17 06:15:23 +00:00
}
cmd = exec . Command ( dockerBinary , "stop" , id )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-17 06:15:23 +00:00
}
state , err = inspectField ( id , "State.Running" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-17 06:15:23 +00:00
}
if state != "false" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container state is 'running'" )
2014-07-17 06:15:23 +00:00
}
pid2 , err := inspectField ( id , "State.Pid" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-17 06:15:23 +00:00
}
if pid2 == pid1 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container state Pid %s, but expected %s" , pid2 , pid1 )
2014-07-17 06:15:23 +00:00
}
cmd = exec . Command ( dockerBinary , "start" , id )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-17 06:15:23 +00:00
}
state , err = inspectField ( id , "State.Running" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-17 06:15:23 +00:00
}
if state != "true" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container state is 'not running'" )
2014-07-17 06:15:23 +00:00
}
pid3 , err := inspectField ( id , "State.Pid" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-17 06:15:23 +00:00
}
if pid3 == pid1 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container state Pid %s, but expected %s" , pid2 , pid1 )
2014-07-17 06:15:23 +00:00
}
}
2014-07-16 19:40:04 +00:00
// Test for #1737
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCopyVolumeUidGid ( c * check . C ) {
2014-07-16 19:40:04 +00:00
name := "testrunvolumesuidgid"
_ , err := buildImage ( name ,
` FROM busybox
RUN echo ' dockerio : x : 1001 : 1001 : : / bin : / bin / false ' >> / etc / passwd
RUN echo ' dockerio : x : 1001 : ' >> / etc / group
RUN mkdir - p / hello && touch / hello / test && chown dockerio . dockerio / hello ` ,
true )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-16 19:40:04 +00:00
}
// Test that the uid and gid is copied from the image to the volume
cmd := exec . Command ( dockerBinary , "run" , "--rm" , "-v" , "/hello" , name , "sh" , "-c" , "ls -l / | grep hello | awk '{print $3\":\"$4}'" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-16 19:40:04 +00:00
}
out = strings . TrimSpace ( out )
if out != "dockerio:dockerio" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Wrong /hello ownership: %s, expected dockerio:dockerio" , out )
2014-07-16 19:40:04 +00:00
}
}
2014-07-17 17:36:45 +00:00
// Test for #1582
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCopyVolumeContent ( c * check . C ) {
2014-07-17 17:36:45 +00:00
name := "testruncopyvolumecontent"
_ , err := buildImage ( name ,
` FROM busybox
RUN mkdir - p / hello / local && echo hello > / hello / local / world ` ,
true )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-17 17:36:45 +00:00
}
// Test that the content is copied from the image to the volume
2014-10-23 18:13:11 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--rm" , "-v" , "/hello" , name , "find" , "/hello" )
2014-07-17 17:36:45 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-17 17:36:45 +00:00
}
if ! ( strings . Contains ( out , "/hello/local/world" ) && strings . Contains ( out , "/hello/local" ) ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container failed to transfer content to volume" )
2014-07-17 17:36:45 +00:00
}
}
2014-07-10 05:46:11 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCleanupCmdOnEntrypoint ( c * check . C ) {
2014-07-10 05:46:11 +00:00
name := "testrunmdcleanuponentrypoint"
if _ , err := buildImage ( name ,
` FROM busybox
ENTRYPOINT [ "echo" ]
CMD [ "testingpoint" ] ` ,
true ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-07-10 05:46:11 +00:00
}
runCmd := exec . Command ( dockerBinary , "run" , "--entrypoint" , "whoami" , name )
out , exit , err := runCommandWithOutput ( runCmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Error: %v, out: %q" , err , out )
2014-07-10 05:46:11 +00:00
}
if exit != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected exit code 0 received %d, out: %q" , exit , out )
2014-07-10 05:46:11 +00:00
}
out = strings . TrimSpace ( out )
if out != "root" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Expected output root, got %q" , out )
2014-07-10 05:46:11 +00:00
}
}
2014-08-12 07:48:36 +00:00
// TestRunWorkdirExistsAndIsFile checks that if 'docker run -w' with existing file can be detected
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWorkdirExistsAndIsFile ( c * check . C ) {
2014-08-12 07:48:36 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-w" , "/bin/cat" , "busybox" )
out , exit , err := runCommandWithOutput ( runCmd )
if ! ( err != nil && exit == 1 && strings . Contains ( out , "Cannot mkdir: /bin/cat is not a directory" ) ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Docker must complains about making dir, but we got out: %s, exit: %d, err: %s" , out , exit , err )
2014-08-12 07:48:36 +00:00
}
}
2014-08-12 09:36:49 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunExitOnStdinClose ( c * check . C ) {
2014-08-12 09:36:49 +00:00
name := "testrunexitonstdinclose"
runCmd := exec . Command ( dockerBinary , "run" , "--name" , name , "-i" , "busybox" , "/bin/cat" )
stdin , err := runCmd . StdinPipe ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
stdout , err := runCmd . StdoutPipe ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
if err := runCmd . Start ( ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
if _ , err := stdin . Write ( [ ] byte ( "hello\n" ) ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
r := bufio . NewReader ( stdout )
line , err := r . ReadString ( '\n' )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
line = strings . TrimSpace ( line )
if line != "hello" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Output should be 'hello', got '%q'" , line )
2014-08-12 09:36:49 +00:00
}
if err := stdin . Close ( ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
finish := make ( chan struct { } )
go func ( ) {
if err := runCmd . Wait ( ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
close ( finish )
} ( )
select {
case <- finish :
case <- time . After ( 1 * time . Second ) :
2015-04-18 16:46:47 +00:00
c . Fatal ( "docker run failed to exit on stdin close" )
2014-08-12 09:36:49 +00:00
}
state , err := inspectField ( name , "State.Running" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-12 09:36:49 +00:00
}
if state != "false" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container must be stopped after stdin closing" )
2014-08-12 09:36:49 +00:00
}
}
2014-07-22 18:16:15 +00:00
// Test for #2267
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWriteHostsFileAndNotCommit ( c * check . C ) {
2014-07-22 18:16:15 +00:00
name := "writehosts"
cmd := exec . Command ( dockerBinary , "run" , "--name" , name , "busybox" , "sh" , "-c" , "echo test2267 >> /etc/hosts && cat /etc/hosts" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
if ! strings . Contains ( out , "test2267" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "/etc/hosts should contain 'test2267'" )
2014-07-22 18:16:15 +00:00
}
cmd = exec . Command ( dockerBinary , "diff" , name )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
2015-01-20 00:32:29 +00:00
2015-04-18 16:46:47 +00:00
if len ( strings . Trim ( out , "\r\n" ) ) != 0 && ! eqToBaseDiff ( out , c ) {
c . Fatal ( "diff should be empty" )
2014-07-22 18:16:15 +00:00
}
}
2015-04-18 16:46:47 +00:00
func eqToBaseDiff ( out string , c * check . C ) bool {
2015-01-20 00:32:29 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "busybox" , "echo" , "hello" )
out1 , _ , err := runCommandWithOutput ( cmd )
2015-04-06 13:21:18 +00:00
cID := strings . TrimSpace ( out1 )
2015-01-20 00:32:29 +00:00
cmd = exec . Command ( dockerBinary , "diff" , cID )
2015-03-26 01:40:23 +00:00
baseDiff , _ , err := runCommandWithOutput ( cmd )
2015-01-20 00:32:29 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , baseDiff )
2015-01-20 00:32:29 +00:00
}
2015-03-26 01:40:23 +00:00
baseArr := strings . Split ( baseDiff , "\n" )
sort . Strings ( baseArr )
outArr := strings . Split ( out , "\n" )
sort . Strings ( outArr )
return sliceEq ( baseArr , outArr )
2015-01-20 00:32:29 +00:00
}
func sliceEq ( a , b [ ] string ) bool {
if len ( a ) != len ( b ) {
return false
}
for i := range a {
if a [ i ] != b [ i ] {
return false
}
}
return true
}
2014-07-22 18:16:15 +00:00
// Test for #2267
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWriteHostnameFileAndNotCommit ( c * check . C ) {
2014-07-22 18:16:15 +00:00
name := "writehostname"
cmd := exec . Command ( dockerBinary , "run" , "--name" , name , "busybox" , "sh" , "-c" , "echo test2267 >> /etc/hostname && cat /etc/hostname" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
if ! strings . Contains ( out , "test2267" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "/etc/hostname should contain 'test2267'" )
2014-07-22 18:16:15 +00:00
}
cmd = exec . Command ( dockerBinary , "diff" , name )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
2015-04-18 16:46:47 +00:00
if len ( strings . Trim ( out , "\r\n" ) ) != 0 && ! eqToBaseDiff ( out , c ) {
c . Fatal ( "diff should be empty" )
2014-07-22 18:16:15 +00:00
}
}
// Test for #2267
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWriteResolvFileAndNotCommit ( c * check . C ) {
2014-07-22 18:16:15 +00:00
name := "writeresolv"
cmd := exec . Command ( dockerBinary , "run" , "--name" , name , "busybox" , "sh" , "-c" , "echo test2267 >> /etc/resolv.conf && cat /etc/resolv.conf" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
if ! strings . Contains ( out , "test2267" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "/etc/resolv.conf should contain 'test2267'" )
2014-07-22 18:16:15 +00:00
}
cmd = exec . Command ( dockerBinary , "diff" , name )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-07-22 18:16:15 +00:00
}
2015-04-18 16:46:47 +00:00
if len ( strings . Trim ( out , "\r\n" ) ) != 0 && ! eqToBaseDiff ( out , c ) {
c . Fatal ( "diff should be empty" )
2014-07-22 18:16:15 +00:00
}
}
2014-08-24 10:09:30 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithBadDevice ( c * check . C ) {
2014-08-24 10:09:30 +00:00
name := "baddevice"
cmd := exec . Command ( dockerBinary , "run" , "--name" , name , "--device" , "/etc" , "busybox" , "true" )
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Run should fail with bad device" )
2014-08-24 10:09:30 +00:00
}
2014-10-01 13:07:24 +00:00
expected := ` \"/etc\": not a device node `
2014-08-24 10:09:30 +00:00
if ! strings . Contains ( out , expected ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Output should contain %q, actual out: %q" , expected , out )
2014-08-24 10:09:30 +00:00
}
}
2014-08-28 00:25:10 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunEntrypoint ( c * check . C ) {
2014-08-28 00:25:10 +00:00
name := "entrypoint"
cmd := exec . Command ( dockerBinary , "run" , "--name" , name , "--entrypoint" , "/bin/echo" , "busybox" , "-n" , "foobar" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-08-28 00:25:10 +00:00
}
expected := "foobar"
if out != expected {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Output should be %q, actual out: %q" , expected , out )
2014-08-28 00:25:10 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunBindMounts ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2014-11-17 16:05:49 +00:00
2014-08-28 00:25:10 +00:00
tmpDir , err := ioutil . TempDir ( "" , "docker-test-container" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-08-28 00:25:10 +00:00
}
defer os . RemoveAll ( tmpDir )
2015-04-18 16:46:47 +00:00
writeFile ( path . Join ( tmpDir , "touch-me" ) , "" , c )
2014-08-28 00:25:10 +00:00
// Test reading from a read-only bind mount
cmd := exec . Command ( dockerBinary , "run" , "-v" , fmt . Sprintf ( "%s:/tmp:ro" , tmpDir ) , "busybox" , "ls" , "/tmp" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-08-28 00:25:10 +00:00
}
if ! strings . Contains ( out , "touch-me" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container failed to read from bind mount" )
2014-08-28 00:25:10 +00:00
}
// test writing to bind mount
cmd = exec . Command ( dockerBinary , "run" , "-v" , fmt . Sprintf ( "%s:/tmp:rw" , tmpDir ) , "busybox" , "touch" , "/tmp/holla" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-08-28 00:25:10 +00:00
}
2015-04-18 16:46:47 +00:00
readFile ( path . Join ( tmpDir , "holla" ) , c ) // Will fail if the file doesn't exist
2014-08-28 00:25:10 +00:00
// test mounting to an illegal destination directory
cmd = exec . Command ( dockerBinary , "run" , "-v" , fmt . Sprintf ( "%s:." , tmpDir ) , "busybox" , "ls" , "." )
_ , err = runCommand ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container bind mounted illegal directory" )
2014-08-28 00:25:10 +00:00
}
// test mount a file
cmd = exec . Command ( dockerBinary , "run" , "-v" , fmt . Sprintf ( "%s/holla:/tmp/holla:rw" , tmpDir ) , "busybox" , "sh" , "-c" , "echo -n 'yotta' > /tmp/holla" )
_ , err = runCommand ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-08-28 00:25:10 +00:00
}
2015-04-18 16:46:47 +00:00
content := readFile ( path . Join ( tmpDir , "holla" ) , c ) // Will fail if the file doesn't exist
2014-08-28 00:25:10 +00:00
expected := "yotta"
if content != expected {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Output should be %q, actual out: %q" , expected , content )
2014-08-28 00:25:10 +00:00
}
}
2014-07-14 23:19:37 +00:00
2014-09-01 15:55:39 +00:00
// Ensure that CIDFile gets deleted if it's empty
// Perform this test by making `docker run` fail
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCidFileCleanupIfEmpty ( c * check . C ) {
2014-09-01 15:55:39 +00:00
tmpDir , err := ioutil . TempDir ( "" , "TestRunCidFile" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-01 15:55:39 +00:00
}
defer os . RemoveAll ( tmpDir )
tmpCidFile := path . Join ( tmpDir , "cid" )
2015-03-06 06:01:49 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--cidfile" , tmpCidFile , "emptyfs" )
2014-09-01 15:55:39 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Run without command must fail. out=%s" , out )
2015-03-06 06:01:49 +00:00
} else if ! strings . Contains ( out , "No command specified" ) {
2015-04-27 20:33:30 +00:00
c . Fatalf ( "Run without command failed with wrong output. out=%s\nerr=%v" , out , err )
2014-09-01 15:55:39 +00:00
}
if _ , err := os . Stat ( tmpCidFile ) ; err == nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "empty CIDFile %q should've been deleted" , tmpCidFile )
2014-09-01 15:55:39 +00:00
}
}
2014-09-01 16:15:20 +00:00
// #2098 - Docker cidFiles only contain short version of the containerId
2015-04-18 16:46:47 +00:00
//sudo docker run --cidfile /tmp/docker_tesc.cid ubuntu echo "test"
2014-09-01 16:15:20 +00:00
// TestRunCidFile tests that run --cidfile returns the longid
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCidFileCheckIDLength ( c * check . C ) {
2014-09-01 16:15:20 +00:00
tmpDir , err := ioutil . TempDir ( "" , "TestRunCidFile" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-01 16:15:20 +00:00
}
tmpCidFile := path . Join ( tmpDir , "cid" )
defer os . RemoveAll ( tmpDir )
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--cidfile" , tmpCidFile , "busybox" , "true" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-01 16:15:20 +00:00
}
id := strings . TrimSpace ( out )
buffer , err := ioutil . ReadFile ( tmpCidFile )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-01 16:15:20 +00:00
}
cid := string ( buffer )
if len ( cid ) != 64 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "--cidfile should be a long id, not %q" , id )
2014-09-01 16:15:20 +00:00
}
if cid != id {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "cid must be equal to %s, got %s" , id , cid )
2014-09-01 16:15:20 +00:00
}
}
2014-09-04 05:50:58 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunNetworkNotInitializedNoneMode ( c * check . C ) {
2014-09-04 05:50:58 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--net=none" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-04 05:50:58 +00:00
}
id := strings . TrimSpace ( out )
res , err := inspectField ( id , "NetworkSettings.IPAddress" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-04 05:50:58 +00:00
}
if res != "" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "For 'none' mode network must not be initialized, but container got IP: %s" , res )
2014-09-04 05:50:58 +00:00
}
}
2014-09-09 12:47:25 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunSetMacAddress ( c * check . C ) {
2014-10-03 21:02:17 +00:00
mac := "12:34:56:78:9a:bc"
2015-02-18 06:18:28 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-i" , "--rm" , fmt . Sprintf ( "--mac-address=%s" , mac ) , "busybox" , "/bin/sh" , "-c" , "ip link show eth0 | tail -1 | awk '{print $2}'" )
out , ec , err := runCommandWithOutput ( cmd )
2014-10-03 21:02:17 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "exec failed:\nexit code=%v\noutput=%s" , ec , out )
2014-10-03 21:02:17 +00:00
}
actualMac := strings . TrimSpace ( out )
if actualMac != mac {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Set MAC address with --mac-address failed. The container has an incorrect MAC address: %q, expected: %q" , actualMac , mac )
2014-10-03 21:02:17 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunInspectMacAddress ( c * check . C ) {
2014-10-03 21:02:17 +00:00
mac := "12:34:56:78:9a:bc"
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--mac-address=" + mac , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-03 21:02:17 +00:00
}
id := strings . TrimSpace ( out )
inspectedMac , err := inspectField ( id , "NetworkSettings.MacAddress" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-03 21:02:17 +00:00
}
if inspectedMac != mac {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "docker inspect outputs wrong MAC address: %q, should be: %q" , inspectedMac , mac )
2014-10-03 21:02:17 +00:00
}
}
2015-02-27 15:27:12 +00:00
// test docker run use a invalid mac address
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunWithInvalidMacAddress ( c * check . C ) {
2015-02-27 15:27:12 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "--mac-address" , "92:d0:c6:0a:29" , "busybox" )
out , _ , err := runCommandWithOutput ( runCmd )
//use a invalid mac address should with a error out
if err == nil || ! strings . Contains ( out , "is not a valid mac address" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "run with an invalid --mac-address should with error out" )
2015-02-27 15:27:12 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunDeallocatePortOnMissingIptablesRule ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2014-09-09 12:47:25 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "-p" , "23:23" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-09 12:47:25 +00:00
}
id := strings . TrimSpace ( out )
ip , err := inspectField ( id , "NetworkSettings.IPAddress" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-09 12:47:25 +00:00
}
2014-11-15 01:36:38 +00:00
iptCmd := exec . Command ( "iptables" , "-D" , "DOCKER" , "-d" , fmt . Sprintf ( "%s/32" , ip ) ,
2014-09-09 12:47:25 +00:00
"!" , "-i" , "docker0" , "-o" , "docker0" , "-p" , "tcp" , "-m" , "tcp" , "--dport" , "23" , "-j" , "ACCEPT" )
out , _ , err = runCommandWithOutput ( iptCmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-09-09 12:47:25 +00:00
}
if err := deleteContainer ( id ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-09 12:47:25 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "-d" , "-p" , "23:23" , "busybox" , "top" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-09-09 12:47:25 +00:00
}
}
2014-09-06 01:59:31 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunPortInUse ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2014-09-06 01:59:31 +00:00
port := "1234"
l , err := net . Listen ( "tcp" , ":" + port )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-06 01:59:31 +00:00
}
defer l . Close ( )
2014-10-09 22:15:17 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "-p" , port + ":80" , "busybox" , "top" )
2014-09-06 01:59:31 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Binding on used port must fail" )
2014-09-08 10:22:50 +00:00
}
if ! strings . Contains ( out , "address already in use" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Out must be about \"address already in use\", got %s" , out )
2014-09-06 01:59:31 +00:00
}
}
2014-09-10 23:49:18 +00:00
2014-10-08 12:41:26 +00:00
// https://github.com/docker/docker/issues/8428
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunPortProxy ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2014-10-08 12:41:26 +00:00
port := "12345"
2014-10-09 22:15:17 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "-p" , port + ":80" , "busybox" , "top" )
2014-10-08 12:41:26 +00:00
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Failed to run and bind port %s, output: %s, error: %s" , port , out , err )
2014-10-08 12:41:26 +00:00
}
2015-04-18 16:46:47 +00:00
// connett for 10 times here. This will trigger 10 EPIPES in the child
2014-10-08 12:41:26 +00:00
// process and kill it when it writes to a closed stdout/stderr
for i := 0 ; i < 10 ; i ++ {
net . Dial ( "tcp" , fmt . Sprintf ( "0.0.0.0:%s" , port ) )
}
listPs := exec . Command ( "sh" , "-c" , "ps ax | grep docker" )
out , _ , err = runCommandWithOutput ( listPs )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Errorf ( "list docker process failed with output %s, error %s" , out , err )
2014-10-08 12:41:26 +00:00
}
if strings . Contains ( out , "docker <defunct>" ) {
2015-04-18 16:46:47 +00:00
c . Errorf ( "Unexpected defunct docker process" )
2014-10-08 12:41:26 +00:00
}
if ! strings . Contains ( out , "docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 12345" ) {
2015-04-18 16:46:47 +00:00
c . Errorf ( "Failed to find docker-proxy process, got %s" , out )
2014-10-08 12:41:26 +00:00
}
}
2014-09-16 00:51:06 +00:00
// Regression test for #7792
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunMountOrdering ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2014-09-16 00:51:06 +00:00
tmpDir , err := ioutil . TempDir ( "" , "docker_nested_mount_test" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-16 00:51:06 +00:00
}
defer os . RemoveAll ( tmpDir )
tmpDir2 , err := ioutil . TempDir ( "" , "docker_nested_mount_test2" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-16 00:51:06 +00:00
}
defer os . RemoveAll ( tmpDir2 )
2015-04-18 16:46:47 +00:00
// Create a temporary tmpfs mounc.
2014-09-16 00:51:06 +00:00
fooDir := filepath . Join ( tmpDir , "foo" )
if err := os . MkdirAll ( filepath . Join ( tmpDir , "foo" ) , 0755 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to mkdir at %s - %s" , fooDir , err )
2014-09-16 00:51:06 +00:00
}
if err := ioutil . WriteFile ( fmt . Sprintf ( "%s/touch-me" , fooDir ) , [ ] byte { } , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-16 00:51:06 +00:00
}
if err := ioutil . WriteFile ( fmt . Sprintf ( "%s/touch-me" , tmpDir ) , [ ] byte { } , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-16 00:51:06 +00:00
}
if err := ioutil . WriteFile ( fmt . Sprintf ( "%s/touch-me" , tmpDir2 ) , [ ] byte { } , 0644 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-16 00:51:06 +00:00
}
cmd := exec . Command ( dockerBinary , "run" , "-v" , fmt . Sprintf ( "%s:/tmp" , tmpDir ) , "-v" , fmt . Sprintf ( "%s:/tmp/foo" , fooDir ) , "-v" , fmt . Sprintf ( "%s:/tmp/tmp2" , tmpDir2 ) , "-v" , fmt . Sprintf ( "%s:/tmp/tmp2/foo" , fooDir ) , "busybox:latest" , "sh" , "-c" , "ls /tmp/touch-me && ls /tmp/foo/touch-me && ls /tmp/tmp2/touch-me && ls /tmp/tmp2/foo/touch-me" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-09-16 00:51:06 +00:00
}
}
2014-09-10 16:43:16 +00:00
2014-09-26 18:28:21 +00:00
// Regression test for https://github.com/docker/docker/issues/8259
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunReuseBindVolumeThatIsSymlink ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2014-09-26 18:28:21 +00:00
tmpDir , err := ioutil . TempDir ( os . TempDir ( ) , "testlink" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-26 18:28:21 +00:00
}
defer os . RemoveAll ( tmpDir )
linkPath := os . TempDir ( ) + "/testlink2"
if err := os . Symlink ( tmpDir , linkPath ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-26 18:28:21 +00:00
}
defer os . RemoveAll ( linkPath )
// Create first container
cmd := exec . Command ( dockerBinary , "run" , "-v" , fmt . Sprintf ( "%s:/tmp/test" , linkPath ) , "busybox" , "ls" , "-lh" , "/tmp/test" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-26 18:28:21 +00:00
}
// Create second container with same symlinked path
// This will fail if the referenced issue is hit with a "Volume exists" error
cmd = exec . Command ( dockerBinary , "run" , "-v" , fmt . Sprintf ( "%s:/tmp/test" , linkPath ) , "busybox" , "ls" , "-lh" , "/tmp/test" )
if out , _ , err := runCommandWithOutput ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-09-26 18:28:21 +00:00
}
}
2014-10-06 17:30:42 +00:00
2015-03-05 14:41:56 +00:00
//GH#10604: Test an "/etc" volume doesn't overlay special bind mounts in container
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunCreateVolumeEtc ( c * check . C ) {
2015-02-12 02:39:07 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--dns=127.0.0.1" , "-v" , "/etc" , "busybox" , "cat" , "/etc/resolv.conf" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-02-12 02:39:07 +00:00
}
if ! strings . Contains ( out , "nameserver 127.0.0.1" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "/etc volume mount hides /etc/resolv.conf" )
2015-02-12 02:39:07 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "-h=test123" , "-v" , "/etc" , "busybox" , "cat" , "/etc/hostname" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-02-12 02:39:07 +00:00
}
if ! strings . Contains ( out , "test123" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "/etc volume mount hides /etc/hostname" )
2015-02-12 02:39:07 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--add-host=test:192.168.0.1" , "-v" , "/etc" , "busybox" , "cat" , "/etc/hosts" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-02-12 02:39:07 +00:00
}
out = strings . Replace ( out , "\n" , " " , - 1 )
2015-03-05 14:41:56 +00:00
if ! strings . Contains ( out , "192.168.0.1\ttest" ) || ! strings . Contains ( out , "127.0.0.1\tlocalhost" ) {
2015-04-18 16:46:47 +00:00
c . Fatal ( "/etc volume mount hides /etc/hosts" )
2015-02-12 02:39:07 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestVolumesNoCopyData ( c * check . C ) {
2014-10-06 17:30:42 +00:00
if _ , err := buildImage ( "dataimage" ,
` FROM busybox
RUN mkdir - p / foo
RUN touch / foo / bar ` ,
true ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-06 17:30:42 +00:00
}
cmd := exec . Command ( dockerBinary , "run" , "--name" , "test" , "-v" , "/foo" , "busybox" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-06 17:30:42 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--volumes-from" , "test" , "dataimage" , "ls" , "-lh" , "/foo/bar" )
if out , _ , err := runCommandWithOutput ( cmd ) ; err == nil || ! strings . Contains ( out , "No such file or directory" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Data was copied on volumes-from but shouldn't be:\n%q" , out )
2014-10-06 17:30:42 +00:00
}
2015-02-20 08:58:44 +00:00
tmpDir := randomUnixTmpDirPath ( "docker_test_bind_mount_copy_data" )
2014-10-06 17:30:42 +00:00
cmd = exec . Command ( dockerBinary , "run" , "-v" , tmpDir + ":/foo" , "dataimage" , "ls" , "-lh" , "/foo/bar" )
if out , _ , err := runCommandWithOutput ( cmd ) ; err == nil || ! strings . Contains ( out , "No such file or directory" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Data was copied on bind-mount but shouldn't be:\n%q" , out )
2014-10-06 17:30:42 +00:00
}
}
2014-10-08 19:01:25 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVolumesNotRecreatedOnStart ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-19 04:06:23 +00:00
2014-10-08 19:01:25 +00:00
// Clear out any remnants from other tests
info , err := ioutil . ReadDir ( volumesConfigPath )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-08 19:01:25 +00:00
}
if len ( info ) > 0 {
for _ , f := range info {
if err := os . RemoveAll ( volumesConfigPath + "/" + f . Name ( ) ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-08 19:01:25 +00:00
}
}
}
cmd := exec . Command ( dockerBinary , "run" , "-v" , "/foo" , "--name" , "lone_starr" , "busybox" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-08 19:01:25 +00:00
}
cmd = exec . Command ( dockerBinary , "start" , "lone_starr" )
if _ , err := runCommand ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-08 19:01:25 +00:00
}
info , err = ioutil . ReadDir ( volumesConfigPath )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-08 19:01:25 +00:00
}
if len ( info ) != 1 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Expected only 1 volume have %v" , len ( info ) )
2014-10-08 19:01:25 +00:00
}
}
2014-10-17 18:06:05 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunNoOutputFromPullInStdout ( c * check . C ) {
2014-10-17 18:06:05 +00:00
// just run with unknown image
cmd := exec . Command ( dockerBinary , "run" , "asdfsg" )
stdout := bytes . NewBuffer ( nil )
cmd . Stdout = stdout
if err := cmd . Run ( ) ; err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Run with unknown image should fail" )
2014-10-17 18:06:05 +00:00
}
if stdout . Len ( ) != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Stdout contains output from pull: %s" , stdout )
2014-10-17 18:06:05 +00:00
}
}
2014-10-20 19:27:26 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVolumesCleanPaths ( c * check . C ) {
2014-10-20 19:27:26 +00:00
if _ , err := buildImage ( "run_volumes_clean_paths" ,
` FROM busybox
VOLUME / foo / ` ,
true ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-20 19:27:26 +00:00
}
cmd := exec . Command ( dockerBinary , "run" , "-v" , "/foo" , "-v" , "/bar/" , "--name" , "dark_helmet" , "run_volumes_clean_paths" )
if out , _ , err := runCommandWithOutput ( cmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-10-20 19:27:26 +00:00
}
out , err := inspectFieldMap ( "dark_helmet" , "Volumes" , "/foo/" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-20 19:27:26 +00:00
}
2015-03-26 19:43:00 +00:00
if out != "" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Found unexpected volume entry for '/foo/' in volumes\n%q" , out )
2014-10-20 19:27:26 +00:00
}
out , err = inspectFieldMap ( "dark_helmet" , "Volumes" , "/foo" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-20 19:27:26 +00:00
}
if ! strings . Contains ( out , volumesStoragePath ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Volume was not defined for /foo\n%q" , out )
2014-10-20 19:27:26 +00:00
}
out , err = inspectFieldMap ( "dark_helmet" , "Volumes" , "/bar/" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-20 19:27:26 +00:00
}
2015-03-26 19:43:00 +00:00
if out != "" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Found unexpected volume entry for '/bar/' in volumes\n%q" , out )
2014-10-20 19:27:26 +00:00
}
out , err = inspectFieldMap ( "dark_helmet" , "Volumes" , "/bar" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-20 19:27:26 +00:00
}
if ! strings . Contains ( out , volumesStoragePath ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Volume was not defined for /bar\n%q" , out )
2014-10-20 19:27:26 +00:00
}
}
2014-10-03 17:38:44 +00:00
// Regression test for #3631
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunSlowStdoutConsumer ( c * check . C ) {
cont := exec . Command ( dockerBinary , "run" , "--rm" , "busybox" , "/bin/sh" , "-c" , "dd if=/dev/zero of=/dev/stdout bs=1024 count=2000 | catv" )
2014-10-03 17:38:44 +00:00
2015-04-18 16:46:47 +00:00
stdout , err := cont . StdoutPipe ( )
2014-10-03 17:38:44 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-03 17:38:44 +00:00
}
2015-04-18 16:46:47 +00:00
if err := cont . Start ( ) ; err != nil {
c . Fatal ( err )
2014-10-03 17:38:44 +00:00
}
2014-10-30 19:10:38 +00:00
n , err := consumeWithSpeed ( stdout , 10000 , 5 * time . Millisecond , nil )
2014-10-03 17:38:44 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-10-03 17:38:44 +00:00
}
expected := 2 * 1024 * 2000
if n != expected {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Expected %d, got %d" , expected , n )
2014-10-03 17:38:44 +00:00
}
}
2014-09-17 01:08:30 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAllowPortRangeThroughExpose ( c * check . C ) {
2014-09-17 01:08:30 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--expose" , "3000-3003" , "-P" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-17 01:08:30 +00:00
}
id := strings . TrimSpace ( out )
portstr , err := inspectFieldJSON ( id , "NetworkSettings.Ports" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-17 01:08:30 +00:00
}
var ports nat . PortMap
2015-03-26 03:18:42 +00:00
if err = unmarshalJSON ( [ ] byte ( portstr ) , & ports ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-03-26 03:18:42 +00:00
}
2014-09-17 01:08:30 +00:00
for port , binding := range ports {
portnum , _ := strconv . Atoi ( strings . Split ( string ( port ) , "/" ) [ 0 ] )
if portnum < 3000 || portnum > 3003 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Port %d is out of range " , portnum )
2014-09-17 01:08:30 +00:00
}
if binding == nil || len ( binding ) != 1 || len ( binding [ 0 ] . HostPort ) == 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Port is not mapped for the port %d" , port )
2014-09-17 01:08:30 +00:00
}
}
if err := deleteContainer ( id ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-09-17 01:08:30 +00:00
}
}
2014-11-06 02:23:42 +00:00
2015-02-19 23:18:13 +00:00
// test docker run expose a invalid port
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunExposePort ( c * check . C ) {
2015-02-19 23:18:13 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "--expose" , "80000" , "busybox" )
out , _ , err := runCommandWithOutput ( runCmd )
//expose a invalid port should with a error out
if err == nil || ! strings . Contains ( out , "Invalid range format for --expose" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "run --expose a invalid port should with error out" )
2015-02-19 23:18:13 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunUnknownCommand ( c * check . C ) {
testRequires ( c , NativeExecDriver )
2014-11-06 02:23:42 +00:00
runCmd := exec . Command ( dockerBinary , "create" , "busybox" , "/bin/nada" )
cID , _ , _ , err := runCommandWithStdoutStderr ( runCmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Failed to create container: %v, output: %q" , err , cID )
2014-11-06 02:23:42 +00:00
}
cID = strings . TrimSpace ( cID )
runCmd = exec . Command ( dockerBinary , "start" , cID )
2015-01-20 00:32:29 +00:00
_ , _ , _ , _ = runCommandWithStdoutStderr ( runCmd )
2014-11-06 02:23:42 +00:00
runCmd = exec . Command ( dockerBinary , "inspect" , "--format={{.State.ExitCode}}" , cID )
rc , _ , _ , err2 := runCommandWithStdoutStderr ( runCmd )
rc = strings . TrimSpace ( rc )
if err2 != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Error getting status of container: %v" , err2 )
2014-11-06 02:23:42 +00:00
}
2015-01-20 00:32:29 +00:00
if rc == "0" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "ExitCode(%v) cannot be 0" , rc )
2014-11-06 02:23:42 +00:00
}
}
2014-11-10 21:14:17 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunModeIpcHost ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2014-11-10 21:14:17 +00:00
hostIpc , err := os . Readlink ( "/proc/1/ns/ipc" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-10 21:14:17 +00:00
}
cmd := exec . Command ( dockerBinary , "run" , "--ipc=host" , "busybox" , "readlink" , "/proc/self/ns/ipc" )
out2 , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2014-11-10 21:14:17 +00:00
}
out2 = strings . Trim ( out2 , "\n" )
if hostIpc != out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "IPC different with --ipc=host %s != %s\n" , hostIpc , out2 )
2014-11-10 21:14:17 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "busybox" , "readlink" , "/proc/self/ns/ipc" )
out2 , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2014-11-10 21:14:17 +00:00
}
out2 = strings . Trim ( out2 , "\n" )
if hostIpc == out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "IPC should be different without --ipc=host %s == %s\n" , hostIpc , out2 )
2014-11-10 21:14:17 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunModeIpcContainer ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2014-11-10 21:14:17 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-11-10 21:14:17 +00:00
}
id := strings . TrimSpace ( out )
state , err := inspectField ( id , "State.Running" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-10 21:14:17 +00:00
}
if state != "true" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Container state is 'not running'" )
2014-11-10 21:14:17 +00:00
}
pid1 , err := inspectField ( id , "State.Pid" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-10 21:14:17 +00:00
}
parentContainerIpc , err := os . Readlink ( fmt . Sprintf ( "/proc/%s/ns/ipc" , pid1 ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-10 21:14:17 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , fmt . Sprintf ( "--ipc=container:%s" , id ) , "busybox" , "readlink" , "/proc/self/ns/ipc" )
out2 , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2014-11-10 21:14:17 +00:00
}
out2 = strings . Trim ( out2 , "\n" )
if parentContainerIpc != out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "IPC different with --ipc=container:%s %s != %s\n" , id , parentContainerIpc , out2 )
2014-11-10 21:14:17 +00:00
}
}
2014-11-18 23:10:07 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunModeIpcContainerNotExists ( c * check . C ) {
2015-03-28 01:07:20 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--ipc" , "container:abcd1234" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if ! strings . Contains ( out , "abcd1234" ) || err == nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "run IPC from a non exists container should with correct error out" )
2015-03-28 01:07:20 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestContainerNetworkMode ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2014-11-18 23:10:07 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2014-11-18 23:10:07 +00:00
}
id := strings . TrimSpace ( out )
if err := waitRun ( id ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-18 23:10:07 +00:00
}
pid1 , err := inspectField ( id , "State.Pid" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-18 23:10:07 +00:00
}
parentContainerNet , err := os . Readlink ( fmt . Sprintf ( "/proc/%s/ns/net" , pid1 ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-18 23:10:07 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , fmt . Sprintf ( "--net=container:%s" , id ) , "busybox" , "readlink" , "/proc/self/ns/net" )
out2 , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2014-11-18 23:10:07 +00:00
}
out2 = strings . Trim ( out2 , "\n" )
if parentContainerNet != out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "NET different with --net=container:%s %s != %s\n" , id , parentContainerNet , out2 )
2014-11-18 23:10:07 +00:00
}
}
2014-11-20 15:29:04 +00:00
2015-04-27 00:07:30 +00:00
func ( s * DockerSuite ) TestContainerNetworkModeToSelf ( c * check . C ) {
cmd := exec . Command ( dockerBinary , "run" , "--name=me" , "--net=container:me" , "busybox" , "true" )
out , _ , err := runCommandWithOutput ( cmd )
if err == nil || ! strings . Contains ( out , "cannot join own network" ) {
c . Fatalf ( "using container net mode to self should result in an error" )
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunModePidHost ( c * check . C ) {
testRequires ( c , NativeExecDriver , SameHostDaemon )
2015-02-20 06:56:02 +00:00
2015-01-14 00:39:08 +00:00
hostPid , err := os . Readlink ( "/proc/1/ns/pid" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-01-14 00:39:08 +00:00
}
cmd := exec . Command ( dockerBinary , "run" , "--pid=host" , "busybox" , "readlink" , "/proc/self/ns/pid" )
out2 , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2015-01-14 00:39:08 +00:00
}
out2 = strings . Trim ( out2 , "\n" )
if hostPid != out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "PID different with --pid=host %s != %s\n" , hostPid , out2 )
2015-01-14 00:39:08 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "busybox" , "readlink" , "/proc/self/ns/pid" )
out2 , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2015-01-14 00:39:08 +00:00
}
out2 = strings . Trim ( out2 , "\n" )
if hostPid == out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "PID should be different without --pid=host %s == %s\n" , hostPid , out2 )
2015-01-14 00:39:08 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunTLSverify ( c * check . C ) {
2014-11-20 15:29:04 +00:00
cmd := exec . Command ( dockerBinary , "ps" )
out , ec , err := runCommandWithOutput ( cmd )
if err != nil || ec != 0 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Should have worked: %v:\n%v" , err , out )
2014-11-20 15:29:04 +00:00
}
// Regardless of whether we specify true or false we need to
// test to make sure tls is turned on if --tlsverify is specified at all
cmd = exec . Command ( dockerBinary , "--tlsverify=false" , "ps" )
out , ec , err = runCommandWithOutput ( cmd )
if err == nil || ec == 0 || ! strings . Contains ( out , "trying to connect" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Should have failed: \net:%v\nout:%v\nerr:%v" , ec , out , err )
2014-11-20 15:29:04 +00:00
}
cmd = exec . Command ( dockerBinary , "--tlsverify=true" , "ps" )
out , ec , err = runCommandWithOutput ( cmd )
if err == nil || ec == 0 || ! strings . Contains ( out , "cert" ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Should have failed: \net:%v\nout:%v\nerr:%v" , ec , out , err )
2014-11-20 15:29:04 +00:00
}
}
2014-12-02 00:24:43 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunPortFromDockerRangeInUse ( c * check . C ) {
2014-12-02 00:24:43 +00:00
// first find allocator current position
cmd := exec . Command ( dockerBinary , "run" , "-d" , "-p" , ":80" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-12-02 00:24:43 +00:00
}
id := strings . TrimSpace ( out )
cmd = exec . Command ( dockerBinary , "port" , id )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-12-02 00:24:43 +00:00
}
out = strings . TrimSpace ( out )
2015-02-17 10:15:51 +00:00
if out == "" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "docker port command output is empty" )
2015-02-17 10:15:51 +00:00
}
2014-12-02 00:24:43 +00:00
out = strings . Split ( out , ":" ) [ 1 ]
lastPort , err := strconv . Atoi ( out )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-02 00:24:43 +00:00
}
port := lastPort + 1
l , err := net . Listen ( "tcp" , ":" + strconv . Itoa ( port ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-02 00:24:43 +00:00
}
defer l . Close ( )
cmd = exec . Command ( dockerBinary , "run" , "-d" , "-p" , ":80" , "busybox" , "top" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( out , err )
2014-12-02 00:24:43 +00:00
}
id = strings . TrimSpace ( out )
cmd = exec . Command ( dockerBinary , "port" , id )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-12-02 00:24:43 +00:00
}
}
2014-12-06 00:50:56 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunTtyWithPipe ( c * check . C ) {
2014-12-06 00:50:56 +00:00
done := make ( chan struct { } )
go func ( ) {
defer close ( done )
cmd := exec . Command ( dockerBinary , "run" , "-ti" , "busybox" , "true" )
if _ , err := cmd . StdinPipe ( ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-06 00:50:56 +00:00
}
expected := "cannot enable tty mode"
if out , _ , err := runCommandWithOutput ( cmd ) ; err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "run should have failed" )
2014-12-06 00:50:56 +00:00
} else if ! strings . Contains ( out , expected ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "run failed with error %q: expected %q" , out , expected )
2014-12-06 00:50:56 +00:00
}
} ( )
select {
case <- done :
case <- time . After ( 3 * time . Second ) :
2015-04-18 16:46:47 +00:00
c . Fatal ( "container is running but should have failed" )
2014-12-06 00:50:56 +00:00
}
}
2014-12-22 22:54:55 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunNonLocalMacAddress ( c * check . C ) {
2014-12-22 22:54:55 +00:00
addr := "00:16:3E:08:00:50"
cmd := exec . Command ( dockerBinary , "run" , "--mac-address" , addr , "busybox" , "ifconfig" )
if out , _ , err := runCommandWithOutput ( cmd ) ; err != nil || ! strings . Contains ( out , addr ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Output should have contained %q: %s, %v" , addr , out , err )
2014-12-22 22:54:55 +00:00
}
}
2014-12-25 04:40:41 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunNetHost ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-02-26 04:16:44 +00:00
2014-12-29 20:56:07 +00:00
hostNet , err := os . Readlink ( "/proc/1/ns/net" )
2014-12-25 04:40:41 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-12-25 04:40:41 +00:00
}
2014-12-29 20:56:07 +00:00
cmd := exec . Command ( dockerBinary , "run" , "--net=host" , "busybox" , "readlink" , "/proc/self/ns/net" )
out2 , _ , err := runCommandWithOutput ( cmd )
2014-12-25 04:40:41 +00:00
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2014-12-25 04:40:41 +00:00
}
2014-12-29 20:56:07 +00:00
out2 = strings . Trim ( out2 , "\n" )
if hostNet != out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Net namespace different with --net=host %s != %s\n" , hostNet , out2 )
2014-12-25 04:40:41 +00:00
}
2014-12-29 20:56:07 +00:00
cmd = exec . Command ( dockerBinary , "run" , "busybox" , "readlink" , "/proc/self/ns/net" )
out2 , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out2 )
2014-12-29 20:56:07 +00:00
}
out2 = strings . Trim ( out2 , "\n" )
if hostNet == out2 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Net namespace should be different without --net=host %s == %s\n" , hostNet , out2 )
2014-12-29 20:56:07 +00:00
}
2014-12-25 04:40:41 +00:00
}
2014-11-03 18:15:55 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunNetContainerWhichHost ( c * check . C ) {
testRequires ( c , SameHostDaemon )
2015-04-07 22:20:39 +00:00
hostNet , err := os . Readlink ( "/proc/1/ns/net" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-04-07 22:20:39 +00:00
}
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--net=host" , "--name=test" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2015-04-07 22:20:39 +00:00
}
cmd = exec . Command ( dockerBinary , "run" , "--net=container:test" , "busybox" , "readlink" , "/proc/self/ns/net" )
out , _ , err = runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2015-04-07 22:20:39 +00:00
}
out = strings . Trim ( out , "\n" )
if hostNet != out {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container should have host network namespace" )
2015-04-07 22:20:39 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunAllowPortRangeThroughPublish ( c * check . C ) {
2014-11-03 18:15:55 +00:00
cmd := exec . Command ( dockerBinary , "run" , "-d" , "--expose" , "3000-3003" , "-p" , "3000-3003" , "busybox" , "top" )
out , _ , err := runCommandWithOutput ( cmd )
id := strings . TrimSpace ( out )
portstr , err := inspectFieldJSON ( id , "NetworkSettings.Ports" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2014-11-03 18:15:55 +00:00
}
var ports nat . PortMap
err = unmarshalJSON ( [ ] byte ( portstr ) , & ports )
for port , binding := range ports {
portnum , _ := strconv . Atoi ( strings . Split ( string ( port ) , "/" ) [ 0 ] )
if portnum < 3000 || portnum > 3003 {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Port %d is out of range " , portnum )
2014-11-03 18:15:55 +00:00
}
if binding == nil || len ( binding ) != 1 || len ( binding [ 0 ] . HostPort ) == 0 {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Port is not mapped for the port " + port , out )
2014-11-03 18:15:55 +00:00
}
}
}
2015-01-09 23:42:55 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunOOMExitCode ( c * check . C ) {
2015-01-09 23:42:55 +00:00
done := make ( chan struct { } )
go func ( ) {
defer close ( done )
2015-03-31 23:57:43 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-m" , "4MB" , "busybox" , "sh" , "-c" , "x=a; while true; do x=$x$x$x$x; done" )
2015-01-09 23:42:55 +00:00
out , exitCode , _ := runCommandWithOutput ( runCmd )
if expected := 137 ; exitCode != expected {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "wrong exit code for OOM container: expected %d, got %d (output: %q)" , expected , exitCode , out )
2015-01-09 23:42:55 +00:00
}
} ( )
select {
case <- done :
2015-03-31 23:57:43 +00:00
case <- time . After ( 30 * time . Second ) :
2015-04-18 16:46:47 +00:00
c . Fatal ( "Timeout waiting for container to die on OOM" )
2015-01-09 23:42:55 +00:00
}
}
2015-01-13 23:19:12 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunSetDefaultRestartPolicy ( c * check . C ) {
2015-03-10 02:09:12 +00:00
runCmd := exec . Command ( dockerBinary , "run" , "-d" , "--name" , "test" , "busybox" , "top" )
if out , _ , err := runCommandWithOutput ( runCmd ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to run container: %v, output: %q" , err , out )
2015-03-10 02:09:12 +00:00
}
cmd := exec . Command ( dockerBinary , "inspect" , "-f" , "{{.HostConfig.RestartPolicy.Name}}" , "test" )
out , _ , err := runCommandWithOutput ( cmd )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "failed to inspect container: %v, output: %q" , err , out )
2015-03-10 02:09:12 +00:00
}
out = strings . Trim ( out , "\r\n" )
if out != "no" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Set default restart policy failed" )
2015-03-10 02:09:12 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunRestartMaxRetries ( c * check . C ) {
2015-01-13 23:19:12 +00:00
out , err := exec . Command ( dockerBinary , "run" , "-d" , "--restart=on-failure:3" , "busybox" , "false" ) . CombinedOutput ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( string ( out ) , err )
2015-01-13 23:19:12 +00:00
}
id := strings . TrimSpace ( string ( out ) )
2015-04-16 19:48:04 +00:00
if err := waitInspect ( id , "{{ .State.Restarting }} {{ .State.Running }}" , "false false" , 10 ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-01-13 23:19:12 +00:00
}
count , err := inspectField ( id , "RestartCount" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-01-13 23:19:12 +00:00
}
if count != "3" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container was restarted %s times, expected %d" , count , 3 )
2015-01-13 23:19:12 +00:00
}
2015-03-17 05:19:59 +00:00
MaximumRetryCount , err := inspectField ( id , "HostConfig.RestartPolicy.MaximumRetryCount" )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-03-17 05:19:59 +00:00
}
if MaximumRetryCount != "3" {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "Container Maximum Retry Count is %s, expected %s" , MaximumRetryCount , "3" )
2015-03-17 05:19:59 +00:00
}
2015-01-13 23:19:12 +00:00
}
2015-01-13 21:52:51 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunContainerWithWritableRootfs ( c * check . C ) {
2015-01-13 21:52:51 +00:00
out , err := exec . Command ( dockerBinary , "run" , "--rm" , "busybox" , "touch" , "/file" ) . CombinedOutput ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( string ( out ) , err )
2015-01-13 21:52:51 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunContainerWithReadonlyRootfs ( c * check . C ) {
testRequires ( c , NativeExecDriver )
2015-02-26 04:16:44 +00:00
2015-01-13 21:52:51 +00:00
out , err := exec . Command ( dockerBinary , "run" , "--read-only" , "--rm" , "busybox" , "touch" , "/file" ) . CombinedOutput ( )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "expected container to error on run with read only error" )
2015-01-13 21:52:51 +00:00
}
expected := "Read-only file system"
if ! strings . Contains ( string ( out ) , expected ) {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected output from failure to contain %s but contains %s" , expected , out )
2015-01-13 21:52:51 +00:00
}
}
2014-12-18 14:57:36 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunVolumesFromRestartAfterRemoved ( c * check . C ) {
2014-12-18 14:57:36 +00:00
out , _ , err := runCommandWithOutput ( exec . Command ( dockerBinary , "run" , "-d" , "--name" , "voltest" , "-v" , "/foo" , "busybox" ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-12-18 14:57:36 +00:00
}
out , _ , err = runCommandWithOutput ( exec . Command ( dockerBinary , "run" , "-d" , "--name" , "restarter" , "--volumes-from" , "voltest" , "busybox" , "top" ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-12-18 14:57:36 +00:00
}
// Remove the main volume container and restart the consuming container
out , _ , err = runCommandWithOutput ( exec . Command ( dockerBinary , "rm" , "-f" , "voltest" ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2014-12-18 14:57:36 +00:00
}
// This should not fail since the volumes-from were already applied
out , _ , err = runCommandWithOutput ( exec . Command ( dockerBinary , "restart" , "restarter" ) )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatalf ( "expected container to restart successfully: %v\n%s" , err , out )
2014-12-18 14:57:36 +00:00
}
}
2015-03-22 18:09:12 +00:00
// run container with --rm should remove container if exit code != 0
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunContainerWithRmFlagExitCodeNotEqualToZero ( c * check . C ) {
2015-04-08 23:20:42 +00:00
name := "flowers"
runCmd := exec . Command ( dockerBinary , "run" , "--name" , name , "--rm" , "busybox" , "ls" , "/notexists" )
2015-03-22 18:09:12 +00:00
out , _ , err := runCommandWithOutput ( runCmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected docker run to fail" , out , err )
2015-03-22 18:09:12 +00:00
}
out , err = getAllContainers ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2015-03-22 18:09:12 +00:00
}
if out != "" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected not to have containers" , out )
2015-03-22 18:09:12 +00:00
}
}
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunContainerWithRmFlagCannotStartContainer ( c * check . C ) {
2015-04-08 23:20:42 +00:00
name := "sparkles"
runCmd := exec . Command ( dockerBinary , "run" , "--name" , name , "--rm" , "busybox" , "commandNotFound" )
2015-03-22 18:09:12 +00:00
out , _ , err := runCommandWithOutput ( runCmd )
if err == nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected docker run to fail" , out , err )
2015-03-22 18:09:12 +00:00
}
out , err = getAllContainers ( )
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( out , err )
2015-03-22 18:09:12 +00:00
}
if out != "" {
2015-04-18 16:46:47 +00:00
c . Fatal ( "Expected not to have containers" , out )
2015-03-22 18:09:12 +00:00
}
}
2015-04-10 18:04:30 +00:00
2015-04-18 16:46:47 +00:00
func ( s * DockerSuite ) TestRunPidHostWithChildIsKillable ( c * check . C ) {
2015-04-10 18:04:30 +00:00
name := "ibuildthecloud"
if out , err := exec . Command ( dockerBinary , "run" , "-d" , "--pid=host" , "--name" , name , "busybox" , "sh" , "-c" , "sleep 30; echo hi" ) . CombinedOutput ( ) ; err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err , out )
2015-04-10 18:04:30 +00:00
}
time . Sleep ( 1 * time . Second )
errchan := make ( chan error )
go func ( ) {
if out , err := exec . Command ( dockerBinary , "kill" , name ) . CombinedOutput ( ) ; err != nil {
errchan <- fmt . Errorf ( "%v:\n%s" , err , out )
}
close ( errchan )
} ( )
select {
case err := <- errchan :
if err != nil {
2015-04-18 16:46:47 +00:00
c . Fatal ( err )
2015-04-10 18:04:30 +00:00
}
case <- time . After ( 5 * time . Second ) :
2015-04-18 16:46:47 +00:00
c . Fatal ( "Kill container timed out" )
2015-04-10 18:04:30 +00:00
}
}