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