Пример #1
0
    def run_once(self):
        super(simple, self).run_once()  # Prints out basic info
        self.loginfo("Starting docker command, timeout %s seconds",
                     self.config['docker_timeout'])

        # Save image
        save_cmd = self.config['save_cmd']
        self.sub_stuff['save_ar'] = (save_cmd % {
            "image": self.sub_stuff["rand_name"],
            "tmpdir": self.tmpdir
        })

        dkrcmd = DockerCmd(self,
                           'save', [self.sub_stuff['save_ar']],
                           verbose=True)
        self.sub_stuff['cmdresult_save'] = dkrcmd.execute()

        # Delete image
        dkrcmd = DockerCmd(self,
                           'rmi', [self.sub_stuff["rand_name"]],
                           verbose=True)
        self.sub_stuff['cmdresult_del'] = dkrcmd.execute()

        # Load image
        load_cmd = self.config['load_cmd']
        self.sub_stuff['load_ar'] = (load_cmd % {
            "image": self.sub_stuff["rand_name"],
            "tmpdir": self.tmpdir
        })

        dkrcmd = DockerCmd(self,
                           'load', [self.sub_stuff['load_ar']],
                           verbose=True)
        dkrcmd.verbose = True
        self.sub_stuff['cmdresult_load'] = dkrcmd.execute()
Пример #2
0
    def run_once(self):
        super(simple, self).run_once()  # Prints out basic info
        self.loginfo("Starting docker command, timeout %s seconds",
                     self.config['docker_timeout'])

        # Save image
        save_cmd = self.config['save_cmd']
        self.sub_stuff['save_ar'] = (save_cmd %
                                     {"image": self.sub_stuff["rand_name"],
                                      "tmpdir": self.tmpdir})

        dkrcmd = DockerCmd(self, 'save',
                           [self.sub_stuff['save_ar']],
                           verbose=True)
        self.sub_stuff['cmdresult_save'] = dkrcmd.execute()

        # Delete image
        dkrcmd = DockerCmd(self, 'rmi',
                           [self.sub_stuff["rand_name"]],
                           verbose=True)
        self.sub_stuff['cmdresult_del'] = dkrcmd.execute()

        # Load image
        load_cmd = self.config['load_cmd']
        self.sub_stuff['load_ar'] = (load_cmd %
                                     {"image": self.sub_stuff["rand_name"],
                                      "tmpdir": self.tmpdir})

        dkrcmd = DockerCmd(self, 'load',
                           [self.sub_stuff['load_ar']],
                           verbose=True)
        dkrcmd.verbose = True
        self.sub_stuff['cmdresult_load'] = dkrcmd.execute()
Пример #3
0
 def init_ei_dockercmd(self, export_arg_csv, import_arg_csv):
     # Never execute()'d, just used for command property
     import_dkrcmd = DockerCmd(self, "import", import_arg_csv.split(','))
     # Actually executed command
     export_args = export_arg_csv.split(',')
     export_args.append(import_dkrcmd.command)
     export_import_dkrcmd = DockerCmd(self, "export", export_args)
     export_import_dkrcmd.verbose = True
     self.sub_stuff['export_import_dkrcmd'] = export_import_dkrcmd
Пример #4
0
 def init_ei_dockercmd(self, export_arg_csv, import_arg_csv):
     # Never execute()'d, just used for command property
     import_dkrcmd = DockerCmd(self, "import", import_arg_csv.split(','))
     # Actually executed command
     export_args = export_arg_csv.split(',')
     export_args.append(import_dkrcmd.command)
     export_import_dkrcmd = DockerCmd(self, "export", export_args)
     export_import_dkrcmd.verbose = True
     self.sub_stuff['export_import_dkrcmd'] = export_import_dkrcmd
    def run_once(self):
        self.loginfo("Starting background docker command, timeout %s seconds",
                     self.config['docker_timeout'])

        in_pipe_r, in_pipe_w = os.pipe()
        dkrcmd = DockerCmd(self, 'run', self.sub_stuff['subargs'],
                           timeout=self.config['docker_timeout'])
        dkrcmd.verbose = True
        # Runs in background
        self.sub_stuff['dkrcmd'] = dkrcmd
        dkrcmd.execute()
        # Allow noticable time difference for date command,
        # and eat into dkrcmd timeout after receiving signal.
        # Throw exception if takes > docker_timeout to exit
        if dkrcmd.exit_status != self.config['exit_status']:
            return

        attach_options = self.config['attach_options_csv'].split(',')
        self.sub_stuff['subargs_a'] = attach_options

        c_name = self.sub_stuff["rand_name"]
        cid = self.sub_stuff["cont"].list_containers_with_name(c_name)
        self.sub_stuff["containers"].append(c_name)

        self.failif(cid == [],
                    "Unable to search container with name %s" % (c_name))

        self.sub_stuff['subargs_a'].append(c_name)

        dkrcmd = AsyncDockerCmd(self, 'attach', self.sub_stuff['subargs_a'],
                                timeout=self.config['docker_timeout'])
        dkrcmd.verbose = True
        # Runs in background
        self.sub_stuff['dkrcmd_attach'] = dkrcmd
        dkrcmd.execute(in_pipe_r)
        os.write(in_pipe_w, self.config['interactive_cmd'] + "\n")
        pid = dkrcmd.process_id
        time.sleep(self.config['wait_interactive_cmd'])
        os.kill(pid, 9)
        try:
            dkrcmd.wait()
        except AssertionError:
            pass
