@matheusbsbs / matheus-bagliano / commits / 343d35c916
Fork 0

Ship our own copy of subprocess.py

so people without the latest Python could run merge-recursive. Signed-off-by: Junio C Hamano <junkio@cox.net>

Junio C Hamano committed Sep 19, 2005 at 19:47 UTC 343d35c9166cf1713eb2787c3506fd2663466262
4 files changed +1176 -9
Makefile
+6
@@ -23,6 +23,8 @@
23 #
24 # Define NO_GETDOMAINNAME if your library lack it (SunOS, Patrick Mauritz).
25 #
26 +# Define WITH_OWN_SUBPROCESS_PY if you want to use with python 2.3.
27 +#
28 # Define COLLISION_CHECK below if you believe that SHA1's
29 # 1461501637330902918203684832716283019655932542976 hashes do not give you
30 # sufficient guarantee that no collisions between objects will ever happen.
@@ -117,6 +119,10 @@ PROGRAMS += git-ssh-pull git-ssh-push
119 PYMODULES = \
120 gitMergeCommon.py
121
122 +ifdef WITH_OWN_SUBPROCESS_PY
123 + PYMODULES += compat/subprocess.py
124 +endif
125 +
126 ifdef WITH_SEND_EMAIL
127 SCRIPT_PERL += git-send-email.perl
128 endif
compat/subprocess.py new
+1165
@@ -0,0 +1,1165 @@
1 +# subprocess - Subprocesses with accessible I/O streams
2 +#
3 +# For more information about this module, see PEP 324.
4 +#
5 +# Copyright (c) 2003-2004 by Peter Astrand <astrand@lysator.liu.se>
6 +#
7 +# By obtaining, using, and/or copying this software and/or its
8 +# associated documentation, you agree that you have read, understood,
9 +# and will comply with the following terms and conditions:
10 +#
11 +# Permission to use, copy, modify, and distribute this software and
12 +# its associated documentation for any purpose and without fee is
13 +# hereby granted, provided that the above copyright notice appears in
14 +# all copies, and that both that copyright notice and this permission
15 +# notice appear in supporting documentation, and that the name of the
16 +# author not be used in advertising or publicity pertaining to
17 +# distribution of the software without specific, written prior
18 +# permission.
19 +#
20 +# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
21 +# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
22 +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR
23 +# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
24 +# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
25 +# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
26 +# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
27 +
28 +r"""subprocess - Subprocesses with accessible I/O streams
29 +
30 +This module allows you to spawn processes, connect to their
31 +input/output/error pipes, and obtain their return codes. This module
32 +intends to replace several other, older modules and functions, like:
33 +
34 +os.system
35 +os.spawn*
36 +os.popen*
37 +popen2.*
38 +commands.*
39 +
40 +Information about how the subprocess module can be used to replace these
41 +modules and functions can be found below.
42 +
43 +
44 +
45 +Using the subprocess module
46 +===========================
47 +This module defines one class called Popen:
48 +
49 +class Popen(args, bufsize=0, executable=None,
50 + stdin=None, stdout=None, stderr=None,
51 + preexec_fn=None, close_fds=False, shell=False,
52 + cwd=None, env=None, universal_newlines=False,
53 + startupinfo=None, creationflags=0):
54 +
55 +
56 +Arguments are:
57 +
58 +args should be a string, or a sequence of program arguments. The
59 +program to execute is normally the first item in the args sequence or
60 +string, but can be explicitly set by using the executable argument.
61 +
62 +On UNIX, with shell=False (default): In this case, the Popen class
63 +uses os.execvp() to execute the child program. args should normally
64 +be a sequence. A string will be treated as a sequence with the string
65 +as the only item (the program to execute).
66 +
67 +On UNIX, with shell=True: If args is a string, it specifies the
68 +command string to execute through the shell. If args is a sequence,
69 +the first item specifies the command string, and any additional items
70 +will be treated as additional shell arguments.
71 +
72 +On Windows: the Popen class uses CreateProcess() to execute the child
73 +program, which operates on strings. If args is a sequence, it will be
74 +converted to a string using the list2cmdline method. Please note that
75 +not all MS Windows applications interpret the command line the same
76 +way: The list2cmdline is designed for applications using the same
77 +rules as the MS C runtime.
78 +
79 +bufsize, if given, has the same meaning as the corresponding argument
80 +to the built-in open() function: 0 means unbuffered, 1 means line
81 +buffered, any other positive value means use a buffer of
82 +(approximately) that size. A negative bufsize means to use the system
83 +default, which usually means fully buffered. The default value for
84 +bufsize is 0 (unbuffered).
85 +
86 +stdin, stdout and stderr specify the executed programs' standard
87 +input, standard output and standard error file handles, respectively.
88 +Valid values are PIPE, an existing file descriptor (a positive
89 +integer), an existing file object, and None. PIPE indicates that a
90 +new pipe to the child should be created. With None, no redirection
91 +will occur; the child's file handles will be inherited from the
92 +parent. Additionally, stderr can be STDOUT, which indicates that the
93 +stderr data from the applications should be captured into the same
94 +file handle as for stdout.
95 +
96 +If preexec_fn is set to a callable object, this object will be called
97 +in the child process just before the child is executed.
98 +
99 +If close_fds is true, all file descriptors except 0, 1 and 2 will be
100 +closed before the child process is executed.
101 +
102 +if shell is true, the specified command will be executed through the
103 +shell.
104 +
105 +If cwd is not None, the current directory will be changed to cwd
106 +before the child is executed.
107 +
108 +If env is not None, it defines the environment variables for the new
109 +process.
110 +
111 +If universal_newlines is true, the file objects stdout and stderr are
112 +opened as a text files, but lines may be terminated by any of '\n',
113 +the Unix end-of-line convention, '\r', the Macintosh convention or
114 +'\r\n', the Windows convention. All of these external representations
115 +are seen as '\n' by the Python program. Note: This feature is only
116 +available if Python is built with universal newline support (the
117 +default). Also, the newlines attribute of the file objects stdout,
118 +stdin and stderr are not updated by the communicate() method.
119 +
120 +The startupinfo and creationflags, if given, will be passed to the
121 +underlying CreateProcess() function. They can specify things such as
122 +appearance of the main window and priority for the new process.
123 +(Windows only)
124 +
125 +
126 +This module also defines two shortcut functions:
127 +
128 +call(*args, **kwargs):
129 + Run command with arguments. Wait for command to complete, then
130 + return the returncode attribute.
131 +
132 + The arguments are the same as for the Popen constructor. Example:
133 +
134 + retcode = call(["ls", "-l"])
135 +
136 +
137 +Exceptions
138 +----------
139 +Exceptions raised in the child process, before the new program has
140 +started to execute, will be re-raised in the parent. Additionally,
141 +the exception object will have one extra attribute called
142 +'child_traceback', which is a string containing traceback information
143 +from the childs point of view.
144 +
145 +The most common exception raised is OSError. This occurs, for
146 +example, when trying to execute a non-existent file. Applications
147 +should prepare for OSErrors.
148 +
149 +A ValueError will be raised if Popen is called with invalid arguments.
150 +
151 +
152 +Security
153 +--------
154 +Unlike some other popen functions, this implementation will never call
155 +/bin/sh implicitly. This means that all characters, including shell
156 +metacharacters, can safely be passed to child processes.
157 +
158 +
159 +Popen objects
160 +=============
161 +Instances of the Popen class have the following methods:
162 +
163 +poll()
164 + Check if child process has terminated. Returns returncode
165 + attribute.
166 +
167 +wait()
168 + Wait for child process to terminate. Returns returncode attribute.
169 +
170 +communicate(input=None)
171 + Interact with process: Send data to stdin. Read data from stdout
172 + and stderr, until end-of-file is reached. Wait for process to
173 + terminate. The optional stdin argument should be a string to be
174 + sent to the child process, or None, if no data should be sent to
175 + the child.
176 +
177 + communicate() returns a tuple (stdout, stderr).
178 +
179 + Note: The data read is buffered in memory, so do not use this
180 + method if the data size is large or unlimited.
181 +
182 +The following attributes are also available:
183 +
184 +stdin
185 + If the stdin argument is PIPE, this attribute is a file object
186 + that provides input to the child process. Otherwise, it is None.
187 +
188 +stdout
189 + If the stdout argument is PIPE, this attribute is a file object
190 + that provides output from the child process. Otherwise, it is
191 + None.
192 +
193 +stderr
194 + If the stderr argument is PIPE, this attribute is file object that
195 + provides error output from the child process. Otherwise, it is
196 + None.
197 +
198 +pid
199 + The process ID of the child process.
200 +
201 +returncode
202 + The child return code. A None value indicates that the process
203 + hasn't terminated yet. A negative value -N indicates that the
204 + child was terminated by signal N (UNIX only).
205 +
206 +
207 +Replacing older functions with the subprocess module
208 +====================================================
209 +In this section, "a ==> b" means that b can be used as a replacement
210 +for a.
211 +
212 +Note: All functions in this section fail (more or less) silently if
213 +the executed program cannot be found; this module raises an OSError
214 +exception.
215 +
216 +In the following examples, we assume that the subprocess module is
217 +imported with "from subprocess import *".
218 +
219 +
220 +Replacing /bin/sh shell backquote
221 +---------------------------------
222 +output=`mycmd myarg`
223 +==>
224 +output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
225 +
226 +
227 +Replacing shell pipe line
228 +-------------------------
229 +output=`dmesg | grep hda`
230 +==>
231 +p1 = Popen(["dmesg"], stdout=PIPE)
232 +p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
233 +output = p2.communicate()[0]
234 +
235 +
236 +Replacing os.system()
237 +---------------------
238 +sts = os.system("mycmd" + " myarg")
239 +==>
240 +p = Popen("mycmd" + " myarg", shell=True)
241 +sts = os.waitpid(p.pid, 0)
242 +
243 +Note:
244 +
245 +* Calling the program through the shell is usually not required.
246 +
247 +* It's easier to look at the returncode attribute than the
248 + exitstatus.
249 +
250 +A more real-world example would look like this:
251 +
252 +try:
253 + retcode = call("mycmd" + " myarg", shell=True)
254 + if retcode < 0:
255 + print >>sys.stderr, "Child was terminated by signal", -retcode
256 + else:
257 + print >>sys.stderr, "Child returned", retcode
258 +except OSError, e:
259 + print >>sys.stderr, "Execution failed:", e
260 +
261 +
262 +Replacing os.spawn*
263 +-------------------
264 +P_NOWAIT example:
265 +
266 +pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
267 +==>
268 +pid = Popen(["/bin/mycmd", "myarg"]).pid
269 +
270 +
271 +P_WAIT example:
272 +
273 +retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
274 +==>
275 +retcode = call(["/bin/mycmd", "myarg"])
276 +
277 +
278 +Vector example:
279 +
280 +os.spawnvp(os.P_NOWAIT, path, args)
281 +==>
282 +Popen([path] + args[1:])
283 +
284 +
285 +Environment example:
286 +
287 +os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
288 +==>
289 +Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
290 +
291 +
292 +Replacing os.popen*
293 +-------------------
294 +pipe = os.popen(cmd, mode='r', bufsize)
295 +==>
296 +pipe = Popen(cmd, shell=True, bufsize=bufsize, stdout=PIPE).stdout
297 +
298 +pipe = os.popen(cmd, mode='w', bufsize)
299 +==>
300 +pipe = Popen(cmd, shell=True, bufsize=bufsize, stdin=PIPE).stdin
301 +
302 +
303 +(child_stdin, child_stdout) = os.popen2(cmd, mode, bufsize)
304 +==>
305 +p = Popen(cmd, shell=True, bufsize=bufsize,
306 + stdin=PIPE, stdout=PIPE, close_fds=True)
307 +(child_stdin, child_stdout) = (p.stdin, p.stdout)
308 +
309 +
310 +(child_stdin,
311 + child_stdout,
312 + child_stderr) = os.popen3(cmd, mode, bufsize)
313 +==>
314 +p = Popen(cmd, shell=True, bufsize=bufsize,
315 + stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
316 +(child_stdin,
317 + child_stdout,
318 + child_stderr) = (p.stdin, p.stdout, p.stderr)
319 +
320 +
321 +(child_stdin, child_stdout_and_stderr) = os.popen4(cmd, mode, bufsize)
322 +==>
323 +p = Popen(cmd, shell=True, bufsize=bufsize,
324 + stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
325 +(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
326 +
327 +
328 +Replacing popen2.*
329 +------------------
330 +Note: If the cmd argument to popen2 functions is a string, the command
331 +is executed through /bin/sh. If it is a list, the command is directly
332 +executed.
333 +
334 +(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
335 +==>
336 +p = Popen(["somestring"], shell=True, bufsize=bufsize
337 + stdin=PIPE, stdout=PIPE, close_fds=True)
338 +(child_stdout, child_stdin) = (p.stdout, p.stdin)
339 +
340 +
341 +(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize, mode)
342 +==>
343 +p = Popen(["mycmd", "myarg"], bufsize=bufsize,
344 + stdin=PIPE, stdout=PIPE, close_fds=True)
345 +(child_stdout, child_stdin) = (p.stdout, p.stdin)
346 +
347 +The popen2.Popen3 and popen3.Popen4 basically works as subprocess.Popen,
348 +except that:
349 +
350 +* subprocess.Popen raises an exception if the execution fails
351 +* the capturestderr argument is replaced with the stderr argument.
352 +* stdin=PIPE and stdout=PIPE must be specified.
353 +* popen2 closes all filedescriptors by default, but you have to specify
354 + close_fds=True with subprocess.Popen.
355 +
356 +
357 +"""
358 +
359 +import sys
360 +mswindows = (sys.platform == "win32")
361 +
362 +import os
363 +import types
364 +import traceback
365 +
366 +if mswindows:
367 + import threading
368 + import msvcrt
369 + if 0: # <-- change this to use pywin32 instead of the _subprocess driver
370 + import pywintypes
371 + from win32api import GetStdHandle, STD_INPUT_HANDLE, \
372 + STD_OUTPUT_HANDLE, STD_ERROR_HANDLE
373 + from win32api import GetCurrentProcess, DuplicateHandle, \
374 + GetModuleFileName, GetVersion
375 + from win32con import DUPLICATE_SAME_ACCESS, SW_HIDE
376 + from win32pipe import CreatePipe
377 + from win32process import CreateProcess, STARTUPINFO, \
378 + GetExitCodeProcess, STARTF_USESTDHANDLES, \
379 + STARTF_USESHOWWINDOW, CREATE_NEW_CONSOLE
380 + from win32event import WaitForSingleObject, INFINITE, WAIT_OBJECT_0
381 + else:
382 + from _subprocess import *
383 + class STARTUPINFO:
384 + dwFlags = 0
385 + hStdInput = None
386 + hStdOutput = None
387 + hStdError = None
388 + class pywintypes:
389 + error = IOError
390 +else:
391 + import select
392 + import errno
393 + import fcntl
394 + import pickle
395 +
396 +__all__ = ["Popen", "PIPE", "STDOUT", "call"]
397 +
398 +try:
399 + MAXFD = os.sysconf("SC_OPEN_MAX")
400 +except:
401 + MAXFD = 256
402 +
403 +# True/False does not exist on 2.2.0
404 +try:
405 + False
406 +except NameError:
407 + False = 0
408 + True = 1
409 +
410 +_active = []
411 +
412 +def _cleanup():
413 + for inst in _active[:]:
414 + inst.poll()
415 +
416 +PIPE = -1
417 +STDOUT = -2
418 +
419 +
420 +def call(*args, **kwargs):
421 + """Run command with arguments. Wait for command to complete, then
422 + return the returncode attribute.
423 +
424 + The arguments are the same as for the Popen constructor. Example:
425 +
426 + retcode = call(["ls", "-l"])
427 + """
428 + return Popen(*args, **kwargs).wait()
429 +
430 +
431 +def list2cmdline(seq):
432 + """
433 + Translate a sequence of arguments into a command line
434 + string, using the same rules as the MS C runtime:
435 +
436 + 1) Arguments are delimited by white space, which is either a
437 + space or a tab.
438 +
439 + 2) A string surrounded by double quotation marks is
440 + interpreted as a single argument, regardless of white space
441 + contained within. A quoted string can be embedded in an
442 + argument.
443 +
444 + 3) A double quotation mark preceded by a backslash is
445 + interpreted as a literal double quotation mark.
446 +
447 + 4) Backslashes are interpreted literally, unless they
448 + immediately precede a double quotation mark.
449 +
450 + 5) If backslashes immediately precede a double quotation mark,
451 + every pair of backslashes is interpreted as a literal
452 + backslash. If the number of backslashes is odd, the last
453 + backslash escapes the next double quotation mark as
454 + described in rule 3.
455 + """
456 +
457 + # See
458 + # http://msdn.microsoft.com/library/en-us/vccelng/htm/progs_12.asp
459 + result = []
460 + needquote = False
461 + for arg in seq:
462 + bs_buf = []
463 +
464 + # Add a space to separate this argument from the others
465 + if result:
466 + result.append(' ')
467 +
468 + needquote = (" " in arg) or ("\t" in arg)
469 + if needquote:
470 + result.append('"')
471 +
472 + for c in arg:
473 + if c == '\\':
474 + # Don't know if we need to double yet.
475 + bs_buf.append(c)
476 + elif c == '"':
477 + # Double backspaces.
478 + result.append('\\' * len(bs_buf)*2)
479 + bs_buf = []
480 + result.append('\\"')
481 + else:
482 + # Normal char
483 + if bs_buf:
484 + result.extend(bs_buf)
485 + bs_buf = []
486 + result.append(c)
487 +
488 + # Add remaining backspaces, if any.
489 + if bs_buf:
490 + result.extend(bs_buf)
491 +
492 + if needquote:
493 + result.extend(bs_buf)
494 + result.append('"')
495 +
496 + return ''.join(result)
497 +
498 +
499 +class Popen(object):
500 + def __init__(self, args, bufsize=0, executable=None,
501 + stdin=None, stdout=None, stderr=None,
502 + preexec_fn=None, close_fds=False, shell=False,
503 + cwd=None, env=None, universal_newlines=False,
504 + startupinfo=None, creationflags=0):
505 + """Create new Popen instance."""
506 + _cleanup()
507 +
508 + if not isinstance(bufsize, (int, long)):
509 + raise TypeError("bufsize must be an integer")
510 +
511 + if mswindows:
512 + if preexec_fn is not None:
513 + raise ValueError("preexec_fn is not supported on Windows "
514 + "platforms")
515 + if close_fds:
516 + raise ValueError("close_fds is not supported on Windows "
517 + "platforms")
518 + else:
519 + # POSIX
520 + if startupinfo is not None:
521 + raise ValueError("startupinfo is only supported on Windows "
522 + "platforms")
523 + if creationflags != 0:
524 + raise ValueError("creationflags is only supported on Windows "
525 + "platforms")
526 +
527 + self.stdin = None
528 + self.stdout = None
529 + self.stderr = None
530 + self.pid = None
531 + self.returncode = None
532 + self.universal_newlines = universal_newlines
533 +
534 + # Input and output objects. The general principle is like
535 + # this:
536 + #
537 + # Parent Child
538 + # ------ -----
539 + # p2cwrite ---stdin---> p2cread
540 + # c2pread <--stdout--- c2pwrite
541 + # errread <--stderr--- errwrite
542 + #
543 + # On POSIX, the child objects are file descriptors. On
544 + # Windows, these are Windows file handles. The parent objects
545 + # are file descriptors on both platforms. The parent objects
546 + # are None when not using PIPEs. The child objects are None
547 + # when not redirecting.
548 +
549 + (p2cread, p2cwrite,
550 + c2pread, c2pwrite,
551 + errread, errwrite) = self._get_handles(stdin, stdout, stderr)
552 +
553 + self._execute_child(args, executable, preexec_fn, close_fds,
554 + cwd, env, universal_newlines,
555 + startupinfo, creationflags, shell,
556 + p2cread, p2cwrite,
557 + c2pread, c2pwrite,
558 + errread, errwrite)
559 +
560 + if p2cwrite:
561 + self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)
562 + if c2pread:
563 + if universal_newlines:
564 + self.stdout = os.fdopen(c2pread, 'rU', bufsize)
565 + else:
566 + self.stdout = os.fdopen(c2pread, 'rb', bufsize)
567 + if errread:
568 + if universal_newlines:
569 + self.stderr = os.fdopen(errread, 'rU', bufsize)
570 + else:
571 + self.stderr = os.fdopen(errread, 'rb', bufsize)
572 +
573 + _active.append(self)
574 +
575 +
576 + def _translate_newlines(self, data):
577 + data = data.replace("\r\n", "\n")
578 + data = data.replace("\r", "\n")
579 + return data
580 +
581 +
582 + if mswindows:
583 + #
584 + # Windows methods
585 + #
586 + def _get_handles(self, stdin, stdout, stderr):
587 + """Construct and return tupel with IO objects:
588 + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
589 + """
590 + if stdin == None and stdout == None and stderr == None:
591 + return (None, None, None, None, None, None)
592 +
593 + p2cread, p2cwrite = None, None
594 + c2pread, c2pwrite = None, None
595 + errread, errwrite = None, None
596 +
597 + if stdin == None:
598 + p2cread = GetStdHandle(STD_INPUT_HANDLE)
599 + elif stdin == PIPE:
600 + p2cread, p2cwrite = CreatePipe(None, 0)
601 + # Detach and turn into fd
602 + p2cwrite = p2cwrite.Detach()
603 + p2cwrite = msvcrt.open_osfhandle(p2cwrite, 0)
604 + elif type(stdin) == types.IntType:
605 + p2cread = msvcrt.get_osfhandle(stdin)
606 + else:
607 + # Assuming file-like object
608 + p2cread = msvcrt.get_osfhandle(stdin.fileno())
609 + p2cread = self._make_inheritable(p2cread)
610 +
611 + if stdout == None:
612 + c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE)
613 + elif stdout == PIPE:
614 + c2pread, c2pwrite = CreatePipe(None, 0)
615 + # Detach and turn into fd
616 + c2pread = c2pread.Detach()
617 + c2pread = msvcrt.open_osfhandle(c2pread, 0)
618 + elif type(stdout) == types.IntType:
619 + c2pwrite = msvcrt.get_osfhandle(stdout)
620 + else:
621 + # Assuming file-like object
622 + c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
623 + c2pwrite = self._make_inheritable(c2pwrite)
624 +
625 + if stderr == None:
626 + errwrite = GetStdHandle(STD_ERROR_HANDLE)
627 + elif stderr == PIPE:
628 + errread, errwrite = CreatePipe(None, 0)
629 + # Detach and turn into fd
630 + errread = errread.Detach()
631 + errread = msvcrt.open_osfhandle(errread, 0)
632 + elif stderr == STDOUT:
633 + errwrite = c2pwrite
634 + elif type(stderr) == types.IntType:
635 + errwrite = msvcrt.get_osfhandle(stderr)
636 + else:
637 + # Assuming file-like object
638 + errwrite = msvcrt.get_osfhandle(stderr.fileno())
639 + errwrite = self._make_inheritable(errwrite)
640 +
641 + return (p2cread, p2cwrite,
642 + c2pread, c2pwrite,
643 + errread, errwrite)
644 +
645 +
646 + def _make_inheritable(self, handle):
647 + """Return a duplicate of handle, which is inheritable"""
648 + return DuplicateHandle(GetCurrentProcess(), handle,
649 + GetCurrentProcess(), 0, 1,
650 + DUPLICATE_SAME_ACCESS)
651 +
652 +
653 + def _find_w9xpopen(self):
654 + """Find and return absolut path to w9xpopen.exe"""
655 + w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)),
656 + "w9xpopen.exe")
657 + if not os.path.exists(w9xpopen):
658 + # Eeek - file-not-found - possibly an embedding
659 + # situation - see if we can locate it in sys.exec_prefix
660 + w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix),
661 + "w9xpopen.exe")
662 + if not os.path.exists(w9xpopen):
663 + raise RuntimeError("Cannot locate w9xpopen.exe, which is "
664 + "needed for Popen to work with your "
665 + "shell or platform.")
666 + return w9xpopen
667 +
668 +
669 + def _execute_child(self, args, executable, preexec_fn, close_fds,
670 + cwd, env, universal_newlines,
671 + startupinfo, creationflags, shell,
672 + p2cread, p2cwrite,
673 + c2pread, c2pwrite,
674 + errread, errwrite):
675 + """Execute program (MS Windows version)"""
676 +
677 + if not isinstance(args, types.StringTypes):
678 + args = list2cmdline(args)
679 +
680 + # Process startup details
681 + default_startupinfo = STARTUPINFO()
682 + if startupinfo == None:
683 + startupinfo = default_startupinfo
684 + if not None in (p2cread, c2pwrite, errwrite):
685 + startupinfo.dwFlags |= STARTF_USESTDHANDLES
686 + startupinfo.hStdInput = p2cread
687 + startupinfo.hStdOutput = c2pwrite
688 + startupinfo.hStdError = errwrite
689 +
690 + if shell:
691 + default_startupinfo.dwFlags |= STARTF_USESHOWWINDOW
692 + default_startupinfo.wShowWindow = SW_HIDE
693 + comspec = os.environ.get("COMSPEC", "cmd.exe")
694 + args = comspec + " /c " + args
695 + if (GetVersion() >= 0x80000000L or
696 + os.path.basename(comspec).lower() == "command.com"):
697 + # Win9x, or using command.com on NT. We need to
698 + # use the w9xpopen intermediate program. For more
699 + # information, see KB Q150956
700 + # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp)
701 + w9xpopen = self._find_w9xpopen()
702 + args = '"%s" %s' % (w9xpopen, args)
703 + # Not passing CREATE_NEW_CONSOLE has been known to
704 + # cause random failures on win9x. Specifically a
705 + # dialog: "Your program accessed mem currently in
706 + # use at xxx" and a hopeful warning about the
707 + # stability of your system. Cost is Ctrl+C wont
708 + # kill children.
709 + creationflags |= CREATE_NEW_CONSOLE
710 +
711 + # Start the process
712 + try:
713 + hp, ht, pid, tid = CreateProcess(executable, args,
714 + # no special security
715 + None, None,
716 + # must inherit handles to pass std
717 + # handles
718 + 1,
719 + creationflags,
720 + env,
721 + cwd,
722 + startupinfo)
723 + except pywintypes.error, e:
724 + # Translate pywintypes.error to WindowsError, which is
725 + # a subclass of OSError. FIXME: We should really
726 + # translate errno using _sys_errlist (or simliar), but
727 + # how can this be done from Python?
728 + raise WindowsError(*e.args)
729 +
730 + # Retain the process handle, but close the thread handle
731 + self._handle = hp
732 + self.pid = pid
733 + ht.Close()
734 +
735 + # Child is launched. Close the parent's copy of those pipe
736 + # handles that only the child should have open. You need
737 + # to make sure that no handles to the write end of the
738 + # output pipe are maintained in this process or else the
739 + # pipe will not close when the child process exits and the
740 + # ReadFile will hang.
741 + if p2cread != None:
742 + p2cread.Close()
743 + if c2pwrite != None:
744 + c2pwrite.Close()
745 + if errwrite != None:
746 + errwrite.Close()
747 +
748 +
749 + def poll(self):
750 + """Check if child process has terminated. Returns returncode
751 + attribute."""
752 + if self.returncode == None:
753 + if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0:
754 + self.returncode = GetExitCodeProcess(self._handle)
755 + _active.remove(self)
756 + return self.returncode
757 +
758 +
759 + def wait(self):
760 + """Wait for child process to terminate. Returns returncode
761 + attribute."""
762 + if self.returncode == None:
763 + obj = WaitForSingleObject(self._handle, INFINITE)
764 + self.returncode = GetExitCodeProcess(self._handle)
765 + _active.remove(self)
766 + return self.returncode
767 +
768 +
769 + def _readerthread(self, fh, buffer):
770 + buffer.append(fh.read())
771 +
772 +
773 + def communicate(self, input=None):
774 + """Interact with process: Send data to stdin. Read data from
775 + stdout and stderr, until end-of-file is reached. Wait for
776 + process to terminate. The optional input argument should be a
777 + string to be sent to the child process, or None, if no data
778 + should be sent to the child.
779 +
780 + communicate() returns a tuple (stdout, stderr)."""
781 + stdout = None # Return
782 + stderr = None # Return
783 +
784 + if self.stdout:
785 + stdout = []
786 + stdout_thread = threading.Thread(target=self._readerthread,
787 + args=(self.stdout, stdout))
788 + stdout_thread.setDaemon(True)
789 + stdout_thread.start()
790 + if self.stderr:
791 + stderr = []
792 + stderr_thread = threading.Thread(target=self._readerthread,
793 + args=(self.stderr, stderr))
794 + stderr_thread.setDaemon(True)
795 + stderr_thread.start()
796 +
797 + if self.stdin:
798 + if input != None:
799 + self.stdin.write(input)
800 + self.stdin.close()
801 +
802 + if self.stdout:
803 + stdout_thread.join()
804 + if self.stderr:
805 + stderr_thread.join()
806 +
807 + # All data exchanged. Translate lists into strings.
808 + if stdout != None:
809 + stdout = stdout[0]
810 + if stderr != None:
811 + stderr = stderr[0]
812 +
813 + # Translate newlines, if requested. We cannot let the file
814 + # object do the translation: It is based on stdio, which is
815 + # impossible to combine with select (unless forcing no
816 + # buffering).
817 + if self.universal_newlines and hasattr(open, 'newlines'):
818 + if stdout:
819 + stdout = self._translate_newlines(stdout)
820 + if stderr:
821 + stderr = self._translate_newlines(stderr)
822 +
823 + self.wait()
824 + return (stdout, stderr)
825 +
826 + else:
827 + #
828 + # POSIX methods
829 + #
830 + def _get_handles(self, stdin, stdout, stderr):
831 + """Construct and return tupel with IO objects:
832 + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
833 + """
834 + p2cread, p2cwrite = None, None
835 + c2pread, c2pwrite = None, None
836 + errread, errwrite = None, None
837 +
838 + if stdin == None:
839 + pass
840 + elif stdin == PIPE:
841 + p2cread, p2cwrite = os.pipe()
842 + elif type(stdin) == types.IntType:
843 + p2cread = stdin
844 + else:
845 + # Assuming file-like object
846 + p2cread = stdin.fileno()
847 +
848 + if stdout == None:
849 + pass
850 + elif stdout == PIPE:
851 + c2pread, c2pwrite = os.pipe()
852 + elif type(stdout) == types.IntType:
853 + c2pwrite = stdout
854 + else:
855 + # Assuming file-like object
856 + c2pwrite = stdout.fileno()
857 +
858 + if stderr == None:
859 + pass
860 + elif stderr == PIPE:
861 + errread, errwrite = os.pipe()
862 + elif stderr == STDOUT:
863 + errwrite = c2pwrite
864 + elif type(stderr) == types.IntType:
865 + errwrite = stderr
866 + else:
867 + # Assuming file-like object
868 + errwrite = stderr.fileno()
869 +
870 + return (p2cread, p2cwrite,
871 + c2pread, c2pwrite,
872 + errread, errwrite)
873 +
874 +
875 + def _set_cloexec_flag(self, fd):
876 + try:
877 + cloexec_flag = fcntl.FD_CLOEXEC
878 + except AttributeError:
879 + cloexec_flag = 1
880 +
881 + old = fcntl.fcntl(fd, fcntl.F_GETFD)
882 + fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag)
883 +
884 +
885 + def _close_fds(self, but):
886 + for i in range(3, MAXFD):
887 + if i == but:
888 + continue
889 + try:
890 + os.close(i)
891 + except:
892 + pass
893 +
894 +
895 + def _execute_child(self, args, executable, preexec_fn, close_fds,
896 + cwd, env, universal_newlines,
897 + startupinfo, creationflags, shell,
898 + p2cread, p2cwrite,
899 + c2pread, c2pwrite,
900 + errread, errwrite):
901 + """Execute program (POSIX version)"""
902 +
903 + if isinstance(args, types.StringTypes):
904 + args = [args]
905 +
906 + if shell:
907 + args = ["/bin/sh", "-c"] + args
908 +
909 + if executable == None:
910 + executable = args[0]
911 +
912 + # For transferring possible exec failure from child to parent
913 + # The first char specifies the exception type: 0 means
914 + # OSError, 1 means some other error.
915 + errpipe_read, errpipe_write = os.pipe()
916 + self._set_cloexec_flag(errpipe_write)
917 +
918 + self.pid = os.fork()
919 + if self.pid == 0:
920 + # Child
921 + try:
922 + # Close parent's pipe ends
923 + if p2cwrite:
924 + os.close(p2cwrite)
925 + if c2pread:
926 + os.close(c2pread)
927 + if errread:
928 + os.close(errread)
929 + os.close(errpipe_read)
930 +
931 + # Dup fds for child
932 + if p2cread:
933 + os.dup2(p2cread, 0)
934 + if c2pwrite:
935 + os.dup2(c2pwrite, 1)
936 + if errwrite:
937 + os.dup2(errwrite, 2)
938 +
939 + # Close pipe fds. Make sure we doesn't close the same
940 + # fd more than once.
941 + if p2cread:
942 + os.close(p2cread)
943 + if c2pwrite and c2pwrite not in (p2cread,):
944 + os.close(c2pwrite)
945 + if errwrite and errwrite not in (p2cread, c2pwrite):
946 + os.close(errwrite)
947 +
948 + # Close all other fds, if asked for
949 + if close_fds:
950 + self._close_fds(but=errpipe_write)
951 +
952 + if cwd != None:
953 + os.chdir(cwd)
954 +
955 + if preexec_fn:
956 + apply(preexec_fn)
957 +
958 + if env == None:
959 + os.execvp(executable, args)
960 + else:
961 + os.execvpe(executable, args, env)
962 +
963 + except:
964 + exc_type, exc_value, tb = sys.exc_info()
965 + # Save the traceback and attach it to the exception object
966 + exc_lines = traceback.format_exception(exc_type,
967 + exc_value,
968 + tb)
969 + exc_value.child_traceback = ''.join(exc_lines)
970 + os.write(errpipe_write, pickle.dumps(exc_value))
971 +
972 + # This exitcode won't be reported to applications, so it
973 + # really doesn't matter what we return.
974 + os._exit(255)
975 +
976 + # Parent
977 + os.close(errpipe_write)
978 + if p2cread and p2cwrite:
979 + os.close(p2cread)
980 + if c2pwrite and c2pread:
981 + os.close(c2pwrite)
982 + if errwrite and errread:
983 + os.close(errwrite)
984 +
985 + # Wait for exec to fail or succeed; possibly raising exception
986 + data = os.read(errpipe_read, 1048576) # Exceptions limited to 1 MB
987 + os.close(errpipe_read)
988 + if data != "":
989 + os.waitpid(self.pid, 0)
990 + child_exception = pickle.loads(data)
991 + raise child_exception
992 +
993 +
994 + def _handle_exitstatus(self, sts):
995 + if os.WIFSIGNALED(sts):
996 + self.returncode = -os.WTERMSIG(sts)
997 + elif os.WIFEXITED(sts):
998 + self.returncode = os.WEXITSTATUS(sts)
999 + else:
1000 + # Should never happen
1001 + raise RuntimeError("Unknown child exit status!")
1002 +
1003 + _active.remove(self)
1004 +
1005 +
1006 + def poll(self):
1007 + """Check if child process has terminated. Returns returncode
1008 + attribute."""
1009 + if self.returncode == None:
1010 + try:
1011 + pid, sts = os.waitpid(self.pid, os.WNOHANG)
1012 + if pid == self.pid:
1013 + self._handle_exitstatus(sts)
1014 + except os.error:
1015 + pass
1016 + return self.returncode
1017 +
1018 +
1019 + def wait(self):
1020 + """Wait for child process to terminate. Returns returncode
1021 + attribute."""
1022 + if self.returncode == None:
1023 + pid, sts = os.waitpid(self.pid, 0)
1024 + self._handle_exitstatus(sts)
1025 + return self.returncode
1026 +
1027 +
1028 + def communicate(self, input=None):
1029 + """Interact with process: Send data to stdin. Read data from
1030 + stdout and stderr, until end-of-file is reached. Wait for
1031 + process to terminate. The optional input argument should be a
1032 + string to be sent to the child process, or None, if no data
1033 + should be sent to the child.
1034 +
1035 + communicate() returns a tuple (stdout, stderr)."""
1036 + read_set = []
1037 + write_set = []
1038 + stdout = None # Return
1039 + stderr = None # Return
1040 +
1041 + if self.stdin:
1042 + # Flush stdio buffer. This might block, if the user has
1043 + # been writing to .stdin in an uncontrolled fashion.
1044 + self.stdin.flush()
1045 + if input:
1046 + write_set.append(self.stdin)
1047 + else:
1048 + self.stdin.close()
1049 + if self.stdout:
1050 + read_set.append(self.stdout)
1051 + stdout = []
1052 + if self.stderr:
1053 + read_set.append(self.stderr)
1054 + stderr = []
1055 +
1056 + while read_set or write_set:
1057 + rlist, wlist, xlist = select.select(read_set, write_set, [])
1058 +
1059 + if self.stdin in wlist:
1060 + # When select has indicated that the file is writable,
1061 + # we can write up to PIPE_BUF bytes without risk
1062 + # blocking. POSIX defines PIPE_BUF >= 512
1063 + bytes_written = os.write(self.stdin.fileno(), input[:512])
1064 + input = input[bytes_written:]
1065 + if not input:
1066 + self.stdin.close()
1067 + write_set.remove(self.stdin)
1068 +
1069 + if self.stdout in rlist:
1070 + data = os.read(self.stdout.fileno(), 1024)
1071 + if data == "":
1072 + self.stdout.close()
1073 + read_set.remove(self.stdout)
1074 + stdout.append(data)
1075 +
1076 + if self.stderr in rlist:
1077 + data = os.read(self.stderr.fileno(), 1024)
1078 + if data == "":
1079 + self.stderr.close()
1080 + read_set.remove(self.stderr)
1081 + stderr.append(data)
1082 +
1083 + # All data exchanged. Translate lists into strings.
1084 + if stdout != None:
1085 + stdout = ''.join(stdout)
1086 + if stderr != None:
1087 + stderr = ''.join(stderr)
1088 +
1089 + # Translate newlines, if requested. We cannot let the file
1090 + # object do the translation: It is based on stdio, which is
1091 + # impossible to combine with select (unless forcing no
1092 + # buffering).
1093 + if self.universal_newlines and hasattr(open, 'newlines'):
1094 + if stdout:
1095 + stdout = self._translate_newlines(stdout)
1096 + if stderr:
1097 + stderr = self._translate_newlines(stderr)
1098 +
1099 + self.wait()
1100 + return (stdout, stderr)
1101 +
1102 +
1103 +def _demo_posix():
1104 + #
1105 + # Example 1: Simple redirection: Get process list
1106 + #
1107 + plist = Popen(["ps"], stdout=PIPE).communicate()[0]
1108 + print "Process list:"
1109 + print plist
1110 +
1111 + #
1112 + # Example 2: Change uid before executing child
1113 + #
1114 + if os.getuid() == 0:
1115 + p = Popen(["id"], preexec_fn=lambda: os.setuid(100))
1116 + p.wait()
1117 +
1118 + #
1119 + # Example 3: Connecting several subprocesses
1120 + #
1121 + print "Looking for 'hda'..."
1122 + p1 = Popen(["dmesg"], stdout=PIPE)
1123 + p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
1124 + print repr(p2.communicate()[0])
1125 +
1126 + #
1127 + # Example 4: Catch execution error
1128 + #
1129 + print
1130 + print "Trying a weird file..."
1131 + try:
1132 + print Popen(["/this/path/does/not/exist"]).communicate()
1133 + except OSError, e:
1134 + if e.errno == errno.ENOENT:
1135 + print "The file didn't exist. I thought so..."
1136 + print "Child traceback:"
1137 + print e.child_traceback
1138 + else:
1139 + print "Error", e.errno
1140 + else:
1141 + print >>sys.stderr, "Gosh. No error."
1142 +
1143 +
1144 +def _demo_windows():
1145 + #
1146 + # Example 1: Connecting several subprocesses
1147 + #
1148 + print "Looking for 'PROMPT' in set output..."
1149 + p1 = Popen("set", stdout=PIPE, shell=True)
1150 + p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE)
1151 + print repr(p2.communicate()[0])
1152 +
1153 + #
1154 + # Example 2: Simple execution of program
1155 + #
1156 + print "Executing calc..."
1157 + p = Popen("calc")
1158 + p.wait()
1159 +
1160 +
1161 +if __name__ == "__main__":
1162 + if mswindows:
1163 + _demo_windows()
1164 + else:
1165 + _demo_posix()
git-core.spec.in
+5 -3
@@ -9,7 +9,7 @@ URL: http://kernel.org/pub/software/scm/git/
9 Source: http://kernel.org/pub/software/scm/git/%{name}-%{version}.tar.gz
10 BuildRequires: zlib-devel, openssl-devel, curl-devel %{!?_without_docs:, xmlto, asciidoc > 6.0.3}
11 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
12 -Requires: rsync, rcs, curl, less, openssh-clients, python >= 2.4, tk
12 +Requires: rsync, rcs, curl, less, openssh-clients, python >= 2.3, tk
13
14 %description
15 This is a stupid (but extremely fast) directory content manager. It
@@ -23,11 +23,13 @@ elsewhere for tools for ordinary humans layered on top of this.
23 %setup -q
24
25 %build
26 -make COPTS="$RPM_OPT_FLAGS" prefix=%{_prefix} all %{!?_without_docs: doc}
26 +make COPTS="$RPM_OPT_FLAGS" WITH_OWN_SUBPROCESS_PY=YesPlease \
27 + prefix=%{_prefix} all %{!?_without_docs: doc}
28
29 %install
30 rm -rf $RPM_BUILD_ROOT
30 -make DESTDIR=$RPM_BUILD_ROOT prefix=%{_prefix} mandir=%{_mandir} \
31 +make DESTDIR=$RPM_BUILD_ROOT WITH_OWN_SUBPROCESS_PY=YesPlease \
32 + prefix=%{_prefix} mandir=%{_mandir} \
33 install %{!?_without_docs: install-doc}
34
35 %clean
gitMergeCommon.py
-6
@@ -11,12 +11,6 @@ def printList(list, file=sys.stdout):
11 file.write(' ')
12 file.write('\n')
13
14 -if sys.version_info[0] < 2 or \
15 - (sys.version_info[0] == 2 and sys.version_info[1] < 4):
16 - die('Python version 2.4 required, found', \
17 - str(sys.version_info[0])+'.'+str(sys.version_info[1])+'.'+ \
18 - str(sys.version_info[2]))
19 -
14 import subprocess
15
16 # Debugging machinery