[232] | 1 | # -*- coding: iso-8859-1 -*- |
---|
| 2 | |
---|
| 3 | import os |
---|
| 4 | import sys |
---|
| 5 | import string |
---|
| 6 | import popen2 |
---|
| 7 | import stat |
---|
| 8 | import re |
---|
| 9 | import time |
---|
| 10 | import commands |
---|
| 11 | import select |
---|
| 12 | |
---|
| 13 | from os.path import join |
---|
| 14 | |
---|
| 15 | ############################################################################ |
---|
| 16 | ## Error and success return function |
---|
| 17 | def S_ERROR( sMessage = '' ): |
---|
| 18 | return { 'Status': -1, 'OK' : 0, 'Message' : sMessage } |
---|
| 19 | |
---|
| 20 | def S_OK( sValue = None, sPname = 'Value' ): |
---|
| 21 | dResult = { 'Status': 'OK', 'OK' : 1 } |
---|
| 22 | if sValue is not None: |
---|
| 23 | dResult[ sPname ] = sValue |
---|
| 24 | return dResult |
---|
| 25 | |
---|
| 26 | ############################################################################ |
---|
| 27 | class SubprocessExecuter: |
---|
| 28 | |
---|
| 29 | def __init__( self, iTimeout = False ): |
---|
| 30 | self.changeTimeout( iTimeout ) |
---|
| 31 | self.iBufferLimit = 5242880 # 5MB limit for data |
---|
| 32 | |
---|
| 33 | def changeTimeout( self, iTimeout ): |
---|
| 34 | self.iTimeout = iTimeout |
---|
| 35 | if self.iTimeout == 0: |
---|
| 36 | self.iTimeout = False |
---|
| 37 | |
---|
| 38 | def __readFromPipe( self, oPipe, iBaseLength = 0 ): |
---|
| 39 | sData = "" |
---|
| 40 | iMaxSliceLength = 8192 |
---|
| 41 | iLastSliceLength = 8192 |
---|
| 42 | |
---|
| 43 | while iLastSliceLength == iMaxSliceLength: |
---|
| 44 | sReadBuffer = os.read( oPipe, iMaxSliceLength ) |
---|
| 45 | iLastSliceLength = len( sReadBuffer ) |
---|
| 46 | sData += sReadBuffer |
---|
| 47 | if len( sData ) + iBaseLength > self.iBufferLimit: |
---|
| 48 | dRetVal = S_ERROR( "Reached maximum allowed length (%d bytes) for called function return value" % self.iBufferLimit ) |
---|
| 49 | dRetVal[ 'ReadData' ] = sData |
---|
| 50 | return dRetVal |
---|
| 51 | |
---|
| 52 | return S_OK( sData ) |
---|
| 53 | |
---|
| 54 | def __executePythonFunction( self, oFunc, stArgs, oWritePipe ): |
---|
| 55 | try: |
---|
| 56 | os.write( oWritePipe, "%s\n" % str( S_OK( oFunc( *stArgs ) ) ) ) |
---|
| 57 | except Exception, v: |
---|
| 58 | os.write( oWritePipe, "%s\n" % str( S_ERROR( str( v ) ) ) ) |
---|
| 59 | try: |
---|
| 60 | os.close( oWritePipe ) |
---|
| 61 | finally: |
---|
| 62 | os._exit(0) |
---|
| 63 | |
---|
| 64 | def __selectFD( self, lR, iTimeout = False ): |
---|
| 65 | if self.iTimeout and not iTimeout: |
---|
| 66 | iTimeout = self.iTimeout |
---|
| 67 | if not iTimeout: |
---|
| 68 | return select.select( lR , [], [] )[0] |
---|
| 69 | else: |
---|
| 70 | return select.select( lR , [], [], iTimeout )[0] |
---|
| 71 | |
---|
| 72 | def pythonCall( self, oFunction, stArgs ): |
---|
| 73 | oReadPipe, oWritePipe = os.pipe() |
---|
| 74 | iPid = os.fork() |
---|
| 75 | if iPid == 0: |
---|
| 76 | os.close( oReadPipe ) |
---|
| 77 | self.__executePythonFunction( oFunction, stArgs, oWritePipe ) |
---|
| 78 | os.close( oWritePipe ) |
---|
| 79 | else: |
---|
| 80 | os.close( oWritePipe ) |
---|
| 81 | lReadable = self.__selectFD( [ oReadPipe ] ) |
---|
| 82 | if len( lReadable ) == 0: |
---|
| 83 | os.close( oReadPipe ) |
---|
| 84 | os.kill( iPid, 9 ) |
---|
| 85 | os.waitpid( iPid, 0 ) |
---|
| 86 | return S_ERROR( "%d seconds timeout for '%s' call" % ( self.iTimeout, oFunction.__name__ ) ) |
---|
| 87 | elif lReadable[0] == oReadPipe: |
---|
| 88 | dData = self.__readFromPipe( oReadPipe ) |
---|
| 89 | os.close( oReadPipe ) |
---|
| 90 | os.waitpid( iPid, 0 ) |
---|
| 91 | if dData[ 'OK' ]: |
---|
| 92 | return eval( dData[ 'Value' ] ) |
---|
| 93 | return dData |
---|
| 94 | |
---|
| 95 | def __generateSystemCommandError( self, sMessage ): |
---|
| 96 | retVal = S_ERROR( sMessage ) |
---|
| 97 | retVal[ 'stdout' ] = self.lBuffers[0][0] |
---|
| 98 | retVal[ 'stderr' ] = self.lBuffers[1][0] |
---|
| 99 | return retVal |
---|
| 100 | |
---|
| 101 | def __readFromFile( self, oFile, iBaseLength, bAll ): |
---|
| 102 | try: |
---|
| 103 | if bAll: |
---|
| 104 | sData = "".join( oFile.readlines() ) |
---|
| 105 | else: |
---|
| 106 | sData = oFile.readline() |
---|
| 107 | except Exception, v: |
---|
| 108 | pass |
---|
| 109 | if sData == "": |
---|
| 110 | #self.checkAlive() |
---|
| 111 | self.bAlive = False |
---|
| 112 | if len( sData ) + iBaseLength > self.iBufferLimit: |
---|
| 113 | dRetVal = S_ERROR( "Reached maximum allowed length (%d bytes) for called function return value" % self.iBufferLimit ) |
---|
| 114 | dRetVal[ 'ReadData' ] = sData |
---|
| 115 | return dRetVal |
---|
| 116 | |
---|
| 117 | return S_OK( sData ) |
---|
| 118 | |
---|
| 119 | def __readFromSystemCommandOutput( self, oFile, iDataIndex, bAll = False ): |
---|
| 120 | retVal = self.__readFromFile( oFile, len( self.lBuffers[ iDataIndex ][0] ), bAll ) |
---|
| 121 | if retVal[ 'OK' ]: |
---|
| 122 | self.lBuffers[ iDataIndex ][0] += retVal[ 'Value' ] |
---|
| 123 | if not self.oCallback == None: |
---|
| 124 | while self.__callLineCallback( iDataIndex ): |
---|
| 125 | pass |
---|
| 126 | return S_OK() |
---|
| 127 | else: |
---|
| 128 | self.lBuffers[ iDataIndex ][0] += retVal[ 'ReadData' ] |
---|
| 129 | os.kill( self.oChild.pid, 9 ) |
---|
| 130 | self.oChild.wait() |
---|
| 131 | return self.__generateSystemCommandError( "Exceeded maximum buffer size ( %d bytes ) timeout for '%s' call" % ( self.iBufferLimit, self.sCmd ) ) |
---|
| 132 | |
---|
[244] | 133 | def systemCall( self, sCmd, oCallbackFunction = None, arg=None ): |
---|
[232] | 134 | self.sCmd = sCmd |
---|
| 135 | self.oCallback = oCallbackFunction |
---|
[244] | 136 | self.arg = arg |
---|
[232] | 137 | self.oChild = popen2.Popen3( self.sCmd, True ) |
---|
| 138 | self.lBuffers = [ [ "", 0 ], [ "", 0 ] ] |
---|
| 139 | iInitialTime = time.time() |
---|
| 140 | iExitStatus = self.oChild.poll() |
---|
| 141 | |
---|
| 142 | while iExitStatus == -1: |
---|
| 143 | retVal = self.__readFromCommand() |
---|
| 144 | if not retVal[ 'OK' ]: |
---|
| 145 | return retVal |
---|
| 146 | if self.iTimeout and time.time() - iInitialTime > self.iTimeout: |
---|
| 147 | os.kill( self.oChild.pid, 9 ) |
---|
| 148 | self.oChild.wait() |
---|
| 149 | self.__readFromCommand( True ) |
---|
| 150 | self.oChild.fromchild.close() |
---|
| 151 | self.oChild.childerr.close() |
---|
| 152 | return self.__generateSystemCommandError( "Timeout (%d seconds) for '%s' call" % ( self.iTimeout, sCmd ) ) |
---|
| 153 | iExitStatus = self.oChild.poll() |
---|
| 154 | |
---|
| 155 | self.__readFromCommand(True ) |
---|
| 156 | |
---|
| 157 | self.oChild.fromchild.close() |
---|
| 158 | self.oChild.childerr.close() |
---|
| 159 | return S_OK( ( iExitStatus / 256, self.lBuffers[0][0], self.lBuffers[1][0] ) ) |
---|
| 160 | |
---|
| 161 | def __readFromCommand( self, bLast = False ): |
---|
| 162 | if bLast: |
---|
| 163 | retVal = self.__readFromSystemCommandOutput( self.oChild.fromchild, 0, True ) |
---|
| 164 | if not retVal[ 'OK' ]: |
---|
| 165 | return retVal |
---|
| 166 | retVal = self.__readFromSystemCommandOutput( self.oChild.childerr, 1, True ) |
---|
| 167 | if not retVal[ 'OK' ]: |
---|
| 168 | return retVal |
---|
| 169 | else: |
---|
| 170 | lReadable = self.__selectFD( [ self.oChild.fromchild, self.oChild.childerr ], 1 ) |
---|
| 171 | if self.oChild.fromchild in lReadable: |
---|
| 172 | retVal = self.__readFromSystemCommandOutput( self.oChild.fromchild, 0 ) |
---|
| 173 | if not retVal[ 'OK' ]: |
---|
| 174 | return retVal |
---|
| 175 | if self.oChild.childerr in lReadable: |
---|
| 176 | retVal = self.__readFromSystemCommandOutput( self.oChild.childerr, 1 ) |
---|
| 177 | if not retVal[ 'OK' ]: |
---|
| 178 | return retVal |
---|
| 179 | return S_OK() |
---|
| 180 | |
---|
| 181 | |
---|
| 182 | def __callLineCallback( self, iIndex ): |
---|
| 183 | iNextLine = self.lBuffers[ iIndex ][0][ self.lBuffers[ iIndex ][1]: ].find( "\n" ) |
---|
| 184 | if iNextLine > -1: |
---|
[244] | 185 | self.oCallback( iIndex, self.lBuffers[ iIndex ][0][ self.lBuffers[ iIndex ][1]: self.lBuffers[ iIndex ][1] + iNextLine ], arg=self.arg ) |
---|
[232] | 186 | self.lBuffers[ iIndex ][1] += iNextLine + 1 |
---|
| 187 | return True |
---|
| 188 | return False |
---|
| 189 | |
---|
| 190 | ############################################################################ |
---|
| 191 | def redirectOutput(index, buffer): |
---|
| 192 | """Filter function to redirect the std output and error of the job |
---|
| 193 | executable for real-time debugging |
---|
| 194 | """ |
---|
| 195 | print buffer |
---|
| 196 | |
---|
| 197 | |
---|
| 198 | ############################################################################ |
---|
[244] | 199 | def exeCommand( sCmd, iTimeout = 0, oLineCallback = redirectOutput, arg=None): |
---|
[232] | 200 | """Return ( status, output, error, pythonError ) of executing cmd in a shell.""" |
---|
| 201 | oSPE = SubprocessExecuter( iTimeout ) |
---|
[244] | 202 | retVal = oSPE.systemCall( sCmd, oLineCallback, arg=arg) |
---|
[232] | 203 | if retVal[ 'OK' ]: |
---|
| 204 | return retVal[ 'Value' ][0], retVal[ 'Value' ][1], retVal[ 'Value' ][2], 0 |
---|
| 205 | else: |
---|
| 206 | if re.search("Timeout",retVal['Message']): |
---|
| 207 | return 1, retVal['stdout'], retVal['Message'], 2 |
---|
| 208 | else: |
---|
| 209 | return 1, retVal['stdout'], retVal['stderr'], 1 |
---|
| 210 | |
---|
| 211 | ################################################################################# |
---|
| 212 | ###################################### EoF ###################################### |
---|
| 213 | ################################################################################# |
---|