Exemplo n.º 1
0
    def initialize(self):
        super(run_memory_base, self).initialize()
        docker_containers = DockerContainers(self.parent_subtest)
        image = DockerImage.full_name_from_defaults(self.config)
        unit_list = ['', 'b', 'B', 'k', 'K', 'm', 'M', 'g', 'G']
        memory_list = []
        self.sub_stuff['name'] = []
        args = []

        if self.config['expect_success'] == "PASS":
            memory_value = str(self.config['memory_value'])
            if memory_value is not '0':
                for unit in unit_list:
                    memory_list.append(memory_value + unit)
            else:
                memory_list.append('0')
        else:
            memory_list.append(self.config['memory_min_invalid'])
            memory_list.append(self.config['memory_max_invalid'])
            memory_list.append(self.config['memory_invalid'])

        for memory in memory_list:
            prefix = self.config['memory_name_prefix']
            name = docker_containers.get_unique_name(prefix, length=4)
            if self.config['expect_success'] == "PASS":
                self.sub_stuff['name'].append(name)
            args.append(self.combine_subargs(name,
                                             memory,
                                             image,
                                             '/bin/bash'))
        self.sub_stuff['subargs'] = args
        self.sub_stuff['container_memory'] = memory_list
        self.sub_stuff['cgroup_memory'] = []
        self.sub_stuff['result'] = []
Exemplo n.º 2
0
 def initialize(self):
     super(stop_base, self).initialize()
     # Prepare a container
     docker_containers = DockerContainers(self.parent_subtest)
     prefix = self.config["stop_name_prefix"]
     name = docker_containers.get_unique_name(prefix, length=4)
     self.sub_stuff['container_name'] = name
     config.none_if_empty(self.config)
     if self.config.get('run_options_csv'):
         subargs = [arg for arg in
                    self.config['run_options_csv'].split(',')]
     subargs.append("--name %s" % name)
     fin = DockerImage.full_name_from_defaults(self.config)
     subargs.append(fin)
     subargs.append("bash")
     subargs.append("-c")
     subargs.append(self.config['exec_cmd'])
     container = AsyncDockerCmd(self, 'run', subargs)
     self.sub_stuff['container_cmd'] = container
     container.execute()
     time.sleep(self.config['wait_start'])
     # Prepare the "stop" command
     if self.config.get('stop_options_csv'):
         subargs = [arg for arg in
                    self.config['stop_options_csv'].split(',')]
     subargs.append(name)
     self.sub_stuff['stop_cmd'] = DockerCmd(self, 'stop', subargs)
Exemplo n.º 3
0
 def cleanup(self):
     super(run_base, self).cleanup()
     if self.config['remove_after_test']:
         dc = DockerContainers(self)
         dc.clean_all(self.sub_stuff.get("containers"))
         di = DockerImages(self)
         di.clean_all(self.sub_stuff.get("images"))
    def postprocess(self):
        self.loginfo("postprocess()")
        # Raise exception if problems found
        OutputGood(self.sub_stuff["cmdresult"])
        self.failif_ne(
            self.sub_stuff["cmdresult"].exit_status, 0, "Non-zero commit exit status: %s" % self.sub_stuff["cmdresult"]
        )

        im = self.check_image_exists(self.sub_stuff["new_image_name"])
        # Needed for cleanup
        self.sub_stuff["image_list"] = im
        self.failif(len(im) < 1, "Failed to look up committed image ")
        self.check_file_in_image()
        # Check if is possible start image with default command.
        dc = DockerCmd(
            self, "run", ["--rm", self.sub_stuff["image_list"][0].long_id], timeout=self.config["docker_timeout"]
        )
        results = dc.execute()

        dct = DockerContainers(self)
        cnts = dct.list_containers()
        for cont in cnts:
            if cont.image_name == self.sub_stuff["image_list"][0].full_name:
                try:
                    dct.kill_container_by_long_id(cont.long_id)
                except ValueError:
                    pass
                dc = DockerCmd(self, "rm", ["-f", cont.long_id])
                rm_results = dc.execute()
                self.failif_ne(rm_results.exit_status, 0, "Non-zero commit exit status: %s" % rm_results)

        self.failif_ne(results.exit_status, 0, "Non-zero commit exit status: %s" % results)

        self.failif(not self.sub_stuff["rand_data"] in results.stdout, "Unexpected command result: %s" % results.stdout)
