Inheritance diagram for GaudiTest.GaudiFilterExecutable:

Collaboration diagram for GaudiTest.GaudiFilterExecutable:

Public Member Functions
def	__init__

def	__init__

Public Attributes
	stack_trace_file

Private Member Functions
def	__UseSeparateProcessGroupForChild (self)

def	_HandleChild (self)
	Needs to replace the ones from RedirectedExecutable and TimeoutExecutable. More...

def	__Monitor (self)

def	__UseSeparateProcessGroupForChild (self)

def	_HandleChild (self)
	Needs to replace the ones from RedirectedExecutable and TimeoutExecutable. More...

def	__Monitor (self)

Private Attributes
	__input

	__timeout

	__monitor_pid

	__monitor_thread
	This is the interesting part: dump the stack trace to a file. More...

Detailed Description

Definition at line 906 of file GaudiTest.py.

Constructor & Destructor Documentation

def GaudiTest.GaudiFilterExecutable.__init__	(	self,
		input,
		timeout = `-1`
	)

Create a new 'Filter'.

'input' -- The string containing the input to provide to the
child process.

'timeout' -- As for 'TimeoutExecutable.__init__'.

Definition at line 907 of file GaudiTest.py.

     def __init__(self, input, timeout = -1):
         """Create a new 'Filter'.
 
         'input' -- The string containing the input to provide to the
         child process.
 
         'timeout' -- As for 'TimeoutExecutable.__init__'."""
 
         super(GaudiFilterExecutable, self).__init__(input, timeout)
         self.__input = input
         self.__timeout = timeout
         self.stack_trace_file = None
         # Temporary file to pass the stack trace from one process to the other
         # The file must be closed and reopened when needed to avoid conflicts
         # between the processes
         tmpf = tempfile.mkstemp()
         os.close(tmpf[0])
         self.stack_trace_file = tmpf[1] # remember only the name
 

def GaudiTest.GaudiFilterExecutable.__init__	(	self,
		input,
		timeout = `-1`
	)

Create a new 'Filter'.

'input' -- The string containing the input to provide to the
child process.

'timeout' -- As for 'TimeoutExecutable.__init__'.

Definition at line 907 of file GaudiTest.py.

     def __init__(self, input, timeout = -1):
         """Create a new 'Filter'.
 
         'input' -- The string containing the input to provide to the
         child process.
 
         'timeout' -- As for 'TimeoutExecutable.__init__'."""
 
         super(GaudiFilterExecutable, self).__init__(input, timeout)
         self.__input = input
         self.__timeout = timeout
         self.stack_trace_file = None
         # Temporary file to pass the stack trace from one process to the other
         # The file must be closed and reopened when needed to avoid conflicts
         # between the processes
         tmpf = tempfile.mkstemp()
         os.close(tmpf[0])
         self.stack_trace_file = tmpf[1] # remember only the name
 

Member Function Documentation

def GaudiTest.GaudiFilterExecutable.__Monitor ( self )

private

Code copied from FilterExecutable.
Kill the child if the timeout expires.

This function is run in the monitoring thread.

Definition at line 1045 of file GaudiTest.py.

         def __Monitor(self):
             """Code copied from FilterExecutable.
             Kill the child if the timeout expires.
 
             This function is run in the monitoring thread."""
 
             # The timeout may be expressed as a floating-point value
             # on UNIX, but it must be an integer number of
             # milliseconds when passed to WaitForSingleObject.
             timeout = int(self.__timeout * 1000)
             # Wait for the child process to terminate or for the
             # timer to expire.
             result = win32event.WaitForSingleObject(self._GetChildPID(),
                                                     timeout)
             # If the timeout occurred, kill the child process.
             if result == win32con.WAIT_TIMEOUT:
                 self.Kill()
 

def GaudiTest.GaudiFilterExecutable.__Monitor ( self )

private

Code copied from FilterExecutable.
Kill the child if the timeout expires.

This function is run in the monitoring thread.

Definition at line 1045 of file GaudiTest.py.

         def __Monitor(self):
             """Code copied from FilterExecutable.
             Kill the child if the timeout expires.
 
             This function is run in the monitoring thread."""
 
             # The timeout may be expressed as a floating-point value
             # on UNIX, but it must be an integer number of
             # milliseconds when passed to WaitForSingleObject.
             timeout = int(self.__timeout * 1000)
             # Wait for the child process to terminate or for the
             # timer to expire.
             result = win32event.WaitForSingleObject(self._GetChildPID(),
                                                     timeout)
             # If the timeout occurred, kill the child process.
             if result == win32con.WAIT_TIMEOUT:
                 self.Kill()
 

def GaudiTest.GaudiFilterExecutable.__UseSeparateProcessGroupForChild ( self )

private

Copied from TimeoutExecutable to allow the re-implementation of
   _HandleChild.

Definition at line 926 of file GaudiTest.py.

     def __UseSeparateProcessGroupForChild(self):
         """Copied from TimeoutExecutable to allow the re-implementation of
            _HandleChild.
         """
         if sys.platform == "win32":
             # In Windows 2000 (or later), we should use "jobs" by
             # analogy with UNIX process groups.  However, that
             # functionality is not (yet) provided by the Python Win32
             # extensions.
             return 0
 
         return self.__timeout >= 0 or self.__timeout == -2

