Пример #1
0
    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
Пример #2
0
    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
Пример #3
0
    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()
Пример #4
0
    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
Пример #5
0
    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
Пример #6
0
    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)
Пример #7
0
    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)
Пример #8
0
 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)
Пример #9
0
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
Пример #10
0
 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)
Пример #11
0
 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)
Пример #12
0
    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)