/[shmookey]/portconf/pexpect.py


UCC Code Repository

Contents of /portconf/pexpect.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 65 - (hide annotations) (download) (as text)
Sat Mar 22 07:00:57 2008 UTC (13 years, 8 months ago) by shmookey
File MIME type: text/x-python
File size: 75937 byte(s)
new versions

1 shmookey 65 """Pexpect is a Python module for spawning child applications and controlling
2     them automatically. Pexpect can be used for automating interactive applications
3     such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup
4     scripts for duplicating software package installations on different servers. It
5     can be used for automated software testing. Pexpect is in the spirit of Don
6     Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python
7     require TCL and Expect or require C extensions to be compiled. Pexpect does not
8     use C, Expect, or TCL extensions. It should work on any platform that supports
9     the standard Python pty module. The Pexpect interface focuses on ease of use so
10     that simple tasks are easy.
11    
12     There are two main interfaces to Pexpect -- the function, run() and the class,
13     spawn. You can call the run() function to execute a command and return the
14     output. This is a handy replacement for os.system().
15    
16     For example::
17    
18     pexpect.run('ls -la')
19    
20     The more powerful interface is the spawn class. You can use this to spawn an
21     external child command and then interact with the child by sending lines and
22     expecting responses.
23    
24     For example::
25    
26     child = pexpect.spawn('scp foo [email protected]:.')
27     child.expect ('Password:')
28     child.sendline (mypassword)
29    
30     This works even for commands that ask for passwords or other input outside of
31     the normal stdio streams.
32    
33     Credits: Noah Spurrier, Richard Holden, Marco Molteni, Kimberley Burchett,
34     Robert Stone, Hartmut Goebel, Chad Schroeder, Erick Tryzelaar, Dave Kirby, Ids
35     vander Molen, George Todd, Noel Taylor, Nicolas D. Cesar, Alexander Gattin,
36     Geoffrey Marshall, Francisco Lourenco, Glen Mabey, Karthik Gurusamy, Fernando
37     Perez, Corey Minyard, Jon Cohen, Guillaume Chazarain, Andrew Ryan, Nick
38     Craig-Wood, Andrew Stone, Jorgen Grahn (Let me know if I forgot anyone.)
39    
40     Free, open source, and all that good stuff.
41    
42     Permission is hereby granted, free of charge, to any person obtaining a copy of
43     this software and associated documentation files (the "Software"), to deal in
44     the Software without restriction, including without limitation the rights to
45     use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
46     of the Software, and to permit persons to whom the Software is furnished to do
47     so, subject to the following conditions:
48    
49     The above copyright notice and this permission notice shall be included in all
50     copies or substantial portions of the Software.
51    
52     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
53     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
54     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
55     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
56     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
57     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
58     SOFTWARE.
59    
60     Pexpect Copyright (c) 2008 Noah Spurrier
61     http://pexpect.sourceforge.net/
62    
63     $Id: pexpect.py 507 2007-12-27 02:40:52Z noah $
64     """
65    
66     try:
67     import os, sys, time
68     import select
69     import string
70     import re
71     import struct
72     import resource
73     import types
74     import pty
75     import tty
76     import termios
77     import fcntl
78     import errno
79     import traceback
80     import signal
81     except ImportError, e:
82     raise ImportError (str(e) + """
83    
84     A critical module was not found. Probably this operating system does not
85     support it. Pexpect is intended for UNIX-like operating systems.""")
86    
87     __version__ = '2.3'
88     __revision__ = '$Revision: 399 $'
89     __all__ = ['ExceptionPexpect', 'EOF', 'TIMEOUT', 'spawn', 'run', 'which',
90     'split_command_line', '__version__', '__revision__']
91    
92     # Exception classes used by this module.
93     class ExceptionPexpect(Exception):
94    
95     """Base class for all exceptions raised by this module.
96     """
97    
98     def __init__(self, value):
99    
100     self.value = value
101    
102     def __str__(self):
103    
104     return str(self.value)
105    
106     def get_trace(self):
107    
108     """This returns an abbreviated stack trace with lines that only concern
109     the caller. In other words, the stack trace inside the Pexpect module
110     is not included. """
111    
112     tblist = traceback.extract_tb(sys.exc_info()[2])
113     #tblist = filter(self.__filter_not_pexpect, tblist)
114     tblist = [item for item in tblist if self.__filter_not_pexpect(item)]
115     tblist = traceback.format_list(tblist)
116     return ''.join(tblist)
117    
118     def __filter_not_pexpect(self, trace_list_item):
119    
120     """This returns True if list item 0 the string 'pexpect.py' in it. """
121    
122     if trace_list_item[0].find('pexpect.py') == -1:
123     return True
124     else:
125     return False
126    
127     class EOF(ExceptionPexpect):
128    
129     """Raised when EOF is read from a child. This usually means the child has exited."""
130    
131     class TIMEOUT(ExceptionPexpect):
132    
133     """Raised when a read time exceeds the timeout. """
134    
135     ##class TIMEOUT_PATTERN(TIMEOUT):
136     ## """Raised when the pattern match time exceeds the timeout.
137     ## This is different than a read TIMEOUT because the child process may
138     ## give output, thus never give a TIMEOUT, but the output
139     ## may never match a pattern.
140     ## """
141     ##class MAXBUFFER(ExceptionPexpect):
142     ## """Raised when a scan buffer fills before matching an expected pattern."""
143    
144     def run (command, timeout=-1, withexitstatus=False, events=None, extra_args=None, logfile=None, cwd=None, env=None):
145    
146     """
147     This function runs the given command; waits for it to finish; then
148     returns all output as a string. STDERR is included in output. If the full
149     path to the command is not given then the path is searched.
150    
151     Note that lines are terminated by CR/LF (\\r\\n) combination even on
152     UNIX-like systems because this is the standard for pseudo ttys. If you set
153     'withexitstatus' to true, then run will return a tuple of (command_output,
154     exitstatus). If 'withexitstatus' is false then this returns just
155     command_output.
156    
157     The run() function can often be used instead of creating a spawn instance.
158     For example, the following code uses spawn::
159    
160     from pexpect import *
161     child = spawn('scp foo [email protected]:.')
162     child.expect ('(?i)password')
163     child.sendline (mypassword)
164    
165     The previous code can be replace with the following::
166    
167     from pexpect import *
168     run ('scp foo [email protected]:.', events={'(?i)password': mypassword})
169    
170     Examples
171     ========
172    
173     Start the apache daemon on the local machine::
174    
175     from pexpect import *
176     run ("/usr/local/apache/bin/apachectl start")
177    
178     Check in a file using SVN::
179    
180     from pexpect import *
181     run ("svn ci -m 'automatic commit' my_file.py")
182    
183     Run a command and capture exit status::
184    
185     from pexpect import *
186     (command_output, exitstatus) = run ('ls -l /bin', withexitstatus=1)
187    
188     Tricky Examples
189     ===============
190    
191     The following will run SSH and execute 'ls -l' on the remote machine. The
192     password 'secret' will be sent if the '(?i)password' pattern is ever seen::
193    
194     run ("ssh [email protected] 'ls -l'", events={'(?i)password':'secret\\n'})
195    
196     This will start mencoder to rip a video from DVD. This will also display
197     progress ticks every 5 seconds as it runs. For example::
198    
199     from pexpect import *
200     def print_ticks(d):
201     print d['event_count'],
202     run ("mencoder dvd://1 -o video.avi -oac copy -ovc copy", events={TIMEOUT:print_ticks}, timeout=5)
203    
204     The 'events' argument should be a dictionary of patterns and responses.
205     Whenever one of the patterns is seen in the command out run() will send the
206     associated response string. Note that you should put newlines in your
207     string if Enter is necessary. The responses may also contain callback
208     functions. Any callback is function that takes a dictionary as an argument.
209     The dictionary contains all the locals from the run() function, so you can
210     access the child spawn object or any other variable defined in run()
211     (event_count, child, and extra_args are the most useful). A callback may
212     return True to stop the current run process otherwise run() continues until
213     the next event. A callback may also return a string which will be sent to
214     the child. 'extra_args' is not used by directly run(). It provides a way to
215     pass data to a callback function through run() through the locals
216     dictionary passed to a callback. """
217    
218     if timeout == -1:
219     child = spawn(command, maxread=2000, logfile=logfile, cwd=cwd, env=env)
220     else:
221     child = spawn(command, timeout=timeout, maxread=2000, logfile=logfile, cwd=cwd, env=env)
222     if events is not None:
223     patterns = events.keys()
224     responses = events.values()
225     else:
226     patterns=None # We assume that EOF or TIMEOUT will save us.
227     responses=None
228     child_result_list = []
229     event_count = 0
230     while 1:
231     try:
232     index = child.expect (patterns)
233     if type(child.after) in types.StringTypes:
234     child_result_list.append(child.before + child.after)
235     else: # child.after may have been a TIMEOUT or EOF, so don't cat those.
236     child_result_list.append(child.before)
237     if type(responses[index]) in types.StringTypes:
238     child.send(responses[index])
239     elif type(responses[index]) is types.FunctionType:
240     callback_result = responses[index](locals())
241     sys.stdout.flush()
242     if type(callback_result) in types.StringTypes:
243     child.send(callback_result)
244     elif callback_result:
245     break
246     else:
247     raise TypeError ('The callback must be a string or function type.')
248     event_count = event_count + 1
249     except TIMEOUT, e:
250     child_result_list.append(child.before)
251     break
252     except EOF, e:
253     child_result_list.append(child.before)
254     break
255     child_result = ''.join(child_result_list)
256     if withexitstatus:
257     child.close()
258     return (child_result, child.exitstatus)
259     else:
260     return child_result
261    
262     class spawn (object):
263    
264     """This is the main class interface for Pexpect. Use this class to start
265     and control child applications. """
266    
267     def __init__(self, command, args=[], timeout=30, maxread=2000, searchwindowsize=None, logfile=None, cwd=None, env=None):
268    
269     """This is the constructor. The command parameter may be a string that
270     includes a command and any arguments to the command. For example::
271    
272     child = pexpect.spawn ('/usr/bin/ftp')
273     child = pexpect.spawn ('/usr/bin/ssh [email protected]')
274     child = pexpect.spawn ('ls -latr /tmp')
275    
276     You may also construct it with a list of arguments like so::
277    
278     child = pexpect.spawn ('/usr/bin/ftp', [])
279     child = pexpect.spawn ('/usr/bin/ssh', ['[email protected]'])
280     child = pexpect.spawn ('ls', ['-latr', '/tmp'])
281    
282     After this the child application will be created and will be ready to
283     talk to. For normal use, see expect() and send() and sendline().
284    
285     Remember that Pexpect does NOT interpret shell meta characters such as
286     redirect, pipe, or wild cards (>, |, or *). This is a common mistake.
287     If you want to run a command and pipe it through another command then
288     you must also start a shell. For example::
289    
290     child = pexpect.spawn('/bin/bash -c "ls -l | grep LOG > log_list.txt"')
291     child.expect(pexpect.EOF)
292    
293     The second form of spawn (where you pass a list of arguments) is useful
294     in situations where you wish to spawn a command and pass it its own
295     argument list. This can make syntax more clear. For example, the
296     following is equivalent to the previous example::
297    
298     shell_cmd = 'ls -l | grep LOG > log_list.txt'
299     child = pexpect.spawn('/bin/bash', ['-c', shell_cmd])
300     child.expect(pexpect.EOF)
301    
302     The maxread attribute sets the read buffer size. This is maximum number
303     of bytes that Pexpect will try to read from a TTY at one time. Setting
304     the maxread size to 1 will turn off buffering. Setting the maxread
305     value higher may help performance in cases where large amounts of
306     output are read back from the child. This feature is useful in
307     conjunction with searchwindowsize.
308    
309     The searchwindowsize attribute sets the how far back in the incomming
310     seach buffer Pexpect will search for pattern matches. Every time
311     Pexpect reads some data from the child it will append the data to the
312     incomming buffer. The default is to search from the beginning of the
313     imcomming buffer each time new data is read from the child. But this is
314     very inefficient if you are running a command that generates a large
315     amount of data where you want to match The searchwindowsize does not
316     effect the size of the incomming data buffer. You will still have
317     access to the full buffer after expect() returns.
318    
319     The logfile member turns on or off logging. All input and output will
320     be copied to the given file object. Set logfile to None to stop
321     logging. This is the default. Set logfile to sys.stdout to echo
322     everything to standard output. The logfile is flushed after each write.
323    
324     Example log input and output to a file::
325    
326     child = pexpect.spawn('some_command')
327     fout = file('mylog.txt','w')
328     child.logfile = fout
329    
330     Example log to stdout::
331    
332     child = pexpect.spawn('some_command')
333     child.logfile = sys.stdout
334    
335     The logfile_read and logfile_send members can be used to separately log
336     the input from the child and output sent to the child. Sometimes you
337     don't want to see everything you write to the child. You only want to
338     log what the child sends back. For example::
339    
340     child = pexpect.spawn('some_command')
341     child.logfile_read = sys.stdout
342    
343     To separately log output sent to the child use logfile_send::
344    
345     self.logfile_send = fout
346    
347     The delaybeforesend helps overcome a weird behavior that many users
348     were experiencing. The typical problem was that a user would expect() a
349     "Password:" prompt and then immediately call sendline() to send the
350     password. The user would then see that their password was echoed back
351     to them. Passwords don't normally echo. The problem is caused by the
352     fact that most applications print out the "Password" prompt and then
353     turn off stdin echo, but if you send your password before the
354     application turned off echo, then you get your password echoed.
355     Normally this wouldn't be a problem when interacting with a human at a
356     real keyboard. If you introduce a slight delay just before writing then
357     this seems to clear up the problem. This was such a common problem for
358     many users that I decided that the default pexpect behavior should be
359     to sleep just before writing to the child application. 1/20th of a
360     second (50 ms) seems to be enough to clear up the problem. You can set
361     delaybeforesend to 0 to return to the old behavior. Most Linux machines
362     don't like this to be below 0.03. I don't know why.
363    
364     Note that spawn is clever about finding commands on your path.
365     It uses the same logic that "which" uses to find executables.
366    
367     If you wish to get the exit status of the child you must call the
368     close() method. The exit or signal status of the child will be stored
369     in self.exitstatus or self.signalstatus. If the child exited normally
370     then exitstatus will store the exit return code and signalstatus will
371     be None. If the child was terminated abnormally with a signal then
372     signalstatus will store the signal value and exitstatus will be None.
373     If you need more detail you can also read the self.status member which
374     stores the status returned by os.waitpid. You can interpret this using
375     os.WIFEXITED/os.WEXITSTATUS or os.WIFSIGNALED/os.TERMSIG. """
376    
377     self.STDIN_FILENO = pty.STDIN_FILENO
378     self.STDOUT_FILENO = pty.STDOUT_FILENO
379     self.STDERR_FILENO = pty.STDERR_FILENO
380     self.stdin = sys.stdin
381     self.stdout = sys.stdout
382     self.stderr = sys.stderr
383    
384     self.searcher = None
385     self.ignorecase = False
386     self.before = None
387     self.after = None
388     self.match = None
389     self.match_index = None
390     self.terminated = True
391     self.exitstatus = None
392     self.signalstatus = None
393     self.status = None # status returned by os.waitpid
394     self.flag_eof = False
395     self.pid = None
396     self.child_fd = -1 # initially closed
397     self.timeout = timeout
398     self.delimiter = EOF
399     self.logfile = logfile
400     self.logfile_read = None # input from child (read_nonblocking)
401     self.logfile_send = None # output to send (send, sendline)
402     self.maxread = maxread # max bytes to read at one time into buffer
403     self.buffer = '' # This is the read buffer. See maxread.
404     self.searchwindowsize = searchwindowsize # Anything before searchwindowsize point is preserved, but not searched.
405     # Most Linux machines don't like delaybeforesend to be below 0.03 (30 ms).
406     self.delaybeforesend = 0.05 # Sets sleep time used just before sending data to child. Time in seconds.
407     self.delayafterclose = 0.1 # Sets delay in close() method to allow kernel time to update process status. Time in seconds.
408     self.delayafterterminate = 0.1 # Sets delay in terminate() method to allow kernel time to update process status. Time in seconds.
409     self.softspace = False # File-like object.
410     self.name = '<' + repr(self) + '>' # File-like object.
411     self.encoding = None # File-like object.
412     self.closed = True # File-like object.
413     self.cwd = cwd
414     self.env = env
415     self.__irix_hack = (sys.platform.lower().find('irix')>=0) # This flags if we are running on irix
416     # Solaris uses internal __fork_pty(). All others use pty.fork().
417     if (sys.platform.lower().find('solaris')>=0) or (sys.platform.lower().find('sunos5')>=0):
418     self.use_native_pty_fork = False
419     else:
420     self.use_native_pty_fork = True
421    
422    
423     # allow dummy instances for subclasses that may not use command or args.
424     if command is None:
425     self.command = None
426     self.args = None
427     self.name = '<pexpect factory incomplete>'
428     else:
429     self._spawn (command, args)
430    
431     def __del__(self):
432    
433     """This makes sure that no system resources are left open. Python only
434     garbage collects Python objects. OS file descriptors are not Python
435     objects, so they must be handled explicitly. If the child file
436     descriptor was opened outside of this class (passed to the constructor)
437     then this does not close it. """
438    
439     if not self.closed:
440     # It is possible for __del__ methods to execute during the
441     # teardown of the Python VM itself. Thus self.close() may
442     # trigger an exception because os.close may be None.
443     # -- Fernando Perez
444     try:
445     self.close()
446     except AttributeError:
447     pass
448    
449     def __str__(self):
450    
451     """This returns a human-readable string that represents the state of
452     the object. """
453    
454     s = []
455     s.append(repr(self))
456     s.append('version: ' + __version__ + ' (' + __revision__ + ')')
457     s.append('command: ' + str(self.command))
458     s.append('args: ' + str(self.args))
459     s.append('searcher: ' + str(self.searcher))
460     s.append('buffer (last 100 chars): ' + str(self.buffer)[-100:])
461     s.append('before (last 100 chars): ' + str(self.before)[-100:])
462     s.append('after: ' + str(self.after))
463     s.append('match: ' + str(self.match))
464     s.append('match_index: ' + str(self.match_index))
465     s.append('exitstatus: ' + str(self.exitstatus))
466     s.append('flag_eof: ' + str(self.flag_eof))
467     s.append('pid: ' + str(self.pid))
468     s.append('child_fd: ' + str(self.child_fd))
469     s.append('closed: ' + str(self.closed))
470     s.append('timeout: ' + str(self.timeout))
471     s.append('delimiter: ' + str(self.delimiter))
472     s.append('logfile: ' + str(self.logfile))
473     s.append('logfile_read: ' + str(self.logfile_read))
474     s.append('logfile_send: ' + str(self.logfile_send))
475     s.append('maxread: ' + str(self.maxread))
476     s.append('ignorecase: ' + str(self.ignorecase))
477     s.append('searchwindowsize: ' + str(self.searchwindowsize))
478     s.append('delaybeforesend: ' + str(self.delaybeforesend))
479     s.append('delayafterclose: ' + str(self.delayafterclose))
480     s.append('delayafterterminate: ' + str(self.delayafterterminate))
481     return '\n'.join(s)
482    
483     def _spawn(self,command,args=[]):
484    
485     """This starts the given command in a child process. This does all the
486     fork/exec type of stuff for a pty. This is called by __init__. If args
487     is empty then command will be parsed (split on spaces) and args will be
488     set to parsed arguments. """
489    
490     # The pid and child_fd of this object get set by this method.
491     # Note that it is difficult for this method to fail.
492     # You cannot detect if the child process cannot start.
493     # So the only way you can tell if the child process started
494     # or not is to try to read from the file descriptor. If you get
495     # EOF immediately then it means that the child is already dead.
496     # That may not necessarily be bad because you may haved spawned a child
497     # that performs some task; creates no stdout output; and then dies.
498    
499     # If command is an int type then it may represent a file descriptor.
500     if type(command) == type(0):
501     raise ExceptionPexpect ('Command is an int type. If this is a file descriptor then maybe you want to use fdpexpect.fdspawn which takes an existing file descriptor instead of a command string.')
502    
503     if type (args) != type([]):
504     raise TypeError ('The argument, args, must be a list.')
505    
506     if args == []:
507     self.args = split_command_line(command)
508     self.command = self.args[0]
509     else:
510     self.args = args[:] # work with a copy
511     self.args.insert (0, command)
512     self.command = command
513    
514     command_with_path = which(self.command)
515     if command_with_path is None:
516     raise ExceptionPexpect ('The command was not found or was not executable: %s.' % self.command)
517     self.command = command_with_path
518     self.args[0] = self.command
519    
520     self.name = '<' + ' '.join (self.args) + '>'
521    
522     assert self.pid is None, 'The pid member should be None.'
523     assert self.command is not None, 'The command member should not be None.'
524    
525     if self.use_native_pty_fork:
526     try:
527     self.pid, self.child_fd = pty.fork()
528     except OSError, e:
529     raise ExceptionPexpect('Error! pty.fork() failed: ' + str(e))
530     else: # Use internal __fork_pty
531     self.pid, self.child_fd = self.__fork_pty()
532    
533     if self.pid == 0: # Child
534     try:
535     self.child_fd = sys.stdout.fileno() # used by setwinsize()
536     self.setwinsize(24, 80)
537     except:
538     # Some platforms do not like setwinsize (Cygwin).
539     # This will cause problem when running applications that
540     # are very picky about window size.
541     # This is a serious limitation, but not a show stopper.
542     pass
543     # Do not allow child to inherit open file descriptors from parent.
544     max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[0]
545     for i in range (3, max_fd):
546     try:
547     os.close (i)
548     except OSError:
549     pass
550    
551     # I don't know why this works, but ignoring SIGHUP fixes a
552     # problem when trying to start a Java daemon with sudo
553     # (specifically, Tomcat).
554     signal.signal(signal.SIGHUP, signal.SIG_IGN)
555    
556     if self.cwd is not None:
557     os.chdir(self.cwd)
558     if self.env is None:
559     os.execv(self.command, self.args)
560     else:
561     os.execvpe(self.command, self.args, self.env)
562    
563     # Parent
564     self.terminated = False
565     self.closed = False
566    
567     def __fork_pty(self):
568    
569     """This implements a substitute for the forkpty system call. This
570     should be more portable than the pty.fork() function. Specifically,
571     this should work on Solaris.
572    
573     Modified 10.06.05 by Geoff Marshall: Implemented __fork_pty() method to
574     resolve the issue with Python's pty.fork() not supporting Solaris,
575     particularly ssh. Based on patch to posixmodule.c authored by Noah
576     Spurrier::
577    
578     http://mail.python.org/pipermail/python-dev/2003-May/035281.html
579    
580     """
581    
582     parent_fd, child_fd = os.openpty()
583     if parent_fd < 0 or child_fd < 0:
584     raise ExceptionPexpect, "Error! Could not open pty with os.openpty()."
585    
586     pid = os.fork()
587     if pid < 0:
588     raise ExceptionPexpect, "Error! Failed os.fork()."
589     elif pid == 0:
590     # Child.
591     os.close(parent_fd)
592     self.__pty_make_controlling_tty(child_fd)
593    
594     os.dup2(child_fd, 0)
595     os.dup2(child_fd, 1)
596     os.dup2(child_fd, 2)
597    
598     if child_fd > 2:
599     os.close(child_fd)
600     else:
601     # Parent.
602     os.close(child_fd)
603    
604     return pid, parent_fd
605    
606     def __pty_make_controlling_tty(self, tty_fd):
607    
608     """This makes the pseudo-terminal the controlling tty. This should be
609     more portable than the pty.fork() function. Specifically, this should
610     work on Solaris. """
611    
612     child_name = os.ttyname(tty_fd)
613    
614     # Disconnect from controlling tty if still connected.
615     fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
616     if fd >= 0:
617     os.close(fd)
618    
619     os.setsid()
620    
621     # Verify we are disconnected from controlling tty
622     try:
623     fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY);
624     if fd >= 0:
625     os.close(fd)
626     raise ExceptionPexpect, "Error! We are not disconnected from a controlling tty."
627     except:
628     # Good! We are disconnected from a controlling tty.
629     pass
630    
631     # Verify we can open child pty.
632     fd = os.open(child_name, os.O_RDWR);
633     if fd < 0:
634     raise ExceptionPexpect, "Error! Could not open child pty, " + child_name
635     else:
636     os.close(fd)
637    
638     # Verify we now have a controlling tty.
639     fd = os.open("/dev/tty", os.O_WRONLY)
640     if fd < 0:
641     raise ExceptionPexpect, "Error! Could not open controlling tty, /dev/tty"
642     else:
643     os.close(fd)
644    
645     def fileno (self): # File-like object.
646    
647     """This returns the file descriptor of the pty for the child.
648     """
649    
650     return self.child_fd
651    
652     def close (self, force=True): # File-like object.
653    
654     """This closes the connection with the child application. Note that
655     calling close() more than once is valid. This emulates standard Python
656     behavior with files. Set force to True if you want to make sure that
657     the child is terminated (SIGKILL is sent if the child ignores SIGHUP
658     and SIGINT). """
659    
660     if not self.closed:
661     self.flush()
662     os.close (self.child_fd)
663     time.sleep(self.delayafterclose) # Give kernel time to update process status.
664     if self.isalive():
665     if not self.terminate(force):
666     raise ExceptionPexpect ('close() could not terminate the child using terminate()')
667     self.child_fd = -1
668     self.closed = True
669     #self.pid = None
670    
671     def flush (self): # File-like object.
672    
673     """This does nothing. It is here to support the interface for a
674     File-like object. """
675    
676     pass
677    
678     def isatty (self): # File-like object.
679    
680     """This returns True if the file descriptor is open and connected to a
681     tty(-like) device, else False. """
682    
683     return os.isatty(self.child_fd)
684    
685     def waitnoecho (self, timeout=-1):
686    
687     """This waits until the terminal ECHO flag is set False. This returns
688     True if the echo mode is off. This returns False if the ECHO flag was
689     not set False before the timeout. This can be used to detect when the
690     child is waiting for a password. Usually a child application will turn
691     off echo mode when it is waiting for the user to enter a password. For
692     example, instead of expecting the "password:" prompt you can wait for
693     the child to set ECHO off::
694    
695     p = pexpect.spawn ('ssh [email protected]')
696     p.waitnoecho()
697     p.sendline(mypassword)
698    
699     If timeout is None then this method to block forever until ECHO flag is
700     False.
701    
702     """
703    
704     if timeout == -1:
705     timeout = self.timeout
706     if timeout is not None:
707     end_time = time.time() + timeout
708     while True:
709     if not self.getecho():
710     return True
711     if timeout < 0 and timeout is not None:
712     return False
713     if timeout is not None:
714     timeout = end_time - time.time()
715     time.sleep(0.1)
716    
717     def getecho (self):
718    
719     """This returns the terminal echo mode. This returns True if echo is
720     on or False if echo is off. Child applications that are expecting you
721     to enter a password often set ECHO False. See waitnoecho(). """
722    
723     attr = termios.tcgetattr(self.child_fd)
724     if attr[3] & termios.ECHO:
725     return True
726     return False
727    
728     def setecho (self, state):
729    
730     """This sets the terminal echo mode on or off. Note that anything the
731     child sent before the echo will be lost, so you should be sure that
732     your input buffer is empty before you call setecho(). For example, the
733     following will work as expected::
734    
735     p = pexpect.spawn('cat')
736     p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
737     p.expect (['1234'])
738     p.expect (['1234'])
739     p.setecho(False) # Turn off tty echo
740     p.sendline ('abcd') # We will set this only once (echoed by cat).
741     p.sendline ('wxyz') # We will set this only once (echoed by cat)
742     p.expect (['abcd'])
743     p.expect (['wxyz'])
744    
745     The following WILL NOT WORK because the lines sent before the setecho
746     will be lost::
747    
748     p = pexpect.spawn('cat')
749     p.sendline ('1234') # We will see this twice (once from tty echo and again from cat).
750     p.setecho(False) # Turn off tty echo
751     p.sendline ('abcd') # We will set this only once (echoed by cat).
752     p.sendline ('wxyz') # We will set this only once (echoed by cat)
753     p.expect (['1234'])
754     p.expect (['1234'])
755     p.expect (['abcd'])
756     p.expect (['wxyz'])
757     """
758    
759     self.child_fd
760     attr = termios.tcgetattr(self.child_fd)
761     if state:
762     attr[3] = attr[3] | termios.ECHO
763     else:
764     attr[3] = attr[3] & ~termios.ECHO
765     # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent
766     # and blocked on some platforms. TCSADRAIN is probably ideal if it worked.
767     termios.tcsetattr(self.child_fd, termios.TCSANOW, attr)
768    
769     def read_nonblocking (self, size = 1, timeout = -1):
770    
771     """This reads at most size characters from the child application. It
772     includes a timeout. If the read does not complete within the timeout
773     period then a TIMEOUT exception is raised. If the end of file is read
774     then an EOF exception will be raised. If a log file was set using
775     setlog() then all data will also be written to the log file.
776    
777     If timeout is None then the read may block indefinitely. If timeout is -1
778     then the self.timeout value is used. If timeout is 0 then the child is
779     polled and if there was no data immediately ready then this will raise
780     a TIMEOUT exception.
781    
782     The timeout refers only to the amount of time to read at least one
783     character. This is not effected by the 'size' parameter, so if you call
784     read_nonblocking(size=100, timeout=30) and only one character is
785     available right away then one character will be returned immediately.
786     It will not wait for 30 seconds for another 99 characters to come in.
787    
788     This is a wrapper around os.read(). It uses select.select() to
789     implement the timeout. """
790    
791     if self.closed:
792     raise ValueError ('I/O operation on closed file in read_nonblocking().')
793    
794     if timeout == -1:
795     timeout = self.timeout
796    
797     # Note that some systems such as Solaris do not give an EOF when
798     # the child dies. In fact, you can still try to read
799     # from the child_fd -- it will block forever or until TIMEOUT.
800     # For this case, I test isalive() before doing any reading.
801     # If isalive() is false, then I pretend that this is the same as EOF.
802     if not self.isalive():
803     r,w,e = self.__select([self.child_fd], [], [], 0) # timeout of 0 means "poll"
804     if not r:
805     self.flag_eof = True
806     raise EOF ('End Of File (EOF) in read_nonblocking(). Braindead platform.')
807     elif self.__irix_hack:
808     # This is a hack for Irix. It seems that Irix requires a long delay before checking isalive.
809     # This adds a 2 second delay, but only when the child is terminated.
810     r, w, e = self.__select([self.child_fd], [], [], 2)
811     if not r and not self.isalive():
812     self.flag_eof = True
813     raise EOF ('End Of File (EOF) in read_nonblocking(). Pokey platform.')
814    
815     r,w,e = self.__select([self.child_fd], [], [], timeout)
816    
817     if not r:
818     if not self.isalive():
819     # Some platforms, such as Irix, will claim that their processes are alive;
820     # then timeout on the select; and then finally admit that they are not alive.
821     self.flag_eof = True
822     raise EOF ('End of File (EOF) in read_nonblocking(). Very pokey platform.')
823     else:
824     raise TIMEOUT ('Timeout exceeded in read_nonblocking().')
825    
826     if self.child_fd in r:
827     try:
828     s = os.read(self.child_fd, size)
829     except OSError, e: # Linux does this
830     self.flag_eof = True
831     raise EOF ('End Of File (EOF) in read_nonblocking(). Exception style platform.')
832     if s == '': # BSD style
833     self.flag_eof = True
834     raise EOF ('End Of File (EOF) in read_nonblocking(). Empty string style platform.')
835    
836     if self.logfile is not None:
837     self.logfile.write (s)
838     self.logfile.flush()
839     if self.logfile_read is not None:
840     self.logfile_read.write (s)
841     self.logfile_read.flush()
842    
843     return s
844    
845     raise ExceptionPexpect ('Reached an unexpected state in read_nonblocking().')
846    
847     def read (self, size = -1): # File-like object.
848    
849     """This reads at most "size" bytes from the file (less if the read hits
850     EOF before obtaining size bytes). If the size argument is negative or
851     omitted, read all data until EOF is reached. The bytes are returned as
852     a string object. An empty string is returned when EOF is encountered
853     immediately. """
854    
855     if size == 0:
856     return ''
857     if size < 0:
858     self.expect (self.delimiter) # delimiter default is EOF
859     return self.before
860    
861     # I could have done this more directly by not using expect(), but
862     # I deliberately decided to couple read() to expect() so that
863     # I would catch any bugs early and ensure consistant behavior.
864     # It's a little less efficient, but there is less for me to
865     # worry about if I have to later modify read() or expect().
866     # Note, it's OK if size==-1 in the regex. That just means it
867     # will never match anything in which case we stop only on EOF.
868     cre = re.compile('.{%d}' % size, re.DOTALL)
869     index = self.expect ([cre, self.delimiter]) # delimiter default is EOF
870     if index == 0:
871     return self.after ### self.before should be ''. Should I assert this?
872     return self.before
873    
874     def readline (self, size = -1): # File-like object.
875    
876     """This reads and returns one entire line. A trailing newline is kept
877     in the string, but may be absent when a file ends with an incomplete
878     line. Note: This readline() looks for a \\r\\n pair even on UNIX
879     because this is what the pseudo tty device returns. So contrary to what
880     you may expect you will receive the newline as \\r\\n. An empty string
881     is returned when EOF is hit immediately. Currently, the size argument is
882     mostly ignored, so this behavior is not standard for a file-like
883     object. If size is 0 then an empty string is returned. """
884    
885     if size == 0:
886     return ''
887     index = self.expect (['\r\n', self.delimiter]) # delimiter default is EOF
888     if index == 0:
889     return self.before + '\r\n'
890     else:
891     return self.before
892    
893     def __iter__ (self): # File-like object.
894    
895     """This is to support iterators over a file-like object.
896     """
897    
898     return self
899    
900     def next (self): # File-like object.
901    
902     """This is to support iterators over a file-like object.
903     """
904    
905     result = self.readline()
906     if result == "":
907     raise StopIteration
908     return result
909    
910     def readlines (self, sizehint = -1): # File-like object.
911    
912     """This reads until EOF using readline() and returns a list containing
913     the lines thus read. The optional "sizehint" argument is ignored. """
914    
915     lines = []
916     while True:
917     line = self.readline()
918     if not line:
919     break
920     lines.append(line)
921     return lines
922    
923     def write(self, s): # File-like object.
924    
925     """This is similar to send() except that there is no return value.
926     """
927    
928     self.send (s)
929    
930     def writelines (self, sequence): # File-like object.
931    
932     """This calls write() for each element in the sequence. The sequence
933     can be any iterable object producing strings, typically a list of
934     strings. This does not add line separators There is no return value.
935     """
936    
937     for s in sequence:
938     self.write (s)
939    
940     def send(self, s):
941    
942     """This sends a string to the child process. This returns the number of
943     bytes written. If a log file was set then the data is also written to
944     the log. """
945    
946     time.sleep(self.delaybeforesend)
947     if self.logfile is not None:
948     self.logfile.write (s)
949     self.logfile.flush()
950     if self.logfile_send is not None:
951     self.logfile_send.write (s)
952     self.logfile_send.flush()
953     c = os.write(self.child_fd, s)
954     return c
955    
956     def sendline(self, s=''):
957    
958     """This is like send(), but it adds a line feed (os.linesep). This
959     returns the number of bytes written. """
960    
961     n = self.send(s)
962     n = n + self.send (os.linesep)
963     return n
964    
965     def sendcontrol(self, char):
966    
967     """This sends a control character to the child such as Ctrl-C or
968     Ctrl-D. For example, to send a Ctrl-G (ASCII 7)::
969    
970     child.sendcontrol('g')
971    
972     See also, sendintr() and sendeof().
973     """
974    
975     char = char.lower()
976     a = ord(char)
977     if a>=97 and a<=122:
978     a = a - ord('a') + 1
979     return self.send (chr(a))
980     d = {'@':0, '`':0,
981     '[':27, '{':27,
982     '\\':28, '|':28,
983     ']':29, '}': 29,
984     '^':30, '~':30,
985     '_':31,
986     '?':127}
987     if char not in d:
988     return 0
989     return self.send (chr(d[char]))
990    
991     def sendeof(self):
992    
993     """This sends an EOF to the child. This sends a character which causes
994     the pending parent output buffer to be sent to the waiting child
995     program without waiting for end-of-line. If it is the first character
996     of the line, the read() in the user program returns 0, which signifies
997     end-of-file. This means to work as expected a sendeof() has to be
998     called at the beginning of a line. This method does not send a newline.
999     It is the responsibility of the caller to ensure the eof is sent at the
1000     beginning of a line. """
1001    
1002     ### Hmmm... how do I send an EOF?
1003     ###C if ((m = write(pty, *buf, p - *buf)) < 0)
1004     ###C return (errno == EWOULDBLOCK) ? n : -1;
1005     #fd = sys.stdin.fileno()
1006     #old = termios.tcgetattr(fd) # remember current state
1007     #attr = termios.tcgetattr(fd)
1008     #attr[3] = attr[3] | termios.ICANON # ICANON must be set to recognize EOF
1009     #try: # use try/finally to ensure state gets restored
1010     # termios.tcsetattr(fd, termios.TCSADRAIN, attr)
1011     # if hasattr(termios, 'CEOF'):
1012     # os.write (self.child_fd, '%c' % termios.CEOF)
1013     # else:
1014     # # Silly platform does not define CEOF so assume CTRL-D
1015     # os.write (self.child_fd, '%c' % 4)
1016     #finally: # restore state
1017     # termios.tcsetattr(fd, termios.TCSADRAIN, old)
1018     if hasattr(termios, 'VEOF'):
1019     char = termios.tcgetattr(self.child_fd)[6][termios.VEOF]
1020     else:
1021     # platform does not define VEOF so assume CTRL-D
1022     char = chr(4)
1023     self.send(char)
1024    
1025     def sendintr(self):
1026    
1027     """This sends a SIGINT to the child. It does not require
1028     the SIGINT to be the first character on a line. """
1029    
1030     if hasattr(termios, 'VINTR'):
1031     char = termios.tcgetattr(self.child_fd)[6][termios.VINTR]
1032     else:
1033     # platform does not define VINTR so assume CTRL-C
1034     char = chr(3)
1035     self.send (char)
1036    
1037     def eof (self):
1038    
1039     """This returns True if the EOF exception was ever raised.
1040     """
1041    
1042     return self.flag_eof
1043    
1044     def terminate(self, force=False):
1045    
1046     """This forces a child process to terminate. It starts nicely with
1047     SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This
1048     returns True if the child was terminated. This returns False if the
1049     child could not be terminated. """
1050    
1051     if not self.isalive():
1052     return True
1053     try:
1054     self.kill(signal.SIGHUP)
1055     time.sleep(self.delayafterterminate)
1056     if not self.isalive():
1057     return True
1058     self.kill(signal.SIGCONT)
1059     time.sleep(self.delayafterterminate)
1060     if not self.isalive():
1061     return True
1062     self.kill(signal.SIGINT)
1063     time.sleep(self.delayafterterminate)
1064     if not self.isalive():
1065     return True
1066     if force:
1067     self.kill(signal.SIGKILL)
1068     time.sleep(self.delayafterterminate)
1069     if not self.isalive():
1070     return True
1071     else:
1072     return False
1073     return False
1074     except OSError, e:
1075     # I think there are kernel timing issues that sometimes cause
1076     # this to happen. I think isalive() reports True, but the
1077     # process is dead to the kernel.
1078     # Make one last attempt to see if the kernel is up to date.
1079     time.sleep(self.delayafterterminate)
1080     if not self.isalive():
1081     return True
1082     else:
1083     return False
1084    
1085     def wait(self):
1086    
1087     """This waits until the child exits. This is a blocking call. This will
1088     not read any data from the child, so this will block forever if the
1089     child has unread output and has terminated. In other words, the child
1090     may have printed output then called exit(); but, technically, the child
1091     is still alive until its output is read. """
1092    
1093     if self.isalive():
1094     pid, status = os.waitpid(self.pid, 0)
1095     else:
1096     raise ExceptionPexpect ('Cannot wait for dead child process.')
1097     self.exitstatus = os.WEXITSTATUS(status)
1098     if os.WIFEXITED (status):
1099     self.status = status
1100     self.exitstatus = os.WEXITSTATUS(status)
1101     self.signalstatus = None
1102     self.terminated = True
1103     elif os.WIFSIGNALED (status):
1104     self.status = status
1105     self.exitstatus = None
1106     self.signalstatus = os.WTERMSIG(status)
1107     self.terminated = True
1108     elif os.WIFSTOPPED (status):
1109     raise ExceptionPexpect ('Wait was called for a child process that is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1110     return self.exitstatus
1111    
1112     def isalive(self):
1113    
1114     """This tests if the child process is running or not. This is
1115     non-blocking. If the child was terminated then this will read the
1116     exitstatus or signalstatus of the child. This returns True if the child
1117     process appears to be running or False if not. It can take literally
1118     SECONDS for Solaris to return the right status. """
1119    
1120     if self.terminated:
1121     return False
1122    
1123     if self.flag_eof:
1124     # This is for Linux, which requires the blocking form of waitpid to get
1125     # status of a defunct process. This is super-lame. The flag_eof would have
1126     # been set in read_nonblocking(), so this should be safe.
1127     waitpid_options = 0
1128     else:
1129     waitpid_options = os.WNOHANG
1130    
1131     try:
1132     pid, status = os.waitpid(self.pid, waitpid_options)
1133     except OSError, e: # No child processes
1134     if e[0] == errno.ECHILD:
1135     raise ExceptionPexpect ('isalive() encountered condition where "terminated" is 0, but there was no child process. Did someone else call waitpid() on our process?')
1136     else:
1137     raise e
1138    
1139     # I have to do this twice for Solaris. I can't even believe that I figured this out...
1140     # If waitpid() returns 0 it means that no child process wishes to
1141     # report, and the value of status is undefined.
1142     if pid == 0:
1143     try:
1144     pid, status = os.waitpid(self.pid, waitpid_options) ### os.WNOHANG) # Solaris!
1145     except OSError, e: # This should never happen...
1146     if e[0] == errno.ECHILD:
1147     raise ExceptionPexpect ('isalive() encountered condition that should never happen. There was no child process. Did someone else call waitpid() on our process?')
1148     else:
1149     raise e
1150    
1151     # If pid is still 0 after two calls to waitpid() then
1152     # the process really is alive. This seems to work on all platforms, except
1153     # for Irix which seems to require a blocking call on waitpid or select, so I let read_nonblocking
1154     # take care of this situation (unfortunately, this requires waiting through the timeout).
1155     if pid == 0:
1156     return True
1157    
1158     if pid == 0:
1159     return True
1160    
1161     if os.WIFEXITED (status):
1162     self.status = status
1163     self.exitstatus = os.WEXITSTATUS(status)
1164     self.signalstatus = None
1165     self.terminated = True
1166     elif os.WIFSIGNALED (status):
1167     self.status = status
1168     self.exitstatus = None
1169     self.signalstatus = os.WTERMSIG(status)
1170     self.terminated = True
1171     elif os.WIFSTOPPED (status):
1172     raise ExceptionPexpect ('isalive() encountered condition where child process is stopped. This is not supported. Is some other process attempting job control with our child pid?')
1173     return False
1174    
1175     def kill(self, sig):
1176    
1177     """This sends the given signal to the child application. In keeping
1178     with UNIX tradition it has a misleading name. It does not necessarily
1179     kill the child unless you send the right signal. """
1180    
1181     # Same as os.kill, but the pid is given for you.
1182     if self.isalive():
1183     os.kill(self.pid, sig)
1184    
1185     def compile_pattern_list(self, patterns):
1186    
1187     """This compiles a pattern-string or a list of pattern-strings.
1188     Patterns must be a StringType, EOF, TIMEOUT, SRE_Pattern, or a list of
1189     those. Patterns may also be None which results in an empty list (you
1190     might do this if waiting for an EOF or TIMEOUT condition without
1191     expecting any pattern).
1192    
1193     This is used by expect() when calling expect_list(). Thus expect() is
1194     nothing more than::
1195    
1196     cpl = self.compile_pattern_list(pl)
1197     return self.expect_list(cpl, timeout)
1198    
1199     If you are using expect() within a loop it may be more
1200     efficient to compile the patterns first and then call expect_list().
1201     This avoid calls in a loop to compile_pattern_list()::
1202    
1203     cpl = self.compile_pattern_list(my_pattern)
1204     while some_condition:
1205     ...
1206     i = self.expect_list(clp, timeout)
1207     ...
1208     """
1209    
1210     if patterns is None:
1211     return []
1212     if type(patterns) is not types.ListType:
1213     patterns = [patterns]
1214    
1215     compile_flags = re.DOTALL # Allow dot to match \n
1216     if self.ignorecase:
1217     compile_flags = compile_flags | re.IGNORECASE
1218     compiled_pattern_list = []
1219     for p in patterns:
1220     if type(p) in types.StringTypes:
1221     compiled_pattern_list.append(re.compile(p, compile_flags))
1222     elif p is EOF:
1223     compiled_pattern_list.append(EOF)
1224     elif p is TIMEOUT:
1225     compiled_pattern_list.append(TIMEOUT)
1226     elif type(p) is type(re.compile('')):
1227     compiled_pattern_list.append(p)
1228     else:
1229     raise TypeError ('Argument must be one of StringTypes, EOF, TIMEOUT, SRE_Pattern, or a list of those type. %s' % str(type(p)))
1230    
1231     return compiled_pattern_list
1232    
1233     def expect(self, pattern, timeout = -1, searchwindowsize=None):
1234    
1235     """This seeks through the stream until a pattern is matched. The
1236     pattern is overloaded and may take several types. The pattern can be a
1237     StringType, EOF, a compiled re, or a list of any of those types.
1238     Strings will be compiled to re types. This returns the index into the
1239     pattern list. If the pattern was not a list this returns index 0 on a
1240     successful match. This may raise exceptions for EOF or TIMEOUT. To
1241     avoid the EOF or TIMEOUT exceptions add EOF or TIMEOUT to the pattern
1242     list. That will cause expect to match an EOF or TIMEOUT condition
1243     instead of raising an exception.
1244    
1245     If you pass a list of patterns and more than one matches, the first match
1246     in the stream is chosen. If more than one pattern matches at that point,
1247     the leftmost in the pattern list is chosen. For example::
1248    
1249     # the input is 'foobar'
1250     index = p.expect (['bar', 'foo', 'foobar'])
1251     # returns 1 ('foo') even though 'foobar' is a "better" match
1252    
1253     Please note, however, that buffering can affect this behavior, since
1254     input arrives in unpredictable chunks. For example::
1255    
1256     # the input is 'foobar'
1257     index = p.expect (['foobar', 'foo'])
1258     # returns 0 ('foobar') if all input is available at once,
1259     # but returs 1 ('foo') if parts of the final 'bar' arrive late
1260    
1261     After a match is found the instance attributes 'before', 'after' and
1262     'match' will be set. You can see all the data read before the match in
1263     'before'. You can see the data that was matched in 'after'. The
1264     re.MatchObject used in the re match will be in 'match'. If an error
1265     occurred then 'before' will be set to all the data read so far and
1266     'after' and 'match' will be None.
1267    
1268     If timeout is -1 then timeout will be set to the self.timeout value.
1269    
1270     A list entry may be EOF or TIMEOUT instead of a string. This will
1271     catch these exceptions and return the index of the list entry instead
1272     of raising the exception. The attribute 'after' will be set to the
1273     exception type. The attribute 'match' will be None. This allows you to
1274     write code like this::
1275    
1276     index = p.expect (['good', 'bad', pexpect.EOF, pexpect.TIMEOUT])
1277     if index == 0:
1278     do_something()
1279     elif index == 1:
1280     do_something_else()
1281     elif index == 2:
1282     do_some_other_thing()
1283     elif index == 3:
1284     do_something_completely_different()
1285    
1286     instead of code like this::
1287    
1288     try:
1289     index = p.expect (['good', 'bad'])
1290     if index == 0:
1291     do_something()
1292     elif index == 1:
1293     do_something_else()
1294     except EOF:
1295     do_some_other_thing()
1296     except TIMEOUT:
1297     do_something_completely_different()
1298    
1299     These two forms are equivalent. It all depends on what you want. You
1300     can also just expect the EOF if you are waiting for all output of a
1301     child to finish. For example::
1302    
1303     p = pexpect.spawn('/bin/ls')
1304     p.expect (pexpect.EOF)
1305     print p.before
1306    
1307     If you are trying to optimize for speed then see expect_list().
1308     """
1309    
1310     compiled_pattern_list = self.compile_pattern_list(pattern)
1311     return self.expect_list(compiled_pattern_list, timeout, searchwindowsize)
1312    
1313     def expect_list(self, pattern_list, timeout = -1, searchwindowsize = -1):
1314    
1315     """This takes a list of compiled regular expressions and returns the
1316     index into the pattern_list that matched the child output. The list may
1317     also contain EOF or TIMEOUT (which are not compiled regular
1318     expressions). This method is similar to the expect() method except that
1319     expect_list() does not recompile the pattern list on every call. This
1320     may help if you are trying to optimize for speed, otherwise just use
1321     the expect() method. This is called by expect(). If timeout==-1 then
1322     the self.timeout value is used. If searchwindowsize==-1 then the
1323     self.searchwindowsize value is used. """
1324    
1325     return self.expect_loop(searcher_re(pattern_list), timeout, searchwindowsize)
1326    
1327     def expect_exact(self, pattern_list, timeout = -1, searchwindowsize = -1):
1328    
1329     """This is similar to expect(), but uses plain string matching instead
1330     of compiled regular expressions in 'pattern_list'. The 'pattern_list'
1331     may be a string; a list or other sequence of strings; or TIMEOUT and
1332     EOF.
1333    
1334     This call might be faster than expect() for two reasons: string
1335     searching is faster than RE matching and it is possible to limit the
1336     search to just the end of the input buffer.
1337    
1338     This method is also useful when you don't want to have to worry about
1339     escaping regular expression characters that you want to match."""
1340    
1341     if type(pattern_list) in types.StringTypes or pattern_list in (TIMEOUT, EOF):
1342     pattern_list = [pattern_list]
1343     return self.expect_loop(searcher_string(pattern_list), timeout, searchwindowsize)
1344    
1345     def expect_loop(self, searcher, timeout = -1, searchwindowsize = -1):
1346    
1347     """This is the common loop used inside expect. The 'searcher' should be
1348     an instance of searcher_re or searcher_string, which describes how and what
1349     to search for in the input.
1350    
1351     See expect() for other arguments, return value and exceptions. """
1352    
1353     self.searcher = searcher
1354    
1355     if timeout == -1:
1356     timeout = self.timeout
1357     if timeout is not None:
1358     end_time = time.time() + timeout
1359     if searchwindowsize == -1:
1360     searchwindowsize = self.searchwindowsize
1361    
1362     try:
1363     incoming = self.buffer
1364     freshlen = len(incoming)
1365     while True: # Keep reading until exception or return.
1366     index = searcher.search(incoming, freshlen, searchwindowsize)
1367     if index >= 0:
1368     self.buffer = incoming[searcher.end : ]
1369     self.before = incoming[ : searcher.start]
1370     self.after = incoming[searcher.start : searcher.end]
1371     self.match = searcher.match
1372     self.match_index = index
1373     return self.match_index
1374     # No match at this point
1375     if timeout < 0 and timeout is not None:
1376     raise TIMEOUT ('Timeout exceeded in expect_any().')
1377     # Still have time left, so read more data
1378     c = self.read_nonblocking (self.maxread, timeout)
1379     freshlen = len(c)
1380     time.sleep (0.0001)
1381     incoming = incoming + c
1382     if timeout is not None:
1383     timeout = end_time - time.time()
1384     except EOF, e:
1385     self.buffer = ''
1386     self.before = incoming
1387     self.after = EOF
1388     index = searcher.eof_index
1389     if index >= 0:
1390     self.match = EOF
1391     self.match_index = index
1392     return self.match_index
1393     else:
1394     self.match = None
1395     self.match_index = None
1396     raise EOF (str(e) + '\n' + str(self))
1397     except TIMEOUT, e:
1398     self.buffer = incoming
1399     self.before = incoming
1400     self.after = TIMEOUT
1401     index = searcher.timeout_index
1402     if index >= 0:
1403     self.match = TIMEOUT
1404     self.match_index = index
1405     return self.match_index
1406     else:
1407     self.match = None
1408     self.match_index = None
1409     raise TIMEOUT (str(e) + '\n' + str(self))
1410     except:
1411     self.before = incoming
1412     self.after = None
1413     self.match = None
1414     self.match_index = None
1415     raise
1416    
1417     def getwinsize(self):
1418    
1419     """This returns the terminal window size of the child tty. The return
1420     value is a tuple of (rows, cols). """
1421    
1422     TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912L)
1423     s = struct.pack('HHHH', 0, 0, 0, 0)
1424     x = fcntl.ioctl(self.fileno(), TIOCGWINSZ, s)
1425     return struct.unpack('HHHH', x)[0:2]
1426    
1427     def setwinsize(self, r, c):
1428    
1429     """This sets the terminal window size of the child tty. This will cause
1430     a SIGWINCH signal to be sent to the child. This does not change the
1431     physical window size. It changes the size reported to TTY-aware
1432     applications like vi or curses -- applications that respond to the
1433     SIGWINCH signal. """
1434    
1435     # Check for buggy platforms. Some Python versions on some platforms
1436     # (notably OSF1 Alpha and RedHat 7.1) truncate the value for
1437     # termios.TIOCSWINSZ. It is not clear why this happens.
1438     # These platforms don't seem to handle the signed int very well;
1439     # yet other platforms like OpenBSD have a large negative value for
1440     # TIOCSWINSZ and they don't have a truncate problem.
1441     # Newer versions of Linux have totally different values for TIOCSWINSZ.
1442     # Note that this fix is a hack.
1443     TIOCSWINSZ = getattr(termios, 'TIOCSWINSZ', -2146929561)
1444     if TIOCSWINSZ == 2148037735L: # L is not required in Python >= 2.2.
1445     TIOCSWINSZ = -2146929561 # Same bits, but with sign.
1446     # Note, assume ws_xpixel and ws_ypixel are zero.
1447     s = struct.pack('HHHH', r, c, 0, 0)
1448     fcntl.ioctl(self.fileno(), TIOCSWINSZ, s)
1449    
1450     def interact(self, escape_character = chr(29), input_filter = None, output_filter = None):
1451    
1452     """This gives control of the child process to the interactive user (the
1453     human at the keyboard). Keystrokes are sent to the child process, and
1454     the stdout and stderr output of the child process is printed. This
1455     simply echos the child stdout and child stderr to the real stdout and
1456     it echos the real stdin to the child stdin. When the user types the
1457     escape_character this method will stop. The default for
1458     escape_character is ^]. This should not be confused with ASCII 27 --
1459     the ESC character. ASCII 29 was chosen for historical merit because
1460     this is the character used by 'telnet' as the escape character. The
1461     escape_character will not be sent to the child process.
1462    
1463     You may pass in optional input and output filter functions. These
1464     functions should take a string and return a string. The output_filter
1465     will be passed all the output from the child process. The input_filter
1466     will be passed all the keyboard input from the user. The input_filter
1467     is run BEFORE the check for the escape_character.
1468    
1469     Note that if you change the window size of the parent the SIGWINCH
1470     signal will not be passed through to the child. If you want the child
1471     window size to change when the parent's window size changes then do
1472     something like the following example::
1473    
1474     import pexpect, struct, fcntl, termios, signal, sys
1475     def sigwinch_passthrough (sig, data):
1476     s = struct.pack("HHHH", 0, 0, 0, 0)
1477     a = struct.unpack('hhhh', fcntl.ioctl(sys.stdout.fileno(), termios.TIOCGWINSZ , s))
1478     global p
1479     p.setwinsize(a[0],a[1])
1480     p = pexpect.spawn('/bin/bash') # Note this is global and used in sigwinch_passthrough.
1481     signal.signal(signal.SIGWINCH, sigwinch_passthrough)
1482     p.interact()
1483     """
1484    
1485     # Flush the buffer.
1486     self.stdout.write (self.buffer)
1487     self.stdout.flush()
1488     self.buffer = ''
1489     mode = tty.tcgetattr(self.STDIN_FILENO)
1490     tty.setraw(self.STDIN_FILENO)
1491     try:
1492     self.__interact_copy(escape_character, input_filter, output_filter)
1493     finally:
1494     tty.tcsetattr(self.STDIN_FILENO, tty.TCSAFLUSH, mode)
1495    
1496     def __interact_writen(self, fd, data):
1497    
1498     """This is used by the interact() method.
1499     """
1500    
1501     while data != '' and self.isalive():
1502     n = os.write(fd, data)
1503     data = data[n:]
1504    
1505     def __interact_read(self, fd):
1506    
1507     """This is used by the interact() method.
1508     """
1509    
1510     return os.read(fd, 1000)
1511    
1512     def __interact_copy(self, escape_character = None, input_filter = None, output_filter = None):
1513    
1514     """This is used by the interact() method.
1515     """
1516    
1517     while self.isalive():
1518     r,w,e = self.__select([self.child_fd, self.STDIN_FILENO], [], [])
1519     if self.child_fd in r:
1520     data = self.__interact_read(self.child_fd)
1521     if output_filter: data = output_filter(data)
1522     if self.logfile is not None:
1523     self.logfile.write (data)
1524     self.logfile.flush()
1525     os.write(self.STDOUT_FILENO, data)
1526     if self.STDIN_FILENO in r:
1527     data = self.__interact_read(self.STDIN_FILENO)
1528     if input_filter: data = input_filter(data)
1529     i = data.rfind(escape_character)
1530     if i != -1:
1531     data = data[:i]
1532     self.__interact_writen(self.child_fd, data)
1533     break
1534     self.__interact_writen(self.child_fd, data)
1535    
1536     def __select (self, iwtd, owtd, ewtd, timeout=None):
1537    
1538     """This is a wrapper around select.select() that ignores signals. If
1539     select.select raises a select.error exception and errno is an EINTR
1540     error then it is ignored. Mainly this is used to ignore sigwinch
1541     (terminal resize). """
1542    
1543     # if select() is interrupted by a signal (errno==EINTR) then
1544     # we loop back and enter the select() again.
1545     if timeout is not None:
1546     end_time = time.time() + timeout
1547     while True:
1548     try:
1549     return select.select (iwtd, owtd, ewtd, timeout)
1550     except select.error, e:
1551     if e[0] == errno.EINTR:
1552     # if we loop back we have to subtract the amount of time we already waited.
1553     if timeout is not None:
1554     timeout = end_time - time.time()
1555     if timeout < 0:
1556     return ([],[],[])
1557     else: # something else caused the select.error, so this really is an exception
1558     raise
1559    
1560     ##############################################################################
1561     # The following methods are no longer supported or allowed.
1562    
1563     def setmaxread (self, maxread):
1564    
1565     """This method is no longer supported or allowed. I don't like getters
1566     and setters without a good reason. """
1567    
1568     raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the maxread member variable.')
1569    
1570     def setlog (self, fileobject):
1571    
1572     """This method is no longer supported or allowed.
1573     """
1574    
1575     raise ExceptionPexpect ('This method is no longer supported or allowed. Just assign a value to the logfile member variable.')
1576    
1577     ##############################################################################
1578     # End of spawn class
1579     ##############################################################################
1580    
1581     class searcher_string (object):
1582    
1583     """This is a plain string search helper for the spawn.expect_any() method.
1584    
1585     Attributes:
1586    
1587     eof_index - index of EOF, or -1
1588     timeout_index - index of TIMEOUT, or -1
1589    
1590     After a successful match by the search() method the following attributes
1591     are available:
1592    
1593     start - index into the buffer, first byte of match
1594     end - index into the buffer, first byte after match
1595     match - the matching string itself
1596     """
1597    
1598     def __init__(self, strings):
1599    
1600     """This creates an instance of searcher_string. This argument 'strings'
1601     may be a list; a sequence of strings; or the EOF or TIMEOUT types. """
1602    
1603     self.eof_index = -1
1604     self.timeout_index = -1
1605     self._strings = []
1606     for n, s in zip(range(len(strings)), strings):
1607     if s is EOF:
1608     self.eof_index = n
1609     continue
1610     if s is TIMEOUT:
1611     self.timeout_index = n
1612     continue
1613     self._strings.append((n, s))
1614    
1615     def __str__(self):
1616    
1617     """This returns a human-readable string that represents the state of
1618     the object."""
1619    
1620     ss = [ (ns[0],' %d: "%s"' % ns) for ns in self._strings ]
1621     ss.append((-1,'searcher_string:'))
1622     if self.eof_index >= 0:
1623     ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1624     if self.timeout_index >= 0:
1625     ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1626     ss.sort()
1627     ss = zip(*ss)[1]
1628     return '\n'.join(ss)
1629    
1630     def search(self, buffer, freshlen, searchwindowsize=None):
1631    
1632     """This searches 'buffer' for the first occurence of one of the search
1633     strings. 'freshlen' must indicate the number of bytes at the end of
1634     'buffer' which have not been searched before. It helps to avoid
1635     searching the same, possibly big, buffer over and over again.
1636    
1637     See class spawn for the 'searchwindowsize' argument.
1638    
1639     If there is a match this returns the index of that string, and sets
1640     'start', 'end' and 'match'. Otherwise, this returns -1. """
1641    
1642     absurd_match = len(buffer)
1643     first_match = absurd_match
1644    
1645     # 'freshlen' helps a lot here. Further optimizations could
1646     # possibly include:
1647     #
1648     # using something like the Boyer-Moore Fast String Searching
1649     # Algorithm; pre-compiling the search through a list of
1650     # strings into something that can scan the input once to
1651     # search for all N strings; realize that if we search for
1652     # ['bar', 'baz'] and the input is '...foo' we need not bother
1653     # rescanning until we've read three more bytes.
1654     #
1655     # Sadly, I don't know enough about this interesting topic. /grahn
1656    
1657     for index, s in self._strings:
1658     if searchwindowsize is None:
1659     # the match, if any, can only be in the fresh data,
1660     # or at the very end of the old data
1661     offset = -(freshlen+len(s))
1662     else:
1663     # better obey searchwindowsize
1664     offset = -searchwindowsize
1665     n = buffer.find(s, offset)
1666     if n >= 0 and n < first_match:
1667     first_match = n
1668     best_index, best_match = index, s
1669     if first_match == absurd_match:
1670     return -1
1671     self.match = best_match
1672     self.start = first_match
1673     self.end = self.start + len(self.match)
1674     return best_index
1675    
1676     class searcher_re (object):
1677    
1678     """This is regular expression string search helper for the
1679     spawn.expect_any() method.
1680    
1681     Attributes:
1682    
1683     eof_index - index of EOF, or -1
1684     timeout_index - index of TIMEOUT, or -1
1685    
1686     After a successful match by the search() method the following attributes
1687     are available:
1688    
1689     start - index into the buffer, first byte of match
1690     end - index into the buffer, first byte after match
1691     match - the re.match object returned by a succesful re.search
1692    
1693     """
1694    
1695     def __init__(self, patterns):
1696    
1697     """This creates an instance that searches for 'patterns' Where
1698     'patterns' may be a list or other sequence of compiled regular
1699     expressions, or the EOF or TIMEOUT types."""
1700    
1701     self.eof_index = -1
1702     self.timeout_index = -1
1703     self._searches = []
1704     for n, s in zip(range(len(patterns)), patterns):
1705     if s is EOF:
1706     self.eof_index = n
1707     continue
1708     if s is TIMEOUT:
1709     self.timeout_index = n
1710     continue
1711     self._searches.append((n, s))
1712    
1713     def __str__(self):
1714    
1715     """This returns a human-readable string that represents the state of
1716     the object."""
1717    
1718     ss = [ (n,' %d: re.compile("%s")' % (n,str(s.pattern))) for n,s in self._searches]
1719     ss.append((-1,'searcher_re:'))
1720     if self.eof_index >= 0:
1721     ss.append ((self.eof_index,' %d: EOF' % self.eof_index))
1722     if self.timeout_index >= 0:
1723     ss.append ((self.timeout_index,' %d: TIMEOUT' % self.timeout_index))
1724     ss.sort()
1725     ss = zip(*ss)[1]
1726     return '\n'.join(ss)
1727    
1728     def search(self, buffer, freshlen, searchwindowsize=None):
1729    
1730     """This searches 'buffer' for the first occurence of one of the regular
1731     expressions. 'freshlen' must indicate the number of bytes at the end of
1732     'buffer' which have not been searched before.
1733    
1734     See class spawn for the 'searchwindowsize' argument.
1735    
1736     If there is a match this returns the index of that string, and sets
1737     'start', 'end' and 'match'. Otherwise, returns -1."""
1738    
1739     absurd_match = len(buffer)
1740     first_match = absurd_match
1741     # 'freshlen' doesn't help here -- we cannot predict the
1742     # length of a match, and the re module provides no help.
1743     if searchwindowsize is None:
1744     searchstart = 0
1745     else:
1746     searchstart = max(0, len(buffer)-searchwindowsize)
1747     for index, s in self._searches:
1748     match = s.search(buffer, searchstart)
1749     if match is None:
1750     continue
1751     n = match.start()
1752     if n < first_match:
1753     first_match = n
1754     the_match = match
1755     best_index = index
1756     if first_match == absurd_match:
1757     return -1
1758     self.start = first_match
1759     self.match = the_match
1760     self.end = self.match.end()
1761     return best_index
1762    
1763     def which (filename):
1764    
1765     """This takes a given filename; tries to find it in the environment path;
1766     then checks if it is executable. This returns the full path to the filename
1767     if found and executable. Otherwise this returns None."""
1768    
1769     # Special case where filename already contains a path.
1770     if os.path.dirname(filename) != '':
1771     if os.access (filename, os.X_OK):
1772     return filename
1773    
1774     if not os.environ.has_key('PATH') or os.environ['PATH'] == '':
1775     p = os.defpath
1776     else:
1777     p = os.environ['PATH']
1778    
1779     # Oddly enough this was the one line that made Pexpect
1780     # incompatible with Python 1.5.2.
1781     #pathlist = p.split (os.pathsep)
1782     pathlist = string.split (p, os.pathsep)
1783    
1784     for path in pathlist:
1785     f = os.path.join(path, filename)
1786     if os.access(f, os.X_OK):
1787     return f
1788     return None
1789    
1790     def split_command_line(command_line):
1791    
1792     """This splits a command line into a list of arguments. It splits arguments
1793     on spaces, but handles embedded quotes, doublequotes, and escaped
1794     characters. It's impossible to do this with a regular expression, so I
1795     wrote a little state machine to parse the command line. """
1796    
1797     arg_list = []
1798     arg = ''
1799    
1800     # Constants to name the states we can be in.
1801     state_basic = 0
1802     state_esc = 1
1803     state_singlequote = 2
1804     state_doublequote = 3
1805     state_whitespace = 4 # The state of consuming whitespace between commands.
1806     state = state_basic
1807    
1808     for c in command_line:
1809     if state == state_basic or state == state_whitespace:
1810     if c == '\\': # Escape the next character
1811     state = state_esc
1812     elif c == r"'": # Handle single quote
1813     state = state_singlequote
1814     elif c == r'"': # Handle double quote
1815     state = state_doublequote
1816     elif c.isspace():
1817     # Add arg to arg_list if we aren't in the middle of whitespace.
1818     if state == state_whitespace:
1819     None # Do nothing.
1820     else:
1821     arg_list.append(arg)
1822     arg = ''
1823     state = state_whitespace
1824     else:
1825     arg = arg + c
1826     state = state_basic
1827     elif state == state_esc:
1828     arg = arg + c
1829     state = state_basic
1830     elif state == state_singlequote:
1831     if c == r"'":
1832     state = state_basic
1833     else:
1834     arg = arg + c
1835     elif state == state_doublequote:
1836     if c == r'"':
1837     state = state_basic
1838     else:
1839     arg = arg + c
1840    
1841     if arg != '':
1842     arg_list.append(arg)
1843     return arg_list
1844    
1845     # vi:ts=4:sw=4:expandtab:ft=python:

Managed by UCC Webmasters ViewVC Help
Powered by ViewVC 1.1.26