def test_process_stderr_line_calls_stdout_line_processing(self): jobtype = JobType(fake_assignment()) logpool.open_log(jobtype.uuid, self.create_file(), ignore_existing=True) protocol = Mock(id=4) with patch.object(jobtype, "process_stdout_line") as process_mock: jobtype.process_stderr_line(protocol, "stderr 4") process_mock.assert_called_with(protocol, "stderr 4")
def _start(self): """ The internal method that gets called to start the job type. Usually this calls :meth:`start` though more advanced behaviors could override this and :meth`start`. .. warning:: Read the source code before overriding this method on your own. This method sets a couple of instance variables and returns a tuple that is relied upon elsewhere. """ # Make sure _start() is not called twice if self.start_called: raise RuntimeError("%s has already been started" % self) log_path = self.get_csvlog_path(self.uuid) logpool.open_log(self.uuid, log_path) self.log_identifier = basename(log_path) register_log_deferred = self._register_logfile_on_master(self.log_identifier) self.started_deferred = Deferred() self.stopped_deferred = Deferred() def start_processes(_): logpool.log( self.uuid, "internal", "Starting work on job %s, assignment of %s tasks." % (self.assignment["job"]["title"], len(self.assignment["tasks"])), ) self._before_start() logger.debug("%r.start()", self.__class__.__name__) try: self.start() self.start_called = True logger.debug("Collecting started deferreds from spawned " "processes") if not self.processes: logger.warning("No processes have been started, firing deferreds " "immediately.") self.started_deferred.callback(None) self.stopped_deferred.callback(None) else: logger.debug("Making deferred list for %s started " "processes", len(self.processes)) processes_deferred = DeferredList([process.started for process in self.processes.values()]) processes_deferred.addCallback(lambda x: self.started_deferred.callback(x)) except Exception as e: self.started_deferred.errback(e) self.stopped_deferred.errback(e) register_log_deferred.addCallback(start_processes) register_log_deferred.addErrback(lambda x: self.started_deferred.errback(x)) register_log_deferred.addErrback(lambda x: self.stopped_deferred.errback(x)) return self.started_deferred, self.stopped_deferred
def test_no_capure_stderr(self): config["jobtype_capture_process_output"] = False protocol = Mock(id=3, pid=33) jobtype = JobType(fake_assignment()) logpool.open_log(jobtype.uuid, self.create_file(), ignore_existing=True) with patch.object(logpool, "log") as mocked: jobtype.log_stderr_line(protocol, "stderr") mocked.assert_called_once_with(jobtype.uuid, STDERR, "stderr", 33)
def test_preprocess_replaces_output(self): jobtype = JobType(fake_assignment()) logpool.open_log(jobtype.uuid, self.create_file(), ignore_existing=True) protocol = Mock(id=2) with nested( patch.object(jobtype, "preprocess_stderr_line", return_value="foo"), patch.object(jobtype, "format_stderr_line"), ) as (_, mocked): jobtype.handle_stderr_line(protocol, "stderr 2") mocked.assert_called_with(protocol, "foo")
def test_format_replaces_output(self): jobtype = JobType(fake_assignment()) logpool.open_log(jobtype.uuid, self.create_file(), ignore_existing=True) protocol = Mock(id=3) with nested( patch.object(jobtype, "format_stdout_line", return_value="bar"), patch.object(jobtype, "log_stdout_line"), patch.object(jobtype, "process_stdout_line"), ) as (_, log_mock, process_mock): jobtype.handle_stdout_line(protocol, "stdout 3") log_mock.assert_called_with(protocol, "bar") process_mock.assert_called_with(protocol, "bar")