← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xiphos/trusty

« back to all changes in this revision

Viewing changes to wafadmin/pproc.py

  • Committer: Package Import Robot
  • Author(s): Dmitrijs Ledkovs, Dmitrijs Ledkovs
  • Date: 2012-03-11 18:43:32 UTC
  • mfrom: (17.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20120311184332-splq3ecpx7tyi87d
Tags: 3.1.5+dfsg-1
http://bugs.debian.org/654511
[ Dmitrijs Ledkovs <dmitrij.ledkov@ubuntu.com> ]  
* New upstream release.
* Build using webkit backend
* Contains unpacked source for waf binary (Closes: #654511)
* Update debian/copyright to latest specification

Show diffs side-by-side

added added

removed removed

Lines of Context:
wafadmin/pproc.py
 
1
#! /usr/bin/env python
 
2
# encoding: utf-8
 
3
 
 
4
import sys
 
5
mswindows=(sys.platform=="win32")
 
6
import os
 
7
import types
 
8
import traceback
 
9
import gc
 
10
class CalledProcessError(Exception):
 
11
        def __init__(self,returncode,cmd):
 
12
                self.returncode=returncode
 
13
                self.cmd=cmd
 
14
        def __str__(self):
 
15
                return"Command '%s' returned non-zero exit status %d"%(self.cmd,self.returncode)
 
16
if mswindows:
 
17
        import threading
 
18
        import msvcrt
 
19
        if 0:
 
20
                import pywintypes
 
21
                from win32api import GetStdHandle,STD_INPUT_HANDLE,STD_OUTPUT_HANDLE,STD_ERROR_HANDLE
 
22
                from win32api import GetCurrentProcess,DuplicateHandle,GetModuleFileName,GetVersion
 
23
                from win32con import DUPLICATE_SAME_ACCESS,SW_HIDE
 
24
                from win32pipe import CreatePipe
 
25
                from win32process import CreateProcess,STARTUPINFO,GetExitCodeProcess,STARTF_USESTDHANDLES,STARTF_USESHOWWINDOW,CREATE_NEW_CONSOLE
 
26
                from win32event import WaitForSingleObject,INFINITE,WAIT_OBJECT_0
 
27
        else:
 
28
                from _subprocess import*
 
29
                class STARTUPINFO:
 
30
                        dwFlags=0
 
31
                        hStdInput=None
 
32
                        hStdOutput=None
 
33
                        hStdError=None
 
34
                        wShowWindow=0
 
35
                class pywintypes:
 
36
                        error=IOError
 
37
else:
 
38
        import select
 
39
        import errno
 
40
        import fcntl
 
41
        import pickle
 
42
__all__=["Popen","PIPE","STDOUT","call","check_call","CalledProcessError"]
 
43
try:
 
44
        MAXFD=os.sysconf("SC_OPEN_MAX")
 
45
except:
 
46
        MAXFD=256
 
47
try:
 
48
        False
 
49
except NameError:
 
50
        False=0
 
51
        True=1
 
52
_active=[]
 
53
def _cleanup():
 
54
        for inst in _active[:]:
 
55
                if inst.poll(_deadstate=sys.maxint)>=0:
 
56
                        try:
 
57
                                _active.remove(inst)
 
58
                        except ValueError:
 
59
                                pass
 
60
PIPE=-1
 
61
STDOUT=-2
 
62
def call(*popenargs,**kwargs):
 
63
        return Popen(*popenargs,**kwargs).wait()
 
64
def check_call(*popenargs,**kwargs):
 
65
        retcode=call(*popenargs,**kwargs)
 
66
        cmd=kwargs.get("args")
 
67
        if cmd is None:
 
68
                cmd=popenargs[0]
 
69
        if retcode:
 
70
                raise CalledProcessError(retcode,cmd)
 
71
        return retcode
 
72
def list2cmdline(seq):
 
73
        result=[]
 
74
        needquote=False
 
75
        for arg in seq:
 
76
                bs_buf=[]
 
77
                if result:
 
78
                        result.append(' ')
 
79
                needquote=(" "in arg)or("\t"in arg)or arg==""
 
80
                if needquote:
 
81
                        result.append('"')
 
82
                for c in arg:
 
83
                        if c=='\\':
 
84
                                bs_buf.append(c)
 
85
                        elif c=='"':
 
86
                                result.append('\\'*len(bs_buf)*2)
 
87
                                bs_buf=[]
 
88
                                result.append('\\"')
 
89
                        else:
 
90
                                if bs_buf:
 
91
                                        result.extend(bs_buf)
 
92
                                        bs_buf=[]
 
93
                                result.append(c)
 
94
                if bs_buf:
 
95
                        result.extend(bs_buf)
 
96
                if needquote:
 
97
                        result.extend(bs_buf)
 
98
                        result.append('"')
 
99
        return''.join(result)
 
100
class Popen(object):
 
101
        def __init__(self,args,bufsize=0,executable=None,stdin=None,stdout=None,stderr=None,preexec_fn=None,close_fds=False,shell=False,cwd=None,env=None,universal_newlines=False,startupinfo=None,creationflags=0):
 
102
                _cleanup()
 
103
                self._child_created=False
 
104
                if not isinstance(bufsize,(int,long)):
 
105
                        raise TypeError("bufsize must be an integer")
 
106
                if mswindows:
 
107
                        if preexec_fn is not None:
 
108
                                raise ValueError("preexec_fn is not supported on Windows platforms")
 
109
                        if close_fds:
 
110
                                raise ValueError("close_fds is not supported on Windows platforms")
 
111
                else:
 
112
                        if startupinfo is not None:
 
113
                                raise ValueError("startupinfo is only supported on Windows platforms")
 
114
                        if creationflags!=0:
 
115
                                raise ValueError("creationflags is only supported on Windows platforms")
 
116
                self.stdin=None
 
117
                self.stdout=None
 
118
                self.stderr=None
 
119
                self.pid=None
 
120
                self.returncode=None
 
121
                self.universal_newlines=universal_newlines
 
122
                (p2cread,p2cwrite,c2pread,c2pwrite,errread,errwrite)=self._get_handles(stdin,stdout,stderr)
 
123
                self._execute_child(args,executable,preexec_fn,close_fds,cwd,env,universal_newlines,startupinfo,creationflags,shell,p2cread,p2cwrite,c2pread,c2pwrite,errread,errwrite)
 
124
                if mswindows:
 
125
                        if stdin is None and p2cwrite is not None:
 
126
                                os.close(p2cwrite)
 
127
                                p2cwrite=None
 
128
                        if stdout is None and c2pread is not None:
 
129
                                os.close(c2pread)
 
130
                                c2pread=None
 
131
                        if stderr is None and errread is not None:
 
132
                                os.close(errread)
 
133
                                errread=None
 
134
                if p2cwrite:
 
135
                        self.stdin=os.fdopen(p2cwrite,'wb',bufsize)
 
136
                if c2pread:
 
137
                        if universal_newlines:
 
138
                                self.stdout=os.fdopen(c2pread,'rU',bufsize)
 
139
                        else:
 
140
                                self.stdout=os.fdopen(c2pread,'rb',bufsize)
 
141
                if errread:
 
142
                        if universal_newlines:
 
143
                                self.stderr=os.fdopen(errread,'rU',bufsize)
 
144
                        else:
 
145
                                self.stderr=os.fdopen(errread,'rb',bufsize)
 
146
        def _translate_newlines(self,data):
 
147
                data=data.replace("\r\n","\n")
 
148
                data=data.replace("\r","\n")
 
149
                return data
 
150
        def __del__(self,sys=sys):
 
151
                if not self._child_created:
 
152
                        return
 
153
                self.poll(_deadstate=sys.maxint)
 
154
                if self.returncode is None and _active is not None:
 
155
                        _active.append(self)
 
156
        def communicate(self,input=None):
 
157
                if[self.stdin,self.stdout,self.stderr].count(None)>=2:
 
158
                        stdout=None
 
159
                        stderr=None
 
160
                        if self.stdin:
 
161
                                if input:
 
162
                                        self.stdin.write(input)
 
163
                                self.stdin.close()
 
164
                        elif self.stdout:
 
165
                                stdout=self.stdout.read()
 
166
                        elif self.stderr:
 
167
                                stderr=self.stderr.read()
 
168
                        self.wait()
 
169
                        return(stdout,stderr)
 
170
                return self._communicate(input)
 
171
        if mswindows:
 
172
                def _get_handles(self,stdin,stdout,stderr):
 
173
                        if stdin is None and stdout is None and stderr is None:
 
174
                                return(None,None,None,None,None,None)
 
175
                        p2cread,p2cwrite=None,None
 
176
                        c2pread,c2pwrite=None,None
 
177
                        errread,errwrite=None,None
 
178
                        if stdin is None:
 
179
                                p2cread=GetStdHandle(STD_INPUT_HANDLE)
 
180
                        if p2cread is not None:
 
181
                                pass
 
182
                        elif stdin is None or stdin==PIPE:
 
183
                                p2cread,p2cwrite=CreatePipe(None,0)
 
184
                                p2cwrite=p2cwrite.Detach()
 
185
                                p2cwrite=msvcrt.open_osfhandle(p2cwrite,0)
 
186
                        elif isinstance(stdin,int):
 
187
                                p2cread=msvcrt.get_osfhandle(stdin)
 
188
                        else:
 
189
                                p2cread=msvcrt.get_osfhandle(stdin.fileno())
 
190
                        p2cread=self._make_inheritable(p2cread)
 
191
                        if stdout is None:
 
192
                                c2pwrite=GetStdHandle(STD_OUTPUT_HANDLE)
 
193
                        if c2pwrite is not None:
 
194
                                pass
 
195
                        elif stdout is None or stdout==PIPE:
 
196
                                c2pread,c2pwrite=CreatePipe(None,0)
 
197
                                c2pread=c2pread.Detach()
 
198
                                c2pread=msvcrt.open_osfhandle(c2pread,0)
 
199
                        elif isinstance(stdout,int):
 
200
                                c2pwrite=msvcrt.get_osfhandle(stdout)
 
201
                        else:
 
202
                                c2pwrite=msvcrt.get_osfhandle(stdout.fileno())
 
203
                        c2pwrite=self._make_inheritable(c2pwrite)
 
204
                        if stderr is None:
 
205
                                errwrite=GetStdHandle(STD_ERROR_HANDLE)
 
206
                        if errwrite is not None:
 
207
                                pass
 
208
                        elif stderr is None or stderr==PIPE:
 
209
                                errread,errwrite=CreatePipe(None,0)
 
210
                                errread=errread.Detach()
 
211
                                errread=msvcrt.open_osfhandle(errread,0)
 
212
                        elif stderr==STDOUT:
 
213
                                errwrite=c2pwrite
 
214
                        elif isinstance(stderr,int):
 
215
                                errwrite=msvcrt.get_osfhandle(stderr)
 
216
                        else:
 
217
                                errwrite=msvcrt.get_osfhandle(stderr.fileno())
 
218
                        errwrite=self._make_inheritable(errwrite)
 
219
                        return(p2cread,p2cwrite,c2pread,c2pwrite,errread,errwrite)
 
220
                def _make_inheritable(self,handle):
 
221
                        return DuplicateHandle(GetCurrentProcess(),handle,GetCurrentProcess(),0,1,DUPLICATE_SAME_ACCESS)
 
222
                def _find_w9xpopen(self):
 
223
                        w9xpopen=os.path.join(os.path.dirname(GetModuleFileName(0)),"w9xpopen.exe")
 
224
                        if not os.path.exists(w9xpopen):
 
225
                                w9xpopen=os.path.join(os.path.dirname(sys.exec_prefix),"w9xpopen.exe")
 
226
                                if not os.path.exists(w9xpopen):
 
227
                                        raise RuntimeError("Cannot locate w9xpopen.exe, which is needed for Popen to work with your shell or platform.")
 
228
                        return w9xpopen
 
229
                def _execute_child(self,args,executable,preexec_fn,close_fds,cwd,env,universal_newlines,startupinfo,creationflags,shell,p2cread,p2cwrite,c2pread,c2pwrite,errread,errwrite):
 
230
                        if not isinstance(args,types.StringTypes):
 
231
                                args=list2cmdline(args)
 
232
                        if startupinfo is None:
 
233
                                startupinfo=STARTUPINFO()
 
234
                        if None not in(p2cread,c2pwrite,errwrite):
 
235
                                startupinfo.dwFlags|=STARTF_USESTDHANDLES
 
236
                                startupinfo.hStdInput=p2cread
 
237
                                startupinfo.hStdOutput=c2pwrite
 
238
                                startupinfo.hStdError=errwrite
 
239
                        if shell:
 
240
                                startupinfo.dwFlags|=STARTF_USESHOWWINDOW
 
241
                                startupinfo.wShowWindow=SW_HIDE
 
242
                                comspec=os.environ.get("COMSPEC","cmd.exe")
 
243
                                args=comspec+" /c "+args
 
244
                                if(GetVersion()>=0x80000000L or os.path.basename(comspec).lower()=="command.com"):
 
245
                                        w9xpopen=self._find_w9xpopen()
 
246
                                        args='"%s" %s'%(w9xpopen,args)
 
247
                                        creationflags|=CREATE_NEW_CONSOLE
 
248
                        try:
 
249
                                hp,ht,pid,tid=CreateProcess(executable,args,None,None,1,creationflags,env,cwd,startupinfo)
 
250
                        except pywintypes.error,e:
 
251
                                raise WindowsError(*e.args)
 
252
                        self._child_created=True
 
253
                        self._handle=hp
 
254
                        self.pid=pid
 
255
                        ht.Close()
 
256
                        if p2cread is not None:
 
257
                                p2cread.Close()
 
258
                        if c2pwrite is not None:
 
259
                                c2pwrite.Close()
 
260
                        if errwrite is not None:
 
261
                                errwrite.Close()
 
262
                def poll(self,_deadstate=None):
 
263
                        if self.returncode is None:
 
264
                                if WaitForSingleObject(self._handle,0)==WAIT_OBJECT_0:
 
265
                                        self.returncode=GetExitCodeProcess(self._handle)
 
266
                        return self.returncode
 
267
                def wait(self):
 
268
                        if self.returncode is None:
 
269
                                obj=WaitForSingleObject(self._handle,INFINITE)
 
270
                                self.returncode=GetExitCodeProcess(self._handle)
 
271
                        return self.returncode
 
272
                def _readerthread(self,fh,buffer):
 
273
                        buffer.append(fh.read())
 
274
                def _communicate(self,input):
 
275
                        stdout=None
 
276
                        stderr=None
 
277
                        if self.stdout:
 
278
                                stdout=[]
 
279
                                stdout_thread=threading.Thread(target=self._readerthread,args=(self.stdout,stdout))
 
280
                                stdout_thread.setDaemon(True)
 
281
                                stdout_thread.start()
 
282
                        if self.stderr:
 
283
                                stderr=[]
 
284
                                stderr_thread=threading.Thread(target=self._readerthread,args=(self.stderr,stderr))
 
285
                                stderr_thread.setDaemon(True)
 
286
                                stderr_thread.start()
 
287
                        if self.stdin:
 
288
                                if input is not None:
 
289
                                        self.stdin.write(input)
 
290
                                self.stdin.close()
 
291
                        if self.stdout:
 
292
                                stdout_thread.join()
 
293
                        if self.stderr:
 
294
                                stderr_thread.join()
 
295
                        if stdout is not None:
 
296
                                stdout=stdout[0]
 
297
                        if stderr is not None:
 
298
                                stderr=stderr[0]
 
299
                        if self.universal_newlines and hasattr(file,'newlines'):
 
300
                                if stdout:
 
301
                                        stdout=self._translate_newlines(stdout)
 
302
                                if stderr:
 
303
                                        stderr=self._translate_newlines(stderr)
 
304
                        self.wait()
 
305
                        return(stdout,stderr)
 
306
        else:
 
307
                def _get_handles(self,stdin,stdout,stderr):
 
308
                        p2cread,p2cwrite=None,None
 
309
                        c2pread,c2pwrite=None,None
 
310
                        errread,errwrite=None,None
 
311
                        if stdin is None:
 
312
                                pass
 
313
                        elif stdin==PIPE:
 
314
                                p2cread,p2cwrite=os.pipe()
 
315
                        elif isinstance(stdin,int):
 
316
                                p2cread=stdin
 
317
                        else:
 
318
                                p2cread=stdin.fileno()
 
319
                        if stdout is None:
 
320
                                pass
 
321
                        elif stdout==PIPE:
 
322
                                c2pread,c2pwrite=os.pipe()
 
323
                        elif isinstance(stdout,int):
 
324
                                c2pwrite=stdout
 
325
                        else:
 
326
                                c2pwrite=stdout.fileno()
 
327
                        if stderr is None:
 
328
                                pass
 
329
                        elif stderr==PIPE:
 
330
                                errread,errwrite=os.pipe()
 
331
                        elif stderr==STDOUT:
 
332
                                errwrite=c2pwrite
 
333
                        elif isinstance(stderr,int):
 
334
                                errwrite=stderr
 
335
                        else:
 
336
                                errwrite=stderr.fileno()
 
337
                        return(p2cread,p2cwrite,c2pread,c2pwrite,errread,errwrite)
 
338
                def _set_cloexec_flag(self,fd):
 
339
                        try:
 
340
                                cloexec_flag=fcntl.FD_CLOEXEC
 
341
                        except AttributeError:
 
342
                                cloexec_flag=1
 
343
                        old=fcntl.fcntl(fd,fcntl.F_GETFD)
 
344
                        fcntl.fcntl(fd,fcntl.F_SETFD,old|cloexec_flag)
 
345
                def _close_fds(self,but):
 
346
                        for i in xrange(3,MAXFD):
 
347
                                if i==but:
 
348
                                        continue
 
349
                                try:
 
350
                                        os.close(i)
 
351
                                except:
 
352
                                        pass
 
353
                def _execute_child(self,args,executable,preexec_fn,close_fds,cwd,env,universal_newlines,startupinfo,creationflags,shell,p2cread,p2cwrite,c2pread,c2pwrite,errread,errwrite):
 
354
                        if isinstance(args,types.StringTypes):
 
355
                                args=[args]
 
356
                        else:
 
357
                                args=list(args)
 
358
                        if shell:
 
359
                                args=["/bin/sh","-c"]+args
 
360
                        if executable is None:
 
361
                                executable=args[0]
 
362
                        errpipe_read,errpipe_write=os.pipe()
 
363
                        self._set_cloexec_flag(errpipe_write)
 
364
                        gc_was_enabled=gc.isenabled()
 
365
                        gc.disable()
 
366
                        try:
 
367
                                self.pid=os.fork()
 
368
                        except:
 
369
                                if gc_was_enabled:
 
370
                                        gc.enable()
 
371
                                raise
 
372
                        self._child_created=True
 
373
                        if self.pid==0:
 
374
                                try:
 
375
                                        if p2cwrite:
 
376
                                                os.close(p2cwrite)
 
377
                                        if c2pread:
 
378
                                                os.close(c2pread)
 
379
                                        if errread:
 
380
                                                os.close(errread)
 
381
                                        os.close(errpipe_read)
 
382
                                        if p2cread:
 
383
                                                os.dup2(p2cread,0)
 
384
                                        if c2pwrite:
 
385
                                                os.dup2(c2pwrite,1)
 
386
                                        if errwrite:
 
387
                                                os.dup2(errwrite,2)
 
388
                                        if p2cread and p2cread not in(0,):
 
389
                                                os.close(p2cread)
 
390
                                        if c2pwrite and c2pwrite not in(p2cread,1):
 
391
                                                os.close(c2pwrite)
 
392
                                        if errwrite and errwrite not in(p2cread,c2pwrite,2):
 
393
                                                os.close(errwrite)
 
394
                                        if close_fds:
 
395
                                                self._close_fds(but=errpipe_write)
 
396
                                        if cwd is not None:
 
397
                                                os.chdir(cwd)
 
398
                                        if preexec_fn:
 
399
                                                apply(preexec_fn)
 
400
                                        if env is None:
 
401
                                                os.execvp(executable,args)
 
402
                                        else:
 
403
                                                os.execvpe(executable,args,env)
 
404
                                except:
 
405
                                        exc_type,exc_value,tb=sys.exc_info()
 
406
                                        exc_lines=traceback.format_exception(exc_type,exc_value,tb)
 
407
                                        exc_value.child_traceback=''.join(exc_lines)
 
408
                                        os.write(errpipe_write,pickle.dumps(exc_value))
 
409
                                os._exit(255)
 
410
                        if gc_was_enabled:
 
411
                                gc.enable()
 
412
                        os.close(errpipe_write)
 
413
                        if p2cread and p2cwrite:
 
414
                                os.close(p2cread)
 
415
                        if c2pwrite and c2pread:
 
416
                                os.close(c2pwrite)
 
417
                        if errwrite and errread:
 
418
                                os.close(errwrite)
 
419
                        data=os.read(errpipe_read,1048576)
 
420
                        os.close(errpipe_read)
 
421
                        if data!="":
 
422
                                os.waitpid(self.pid,0)
 
423
                                child_exception=pickle.loads(data)
 
424
                                raise child_exception
 
425
                def _handle_exitstatus(self,sts):
 
426
                        if os.WIFSIGNALED(sts):
 
427
                                self.returncode=-os.WTERMSIG(sts)
 
428
                        elif os.WIFEXITED(sts):
 
429
                                self.returncode=os.WEXITSTATUS(sts)
 
430
                        else:
 
431
                                raise RuntimeError("Unknown child exit status!")
 
432
                def poll(self,_deadstate=None):
 
433
                        if self.returncode is None:
 
434
                                try:
 
435
                                        pid,sts=os.waitpid(self.pid,os.WNOHANG)
 
436
                                        if pid==self.pid:
 
437
                                                self._handle_exitstatus(sts)
 
438
                                except os.error:
 
439
                                        if _deadstate is not None:
 
440
                                                self.returncode=_deadstate
 
441
                        return self.returncode
 
442
                def wait(self):
 
443
                        if self.returncode is None:
 
444
                                pid,sts=os.waitpid(self.pid,0)
 
445
                                self._handle_exitstatus(sts)
 
446
                        return self.returncode
 
447
                def _communicate(self,input):
 
448
                        read_set=[]
 
449
                        write_set=[]
 
450
                        stdout=None
 
451
                        stderr=None
 
452
                        if self.stdin:
 
453
                                self.stdin.flush()
 
454
                                if input:
 
455
                                        write_set.append(self.stdin)
 
456
                                else:
 
457
                                        self.stdin.close()
 
458
                        if self.stdout:
 
459
                                read_set.append(self.stdout)
 
460
                                stdout=[]
 
461
                        if self.stderr:
 
462
                                read_set.append(self.stderr)
 
463
                                stderr=[]
 
464
                        input_offset=0
 
465
                        while read_set or write_set:
 
466
                                rlist,wlist,xlist=select.select(read_set,write_set,[])
 
467
                                if self.stdin in wlist:
 
468
                                        bytes_written=os.write(self.stdin.fileno(),buffer(input,input_offset,512))
 
469
                                        input_offset+=bytes_written
 
470
                                        if input_offset>=len(input):
 
471
                                                self.stdin.close()
 
472
                                                write_set.remove(self.stdin)
 
473
                                if self.stdout in rlist:
 
474
                                        data=os.read(self.stdout.fileno(),1024)
 
475
                                        if data=="":
 
476
                                                self.stdout.close()
 
477
                                                read_set.remove(self.stdout)
 
478
                                        stdout.append(data)
 
479
                                if self.stderr in rlist:
 
480
                                        data=os.read(self.stderr.fileno(),1024)
 
481
                                        if data=="":
 
482
                                                self.stderr.close()
 
483
                                                read_set.remove(self.stderr)
 
484
                                        stderr.append(data)
 
485
                        if stdout is not None:
 
486
                                stdout=''.join(stdout)
 
487
                        if stderr is not None:
 
488
                                stderr=''.join(stderr)
 
489
                        if self.universal_newlines and hasattr(file,'newlines'):
 
490
                                if stdout:
 
491
                                        stdout=self._translate_newlines(stdout)
 
492
                                if stderr:
 
493
                                        stderr=self._translate_newlines(stderr)
 
494
                        self.wait()
 
495
                        return(stdout,stderr)
 
496