def test_emit_tracks_correct_file_for_multiple_handlers(self):
"""
Rollovers should roll for all handlers of the same file.
When more than one process logs to a singlefile, we want to
make sure that files get rotated properly.
When the file rotates, all handlers should start writing to
the file specified by handler.baseFilename.
"""
handler1 = self._makeOne(self.filename, maxBytes=10, backupCount=2)
handler2 = self._makeOne(self.filename, maxBytes=10, backupCount=2)
record = self._makeLogRecord('a' * 4)
handler1.emit(record) #4 bytes
handler2.emit(record) #8 bytes
self.assertFalse(os.path.exists(self.filename + '.1'))
handler1.emit(record) #12 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertTrue(handler1.stream == handler2.stream)
new_record = self._makeLogRecord("NEW")
handler2.emit(new_record)
self.assertTrue(read_file(self.filename,'r').endswith("NEW"))
handler1.emit(record)
self.assertTrue(read_file(self.filename,'r').endswith("aaaa"))
handler2.emit(new_record)
self.assertTrue(read_file(self.filename,'r').endswith(""))
def test_emit_tracks_correct_file_for_multiple_handlers(self):
"""
Rollovers should roll for all handlers of the same file.
When more than one process logs to a singlefile, we want to
make sure that files get rotated properly.
When the file rotates, all handlers should start writing to
the file specified by handler.baseFilename.
"""
handler1 = self._makeOne(self.filename, maxBytes=10, backupCount=2)
handler2 = self._makeOne(self.filename, maxBytes=10, backupCount=2)
record = self._makeLogRecord('a' * 4)
handler1.emit(record) #4 bytes
handler2.emit(record) #8 bytes
self.assertFalse(os.path.exists(self.filename + '.1'))
handler1.emit(record) #12 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertTrue(handler1.stream == handler2.stream)
new_record = self._makeLogRecord("NEW")
handler2.emit(new_record)
self.assertTrue(read_file(self.filename, 'r').endswith("NEW"))
handler1.emit(record)
self.assertTrue(read_file(self.filename, 'r').endswith("aaaa"))
handler2.emit(new_record)
self.assertTrue(read_file(self.filename, 'r').endswith(""))
def test_emit_does_rollover(self):
handler = self._makeOne(self.filename, maxBytes=10, backupCount=2)
record = self._makeLogRecord('a' * 4)
handler.emit(record) # 4 bytes
self.assertFalse(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 8 bytes
self.assertFalse(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 12 bytes, do rollover
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 16 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 20 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 24 bytes, do rollover
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertTrue(os.path.exists(self.filename + '.2'))
handler.emit(record) # 28 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertTrue(os.path.exists(self.filename + '.2'))
self.assertEqual(read_file(self.filename), 'a' * 4)
one = read_file(self.filename + '.1')
self.assertEqual(one, 'a' * 12)
two = read_file(self.filename + '.2')
self.assertEqual(two, 'a' * 12)
def test_emit_does_rollover(self):
handler = self._makeOne(self.filename, maxBytes=10, backupCount=2)
record = self._makeLogRecord('a' * 4)
handler.emit(record) # 4 bytes
self.assertFalse(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 8 bytes
self.assertFalse(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 12 bytes, do rollover
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 16 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 20 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertFalse(os.path.exists(self.filename + '.2'))
handler.emit(record) # 24 bytes, do rollover
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertTrue(os.path.exists(self.filename + '.2'))
handler.emit(record) # 28 bytes
self.assertTrue(os.path.exists(self.filename + '.1'))
self.assertTrue(os.path.exists(self.filename + '.2'))
self.assertEqual(read_file(self.filename), 'a' * 4)
one = read_file(self.filename+'.1')
self.assertEqual(one, 'a'*12)
two = read_file(self.filename+'.2')
self.assertEqual(two, 'a'*12)
def test_stdout_capturemode_single_buffer(self):
# mike reported that comm events that took place within a single
# output buffer were broken 8/20/2007
from supervisor.events import ProcessCommunicationEvent
from supervisor.events import subscribe
events = []
def doit(event):
events.append(event)
subscribe(ProcessCommunicationEvent, doit)
BEGIN_TOKEN = ProcessCommunicationEvent.BEGIN_TOKEN
END_TOKEN = ProcessCommunicationEvent.END_TOKEN
data = BEGIN_TOKEN + 'hello' + END_TOKEN
options = DummyOptions()
from supervisor.loggers import getLogger
options.getLogger = getLogger # actually use real logger
logfile = '/tmp/log'
config = DummyPConfig(options,
'process1',
'/bin/process1',
stdout_logfile=logfile,
stdout_capture_maxbytes=1000)
process = DummyProcess(config)
dispatcher = self._makeOne(process)
try:
dispatcher.output_buffer = data
dispatcher.record_output()
self.assertEqual(read_file(logfile), '')
self.assertEqual(dispatcher.output_buffer, '')
self.assertEqual(len(events), 1)
event = events[0]
from supervisor.events import ProcessCommunicationStdoutEvent
self.assertEqual(event.__class__, ProcessCommunicationStdoutEvent)
self.assertEqual(event.process, process)
self.assertEqual(event.channel, 'stdout')
self.assertEqual(event.data, 'hello')
finally:
try:
dispatcher.capturelog.close()
dispatcher.childlog.close()
os.remove(logfile)
except (OSError, IOError):
pass
def test_stdout_capturemode_single_buffer(self):
# mike reported that comm events that took place within a single
# output buffer were broken 8/20/2007
from supervisor.events import ProcessCommunicationEvent
from supervisor.events import subscribe
events = []
def doit(event):
events.append(event)
subscribe(ProcessCommunicationEvent, doit)
BEGIN_TOKEN = ProcessCommunicationEvent.BEGIN_TOKEN
END_TOKEN = ProcessCommunicationEvent.END_TOKEN
data = BEGIN_TOKEN + 'hello' + END_TOKEN
options = DummyOptions()
from supervisor.loggers import getLogger
options.getLogger = getLogger # actually use real logger
logfile = '/tmp/log'
config = DummyPConfig(options, 'process1', '/bin/process1',
stdout_logfile=logfile,
stdout_capture_maxbytes=1000)
process = DummyProcess(config)
dispatcher = self._makeOne(process)
try:
dispatcher.output_buffer = data
dispatcher.record_output()
self.assertEqual(read_file(logfile), '')
self.assertEqual(dispatcher.output_buffer, '')
self.assertEqual(len(events), 1)
event = events[0]
from supervisor.events import ProcessCommunicationStdoutEvent
self.assertEqual(event.__class__, ProcessCommunicationStdoutEvent)
self.assertEqual(event.process, process)
self.assertEqual(event.channel, 'stdout')
self.assertEqual(event.data, 'hello')
finally:
try:
os.remove(logfile)
except (OSError, IOError):
pass
def test_emit_ascii_noerror(self):
handler = self._makeOne(self.filename)
record = self._makeLogRecord('hello!')
handler.emit(record)
handler.close()
self.assertEqual(read_file(self.filename, 'r'), 'hello!')
def test_stdout_capturemode_multiple_buffers(self):
from supervisor.events import ProcessCommunicationEvent
from supervisor.events import subscribe
events = []
def doit(event):
events.append(event)
subscribe(ProcessCommunicationEvent, doit)
import string
# ascii_letters for python 3
letters = getattr(string, "letters", string.ascii_letters)
digits = string.digits * 4
BEGIN_TOKEN = ProcessCommunicationEvent.BEGIN_TOKEN
END_TOKEN = ProcessCommunicationEvent.END_TOKEN
data = (letters + BEGIN_TOKEN + digits + END_TOKEN + letters)
# boundaries that split tokens
broken = data.split(':')
first = broken[0] + ':'
second = broken[1] + ':'
third = broken[2]
options = DummyOptions()
from supervisor.loggers import getLogger
options.getLogger = getLogger # actually use real logger
logfile = '/tmp/log'
config = DummyPConfig(options,
'process1',
'/bin/process1',
stdout_logfile=logfile,
stdout_capture_maxbytes=10000)
process = DummyProcess(config)
dispatcher = self._makeOne(process)
try:
dispatcher.output_buffer = first
dispatcher.record_output()
[x.flush() for x in dispatcher.childlog.handlers]
self.assertEqual(read_file(logfile), letters)
self.assertEqual(dispatcher.output_buffer, first[len(letters):])
self.assertEqual(len(events), 0)
dispatcher.output_buffer += second
dispatcher.record_output()
self.assertEqual(len(events), 0)
[x.flush() for x in dispatcher.childlog.handlers]
self.assertEqual(read_file(logfile), letters)
self.assertEqual(dispatcher.output_buffer, first[len(letters):])
self.assertEqual(len(events), 0)
dispatcher.output_buffer += third
dispatcher.record_output()
[x.flush() for x in dispatcher.childlog.handlers]
self.assertEqual(read_file(logfile), letters * 2)
self.assertEqual(len(events), 1)
event = events[0]
from supervisor.events import ProcessCommunicationStdoutEvent
self.assertEqual(event.__class__, ProcessCommunicationStdoutEvent)
self.assertEqual(event.process, process)
self.assertEqual(event.channel, 'stdout')
self.assertEqual(event.data, digits)
finally:
try:
dispatcher.capturelog.close()
dispatcher.childlog.close()
os.remove(logfile)
except (OSError, IOError):
pass
def test_stdout_capturemode_multiple_buffers(self):
from supervisor.events import ProcessCommunicationEvent
from supervisor.events import subscribe
events = []
def doit(event):
events.append(event)
subscribe(ProcessCommunicationEvent, doit)
import string
try:
letters = string.letters
except Exception:
letters = string.ascii_letters
digits = string.digits * 4
BEGIN_TOKEN = ProcessCommunicationEvent.BEGIN_TOKEN
END_TOKEN = ProcessCommunicationEvent.END_TOKEN
data = (letters + BEGIN_TOKEN + digits + END_TOKEN + letters)
# boundaries that split tokens
broken = data.split(':')
first = broken[0] + ':'
second = broken[1] + ':'
third = broken[2]
options = DummyOptions()
from supervisor.loggers import getLogger
options.getLogger = getLogger # actually use real logger
logfile = '/tmp/log'
config = DummyPConfig(options, 'process1', '/bin/process1',
stdout_logfile=logfile,
stdout_capture_maxbytes=10000)
process = DummyProcess(config)
dispatcher = self._makeOne(process)
try:
dispatcher.output_buffer = first
dispatcher.record_output()
[ x.flush() for x in dispatcher.childlog.handlers]
self.assertEqual(read_file(logfile), letters)
self.assertEqual(dispatcher.output_buffer, first[len(letters):])
self.assertEqual(len(events), 0)
dispatcher.output_buffer += second
dispatcher.record_output()
self.assertEqual(len(events), 0)
[ x.flush() for x in dispatcher.childlog.handlers]
self.assertEqual(read_file(logfile), letters)
self.assertEqual(dispatcher.output_buffer, first[len(letters):])
self.assertEqual(len(events), 0)
dispatcher.output_buffer += third
dispatcher.record_output()
[ x.flush() for x in dispatcher.childlog.handlers]
self.assertEqual(read_file(logfile), letters *2)
self.assertEqual(len(events), 1)
event = events[0]
from supervisor.events import ProcessCommunicationStdoutEvent
self.assertEqual(event.__class__, ProcessCommunicationStdoutEvent)
self.assertEqual(event.process, process)
self.assertEqual(event.channel, 'stdout')
self.assertEqual(event.data, digits)
finally:
try:
os.remove(logfile)
except (OSError, IOError):
pass
def test_emit_ascii_noerror(self):
handler = self._makeOne(self.filename)
record = self._makeLogRecord('hello!')
handler.emit(record)
handler.close()
self.assertEqual(read_file(self.filename,'r'), 'hello!')
