kotovalexarian-likes-github
/
moby--moby
mirror of https://github.com/moby/moby.git
1
0
Fork 0
Code Releases Activity

Merge pull request #14851 from bfirsh/golint-integration-cli 

Golint integration-cli
This commit is contained in:
Tibor Vass 2015-07-22 11:28:19 -04:00
parent a751c0a52f 6b3c928140
commit 875fffdff8
17 changed files with 186 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hack/make/validate-lint
View File

@ -15,6 +15,7 @@ packages=(
daemon/network daemon/network
docker docker
dockerinit dockerinit
integration-cli
pkg/chrootarchive pkg/chrootarchive
pkg/directory pkg/directory
pkg/fileutils pkg/fileutils

42
integration-cli/docker_api_containers_test.go
View File

@ -584,7 +584,7 @@ RUN echo 'right'
} }
func (s *DockerSuite) TestBuildApiLowerDockerfile(c *check.C) { func (s *DockerSuite) TestBuildApiLowerDockerfile(c *check.C) {
git, err := fakeGIT("repo", map[string]string{ git, err := newFakeGit("repo", map[string]string{
"dockerfile": `FROM busybox "dockerfile": `FROM busybox
RUN echo from dockerfile`, RUN echo from dockerfile`,
}, false) }, false)
@ -609,7 +609,7 @@ RUN echo from dockerfile`,
} }
func (s *DockerSuite) TestBuildApiBuildGitWithF(c *check.C) { func (s *DockerSuite) TestBuildApiBuildGitWithF(c *check.C) {
git, err := fakeGIT("repo", map[string]string{ git, err := newFakeGit("repo", map[string]string{
"baz": `FROM busybox "baz": `FROM busybox
RUN echo from baz`, RUN echo from baz`,
"Dockerfile": `FROM busybox "Dockerfile": `FROM busybox
@ -638,7 +638,7 @@ RUN echo from Dockerfile`,
func (s *DockerSuite) TestBuildApiDoubleDockerfile(c *check.C) { func (s *DockerSuite) TestBuildApiDoubleDockerfile(c *check.C) {
testRequires(c, UnixCli) // dockerfile overwrites Dockerfile on Windows testRequires(c, UnixCli) // dockerfile overwrites Dockerfile on Windows
git, err := fakeGIT("repo", map[string]string{ git, err := newFakeGit("repo", map[string]string{
"Dockerfile": `FROM busybox "Dockerfile": `FROM busybox
RUN echo from Dockerfile`, RUN echo from Dockerfile`,
"dockerfile": `FROM busybox "dockerfile": `FROM busybox
@ -809,14 +809,14 @@ func (s *DockerSuite) TestContainerApiCommit(c *check.C) {
c.Assert(status, check.Equals, http.StatusCreated) c.Assert(status, check.Equals, http.StatusCreated)
type resp struct { type resp struct {
Id string ID string
} }
var img resp var img resp
if err := json.Unmarshal(b, &img); err != nil { if err := json.Unmarshal(b, &img); err != nil {
c.Fatal(err) c.Fatal(err)
} }
cmd, err := inspectField(img.Id, "Config.Cmd") cmd, err := inspectField(img.ID, "Config.Cmd")
if err != nil { if err != nil {
c.Fatal(err) c.Fatal(err)
} }
@ -824,7 +824,7 @@ func (s *DockerSuite) TestContainerApiCommit(c *check.C) {
c.Fatalf("got wrong Cmd from commit: %q", cmd) c.Fatalf("got wrong Cmd from commit: %q", cmd)
} }
// sanity check, make sure the image is what we think it is // sanity check, make sure the image is what we think it is
dockerCmd(c, "run", img.Id, "ls", "/test") dockerCmd(c, "run", img.ID, "ls", "/test")
} }
func (s *DockerSuite) TestContainerApiCommitWithLabelInConfig(c *check.C) { func (s *DockerSuite) TestContainerApiCommitWithLabelInConfig(c *check.C) {
@ -841,26 +841,26 @@ func (s *DockerSuite) TestContainerApiCommitWithLabelInConfig(c *check.C) {
c.Assert(status, check.Equals, http.StatusCreated) c.Assert(status, check.Equals, http.StatusCreated)
type resp struct { type resp struct {
Id string ID string
} }
var img resp var img resp
if err := json.Unmarshal(b, &img); err != nil { if err := json.Unmarshal(b, &img); err != nil {
c.Fatal(err) c.Fatal(err)
} }
label1, err := inspectFieldMap(img.Id, "Config.Labels", "key1") label1, err := inspectFieldMap(img.ID, "Config.Labels", "key1")
if err != nil { if err != nil {
c.Fatal(err) c.Fatal(err)
} }
c.Assert(label1, check.Equals, "value1") c.Assert(label1, check.Equals, "value1")
label2, err := inspectFieldMap(img.Id, "Config.Labels", "key2") label2, err := inspectFieldMap(img.ID, "Config.Labels", "key2")
if err != nil { if err != nil {
c.Fatal(err) c.Fatal(err)
} }
c.Assert(label2, check.Equals, "value2") c.Assert(label2, check.Equals, "value2")
cmd, err := inspectField(img.Id, "Config.Cmd") cmd, err := inspectField(img.ID, "Config.Cmd")
if err != nil { if err != nil {
c.Fatal(err) c.Fatal(err)
} }
@ -869,7 +869,7 @@ func (s *DockerSuite) TestContainerApiCommitWithLabelInConfig(c *check.C) {
} }
// sanity check, make sure the image is what we think it is // sanity check, make sure the image is what we think it is
dockerCmd(c, "run", img.Id, "ls", "/test") dockerCmd(c, "run", img.ID, "ls", "/test")
} }
func (s *DockerSuite) TestContainerApiBadPort(c *check.C) { func (s *DockerSuite) TestContainerApiBadPort(c *check.C) {
@ -909,14 +909,14 @@ func (s *DockerSuite) TestContainerApiCreate(c *check.C) {
c.Assert(status, check.Equals, http.StatusCreated) c.Assert(status, check.Equals, http.StatusCreated)
type createResp struct { type createResp struct {
Id string ID string
} }
var container createResp var container createResp
if err := json.Unmarshal(b, &container); err != nil { if err := json.Unmarshal(b, &container); err != nil {
c.Fatal(err) c.Fatal(err)
} }
out, _ := dockerCmd(c, "start", "-a", container.Id) out, _ := dockerCmd(c, "start", "-a", container.ID)
if strings.TrimSpace(out) != "/test" { if strings.TrimSpace(out) != "/test" {
c.Fatalf("expected output `/test`, got %q", out) c.Fatalf("expected output `/test`, got %q", out)
} }
@ -1050,15 +1050,15 @@ func (s *DockerSuite) TestContainerApiCreateWithCpuSharesCpuset(c *check.C) {
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
c.Assert(status, check.Equals, http.StatusOK) c.Assert(status, check.Equals, http.StatusOK)
var containerJson types.ContainerJSON var containerJSON types.ContainerJSON
c.Assert(json.Unmarshal(body, &containerJson), check.IsNil) c.Assert(json.Unmarshal(body, &containerJSON), check.IsNil)
out, err := inspectField(containerJson.Id, "HostConfig.CpuShares") out, err := inspectField(containerJSON.Id, "HostConfig.CpuShares")
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
c.Assert(out, check.Equals, "512") c.Assert(out, check.Equals, "512")
outCpuset, errCpuset := inspectField(containerJson.Id, "HostConfig.CpusetCpus") outCpuset, errCpuset := inspectField(containerJSON.Id, "HostConfig.CpusetCpus")
c.Assert(errCpuset, check.IsNil, check.Commentf("Output: %s", outCpuset)) c.Assert(errCpuset, check.IsNil, check.Commentf("Output: %s", outCpuset))
c.Assert(outCpuset, check.Equals, "0,1") c.Assert(outCpuset, check.Equals, "0,1")
} }
@ -1154,14 +1154,14 @@ func (s *DockerSuite) TestContainerApiPostCreateNull(c *check.C) {
c.Fatal(err) c.Fatal(err)
} }
type createResp struct { type createResp struct {
Id string ID string
} }
var container createResp var container createResp
if err := json.Unmarshal(b, &container); err != nil { if err := json.Unmarshal(b, &container); err != nil {
c.Fatal(err) c.Fatal(err)
} }
out, err := inspectField(container.Id, "HostConfig.CpusetCpus") out, err := inspectField(container.ID, "HostConfig.CpusetCpus")
if err != nil { if err != nil {
c.Fatal(err, out) c.Fatal(err, out)
} }
@ -1169,12 +1169,12 @@ func (s *DockerSuite) TestContainerApiPostCreateNull(c *check.C) {
c.Fatalf("expected empty string, got %q", out) c.Fatalf("expected empty string, got %q", out)
} }
outMemory, errMemory := inspectField(container.Id, "HostConfig.Memory") outMemory, errMemory := inspectField(container.ID, "HostConfig.Memory")
c.Assert(outMemory, check.Equals, "0") c.Assert(outMemory, check.Equals, "0")
if errMemory != nil { if errMemory != nil {
c.Fatal(errMemory, outMemory) c.Fatal(errMemory, outMemory)
} }
outMemorySwap, errMemorySwap := inspectField(container.Id, "HostConfig.MemorySwap") outMemorySwap, errMemorySwap := inspectField(container.ID, "HostConfig.MemorySwap")
c.Assert(outMemorySwap, check.Equals, "0") c.Assert(outMemorySwap, check.Equals, "0")
if errMemorySwap != nil { if errMemorySwap != nil {
c.Fatal(errMemorySwap, outMemorySwap) c.Fatal(errMemorySwap, outMemorySwap)

6
integration-cli/docker_cli_build_test.go
View File

@ -1890,7 +1890,7 @@ func (s *DockerSuite) TestBuildCancelationKillsSleep(c *check.C) {
} }
// Get the exit status of `docker build`, check it exited because killed. // Get the exit status of `docker build`, check it exited because killed.
if err := buildCmd.Wait(); err != nil && !IsKilled(err) { if err := buildCmd.Wait(); err != nil && !isKilled(err) {
c.Fatalf("wait failed during build run: %T %s", err, err) c.Fatalf("wait failed during build run: %T %s", err, err)
} }
@ -4065,7 +4065,7 @@ func (s *DockerSuite) TestBuildAddTarXzGz(c *check.C) {
func (s *DockerSuite) TestBuildFromGIT(c *check.C) { func (s *DockerSuite) TestBuildFromGIT(c *check.C) {
name := "testbuildfromgit" name := "testbuildfromgit"
git, err := fakeGIT("repo", map[string]string{ git, err := newFakeGit("repo", map[string]string{
"Dockerfile": `FROM busybox "Dockerfile": `FROM busybox
ADD first /first ADD first /first
RUN [ -f /first ] RUN [ -f /first ]
@ -4092,7 +4092,7 @@ func (s *DockerSuite) TestBuildFromGIT(c *check.C) {
func (s *DockerSuite) TestBuildFromGITWithContext(c *check.C) { func (s *DockerSuite) TestBuildFromGITWithContext(c *check.C) {
name := "testbuildfromgit" name := "testbuildfromgit"
git, err := fakeGIT("repo", map[string]string{ git, err := newFakeGit("repo", map[string]string{
"docker/Dockerfile": `FROM busybox "docker/Dockerfile": `FROM busybox
ADD first /first ADD first /first
RUN [ -f /first ] RUN [ -f /first ]

18
integration-cli/docker_cli_build_unix_test.go
View File

@ -10,7 +10,7 @@ import (
) )
func (s *DockerSuite) TestBuildResourceConstraintsAreUsed(c *check.C) { func (s *DockerSuite) TestBuildResourceConstraintsAreUsed(c *check.C) {
testRequires(c, CpuCfsQuota) testRequires(c, cpuCfsQuota)
name := "testbuildresourceconstraints" name := "testbuildresourceconstraints"
ctx, err := fakeContext(` ctx, err := fakeContext(`
@ -32,8 +32,8 @@ func (s *DockerSuite) TestBuildResourceConstraintsAreUsed(c *check.C) {
MemorySwap int64 MemorySwap int64
CpusetCpus string CpusetCpus string
CpusetMems string CpusetMems string
CpuShares int64 CPUShares int64
CpuQuota int64 CPUQuota int64
} }
cfg, err := inspectFieldJSON(cID, "HostConfig") cfg, err := inspectFieldJSON(cID, "HostConfig")
@ -45,9 +45,9 @@ func (s *DockerSuite) TestBuildResourceConstraintsAreUsed(c *check.C) {
if err := json.Unmarshal([]byte(cfg), &c1); err != nil { if err := json.Unmarshal([]byte(cfg), &c1); err != nil {
c.Fatal(err, cfg) c.Fatal(err, cfg)
} }
if c1.Memory != 67108864 || c1.MemorySwap != -1 || c1.CpusetCpus != "0" || c1.CpusetMems != "0" || c1.CpuShares != 100 || c1.CpuQuota != 8000 { if c1.Memory != 67108864 || c1.MemorySwap != -1 || c1.CpusetCpus != "0" || c1.CpusetMems != "0" || c1.CPUShares != 100 || c1.CPUQuota != 8000 {
c.Fatalf("resource constraints not set properly:\nMemory: %d, MemSwap: %d, CpusetCpus: %s, CpusetMems: %s, CpuShares: %d, CpuQuota: %d", c.Fatalf("resource constraints not set properly:\nMemory: %d, MemSwap: %d, CpusetCpus: %s, CpusetMems: %s, CPUShares: %d, CPUQuota: %d",
c1.Memory, c1.MemorySwap, c1.CpusetCpus, c1.CpusetMems, c1.CpuShares, c1.CpuQuota) c1.Memory, c1.MemorySwap, c1.CpusetCpus, c1.CpusetMems, c1.CPUShares, c1.CPUQuota)
} }
// Make sure constraints aren't saved to image // Make sure constraints aren't saved to image
@ -61,9 +61,9 @@ func (s *DockerSuite) TestBuildResourceConstraintsAreUsed(c *check.C) {
if err := json.Unmarshal([]byte(cfg), &c2); err != nil { if err := json.Unmarshal([]byte(cfg), &c2); err != nil {
c.Fatal(err, cfg) c.Fatal(err, cfg)
} }
if c2.Memory == 67108864 || c2.MemorySwap == -1 || c2.CpusetCpus == "0" || c2.CpusetMems == "0" || c2.CpuShares == 100 || c2.CpuQuota == 8000 { if c2.Memory == 67108864 || c2.MemorySwap == -1 || c2.CpusetCpus == "0" || c2.CpusetMems == "0" || c2.CPUShares == 100 || c2.CPUQuota == 8000 {
c.Fatalf("resource constraints leaked from build:\nMemory: %d, MemSwap: %d, CpusetCpus: %s, CpusetMems: %s, CpuShares: %d, CpuQuota: %d", c.Fatalf("resource constraints leaked from build:\nMemory: %d, MemSwap: %d, CpusetCpus: %s, CpusetMems: %s, CPUShares: %d, CPUQuota: %d",
c2.Memory, c2.MemorySwap, c2.CpusetCpus, c2.CpusetMems, c2.CpuShares, c2.CpuQuota) c2.Memory, c2.MemorySwap, c2.CpusetCpus, c2.CpusetMems, c2.CPUShares, c2.CPUQuota)
} }
} }

74
integration-cli/docker_cli_cp_utils.go
View File

@ -13,37 +13,37 @@ import (
"github.com/go-check/check" "github.com/go-check/check"
) )
type FileType uint32 type fileType uint32
const ( const (
Regular FileType = iota ftRegular fileType = iota
Dir ftDir
Symlink ftSymlink
) )
type FileData struct { type fileData struct {
filetype FileType filetype fileType
path string path string
contents string contents string
} }
func (fd FileData) creationCommand() string { func (fd fileData) creationCommand() string {
var command string var command string
switch fd.filetype { switch fd.filetype {
case Regular: case ftRegular:
// Don't overwrite the file if it already exists! // Don't overwrite the file if it already exists!
command = fmt.Sprintf("if [ ! -f %s ]; then echo %q > %s; fi", fd.path, fd.contents, fd.path) command = fmt.Sprintf("if [ ! -f %s ]; then echo %q > %s; fi", fd.path, fd.contents, fd.path)
case Dir: case ftDir:
command = fmt.Sprintf("mkdir -p %s", fd.path) command = fmt.Sprintf("mkdir -p %s", fd.path)
case Symlink: case ftSymlink:
command = fmt.Sprintf("ln -fs %s %s", fd.contents, fd.path) command = fmt.Sprintf("ln -fs %s %s", fd.contents, fd.path)
} }
return command return command
} }
func mkFilesCommand(fds []FileData) string { func mkFilesCommand(fds []fileData) string {
commands := make([]string, len(fds)) commands := make([]string, len(fds))
for i, fd := range fds { for i, fd := range fds {
@ -53,29 +53,29 @@ func mkFilesCommand(fds []FileData) string {
return strings.Join(commands, " && ") return strings.Join(commands, " && ")
} }
var defaultFileData = []FileData{ var defaultFileData = []fileData{
{Regular, "file1", "file1"}, {ftRegular, "file1", "file1"},
{Regular, "file2", "file2"}, {ftRegular, "file2", "file2"},
{Regular, "file3", "file3"}, {ftRegular, "file3", "file3"},
{Regular, "file4", "file4"}, {ftRegular, "file4", "file4"},
{Regular, "file5", "file5"}, {ftRegular, "file5", "file5"},
{Regular, "file6", "file6"}, {ftRegular, "file6", "file6"},
{Regular, "file7", "file7"}, {ftRegular, "file7", "file7"},
{Dir, "dir1", ""}, {ftDir, "dir1", ""},
{Regular, "dir1/file1-1", "file1-1"}, {ftRegular, "dir1/file1-1", "file1-1"},
{Regular, "dir1/file1-2", "file1-2"}, {ftRegular, "dir1/file1-2", "file1-2"},
{Dir, "dir2", ""}, {ftDir, "dir2", ""},
{Regular, "dir2/file2-1", "file2-1"}, {ftRegular, "dir2/file2-1", "file2-1"},
{Regular, "dir2/file2-2", "file2-2"}, {ftRegular, "dir2/file2-2", "file2-2"},
{Dir, "dir3", ""}, {ftDir, "dir3", ""},
{Regular, "dir3/file3-1", "file3-1"}, {ftRegular, "dir3/file3-1", "file3-1"},
{Regular, "dir3/file3-2", "file3-2"}, {ftRegular, "dir3/file3-2", "file3-2"},
{Dir, "dir4", ""}, {ftDir, "dir4", ""},
{Regular, "dir4/file3-1", "file4-1"}, {ftRegular, "dir4/file3-1", "file4-1"},
{Regular, "dir4/file3-2", "file4-2"}, {ftRegular, "dir4/file3-2", "file4-2"},
{Dir, "dir5", ""}, {ftDir, "dir5", ""},
{Symlink, "symlink1", "target1"}, {ftSymlink, "symlink1", "target1"},
{Symlink, "symlink2", "target2"}, {ftSymlink, "symlink2", "target2"},
} }
func defaultMkContentCommand() string { func defaultMkContentCommand() string {
@ -86,15 +86,15 @@ func makeTestContentInDir(c *check.C, dir string) {
for _, fd := range defaultFileData { for _, fd := range defaultFileData {
path := filepath.Join(dir, filepath.FromSlash(fd.path)) path := filepath.Join(dir, filepath.FromSlash(fd.path))
switch fd.filetype { switch fd.filetype {
case Regular: case ftRegular:
if err := ioutil.WriteFile(path, []byte(fd.contents+"\n"), os.FileMode(0666)); err != nil { if err := ioutil.WriteFile(path, []byte(fd.contents+"\n"), os.FileMode(0666)); err != nil {
c.Fatal(err) c.Fatal(err)
} }
case Dir: case ftDir:
if err := os.Mkdir(path, os.FileMode(0777)); err != nil { if err := os.Mkdir(path, os.FileMode(0777)); err != nil {
c.Fatal(err) c.Fatal(err)
} }
case Symlink: case ftSymlink:
if err := os.Symlink(fd.contents, path); err != nil { if err := os.Symlink(fd.contents, path); err != nil {
c.Fatal(err) c.Fatal(err)
} }

80
integration-cli/docker_cli_daemon_test.go
View File

@ -476,10 +476,10 @@ func (s *DockerDaemonSuite) TestDaemonBridgeExternal(c *check.C) {
defer d.Restart() defer d.Restart()
bridgeName := "external-bridge" bridgeName := "external-bridge"
bridgeIp := "192.169.1.1/24" bridgeIP := "192.169.1.1/24"
_, bridgeIPNet, _ := net.ParseCIDR(bridgeIp) _, bridgeIPNet, _ := net.ParseCIDR(bridgeIP)
out, err := createInterface(c, "bridge", bridgeName, bridgeIp) out, err := createInterface(c, "bridge", bridgeName, bridgeIP)
c.Assert(err, check.IsNil, check.Commentf(out)) c.Assert(err, check.IsNil, check.Commentf(out))
defer deleteInterface(c, bridgeName) defer deleteInterface(c, bridgeName)
@ -498,11 +498,11 @@ func (s *DockerDaemonSuite) TestDaemonBridgeExternal(c *check.C) {
_, err = d.Cmd("run", "-d", "--name", "ExtContainer", "busybox", "top") _, err = d.Cmd("run", "-d", "--name", "ExtContainer", "busybox", "top")
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
containerIp := d.findContainerIP("ExtContainer") containerIP := d.findContainerIP("ExtContainer")
ip := net.ParseIP(containerIp) ip := net.ParseIP(containerIP)
c.Assert(bridgeIPNet.Contains(ip), check.Equals, true, c.Assert(bridgeIPNet.Contains(ip), check.Equals, true,
check.Commentf("Container IP-Address must be in the same subnet range : %s", check.Commentf("Container IP-Address must be in the same subnet range : %s",
containerIp)) containerIP))
} }
func createInterface(c *check.C, ifType string, ifName string, ipNet string) (string, error) { func createInterface(c *check.C, ifType string, ifName string, ipNet string) (string, error) {
@ -547,10 +547,10 @@ func (s *DockerDaemonSuite) TestDaemonBridgeIP(c *check.C) {
d := s.d d := s.d
bridgeIp := "192.169.1.1/24" bridgeIP := "192.169.1.1/24"
ip, bridgeIPNet, _ := net.ParseCIDR(bridgeIp) ip, bridgeIPNet, _ := net.ParseCIDR(bridgeIP)
err := d.StartWithBusybox("--bip", bridgeIp) err := d.StartWithBusybox("--bip", bridgeIP)
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
defer d.Restart() defer d.Restart()
@ -575,11 +575,11 @@ func (s *DockerDaemonSuite) TestDaemonBridgeIP(c *check.C) {
out, err = d.Cmd("run", "-d", "--name", "test", "busybox", "top") out, err = d.Cmd("run", "-d", "--name", "test", "busybox", "top")
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
containerIp := d.findContainerIP("test") containerIP := d.findContainerIP("test")
ip = net.ParseIP(containerIp) ip = net.ParseIP(containerIP)
c.Assert(bridgeIPNet.Contains(ip), check.Equals, true, c.Assert(bridgeIPNet.Contains(ip), check.Equals, true,
check.Commentf("Container IP-Address must be in the same subnet range : %s", check.Commentf("Container IP-Address must be in the same subnet range : %s",
containerIp)) containerIP))
deleteInterface(c, defaultNetworkBridge) deleteInterface(c, defaultNetworkBridge)
} }
@ -622,9 +622,9 @@ func (s *DockerDaemonSuite) TestDaemonBridgeFixedCidr(c *check.C) {
d := s.d d := s.d
bridgeName := "external-bridge" bridgeName := "external-bridge"
bridgeIp := "192.169.1.1/24" bridgeIP := "192.169.1.1/24"
out, err := createInterface(c, "bridge", bridgeName, bridgeIp) out, err := createInterface(c, "bridge", bridgeName, bridgeIP)
c.Assert(err, check.IsNil, check.Commentf(out)) c.Assert(err, check.IsNil, check.Commentf(out))
defer deleteInterface(c, bridgeName) defer deleteInterface(c, bridgeName)
@ -649,18 +649,18 @@ func (s *DockerDaemonSuite) TestDaemonDefaultGatewayIPv4Implicit(c *check.C) {
d := s.d d := s.d
bridgeIp := "192.169.1.1" bridgeIP := "192.169.1.1"
bridgeIpNet := fmt.Sprintf("%s/24", bridgeIp) bridgeIPNet := fmt.Sprintf("%s/24", bridgeIP)
err := d.StartWithBusybox("--bip", bridgeIpNet) err := d.StartWithBusybox("--bip", bridgeIPNet)
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
defer d.Restart() defer d.Restart()
expectedMessage := fmt.Sprintf("default via %s dev", bridgeIp) expectedMessage := fmt.Sprintf("default via %s dev", bridgeIP)
out, err := d.Cmd("run", "busybox", "ip", "-4", "route", "list", "0/0") out, err := d.Cmd("run", "busybox", "ip", "-4", "route", "list", "0/0")
c.Assert(strings.Contains(out, expectedMessage), check.Equals, true, c.Assert(strings.Contains(out, expectedMessage), check.Equals, true,
check.Commentf("Implicit default gateway should be bridge IP %s, but default route was '%s'", check.Commentf("Implicit default gateway should be bridge IP %s, but default route was '%s'",
bridgeIp, strings.TrimSpace(out))) bridgeIP, strings.TrimSpace(out)))
deleteInterface(c, defaultNetworkBridge) deleteInterface(c, defaultNetworkBridge)
} }
@ -670,19 +670,19 @@ func (s *DockerDaemonSuite) TestDaemonDefaultGatewayIPv4Explicit(c *check.C) {
d := s.d d := s.d
bridgeIp := "192.169.1.1" bridgeIP := "192.169.1.1"
bridgeIpNet := fmt.Sprintf("%s/24", bridgeIp) bridgeIPNet := fmt.Sprintf("%s/24", bridgeIP)
gatewayIp := "192.169.1.254" gatewayIP := "192.169.1.254"
err := d.StartWithBusybox("--bip", bridgeIpNet, "--default-gateway", gatewayIp) err := d.StartWithBusybox("--bip", bridgeIPNet, "--default-gateway", gatewayIP)
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
defer d.Restart() defer d.Restart()
expectedMessage := fmt.Sprintf("default via %s dev", gatewayIp) expectedMessage := fmt.Sprintf("default via %s dev", gatewayIP)
out, err := d.Cmd("run", "busybox", "ip", "-4", "route", "list", "0/0") out, err := d.Cmd("run", "busybox", "ip", "-4", "route", "list", "0/0")
c.Assert(strings.Contains(out, expectedMessage), check.Equals, true, c.Assert(strings.Contains(out, expectedMessage), check.Equals, true,
check.Commentf("Explicit default gateway should be %s, but default route was '%s'", check.Commentf("Explicit default gateway should be %s, but default route was '%s'",
gatewayIp, strings.TrimSpace(out))) gatewayIP, strings.TrimSpace(out)))
deleteInterface(c, defaultNetworkBridge) deleteInterface(c, defaultNetworkBridge)
} }
@ -723,9 +723,9 @@ func (s *DockerDaemonSuite) TestDaemonICCPing(c *check.C) {
d := s.d d := s.d
bridgeName := "external-bridge" bridgeName := "external-bridge"
bridgeIp := "192.169.1.1/24" bridgeIP := "192.169.1.1/24"
out, err := createInterface(c, "bridge", bridgeName, bridgeIp) out, err := createInterface(c, "bridge", bridgeName, bridgeIP)
c.Assert(err, check.IsNil, check.Commentf(out)) c.Assert(err, check.IsNil, check.Commentf(out))
defer deleteInterface(c, bridgeName) defer deleteInterface(c, bridgeName)
@ -763,9 +763,9 @@ func (s *DockerDaemonSuite) TestDaemonICCLinkExpose(c *check.C) {
d := s.d d := s.d
bridgeName := "external-bridge" bridgeName := "external-bridge"
bridgeIp := "192.169.1.1/24" bridgeIP := "192.169.1.1/24"
out, err := createInterface(c, "bridge", bridgeName, bridgeIp) out, err := createInterface(c, "bridge", bridgeName, bridgeIP)
c.Assert(err, check.IsNil, check.Commentf(out)) c.Assert(err, check.IsNil, check.Commentf(out))
defer deleteInterface(c, bridgeName) defer deleteInterface(c, bridgeName)
@ -792,9 +792,9 @@ func (s *DockerDaemonSuite) TestDaemonICCLinkExpose(c *check.C) {
func (s *DockerDaemonSuite) TestDaemonLinksIpTablesRulesWhenLinkAndUnlink(c *check.C) { func (s *DockerDaemonSuite) TestDaemonLinksIpTablesRulesWhenLinkAndUnlink(c *check.C) {
bridgeName := "external-bridge" bridgeName := "external-bridge"
bridgeIp := "192.169.1.1/24" bridgeIP := "192.169.1.1/24"
out, err := createInterface(c, "bridge", bridgeName, bridgeIp) out, err := createInterface(c, "bridge", bridgeName, bridgeIP)
c.Assert(err, check.IsNil, check.Commentf(out)) c.Assert(err, check.IsNil, check.Commentf(out))
defer deleteInterface(c, bridgeName) defer deleteInterface(c, bridgeName)
@ -1210,16 +1210,16 @@ func (s *DockerDaemonSuite) TestDaemonRestartKillWait(c *check.C) {
// TestHttpsInfo connects via two-way authenticated HTTPS to the info endpoint // TestHttpsInfo connects via two-way authenticated HTTPS to the info endpoint
func (s *DockerDaemonSuite) TestHttpsInfo(c *check.C) { func (s *DockerDaemonSuite) TestHttpsInfo(c *check.C) {
const ( const (
testDaemonHttpsAddr = "localhost:4271" testDaemonHTTPSAddr = "localhost:4271"
) )
if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem", if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
"--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHttpsAddr); err != nil { "--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHTTPSAddr); err != nil {
c.Fatalf("Could not start daemon with busybox: %v", err) c.Fatalf("Could not start daemon with busybox: %v", err)
} }
//force tcp protocol //force tcp protocol
host := fmt.Sprintf("tcp://%s", testDaemonHttpsAddr) host := fmt.Sprintf("tcp://%s", testDaemonHTTPSAddr)
daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-cert.pem", "--tlskey", "fixtures/https/client-key.pem"} daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-cert.pem", "--tlskey", "fixtures/https/client-key.pem"}
out, err := s.d.CmdWithArgs(daemonArgs, "info") out, err := s.d.CmdWithArgs(daemonArgs, "info")
if err != nil { if err != nil {
@ -1232,15 +1232,15 @@ func (s *DockerDaemonSuite) TestHttpsInfo(c *check.C) {
func (s *DockerDaemonSuite) TestHttpsInfoRogueCert(c *check.C) { func (s *DockerDaemonSuite) TestHttpsInfoRogueCert(c *check.C) {
const ( const (
errBadCertificate = "remote error: bad certificate" errBadCertificate = "remote error: bad certificate"
testDaemonHttpsAddr = "localhost:4271" testDaemonHTTPSAddr = "localhost:4271"
) )
if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem", if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-cert.pem",
"--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHttpsAddr); err != nil { "--tlskey", "fixtures/https/server-key.pem", "-H", testDaemonHTTPSAddr); err != nil {
c.Fatalf("Could not start daemon with busybox: %v", err) c.Fatalf("Could not start daemon with busybox: %v", err)
} }
//force tcp protocol //force tcp protocol
host := fmt.Sprintf("tcp://%s", testDaemonHttpsAddr) host := fmt.Sprintf("tcp://%s", testDaemonHTTPSAddr)
daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"} daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"}
out, err := s.d.CmdWithArgs(daemonArgs, "info") out, err := s.d.CmdWithArgs(daemonArgs, "info")
if err == nil || !strings.Contains(out, errBadCertificate) { if err == nil || !strings.Contains(out, errBadCertificate) {
@ -1253,15 +1253,15 @@ func (s *DockerDaemonSuite) TestHttpsInfoRogueCert(c *check.C) {
func (s *DockerDaemonSuite) TestHttpsInfoRogueServerCert(c *check.C) { func (s *DockerDaemonSuite) TestHttpsInfoRogueServerCert(c *check.C) {
const ( const (
errCaUnknown = "x509: certificate signed by unknown authority" errCaUnknown = "x509: certificate signed by unknown authority"
testDaemonRogueHttpsAddr = "localhost:4272" testDaemonRogueHTTPSAddr = "localhost:4272"
) )
if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-rogue-cert.pem", if err := s.d.Start("--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/server-rogue-cert.pem",
"--tlskey", "fixtures/https/server-rogue-key.pem", "-H", testDaemonRogueHttpsAddr); err != nil { "--tlskey", "fixtures/https/server-rogue-key.pem", "-H", testDaemonRogueHTTPSAddr); err != nil {
c.Fatalf("Could not start daemon with busybox: %v", err) c.Fatalf("Could not start daemon with busybox: %v", err)
} }
//force tcp protocol //force tcp protocol
host := fmt.Sprintf("tcp://%s", testDaemonRogueHttpsAddr) host := fmt.Sprintf("tcp://%s", testDaemonRogueHTTPSAddr)
daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"} daemonArgs := []string{"--host", host, "--tlsverify", "--tlscacert", "fixtures/https/ca.pem", "--tlscert", "fixtures/https/client-rogue-cert.pem", "--tlskey", "fixtures/https/client-rogue-key.pem"}
out, err := s.d.CmdWithArgs(daemonArgs, "info") out, err := s.d.CmdWithArgs(daemonArgs, "info")
if err == nil || !strings.Contains(out, errCaUnknown) { if err == nil || !strings.Contains(out, errCaUnknown) {

4
integration-cli/docker_cli_exec_unix_test.go
View File

@ -16,9 +16,9 @@ import (
// regression test for #12546 // regression test for #12546
func (s *DockerSuite) TestExecInteractiveStdinClose(c *check.C) { func (s *DockerSuite) TestExecInteractiveStdinClose(c *check.C) {
out, _ := dockerCmd(c, "run", "-itd", "busybox", "/bin/cat") out, _ := dockerCmd(c, "run", "-itd", "busybox", "/bin/cat")
contId := strings.TrimSpace(out) contID := strings.TrimSpace(out)
cmd := exec.Command(dockerBinary, "exec", "-i", contId, "echo", "-n", "hello") cmd := exec.Command(dockerBinary, "exec", "-i", contID, "echo", "-n", "hello")
p, err := pty.Start(cmd) p, err := pty.Start(cmd)
if err != nil { if err != nil {
c.Fatal(err) c.Fatal(err)

8
integration-cli/docker_cli_images_test.go
View File

@ -139,17 +139,17 @@ func (s *DockerSuite) TestImagesFilterSpaceTrimCase(c *check.C) {
func (s *DockerSuite) TestImagesEnsureDanglingImageOnlyListedOnce(c *check.C) { func (s *DockerSuite) TestImagesEnsureDanglingImageOnlyListedOnce(c *check.C) {
// create container 1 // create container 1
out, _ := dockerCmd(c, "run", "-d", "busybox", "true") out, _ := dockerCmd(c, "run", "-d", "busybox", "true")
containerId1 := strings.TrimSpace(out) containerID1 := strings.TrimSpace(out)
// tag as foobox // tag as foobox
out, _ = dockerCmd(c, "commit", containerId1, "foobox") out, _ = dockerCmd(c, "commit", containerID1, "foobox")
imageId := stringid.TruncateID(strings.TrimSpace(out)) imageID := stringid.TruncateID(strings.TrimSpace(out))
// overwrite the tag, making the previous image dangling // overwrite the tag, making the previous image dangling
dockerCmd(c, "tag", "-f", "busybox", "foobox") dockerCmd(c, "tag", "-f", "busybox", "foobox")
out, _ = dockerCmd(c, "images", "-q", "-f", "dangling=true") out, _ = dockerCmd(c, "images", "-q", "-f", "dangling=true")
if e, a := 1, strings.Count(out, imageId); e != a { if e, a := 1, strings.Count(out, imageID); e != a {
c.Fatalf("expected 1 dangling image, got %d: %s", a, out) c.Fatalf("expected 1 dangling image, got %d: %s", a, out)
} }
} }

12
integration-cli/docker_cli_inspect_test.go
View File

@ -171,12 +171,12 @@ func (s *DockerSuite) TestInspectImageGraphDriver(c *check.C) {
return return
} }
deviceId, err := inspectField(imageTest, "GraphDriver.Data.DeviceId") deviceID, err := inspectField(imageTest, "GraphDriver.Data.DeviceId")
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
_, err = strconv.Atoi(deviceId) _, err = strconv.Atoi(deviceID)
if err != nil { if err != nil {
c.Fatalf("failed to inspect DeviceId of the image: %s, %v", deviceId, err) c.Fatalf("failed to inspect DeviceId of the image: %s, %v", deviceID, err)
} }
deviceSize, err := inspectField(imageTest, "GraphDriver.Data.DeviceSize") deviceSize, err := inspectField(imageTest, "GraphDriver.Data.DeviceSize")
@ -203,12 +203,12 @@ func (s *DockerSuite) TestInspectContainerGraphDriver(c *check.C) {
return return
} }
deviceId, err := inspectField(out, "GraphDriver.Data.DeviceId") deviceID, err := inspectField(out, "GraphDriver.Data.DeviceId")
c.Assert(err, check.IsNil) c.Assert(err, check.IsNil)
_, err = strconv.Atoi(deviceId) _, err = strconv.Atoi(deviceID)
if err != nil { if err != nil {
c.Fatalf("failed to inspect DeviceId of the image: %s, %v", deviceId, err) c.Fatalf("failed to inspect DeviceId of the image: %s, %v", deviceID, err)
} }
deviceSize, err := inspectField(out, "GraphDriver.Data.DeviceSize") deviceSize, err := inspectField(out, "GraphDriver.Data.DeviceSize")

4
integration-cli/docker_cli_run_test.go
View File

@ -1825,7 +1825,7 @@ func (s *DockerSuite) TestRunVolumesCleanPaths(c *check.C) {
dockerCmd(c, "run", "-v", "/foo", "-v", "/bar/", "--name", "dark_helmet", "run_volumes_clean_paths") dockerCmd(c, "run", "-v", "/foo", "-v", "/bar/", "--name", "dark_helmet", "run_volumes_clean_paths")
out, err := inspectMountSourceField("dark_helmet", "/foo/") out, err := inspectMountSourceField("dark_helmet", "/foo/")
if err != mountNotFound { if err != errMountNotFound {
c.Fatalf("Found unexpected volume entry for '/foo/' in volumes\n%q", out) c.Fatalf("Found unexpected volume entry for '/foo/' in volumes\n%q", out)
} }
@ -1836,7 +1836,7 @@ func (s *DockerSuite) TestRunVolumesCleanPaths(c *check.C) {
} }
out, err = inspectMountSourceField("dark_helmet", "/bar/") out, err = inspectMountSourceField("dark_helmet", "/bar/")
if err != mountNotFound { if err != errMountNotFound {
c.Fatalf("Found unexpected volume entry for '/bar/' in volumes\n%q", out) c.Fatalf("Found unexpected volume entry for '/bar/' in volumes\n%q", out)
} }

6
integration-cli/docker_cli_run_unix_test.go
View File

@ -250,7 +250,7 @@ func (s *DockerSuite) TestRunAttachDetach(c *check.C) {
// "test" should be printed // "test" should be printed
func (s *DockerSuite) TestRunEchoStdoutWithCPUQuota(c *check.C) { func (s *DockerSuite) TestRunEchoStdoutWithCPUQuota(c *check.C) {
testRequires(c, CpuCfsQuota) testRequires(c, cpuCfsQuota)
out, _, err := dockerCmdWithError(c, "run", "--cpu-quota", "8000", "--name", "test", "busybox", "echo", "test") out, _, err := dockerCmdWithError(c, "run", "--cpu-quota", "8000", "--name", "test", "busybox", "echo", "test")
if err != nil { if err != nil {
@ -270,7 +270,7 @@ func (s *DockerSuite) TestRunEchoStdoutWithCPUQuota(c *check.C) {
} }
func (s *DockerSuite) TestRunWithCpuPeriod(c *check.C) { func (s *DockerSuite) TestRunWithCpuPeriod(c *check.C) {
testRequires(c, CpuCfsPeriod) testRequires(c, cpuCfsPeriod)
if _, _, err := dockerCmdWithError(c, "run", "--cpu-period", "50000", "--name", "test", "busybox", "true"); err != nil { if _, _, err := dockerCmdWithError(c, "run", "--cpu-period", "50000", "--name", "test", "busybox", "true"); err != nil {
c.Fatalf("failed to run container: %v", err) c.Fatalf("failed to run container: %v", err)
@ -284,7 +284,7 @@ func (s *DockerSuite) TestRunWithCpuPeriod(c *check.C) {
} }
func (s *DockerSuite) TestRunOOMExitCode(c *check.C) { func (s *DockerSuite) TestRunOOMExitCode(c *check.C) {
testRequires(c, OomControl) testRequires(c, oomControl)
errChan := make(chan error) errChan := make(chan error)
go func() { go func() {
defer close(errChan) defer close(errChan)

2
integration-cli/docker_cli_save_load_test.go
View File

@ -269,7 +269,7 @@ func (s *DockerSuite) TestSaveDirectoryPermissions(c *check.C) {
c.Fatalf("failed to open %s: %s", layerPath, err) c.Fatalf("failed to open %s: %s", layerPath, err)
} }
entries, err := ListTar(f) entries, err := listTar(f)
for _, e := range entries { for _, e := range entries {
if !strings.Contains(e, "dev/") { if !strings.Contains(e, "dev/") {
entriesSansDev = append(entriesSansDev, e) entriesSansDev = append(entriesSansDev, e)

53
integration-cli/docker_utils.go
View File

@ -289,6 +289,8 @@ func (d *Daemon) Cmd(name string, arg ...string) (string, error) {
return string(b), err return string(b), err
} }
// CmdWithArgs will execute a docker CLI command against a daemon with the
// given additional arguments
func (d *Daemon) CmdWithArgs(daemonArgs []string, name string, arg ...string) (string, error) { func (d *Daemon) CmdWithArgs(daemonArgs []string, name string, arg ...string) (string, error) {
args := append(daemonArgs, name) args := append(daemonArgs, name)
args = append(args, arg...) args = append(args, arg...)
@ -297,33 +299,34 @@ func (d *Daemon) CmdWithArgs(daemonArgs []string, name string, arg ...string) (s
return string(b), err return string(b), err
} }
// LogfileName returns the path the the daemon's log file
func (d *Daemon) LogfileName() string { func (d *Daemon) LogfileName() string {
return d.logFile.Name() return d.logFile.Name()
} }
func daemonHost() string { func daemonHost() string {
daemonUrlStr := "unix://" + opts.DefaultUnixSocket daemonURLStr := "unix://" + opts.DefaultUnixSocket
if daemonHostVar := os.Getenv("DOCKER_HOST"); daemonHostVar != "" { if daemonHostVar := os.Getenv("DOCKER_HOST"); daemonHostVar != "" {
daemonUrlStr = daemonHostVar daemonURLStr = daemonHostVar
} }
return daemonUrlStr return daemonURLStr
} }
func sockConn(timeout time.Duration) (net.Conn, error) { func sockConn(timeout time.Duration) (net.Conn, error) {
daemon := daemonHost() daemon := daemonHost()
daemonUrl, err := url.Parse(daemon) daemonURL, err := url.Parse(daemon)
if err != nil { if err != nil {
return nil, fmt.Errorf("could not parse url %q: %v", daemon, err) return nil, fmt.Errorf("could not parse url %q: %v", daemon, err)
} }
var c net.Conn var c net.Conn
switch daemonUrl.Scheme { switch daemonURL.Scheme {
case "unix": case "unix":
return net.DialTimeout(daemonUrl.Scheme, daemonUrl.Path, timeout) return net.DialTimeout(daemonURL.Scheme, daemonURL.Path, timeout)
case "tcp": case "tcp":
return net.DialTimeout(daemonUrl.Scheme, daemonUrl.Host, timeout) return net.DialTimeout(daemonURL.Scheme, daemonURL.Host, timeout)
default: default:
return c, fmt.Errorf("unknown scheme %v (%s)", daemonUrl.Scheme, daemon) return c, fmt.Errorf("unknown scheme %v (%s)", daemonURL.Scheme, daemon)
} }
} }
@ -638,10 +641,12 @@ func getContainerCount() (int, error) {
return 0, fmt.Errorf("couldn't find the Container count in the output") return 0, fmt.Errorf("couldn't find the Container count in the output")
} }
// FakeContext creates directories that can be used as a build context
type FakeContext struct { type FakeContext struct {
Dir string Dir string
} }
// Add a file at a path, creating directories where necessary
func (f *FakeContext) Add(file, content string) error { func (f *FakeContext) Add(file, content string) error {
return f.addFile(file, []byte(content)) return f.addFile(file, []byte(content))
} }
@ -658,11 +663,13 @@ func (f *FakeContext) addFile(file string, content []byte) error {
} }
// Delete a file at a path
func (f *FakeContext) Delete(file string) error { func (f *FakeContext) Delete(file string) error {
filepath := path.Join(f.Dir, file) filepath := path.Join(f.Dir, file)
return os.RemoveAll(filepath) return os.RemoveAll(filepath)
} }
// Close deletes the context
func (f *FakeContext) Close() error { func (f *FakeContext) Close() error {
return os.RemoveAll(f.Dir) return os.RemoveAll(f.Dir)
} }
@ -898,7 +905,7 @@ func inspectMountPoint(name, destination string) (types.MountPoint, error) {
return inspectMountPointJSON(out, destination) return inspectMountPointJSON(out, destination)
} }
var mountNotFound = errors.New("mount point not found") var errMountNotFound = errors.New("mount point not found")
func inspectMountPointJSON(j, destination string) (types.MountPoint, error) { func inspectMountPointJSON(j, destination string) (types.MountPoint, error) {
var mp []types.MountPoint var mp []types.MountPoint
@ -915,7 +922,7 @@ func inspectMountPointJSON(j, destination string) (types.MountPoint, error) {
} }
if m == nil { if m == nil {
return types.MountPoint{}, mountNotFound return types.MountPoint{}, errMountNotFound
} }
return *m, nil return *m, nil
@ -1027,7 +1034,7 @@ func buildImageFromPath(name, path string, useCache bool) (string, error) {
return getIDByName(name) return getIDByName(name)
} }
type GitServer interface { type gitServer interface {
URL() string URL() string
Close() error Close() error
} }
@ -1045,18 +1052,18 @@ func (r *localGitServer) URL() string {
return r.Server.URL return r.Server.URL
} }
type FakeGIT struct { type fakeGit struct {
root string root string
server GitServer server gitServer
RepoURL string RepoURL string
} }
func (g *FakeGIT) Close() { func (g *fakeGit) Close() {
g.server.Close() g.server.Close()
os.RemoveAll(g.root) os.RemoveAll(g.root)
} }
func fakeGIT(name string, files map[string]string, enforceLocalServer bool) (*FakeGIT, error) { func newFakeGit(name string, files map[string]string, enforceLocalServer bool) (*fakeGit, error) {
ctx, err := fakeContextWithFiles(files) ctx, err := fakeContextWithFiles(files)
if err != nil { if err != nil {
return nil, err return nil, err
@ -1112,7 +1119,7 @@ func fakeGIT(name string, files map[string]string, enforceLocalServer bool) (*Fa
return nil, err return nil, err
} }
var server GitServer var server gitServer
if !enforceLocalServer { if !enforceLocalServer {
// use fakeStorage server, which might be local or remote (at test daemon) // use fakeStorage server, which might be local or remote (at test daemon)
server, err = fakeStorageWithContext(fakeContextFromDir(root)) server, err = fakeStorageWithContext(fakeContextFromDir(root))
@ -1124,7 +1131,7 @@ func fakeGIT(name string, files map[string]string, enforceLocalServer bool) (*Fa
httpServer := httptest.NewServer(http.FileServer(http.Dir(root))) httpServer := httptest.NewServer(http.FileServer(http.Dir(root)))
server = &localGitServer{httpServer} server = &localGitServer{httpServer}
} }
return &FakeGIT{ return &fakeGit{
root: root, root: root,
server: server, server: server,
RepoURL: fmt.Sprintf("%s/%s.git", server.URL(), name), RepoURL: fmt.Sprintf("%s/%s.git", server.URL(), name),
@ -1162,8 +1169,8 @@ func readFile(src string, c *check.C) (content string) {
return string(data) return string(data)
} }
func containerStorageFile(containerId, basename string) string { func containerStorageFile(containerID, basename string) string {
return filepath.Join("/var/lib/docker/containers", containerId, basename) return filepath.Join("/var/lib/docker/containers", containerID, basename)
} }
// docker commands that use this function must be run with the '-d' switch. // docker commands that use this function must be run with the '-d' switch.
@ -1180,8 +1187,8 @@ func runCommandAndReadContainerFile(filename string, cmd *exec.Cmd) ([]byte, err
return readContainerFile(contID, filename) return readContainerFile(contID, filename)
} }
func readContainerFile(containerId, filename string) ([]byte, error) { func readContainerFile(containerID, filename string) ([]byte, error) {
f, err := os.Open(containerStorageFile(containerId, filename)) f, err := os.Open(containerStorageFile(containerID, filename))
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -1195,8 +1202,8 @@ func readContainerFile(containerId, filename string) ([]byte, error) {
return content, nil return content, nil
} }
func readContainerFileWithExec(containerId, filename string) ([]byte, error) { func readContainerFileWithExec(containerID, filename string) ([]byte, error) {
out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "exec", containerId, "cat", filename)) out, _, err := runCommandWithOutput(exec.Command(dockerBinary, "exec", containerID, "cat", filename))
return []byte(out), err return []byte(out), err
} }

6
integration-cli/registry.go
View File

@ -66,7 +66,7 @@ func (t *testRegistryV2) Ping() error {
return nil return nil
} }
func (r *testRegistryV2) Close() { func (t *testRegistryV2) Close() {
r.cmd.Process.Kill() t.cmd.Process.Kill()
os.RemoveAll(r.dir) os.RemoveAll(t.dir)
} }

26
integration-cli/requirements.go
View File

@ -13,10 +13,10 @@ import (
"github.com/go-check/check" "github.com/go-check/check"
) )
type TestCondition func() bool type testCondition func() bool
type TestRequirement struct { type testRequirement struct {
Condition TestCondition Condition testCondition
SkipMessage string SkipMessage string
} }
@ -24,19 +24,19 @@ type TestRequirement struct {
var ( var (
daemonExecDriver string daemonExecDriver string
SameHostDaemon = TestRequirement{ SameHostDaemon = testRequirement{
func() bool { return isLocalDaemon }, func() bool { return isLocalDaemon },
"Test requires docker daemon to runs on the same machine as CLI", "Test requires docker daemon to runs on the same machine as CLI",
} }
UnixCli = TestRequirement{ UnixCli = testRequirement{
func() bool { return isUnixCli }, func() bool { return isUnixCli },
"Test requires posix utilities or functionality to run.", "Test requires posix utilities or functionality to run.",
} }
ExecSupport = TestRequirement{ ExecSupport = testRequirement{
func() bool { return supportsExec }, func() bool { return supportsExec },
"Test requires 'docker exec' capabilities on the tested daemon.", "Test requires 'docker exec' capabilities on the tested daemon.",
} }
Network = TestRequirement{ Network = testRequirement{
func() bool { func() bool {
// Set a timeout on the GET at 15s // Set a timeout on the GET at 15s
var timeout = time.Duration(15 * time.Second) var timeout = time.Duration(15 * time.Second)
@ -57,14 +57,14 @@ var (
}, },
"Test requires network availability, environment variable set to none to run in a non-network enabled mode.", "Test requires network availability, environment variable set to none to run in a non-network enabled mode.",
} }
Apparmor = TestRequirement{ Apparmor = testRequirement{
func() bool { func() bool {
buf, err := ioutil.ReadFile("/sys/module/apparmor/parameters/enabled") buf, err := ioutil.ReadFile("/sys/module/apparmor/parameters/enabled")
return err == nil && len(buf) > 1 && buf[0] == 'Y' return err == nil && len(buf) > 1 && buf[0] == 'Y'
}, },
"Test requires apparmor is enabled.", "Test requires apparmor is enabled.",
} }
RegistryHosting = TestRequirement{ RegistryHosting = testRequirement{
func() bool { func() bool {
// for now registry binary is built only if we're running inside // for now registry binary is built only if we're running inside
// container through `make test`. Figure that out by testing if // container through `make test`. Figure that out by testing if
@ -74,7 +74,7 @@ var (
}, },
fmt.Sprintf("Test requires an environment that can host %s in the same host", v2binary), fmt.Sprintf("Test requires an environment that can host %s in the same host", v2binary),
} }
NativeExecDriver = TestRequirement{ NativeExecDriver = testRequirement{
func() bool { func() bool {
if daemonExecDriver == "" { if daemonExecDriver == "" {
// get daemon info // get daemon info
@ -98,7 +98,7 @@ var (
}, },
"Test requires the native (libcontainer) exec driver.", "Test requires the native (libcontainer) exec driver.",
} }
NotOverlay = TestRequirement{ NotOverlay = testRequirement{
func() bool { func() bool {
cmd := exec.Command("grep", "^overlay / overlay", "/proc/mounts") cmd := exec.Command("grep", "^overlay / overlay", "/proc/mounts")
if err := cmd.Run(); err != nil { if err := cmd.Run(); err != nil {
@ -108,7 +108,7 @@ var (
}, },
"Test requires underlying root filesystem not be backed by overlay.", "Test requires underlying root filesystem not be backed by overlay.",
} }
IPv6 = TestRequirement{ IPv6 = testRequirement{
func() bool { func() bool {
cmd := exec.Command("test", "-f", "/proc/net/if_inet6") cmd := exec.Command("test", "-f", "/proc/net/if_inet6")
@ -123,7 +123,7 @@ var (
// testRequires checks if the environment satisfies the requirements // testRequires checks if the environment satisfies the requirements
// for the test to run or skips the tests. // for the test to run or skips the tests.
func testRequires(c *check.C, requirements ...TestRequirement) { func testRequires(c *check.C, requirements ...testRequirement) {
for _, r := range requirements { for _, r := range requirements {
if !r.Condition() { if !r.Condition() {
c.Skip(r.SkipMessage) c.Skip(r.SkipMessage)

14
integration-cli/requirements_unix.go
View File

@ -10,33 +10,33 @@ import (
) )
var ( var (
CpuCfsPeriod = TestRequirement{ cpuCfsPeriod = testRequirement{
func() bool { func() bool {
cgroupCpuMountpoint, err := cgroups.FindCgroupMountpoint("cpu") cgroupCPUMountpoint, err := cgroups.FindCgroupMountpoint("cpu")
if err != nil { if err != nil {
return false return false
} }
if _, err := ioutil.ReadFile(path.Join(cgroupCpuMountpoint, "cpu.cfs_period_us")); err != nil { if _, err := ioutil.ReadFile(path.Join(cgroupCPUMountpoint, "cpu.cfs_period_us")); err != nil {
return false return false
} }
return true return true
}, },
"Test requires an environment that supports cgroup cfs period.", "Test requires an environment that supports cgroup cfs period.",
} }
CpuCfsQuota = TestRequirement{ cpuCfsQuota = testRequirement{
func() bool { func() bool {
cgroupCpuMountpoint, err := cgroups.FindCgroupMountpoint("cpu") cgroupCPUMountpoint, err := cgroups.FindCgroupMountpoint("cpu")
if err != nil { if err != nil {
return false return false
} }
if _, err := ioutil.ReadFile(path.Join(cgroupCpuMountpoint, "cpu.cfs_quota_us")); err != nil { if _, err := ioutil.ReadFile(path.Join(cgroupCPUMountpoint, "cpu.cfs_quota_us")); err != nil {
return false return false
} }
return true return true
}, },
"Test requires an environment that supports cgroup cfs quota.", "Test requires an environment that supports cgroup cfs quota.",
} }
OomControl = TestRequirement{ oomControl = testRequirement{
func() bool { func() bool {
cgroupMemoryMountpoint, err := cgroups.FindCgroupMountpoint("memory") cgroupMemoryMountpoint, err := cgroups.FindCgroupMountpoint("memory")
if err != nil { if err != nil {

13
integration-cli/utils.go
View File

@ -7,7 +7,6 @@ import (
"errors" "errors"
"fmt" "fmt"
"io" "io"
"net/http/httptest"
"os" "os"
"os/exec" "os/exec"
"path" "path"
@ -41,7 +40,7 @@ func processExitCode(err error) (exitCode int) {
return return
} }
func IsKilled(err error) bool { func isKilled(err error) bool {
if exitErr, ok := err.(*exec.ExitError); ok { if exitErr, ok := err.(*exec.ExitError); ok {
status, ok := exitErr.Sys().(syscall.WaitStatus) status, ok := exitErr.Sys().(syscall.WaitStatus)
if !ok { if !ok {
@ -114,13 +113,13 @@ func runCommandWithOutputForDuration(cmd *exec.Cmd, duration time.Duration) (out
return return
} }
var ErrCmdTimeout = fmt.Errorf("command timed out") var errCmdTimeout = fmt.Errorf("command timed out")
func runCommandWithOutputAndTimeout(cmd *exec.Cmd, timeout time.Duration) (output string, exitCode int, err error) { func runCommandWithOutputAndTimeout(cmd *exec.Cmd, timeout time.Duration) (output string, exitCode int, err error) {
var timedOut bool var timedOut bool
output, exitCode, timedOut, err = runCommandWithOutputForDuration(cmd, timeout) output, exitCode, timedOut, err = runCommandWithOutputForDuration(cmd, timeout)
if timedOut { if timedOut {
err = ErrCmdTimeout err = errCmdTimeout
} }
return return
} }
@ -253,7 +252,7 @@ func compareDirectoryEntries(e1 []os.FileInfo, e2 []os.FileInfo) error {
return nil return nil
} }
func ListTar(f io.Reader) ([]string, error) { func listTar(f io.Reader) ([]string, error) {
tr := tar.NewReader(f) tr := tar.NewReader(f)
var entries []string var entries []string
@ -270,10 +269,6 @@ func ListTar(f io.Reader) ([]string, error) {
} }
} }
type FileServer struct {
*httptest.Server
}
// randomUnixTmpDirPath provides a temporary unix path with rand string appended. // randomUnixTmpDirPath provides a temporary unix path with rand string appended.
// does not create or checks if it exists. // does not create or checks if it exists.
func randomUnixTmpDirPath(s string) string { func randomUnixTmpDirPath(s string) string {