def __create_timeout(analyzer_process): """ Once the analyzer process is started, this method is called. Set up a timeout for the analysis. """ timeout_cleanup[0] = util.setup_process_timeout( analyzer_process, analysis_timeout)
def testTimeoutWithLongRunning(self): """ Test if process timeout watcher kills the process that runs too long, and properly reports that it was killed. """ # Create a process that runs infinitely. proc = subprocess.Popen(['sh', '-c', 'yes'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=os.setpgrp) print("Started `yes` with PID {0}".format(proc.pid)) future = setup_process_timeout(proc, 5) # Simulate waiting for the process. proc.wait() # Execution reaches this spot, which means the process was killed. # (Or it ran way too long and the OS killed it. Usually tests run # quick enough this isn't the case...) killed = future() self.assertTrue(killed, "Process timeout watcher said it did not kill the " "process, but it should have.") with self.assertRaises(psutil.NoSuchProcess): # Try to fetch the process from the system. It shouldn't exist. osproc = psutil.Process(proc.pid) # There can be rare cases that the OS so quickly recycles the PID. if osproc.exe() != 'yes': # (Let's just say it's very, very, VERY rare that it recycles # the PID to another execution of 'yes'...) # If the process exists but it isn't the process we started, # it's the same as if it doesn't existed. raise psutil.NoSuchProcess(proc.pid) # NOTE: This assertion is only viable on Unix systems! self.assertEquals(proc.returncode, -signal.SIGTERM, "`yes` died in a way that it wasn't the process " "timeout watcher killing it.")
def testTimeoutWithProcessFinishing(self): """ Test if process timeout watcher recognises if a process ended gracefully before the timeout expired. """ # Create a process that executes quickly. proc = subprocess.Popen(['echo', 'This process executes quickly!'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) print("Started `echo` with PID {0}".format(proc.pid)) future = setup_process_timeout(proc, 5, signal.SIGKILL) # Simulate waiting for the process. proc.wait() # Execution reaches this spot, the process exited, one way or another. killed = future() self.assertFalse( killed, "Process timeout watcher said it killed the " "process, but it should have exited long beforehand.")