def processEnded(self, reason):
"""See `ProcessProtocol.processEnded`.
If the process dies and we're waiting to SIGKILL it, we can stop
waiting.
"""
ProcessProtocol.processEnded(self, reason)
if self._sigkill_delayed_call is not None:
self._sigkill_delayed_call.cancel()
self._sigkill_delayed_call = None
def processEnded(self, reason):
"""See `ProcessProtocol.processEnded`.
If the process dies and we're waiting to SIGKILL it, we can stop
waiting.
"""
ProcessProtocol.processEnded(self, reason)
if self._sigkill_delayed_call is not None:
self._sigkill_delayed_call.cancel()
self._sigkill_delayed_call = None
def processEnded(self, reason):
""" Logging, git process end.
Called when the child process exits and all file descriptors associated
with it have been closed.
"""
self.log("process ended", "gateway - git process")
ProcessProtocol.processEnded(self, reason)
# Signal to the other end that the process has ended through
# the underlying SSHSessionProcessProtocol
self.protocol.processEnded(reason)
self._end_record()
def test_run_stdout_stderr_exit(self):
"""Check that we get the expected stdout, stderr and exit code
"""
stdoutText = "output out o text"
stderrText = "error err e text"
exitCode = 42
pythonScript = ("import sys;"
"sys.stdout.write('%s');"
"sys.stderr.write('%s');"
"exit(%i);" % (stdoutText, stderrText, exitCode))
command = "%s -c %r" % (PYTHON_COMMAND, pythonScript)
disconnectedDeferred = defer.Deferred()
protocol = ProcessProtocol()
protocol.processEnded = disconnectedDeferred.callback
resultDeferred = self.inductor.run(command, uid=UID)
resultDeferred.addErrback(self.fail)
@resultDeferred.addCallback
def checkResult(res):
r_stdoutText, r_stderrText, r_exitCode = res
self.assertEqual(r_stdoutText, stdoutText,
"stdout not as expected")
self.assertEqual(r_stderrText, stderrText,
"stderr not as expected")
self.assertEqual(r_exitCode, exitCode, "unexpected exit code")
return resultDeferred
def test_run_stdout_stderr_exit(self):
"""Check that we get the expected stdout, stderr and exit code
"""
stdoutText = "output out o text"
stderrText = "error err e text"
exitCode = 42
pythonScript = ("import sys;"
"sys.stdout.write('%s');"
"sys.stderr.write('%s');"
"exit(%i);"
% (stdoutText, stderrText, exitCode))
command = "%s -c %r" % (PYTHON_COMMAND, pythonScript)
disconnectedDeferred = defer.Deferred()
protocol = ProcessProtocol()
protocol.processEnded = disconnectedDeferred.callback
resultDeferred = self.inductor.run(command, uid=UID)
resultDeferred.addErrback(self.fail)
@resultDeferred.addCallback
def checkResult(res):
r_stdoutText, r_stderrText, r_exitCode = res
self.assertEqual(r_stdoutText, stdoutText, "stdout not as expected")
self.assertEqual(r_stderrText, stderrText, "stderr not as expected")
self.assertEqual(r_exitCode, exitCode, "unexpected exit code")
return resultDeferred
def start(self):
p = ProcessProtocol()
self.buff = ""
self.protocol = p
p.outReceived = self.got_out
p.processEnded = self.got_exit
reactor.spawnProcess(p, self.cmd[0], self.cmd)
def start(self):
p = ProcessProtocol()
self.buff = ""
self.protocol = p
p.outReceived = self.got_out
p.processEnded = self.got_exit
reactor.spawnProcess(p, self.cmd[0], self.cmd)
def test_execute_exitcode_0(self):
"""Check that we get the expected reason failure object
when a process exits with exit code 0.
"""
processEndedDeferred = defer.Deferred()
protocol = ProcessProtocol()
protocol.processEnded = processEndedDeferred.callback
processDeferred = self.inductor.execute(protocol, SUCCEEDING_COMMAND,
uid=UID)
self.assertFailure(processEndedDeferred, ProcessDone)
return defer.DeferredList([processDeferred, processEndedDeferred],
fireOnOneErrback=True)
def makeDeferredWithProcessProtocol():
"""Returns a (`Deferred`, `ProcessProtocol`) tuple.
The Deferred's `callback()` will be called (with None) if the
`ProcessProtocol` is called back indicating that no error occurred.
Its `errback()` will be called with the `Failure` reason otherwise.
"""
done = Deferred()
protocol = ProcessProtocol()
# Call the errback if the "failure" object indicates a non-zero exit.
protocol.processEnded = lambda reason: (done.errback(reason) if (
reason and not reason.check(ProcessDone)) else done.callback(None))
return done, protocol
def test_execute_exitcode_0(self):
"""Check that we get the expected reason failure object
when a process exits with exit code 0.
"""
processEndedDeferred = defer.Deferred()
protocol = ProcessProtocol()
protocol.processEnded = processEndedDeferred.callback
processDeferred = self.inductor.execute(protocol,
SUCCEEDING_COMMAND,
uid=UID)
self.assertFailure(processEndedDeferred, ProcessDone)
return defer.DeferredList([processDeferred, processEndedDeferred],
fireOnOneErrback=True)
def test_execute_nonzero_exitcode(self):
"""Check that we get the expected failure when a process exits
with a nonzero exit code.
"""
processEndedDeferred = defer.Deferred()
protocol = ProcessProtocol()
protocol.processEnded = processEndedDeferred.callback
processDeferred = self.inductor.execute(protocol, FAILING_COMMAND,
uid=UID)
# Process should return a ProcessTerminated failure
# when it exits with a nonzero exit code
self.assertFailure(processEndedDeferred, ProcessTerminated)
@processEndedDeferred.addErrback
def checkExitCode(failure):
exitCode = failure.value.exitCode
self.assertNotEqual(exitCode, 0)
return defer.DeferredList([processDeferred, processEndedDeferred],
fireOnOneErrback=True)
def test_execute_nonzero_exitcode(self):
"""Check that we get the expected failure when a process exits
with a nonzero exit code.
"""
processEndedDeferred = defer.Deferred()
protocol = ProcessProtocol()
protocol.processEnded = processEndedDeferred.callback
processDeferred = self.inductor.execute(protocol,
FAILING_COMMAND,
uid=UID)
# Process should return a ProcessTerminated failure
# when it exits with a nonzero exit code
self.assertFailure(processEndedDeferred, ProcessTerminated)
@processEndedDeferred.addErrback
def checkExitCode(failure):
exitCode = failure.value.exitCode
self.assertNotEqual(exitCode, 0)
return defer.DeferredList([processDeferred, processEndedDeferred],
fireOnOneErrback=True)