Пример #6
0
    def run_once(self):
        super(simple, self).run_once()  # Prints out basic info
        self.loginfo("Starting docker command, timeout %s seconds",
                     self.config['docker_timeout'])

        # Save image
        save_cmd = self.config['save_cmd']
        self.sub_stuff['save_ar'] = (save_cmd %
                                     {"image": self.sub_stuff["rand_name"]})

        dkrcmd = DockerCmd(self.parent_subtest, 'save',
                           [self.sub_stuff['save_ar']],
                           verbose=True)
        dkrcmd.verbose = True
        # Runs in background
        self.sub_stuff['cmdresult_save'] = dkrcmd.execute()

        if self.sub_stuff['cmdresult_save'].exit_status != 0:
            # Pass error to postprocess
            return

        # Delete image
        dkrcmd = DockerCmd(self.parent_subtest, 'rmi',
                           [self.sub_stuff["rand_name"]],
                           verbose=True)
        dkrcmd.verbose = True
        # Runs in background
        self.sub_stuff['cmdresult_del'] = dkrcmd.execute()

        # Load image
        load_cmd = self.config['load_cmd']
        self.sub_stuff['load_ar'] = (load_cmd %
                                     {"image": self.sub_stuff["rand_name"]})

        dkrcmd = DockerCmd(self.parent_subtest, 'load',
                           [self.sub_stuff['load_ar']],
                           verbose=True)
        dkrcmd.verbose = True
        # Runs in background
        self.sub_stuff['cmdresult_load'] = dkrcmd.execute()
Пример #7
0
 def init_test_container(self, name):
     self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % name)
     dkrcmd = DockerCmd(self, 'run', self.sub_stuff['subargs'],
                        timeout=self.config['docker_timeout'])
     dkrcmd.verbose = True
     cmdresult = dkrcmd.execute()
     if cmdresult.exit_status != 0:
         xceptions.DockerTestNAError("Unable to prepare env for test: %s" %
                                     (cmdresult))
     cid = self.sub_stuff["cont"].list_containers_with_name(name)
     self.failif(cid == [],
                 "Unable to search container with name %s: details :%s" %
                 (name, cmdresult))
Пример #8
0
 def init_test_container(self, name):
     self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % name)
     dkrcmd = DockerCmd(self, 'run', self.sub_stuff['subargs'],
                        timeout=self.config['docker_timeout'])
     dkrcmd.verbose = True
     cmdresult = dkrcmd.execute()
     if cmdresult.exit_status != 0:
         xceptions.DockerTestNAError("Unable to prepare env for test: %s" %
                                     (cmdresult))
     cid = self.sub_stuff["cont"].list_containers_with_name(name)
     self.failif(cid == [],
                 "Unable to search container with name %s: details :%s" %
                 (name, cmdresult))
Пример #9
0
    def initialize(self):
        super(simple, self).initialize()
        rand_name = utils.generate_random_string(8).lower()
        self.sub_stuff["rand_name"] = rand_name
        self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % rand_name)

        dkrcmd = DockerCmd(self.parent_subtest, 'run',
                           self.sub_stuff['subargs'],
                           verbose=True)

        cmdresult = dkrcmd.execute()
        if cmdresult.exit_status != 0:
            error.TestNAError("Unable to prepare env for test: %s" %
                              (cmdresult))

        c_name = self.sub_stuff["rand_name"]
        self.sub_stuff["images"].append(c_name)
        cid = self.sub_stuff["cont"].list_containers_with_name(c_name)

        self.failif(cid == [],
                    "Unable to search container with name %s: details :%s" %
                   (c_name, cmdresult))

        dkrcmd = DockerCmd(self.parent_subtest, 'commit',
                           [c_name, c_name], verbose=True)
        dkrcmd.verbose = True

        cmdresult = dkrcmd.execute()
        if cmdresult.exit_status != 0:
            error.TestNAError("Unable to prepare env for test: %s" %
                              (cmdresult))
        dkrcmd = DockerCmd(self.parent_subtest, 'rm', [c_name], verbose=True)
        cmdresult = dkrcmd.execute()
        if cmdresult.exit_status != 0:
            error.TestNAError("Failed to cleanup env for test: %s" %
                              (cmdresult))
Пример #10
0
 def run_once(self):
     super(run_base, self).run_once()    # Prints out basic info
     dkrcmd = DockerCmd(self.parent_subtest, 'run',
                        self.sub_stuff['subargs'])
     dkrcmd.verbose = True
     self.sub_stuff['cmdresult'] = dkrcmd.execute()
Пример #11
0
 def run_once(self):
     super(run_base, self).run_once()    # Prints out basic info
     dkrcmd = DockerCmd(self, 'run', self.sub_stuff['subargs'])
     dkrcmd.verbose = True
     self.sub_stuff['dkrcmd'] = dkrcmd
     dkrcmd.execute()