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 _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 __init__(self):
"""Create the GenericEntity object with empty metadata dictionary."""
options = KytosConfig().options['daemon']
self.metadata = {}
self._active: bool = True
self._enabled: bool = options.enable_entities_by_default
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 __init__(self):
"""Create the GenericEntity object with empty metadata dictionary."""
options = KytosConfig().options['daemon']
self.metadata = {}
# operational status with True or False
self._active = True
# administrative status with True or False
self._enabled = options.enable_entities_by_default
def main():
config = KytosConfig().options['daemon']
if config.foreground:
async_main(config)
else:
with daemon.DaemonContext():
async_main(config)
def main():
"""Read config and start Kytos in foreground or daemon mode."""
config = KytosConfig().options['daemon']
if config.foreground:
async_main(config)
else:
with daemon.DaemonContext():
async_main(config)
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 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 get_config():
"""Exclude unittest args from Config argparser."""
argv_backup = None
# If cli command was like "python -m unittest"
if sys.argv[0].split()[-1] == 'unittest':
argv_backup = sys.argv
sys.argv = sys.argv[:1]
config = KytosConfig()
if argv_backup:
# Recover original argv
sys.argv = argv_backup
return config
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 main():
"""Read config and start Kytos in foreground or daemon mode."""
# data_files is not enough when installing from PyPI
_create_pid_dir()
config = KytosConfig().options['daemon']
if config.foreground or not config.daemon:
async_main(config)
else:
with daemon.DaemonContext():
async_main(config)
def get_token_expiration():
"""Return token expiration time in minutes defined in kytos conf."""
options = KytosConfig().options['daemon']
return options.token_expiration_minutes
def get_controller_mock():
"""Return a controller mock."""
options = KytosConfig().options['daemon']
controller = Controller(options)
controller.log = Mock()
return controller
def __init__(self, options=None, loop=None):
"""Init method of Controller class takes the parameters below.
Args:
options (:attr:`ParseArgs.args`): :attr:`options` attribute from an
instance of :class:`~kytos.core.config.KytosConfig` class.
"""
if options is None:
options = KytosConfig().options['daemon']
self._loop = loop or asyncio.get_event_loop()
self._pool = ThreadPoolExecutor(max_workers=1)
# asyncio tasks
self._tasks = []
#: dict: keep the main threads of the controller (buffers and handler)
self._threads = {}
#: KytosBuffers: KytosBuffer object with Controller buffers
self.buffers = KytosBuffers(loop=self._loop)
#: dict: keep track of the socket connections labeled by ``(ip, port)``
#:
#: This dict stores all connections between the controller and the
#: switches. The key for this dict is a tuple (ip, port). The content
#: is a Connection
self.connections = {}
#: dict: mapping of events and event listeners.
#:
#: The key of the dict is a KytosEvent (or a string that represent a
#: regex to match against KytosEvents) and the value is a list of
#: methods that will receive the referenced event
self.events_listeners = {
'kytos/core.connection.new': [self.new_connection]
}
#: dict: Current loaded apps - ``'napp_name'``: ``napp`` (instance)
#:
#: The key is the napp name (string), while the value is the napp
#: instance itself.
self.napps = {}
#: Object generated by ParseArgs on config.py file
self.options = options
#: KytosServer: Instance of KytosServer that will be listening to TCP
#: connections.
self.server = None
#: dict: Current existing switches.
#:
#: The key is the switch dpid, while the value is a Switch object.
self.switches = {} # dpid: Switch()
self._switches_lock = threading.Lock()
#: datetime.datetime: Time when the controller finished starting.
self.started_at = None
#: logging.Logger: Logger instance used by Kytos.
self.log = None
#: Observer that handle NApps when they are enabled or disabled.
self.napp_dir_listener = NAppDirListener(self)
self.napps_manager = NAppsManager(self)
#: API Server used to expose rest endpoints.
self.api_server = APIServer(__name__, self.options.listen,
self.options.api_port, self.napps_manager,
self.options.napps)
self.auth = Auth(self)
self.dead_letter = DeadLetter(self)
self._register_endpoints()
#: Adding the napps 'enabled' directory into the PATH
#: Now you can access the enabled napps with:
#: from napps.<username>.<napp_name> import ?....
sys.path.append(os.path.join(self.options.napps, os.pardir))
sys.excepthook = exc_handler
def get_authenticate_options():
"""Return configuration options related to authentication."""
options = KytosConfig().options['daemon']
return options.authenticate_urls
def get_thread_pool_max_workers():
"""Get the number of thread pool max workers."""
return KytosConfig().options["daemon"].thread_pool_max_workers
def get_apm_name():
"""Get apm backend name."""
return KytosConfig().options["daemon"].apm
def get_jwt_secret(cls):
"""Return JWT secret defined in kytos conf."""
options = KytosConfig().options['daemon']
return options.jwt_secret
def setUp(self):
"""Instantiate a controller."""
self.options = KytosConfig().options['daemon']
self.controller = Controller(self.options)
self.controller.log = Mock()