def test_handle_result_rejectevent(self):
from docker_supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from docker_supervisor import events
subscribe(events.EventRejectedEvent, doit)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
def rejected(event, result):
from docker_supervisor.dispatchers import RejectEvent
raise RejectEvent(result)
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
process.group.config.result_handler = rejected
process.listener_state = EventListenerStates.BUSY
dispatcher.handle_result('foo')
self.assertEqual(len(L), 1)
self.assertEqual(L[0].__class__, events.EventRejectedEvent)
self.assertEqual(process.listener_state,
EventListenerStates.ACKNOWLEDGED)
self.assertEqual(options.logger.data[0],
'process1: event was rejected')
self.assertEqual(options.logger.data[1],
'process1: BUSY -> ACKNOWLEDGED')
def test_handle_result_exception(self):
from docker_supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from docker_supervisor import events
subscribe(events.EventRejectedEvent, doit)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
def exception(event, result):
raise ValueError
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
process.group.config.result_handler = exception
process.group.result_handler = exception
process.listener_state = EventListenerStates.BUSY
dispatcher.handle_result('foo')
self.assertEqual(len(L), 1)
self.assertEqual(L[0].__class__, events.EventRejectedEvent)
self.assertEqual(process.listener_state,
EventListenerStates.UNKNOWN)
self.assertEqual(options.logger.data[0],
'process1: event caused an error')
self.assertEqual(options.logger.data[1],
'process1: BUSY -> UNKNOWN')
self.assertEqual(options.logger.data[2],
'process1: has entered the UNKNOWN state and will '
'no longer receive events, this usually indicates '
'the process violated the eventlistener protocol')
def test_handle_listener_state_change_busy_to_unknown(self):
from docker_supervisor.events import EventRejectedEvent
from docker_supervisor.events import subscribe
events = []
def doit(event):
events.append(event)
subscribe(EventRejectedEvent, doit)
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
current_event = DummyEvent()
process.event = current_event
dispatcher.state_buffer = 'bogus data\n'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, '')
self.assertEqual(options.logger.data[0],
"process1: bad result line: 'bogus data'")
self.assertEqual(options.logger.data[1],
'process1: BUSY -> UNKNOWN')
self.assertEqual(options.logger.data[2],
'process1: has entered the UNKNOWN state and will '
'no longer receive events, this usually indicates '
'the process violated the eventlistener protocol')
self.assertEqual(process.listener_state,
EventListenerStates.UNKNOWN)
self.assertEqual(events[0].process, process)
self.assertEqual(events[0].event, current_event)
def test_handle_listener_state_busy_gobbles(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
from docker_supervisor.dispatchers import default_handler
process.group.config.result_handler = default_handler
dispatcher.state_buffer = 'RESULT 2\nOKbogus data\n'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, '')
self.assertEqual(options.logger.data[0],
'process1: event was processed')
self.assertEqual(options.logger.data[1],
'process1: BUSY -> ACKNOWLEDGED')
self.assertEqual(options.logger.data[2],
'process1: ACKNOWLEDGED -> UNKNOWN')
self.assertEqual(options.logger.data[3],
'process1: has entered the UNKNOWN state and will '
'no longer receive events, this usually indicates '
'the process violated the eventlistener protocol')
self.assertEqual(process.listener_state,
EventListenerStates.UNKNOWN)
def test_handle_listener_state_change_busy_to_insufficient(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
dispatcher.state_buffer = 'bogus data yo'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, 'bogus data yo')
self.assertEqual(process.listener_state, EventListenerStates.BUSY)
def test_handle_listener_state_change_from_unknown(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.UNKNOWN
dispatcher.state_buffer = 'whatever'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, '')
self.assertEqual(options.logger.data, [])
self.assertEqual(process.listener_state, EventListenerStates.UNKNOWN)
def test_handle_listener_state_change_acknowledged_to_insufficient(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.ACKNOWLEDGED
dispatcher.state_buffer = 'RE'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, 'RE')
self.assertEqual(options.logger.data, [])
self.assertEqual(process.listener_state,
EventListenerStates.ACKNOWLEDGED)
def test_handle_listener_state_change_acknowledged_gobbles(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.ACKNOWLEDGED
dispatcher.state_buffer = 'READY\ngarbage\n'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, '')
self.assertEqual(options.logger.data[0],
'process1: ACKNOWLEDGED -> READY')
self.assertEqual(options.logger.data[1],
'process1: READY -> UNKNOWN')
self.assertEqual(process.listener_state, EventListenerStates.UNKNOWN)
def test_handle_read_event_calls_handle_listener_state_change(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1',
stdout_logfile='/tmp/foo')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
process.listener_state = EventListenerStates.ACKNOWLEDGED
dispatcher = self._makeOne(process)
options.readfd_result = dispatcher.READY_FOR_EVENTS_TOKEN
self.assertEqual(dispatcher.handle_read_event(), None)
self.assertEqual(process.listener_state, EventListenerStates.READY)
self.assertEqual(dispatcher.state_buffer, '')
self.assertEqual(len(dispatcher.childlog.data), 1)
self.assertEqual(dispatcher.childlog.data[0],
dispatcher.READY_FOR_EVENTS_TOKEN)
def test_handle_listener_state_change_ready_to_unknown(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.READY
dispatcher.state_buffer = 'bogus data yo'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, '')
self.assertEqual(options.logger.data[0],
'process1: READY -> UNKNOWN')
self.assertEqual(options.logger.data[1],
'process1: has entered the UNKNOWN state and will '
'no longer receive events, this usually indicates '
'the process violated the eventlistener protocol')
self.assertEqual(process.listener_state, EventListenerStates.UNKNOWN)
def test_handle_listener_state_change_busy_to_acknowledged_rejected(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from docker_supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
from docker_supervisor.dispatchers import default_handler
process.group.config.result_handler = default_handler
dispatcher.state_buffer = 'RESULT 4\nFAILabc'
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, 'abc')
self.assertEqual(options.logger.data[0],
'process1: event was rejected')
self.assertEqual(options.logger.data[1],
'process1: BUSY -> ACKNOWLEDGED')
self.assertEqual(process.listener_state,
EventListenerStates.ACKNOWLEDGED)
