def check_duplicated_console(command, force_command, status_error, login_user, login_passwd, test): """ Test opening a second console with another console active using --force option or not. :param command: Test command without --force option :param force_command: Test command with --force option :param status_error: Whether the command is fault. :param login_user: User name for logging into the VM. :param login_passwd: Password for logging into the VM. :param test: Test Object """ session = aexpect.ShellSession(command) if not status_error: # Test duplicated console session res = process.run(command, timeout=10, ignore_status=True, shell=True) logging.debug(res) if res.exit_status == 0: test.fail("Duplicated console session should fail. " "but succeeded with:\n%s" % res) # Test duplicated console session with force option force_session = aexpect.ShellSession(force_command) force_status = utils_test.libvirt.verify_virsh_console(force_session, login_user, login_passwd, timeout=10, debug=True) if not force_status: test.fail("Expect force console session should succeed, " "but failed.") force_session.close() session.close()
def test_launch(self): host = self.params.get("hostname", '/tests/', "localhost") hostfile = self.params.get("hostfile1", '/files/', "/tmp/hostfile1") urifile = self.params.get("urifile", '/files/', "/tmp/urifile") server_count = len(genio.read_all_lines(hostfile)) get_prompt = "/bin/bash" launch_cmd = "../../install/bin/orterun --np {0} ".format(server_count) launch_cmd += "--hostfile {0} --enable-recovery ".format(hostfile) launch_cmd += "--report-uri {0} -x D_LOG_FILE=/mnt/shared/test/tmp/daos.log ".format( urifile) launch_cmd += "-x LD_LIBRARY_PATH=/home/skirvan/daos_m10/install/lib:/home/skirvan/daos_m10/install/lib/daos_srv " launch_cmd += "../../install/bin/daos_server -d /tmp/.daos -g daos_server" try: session = aexpect.ShellSession(get_prompt) if (session.is_responsive()): session.sendline(launch_cmd) session.read_until_any_line_matches( "XDAOS server (v0.0.2) started on rank *", timeout=5.0, print_func=printFunc) else: self.fail("Server did not start.\n") except Exception as e: self.fail("Server did not start.\n") session.sendcontrol("c")
def runServer(hostfile, setname, basepath): global sessions try: server_count = len(genio.read_all_lines(hostfile)) initial_cmd = "/bin/sh" server_cmd = basepath + "/install/bin/orterun --np {0} ".format( server_count) server_cmd += "--hostfile {0} --enable-recovery ".format(hostfile) server_cmd += "-x D_LOG_MASK=DEBUG,RPC=ERR,MEM=ERR -x D_LOG_FILE=" server_cmd += basepath + "/install/tmp/daos.log " server_cmd += "-x LD_LIBRARY_PATH={0}/install/lib:".format(basepath) server_cmd += "{0}/install/lib/daos_srv ".format(basepath) server_cmd += basepath + "/install/bin/daos_server -g {0} -c 1 ".format( setname) server_cmd += " -a" + basepath + "/install/tmp/" print "Start CMD>>>>{0}".format(server_cmd) sessions[setname] = aexpect.ShellSession(initial_cmd) if (sessions[setname].is_responsive()): sessions[setname].sendline(server_cmd) sessions[setname].read_until_any_line_matches( "DAOS server (v0.0.2) started on rank 0*", print_func=printFunc) print "<SERVER> server started" except Exception as e: print "<SERVER> Exception occurred: {0}".format(str(e)) raise ServerFailed("Server didn't start!")
def _start_tcpdump(self): port = self._params.get('shell_port') prompt = self._params.get('shell_prompt') address = self._params.get('ovirt_node_address') username = self._params.get('ovirt_node_user') password = self._params.get('ovirt_node_password') cmd_template = "%s -npvvvi any 'port 68 or port 546'" cmd = cmd_template % utils_misc.find_command("tcpdump") if self._params.get("remote_preprocess") == "yes": login_cmd = ("ssh -o UserKnownHostsFile=/dev/null " "-o StrictHostKeyChecking=no " "-o PreferredAuthentications=password -p %s %s@%s" % (port, username, address)) self._tcpdump = aexpect.ShellSession( login_cmd, output_func=_update_address_cache, output_params=(self, )) remote.handle_prompts(self._tcpdump, username, password, prompt) self._tcpdump.sendline(cmd) else: self._tcpdump = aexpect.Tail(command=cmd, output_func=_tcpdump_handler, output_params=(self, "tcpdump.log")) if utils_misc.wait_for(lambda: not self._tcpdump.is_alive(), 0.1, 0.1, 1.0): logging.warn("Could not start tcpdump") logging.warn("Status: %s", self._tcpdump.get_status()) msg = utils_misc.format_str_for_message(self._tcpdump.get_output()) logging.warn("Output: %s", msg)
def edit_image_xml(): edit_cmd = r":%s /<boot dev='hd'\/>/<boot dev='cdrom'\/>" if restore_state == "running": option = "--running" elif restore_state == "paused": option = "--paused" elif restore_state == "": option = "" else: test.fail("Unknown save-image-define option") session = aexpect.ShellSession("sudo -s") try: logging.info("Execute virsh save-image-edit %s %s", vm_save, option) session.sendline("virsh save-image-edit %s %s " % (vm_save, option)) logging.info("Replace '<boot dev='hd'/>' to '<boot dev='cdrom'/>'") session.sendline(edit_cmd) session.send('\x1b') session.send('ZZ') session.read_until_any_line_matches( patterns=['State file.*%s edited' % vm_save, 'not changed'], timeout=5, print_func=logging.debug) except (aexpect.ShellError, aexpect.ExpectError, aexpect.ShellTimeoutError) as details: session.close() test.error("Failed to do save-image-edit: %s" % details)
def create_ssh_session(self): """Create ssh session""" user_known_hosts_file = '/dev/null' port = 22 _, output = self.serial_cmd("ping -c 2 %s" % NETWORKS.ipaddr) LOG.debug("check ping result %s" % output) ssh_session = aexpect.ShellSession( "ssh %s -o UserKnownHostsFile=%s -o StrictHostKeyChecking=no -p %s" % (self.guest_ip, user_known_hosts_file, port), auto_close=False, output_func=self.serial_log.debug, prompt=r"[\#\$]", status_test_command="echo $?") try: self.console_manager.handle_session(ssh_session, username=CONFIG.vm_username, password=CONFIG.vm_password, prompt=r"[\#\$]", timeout=60.0) except Exception: ssh_session.close() raise Exception("handle_prompts ssh session failed!") return ssh_session
def edit_snap_xml(dom_name, edit_opts, edit_cmd): """ Edit domain snapshot xml :param dom_name: name of domain :param snap_name: name of snapshot :param edit_opts: snapshot-edit options :param edit_cmd: edit command list in interactive mode """ session = aexpect.ShellSession("sudo -s") try: logging.debug("snapshot-edit options is: %s" % edit_opts) logging.debug("edit cmd is: %s" % edit_cmd) session.sendline("virsh snapshot-edit %s %s" % (dom_name, edit_opts)) for i in edit_cmd: session.sendline(i) # Press ESC session.send('\x1b') # Save and quit session.send('ZZ') # use sleep(1) to make sure the modify has been completed. remote.handle_prompts(session, None, None, r"[\#\$]\s*$") session.close() logging.info("Succeed to do snapshot edit") except (aexpect.ShellError, aexpect.ExpectError) as details: log = session.get_output() session.close() test.fail("Failed to do snapshot-edit: %s\n%s" % (details, log))
def edit_net_xml(edit_cmd, expect_error, **dargs): """ Edit net xml with virsh net-edit :params edit_cmd: The edit cmd to execute :params expect_error: Boolean, expect success or not :params **dargs: The virsh edit's option """ logging.debug("edit_cmd: %s", edit_cmd) readonly = dargs.get("readonly", False) session = aexpect.ShellSession("sudo -s") try: logging.info("Execute virsh net-edit %s", net_name) virsh_cmd = "virsh net-edit %s" % net_name if readonly: virsh_cmd = "virsh -r net-edit %s" % net_name logging.debug("virsh_cmd: %s", virsh_cmd) session.sendline(virsh_cmd) session.sendline(edit_cmd) session.send('\x1b') session.send('ZZ') remote.handle_prompts(session, None, None, r"[\#\$]\s*$") session.close() except (aexpect.ShellError, aexpect.ExpectError, remote.LoginTimeoutError) as details: log = session.get_output() session.close() if not expect_error: test.fail("Failed to do net-edit: %s\n%s" % (details, log)) logging.debug("Expected error: %s" % log) if readonly and "read only" not in log: test.fail("Not expected error")
def virtio_serial_login(self, port='vs1'): error_context.context("Try to login guest via '%s'" % port, logging.info) username = self.params.get("username") password = self.params.get("password") prompt = self.params.get("shell_prompt", "[#$]") linesep = eval("'%s'" % self.params.get("shell_linesep", r"\n")) for vport in self.get_virtio_ports(self.vm)[1]: if vport.name == port: break vport = None if not vport: self.test.error("Not virtio serial port '%s' found" % port) logfile = "serial-%s-%s.log" % (vport.name, self.vm.name) socat_cmd = "nc -U %s" % vport.hostfile session = aexpect.ShellSession(socat_cmd, auto_close=False, output_func=utils_misc.log_line, output_params=(logfile, ), prompt=prompt) session.set_linesep(linesep) session.sendline() self.__sessions__.append(session) try: remote.handle_prompts(session, username, password, prompt, 180) self.test.fail("virtio serial '%s' should no " % port + "channel to login") except remote.LoginTimeoutError: self.__sessions__.append(session) logging.info("Can't login via %s" % port) return session
def edit_image_xml(): edit_cmd = r":%s /<boot dev='hd'\/>/<boot dev='cdrom'\/>" if restore_state == "running": option = "--running" elif restore_state == "paused": option = "--paused" else: raise error.TestFail("Unknown save-image-define option") session = aexpect.ShellSession("sudo -s") try: logging.info("Execute virsh save-image-edit %s %s", vm_save, option) session.sendline("virsh save-image-edit %s %s " % (vm_save, option)) logging.info("Replace '<boot dev='hd'/>' to '<boot dev='cdrom'/>'") session.sendline(edit_cmd) session.send('\x1b') session.send('ZZ') remote.handle_prompts(session, None, None, r"[\#\$]\s*$") session.close() except (aexpect.ShellError, aexpect.ExpectError), details: log = session.get_output() session.close() raise error.TestFail("Failed to do save-image-edit: %s\n%s" % (details, log))
def login(self, timeout=LOGIN_TIMEOUT): """ Log into the hypervisor using required URIs . @timeout: Time in seconds that we will wait before giving up on logging into the host. @return: A ShellSession object. """ if self.driver is None: uri = utils.system_output('%s uri' % self.virsh_exec) else: uri = "%s+ssh://%s@%s/system" % (self.driver, self.username, self.host) command = "%s --connect %s" % (self.virsh_exec, uri) session = aexpect.ShellSession(command, linesep=self.linesep, prompt=self.prompt) if self.username is not None: try: virt_utils._remote_login(session, self.username, self.password, self.prompt, timeout) except aexpect.ShellError: session.close() session = None return session
def remote_login(client, host, port, username, password, prompt, linesep="\n", log_filename=None, timeout=10, interface=None, status_test_command="echo $?"): """ Log into a remote host (guest) using SSH/Telnet/Netcat. :param client: The client to use ('ssh', 'telnet' or 'nc') :param host: Hostname or IP address :param port: Port to connect to :param username: Username (if required) :param password: Password (if required) :param prompt: Shell prompt (regular expression) :param linesep: The line separator to use when sending lines (e.g. '\\n' or '\\r\\n') :param log_filename: If specified, log all output to this file :param timeout: The maximal time duration (in seconds) to wait for each step of the login procedure (i.e. the "Are you sure" prompt or the password prompt) :interface: The interface the neighbours attach to (only use when using ipv6 linklocal address.) :param status_test_command: Command to be used for getting the last exit status of commands run inside the shell (used by cmd_status_output() and friends). :raise LoginError: If using ipv6 linklocal but not assign a interface that the neighbour attache :raise LoginBadClientError: If an unknown client is requested :raise: Whatever handle_prompts() raises :return: A ShellSession object. """ if host and host.lower().startswith("fe80"): if not interface: raise LoginError("When using ipv6 linklocal an interface must " "be assigned") host = "%s%%%s" % (host, interface) if client == "ssh": cmd = ("ssh -o UserKnownHostsFile=/dev/null " "-o StrictHostKeyChecking=no " "-o PreferredAuthentications=password -p %s %s@%s" % (port, username, host)) elif client == "telnet": cmd = "telnet -l %s %s %s" % (username, host, port) elif client == "nc": cmd = "nc %s %s" % (host, port) else: raise LoginBadClientError(client) logging.debug("Login command: '%s'", cmd) session = aexpect.ShellSession(cmd, linesep=linesep, prompt=prompt, status_test_command=status_test_command) try: handle_prompts(session, username, password, prompt, timeout) except Exception: session.close() raise if log_filename: session.set_output_func(utils_misc.log_line) session.set_output_params((log_filename,)) session.set_log_file(log_filename) return session
def _verify_multipathd_alive(): """ Verify whether multipathd statue is active, return bool value """ host_session = aexpect.ShellSession("sh") return utils_misc.get_guest_service_status( host_session, 'multipathd') == 'active'
def power_on(self): assert not self.is_on() self.monitor_socket = tempfile.mktemp() self.devices.add_qmp_monitor(self.monitor_socket) self._qmp = monitor.QEMUMonitorProtocol(self.monitor_socket, server=True) self.serial_socket = tempfile.mktemp() self.devices.add_serial(self.serial_socket) tmpl = self.params.get('contents', '/plugins/virt/qemu/template/*') if tmpl is None: cmdline = self.devices.get_cmdline() else: tags = self._template_build_tags() cmdline = self._template_apply(tmpl, tags) try: self._popen = process.SubProcess(cmd=cmdline) self.pid = self._popen.start() self._qmp.accept() self.serial_console = aexpect.ShellSession( "nc -U %s" % self.serial_socket, auto_close=False, output_func=genio.log_line, output_params=("serial-console-%s.log" % self.short_id,), prompt=self.params.get("shell_prompt", "/plugins/virt/guest/*", default="[\#\$]")) self._screendump_thread_start() finally: os.remove(self.monitor_socket)
def cmd_output(self, command, timeout=60): """ Get output from shell session. If the create flag is True, init the shell session and set the create flag to False. :param command: command to execute in qemu-io :param timeout: timeout for execute the command """ qemu_io_cmd = self.qemu_io_cmd prompt = self.prompt output_func = self.output_func output_params = self.output_params output_prefix = self.output_prefix if self.create_session: error.context("Running command: %s" % qemu_io_cmd, self.log_func) self.session = aexpect.ShellSession(qemu_io_cmd, echo=True, prompt=prompt, output_func=output_func, output_params=output_params, output_prefix=output_prefix) # Record the command line in log file if self.output_func: params = self.output_params + (qemu_io_cmd, ) self.output_func(*params) self.create_session = False # Get the reaction from session self.session.cmd_output("\n") error.context("Executing command: %s" % command, self.log_func) return self.session.cmd_output(command, timeout=timeout)
def test_data_transfer(dev_type): """ Test data transfer between guest and host via console/serial device :param dev_type: The device type to be tested, console or channel """ vmxml = vm_xml.VMXML.new_from_dumpxml(vm_name) console_xml = vmxml.xmltreefile.find('devices').find(dev_type) host_path = console_xml.find('source').get('path') guest_path = '/dev/hvc0' if dev_type == 'console' else '/dev/vport0p1' test_message = 'virtiochannel' cat_cmd = "cat %s" % host_path logfile = "test_data_transfer-%s.log" % dev_type host_process = aexpect.ShellSession(cat_cmd, auto_close=False, output_func=utils_misc.log_line, output_params=(logfile, )) guest_session = vm.wait_for_login() guest_session.cmd_output('echo %s > %s' % (test_message, guest_path)) guest_session.close() try: host_process.read_until_last_line_matches(test_message, timeout=10) except aexpect.exceptions.ExpectError as e: test.fail('Did not catch the expected output from host side,' ' the detail of the failure: %s' % str(e)) finally: host_process.close()
def runServer(hostfile, urifile): global session try: server_count = len(genio.read_all_lines(hostfile)) initial_cmd = "/bin/bash" server_cmd = "/home/skirvan/daos_m10/install/bin/orterun --np {0} ".format( server_count) server_cmd += "--hostfile {0} --enable-recovery ".format(hostfile) server_cmd += "--report-uri {0} -x DD_LOG=/mnt/shared/test/tmp/daos.log ".format( urifile) server_cmd += "-x LD_LIBRARY_PATH=/home/skirvan/daos_m10/install/lib:/home/skirvan/daos_m10/install/lib/daos_srv " server_cmd += "/home/skirvan/daos_m10/install/bin/daos_server -g daos_server" print "Start CMD>>>>{0}".format(server_cmd) session = aexpect.ShellSession(initial_cmd) if (session.is_responsive()): session.sendline(server_cmd) session.read_until_any_line_matches( "DAOS server (v0.0.2) started on rank 0*", print_func=printFunc) print "<SERVER> server started" except Exception as e: print "<SERVER> Exception occurred: {0}".format(str(e)) raise ServerFailed("Server didn't start!")
def setup_remote_ssh_key(hostname1, user1, password1, hostname2=None, user2=None, password2=None, port=22, config_options=None, public_key="rsa"): """ Setup up remote to remote login in another server by using public key If hostname2 is not supplied, setup to local. :param hostname1: the server wants to login other host :param hostname2: the server to be logged in :type hostname: str :param user: user to login :type user: str :param password: password :type password: str :param port: port number :type port: int :param config_options: list of options eg: ["StrictHostKeyChecking=no"] :type config_options: list of str """ LOG.debug('Performing SSH key setup on %s:%d as %s.' % (hostname1, port, user1)) try: session1 = remote.remote_login(client='ssh', host=hostname1, port=port, username=user1, password=password1, prompt=r'[$#%]') public_key = get_remote_public_key(session1, public_key=public_key) if hostname2 is None: # Simply create a session to local session2 = aexpect.ShellSession("sh", linesep='\n', prompt='#') # set config in local machine if config_options: for each_option in config_options: session2.cmd_output("echo '%s' >> ~/.ssh/config" % each_option) else: session2 = remote.remote_login(client='ssh', host=hostname2, port=port, username=user2, password=password2, prompt=r'[$#%]') # set config in remote machine if config_options: for each_option in config_options: session1.cmd_output("echo '%s' >> ~/.ssh/config" % each_option) session2.cmd_output('mkdir -p ~/.ssh') session2.cmd_output('chmod 700 ~/.ssh') session2.cmd_output("echo '%s' >> ~/.ssh/authorized_keys; " % public_key) session2.cmd_output('chmod 600 ~/.ssh/authorized_keys') LOG.debug('SSH key setup on %s complete.', session2) except Exception as err: LOG.debug('SSH key setup has failed: %s', err) try: session1.close() session2.close() except Exception: pass
def remote_login(client, host, port, username, password, prompt, linesep="\n", log_filename=None, timeout=10, interface=None): """ log into a remote host(guest) using SSH/Telnet/Netcat. :param client: the client to use ('ssh', 'telnet' or the other nc) :param host: Hostname or IP address :param username: Username (if required) :param password: Password (if required) :param prompt: shell prompt (regular expression) :param linesep: The line separator to use when sending lines (e.g. '\\n' or '\\r\\n') :param log_filename: if specified, log all output to this file :param timeout: the maximal time duration (in seconds) to wait for each step of the login procedure :interface: The interface the neighbours attach to (only use when using the ipv6 linklocal address.) :raise LoginError: If using ipv6 linklocal but not assign a interface that the neighbour attache :raise LoginBadClientError: If an unknown client is requested :raise Whatever handle_prompts() raises :return: A ShellSession object """ if host and host.lower.startswith("fe800"): if not interface: raise LoginError( "When using ipv6 linklocal an interface must be assigned") host = "%s%%%s" % (host, interface) if client == "ssh": cmd = ( "ssh -o UserKnownHostsFile=/dev/null -o PreferredAuthentications=password " "-p %s %s@%s " % (port, username, host)) elif client == "telnet": cmd = "telent -l %s %s %s" % (username, host, port) else: raise LoginBadClientError(client) logging.debug("Login Command: '%s'", cmd) # need to realize the aexpect.ShellSession session = aexpect.ShellSession(cmd, linesep=linesep, prompt=prompt) try: handle_prompts(session, username, password, prompt, timeout) except Exception: session.close() raise if log_filename: session.set_output_func(utils.log_line) session.set_output_params((log_filename, )) session.set_log_file(log_filename) return session
def remote_login(client, host, src, params_login, host_ip): src_name = src if src != "localhost": src_name = src.name logging.info("Login %s from %s" % (host, src_name)) port = params_login["target_port"] username = params_login["username"] password = params_login["password"] prompt = params_login["shell_prompt"] linesep = eval("'%s'" % params_login.get("shell_linesep", r"\n")) quit_cmd = params.get("quit_cmd", "exit") if host == host_ip: # Try to login from guest to host. prompt = r"^\[.*\][\#\$]\s*$" linesep = "\n" username = params_login["host_username"] password = params_login["host_password"] quit_cmd = "exit" if client == "ssh": # We only support ssh for Linux in this test cmd = ("ssh -o UserKnownHostsFile=/dev/null " "-o StrictHostKeyChecking=no " "-o PreferredAuthentications=password -p %s %s@%s" % (port, username, host)) elif client == "telnet": cmd = "telnet -l %s %s %s" % (username, host, port) else: raise remote.LoginBadClientError(client) if src == "localhost": logging.debug("Login with command %s" % cmd) session = aexpect.ShellSession(cmd, linesep=linesep, prompt=prompt) else: if params_login.get("os_type") == "windows": if client == "telnet": cmd = "C:\\telnet.py %s %s " % (host, username) cmd += "%s \"%s\" && " % (password, prompt) cmd += "C:\\wait_for_quit.py" cmd = "%s || ping 127.0.0.1 -n 5 -w 1000 > nul" % cmd else: cmd += " || sleep 5" session = src.wait_for_login() logging.debug("Sending login command: %s" % cmd) session.sendline(cmd) try: out = remote.handle_prompts(session, username, password, prompt, timeout, debug=True) except Exception as err: session.close() raise err try: session.cmd(quit_cmd) session.close() except Exception: pass return out
def create_isula_shellsession(self, name): """Create session to isula container""" self.isula_session = aexpect.ShellSession( "isula exec -ti %s sh" % name, auto_close=False, output_func=LOG.debug, prompt=r"[\#\$]", status_test_command="echo $?") return self.isula_session
def run(test, params, env): """ Test virsh nwfilter-edit with uuid. 1) Prepare parameters. 2) Run nwfilter-edit command. 3) Check result. 4) Clean env """ # Prepare parameters filter_name = params.get("edit_filter_name", "") status_error = params.get("status_error", "no") new_uuid = "11111111-1111-1111-1111-111111111111" edit_cmd = ":2s/<uuid>.*$/<uuid>%s<\/uuid>/" % new_uuid # Since commit 46a811d, the logic changed for not allow update filter # uuid, so decide status_error with libvirt version. if libvirt_version.version_compare(1, 2, 7): status_error = True else: status_error = False # Backup filter xml new_filter = libvirt_xml.NwfilterXML() filterxml = new_filter.new_from_filter_dumpxml(filter_name) logging.debug("the filter xml is: %s" % filterxml.xmltreefile) try: # Run command session = aexpect.ShellSession("sudo -s") try: session.sendline("virsh nwfilter-edit %s" % filter_name) session.sendline(edit_cmd) # Press ESC session.send('\x1b') # Save and quit session.send('ZZ') remote.handle_prompts(session, None, None, r"[\#\$]\s*$") session.close() if not status_error: logging.info("Succeed to do nwfilter edit") else: test.fail("edit uuid should fail but got succeed.") except (aexpect.ShellError, aexpect.ExpectError, remote.LoginTimeoutError) as details: log = session.get_output() session.close() if "Try again? [y,n,f,?]:" in log and status_error: logging.debug("edit uuid failed as expected.") else: test.fail("Failed to do nwfilter-edit: %s\n%s" % (details, log)) finally: # Clean env virsh.nwfilter_undefine(filter_name, debug=True) virsh.nwfilter_define(filterxml.xml, debug=True)
def setup_remote_ssh_key(hostname1, user1, password1, hostname2=None, user2=None, password2=None, port=22): ''' Setup up remote to remote login in another server by using public key If hostname2 is not supplied, setup to local. :param hostname1: the server wants to login other host :param hostname2: the server to be logged in :type hostname: str :param user: user to login :type user: str :param password: password :type password: str :param port: port number :type port: int ''' logging.debug('Performing SSH key setup on %s:%d as %s.' % (hostname1, port, user1)) try: session1 = remote.remote_login(client='ssh', host=hostname1, port=port, username=user1, password=password1, prompt=r'[$#%]') public_key = get_remote_public_key(session1) if hostname2 is None: # Simply create a session to local session2 = aexpect.ShellSession("sh", linesep='\n', prompt='#') else: session2 = remote.remote_login(client='ssh', host=hostname2, port=port, username=user2, password=password2, prompt=r'[$#%]') session2.cmd_output('mkdir -p ~/.ssh') session2.cmd_output('chmod 700 ~/.ssh') session2.cmd_output("echo '%s' >> ~/.ssh/authorized_keys; " % public_key) session2.cmd_output('chmod 600 ~/.ssh/authorized_keys') logging.debug('SSH key setup on %s complete.', session2) except Exception as err: logging.debug('SSH key setup has failed: %s', err) try: session1.close() session2.close() except Exception: pass
def create_serial_control(self): """Create serial control""" self._wait_console_create() self.serial_console = aexpect.ShellSession( "/usr/bin/nc -U %s" % self._console_address, auto_close=False, output_func=self.serial_log.debug, prompt=r"[\#\$]", status_test_command="echo $?") self.console_manager.config_console(self.serial_console)
def check_disconnect_on_shutdown(command, status_error, login_user, login_passwd, test): """ Test whether an active console will disconnect after shutting down the VM. :param command: Test command without --force option :param status_error: Whether the command is fault. :param login_user: User name for logging into the VM. :param login_passwd: Password for logging into the VM. :param test: Test Object """ session = aexpect.ShellSession(command) if not status_error: log = "" console_cmd = "shutdown -h now" try: while True: match, text = session.read_until_last_line_matches( [ r"[E|e]scape character is", r"login:"******"[P|p]assword:", session.prompt ], 10, internal_timeout=1) if match == 0: logging.debug("Got '^]', sending '\\n'") session.sendline() elif match == 1: logging.debug("Got 'login:'******'%s'", login_user) session.sendline(login_user) elif match == 2: logging.debug("Got 'Password:'******'%s'", login_passwd) session.sendline(login_passwd) elif match == 3: logging.debug("Got Shell prompt -- logged in") break session.cmd_output(console_cmd) # On newer OS like RHEL7, 'shutdown -h now' will not exit before # machine shutdown. But on RHEL6, 'shutdown -h now' will exit and # allow user to execute another command. This next command will not # exit before machine shutdown. session.cmd_output("echo $?") session.close() test.error('Do not expect any command can be executed ' 'after successfully shutdown') except (aexpect.ShellError, aexpect.ExpectError) as detail: if 'Shell process terminated' not in str(detail): test.fail('Expect shell terminated, but found %s' % detail) log = session.get_output() logging.debug("Shell terminated on VM shutdown:\n%s\n%s", detail, log) session.close()
def add_running_host(self, log, remote_ip, password): cmd = "ssh-copy-id -i ~/.ssh/id_rsa.pub -o StrictHostKeyChecking=" \ "no root@%s" % remote_ip session = aexpect.ShellSession(cmd, prompt="password:"******"password:"******"Done")
def _start_remote(self): address, port, username, password, prompt = self._remote_opts cmd = "%s %s" % (self.command, self.options) logging.debug("Run '%s' on host '%s'", cmd, address) login_cmd = ("ssh -o UserKnownHostsFile=/dev/null " "-o StrictHostKeyChecking=no " "-o PreferredAuthentications=password -p %s %s@%s" % (port, username, address)) self._process = aexpect.ShellSession( login_cmd, output_func=self._output_logger_handler) handle_prompts(self._process, username, password, prompt) self._process.sendline(cmd)
def check_vm_network_accessed(vm_session, expected_iface_no=3, ping_dest="8.8.8.8", timeout=30, tcpdump_iface=None, tcpdump_status_error=False): """ Test VM's network by checking ifaces' number and the accessibility :param vm_session: The session object to the guest :param expected_iface_no: The expected number of ifaces :param ping_dest: The destination to be ping :param timeout: The timeout of the checking :param tcpdump_iface: The interface to check :param tcpdump_status_error: Whether the tcpdump's output should include the string "ICMP echo request" :raise: test.fail when ifaces' number is incorrect or ping fails. """ if not utils_misc.wait_for( lambda: check_vm_iface_num(vm_session, expected_iface_no), first=3, timeout=timeout): test.fail("%d interfaces should be found on the vm." % expected_iface_no) if tcpdump_iface: cmd = "tcpdump -i %s icmp" % tcpdump_iface tcpdump_session = aexpect.ShellSession('bash') tcpdump_session.sendline(cmd) if not utils_misc.wait_for( lambda: not utils_test.ping(ping_dest, count=3, timeout=5, output_func=logging.debug, session=vm_session)[0], first=5, timeout=timeout): test.fail("Failed to ping %s." % ping_dest) if tcpdump_iface: output = tcpdump_session.get_stripped_output() logging.debug("tcpdump's output: %s.", output) pat_str = "ICMP echo request" if re.search(pat_str, output): if tcpdump_status_error: test.fail( "Get incorrect tcpdump output: {}, it should not " "include '{}'.".format(output, pat_str)) else: if not tcpdump_status_error: test.fail("Get incorrect tcpdump output: {}, it should " "include '{}'.".format(output, pat_str))
def start_avahi_autoipd(self): """ Start avahi-autoipd on veth0 verify ip by logging in with the ip and check using ip command """ subprocess.Popen("avahi-autoipd veth0 1>%s/out 2>%s/err &" % (self.tmpdir, self.tmpdir), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) time.sleep(15) result = open("%s/err" % self.tmpdir, "r").readlines() for line in result: if "Successfully claimed IP address" in line: self.ip_addr = line.split()[-1] if self.ip_addr is None: self.nfail += 1 raise error.TestError('\n avahi-autoipd failed to assign veth0 ip') else: logging.info('\nIP assigned is %s' % self.ip_addr) pass_word = utils.system_output("openssl passwd -crypt password") utils.system("useradd testuser -p %s" % pass_word) p = aexpect.ShellSession("ssh testuser@%s" % self.ip_addr) time.sleep(5) if "Are you sure you want to continue connecting" in p.get_output(): p.sendline("yes") time.sleep(5) if "password:"******"password") else: raise error.TestError( '\n Failed to login giving password to avahi-autoipd ip') elif "password:"******"password") else: print p.get_output() raise error.TestError('\n Failed to login to avahi-autoipd ip') print p.get_output() status, output = p.get_command_status_output( "ip addr show veth0|grep -w inet") if self.ip_addr not in output: self.nfail += 1 raise error.TestError('\n avahi-autoipd failed to assign valid ip') p.close()
def remote_login(client, host, port, username, password, prompt, linesep="\n", log_filename=None, timeout=10): """ Log into a remote host (guest) using SSH/Telnet/Netcat. :param client: The client to use ('ssh', 'telnet' or 'nc') :param host: Hostname or IP address :param port: Port to connect to :param username: Username (if required) :param password: Password (if required) :param prompt: Shell prompt (regular expression) :param linesep: The line separator to use when sending lines (e.g. '\\n' or '\\r\\n') :param log_filename: If specified, log all output to this file :param timeout: The maximal time duration (in seconds) to wait for each step of the login procedure (i.e. the "Are you sure" prompt or the password prompt) :raise LoginBadClientError: If an unknown client is requested :raise: Whatever handle_prompts() raises :return: A ShellSession object. """ if client == "ssh": cmd = ("ssh -o UserKnownHostsFile=/dev/null " "-o PreferredAuthentications=password -p %s %s@%s" % (port, username, host)) elif client == "telnet": cmd = "telnet -l %s %s %s" % (username, host, port) elif client == "nc": cmd = "nc %s %s" % (host, port) else: raise LoginBadClientError(client) logging.debug("Login command: '%s'", cmd) session = aexpect.ShellSession(cmd, linesep=linesep, prompt=prompt) try: handle_prompts(session, username, password, prompt, timeout) except Exception: session.close() raise if log_filename: session.set_output_func(utils_misc.log_line) session.set_output_params((log_filename, )) session.set_log_file(log_filename) return session