1

2

3

4

download pexpect-2.3.tar.gz

tar zxvf pexpect-2.3.tar.g

cd pexpect-2.3

python setup.py install  (do this as root)

1

2

run(command,timeout=-1,withexitstatus=False,events=None,\

extra_args=None,logfile=None, cwd=None, env=None)

1

2

from pexpect import *

run ("svn ci -m 'automatic commit' my_file.py")

1

2

from pexpect import *

(command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)

1

2

3

class spawn:

def __init__(self,command,args=[],timeout=30,maxread=2000,\

searchwindowsize=None, logfile=None, cwd=None, env=None)

1

2

3

child = pexpect.spawn ('/usr/bin/ftp') #執行ftp客戶端命令

child = pexpect.spawn ('/usr/bin/ssh [email protected]') #使用ssh登入目標機器

child = pexpect.spawn ('ls -latr /tmp') #顯示 /tmp目錄內容

1

2

3

child = pexpect.spawn ('/usr/bin/ftp', [])

child = pexpect.spawn ('/usr/bin/ssh', ['[email protected]'])

child = pexpect.spawn ('ls', ['-latr', '/tmp'])

1

2

3

child = pexpect.spawn('some_command')

fout = file('mylog.txt','w')

child.logfile = fout

1

2

child = pexpect.spawn('some_command')

child.logfile = sys.stdout

1

2

child = pexpect.spawn('some_command')

child.logfile_send = sys.stdout

1

expect(self, pattern, timeout=-1, searchwindowsize=None)

1

2

3

4

5

6

7

8

while True:

index = child.expect(["suc","fail",pexpect.TIMEOUT])

if index == 0:

break

elif index == 1:

return False

elif index == 2:

pass        #continue to wait

1

2

3

4

5

6

7

8

9

10

try:

index = pexpect (['good', 'bad'])

if index == 0:

do_something()

elif index == 1:

do_something_else()

except EOF:

do_some_other_thing()

except TIMEOUT:

do_something_completely_different()

1

2

3

4

5

6

7

8

9

index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])

if index == 0:

do_something()

elif index == 1:

do_something_else()

elif index == 2:

do_some_other_thing()

elif index == 3:

do_something_completely_different()

1

2

3

child = pexpect.spawn('/bin/ls /')

child.expect (pexpect.EOF)

print child.before

1

2

3

send(self, s)

sendline(self, s='')

sendcontrol(self, char)

1

child.sendcontrol('c')

1

interact(self, escape_character = chr(29), input_filter = None, output_filter = None)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

# This connects to the openbsd ftp site and

# downloads the README file.

import pexpect

child = pexpect.spawn ('ftp ftp.openbsd.org')

child.expect ('Name .*: ')

child.sendline ('anonymous')

child.expect ('Password:')

child.sendline ('[email protected]')

child.expect ('ftp> ')

child.sendline ('cd pub/OpenBSD')

child.expect('ftp> ')

child.sendline ('get README')

child.expect('ftp> ')

child.sendline ('bye')

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

import re,sys,os

from pexpect import *

