def _init_container_attached(self, name): """ Starts detached container and attaches it using docker attach """ if self.config.get('run_options_csv'): subargs = [arg for arg in self.config['run_options_csv'].split(',')] else: subargs = [] if self.tty: subargs.append('--tty=true') else: subargs.append('--tty=false') 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 = DockerCmd(self, 'run', subargs) self.sub_stuff['container_cmd'] = container mustpass(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) c_attach = AsyncDockerCmd(self, 'attach', subargs) self.sub_stuff['container_cmd'] = c_attach # overwrites finished cmd c_attach.execute()
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 = AsyncDockerCmd(self, 'run', self.sub_stuff['subargs'], timeout=self.config['docker_timeout']) dkrcmd.verbose = True dkrcmd.timeout = 10 # Runs in background dkrcmd.execute(in_pipe_r) self.sub_stuff['dkrcmd'] = dkrcmd wait = self.config['wait_interactive_cmd'] icmd = self.config['interactive_cmd'] + "\n" # Allow noticable time difference for date command, # and eat into dkrcmd timeout after receiving signal. time.sleep(wait) os.write(in_pipe_w, icmd) self.loginfo("Waiting up to %d seconds for exit", dkrcmd.timeout) # Throw exception if takes > docker_timeout to exit self.loginfo("Container running, waiting %d seconds to finish.", wait) self.logdebug("interactive cmds %s", icmd) time.sleep(wait) os.close(in_pipe_w) dkrcmd.wait()
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)
def _init_container_attached(self, name): if self.sub_stuff.get('run_options_csv'): subargs = [arg for arg in self.sub_stuff['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") subargs.append("-c") subargs.append(self.config['exec_cmd']) container = DockerCmd(self, 'run', subargs) self.sub_stuff['container_cmd'] = container mustpass(container.execute()) if self.sub_stuff.get('attach_options_csv'): subargs = [arg for arg in self.sub_stuff['attach_options_csv'].split(',')] else: subargs = [] subargs.append(name) c_attach = AsyncDockerCmd(self, 'attach', subargs) self.sub_stuff['container_cmd'] = c_attach # overwrites finished cmd c_attach.execute()
def run_once(self): sig = getattr(signal, self.config['listen_signal']) dkrcmd = AsyncDockerCmd(self, 'run', self.sub_stuff['subargs'], timeout=self.config['docker_timeout']) self.logdebug("Starting background docker command, " "timeout %s seconds: " "%s", self.config['docker_timeout'], dkrcmd.command) dkrcmd.verbose = True # Runs in background self.sub_stuff['dkrcmd'] = dkrcmd dkrcmd.execute() pid = dkrcmd.process_id ss = self.config['secret_sauce'] while True: stdout = dkrcmd.stdout if stdout.count(ss) >= 1: break time.sleep(0.1) wait_start = self.config['wait_start'] self.loginfo("Container running, waiting %d seconds to send signal" % wait_start) # Allow noticable time difference for date command, # and eat into dkrcmd timeout after receiving signal. time.sleep(wait_start) self.failif(not utils.pid_is_alive(pid), "Pid %s not running after wait: %s" % (pid, dkrcmd.exit_status)) self.loginfo("Signaling pid %d with signal %s", pid, self.config['listen_signal']) utils.signal_pid(pid, sig) self.loginfo("Waiting up to %d seconds for exit", dkrcmd.timeout) # Throw exception if takes > docker_timeout to exit dkrcmd.wait()
def initialize(self): super(stop_base, self).initialize() # Prepare a container docker_containers = DockerContainers(self) name = docker_containers.get_unique_name() 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() container.wait_for_ready() # 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)
def _init_container_attached(self, name): """ Starts detached container and attaches it using docker attach """ if self.config.get("run_options_csv"): subargs = [arg for arg in self.config["run_options_csv"].split(",")] else: subargs = [] if self.tty: subargs.append("--tty=true") else: subargs.append("--tty=false") 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 = DockerCmd(self, "run", subargs) self.sub_stuff["container_cmd"] = container mustpass(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) c_attach = AsyncDockerCmd(self, "attach", subargs) self.sub_stuff["container_cmd"] = c_attach # overwrites finished cmd c_attach.execute()
def pull_image(self, image_name): dkrcmd = AsyncDockerCmd(self, "pull", [image_name], self.config["docker_timeout"], verbose=True) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("Pulling...") time.sleep(3) self.failif(dkrcmd.exit_status != 0, "Fail to download image %s" % image_name)
def pull_image(self, image_name): dkrcmd = AsyncDockerCmd(self, 'pull', [image_name], self.config['docker_timeout']) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("Pulling...") time.sleep(3) self.failif_ne(dkrcmd.exit_status, 0, "Fail to download image %s" % image_name)
def run_once(self): super(tag_base, self).run_once() dkrcmd = AsyncDockerCmd(self, 'tag', self.complete_docker_command_line()) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("tagging...") time.sleep(3) self.sub_stuff["cmdresult"] = dkrcmd.wait()
def run_once(self): super(history_base, self).run_once() dkrcmd = AsyncDockerCmd(self, 'history', self.complete_history_cmd(), self.config['docker_history_timeout']) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("historyting...") time.sleep(3) self.sub_stuff["cmdresult"] = dkrcmd.wait()
def run_once(self): super(commit_base, self).run_once() dkrcmd = AsyncDockerCmd(self.parent_subtest, 'commit', self.complete_docker_command_line(), self.config['docker_commit_timeout']) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("Commiting...") time.sleep(3) self.sub_stuff["cmdresult"] = dkrcmd.wait()
def run_once(self): super(start_base, self).run_once() # 1. Run with no options dkrcmd = AsyncDockerCmd(self, 'start', self.complete_docker_command_line(), self.config['docker_start_timeout']) self.loginfo("Starting container...") self.loginfo("Executing background command: %s" % dkrcmd.command) dkrcmd.execute() dkrcmd.wait(60) self.sub_stuff["dkrcmd"] = dkrcmd
def start_test_container(self, read_fd, write_fd): dc = self.sub_stuff["dc"] name = dc.get_unique_name() subargs = ["--interactive", "--publish-all", "--name", name, self.sub_stuff["builds"][-1].image_name, "sh"] async_dkrcmd = AsyncDockerCmd(self, "run", subargs) self.sub_stuff["async_dkrcmd"] = async_dkrcmd async_dkrcmd.execute(read_fd) os.close(read_fd) os.write(write_fd, 'echo "StArTeD!"\n') self.failif(not wait_for_output(lambda: async_dkrcmd.stdout, "StArTeD!", timeout=10), str(async_dkrcmd)) return name
def postprocess(self): super(simple, self).postprocess() name = self.sub_stuff['container_name'] logs = AsyncDockerCmd(self, "logs", ['-f', name]) logs.execute() utils.wait_for(lambda: logs.stdout.count("\n") == 2, 5, step=0.1) out = logs.stdout self.failif(out.count("\n") != 2, "The container was executed twice, " "there should be 2 lines with start dates, but is " "%s.\nContainer output:\n%s" % (out.count("\n"), out)) mustpass(DockerCmd(self, "kill", [name]).execute())
def run_once(self): super(start_base, self).run_once() # 1. Run with no options dkrcmd = AsyncDockerCmd(self.parent_subtest, 'start', self.complete_docker_command_line(), self.config['docker_start_timeout']) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("Starting container...") time.sleep(3) self.sub_stuff["cmdresult"] = dkrcmd.wait()
def run_once(self): super(rmi_base, self).run_once() # 1. Run with no options dkrcmd = AsyncDockerCmd(self, 'rmi', self.complete_docker_command_line(), self.config['docker_rmi_timeout'], True) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("Deleting image...") time.sleep(3) self.sub_stuff["cmdresult"] = dkrcmd.wait()
def start_test_container(self, read_fd, write_fd): dc = self.sub_stuff['dc'] name = dc.get_unique_name() subargs = [ '--interactive', '--publish-all', '--name', name, self.sub_stuff['builds'][-1].image_name, 'sh' ] async_dkrcmd = AsyncDockerCmd(self, 'run', subargs) self.sub_stuff['async_dkrcmd'] = async_dkrcmd async_dkrcmd.execute(read_fd) os.close(read_fd) os.write(write_fd, b'\necho "R""EADY"\n') async_dkrcmd.wait_for_ready() return name
def _init_container_normal(self, name): if self.sub_stuff.get("run_options_csv"): subargs = [arg for arg in self.sub_stuff["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") subargs.append("-c") subargs.append(self.config["exec_cmd"]) container = AsyncDockerCmd(self, "run", subargs) self.sub_stuff["container_cmd"] = container container.execute()
def run_once(self): super(build, self).run_once() subargs = [self.config['docker_build_options'], "-t", self.stuff['image_name_tag'], self.srcdir] # Don't really need async here, just exercizing class dkrcmd = AsyncDockerCmd(self, 'build', subargs, self.config['build_timeout_seconds']) self.loginfo("Executing background command: %s" % dkrcmd) dkrcmd.execute() while not dkrcmd.done: self.loginfo("Building...") time.sleep(3) self.stuff["cmdresult"] = dkrcmd.wait()
def _init_container_normal(self, name): if self.sub_stuff.get('run_options_csv'): subargs = [arg for arg in self.sub_stuff['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") subargs.append("-c") subargs.append(self.config['exec_cmd']) container = AsyncDockerCmd(self, 'run', subargs) self.sub_stuff['container_cmd'] = container container.execute()
def start_base_container(self): 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 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 start_test_container(self, read_fd, write_fd): dc = self.sub_stuff['dc'] name = dc.get_unique_name() subargs = ['--interactive', '--publish-all', '--name', name, self.sub_stuff['builds'][-1].image_name, 'sh'] async_dkrcmd = AsyncDockerCmd(self, 'run', subargs) self.sub_stuff['async_dkrcmd'] = async_dkrcmd async_dkrcmd.execute(read_fd) os.close(read_fd) os.write(write_fd, 'echo "StArTeD!"\n') self.failif(not wait_for_output(lambda: async_dkrcmd.stdout, "StArTeD!", timeout=10), str(async_dkrcmd)) return name
def initialize(self): super(simple_base, self).initialize() rand_name = self.sub_stuff['cont'].get_unique_name() self.sub_stuff["rand_name"] = rand_name self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % rand_name) run_in_pipe_r, run_in_pipe_w = os.pipe() self.sub_stuff['file_desc'].append(run_in_pipe_r) self.sub_stuff['file_desc'].append(run_in_pipe_w) self.sub_stuff["run_in_pipe_w"] = run_in_pipe_w dkrcmd = AsyncDockerCmd(self, 'run', self.sub_stuff['subargs'], verbose=True) # Runs in background self.sub_stuff['cmdresult'] = dkrcmd.execute(run_in_pipe_r) self.sub_stuff['cmd_run'] = dkrcmd self.wait_interactive_cmd() self.logdebug("Detail after waiting: %s", dkrcmd.cmdresult) attach_options = self.config['attach_options_csv'].split(',') self.sub_stuff['subargs_a'] = attach_options c_name = self.sub_stuff["rand_name"] self.sub_stuff["containers"].append(c_name) cid = self.sub_stuff["cont"].list_containers_with_name(c_name) self.failif(cid == [], "Unable to search container with name %s" % (c_name))
def initialize(self): super(sig_proxy_off_base, self).initialize() rand_name = self.sub_stuff['cont'].get_unique_name() self.sub_stuff["rand_name"] = rand_name self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % rand_name) run_in_pipe_r, run_in_pipe_w = os.pipe() self.sub_stuff['file_desc'].append(run_in_pipe_r) self.sub_stuff['file_desc'].append(run_in_pipe_w) self.sub_stuff["run_in_pipe_w"] = run_in_pipe_w dkrcmd = AsyncDockerCmd(self, 'run', self.sub_stuff['subargs']) # Runs in background self.sub_stuff['cmdresult'] = dkrcmd.execute(run_in_pipe_r) self.sub_stuff['cmd_run'] = dkrcmd attach_options = self.config['attach_options_csv'].split(',') self.sub_stuff['subargs_a'] = attach_options self.wait_interactive_cmd() c_name = self.sub_stuff["rand_name"] self.sub_stuff["containers"].append(c_name) cid = self.sub_stuff["cont"].list_containers_with_name(c_name) self.failif(cid == [], "Unable to search container with name %s, detail: %s" % (c_name, dkrcmd))
def initialize(self): super(sig_proxy_off_base, self).initialize() rand_name = self.sub_stuff['cont'].get_unique_name() self.sub_stuff["rand_name"] = rand_name self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % rand_name) run_in_pipe_r, run_in_pipe_w = os.pipe() self.sub_stuff['file_desc'].append(run_in_pipe_r) self.sub_stuff['file_desc'].append(run_in_pipe_w) self.sub_stuff["run_in_pipe_w"] = run_in_pipe_w dkrcmd = AsyncDockerCmd(self, 'run', self.sub_stuff['subargs']) # Runs in background self.sub_stuff['cmdresult'] = dkrcmd.execute(run_in_pipe_r) self.sub_stuff['cmd_run'] = dkrcmd attach_options = self.config['attach_options_csv'].split(',') self.sub_stuff['subargs_a'] = attach_options dkrcmd.wait_for_ready() c_name = self.sub_stuff["rand_name"] self.sub_stuff["containers"].append(c_name) cid = self.sub_stuff["cont"].list_containers_with_name(c_name) self.failif( cid == [], "Unable to search container with name %s, detail: %s" % (c_name, dkrcmd))
def initialize(self): super(simple_base, self).initialize() rand_name = utils.generate_random_string(8) self.sub_stuff["rand_name"] = rand_name self.sub_stuff["subargs"].insert(0, "--name=\"%s\"" % rand_name) run_in_pipe_r, run_in_pipe_w = os.pipe() self.sub_stuff['file_desc'].append(run_in_pipe_r) self.sub_stuff['file_desc'].append(run_in_pipe_w) self.sub_stuff["run_in_pipe_w"] = run_in_pipe_w dkrcmd = AsyncDockerCmd(self.parent_subtest, 'run', self.sub_stuff['subargs'], verbose=True) # Runs in background self.sub_stuff['cmdresult'] = dkrcmd.execute(run_in_pipe_r) self.sub_stuff['cmd_run'] = dkrcmd self.wait_interactive_cmd() dkrcmd.update_result() self.logdebug("Detail after waiting: %s", dkrcmd) attach_options = self.config['attach_options_csv'].split(',') self.sub_stuff['subargs_a'] = attach_options c_name = self.sub_stuff["rand_name"] self.sub_stuff["containers"].append(c_name) cid = self.sub_stuff["cont"].list_containers_with_name(c_name) self.failif(cid == [], "Unable to search container with name %s" % (c_name))
def run_once(self): super(simple_base, self).run_once() self.loginfo("Starting background docker command, timeout %s seconds", self.config["docker_timeout"]) attach_in_pipe_r, attach_in_pipe_w = os.pipe() self.sub_stuff["file_desc"].append(attach_in_pipe_r) self.sub_stuff["file_desc"].append(attach_in_pipe_w) self.sub_stuff["subargs_a"].append(self.sub_stuff["rand_name"]) dkrcmd = AsyncDockerCmd(self, "attach", self.sub_stuff["subargs_a"], verbose=True) # Runs in background self.sub_stuff["cmd_attach"] = dkrcmd self.sub_stuff["cmdresult_attach"] = dkrcmd.execute(attach_in_pipe_r) self.wait_interactive_cmd() self.logdebug("Before input should be ignored: %s", dkrcmd.cmdresult) # This input should be ignored. os.write(self.sub_stuff["run_in_pipe_w"], self.config["interactive_cmd_run"] + "\n") self.logdebug("Before input should be passed: %s", dkrcmd.cmdresult) # This input should be passed to container. os.write(attach_in_pipe_w, self.config["interactive_cmd_attach"] + "\n") self.wait_interactive_cmd() self.logdebug("After input was passsed: %s", dkrcmd.cmdresult)
def initialize(self): super(simple_base, self).initialize() rand_name = self.sub_stuff["cont"].get_unique_name() self.sub_stuff["rand_name"] = rand_name self.sub_stuff["subargs"].insert(0, '--name="%s"' % rand_name) run_in_pipe_r, run_in_pipe_w = os.pipe() self.sub_stuff["file_desc"].append(run_in_pipe_r) self.sub_stuff["file_desc"].append(run_in_pipe_w) self.sub_stuff["run_in_pipe_w"] = run_in_pipe_w dkrcmd = AsyncDockerCmd(self, "run", self.sub_stuff["subargs"], verbose=True) # Runs in background self.sub_stuff["cmdresult"] = dkrcmd.execute(run_in_pipe_r) self.sub_stuff["cmd_run"] = dkrcmd self.wait_interactive_cmd() self.logdebug("Detail after waiting: %s", dkrcmd.cmdresult) attach_options = self.config["attach_options_csv"].split(",") self.sub_stuff["subargs_a"] = attach_options c_name = self.sub_stuff["rand_name"] self.sub_stuff["containers"].append(c_name) cid = self.sub_stuff["cont"].list_containers_with_name(c_name) self.failif(cid == [], "Unable to search container with name %s" % (c_name))
def run_once(self): super(simple_base, self).run_once() self.loginfo("Starting background docker command, timeout %s seconds", self.config['docker_timeout']) attach_in_pipe_r, attach_in_pipe_w = os.pipe() self.sub_stuff['file_desc'].append(attach_in_pipe_r) self.sub_stuff['file_desc'].append(attach_in_pipe_w) self.sub_stuff['subargs_a'].append(self.sub_stuff["rand_name"]) dkrcmd = AsyncDockerCmd(self, 'attach', self.sub_stuff['subargs_a'], verbose=True) # Runs in background self.sub_stuff['cmd_attach'] = dkrcmd self.sub_stuff['cmdresult_attach'] = dkrcmd.execute(attach_in_pipe_r) self.wait_interactive_cmd() self.logdebug("Before input should be ignored: %s", dkrcmd.cmdresult) # This input should be ignored. os.write(self.sub_stuff["run_in_pipe_w"], self.config['interactive_cmd_run'] + "\n") self.logdebug("Before input should be passed: %s", dkrcmd.cmdresult) # This input should be passed to container. os.write(attach_in_pipe_w, self.config['interactive_cmd_attach'] + "\n") self.wait_interactive_cmd() self.logdebug("After input was passsed: %s", dkrcmd.cmdresult)
def _start_container(self): """ Start a container. All it does is emit output to stdout, one line per second. We don't care what the output is, we just care that the number of output lines increases over time. """ c_name = self.stuff['dc'].get_unique_name() fin = DockerImage.full_name_from_defaults(self.config) subargs = ['--detach', '--name=' + c_name, fin, 'bash -c "echo READY;' ' while :; do date +%s; sleep 1;done"'] dkrcmd = AsyncDockerCmd(self, 'run', subargs) dkrcmd.execute() dkrcmd.wait_for_ready(c_name) self.stuff['container_name'] = c_name
def run_once(self): super(simple_base, self).run_once() self.loginfo("Starting background docker command, timeout %s seconds", self.config['docker_timeout']) attach_in_pipe_r, attach_in_pipe_w = os.pipe() self.sub_stuff['file_desc'].append(attach_in_pipe_r) self.sub_stuff['file_desc'].append(attach_in_pipe_w) self.sub_stuff['subargs_a'].append(self.sub_stuff["rand_name"]) dkrcmd = AsyncDockerCmd(self.parent_subtest, 'attach', self.sub_stuff['subargs_a'], verbose=True) # Runs in background self.sub_stuff['cmd_attach'] = dkrcmd self.sub_stuff['cmdresult_attach'] = dkrcmd.execute(attach_in_pipe_r) self.wait_interactive_cmd() dkrcmd.update_result() self.logdebug("Before input should be ignored: %s", dkrcmd) # This input should be ignored. os.write(self.sub_stuff["run_in_pipe_w"], self.config['interactive_cmd_run'] + "\n") dkrcmd.update_result() self.logdebug("Before input should be passed: %s", dkrcmd) # This input should be passed to container. os.write(attach_in_pipe_w, self.config['interactive_cmd_attach'] + "\n") self.wait_interactive_cmd() dkrcmd.update_result() self.logdebug("After input was passsed: %s", dkrcmd)
def run_once(self): super(build, self).run_once() subargs = [self.config['docker_build_options'], "-t", self.stuff['image_name_tag'], self.srcdir] # Don't really need async here, just exercizing class dkrcmd = AsyncDockerCmd(self, 'build', subargs, self.config['build_timeout_seconds'], verbose=True) dkrcmd.execute() nss = NotSeenString(getattr, dkrcmd, 'stdout') while not dkrcmd.done: if nss.has_new_line(): self.loginfo("Building: %s" % nss) else: time.sleep(3) self.stuff["cmdresult"] = dkrcmd.wait()
def start_test_container(self, read_fd, write_fd): dc = self.sub_stuff['dc'] name = dc.get_unique_name() subargs = [ '--interactive', '--publish-all', '--name', name, self.sub_stuff['builds'][-1].image_name, 'sh' ] async_dkrcmd = AsyncDockerCmd(self, 'run', subargs) self.sub_stuff['async_dkrcmd'] = async_dkrcmd async_dkrcmd.execute(read_fd) os.close(read_fd) os.write(write_fd, 'echo "StArTeD!"\n') self.failif( not wait_for_output( lambda: async_dkrcmd.stdout, "StArTeD!", timeout=10), str(async_dkrcmd)) return name
def _start_container(self, name): """ Create, store in self.sub_stuff and execute container """ self.sub_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") subargs.append("-c") subargs.append("'echo STARTED: $(date); while :; do sleep 0.1; done'") container = AsyncDockerCmd(self, 'run', subargs) container.execute() utils.wait_for(lambda: container.stdout.startswith("STARTED"), 5, step=0.1)
def _start_idle_container(self): """ Start a container. We only need it briefly, until we (the test, running in host space) can cd into its root filesystem. Container will spin idly until a semaphore file is removed. """ c_name = self.stuff['dc'].get_unique_name() fin = DockerImage.full_name_from_defaults(self.config) self.stuff['trigger_file'] = trigger_file = 'DELETE-ME' subargs = ['--rm', '--name=' + c_name, fin, 'bash -c "echo READY;touch /%s;' ' while [ -e /%s ]; do sleep 0.1; done"' % (trigger_file, trigger_file)] dkrcmd = AsyncDockerCmd(self, 'run', subargs) dkrcmd.execute() dkrcmd.wait_for_ready(c_name) self.stuff['container_name'] = c_name
def _start_idle_container(self): """ Start a container. We only need it briefly, until we (the test, running in host space) can cd into its root filesystem. Container will spin idly until a semaphore file is removed. """ c_name = self.stuff['dc'].get_unique_name() fin = DockerImage.full_name_from_defaults(self.config) self.stuff['trigger_file'] = trigger_file = 'DELETE-ME' subargs = [ '--rm', '--name=' + c_name, fin, 'bash -c "echo READY;touch /%s;' ' while [ -e /%s ]; do sleep 0.1; done"' % (trigger_file, trigger_file) ] dkrcmd = AsyncDockerCmd(self, 'run', subargs) dkrcmd.execute() dkrcmd.wait_for_ready(c_name) self.stuff['container_name'] = c_name
def _init_container_normal(self, name): """ Starts container """ if self.config.get("run_options_csv"): subargs = [arg for arg in self.config["run_options_csv"].split(",")] else: subargs = [] if self.tty: subargs.append("--tty=true") else: subargs.append("--tty=false") 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, verbose=False) self.sub_stuff["container_cmd"] = container container.execute()
def _init_container_normal(self, name): """ Starts container """ if self.config.get('run_options_csv'): subargs = [ arg for arg in self.config['run_options_csv'].split(',') ] else: subargs = [] if self.tty: subargs.append('--tty=true') else: subargs.append('--tty=false') 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, verbose=False) self.sub_stuff['container_cmd'] = container container.execute()
def run_once(self): """ Run a background container with --rm; while that's running, clone another process sharing the same mount namespace. That process will signal the container to finish, and when docker cleans it up (--rm) we expect no errors. """ super(rmdir_mount, self).run_once() fin = DockerImage.full_name_from_defaults(self.config) name = DockerContainers(self).get_unique_name() # Create a state file; container will exit once this is deleted waitfile = 'state_file_for_signaling_the_container_to_exit' waitfile_local = os.path.join(self.tmpdir, waitfile) open(waitfile_local, 'a').close() # Basically: mount self.tmpdir as /tmp in container, constantly # check the state file, exit when it's deleted, then (--rm) have # docker clean it up. subargs = [ '--rm', '-v', '%s:/tmp:z' % self.tmpdir, '--name', name, fin, 'bash', '-c', "'echo READY; while [ -e /tmp/%s ]; do sleep 0.1; done'" % waitfile ] dkrcmd = AsyncDockerCmd(self, 'run', subargs) self.sub_stuff['dkrcmd'] = dkrcmd dkrcmd.execute() dkrcmd.wait_for_ready(name, timeout=5) # Container is running. Now, in parallel: clone, delete state file, # and wait for container to terminate. in_n = ("rm -f %s;" " while :;do" " docker inspect %s 2>/dev/null || exit 0;" " done" % (waitfile_local, name)) self.sub_stuff['unshare'] = utils.run("unshare -m bash -c '%s'" % in_n)
def run_once(self): super(sig_proxy_off_base, self).run_once() self.loginfo("Starting background docker command, timeout %s seconds", self.config['docker_timeout']) self.sub_stuff['subargs_a'].append(self.sub_stuff["rand_name"]) dkrcmd = AsyncDockerCmd(self, 'attach', self.sub_stuff['subargs_a']) # Runs in background self.sub_stuff['cmd_attach'] = dkrcmd self.sub_stuff['cmdresult_attach'] = dkrcmd.execute() self.wait_interactive_cmd() pid = dkrcmd.process_id os.kill(pid, int(self.config["signal"])) self.wait_interactive_cmd() self.logdebug("After the killing: %s", dkrcmd.cmdresult)