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")