def telnet_login(server,user, passwd,shell_prompt= “#|->”): 

""" 

@summary: This logs the user into the given server.

It uses the 'shell_prompt' to try to find the prompt right after login.

When it finds the prompt it immediately tries to reset the prompt to '#UNIQUEPROMPT#'

more easily matched. 

@return: If Login successfully ,It will return a pexpect object   

@raise exception: RuntimeError will be raised when the cmd telnet failed or the user

and passwd do not match 

@attention:1. shell_prompt should not include '$',on some server, after sendline

(passwd)   the pexpect object will read a '$'. 

2.sometimes the server's output before its shell prompt will contain '#' or

'->'  So the caller should kindly assign the shell prompt 

""" 

if not server or not user \ 

or not passwd or not shell_prompt: 

raise RuntimeError, "You entered empty parameter for telnet_login " 

child = pexpect.spawn('telnet %s' % server) 

child.logfile_read = sys.stdout 

index = child.expect (['(?i)login:', '(?i)username', '(?i)Unknown host']) 

if index == 2: 

raise RuntimeError, 'unknown machine_name' + server 

child.sendline (user) 

child.expect ('(?i)password:') 

child.logfile_read = None  # To turn off log

child.sendline (passwd) 

while True: 

index = child.expect([pexpect.TIMEOUT,shell_prompt]) 

child.logfile_read = sys.stdout 

if index == 0: 

if re.search('an invalid login', child.before): 

raise RuntimeError, 'You entered an invalid login name or password.'

elif index == 1: 

break     

child.logfile_read = sys.stdout # To tun on log again

child.sendline(“PS1=#UNIQUEPROMPT#”) 

#This is very crucial to wait for PS1 has been modified successfully 

#child.expect(“#UNIQUEPROMPT#”) 

child.expect("%s.+%s" % (“#UNIQUEPROMPT#”, “#UNIQUEPROMPT#”)) 

return child

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

import pxssh 

import getpass 

try:

s = pxssh.pxssh()

hostname = raw_input('hostname: ') 

username = raw_input('username: ') 

password = getpass.getpass('password: ') 

s.login (hostname, username, password) 

s.sendline ('uptime')  # run a command 

s.prompt()             # match the prompt 

print s.before         # print everything before the propt. 

s.sendline ('ls -l') 

s.prompt()

print s.before 

s.sendline ('df') 

s.prompt()

print s.before 

s.logout()

except pxssh.ExceptionPxssh, e: 

print "pxssh failed on login."

print str(e)

1

2

3

shell_cmd = 'ls -l | grep LOG > log_list.txt'

child = pexpect.spawn('/bin/bash', ['-c', shell_cmd])

child.expect(pexpect.EOF)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

use threads;

use Expect; 

$timeout = 5; 

my $thr = threads->create(\&sub1(first_server)); 

my $thr2 = threads->create(\&sub1(second_server)); 

sub sub1 

{ 

my $exp = new Expect; 

$exp -> raw_pty(1); 

$exp -> spawn ("telnet",$_[0]) or die "cannot access telnet";

$exp -> expect ( $timeout, -re=>'[Ll]ogin:' ); 

$exp -> send ( "user\n"); 

$exp -> expect ( $timeout, -re=>'[Pp]assword:' ); 

$exp -> send ( "password\n" ); 

$exp -> expect ( $timeout, -re=>" #" ); 

$exp -> send ( "date\n" );

$exp -> expect ( $timeout, -re=>'\w\w\w \w\w\w \d{1,2}

\d\d:\d\d:\d\d \w\w\w \d\d\d\d'); 

$localtime=$exp->match();

print "\tThe first server’s time is : $localtime\n"; 

$exp -> soft_close ();

} 

print "This is the main thread!"; 

$thr->join();

$thr2->join();

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

import sys,os 

from Login import *

PROMPT = “#UNIQUEPROMPT#”

class RefreshKernelThreadClass(threading.Thread): 

""" The thread to downLoad the kernel and install it on a new server  """

def __init__(self,server_name,user,passwd): 

threading.Thread.__init__(self) 

self.server_name_ = server_name 

self.user_ = user 

self.passwd_ = passwd 

self.result_ = [] # the result information of the thread

def run(self): 

self.setName(self.server_name_) # set the name of thread

try: 

#call the telnet_login to access the server through telnet

child = telnet_login(self.server_name_,self.user_, self.passwd_) 

except RuntimeError,ex: 

info = "telnet to machine %s failed with reason %s" % (self.server_name_, ex)

self.result_.=(False, self.server_name_+info)

return self.result_  

child.sendline(' cd ~/Download/dw_test && \

wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.28.tar.gz && \

tar zxvf linux-2.6.28.tar.gz && \

cd linux-2.6.28 \

&& make mrproper && make allyesconfig and make -j 4 && make modules && \

make modules install && make install') 

# wail these commands finish

while True:

index = child.expect([PROMPT,pexpect.TIMEOUT,pexpect.EOF]) 

if index == 0:

break

elif index == 1:

pass

elif index ==2 :

self.result_=(False,'Sub process exit abnormally ')

return False

# reboot the server

child.sendline('shutdown -Fr') 

child.expect('\r\n') 

retry_times = 10

while retry_times > 0:  

index_shutdown = child.expect(["Unmounting the file systems",

pexpect.EOF, 

pexpect.TIMEOUT]) 

if index_shutdown == 0 or index_shutdown == 1 : 

break 

elif index_shutdown == 2:

retry_times = retry_times-1

if retry_times == 0: 

self.result_=(False,'Cannot shutdown ') 

return self.result_

def refresh_kernel(linux_server_list,same_user,same_passwd): 

""" 

@summary: The function is used to work on different linux servers to download

the same version linux kernel, conpile them and reboot all these servers 

To keep it simple we use the same user id and password on these servers   

""" 

if not type(linux_server_list) == list:

return (False,"Param %s Error!"%linux_server_list) 

if same_user is None or same_passwd is None or not 

type(same_user)== str or not type(same_passwd) == str: 

return (False,"Param Error!")

thread_list = []

# start threads to execute command on the remote servers

for i in range (len(linux_server_list)): 

thread_list[i] = RefreshKernelThreadClass(linux_server_list[i],

same_user,same_passwd)

thread_list[i].start()

# wait the threads finish

for i in range (len(linux_server_list)): 

thread_list[i].join()

# validate the result

for i in range (len(linux_server_list)): 

if thread_list[0].result_[0] == False: 

return False

else:

return True

if __name__ == "__main__":

refresh_kernel(server_list,"test_user","test_passwd")