run_exec: Rewrite test to be more reliable

Test was over-engineered, internally inconsistent, and not working.
Easier to re-write in boring standard way that works than fix.

Signed-off-by: Chris Evich <[email protected]>

Author: cevich

config_defaults/subtests/docker_cli/run_exec.ini

@@ -7,24 +7,13 @@ run_options_csv = --interactive
 bash_cmd = /bin/sh
 #: modifies the execning command in started container)
 exec_options_csv = --interactive
-#: csv command prefix (docker exec ... $exec_bash_cmd $cmd)
-exec_bash_cmd = /bin/sh,-c
-#: Specifies the executed command inside the running container
-cmd =
 #: expected exit status
-exit_status =
-subsubtests = exec_true, exec_false, exec_pid_count
-
-[docker_cli/run_exec/exec_true]
-cmd = /bin/true
 exit_status = 0
+subsubtests = exec_true, exec_false, exec_pid_count
 
 [docker_cli/run_exec/exec_false]
-cmd = /bin/false
 exit_status = 1
 
 [docker_cli/run_exec/exec_pid_count]
-exec_bash_cmd = /bin/sh
 #: Expected count of pid in container when command using exec is started.
-pid_count = 3
-exit_status = 0
+pid_count = 2

subtests/docker_cli/run_exec/run_exec.py

@@ -8,212 +8,172 @@
 Operational Summary
 ----------------------
 
