def postprocess(self): super(systemd_run, self).postprocess() host = 'localhost' port = 4321 utils.wait_for(lambda: not is_port_free(port, host), 10) time_from_socket = self.read_socket(host, port) self.failif(not time_from_socket.isdigit(), "Data received from container is non-numeric: '%s'" % time_from_socket)
def postprocess(self): super(systemd_run, self).postprocess() host = 'localhost' port = 4321 utils.wait_for(lambda: not is_port_free(port, host), 10) time_from_socket = self.read_socket(host, port) self.failif( not time_from_socket.isdigit(), "Data received from container is non-numeric: '%s'" % time_from_socket)
def run_once(self): host = 'localhost' port = 4321 self.sysd_action('daemon-reload') self.sysd_action('start', self.config['sysd_unit_file']) utils.wait_for(lambda: not is_port_free(port, host), 10) time_from_socket = self.read_socket(host, port) self.failif(not time_from_socket.isdigit(), "Data received from container is non-numeric: '%s'" % time_from_socket)
def get_container_ip(self, cont_name): # Wait untils container is ready. got_json = lambda: self.get_jason(cont_name) utils.wait_for(got_json, 120, text='Waiting on container %s start' % cont_name) json = self.get_jason(cont_name) if len(json) == 1: netset = json[0].get("NetworkSettings") if netset is not None: return netset.get("IPAddress") # Could return None return None
def run_once(self): super(liverestore, self).run_once() self._start_container() self._verify_that_container_is_running() # Restart docker daemon. It should be nearly instantaneous; if it # takes ~90 seconds it could be another symptom of rhbz1424709. # The warning message might help someone diagnose a later failure. # 2018-04-04 also restart docker-containerd. This is currently # only meaningful for Fedora 28; the service doesn't exist on RHEL. # So don't actually check exit status. self.stuff['dockerd_pid_orig'] = docker_daemon.pid() self.stuff['container_pid_orig'] = self._container_pid() t0 = time.time() utils.run('systemctl restart docker-containerd.service', ignore_status=True) docker_daemon.restart() t1 = time.time() if t1 - t0 > 30: self.logwarning("docker restart took %d seconds", t1 - t0) # Wait until docker is back def _docker_is_active(): result = docker_daemon.systemd_action('is-active').stdout.strip() self.logdebug("is-active -> %s" % result) return result == 'active' self.failif( utils.wait_for(_docker_is_active, 15, step=1) is None, "Timed out waiting for docker daemon ")
def init_save_images(self): # If images w/ same id as remote image already exist, save then remove di = self.sub_stuff['img'] imgs = di.list_imgs_with_full_name(self.config["remote_image_fqin"]) if imgs: long_id = imgs[0].long_id existing_images = di.list_imgs_with_image_id(long_id) self.sub_stuff['saved_images'] = os.path.join(self.tmpdir, str(long_id)) subargs = ['--output', self.sub_stuff['saved_images']] for img in existing_images: self.loginfo("Going to save image %s" % img.full_name) subargs.append(img.full_name) self.loginfo("Saving images...") mustpass(DockerCmd(self, 'save', subargs).execute()) self.loginfo("Removing images...") subargs = ['--force'] subargs += [img.full_name for img in existing_images] mustpass(DockerCmd(self, 'rmi', subargs).execute()) # Wait for images to actually go away _fn = lambda: self.long_id_in_images(long_id) gone = utils.wait_for(_fn, 60, step=1, text="Waiting for image removal") self.logdebug("Current images: %s", di.list_imgs()) if not gone: raise DockerTestFail("Timeout waiting for removal of %s" % long_id)
def run(test, params, env): """ Kill started qemu VM process with different signals and check the status of the VM changes accordingly. """ vm_name = params.get('main_vm') sig_name = params.get('signal', 'SIGSTOP') vm_state = params.get('vm_state', 'running') expect_stop = params.get('expect_stop', 'yes') == 'yes' vm = env.get_vm(vm_name) xml_backup = vm_xml.VMXML.new_from_inactive_dumpxml(vm_name) try: if vm_state == 'running': pass elif vm_state == 'paused': vm.pause() elif vm_state == 'pmsuspended': vm.prepare_guest_agent() vm.pmsuspend() else: raise error.TestError("Unhandled VM state %s" % vm_state) os.kill(vm.get_pid(), getattr(signal, sig_name)) stopped = bool(utils.wait_for(lambda: vm.state() == 'shut off', 10)) if stopped != expect_stop: raise error.TestFail('Expected VM stop is "%s", got "%s"' % (expect_stop, vm.state())) finally: xml_backup.sync()
def init_save_images(self): # If images w/ same id as remote image already exist, save then remove di = self.sub_stuff['img'] imgs = di.list_imgs_with_full_name(self.config["remote_image_fqin"]) if imgs: long_id = imgs[0].long_id existing_images = di.list_imgs_with_image_id(long_id) self.sub_stuff['saved_images'] = os.path.join(self.tmpdir, str(long_id)) subargs = ['--output', self.sub_stuff['saved_images']] for img in existing_images: self.loginfo("Going to save image %s" % img.full_name) subargs.append(img.full_name) self.loginfo("Saving images...") mustpass(DockerCmd(self, 'save', subargs).execute()) self.loginfo("Removing images...") subargs = ['--force'] subargs += [img.full_name for img in existing_images] mustpass(DockerCmd(self, 'rmi', subargs, verbose=True).execute()) # Wait for images to actually go away _fn = lambda: self.long_id_in_images(long_id) gone = utils.wait_for(_fn, 60, step=1, text="Waiting for image removal") self.logdebug("Current images: %s", di.list_imgs()) if not gone: raise DockerTestFail("Timeout waiting for removal of %s" % long_id)
def wait_start(self): self.sub_stuff['dkrcmd'].execute() self.loginfo("Waiting up to %s seconds for container start", self.config['docker_timeout']) self.failif(not utils.wait_for(func=self.cidfile_has_cid, timeout=self.config['docker_timeout'], text=("\t\tWaiting for container to " "start")))
def wait_start(self): self.sub_stuff['dkrcmd'].execute() self.loginfo("Waiting up to %s seconds for container start", self.config['docker_timeout']) self.failif(not utils.wait_for(func=self.cidfile_has_cid, timeout=self.config['docker_timeout'], text=("\t\tWaiting for container to " "start")))
def postprocess(self): net_device = self.sub_stuff['net_device'] container_rules = lambda: self.read_iptable_rules(net_device) added_rules = utils.wait_for(container_rules, 10, step=0.1) self.failif(not added_rules, "No rules added when container started.") self.loginfo("Container %s\niptable rule list %s:" % (self.sub_stuff['name'], added_rules)) NoFailDockerCmd(self, 'stop', ["-t 0", self.sub_stuff['name']]).execute() container_rules = lambda: not self.read_iptable_rules(net_device) removed_rules = utils.wait_for(container_rules, 10, step=0.1) self.failif(not removed_rules, "Container %s iptable rules not " "removed in 10s after stop. Rules:\n%s" % (self.sub_stuff['name'], self.read_iptable_rules(net_device)))
def postprocess(self): super(sigproxy_base, self).postprocess() self._check_results() # stop the container container_name = self.sub_stuff['container_name'] mustpass(DockerCmd(self, "kill", [container_name]).execute()) container = self.sub_stuff['container_cmd'] if not utils.wait_for(lambda: container.done, 5, step=0.1): raise DockerTestFail("Unable to kill container after test...")
def postprocess(self): super(sigproxy_base, self).postprocess() self._check_results() # stop the container container_name = self.sub_stuff['container_name'] mustpass(DockerCmd(self, "kill", [container_name]).execute()) container = self.sub_stuff['container_cmd'] if not utils.wait_for(lambda: container.done, 5, step=0.1): raise DockerTestFail("Unable to kill container after test...")
def wait_for_output(check, output, stderr=False): """ Wait until check in the new output """ idx = output.idx if stderr: output_matches = lambda: check in output.geterr(idx) else: output_matches = lambda: check in output.get(idx) if utils.wait_for(output_matches, 10, step=0.01) is None: return -1 return 0
def wait_container(self): wait_stop = self.config["wait_stop"] self.logdebug("Waiting up to %d seconds for container to exit", wait_stop) dkrcmd = self.sub_stuff["dkrcmd"] self.failif( not utils.wait_for( func=self.container_finished, timeout=wait_stop, text=("\t\tWaiting for container to " "exit") ), "Container did not exit w/in timeout: stdout '%s' " "stderr '%s'" % (dkrcmd.stdout, dkrcmd.stderr), ) cmdresult = self.sub_stuff["cmdresult"] = dkrcmd.wait() self.logdebug("Result: %s", cmdresult)
def wait_container(self): wait_stop = self.config['wait_stop'] self.logdebug("Waiting up to %d seconds for container to exit", wait_stop) dkrcmd = self.sub_stuff['dkrcmd'] self.failif( not utils.wait_for(func=self.container_finished, timeout=wait_stop, text=("\t\tWaiting for container to " "exit")), "Container did not exit w/in timeout: stdout '%s' " "stderr '%s'" % (dkrcmd.stdout, dkrcmd.stderr)) cmdresult = self.sub_stuff['cmdresult'] = dkrcmd.wait() self.logdebug("Result: %s", cmdresult)
def postprocess(self): super(cp_symlink, self).postprocess() # Container should terminate on its own self.failif(not utils.wait_for(func=self._container_done, timeout=5, text="\tWaiting for container to exit"), "Container did not exit! Perhaps /stop did not copy?") cmdresult = self.sub_stuff['dkrcmd'].wait(1) OutputGood(cmdresult) self.failif(cmdresult.exit_status == 4, "File was not copied into container:%s" % self.config['destdir']) self.failif(cmdresult.exit_status == 5, "File was copied, but content is bad: %s" % cmdresult.stdout) self.failif_ne(cmdresult.exit_status, 0, "Unexpected error running command: %s" % cmdresult)
def wait_for_stop(self, timeout=60, step=0.1): """ Wait for libvirtd to stop. :param timeout: Max wait time :param step: Checking interval """ logging.debug('Waiting for libvirtd to stop') if self.gdb: return self.gdb.wait_for_stop(timeout=timeout) else: return utils.wait_for( lambda: not self.running, timeout=timeout, step=step, )
def wait_for_output(output_fn, pattern, timeout=60, timestep=0.2): r""" Wait for matched_string in async_process.stdout max for time==timeout. :param output_fn: function which returns data for matching. :type output_fn: function :param pattern: string which should be found in stdout. :return: True if pattern matches process_output else False """ if not callable(output_fn): raise TypeError("Output function type %s value %s is not a callable" % (output_fn.__class__.__name__, str(output_fn))) regex = re.compile(pattern) _fn = lambda: regex.findall(output_fn()) != [] res = utils.wait_for(_fn, timeout, step=timestep) if res: return True return False
def wait_for_output(output_fn, pattern, timeout=60, timestep=0.2): r""" Wait for matched_string in async_process.stdout max for time==timeout. :param process_output_fn: function which returns data for matching. :type process_output_fn: function :param pattern: string which should be found in stdout. :return: True if pattern matches process_output else False """ if not callable(output_fn): raise TypeError("Output function type %s value %s is not a callable" % (output_fn.__class__.__name__, str(output_fn))) regex = re.compile(pattern) _fn = lambda: regex.findall(output_fn()) != [] res = utils.wait_for(_fn, timeout, step=timestep) if res: return True return False
def test(self): super(test_multihost_copy, self).test() copy_timeout = int(params.get("copy_timeout", 480)) checksum_timeout = int(params.get("checksum_timeout", 180)) pid = None sync_id = {'src': self.srchost, 'dst': self.dsthost, "type": "file_trasfer"} filename = "orig" if self.is_src: # Starts in source vm = env.get_vm(self.vms[0]) vm.monitor.migrate_set_speed("1G") session = vm.wait_for_login(timeout=login_timeout) cdrom_dev_list = list_guest_cdroms(session) logging.debug("cdrom_dev_list: %s", cdrom_dev_list) cdrom = cdrom_dev_list[-1] mount_point = get_cdrom_mount_point(session, cdrom, params) mount_cmd = params["mount_cdrom_cmd"] % (cdrom, mount_point) src_file = params["src_file"] % (mount_point, filename) dst_file = params["dst_file"] % filename copy_file_cmd = params[ "copy_file_cmd"] % (mount_point, filename) remove_file_cmd = params["remove_file_cmd"] % filename md5sum_cmd = params["md5sum_cmd"] if params["os_type"] != "windows": error.context("Mount and copy data") session.cmd(mount_cmd, timeout=30) error.context("File copying test") session.cmd(copy_file_cmd) pid = disk_copy(vm, src_file, dst_file, copy_timeout) sync = SyncData(self.mig.master_id(), self.mig.hostid, self.mig.hosts, sync_id, self.mig.sync_server) pid = sync.sync(pid, timeout=cdrom_prepare_timeout)[self.srchost] self.mig.migrate_wait([self.vms[0]], self.srchost, self.dsthost) if not self.is_src: # Starts in source vm = env.get_vm(self.vms[0]) session = vm.wait_for_login(timeout=login_timeout) error.context("Wait for copy finishing.") def is_copy_done(): if params["os_type"] == "windows": cmd = "tasklist /FI \"PID eq %s\"" % pid else: cmd = "ps -p %s" % pid return session.cmd_status(cmd) != 0 if utils.wait_for(is_copy_done, timeout=copy_timeout) is None: raise error.TestFail("Wait for file copy finish timeout") error.context("Compare file on disk and on cdrom") f1_hash = session.cmd("%s %s" % (md5sum_cmd, dst_file), timeout=checksum_timeout).split()[0] f2_hash = session.cmd("%s %s" % (md5sum_cmd, src_file), timeout=checksum_timeout).split()[0] if f1_hash.strip() != f2_hash.strip(): raise error.TestFail("On disk and on cdrom files are" " different, md5 mismatch") session.cmd(remove_file_cmd) self.mig._hosts_barrier(self.mig.hosts, self.mig.hosts, 'Finish_cdrom_test', login_timeout)
def wait_start(self): self.stuff['dkrcmd'].execute() self.failif(not utils.wait_for(func=self.cidfile_has_cid, timeout=self.config['docker_timeout'], text="Waiting for container to start"))
def wait_start(self): self.stuff['dkrcmd'].execute() self.failif(not utils.wait_for(func=self.cidfile_has_cid, timeout=self.config['docker_timeout'], text="Waiting for container to start"))
def run_once(self): def wait_for_output(check, output, stderr=False): """ Wait until check in the new output """ idx = output.idx if stderr: output_matches = lambda: check in output.geterr(idx) else: output_matches = lambda: check in output.get(idx) if utils.wait_for(output_matches, 10, step=0.01) is None: return -1 return 0 def error_msg(log_us): """ Format a nice string from dictionary """ out = ["%s\n%s" % (key, value) for key, value in log_us.iteritems()] return "\n\n".join(out) def _output_matches(cmd1, cmd2): """ Compares the output of stdout&stderr """ out1 = cmd1.stdout.splitlines() + cmd1.stderr.splitlines() out1 = set((_ for _ in out1 if not _.startswith('[debug]'))) out2 = cmd2.stdout.splitlines() + cmd2.stderr.splitlines() out2 = set((_ for _ in out2 if not _.startswith('[debug]'))) return out1 == out2 super(simple_base, self).run_once() log_us = {} # Create container dkrcmd, name = self._init_container(self.sub_stuff['subargs'], 'bash') log_us['container'] = dkrcmd dkrcmd.execute() self.wait_exists(name) # Create docker logs --follow log1 = AsyncDockerCmd(self, 'logs', ['--follow', name], verbose=False) self.sub_stuff['async_processes'].append(log1) log_us['log1'] = log1 log1.execute() log1_out = Output(log1) # Generate output to stdout for _ in xrange(5): prefix = utils.generate_random_string(5) dkrcmd.stdin("PREFIX='%s'\n" % prefix) line = utils.generate_random_string(10) dkrcmd.stdin("echo $PREFIX: %s\n" % line) line = "%s: %s" % (prefix, line) self.failif(wait_for_output(line, log1_out), "Stdout '%s' did not occur in log1 output in 10s:\n%s" % (line, error_msg(log_us))) # Start docker logs without follow and compare output log2 = DockerCmd(self, 'logs', [name], verbose=False) log_us['log2'] = log2 log2.execute() match = lambda: _output_matches(log1, log2) self.failif(not utils.wait_for(match, 5), "Outputs of log1 and " "log2 are not the same:\n%s" % error_msg(log_us)) # Generate output to stderr for _ in xrange(5): prefix = utils.generate_random_string(5) dkrcmd.stdin("PREFIX='%s'\n" % prefix) line = utils.generate_random_string(10) dkrcmd.stdin(">&2 echo $PREFIX: %s\n" % line) line = "%s: %s" % (prefix, line) self.failif(wait_for_output(line, log1_out, self.sub_stuff['stderr']), "Output '%s' did not occur in log1 output in 10s:\n%s" % (line, error_msg(log_us))) self.failif(_output_matches(log1, log2), 'Outputs log1 and log2 are ' "the same even thought new input was generated and log2 " "was executed without --follow:\n%s" % error_msg(log_us)) # Stop the container dkrcmd.stdin('exit\n') dkrcmd.close() # Wait for docker logs exit log1.wait(10) # Start docker logs without follow and compare output log3 = DockerCmd(self, 'logs', [name], verbose=False) log_us['log3'] = log3 log3.execute() match = lambda: _output_matches(log1, log3) self.failif(not utils.wait_for(match, 5), "Outputs of log1 and " "log3 are not the same:\n%s" % error_msg(log_us))
def test(self): super(test_multihost_copy, self).test() copy_timeout = int(params.get("copy_timeout", 480)) checksum_timeout = int(params.get("checksum_timeout", 180)) pid = None sync_id = { 'src': self.srchost, 'dst': self.dsthost, "type": "file_trasfer" } filename = "orig" if self.is_src: # Starts in source vm = env.get_vm(self.vms[0]) vm.monitor.migrate_set_speed("1G") session = vm.wait_for_login(timeout=login_timeout) cdrom_dev_list = list_guest_cdroms(session) logging.debug("cdrom_dev_list: %s", cdrom_dev_list) cdrom = cdrom_dev_list[-1] mount_point = get_cdrom_mount_point(session, cdrom, params) mount_cmd = params["mount_cdrom_cmd"] % (cdrom, mount_point) src_file = params["src_file"] % (mount_point, filename) dst_file = params["dst_file"] % filename copy_file_cmd = params["copy_file_cmd"] % (mount_point, filename) remove_file_cmd = params["remove_file_cmd"] % filename md5sum_cmd = params["md5sum_cmd"] if params["os_type"] != "windows": error.context("Mount and copy data") session.cmd(mount_cmd, timeout=30) error.context("File copying test") session.cmd(copy_file_cmd) pid = disk_copy(vm, src_file, dst_file, copy_timeout) sync = SyncData(self.mig.master_id(), self.mig.hostid, self.mig.hosts, sync_id, self.mig.sync_server) pid = sync.sync(pid, timeout=cdrom_prepare_timeout)[self.srchost] self.mig.migrate_wait([self.vms[0]], self.srchost, self.dsthost) if not self.is_src: # Starts in source vm = env.get_vm(self.vms[0]) session = vm.wait_for_login(timeout=login_timeout) error.context("Wait for copy finishing.") def is_copy_done(): if params["os_type"] == "windows": cmd = "tasklist /FI \"PID eq %s\"" % pid else: cmd = "ps -p %s" % pid return session.cmd_status(cmd) != 0 if utils.wait_for(is_copy_done, timeout=copy_timeout) is None: raise error.TestFail("Wait for file copy finish timeout") error.context("Compare file on disk and on cdrom") f1_hash = session.cmd("%s %s" % (md5sum_cmd, dst_file), timeout=checksum_timeout).split()[0] f2_hash = session.cmd("%s %s" % (md5sum_cmd, src_file), timeout=checksum_timeout).split()[0] if f1_hash.strip() != f2_hash.strip(): raise error.TestFail("On disk and on cdrom files are" " different, md5 mismatch") session.cmd(remove_file_cmd) self.mig._hosts_barrier(self.mig.hosts, self.mig.hosts, 'Finish_cdrom_test', login_timeout)