Exemplo n.º 5
0
 def cleanup(self):
     """
     Cleanup the containers defined in self.sub_stuff['containers']
     """
     if self.config['remove_after_test']:
         dc = DockerContainers(self)
         dc.clean_all(self.sub_stuff.get("containers"))
Exemplo n.º 6
0
 def initialize(self):
     super(simple, self).initialize()
     config.none_if_empty(self.config)
     # Get free name
     docker_containers = DockerContainers(self)
     name = docker_containers.get_unique_name()
     self.sub_stuff['container_name'] = name
Exemplo n.º 7
0
    def _init_container(self):
        """ Create, store in self.stuff and execute container """
        docker_containers = DockerContainers(self)
        prefix = self.config["container_name_prefix"]
        name = docker_containers.get_unique_name(prefix, length=4)
        self.stuff['container_name'] = name
        if self.config.get('run_options_csv'):
            subargs = [arg for arg in
                       self.config['run_options_csv'].split(',')]
        else:
            subargs = []
        subargs.append("--name %s" % name)
        fin = DockerImage.full_name_from_defaults(self.config)
        subargs.append(fin)
        subargs.append("bash")
        container = NoFailDockerCmd(self, 'run', subargs)
        self.stuff['container_cmd'] = container
        container.execute()

        if self.config.get('attach_options_csv'):
            subargs = [arg for arg in
                       self.config['attach_options_csv'].split(',')]
        else:
            subargs = []
        subargs.append(name)
        container = AsyncDockerCmd(self, 'attach', subargs)
        self.stuff['container_cmd'] = container  # overwrites finished cmd
        stdin = os.pipe()
        self.stuff['container_stdin'] = stdin[1]
        container.execute(stdin[0])
Exemplo n.º 8
0
    def _init_container(self):
        """ Create, store in self.stuff and execute container """
        try:
            fin = DockerImage.full_name_from_defaults(self.config)
        except ValueError:
            raise DockerTestNAError("Empty test image name configured,"
                                    "did you set one for this test?")

        docker_containers = DockerContainers(self)
        name = docker_containers.get_unique_name()
        self.stuff['container_name'] = name
        if self.config.get('run_options_csv'):
            subargs = [arg for arg in
                       self.config['run_options_csv'].split(',')]
        else:
            subargs = []
        subargs.append("--name %s" % name)

        subargs.append(fin)
        subargs.append("bash")
        container = NoFailDockerCmd(self, 'run', subargs)
        self.stuff['container_cmd'] = container
        container.execute()

        if self.config.get('attach_options_csv'):
            subargs = [arg for arg in
                       self.config['attach_options_csv'].split(',')]
        else:
            subargs = []
        subargs.append(name)
        container = AsyncDockerCmd(self, 'attach', subargs)
        self.stuff['container_cmd'] = container  # overwrites finished cmd
        stdin = os.pipe()
        self.stuff['container_stdin'] = stdin[1]
        container.execute(stdin[0])
Exemplo n.º 9
0
 def cleanup(self):
     """
     Cleanup the container
     """
     super(run_user, self).cleanup()
     if self.config['remove_after_test']:
         dc = DockerContainers(self)
         dc.clean_all([self.stuff.get("container")])
Exemplo n.º 10
0
 def initialize(self):
     super(diff_base, self).initialize()
     dc = DockerContainers(self)
     name = self.sub_stuff['name'] = dc.get_unique_name()
     fin = DockerImage.full_name_from_defaults(self.config)
     subargs = ['--name=%s' % (name), fin]
     subargs = subargs + self.config['command'].split(',')
     nfdc = DockerCmd(self, 'run', subargs)
     mustpass(nfdc.execute())
