|
概述 |
例 1：ftp 的使用
本例实现了如下功能：ftp 登录到 develperWorks.ibm.com 主机上，并用二进制传输模式下载一个名叫 rmall的文件。
#!/usr/bin/env python
import pexpect
# 即将 ftp 所要登录的远程主机的域名
ipAddress = 'develperWorks.ibm.com'
# 登录用户名
loginName = 'root'
# 用户名密码
loginPassword = 'passw0rd'
# 拼凑 ftp 命令
cmd = 'ftp ' + ipAddress
# 利用 ftp 命令作为 spawn 类构造函数的参数，生成一个 spawn 类的对象
child = pexpect.spawn(cmd)
# 期望具有提示输入用户名的字符出现
index = child.expect(["(?i)name", "(?i)Unknown host", pexpect.EOF, pexpect.TIMEOUT])
# 匹配到了 "(?i)name"，表明接下来要输入用户名
if ( index == 0 ):
# 发送登录用户名 + 换行符给子程序.
child.sendline(loginName)
# 期望 "(?i)password" 具有提示输入密码的字符出现.
index = child.expect(["(?i)password", pexpect.EOF, pexpect.TIMEOUT])
# 匹配到了 pexpect.EOF 或 pexpect.TIMEOUT，表示超时或者 EOF，程序打印提示信息并退出.
if (index != 0):
print "ftp login failed"
child.close(force=True)
# 匹配到了密码提示符，发送密码 + 换行符给子程序.
child.sendline(loginPassword)
# 期望登录成功后，提示符 "ftp>" 字符出现.
index = child.expect( ['ftp>', 'Login incorrect', 'Service not available',
pexpect.EOF, pexpect.TIMEOUT])
# 匹配到了 'ftp>'，登录成功.
if (index == 0):
print 'Congratulations! ftp login correct!'
# 发送 'bin'+ 换行符给子程序，表示接下来使用二进制模式来传输文件.
child.sendline("bin")
print 'getting a file...'
# 向子程序发送下载文件 rmall 的命令.
child.sendline("get rmall")
# 期望下载成功后，出现 'Transfer complete.*ftp>'，其实下载成功后,
# 会出现以下类似于以下的提示信息:
# 200 PORT command successful.
# 150 Opening data connection for rmall (548 bytes).
# 226 Transfer complete.
# 548 bytes received in 0.00019 seconds (2.8e+03 Kbytes/s)
# 所以直接用正则表达式 '.*' 将 'Transfer complete' 和提示符 'ftp>' 之间的字符全省去.
index = child.expect( ['Transfer complete.*ftp>', pexpect.EOF, pexpect.TIMEOUT] )
# 匹配到了 pexpect.EOF 或 pexpect.TIMEOUT，表示超时或者 EOF，程序打印提示信息并退出.
if (index != 0):
print "failed to get the file"
child.close(force=True)
# 匹配到了 'Transfer complete.*ftp>'，表明下载文件成功，打印成功信息，并输入 'bye'，结束 ftp session.
print 'successfully received the file'
child.sendline("bye")
# 用户名或密码不对，会先出现 'Login incorrect'，然后仍会出现 'ftp>'，但是 pexpect 是最小匹配，不是贪婪匹配,
# 所以如果用户名或密码不对，会匹配到 'Login incorrect'，而不是 'ftp>'，然后程序打印提示信息并退出.
elif (index == 1):
print "You entered an invalid login name or password. Program quits!"
child.close(force=True)
# 匹配到了 'Service not available'，一般表明 421 Service not available, remote server has
# closed connection，程序打印提示信息并退出.
# 匹配到了 pexpect.EOF 或 pexpect.TIMEOUT，表示超时或者 EOF，程序打印提示信息并退出.
else:
print "ftp login failed! index = " + index
child.close(force=True)
# 匹配到了 "(?i)Unknown host"，表示 server 地址不对，程序打印提示信息并退出
elif index == 1 :
print "ftp login failed, due to unknown host"
child.close(force=True)
# 匹配到了 pexpect.EOF 或 pexpect.TIMEOUT，表示超时或者 EOF，程序打印提示信息并退出
else:
print "ftp login failed, due to TIMEOUT or EOF"
child.close(force=True)
|
注： 本例 expect 函数中的 pattern 使用了 List，并包含了 pexpect.EOF和pexpect.TIMEOUT，这样出现了超时或者 EOF，不会抛出 expection 。（关于 expect() 函数的具体使用，请参阅参考资料） |
|
例 2：记录 log |
#!/usr/bin/env python """ This run a user specified command and log its result. ./command.py [-a] [-c command] {logfilename} logfilename : This is the name of the log file. Default is command.log. -a : Append to log file. Default is to overwrite log file. -c : spawn command. Default is the command 'ls -l'. Example: This will execute the command 'pwd' and append to the log named my_session.log: ./command.py -a -c 'pwd' my_session.log """ import os, sys, getopt import traceback import pexpect # 如果程序中间出错，打印提示信息后退出 def exit_with_usage(): print globals()['__doc__'] os._exit(1) def main(): ###################################################################### # Parse the options, arguments, get ready, etc. ###################################################################### try: optlist, args = getopt.getopt(sys.argv[1:], 'h?ac:', ['help','h','?']) # 如果指定的参数不是’ -a ’ , ‘ -h ’ , ‘ -c ’ , ‘ -? ’ , ‘ --help ’ , #‘ --h ’或’ --? ’时，会抛出 exception, # 这里 catch 住，然后打印出 exception 的信息，并输出 usage 提示信息. except Exception, e: print str(e) exit_with_usage() options = dict(optlist) # 最多只能指定一个 logfile，否则出错. if len(args) > 1: exit_with_usage() # 如果指定的是 '-h','--h','-?','--?' 或 '--help'，只输出 usage 提示信息. if [elem for elem in options if elem in ['-h','--h','-?','--?','--help']]: print "Help:" exit_with_usage() # 获取 logfile 的名字. if len(args) == 1: script_filename = args[0] else: # 如果用户没指定，默认 logfile 的名字是 command.log script_filename = "command.log" # 如果用户指定了参数 -a，如果之前该 logfile 存在，那么接下来的内容会附加在原先内容之后, # 如果之前没有该 logfile，新建一个文件，并且接下来将内容写入到该文件中. if '-a' in options: fout = open (script_filename, "ab") else: # 如果用户没指定参数 -a，默认按照用户指定 logfile 文件名新建一个文件，然后将接下来将内容写入到该文件中. fout = open (script_filename, "wb") # 如果用户指定了 -c 参数，那么运行用户指定的命令. if '-c' in options: command = options['-c'] # 如果用户没有指定 -c 参数，那么默认运行命令'ls – l' else: command = "ls -l" # logfile 文件的 title fout.write ('==========Log Tile: IBM developerWorks China==========\n') # 为接下来的运行命令生成一个 pexpect 的 spawn 类子程序的对象. p = pexpect.spawn(command) # 将之前 open 的 file 对象指定为 spawn 类子程序对象的 log 文件. p.logfile = fout # 命令运行完后，expect EOF 出现，这时会将 spawn 类子程序对象的输出写入到 log 文件. p.expect(pexpect.EOF) #open 完文件，使用完毕后，需关闭该文件. fout.close() return 0 if __name__ == "__main__": try: main() except SystemExit, e: raise e except Exception, e: print "ERROR" print str(e) traceback.print_exc() os._exit(1)
|
注： logfile：
运行该脚本后，你会发现其实 log.txt 是空的，没有记录 ls -l 命令的内容，原因是没有调用 send 或 read_nonblocking，真正的内容没有被 flush 到 log 中。如果在 fout.close() 之前加上 p.expect(pexpect.EOF)，log.txt 才会有 ls -l 命令的内容。 |
|
本例实现了如下功能：ssh 登录到某个用户指定的主机上，运行某个用户指定的命令，并输出该命令的结果。 |
#!/usr/bin/env python """ This runs a command on a remote host using SSH. At the prompts enter hostname, user, password and the command. """ import pexpect import getpass, os #user: ssh 主机的用户名 #host：ssh 主机的域名 #password：ssh 主机的密码 #command：即将在远端 ssh 主机上运行的命令 def ssh_command (user, host, password, command): """ This runs a command on the remote host. This could also be done with the pxssh class, but this demonstrates what that class does at a simpler level. This returns a pexpect.spawn object. This handles the case when you try to connect to a new host and ssh asks you if you want to accept the public key fingerprint and continue connecting. """ ssh_newkey = 'Are you sure you want to continue connecting' # 为 ssh 命令生成一个 spawn 类的子程序对象. child = pexpect.spawn('ssh -l %s %s %s'%(user, host, command)) i = child.expect([pexpect.TIMEOUT, ssh_newkey, 'password: ']) # 如果登录超时，打印出错信息，并退出. if i == 0: # Timeout print 'ERROR!' print 'SSH could not login. Here is what SSH said:' print child.before, child.after return None # 如果 ssh 没有 public key，接受它. if i == 1: # SSH does not have the public key. Just accept it. child.sendline ('yes') child.expect ('password: ') i = child.expect([pexpect.TIMEOUT, 'password: ']) if i == 0: # Timeout print 'ERROR!' print 'SSH could not login. Here is what SSH said:' print child.before, child.after return None # 输入密码. child.sendline(password) return child def main (): # 获得用户指定 ssh 主机域名. host = raw_input('Hostname: ') # 获得用户指定 ssh 主机用户名. user = raw_input('User: ') # 获得用户指定 ssh 主机密码. password = getpass.getpass() # 获得用户指定 ssh 主机上即将运行的命令. command = raw_input('Enter the command: ') child = ssh_command (user, host, password, command) # 匹配 pexpect.EOF child.expect(pexpect.EOF) # 输出命令结果. print child.before if __name__ == '__main__': try: main() except Exception, e: print str(e) traceback.print_exc() os._exit(1)
|
注：
|
|
本例实现了如下功能：使用 pexpect 自带的 pxssh 模块实现 ssh 登录到某个用户指定的主机上，运行命令’ uptime ’和’ ls -l ’，并输出该命令的结果。 |
#!/usr/bin/env python import pxssh import getpass try: # 调用构造函数，创建一个 pxssh 类的对象. s = pxssh.pxssh() # 获得用户指定 ssh 主机域名. hostname = raw_input('hostname: ') # 获得用户指定 ssh 主机用户名. username = raw_input('username: ') # 获得用户指定 ssh 主机密码. password = getpass.getpass('password: ') # 利用 pxssh 类的 login 方法进行 ssh 登录，原始 prompt 为'$' , '#'或'>' s.login (hostname, username, password, original_prompt='[$#>]') # 发送命令 'uptime' s.sendline ('uptime') # 匹配 prompt s.prompt() # 将 prompt 前所有内容打印出，即命令 'uptime' 的执行结果. print s.before # 发送命令 ' ls -l ' s.sendline ('ls -l') # 匹配 prompt s.prompt() # 将 prompt 前所有内容打印出，即命令 ' ls -l ' 的执行结果. print s.before # 退出 ssh session s.logout() except pxssh.ExceptionPxssh, e: print "pxssh failed on login." print str(e)
使用原始 original_prompt 来找到 login 后的提示符（这里默认 original_prompt 是“$”或“#”，但是有时候可能也是别的 prompt，这时就需要在 login 时手动指定这个特殊的 prompt，见上例，有可能是“ > ”），如果找到了，立马使用更容易匹配的字符串来重置该原始提示符（这是由 pxssh 自己自动做的，通过命令 "PS1='[PEXPECT]\$ '" 重置原始提示符，然后每次 expect 匹配 PEXPECT
[\$\#]）。原始提示符是很容易被混淆和胡弄的，为了阻止错误匹配，最好根据特定的系统，指定更加精确的原始提示符，例如 "Message Of The Day" 。有些情况是不允许重置原始提示符的，这时就要设置 auto_prompt_reset 为 False 。而且此时需要手动设置 PROMPT 域为某个正则表达式来 match 接下来要出现的新提示符，因为 prompt() 函数默认是 expect 被重置过的 PROMPT 的。
匹配新提示符（不是 original_prompt）。注：这只是匹配提示符，不能匹配别的 string，如果要匹配特殊 string，需直接使用父类 spawn 的 expect 方法。 prompt 方法相当于是 expect 方法的一个快捷方法。如果auto_prompt_reset 为 False，这时需要手动设置 PROMPT 域为某个正则表达式来 match 接下来要出现的 prompt，因为 prompt() 函数默认是 expect 被重置过的 PROMPT 的。 logout方法
|
|
本例实现了如下功能：telnet 登录到某远程主机上，输入命令“ls -l”后，将子程序的执行权交还给用户，用户可以与生成的 telnet 子程序进行交互。
|
#!/usr/bin/env python import pexpect # 即将 telnet 所要登录的远程主机的域名 ipAddress = 'develperWorks.ibm.com' # 登录用户名 loginName = 'root' # 用户名密码 loginPassword = 'passw0rd' # 提示符，可能是’ $ ’ , ‘ # ’或’ > ’ loginprompt = '[$#>]' # 拼凑 telnet 命令 cmd = 'telnet ' + ipAddress # 为 telnet 生成 spawn 类子程序 child = pexpect.spawn(cmd) # 期待'login'字符串出现，从而接下来可以输入用户名 index = child.expect(["login", "(?i)Unknown host", pexpect.EOF, pexpect.TIMEOUT]) if ( index == 0 ): # 匹配'login'字符串成功，输入用户名. child.sendline(loginName) # 期待 "[pP]assword" 出现. index = child.expect(["[pP]assword", pexpect.EOF, pexpect.TIMEOUT]) # 匹配 "[pP]assword" 字符串成功，输入密码. child.sendline(loginPassword) # 期待提示符出现. child.expect(loginprompt) if (index == 0): # 匹配提示符成功，输入执行命令 'ls -l' child.sendline('ls -l') # 立马匹配 'ls -l'，目的是为了清除刚刚被 echo 回显的命令. child.expect('ls -l') # 期待提示符出现. child.expect(loginprompt) # 将 'ls -l' 的命令结果输出. print child.before print "Script recording started. Type ^] (ASCII 29) to escape from the script shell." # 将 telnet 子程序的执行权交给用户. child.interact() print 'Left interactve mode.' else: # 匹配到了 pexpect.EOF 或 pexpect.TIMEOUT，表示超时或者 EOF，程序打印提示信息并退出. print "telnet login failed, due to TIMEOUT or EOF" child.close(force=True) else: # 匹配到了 pexpect.EOF 或 pexpect.TIMEOUT，表示超时或者 EOF，程序打印提示信息并退出. print "telnet login failed, due to TIMEOUT or EOF" child.close(force=True)
通常一个 python 主程序通过 pexpect.spawn 启动一个子程序，一旦该子程序启动后，python 主程序就可以通过 child.expect 和 child.send/child.sendline 来和子程序通话，python 主程序运行结束后，子程序也就死了。比如 python 主程序通过 pexpect.spawn 启动了一个 telnet 子程序，在进行完一系列的 telnet 上的命令操作后，python 主程序运行结束了，那么该 telnet session（telnet 子程序）也会自动退出。但是如果调用 child.interact，那么该子程序（python 主程序通过 pexpect.spawn 衍生成的）就可以在运行到 child.interact 时，将子程序的控制权交给了终端用户（the human at the keyboard），用户可以通过键盘的输入来和子程序进行命令交互，管理子程序的生杀大权，用户的键盘输入 stdin 会被传给子程序，而且子程序的 stdout 和 stderr 输出也会被打印出来到终端。默认 ctrl + ] 退出 interact() 模式，把子程序的执行权重新交给 python 主程序。参数 escape_character 指定了交互模式的退出字符，例如 child.interact(chr(26)) 接下来就会变成 ctrl + z 退出 interact() 模式。 |
清单 7. 打印 pexpect.spawn 对象的字符串 value 值的例子代码
清单 8. 记录 log 的例子代码
清单 9. 重新启动一个 shell 来规避 pexpect 对元字符的不解释
如果想在 spawn 出来的新子程序中使用重定向 redirect，管道 pipe，和通配符 wildcards( “ > ” , “ | ”和“ * ”等 )，好像没有好的方法，只能不使用这些字符，先利用 expect 匹配命令提示符，从而在 before 中可以拿到之前命令的结果，然后在分析 before 的内容达到使用重定向 redirect, 管道 pipe, 和通配符 wildcards 的目的。
如果子程序没有在指定的时间内生成任何 output，那么 expect() 和 read() 都会产生 TIMEOUT 异常。超时默认是 30s，可以在 expect() 和 spawn 构造函数初始化时指定为其它时间，如：
如果你想让 expect() 和 read() 忽略超时限制，即无限期阻塞住直到有 output 产生，设置 timeout 参数为 None。 清单 10. 忽略 timeout 超时限制的例子代码
可能会有两种 EOF 异常被抛出，但是他们除了显示的信息不同，其实本质上是相同的。为了实用的目的，不需要区分它们，他们只是给了些关于你的 python 程序到底运行在哪个平台上的额外信息，这两个显示信息是：
有些 UNIX 平台，当你读取一个处于 EOF 状态的文件描述符时，会抛出异常，其他 UNIX 平台，却只会静静地返回一个空字符串来表明该文件已经达到了状态。 pexpect 模块除了提供 spawn 类以外，还提供了 run() 函数，使用其可以取代一些 spawn 的使用，而且更加简单明了。 清单 11. 使用 run() 来替代 spawn 的使用的例子代码
清单 12. 其它一些使用 run() 的例子代码
expect_exact(self, pattern_list, timeout = -1, searchwindowsize = -1); expect_exact() 与 expect() 类似，但是 pattern_list 只能是字符串或者是一个字符串的 list，不能是正则表达式，其匹配速度会快于 expect()，原因有两个：一是字符串的 search 比正则表达式的匹配要快，另一个则是可以限制只从输入缓冲的结尾来寻找匹配的字符串。还有当你觉得每次要 escape 正则表达式中的特殊字符为普通字符时很烦，那么你也可以使用 expect_exact() 来取代 expect()。 清单 13. expect_exact() 的例子代码
expect() 中的正则表达式不是贪婪匹配 greedy match，而是最小匹配，即只匹配缓冲区中最早出现的第一个字符串。因为是依次读取一个字符的 stream 流来判断是否和正则表达式所表达的模式匹配，所以如果参数 pattern 是个 list，而且不止一次匹配，那么缓冲区中最早出现的第一个匹配的字符串才算数。 清单 14. expect() 的最小匹配例子代码
正则表达式中，'$'可以匹配一行的结束（具体'$'正则表达式的使用，请参阅参考资料），但是 pexpect 从子程序中一次只读取一个字符，而且每个字符都好像是一行的结束一样，pexpect 不能在子程序的输出流去预测。匹配一行结束的方法必须是匹配 "\r\n" (CR/LF) 。即使是 Unix 系统，也是匹配 "\r\n" (CR/LF)，因为 pexpect 使用一个 Pseudo-TTY 设备与子程序通话，所以当子程序输出 "\n" 你仍然会在 python 主程序中看到 "\r\n" 。原因是 TTY 设备更像 windows 操作系统，每一行结束都有个 "\r\n" (CR/LF) 的组合，当你从 TTY 设备去解释一个 Unix 的命令时，你会发现真正的输出是 "\r\n" (CR/LF)，一个 Unix 命令只会写入一个 linefeed (\n)，但是 TTY 设备驱动会将其转换成 "\r\n" (CR/LF) 。 清单 15. 匹配一行结束 1
如果你只是想跳过一个新行，直接 expect('\n') 就可以了，但是如果你想在一行的结束匹配一个具体的 pattern 时，就必须精确的寻找 (\r)，见下例： 清单 16. 匹配一行结束 2
这个问题其实不只是 pexpect 会有，如果你在一个 stream 流上实施正则表达式匹配时，都会遇到此问题。正则表达式需要预测，stream 流中很难预测，因为生成这个流的进程可能还没有结束，所以你很难知道是否该进程是暂时性的暂停还是已经彻底结束。
child.expect ('.+'); 因为是最小匹配，所以只会返回一个字符，而不是一个整个一行（虽然 pexpect 设置了 re.DOTALL，会匹配一个新行。 child.expect ('.*'); 每次匹配都会成功，但是总是没有字符返回，因为 '*' 表明前面的字符可以出现 0 次 , 在 pexpect 中，一般来说，任何 '*' 都会尽量少的匹配。
测试子程序是否还在运行。这个方法是非阻塞的，如果子程序被终止了，那么该方法会去读取子程序的 exitstatus 或 signalstatus 这两个域。返回 True 表明子程序好像是在运行，返回 False 表示不再运行。当平台是 Solaris 时，可能需要几秒钟才能得到正确的状态。当子程序退出后立马执行 isalive() 有时可能会返回 1 (True)，这是一个 race condition，原因是子程序已经关闭了其文件描述符，但是在 isalive() 执行前还没有完全的退出。增加一个小小的延时会对 isalive() 的结果有效性有帮助。 清单 17. isalive() 的例子代码
spawn 类的域 delaybeforesend 可以帮助克服一些古怪的行为。比如，经典的是，当一个用户使用 expect() 期待 "Password:" 提示符时，如果匹配，立马 sendline() 发送密码给子程序，但是这个用户会看到他们的密码被 echo back 回显回来了。这是因为，通常许多应用程序都会在打印出 "Password:" 提示符后，立马关掉 stdin 的 echo，但是如果你发送密码过快，在程序关掉 stdin 的 echo 之前就发送密码出去了，那么该密码就会被 echo 出来。 清单 18. delaybeforesend 的例子代码
|
