27

import wx

    28

import subprocess, ctypes

    29

import threading

    30

import os

    32

    33

class outputThread(threading.Thread):

    34

    """

    35

    Thread is used to print the output of a command to the stdout

    36

    """

    37

    def __init__(self, Proc, fd, callback=None, endcallback=None):

    38

        threading.Thread.__init__(self)

    39

        self.killed = False

    40

        self.finished = False

    41

        self.retval = None

    42

        self.Proc = Proc

    43

        self.callback = callback

    44

        self.endcallback = endcallback

    45

        self.fd = fd

    47

    def run(self):

    48

        outeof = False

    49

        self.retval = self.Proc.poll()

    50

        while not self.retval and not self.killed and not outeof:   

    51

            outchunk = self.fd.readline()

    52

            if outchunk == '': outeof = True

    53

            if self.callback :

    54

                wx.CallAfter(self.callback,outchunk)

    55

            self.retval=self.Proc.poll()

    56

        if self.endcallback:

    57

            err = self.Proc.wait()

    58

            self.finished = True

    59

            wx.CallAfter(self.endcallback, self.Proc.pid, self.retval)

    61

class ProcessLogger:

    62

    def __init__(self, logger, Command, finish_callback=None, no_stdout=False, no_stderr=False):

    63

        self.logger = logger

    64

        self.Command = Command

    65

        self.finish_callback = finish_callback

    66

        self.no_stdout = no_stdout

    67

        self.no_stderr = no_stderr

    68

        self.errlen = 0

    69

        self.outlen = 0

    70

        self.exitcode = None

    71

        self.outdata = ""

    72

        self.errdata = ""

    73

        self.finished = False

    75

        self.Proc = subprocess.Popen(self.Command, 

    76

                                   cwd = os.getcwd(),

    77

                                   stdin = subprocess.PIPE, 

    78

                                   stdout = subprocess.PIPE, 

    79

                                   stderr = subprocess.STDOUT)

    80

#                                   stderr = subprocess.PIPE)

    82

        self.outt = outputThread(

    83

                      self.Proc,

    84

                      self.Proc.stdout,

    85

                      self.output,

    86

                      self.finish)

    88

        self.outt.start()

    90

#        self.errt = outputThread(

    91

#                      self.Proc,

    92

#                      self.Proc.stderr,

    93

#                      self.errors)

    94

#

    95

#        self.errt.start()

    97

    def output(self,v):

    98

        self.outdata += v

    99

        self.outlen += 1

   100

        if not self.no_stdout:

   101

            self.logger.write(v)

   103

    def errors(self,v):

   104

        self.errdata += v

   105

        self.errlen += 1

   106

        if not self.no_stderr:

   107

            self.logger.write_warning(v)

   109

    def finish(self, pid,ecode):

   110

        self.finished = True

   111

        self.exitcode = ecode

   112

        if self.exitcode != 0:

   113

            self.logger.write(self.Command + "\n")

   114

            self.logger.write_warning("exited with status %s (pid %s)\n"%(str(ecode),str(pid)))

   115

        if self.finish_callback is not None:

   116

            self.finish_callback(self,ecode,pid)

   119

        self.outt.killed = True

   120

#        self.errt.killed = True

   121

        if wx.Platform == '__WXMSW__':

   122

            PROCESS_TERMINATE = 1

   123

            handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, self.Proc.pid)

   124

            ctypes.windll.kernel32.TerminateProcess(handle, -1)

   125

            ctypes.windll.kernel32.CloseHandle(handle)

   126

        else:

   127

            os.kill(self.Proc.pid)

   129

    def spin(self, timeout=None, out_limit=None, err_limit=None, keyword = None, kill_it = True):

   130

        count = 0

   131

        while not self.finished:

   132

            if err_limit and self.errlen > err_limit:

   133

                break

   134

            if out_limit and self.outlen > out_limit:

   135

                break

   136

            if timeout:

   137

                if count > timeout:

   138

                    break

   139

                count += 1

   140

            if keyword and self.outdata.find(keyword)!=-1:

   141

                    break

   145

        if not self.outt.finished and kill_it:

   146

            self.kill()

   148

        return [self.exitcode, self.outdata, self.errdata]