Exemplo n.º 11
0
 def initialize(self):
     super(simple, self).initialize()
     self._init_stuff()
     config.none_if_empty(self.config)
     # Get free name
     prefix = self.config["container_name_prefix"]
     docker_containers = DockerContainers(self.parent_subtest)
     name = docker_containers.get_unique_name(prefix, length=4)
     self.sub_stuff['container_name'] = name
Exemplo n.º 12
0
 def cleanup(self):
     super(run_attach_stdout, self).cleanup()
     dc = DockerContainers(self.parent_subtest)
     name = self.sub_stuff["rand_name"]
     try:
         dc.kill_container_by_name(name)
     except ValueError:
         pass  #  death was the goal
     dc.remove_by_name(self.sub_stuff["rand_name"])
Exemplo n.º 13
0
 def initialize(self):
     super(flag, self).initialize()
     self.stuff["containter_name"] = []
     self.stuff["subargs"] = []
     self.stuff["cmdresult"] = []
     docker_containers = DockerContainers(self)
     self.logdebug("Generating ramdom name will take 1 minute")
     cname = docker_containers.get_unique_name("docker", "test", 4)
     self.stuff["containter_name"] = cname
Exemplo n.º 14
0
 def cleanup(self):
     super(commit_base, self).cleanup()
     if self.config["remove_after_test"]:
         dc = DockerContainers(self)
         container = self.sub_stuff.get("container")
         if container:
             dc.clean_all([container])
         di = di = DockerImages(self)
         images = [img.full_name for img in self.sub_stuff.get("image_list", [])]
         di.clean_all(images)
Exemplo n.º 15
0
 def initialize(self):
     super(diff_base, self).initialize()
     dc = DockerContainers(self.parent_subtest)
     scn = self.__class__.__name__
     name = self.sub_stuff['name'] = dc.get_unique_name(prefix=scn)
     fin = DockerImage.full_name_from_defaults(self.config)
     subargs = ['--name=%s' % (name), fin]
     subargs = subargs + self.config['command'].split(',')
     nfdc = NoFailDockerCmd(self, 'run', subargs)
     nfdc.execute()
Exemplo n.º 16
0
 def initialize(self):
     super(run_attach_stdout, self).initialize()
     dc = DockerContainers(self.parent_subtest)
     self.sub_stuff["rand_name"] = rand_name = dc.get_unique_name()
     self.sub_stuff["rand_data"] = utils.generate_random_string(8)
     self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % rand_name)
     attach_options = self.config['attach_options_csv'].split(',')
     attach_options.append(rand_name)
     self.sub_stuff['attach_options'] = attach_options
     self.sub_stuff["rpipe"], self.sub_stuff["wpipe"] = os.pipe()
Exemplo n.º 17
0
 def cleanup(self):
     super(rmi_base, self).cleanup()
     di = DockerImages(self)
     # Auto-converts "yes/no" to a boolean
     if self.config['remove_after_test']:
         dc = DockerContainers(self)
         dc.clean_all(self.sub_stuff.get("containers"))
         di = DockerImages(self)
         imgs = [img.full_name
                 for img in self.sub_stuff.get("image_list", [])]
         di.clean_all(imgs)
Exemplo n.º 18
0
 def cleanup(self):
     super(exec_base, self).cleanup()
     for ifd in self.sub_stuff['fds']:
         try:
             os.close(ifd)
         except OSError:
             pass
     if self.config['remove_after_test']:
         dc = DockerContainers(self)
         dc.clean_all(self.sub_stuff.get("containers"))
         di = DockerImages(self)
         di.clean_all(self.sub_stuff.get("images"))
