toolshed/docker-cli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

migrated ipc integration tests to integration/container

Browse Source 
Signed-off-by: Arash Deshmeh <adeshmeh@ca.ibm.com>
(cherry picked from commit febefb850d12e0ed1c2ab2a25336ece43204ba03)
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
Upstream-commit: 6a1983ea7564697f18ce2aa1147646906abb97c4
Component: engine
This commit is contained in:
Arash Deshmeh
2019-04-17 21:32:18 +02:00
committed by Sebastiaan van Stijn
parent 2ee77da805
commit 04efd9ec4a
4 changed files with 120 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/engine/integration-cli/docker_api_ipcmode_test.go
-81
View File
@@ -1,81 +0,0 @@
// build +linux
package main
import (
"bufio"
"context"
"io/ioutil"
"os"
"strings"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/integration-cli/checker"
"github.com/docker/docker/integration-cli/cli"
"github.com/go-check/check"
)
/* testIpcCheckDevExists checks whether a given mount (identified by its
* major:minor pair from /proc/self/mountinfo) exists on the host system.
*
* The format of /proc/self/mountinfo is like:
*
* 29 23 0:24 / /dev/shm rw,nosuid,nodev shared:4 - tmpfs tmpfs rw
* ^^^^\
* - this is the minor:major we look for
*/
func testIpcCheckDevExists(mm string) (bool, error) {
f, err := os.Open("/proc/self/mountinfo")
if err != nil {
return false, err
}
defer f.Close()
s := bufio.NewScanner(f)
for s.Scan() {
fields := strings.Fields(s.Text())
if len(fields) < 7 {
continue
}
if fields[2] == mm {
return true, nil
}
}
return false, s.Err()
}
/* TestAPIIpcModeHost checks that a container created with --ipc host
* can use IPC of the host system.
*/
func (s *DockerSuite) TestAPIIpcModeHost(c *check.C) {
testRequires(c, DaemonIsLinux, SameHostDaemon, NotUserNamespace)
cfg := container.Config{
Image: "busybox",
Cmd: []string{"top"},
}
hostCfg := container.HostConfig{
IpcMode: container.IpcMode("host"),
}
ctx := context.Background()
client := testEnv.APIClient()
resp, err := client.ContainerCreate(ctx, &cfg, &hostCfg, nil, "")
c.Assert(err, checker.IsNil)
c.Assert(len(resp.Warnings), checker.Equals, 0)
name := resp.ID
err = client.ContainerStart(ctx, name, types.ContainerStartOptions{})
c.Assert(err, checker.IsNil)
// check that IPC is shared
// 1. create a file inside container
cli.DockerCmd(c, "exec", name, "sh", "-c", "printf covfefe > /dev/shm/."+name)
// 2. check it's the same on the host
bytes, err := ioutil.ReadFile("/dev/shm/." + name)
c.Assert(err, checker.IsNil)
c.Assert(string(bytes), checker.Matches, "^covfefe$")
// 3. clean up
cli.DockerCmd(c, "exec", name, "rm", "-f", "/dev/shm/."+name)
}
components/engine/integration-cli/docker_cli_daemon_test.go
-61
View File
@@ -2903,67 +2903,6 @@ func (s *DockerDaemonSuite) TestShmSizeReload(c *check.C) {
c.Assert(strings.TrimSpace(out), check.Equals, fmt.Sprintf("%v", size))
}
// this is used to test both "private" and "shareable" daemon default ipc modes
func testDaemonIpcPrivateShareable(d *daemon.Daemon, c *check.C, mustExist bool) {
name := "test-ipcmode"
_, err := d.Cmd("run", "-d", "--name", name, "busybox", "top")
c.Assert(err, checker.IsNil)
// get major:minor pair for /dev/shm from container's /proc/self/mountinfo
cmd := "awk '($5 == \"/dev/shm\") {printf $3}' /proc/self/mountinfo"
mm, err := d.Cmd("exec", "-i", name, "sh", "-c", cmd)
c.Assert(err, checker.IsNil)
c.Assert(mm, checker.Matches, "^[0-9]+:[0-9]+$")
exists, err := testIpcCheckDevExists(mm)
c.Assert(err, checker.IsNil)
c.Logf("[testDaemonIpcPrivateShareable] ipcdev: %v, exists: %v, mustExist: %v\n", mm, exists, mustExist)
c.Assert(exists, checker.Equals, mustExist)
}
// TestDaemonIpcModeShareable checks that --default-ipc-mode shareable works as intended.
func (s *DockerDaemonSuite) TestDaemonIpcModeShareable(c *check.C) {
testRequires(c, DaemonIsLinux, SameHostDaemon)
s.d.StartWithBusybox(c, "--default-ipc-mode", "shareable")
testDaemonIpcPrivateShareable(s.d, c, true)
}
// TestDaemonIpcModePrivate checks that --default-ipc-mode private works as intended.
func (s *DockerDaemonSuite) TestDaemonIpcModePrivate(c *check.C) {
testRequires(c, DaemonIsLinux, SameHostDaemon)
s.d.StartWithBusybox(c, "--default-ipc-mode", "private")
testDaemonIpcPrivateShareable(s.d, c, false)
}
// used to check if an IpcMode given in config works as intended
func testDaemonIpcFromConfig(s *DockerDaemonSuite, c *check.C, mode string, mustExist bool) {
f, err := ioutil.TempFile("", "test-daemon-ipc-config")
c.Assert(err, checker.IsNil)
defer os.Remove(f.Name())
config := `{"default-ipc-mode": "` + mode + `"}`
_, err = f.WriteString(config)
c.Assert(f.Close(), checker.IsNil)
c.Assert(err, checker.IsNil)
s.d.StartWithBusybox(c, "--config-file", f.Name())
testDaemonIpcPrivateShareable(s.d, c, mustExist)
}
// TestDaemonIpcModePrivateFromConfig checks that "default-ipc-mode: private" config works as intended.
func (s *DockerDaemonSuite) TestDaemonIpcModePrivateFromConfig(c *check.C) {
testRequires(c, DaemonIsLinux, SameHostDaemon)
testDaemonIpcFromConfig(s, c, "private", false)
}
// TestDaemonIpcModeShareableFromConfig checks that "default-ipc-mode: shareable" config works as intended.
func (s *DockerDaemonSuite) TestDaemonIpcModeShareableFromConfig(c *check.C) {
testRequires(c, DaemonIsLinux, SameHostDaemon)
testDaemonIpcFromConfig(s, c, "shareable", true)
}
func testDaemonStartIpcMode(c *check.C, from, mode string, valid bool) {
d := daemon.New(c, dockerBinary, dockerdBinary, testdaemon.WithEnvironment(testEnv.Execution))
c.Logf("Checking IpcMode %s set from %s\n", mode, from)