-#.  Test execute ``/bin/true`` in running container returning zero
-#.  Test execute ``/bin/false`` in running container returning non zero
-#.  Test execute ``/bin/sh`` in running container and check count of pids
-#.  Test detached execute ``/bin/sh`` in running container and check count
-    of pids
-#.  Smoke test try to start count of containers as fast as possible in running
-    container.
+#.  Execute a shell in a container and leave it idling
+#.  In parallel, run a command in container with ``docker exec``
+#.  Verify expected result from above step
+#.  Cleanup shell container
+
+Prerequisites
+---------------
+
+*  Test container contains ``/bin/true`` and ``/bin/false``
+*  Test container contains ``find`` command
+*  Test container's ``/proc`` filesystem is accessable by ``docker exec``
 """
 
+
 import os
-import re
 import time
-from autotest.client.shared import error
-from autotest.client.shared import utils
 from dockertest.subtest import SubSubtest, SubSubtestCaller
 from dockertest.dockercmd import AsyncDockerCmd
 from dockertest.dockercmd import DockerCmd
 from dockertest.containers import DockerContainers
 from dockertest.images import DockerImage
 from dockertest.images import DockerImages
-from dockertest.xceptions import DockerTestNAError
+from dockertest.xceptions import DockerTestFail
+from dockertest.output import mustpass
+from dockertest.output import mustfail
 from dockertest.output import OutputGood
+from dockertest.output import OutputNotBad
+from dockertest.output import wait_for_output
 from dockertest.config import get_as_list
 
 
-class AsyncDockerCmdStdIn(AsyncDockerCmd):
-
-    r"""
-    Setup a call docker subcommand as if by CLI w/ subtest config integration
-    Execute docker subcommand with arguments and a timeout.
-
-    :param subtest: A subtest.Subtest (**NOT** a SubSubtest) subclass instance
-    :param subcomd: A Subcommand or fully-formed option/argument string
-    :param subargs: (optional) A list of strings containing additional
-                    args to subcommand
-    :param timeout: Seconds to wait before terminating docker command
-                    None to use 'docker_timeout' config. option.
-    :param stdin_r: File descriptor for reading input data for stdin.
-    :param stdin: Write part of file descriptor for reading.
-    :raises DockerTestError: on incorrect usage
-    """
-
-    verbose = True
-
-    stdin_r = None
-    stdin = None
-
-    PIPE = -1  # file descriptor should never be negative value.
-
-    def __init__(self, subtest, subcmd, subargs=None, timeout=None,
-                 verbose=True, stdin_r=None, stdin=None):
-        super(AsyncDockerCmdStdIn, self).__init__(subtest, subcmd, subargs,
-                                                  timeout, verbose)
-
-        self.stdin = stdin
-        if stdin_r == self.PIPE:
-            self.stdin_r, self.stdin = os.pipe()
-
-        super(AsyncDockerCmdStdIn, self).execute(self.stdin_r)
-
-    def execute(self, stdin=None):
-        """
-        Unimplemented method.
-        """
-        raise RuntimeError('Method is not implemented')
-
-    def close(self):
-        if self.stdin_r is not None:
-            os.close(self.stdin_r)
-        if self.stdin is not None:
-            os.close(self.stdin)
-
-
 class run_exec(SubSubtestCaller):
-    config_section = 'docker_cli/run_exec'
+    pass
 
 
 class exec_base(SubSubtest):
 
-    fqin = None
-    containers = None
-    images = None
-    cont = None
-    img = None
-
     def init_subargs(self):
-        self.fqin = DockerImage.full_name_from_defaults(self.config)
-
-        run_opts = get_as_list(self.config.get("run_options_csv"))
-        self.sub_stuff['run_args'] = run_opts
-        name = "--name=%s" % self.sub_stuff["container_name"]
-        self.sub_stuff['run_args'].append(name)
-        self.sub_stuff['run_args'].append(self.fqin)
-        self.sub_stuff['run_args'] += self.config['bash_cmd'].split(',')
-
-        exec_opts = get_as_list(self.config.get("exec_options_csv"))
-        self.sub_stuff['exec_args'] = exec_opts
-        self.sub_stuff['exec_args'].append(self.sub_stuff["container_name"])
-        self.sub_stuff['exec_args'] += self.config['exec_bash_cmd'].split(',')
-        self.sub_stuff['exec_args'].append(self.config['cmd'])
-
-    def run_cmd(self, bash_stdin, cmd):
-        self.logdebug("send command to container:\n%s" % (cmd))
-        os.write(bash_stdin, cmd)
-
-    @staticmethod
-    def wait_for_output(dkrcmd, pattern, timeout=120):
-        got_pattern = lambda: pattern in dkrcmd.stdout
-        return utils.wait_for(got_pattern,
-                              timeout,
-                              text='Waiting on container %s commend' % dkrcmd)
+        run_args = self.sub_stuff['run_args']
+        run_options_csv = self.config["run_options_csv"]
+        if run_options_csv:
+            run_args += get_as_list(run_options_csv)
+
+        run_args.append('--name')
+        name = self.sub_stuff['cont'].get_unique_name()
+        self.sub_stuff['run_name'] = name
+        run_args.append(name)
+        fqin = DockerImage.full_name_from_defaults(self.config)
+        run_args.append(fqin)
+        bash_cmd = self.config['bash_cmd']
+        if bash_cmd:
+            run_args += get_as_list(bash_cmd)
+
+        exec_args = self.sub_stuff['exec_args']
+        exec_options_csv = self.config["exec_options_csv"]
+        if exec_options_csv:
+            exec_args += get_as_list(exec_options_csv)
+        exec_args.append(name)
 
     def start_base_container(self):
-        dkrcmd = AsyncDockerCmdStdIn(self, 'run', self.sub_stuff['run_args'],
-                                     stdin_r=AsyncDockerCmdStdIn.PIPE)
+        reader, writer = os.pipe()
+        # Exception could occur before os.close(reader) below
+        self.sub_stuff['fds'].append(reader)
+        self.sub_stuff['fds'].append(writer)
+        self.sub_stuff['dkrcmd_stdin'] = writer
+        dkrcmd = AsyncDockerCmd(self, 'run', self.sub_stuff['run_args'])
+        dkrcmd.execute(reader)
+        self.sub_stuff['containers'].append(self.sub_stuff['run_name'])
+        os.close(reader)  # not needed anymore
         self.sub_stuff['dkrcmd'] = dkrcmd
-        self.run_cmd(dkrcmd.stdin, "echo \"Started\"\n")
-        if self.wait_for_output(dkrcmd, "Started", 10) is None:
-            raise DockerTestNAError("Unable to start base container:\n %s" %
-                                    (dkrcmd))
-        self.containers.append(self.sub_stuff["container_name"])
+        os.write(writer, 'echo "Started"\n')
+        if not wait_for_output(lambda: dkrcmd.stdout, "Started"):
+            raise DockerTestFail("Unable to start base container:\n %s" %
+                                 (dkrcmd))
 
     def initialize(self):
         super(exec_base, self).initialize()
-        self.containers = []
-        self.images = []
-        self.cont = DockerContainers(self)
-        self.img = DockerImages(self)
-        self.sub_stuff["container_name"] = self.cont.get_unique_name()
+        self.sub_stuff['containers'] = []
+        self.sub_stuff['images'] = []
+        self.sub_stuff['cont'] = DockerContainers(self)
+        self.sub_stuff['img'] = DockerImages(self)
+        self.sub_stuff['fds'] = []  # every fd in here guarantee closed
+        self.sub_stuff['dkrcmd_stdin'] = None  # stdin fd for vvvvvvv
+        self.sub_stuff['run_name'] = None  # container name for vvvvvvv
+        self.sub_stuff['run_args'] = []  # parameters for vvvvvv
+        self.sub_stuff['dkrcmd'] = None  # docker run ... container
+        self.sub_stuff['exec_args'] = []  # parameters for vvvvvv
+        self.sub_stuff['dkrcmd_exec'] = None  # docker exec ... container
         self.init_subargs()
         self.start_base_container()
 
     def postprocess(self):
         super(exec_base, self).postprocess()  # Prints out basic info
-        if 'dkrcmd_exec' in self.sub_stuff:
-            # Fail test if bad command or other stdout/stderr problems detected
-            dkrcmd = self.sub_stuff['dkrcmd_exec']
-            OutputGood(dkrcmd.cmdresult)
-            expected = self.config['exit_status']
-            self.failif(dkrcmd.exit_status != expected,
-                        "Expected exit status: %s does not match command"
-                        "exit status: %s. Details: %s" %
-                        (expected, dkrcmd.exit_status, dkrcmd.cmdresult))
-
-            self.logdebug(dkrcmd.cmdresult)
+        os.write(self.sub_stuff['dkrcmd_stdin'], 'exit\t')
+        time.sleep(1)
+        mustpass(DockerCmd(self, 'kill',
+                           [self.sub_stuff['run_name']]).execute())
+        # It may have been killed, but exec is what we care about
+        OutputNotBad(self.sub_stuff['dkrcmd'].cmdresult)
 
     def cleanup(self):
         super(exec_base, self).cleanup()
-        # Auto-converts "yes/no" to a boolean
+        for ifd in self.sub_stuff['fds']:
+            try:
+                os.close(ifd)
+            except OSError:
+                pass
         if self.config['remove_after_test']:
-            if "dkrcmd" in self.sub_stuff:
-                self.sub_stuff['dkrcmd'].close()
-
-            for cont in self.containers:
-                dkrcmd = DockerCmd(self, "rm", ['--volumes', '--force', cont])
-                cmdresult = dkrcmd.execute()
-                msg = (" removed test container: %s" % cont)
-                if cmdresult.exit_status == 0:
-                    self.logdebug("Successfully" + msg)
-                else:
-                    self.logwarning("Failed" + msg)
-            for image in self.images:
-                try:
-                    di = DockerImages(self.parent_subtest)
-                    self.logdebug("Removing image %s", image)
-                    di.remove_image_by_full_name(image)
-                    self.logdebug("Successfully removed test image: %s",
-                                  image)
-                except error.CmdError, e:
-                    error_text = "tagged in multiple repositories"
-                    if error_text not in e.result_obj.stderr:
-                        raise
+            for cntnr in self.sub_stuff['containers']:
+                DockerCmd(self, 'kill', [cntnr]).execute()
+                DockerCmd(self, 'rm', [cntnr]).execute()
+            for image in self.sub_stuff['images']:
+                DockerCmd(self, 'rmi', [image])
 
 
 class exec_true(exec_base):
 
     def run_once(self):
         super(exec_true, self).run_once()
-        dkrcmd = AsyncDockerCmdStdIn(self, 'exec', self.sub_stuff['exec_args'])
-        self.sub_stuff['dkrcmd_exec'] = dkrcmd
-        dkrcmd.wait(120)
+        subargs = self.sub_stuff['exec_args'] + ['/bin/true']
+        dkrcmd_exec = DockerCmd(self, 'exec', subargs, timeout=60)
+        self.sub_stuff['dkrcmd_exec'] = dkrcmd_exec
+        dkrcmd_exec.execute()
 
+    def postprocess(self):
+        dkrcmd_exec = self.sub_stuff['dkrcmd_exec']
+        mustpass(dkrcmd_exec.cmdresult)
+        OutputGood(dkrcmd_exec.cmdresult)
+        super(exec_true, self).postprocess()
 
-class exec_false(exec_true):
-    pass  # Only change is in configuration
+
+class exec_false(exec_base):
+
+    def run_once(self):
+        super(exec_false, self).run_once()
+        subargs = self.sub_stuff['exec_args'] + ['/bin/false']
+        dkrcmd_exec = DockerCmd(self, 'exec', subargs, timeout=60)
+        self.sub_stuff['dkrcmd_exec'] = dkrcmd_exec
+        dkrcmd_exec.execute()
+
+    def postprocess(self):
+        dkrcmd_exec = self.sub_stuff['dkrcmd_exec']
+        mustfail(dkrcmd_exec.cmdresult)
+        OutputNotBad(dkrcmd_exec.cmdresult)
+        super(exec_false, self).postprocess()
 
 
 class exec_pid_count(exec_base):
 
     def run_once(self):
-        super(exec_pid_count, self).run_once()    # Prints out basic info
-        dkrcmd = AsyncDockerCmdStdIn(self, 'exec', self.sub_stuff['exec_args'],
-                                     stdin_r=AsyncDockerCmdStdIn.PIPE)
-        self.sub_stuff['dkrcmd_exec'] = dkrcmd
-        self.run_cmd(dkrcmd.stdin, "ls -l /proc\n")
-        self.wait_for_output(dkrcmd, "cmdline", 10)
-        self.run_cmd(dkrcmd.stdin, "exit\n")
-        dkrcmd.close()
-        dkrcmd.wait(120)
+        super(exec_pid_count, self).run_once()
+        subargs = self.sub_stuff['exec_args']
+        subargs.append("find /proc -maxdepth 1 -a -type d -a "
+                       "-regextype posix-extended -a "
+                       r"-regex '/proc/[0-9]+'")
+        dkrcmd_exec = DockerCmd(self, 'exec', subargs)
+        self.sub_stuff['dkrcmd_exec'] = dkrcmd_exec
+        dkrcmd_exec.execute()
 
     def postprocess(self):
-        super(exec_pid_count, self).postprocess()  # Prints out basic info
-        if 'dkrcmd_exec' in self.sub_stuff:
-            # Check count of pids
-            dkrcmd = self.sub_stuff['dkrcmd_exec']
-            pids = re.findall("^dr.+ ([0-9]+).?$", dkrcmd.stdout, re.MULTILINE)
-            self.failif(len(pids) != self.config.get("pid_count", 3),
-                        "There should be exactly 3 pids in"
-                        " container. Count of pid: %s" % len(pids))
+        dkrcmd_exec = self.sub_stuff['dkrcmd_exec']
+        mustpass(dkrcmd_exec.cmdresult)
+        OutputGood(dkrcmd_exec.cmdresult)
+        pids = dkrcmd_exec.stdout.strip().splitlines()
+        expected = self.config["pid_count"]
+        self.failif(len(pids) != expected,
+                    "Expecting %d pids: %s"
+                    % (expected, pids))
+        super(exec_pid_count, self).postprocess()