Exemplo n.º 19
0
 def initialize(self):
     super(syslog, self).initialize()
     dc = DockerContainers(self)
     scn = self.__class__.__name__
     name = self.stuff["container_name"] = dc.get_unique_name(prefix=scn)
     self.stuff['name'] = '--name=%s' % name
     self.stuff['fin'] = DockerImage.full_name_from_defaults(self.config)
     self.stuff['params'] = '-v /dev/log:/dev/log'
     now = datetime.datetime.now()
     time = now.strftime("%Y-%m-%d %H:%M:%S")
     self.stuff["msg"] = "SYSLOGTEST at time: %s" % time
     self.stuff['testcmds'] = 'logger %s' % self.stuff["msg"]
Exemplo n.º 20
0
 def initialize(self):
     """
     Runs one container
     """
     super(kill_bad_base, self).initialize()
     # Prepare a container
     docker_containers = DockerContainers(self.parent_subtest)
     name = docker_containers.get_unique_name()
     self.sub_stuff['container_name'] = name
     config.none_if_empty(self.config)
     self._init_container(name)
     time.sleep(self.config.get('wait_start', 3))
Exemplo n.º 21
0
 def try_rm(subtest, cidfilename, cmdresult):
     docker_containers = DockerContainers(subtest)
     try:
         cidfile = open(cidfilename, 'rb')
         cid = cidfile.read()
         if len(cid) < 12:
             raise ValueError()
         docker_containers.remove_by_id(cid.strip())
         subtest.loginfo("Removed container %s", cid[:12])
     except ValueError:
         subtest.logdebug("Container %s not found to rm", cid[:12])
     except IOError:
         subtest.logdebug("Container never ran for %s", cmdresult)
Exemplo n.º 22
0
 def try_kill(subtest, cidfilename, cmdresult):
     docker_containers = DockerContainers(subtest)
     try:
         cidfile = open(cidfilename, 'rb')
         cid = cidfile.read()
         if len(cid) < 12:
             raise ValueError()
         else:
             docker_containers.kill_container_by_long_id(cid.strip())
     except ValueError:
         subtest.logdebug("Container %s not found to kill", cid[:12])
     except IOError:
         subtest.logdebug("Container never ran for %s", cmdresult)
 def cleanup(self):
     super(selinux_base, self).cleanup()
     for fd in self.sub_stuff.get('fds', []):
         try:
             os.close(fd)
         except OSError:
             pass  # closing was the goal
     if self.config['remove_after_test']:
         dc = DockerContainers(self)
         dc.clean_all(self.sub_stuff.get("containers", []))
     for name in self.sub_stuff['volumes']:
         if os.path.exists(name):
             shutil.rmtree(name)
Exemplo n.º 24
0
 def init_use_names(self, use_names=False):
     if use_names:
         conts = self.sub_stuff['containers']
         containers = DockerContainers(self.parent_subtest)
         containers = containers.list_containers()
         cont_ids = [cont['id'] for cont in conts]
         for cont in containers:
             if cont.long_id in cont_ids:
                 if use_names is not True and random.choice((True, False)):
                     continue    # 50% chance of using id vs. name
                 # replace the id with name
                 cont_idx = cont_ids.index(cont.long_id)
                 conts[cont_idx]['id'] = cont.container_name
Exemplo n.º 25
0
 def cntnr_ip_map(self):
     """
     Return mapping of container names to IP addresses
     """
     # map container eth0 ifindex's to names
     dc = DockerContainers(self)
     names = dc.list_container_names()
     jsons = [dc.json_by_name(name)[0] for name in names]
     njs = dict(zip(names, jsons))
     result = {}
     for name in [_ for _ in njs if njs[_]["NetworkSettings"]["IPAddress"] != ""]:
         result[name] = njs[name]["NetworkSettings"]["IPAddress"]
         self.logdebug("%s -> %s", name, result[name])
     return result
Exemplo n.º 26
0
 def init_subargs(self):
     """
     Initialize basic arguments that will use for start container
     Will return a list 'args'
     """
     docker_containers = DockerContainers(self)
     image = DockerImage.full_name_from_defaults(self.config)
     name = docker_containers.get_unique_name()
     self.sub_stuff['name'] = name
     bash_cmd = self.config['bash_cmd']
     args = ["--name=%s" % name]
     args += get_as_list(self.config['run_args_csv'])
     args += [image, bash_cmd]
     return args
