def test_process_state_events_with_pid(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (
events.ProcessStateRunningEvent,
events.ProcessStateStoppedEvent,
events.ProcessStateStoppingEvent,
):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1',
'/bin/process1')
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
process1.pid = 1
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 4)
self.assertEqual(headers['processname'], 'process1')
self.assertEqual(headers['groupname'], 'process1')
self.assertEqual(headers['from_state'], 'STARTING')
self.assertEqual(headers['pid'], '1')
self.assertEqual(payload, '')
def test_handle_result_accept(self):
from supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from supervisor import events
subscribe(events.EventRejectedEvent, doit)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
def handle(event, result):
pass
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
process.group.config.result_handler = handle
process.listener_state = EventListenerStates.BUSY
dispatcher.handle_result('foo')
self.assertEqual(len(L), 0)
self.assertEqual(process.listener_state,
EventListenerStates.ACKNOWLEDGED)
result = options.logger.data[0]
self.assertTrue(result.endswith('BUSY -> ACKNOWLEDGED (processed)'))
def test_handle_result_exception(self):
from supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from supervisor import events
subscribe(events.EventRejectedEvent, doit)
from 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)
result = options.logger.data[0]
self.assertTrue(result.endswith('BUSY -> UNKNOWN'))
def test_handle_result_rejectevent(self):
from supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from supervisor import events
subscribe(events.EventRejectedEvent, doit)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
def rejected(event, result):
from 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)
result = options.logger.data[0]
self.assertTrue(result.endswith('BUSY -> ACKNOWLEDGED (rejected)'))
def test_handle_result_rejectevent(self):
from supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from supervisor import events
subscribe(events.EventRejectedEvent, doit)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
def rejected(event, result):
from 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_accept(self):
from supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from supervisor import events
subscribe(events.EventRejectedEvent, doit)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
def handle(event, result):
pass
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
process.group.config.result_handler = handle
process.listener_state = EventListenerStates.BUSY
dispatcher.handle_result('foo')
self.assertEqual(len(L), 0)
self.assertEqual(process.listener_state,
EventListenerStates.ACKNOWLEDGED)
self.assertEqual(options.logger.data[0],
'process1: event was processed')
self.assertEqual(options.logger.data[1],
'process1: BUSY -> ACKNOWLEDGED')
def test_handle_result_exception(self):
from supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from supervisor import events
subscribe(events.EventRejectedEvent, doit)
from 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_process_state_events_starting_and_backoff(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (
events.ProcessStateStartingEvent,
events.ProcessStateBackoffEvent,
):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1',
'/bin/process1')
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 4)
self.assertEqual(headers['processname'], 'process1')
self.assertEqual(headers['groupname'], 'process1')
self.assertEqual(headers['from_state'], 'STARTING')
self.assertEqual(headers['tries'], '0')
self.assertEqual(payload, '')
process1.backoff = 1
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(headers['tries'], '1')
process1.backoff = 2
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(headers['tries'], '2')
def test_handle_listener_state_busy_gobbles(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
from 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_process_state_events_starting_and_backoff(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (events.ProcessStateStartingEvent, events.ProcessStateBackoffEvent):
options = DummyOptions()
pconfig1 = DummyPConfig(options, "process1", "process1", "/bin/process1")
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 4)
self.assertEqual(headers["processname"], "process1")
self.assertEqual(headers["groupname"], "process1")
self.assertEqual(headers["from_state"], "STARTING")
self.assertEqual(headers["tries"], "0")
self.assertEqual(payload, "")
process1.backoff = 1
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(headers["tries"], "1")
process1.backoff = 2
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(headers["tries"], "2")
def test_process_state_events_with_pid(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (
events.ProcessStateRunningEvent,
events.ProcessStateStoppedEvent,
events.ProcessStateStoppingEvent,
):
options = DummyOptions()
pconfig1 = DummyPConfig(options, "process1", "process1", "/bin/process1")
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
process1.pid = 1
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 4)
self.assertEqual(headers["processname"], "process1")
self.assertEqual(headers["groupname"], "process1")
self.assertEqual(headers["from_state"], "STARTING")
self.assertEqual(headers["pid"], "1")
self.assertEqual(payload, "")
def test_handle_result_exception(self):
from supervisor.events import subscribe
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
L = []
def doit(event):
L.append(event)
from supervisor import events
subscribe(events.EventRejectedEvent, doit)
from 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_busy_gobbles(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
from 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_plog_stdout_event(self):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1','/bin/process1')
process1 = DummyProcess(pconfig1)
from supervisor.events import ProcessLogStdoutEvent
class DummyGroup:
config = pconfig1
process1.group = DummyGroup
event = ProcessLogStdoutEvent(process1, 1, 'yo')
headers, payload = self._deserialize(event.payload())
self.assertEqual(headers['processname'], 'process1', headers)
self.assertEqual(headers['groupname'], 'process1', headers)
self.assertEqual(headers['pid'], '1', headers)
self.assertEqual(payload, 'yo')
def test_pcomm_stderr_event(self):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1','/bin/process1')
process1 = DummyProcess(pconfig1)
class DummyGroup:
config = pconfig1
process1.group = DummyGroup
from supervisor.events import ProcessCommunicationStderrEvent
event = ProcessCommunicationStderrEvent(process1, 1, 'yo')
headers, payload = self._deserialize(str(event))
self.assertEqual(headers['processname'], 'process1', headers)
self.assertEqual(headers['groupname'], 'process1', headers)
self.assertEqual(headers['pid'], '1', headers)
self.assertEqual(payload, 'yo')
def test_pcomm_stdout_event(self):
options = DummyOptions()
pconfig1 = DummyPConfig(options, "process1", "process1", "/bin/process1")
process1 = DummyProcess(pconfig1)
from supervisor.events import ProcessCommunicationStdoutEvent
class DummyGroup:
config = pconfig1
process1.group = DummyGroup
event = ProcessCommunicationStdoutEvent(process1, 1, "yo")
headers, payload = self._deserialize(str(event))
self.assertEqual(headers["processname"], "process1", headers)
self.assertEqual(headers["groupname"], "process1", headers)
self.assertEqual(headers["pid"], "1", headers)
self.assertEqual(payload, "yo")
def test_plog_stdout_event(self):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1',
'/bin/process1')
process1 = DummyProcess(pconfig1)
from supervisor.events import ProcessLogStdoutEvent
class DummyGroup:
config = pconfig1
process1.group = DummyGroup
event = ProcessLogStdoutEvent(process1, 1, 'yo')
headers, payload = self._deserialize(event.payload())
self.assertEqual(headers['processname'], 'process1', headers)
self.assertEqual(headers['groupname'], 'process1', headers)
self.assertEqual(headers['pid'], '1', headers)
self.assertEqual(payload, 'yo')
def test_process_state_events_without_extra_values(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (events.ProcessStateFatalEvent, events.ProcessStateUnknownEvent):
options = DummyOptions()
pconfig1 = DummyPConfig(options, "process1", "process1", "/bin/process1")
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 3)
self.assertEqual(headers["processname"], "process1")
self.assertEqual(headers["groupname"], "process1")
self.assertEqual(headers["from_state"], "STARTING")
self.assertEqual(payload, "")
def test_handle_listener_state_change_busy_to_acknowledged_rejected(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
from 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: BUSY -> ACKNOWLEDGED (rejected)')
self.assertEqual(process.listener_state,
EventListenerStates.ACKNOWLEDGED)
def test_process_state_events_without_extra_values(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (
events.ProcessStateFatalEvent,
events.ProcessStateUnknownEvent,
):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1',
'/bin/process1')
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(event.payload())
self.assertEqual(len(headers), 3)
self.assertEqual(headers['processname'], 'process1')
self.assertEqual(headers['groupname'], 'process1')
self.assertEqual(headers['from_state'], 'STARTING')
self.assertEqual(payload, '')
def test_process_state_exited_event_unexpected(self):
from supervisor import events
from supervisor.states import ProcessStates
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1','/bin/process1')
process1 = DummyProcess(pconfig1)
class DummyGroup:
config = pconfig1
process1.group = DummyGroup
process1.pid = 1
event = events.ProcessStateExitedEvent(process1,
ProcessStates.STARTING,
expected=False)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 5)
self.assertEqual(headers['processname'], 'process1')
self.assertEqual(headers['groupname'], 'process1')
self.assertEqual(headers['pid'], '1')
self.assertEqual(headers['from_state'], 'STARTING')
self.assertEqual(headers['expected'], '0')
self.assertEqual(payload, '')
def test_process_state_events_without_extra_values(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (
events.ProcessStateFatalEvent,
events.ProcessStateUnknownEvent,
):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1',
'/bin/process1')
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 3)
self.assertEqual(headers['processname'], 'process1')
self.assertEqual(headers['groupname'], 'process1')
self.assertEqual(headers['from_state'], 'STARTING')
self.assertEqual(payload, '')
def test_handle_listener_state_change_busy_to_acknowledged_procd(self):
options = DummyOptions()
config = DummyPConfig(options, "process1", "/bin/process1")
process = DummyProcess(config)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
from supervisor.dispatchers import default_handler
process.group.config.result_handler = default_handler
dispatcher.state_buffer = "RESULT 2\nOKabc"
self.assertEqual(dispatcher.handle_listener_state_change(), None)
self.assertEqual(dispatcher.state_buffer, "abc")
self.assertEqual(options.logger.data[0], "process1: BUSY -> ACKNOWLEDGED (processed)")
self.assertEqual(process.listener_state, EventListenerStates.ACKNOWLEDGED)
def test_process_state_exited_event_unexpected(self):
from supervisor import events
from supervisor.states import ProcessStates
options = DummyOptions()
pconfig1 = DummyPConfig(options, "process1", "process1", "/bin/process1")
process1 = DummyProcess(pconfig1)
class DummyGroup:
config = pconfig1
process1.group = DummyGroup
process1.pid = 1
event = events.ProcessStateExitedEvent(process1, ProcessStates.STARTING, expected=False)
headers, payload = self._deserialize(str(event))
self.assertEqual(len(headers), 5)
self.assertEqual(headers["processname"], "process1")
self.assertEqual(headers["groupname"], "process1")
self.assertEqual(headers["pid"], "1")
self.assertEqual(headers["from_state"], "STARTING")
self.assertEqual(headers["expected"], "0")
self.assertEqual(payload, "")
def test_handle_listener_state_busy_gobbles(self):
options = DummyOptions()
config = DummyPConfig(options, 'process1', '/bin/process1')
process = DummyProcess(config)
from supervisor.dispatchers import EventListenerStates
dispatcher = self._makeOne(process)
process.listener_state = EventListenerStates.BUSY
class Dummy:
pass
process.group = Dummy()
process.group.config = Dummy()
from 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: BUSY -> ACKNOWLEDGED (processed)')
self.assertEqual(options.logger.data[1],
'process1: ACKNOWLEDGED -> UNKNOWN')
self.assertEqual(process.listener_state,
EventListenerStates.UNKNOWN)
def test_process_state_events_with_pid(self):
from supervisor.states import ProcessStates
from supervisor import events
for klass in (
events.ProcessStateRunningEvent,
events.ProcessStateStoppedEvent,
events.ProcessStateStoppingEvent,
):
options = DummyOptions()
pconfig1 = DummyPConfig(options, 'process1', 'process1',
'/bin/process1')
class DummyGroup:
config = pconfig1
process1 = DummyProcess(pconfig1)
process1.group = DummyGroup
process1.pid = 1
event = klass(process1, ProcessStates.STARTING)
headers, payload = self._deserialize(event.payload())
self.assertEqual(len(headers), 4)
self.assertEqual(headers['processname'], 'process1')
self.assertEqual(headers['groupname'], 'process1')
self.assertEqual(headers['from_state'], 'STARTING')
self.assertEqual(headers['pid'], '1')
self.assertEqual(payload, '')
