def main():
"""Start main Kytos Daemon."""
def stop_controller(signum, frame): # pylint: disable=unused-argument
"""Stop the controller before quitting."""
if controller:
print('Stopping controller...')
# If stop() hangs, old ctrl+c behaviour will be restored
signal.signal(signal.SIGINT, kill_handler)
controller.stop()
kill_handler = signal.signal(signal.SIGINT, stop_controller)
config = KytosConfig()
controller = Controller(config.options['daemon'])
if controller.options.foreground:
try:
controller.start()
except SystemExit as exc:
controller.log.error(exc)
controller.log.info("Kytos start aborted.")
sys.exit()
start_shell(controller)
controller.stop()
else:
with daemon.DaemonContext():
try:
controller.start()
except SystemExit as exc:
controller.log.error(exc)
controller.log.info("Kytos daemon start aborted.")
sys.exit()
def test_start_controller(*args):
"""Test activate method."""
(mock_pre_install_napps, mock_load_napps, mock_raw_event_handler,
mock_msg_in_event_handler, mock_msg_out_event_handler,
mock_app_event_handler, _) = args
napp = MagicMock()
loop = MagicMock()
options = KytosConfig().options['daemon']
options.napps_pre_installed = [napp]
controller = Controller(options, loop=loop)
controller.log = Mock()
controller.start_controller()
controller.server.serve_forever.assert_called()
calls = [
call(mock_raw_event_handler.return_value),
call(mock_msg_in_event_handler.return_value),
call(mock_msg_out_event_handler.return_value),
call(mock_app_event_handler.return_value)
]
loop.create_task.assert_has_calls(calls)
mock_pre_install_napps.assert_called_with([napp])
mock_load_napps.assert_called()
def setUp(self):
"""Instantiate a controller."""
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.options = KytosConfig().options['daemon']
self.controller = Controller(self.options, loop=self.loop)
self.controller.log = Mock()
def async_main(config):
"""Start main Kytos Daemon with asyncio loop."""
def stop_controller(controller, shell_task=None):
"""Stop the controller before quitting."""
loop = asyncio.get_event_loop()
if loop:
# If stop() hangs, old ctrl+c behaviour will be restored
loop.remove_signal_handler(signal.SIGINT)
loop.remove_signal_handler(signal.SIGTERM)
# disable_threadpool_exit()
controller.log.info("Stopping Kytos controller...")
controller.stop()
if shell_task:
shell_task.cancel()
async def start_shell_async():
"""Run the shell inside a thread and stop controller when done."""
interactive_shell = create_shell(controller)
try:
data = await loop.run_in_executor(executor, interactive_shell)
finally:
# Exit all embedded code in shell
interactive_shell.magic("%exit_raise")
stop_controller(controller)
return data
loop = asyncio.get_event_loop()
controller = Controller(config)
if controller.options.debug:
loop.set_debug(True)
loop.call_soon(controller.start)
shell_task = None
if controller.options.foreground:
executor = ThreadPoolExecutor(max_workers=1)
shell_task = loop.create_task(start_shell_async())
kill_handler = functools.partial(stop_controller, controller, shell_task)
loop.add_signal_handler(signal.SIGINT, kill_handler)
loop.add_signal_handler(signal.SIGTERM, kill_handler)
try:
loop.run_forever()
except SystemExit as exc:
controller.log.error(exc)
controller.log.info("Shutting down Kytos...")
finally:
loop.close()
def setUp(self):
"""Execute steps before each tests."""
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.options = KytosConfig().options['daemon']
self.controller = Controller(self.options, loop=self.loop)
self.controller.log = MagicMock()
self.controller.load_napp = MagicMock()
self.controller.unload_napp = MagicMock()
self.napps_manager = NAppsManager(self.controller)
def async_main():
"""Start main Kytos Daemon with asyncio loop."""
def stop_controller(controller):
"""Stop the controller before quitting."""
loop = asyncio.get_event_loop()
# If stop() hangs, old ctrl+c behaviour will be restored
loop.remove_signal_handler(signal.SIGINT)
loop.remove_signal_handler(signal.SIGTERM)
# disable_threadpool_exit()
controller.log.info("Stopping Kytos controller...")
controller.stop()
async def start_shell_async():
"""Run the shell inside a thread and stop controller when done."""
_start_shell = functools.partial(start_shell, controller)
data = await loop.run_in_executor(executor, _start_shell)
executor.shutdown()
stop_controller(controller)
return data
config = KytosConfig()
controller = Controller(config.options['daemon'])
loop = asyncio.get_event_loop()
kill_handler = functools.partial(stop_controller, controller)
loop.add_signal_handler(signal.SIGINT, kill_handler)
loop.add_signal_handler(signal.SIGTERM, kill_handler)
if controller.options.debug:
loop.set_debug(True)
if controller.options.foreground:
try:
controller.start()
except SystemExit as exc:
controller.log.error(exc)
controller.log.info("Kytos start aborted.")
sys.exit()
executor = ThreadPoolExecutor(max_workers=1)
loop.create_task(start_shell_async())
else:
with daemon.DaemonContext():
try:
controller.start()
except SystemExit as exc:
controller.log.error(exc)
controller.log.info("Kytos daemon start aborted.")
sys.exit()
def _get_controller_mock(self):
"""Return a controller mock."""
loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
options = KytosConfig().options['daemon']
options.jwt_secret = 'jwt_secret'
controller = Controller(options, loop=loop)
controller.log = Mock()
# Patch event callback trigger.
controller.buffers.app.put = self._patch_event_trigger
return controller
def new_controller(options=None):
"""Instantiate a Kytos Controller.
Args:
options (KytosConfig.options): options generated by KytosConfig
Returns:
controller: Running Controler
"""
if options is None:
options = get_config().options['daemon']
controller = Controller(options)
controller.start()
time.sleep(0.1)
return controller
def test_websocket_log_usage(path, log_manager):
"""Assert that the web socket log is used."""
# Save original state
handlers_bak = copy(logging.root.handlers)
# Minimum to instantiate Controller
options = Mock(napps='')
path.return_value.exists.return_value = False
controller = Controller(options)
# The test
controller.enable_logs()
log_manager.enable_websocket.assert_called_once()
# Restore original state
logging.root.handlers = handlers_bak
def test_start_controller(*args):
"""Test activate method."""
(mock_pre_install_napps, mock_load_napps, _, _, _, _, _) = args
napp = MagicMock()
loop = MagicMock()
options = KytosConfig().options['daemon']
options.napps_pre_installed = [napp]
controller = Controller(options, loop=loop)
controller.log = Mock()
controller.start_controller()
controller.server.serve_forever.assert_called()
assert loop.create_task.call_count == 5
assert len(controller._tasks) == 5
mock_pre_install_napps.assert_called_with([napp])
mock_load_napps.assert_called()
def get_controller_mock():
"""Return a controller mock."""
options = KytosConfig().options['daemon']
controller = Controller(options)
controller.log = Mock()
return controller
def setUp(self):
"""Instantiate a controller."""
self.options = KytosConfig().options['daemon']
self.controller = Controller(self.options)
self.controller.log = Mock()