Exemplo n.º 27
0
 def initialize(self):
     super(syslog, self).initialize()
     if not os.path.isfile(self.config['syslogfile']):
         raise DockerTestNAError("Couldn't find system log: %s"
                                 % self.config['syslogfile'])
     dc = DockerContainers(self)
     name = self.stuff["container_name"] = dc.get_unique_name()
     self.stuff['name'] = '--name=%s' % name
     self.stuff['fin'] = DockerImage.full_name_from_defaults(self.config)
     self.stuff['params'] = '-v /dev/log:/dev/log'
     now = datetime.datetime.now()
     time = now.strftime("%Y-%m-%d %H:%M:%S")
     self.stuff["msg"] = "SYSLOGTEST at time: %s" % time
     self.stuff['testcmds'] = 'logger %s' % self.stuff["msg"]
Exemplo n.º 28
0
 def cleanup(self):
     super(run, self).cleanup()
     # Clean up all containers
     dc = DockerContainers(self)
     for cobj in dc.list_containers():
         self.logwarning("Found leftover container: %s", cobj.container_name)
         try:
             dc.kill_container_by_obj(cobj)
         except ValueError:
             pass  # already dead
         else:
             self.logdebug("Killed container %s, waiting up to %d seconds "
                           "for it to exit", cobj.container_name,
                           dc.timeout)
             dc.wait_by_obj(cobj)
         self.logdebug("Removing container %s", cobj.container_name)
         dc.remove_by_obj(cobj)
     # Clean up all non-default images
     fqin = DockerImage.full_name_from_defaults(self.config)
     di = DockerImages(self)
     def_img_obj = di.list_imgs_with_full_name(fqin)[0]
     for img_obj in di.list_imgs():
         if img_obj.full_name != def_img_obj.full_name:
             self.logwarning("Found leftover image: %s", img_obj)
             di.remove_image_by_image_obj(img_obj)
         else:
             self.logdebug("Not removing default image: %s", def_img_obj)
Exemplo n.º 29
0
 def initialize(self):
     super(simple, self).initialize()
     # Test container setup
     dc = DockerContainers(self)
     c_name = dc.get_unique_name()
     self.sub_stuff["containers"].append(c_name)
     self.init_test_container(c_name)
     # export/import command setup
     di = DockerImages(self)
     i_name = di.get_unique_name(c_name)  # easier debugging
     self.sub_stuff["images"].append(i_name)
     subdct = {"container": c_name, "image": i_name}
     export_cmd_args = self.config['export_cmd_args'].strip() % subdct
     import_cmd_args = self.config['import_cmd_args'].strip() % subdct
     self.init_ei_dockercmd(export_cmd_args, import_cmd_args)
Exemplo n.º 30
0
 def cleanup(self):
     super(build, self).cleanup()
     # Auto-converts "yes/no" to a boolean
     if self.config['try_remove_after_test']:
         dc = DockerContainers(self)
         for cid in dc.list_container_ids():
             dcmd = DockerCmd(self, 'rm', ['--force', '--volumes', cid])
             dcmd.execute()
         di = DockerImages(self)
         if self.stuff.get('image_id') is not None:
             di.remove_image_by_id(self.stuff['image_id'])
         di.remove_image_by_full_name("empty_base_image")
         self.loginfo("Successfully removed test images")
     else:
         self.loginfo("NOT removing image")
Exemplo n.º 31
0
 def clean_up(self):
     super(images_prune, self).clean_up()
     ctns = DockerContainers(self)
     ctns.clean_all(['rsyslog'])
Exemplo n.º 32
0
 def cleanup(self):
     DockerContainers(self).clean_all(self.sub_stuff['my_containers'])
     DockerImages(self).clean_all(self.sub_stuff['my_images'])
     self._restore_docker_auth_file()