def GaudiTest.GaudiFilterExecutable.__UseSeparateProcessGroupForChild ( self )

private

Copied from TimeoutExecutable to allow the re-implementation of
   _HandleChild.

Definition at line 926 of file GaudiTest.py.

     def __UseSeparateProcessGroupForChild(self):
         """Copied from TimeoutExecutable to allow the re-implementation of
            _HandleChild.
         """
         if sys.platform == "win32":
             # In Windows 2000 (or later), we should use "jobs" by
             # analogy with UNIX process groups.  However, that
             # functionality is not (yet) provided by the Python Win32
             # extensions.
             return 0
 
         return self.__timeout >= 0 or self.__timeout == -2

def GaudiTest.GaudiFilterExecutable._HandleChild ( self )

private

Needs to replace the ones from RedirectedExecutable and TimeoutExecutable.

Code copied from both FilterExecutable and TimeoutExecutable.

Definition at line 940 of file GaudiTest.py.

     def _HandleChild(self):
         """Code copied from both FilterExecutable and TimeoutExecutable.
         """
         # Close the pipe ends that we do not need.
         if self._stdin_pipe:
             self._ClosePipeEnd(self._stdin_pipe[0])
         if self._stdout_pipe:
             self._ClosePipeEnd(self._stdout_pipe[1])
         if self._stderr_pipe:
             self._ClosePipeEnd(self._stderr_pipe[1])
 
         # The pipes created by 'RedirectedExecutable' must be closed
         # before the monitor process (created by 'TimeoutExecutable')
         # is created.  Otherwise, if the child process dies, 'select'
         # in the parent will not return if the monitor process may
         # still have one of the file descriptors open.
 
         super(qm.executable.TimeoutExecutable, self)._HandleChild()
 
         if self.__UseSeparateProcessGroupForChild():
             # Put the child into its own process group.  This step is
             # performed in both the parent and the child; therefore both
             # processes can safely assume that the creation of the process
             # group has taken place.
             child_pid = self._GetChildPID()
             try:
                 os.setpgid(child_pid, child_pid)
             except:
                 # The call to setpgid may fail if the child has exited,
                 # or has already called 'exec'.  In that case, we are
                 # guaranteed that the child has already put itself in the
                 # desired process group.
                 pass
             # Create the monitoring process.
             #
             # If the monitoring process is in parent's process group and
             # kills the child after waitpid has returned in the parent, we
             # may end up trying to kill a process group other than the one
             # that we intend to kill.  Therefore, we put the monitoring
             # process in the same process group as the child; that ensures
             # that the process group will persist until the monitoring
             # process kills it.
             self.__monitor_pid = os.fork()
             if self.__monitor_pid != 0:
                 # Make sure that the monitoring process is placed into the
                 # child's process group before the parent process calls
                 # 'waitpid'.  In this way, we are guaranteed that the process
                 # group as the child
                 os.setpgid(self.__monitor_pid, child_pid)
             else:
                 # Put the monitoring process into the child's process
                 # group.  We know the process group still exists at
                 # this point because either (a) we are in the process
                 # group, or (b) the parent has not yet called waitpid.
                 os.setpgid(0, child_pid)
 
                 # Close all open file descriptors.  They are not needed
                 # in the monitor process.  Furthermore, when the parent
                 # closes the write end of the stdin pipe to the child,
                 # we do not want the pipe to remain open; leaving the
                 # pipe open in the monitor process might cause the child
                 # to block waiting for additional input.
                 try:
                     max_fds = os.sysconf("SC_OPEN_MAX")
                 except:
                     max_fds = 256
                 for fd in xrange(max_fds):
                     try:
                         os.close(fd)
                     except:
                         pass
                 try:
                     if self.__timeout >= 0:
                         # Give the child time to run.
                         time.sleep (self.__timeout)
                         #######################################################
                         ### This is the interesting part: dump the stack trace to a file
                         if sys.platform == "linux2": # we should be have /proc and gdb
                             cmd = ["gdb",
                                    os.path.join("/proc", str(child_pid), "exe"),
                                    str(child_pid),
                                    "-batch", "-n", "-x",
                                    "'%s'" % os.path.join(os.path.dirname(__file__), "stack-trace.gdb")]
                             # FIXME: I wanted to use subprocess.Popen, but it doesn't want to work
                             #        in this context.
                             o = os.popen(" ".join(cmd)).read()
                             open(self.stack_trace_file,"w").write(o)
                         #######################################################
 
                         # Kill all processes in the child process group.
                         os.kill(0, signal.SIGKILL)
                     else:
                         # This call to select will never terminate.
                         select.select ([], [], [])
                 finally:
                     # Exit.  This code is in a finally clause so that
                     # we are guaranteed to get here no matter what.
                     os._exit(0)
         elif self.__timeout >= 0 and sys.platform == "win32":
             # Create a monitoring thread.
             self.__monitor_thread = Thread(target = self.__Monitor)
             self.__monitor_thread.start()
 

def GaudiTest.GaudiFilterExecutable._HandleChild ( self )

private

Needs to replace the ones from RedirectedExecutable and TimeoutExecutable.

Code copied from both FilterExecutable and TimeoutExecutable.

Definition at line 940 of file GaudiTest.py.

     def _HandleChild(self):
         """Code copied from both FilterExecutable and TimeoutExecutable.
         """
         # Close the pipe ends that we do not need.
         if self._stdin_pipe:
             self._ClosePipeEnd(self._stdin_pipe[0])
         if self._stdout_pipe:
             self._ClosePipeEnd(self._stdout_pipe[1])
         if self._stderr_pipe:
             self._ClosePipeEnd(self._stderr_pipe[1])
 
         # The pipes created by 'RedirectedExecutable' must be closed
         # before the monitor process (created by 'TimeoutExecutable')
         # is created.  Otherwise, if the child process dies, 'select'
         # in the parent will not return if the monitor process may
         # still have one of the file descriptors open.
 
         super(qm.executable.TimeoutExecutable, self)._HandleChild()
 
         if self.__UseSeparateProcessGroupForChild():
             # Put the child into its own process group.  This step is
             # performed in both the parent and the child; therefore both
             # processes can safely assume that the creation of the process
             # group has taken place.
             child_pid = self._GetChildPID()
             try:
                 os.setpgid(child_pid, child_pid)
             except:
                 # The call to setpgid may fail if the child has exited,
                 # or has already called 'exec'.  In that case, we are
                 # guaranteed that the child has already put itself in the
                 # desired process group.
                 pass
             # Create the monitoring process.
             #
             # If the monitoring process is in parent's process group and
             # kills the child after waitpid has returned in the parent, we
             # may end up trying to kill a process group other than the one
             # that we intend to kill.  Therefore, we put the monitoring
             # process in the same process group as the child; that ensures
             # that the process group will persist until the monitoring
             # process kills it.
             self.__monitor_pid = os.fork()
             if self.__monitor_pid != 0:
                 # Make sure that the monitoring process is placed into the
                 # child's process group before the parent process calls
                 # 'waitpid'.  In this way, we are guaranteed that the process
                 # group as the child
                 os.setpgid(self.__monitor_pid, child_pid)
             else:
                 # Put the monitoring process into the child's process
                 # group.  We know the process group still exists at
                 # this point because either (a) we are in the process
                 # group, or (b) the parent has not yet called waitpid.
                 os.setpgid(0, child_pid)
 
                 # Close all open file descriptors.  They are not needed
                 # in the monitor process.  Furthermore, when the parent
                 # closes the write end of the stdin pipe to the child,
                 # we do not want the pipe to remain open; leaving the
                 # pipe open in the monitor process might cause the child
                 # to block waiting for additional input.
                 try:
                     max_fds = os.sysconf("SC_OPEN_MAX")
                 except:
                     max_fds = 256
                 for fd in xrange(max_fds):
                     try:
                         os.close(fd)
                     except:
                         pass
                 try:
                     if self.__timeout >= 0:
                         # Give the child time to run.
                         time.sleep (self.__timeout)
                         #######################################################
                         ### This is the interesting part: dump the stack trace to a file
                         if sys.platform == "linux2": # we should be have /proc and gdb
                             cmd = ["gdb",
                                    os.path.join("/proc", str(child_pid), "exe"),
                                    str(child_pid),
                                    "-batch", "-n", "-x",
                                    "'%s'" % os.path.join(os.path.dirname(__file__), "stack-trace.gdb")]
                             # FIXME: I wanted to use subprocess.Popen, but it doesn't want to work
                             #        in this context.
                             o = os.popen(" ".join(cmd)).read()
                             open(self.stack_trace_file,"w").write(o)
                         #######################################################
 
                         # Kill all processes in the child process group.
                         os.kill(0, signal.SIGKILL)
                     else:
                         # This call to select will never terminate.
                         select.select ([], [], [])
                 finally:
                     # Exit.  This code is in a finally clause so that
                     # we are guaranteed to get here no matter what.
                     os._exit(0)
         elif self.__timeout >= 0 and sys.platform == "win32":
             # Create a monitoring thread.
             self.__monitor_thread = Thread(target = self.__Monitor)
             self.__monitor_thread.start()
 

Member Data Documentation

GaudiTest.GaudiFilterExecutable.__input

private

Definition at line 916 of file GaudiTest.py.

GaudiTest.GaudiFilterExecutable.__monitor_pid

private

Definition at line 982 of file GaudiTest.py.

GaudiTest.GaudiFilterExecutable.__monitor_thread

private

This is the interesting part: dump the stack trace to a file.

Definition at line 1040 of file GaudiTest.py.

GaudiTest.GaudiFilterExecutable.__timeout

private

Definition at line 917 of file GaudiTest.py.

GaudiTest.GaudiFilterExecutable.stack_trace_file

Definition at line 918 of file GaudiTest.py.

The documentation for this class was generated from the following file:

InstallArea/x86_64-slc6-gcc48-opt/qmtest_classes/GaudiTest.py

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation