def create_dummy_status_server(self, p_process_handlers=None):
# TODO: Add rule set configs as parameters again and migrate them into the datamodel
if p_process_handlers is None:
p_process_handlers = {}
_persistence = test_persistence.TestPersistence.create_dummy_persistence(
self._logger)
_rule_handler = test_rule_handler.TestRuleHandler.create_dummy_rule_handler(
p_persistence=_persistence)
master_connector_config = master_connector.MasterConnectorConfigModel()
_master_connector = master_connector.MasterConnector(
p_config=master_connector_config)
app_control_config = app_control.AppControlConfigModel()
_app_control = app_control.AppControl(
p_config=app_control_config,
p_debug_mode=False,
p_process_handlers=p_process_handlers,
p_device_handler=None,
p_prometheus_client=None,
p_persistence=_persistence,
p_rule_handler=_rule_handler,
p_notification_handlers=[],
p_master_connector=_master_connector,
p_login_mapping=test_data.LOGIN_MAPPING,
p_locale_helper=locale_helper.LocaleHelper())
status_server_config = status_server.StatusServerConfigModel()
status_server_config.admin_username = ADMIN_USERNAME
status_server_config.admin_password = ADMIN_PASSWORD
status_server_config.app_secret = "secret!"
status_server_config.port = int(os.getenv("STATUS_SERVER_PORT",
"5555"))
user_handler_config = unix_user_handler.BaseUserHandlerConfigModel()
user_handler_config.admin_username = ADMIN_USERNAME
user_handler_config.admin_password = ADMIN_PASSWORD
user_handler = unix_user_handler.UnixUserHandler(
p_config=user_handler_config)
_status_server = status_server.StatusServer(
p_config=status_server_config,
p_package_name=app.PACKAGE_NAME,
p_app_control=_app_control,
p_master_connector=_master_connector,
p_persistence=_persistence,
p_is_master=True,
p_user_handler=user_handler,
p_locale_helper=locale_helper.LocaleHelper())
return _status_server
def test_retrieve_user_mappings(self):
config = app_control.AppControlConfigModel()
ac = app_control.AppControl(p_config=config,
p_debug_mode=False,
p_persistence=test_persistence.
TestPersistence.create_dummy_persistence(
self._logger))
ac.retrieve_user_mappings()
def test_constructor(self):
config = app_control.AppControlConfigModel()
ac = app_control.AppControl(p_config=config,
p_debug_mode=False,
p_persistence=test_persistence.
TestPersistence.create_dummy_persistence(
self._logger))
self.assertIsNotNone(ac)
def test_get_number_of_monitored_users_function(self):
config = app_control.AppControlConfigModel()
ac = app_control.AppControl(p_config=config,
p_debug_mode=False,
p_persistence=test_persistence.
TestPersistence.create_dummy_persistence(
self._logger))
func = ac.get_number_of_monitored_users_function()
self.assertIsNotNone(func)
self.assertEqual(func(), 0)
def test_is_master(self):
mc_config = master_connector.MasterConnectorConfigModel()
config = app_control.AppControlConfigModel()
mc = master_connector.MasterConnector(p_config=mc_config)
ac = app_control.AppControl(p_config=config,
p_debug_mode=False,
p_master_connector=mc,
p_persistence=test_persistence.
TestPersistence.create_dummy_persistence(
self._logger))
self.assertTrue(ac.is_master())
def test_check_interval(self):
config = app_control.AppControlConfigModel()
config.check_interval = 123
ac = app_control.AppControl(p_config=config,
p_debug_mode=False,
p_persistence=test_persistence.
TestPersistence.create_dummy_persistence(
self._logger))
self.assertIsNotNone(ac)
check_interval = ac.check_interval
self.assertEqual(check_interval, 123)
def test_is_slave(self):
mc_config = master_connector.MasterConnectorConfigModel()
mc_config.host_url = "http://master.domain/"
config = app_control.AppControlConfigModel()
mc = master_connector.MasterConnector(p_config=mc_config)
ac = app_control.AppControl(p_config=config,
p_debug_mode=False,
p_master_connector=mc,
p_persistence=test_persistence.
TestPersistence.create_dummy_persistence(
self._logger))
self.assertFalse(ac.is_master())
def create_dummy_status_server(p_process_handlers=None,
p_ruleset_configs=None):
if p_process_handlers is None:
p_process_handlers = {}
if p_ruleset_configs is None:
p_ruleset_configs = {}
_persistence = test_persistence.TestPersistence.create_dummy_persistence(
)
_rule_handler = test_rule_handler.TestRuleHandler.create_dummy_rule_handler(
p_ruleset_configs=p_ruleset_configs)
master_connector_config = master_connector.MasterConnectorConfigModel()
_master_connector = master_connector.MasterConnector(
p_config=master_connector_config)
app_control_config = app_control.AppControlConfigModel()
_app_control = app_control.AppControl(
p_config=app_control_config,
p_debug_mode=False,
p_process_handlers=p_process_handlers,
p_persistence=_persistence,
p_rule_handler=_rule_handler,
p_notification_handlers=[],
p_rule_set_configs=p_ruleset_configs,
p_master_connector=_master_connector,
p_username_map=test_data.USERNAME_MAP)
status_server_config = status_server.StatusServerConfigModel()
status_server_config.admin_username = ADMIN_USERNAME
status_server_config.admin_password = ADMIN_PASSWORD
status_server_config.app_secret = "secret!"
status_server_config.port = int(os.getenv("STATUS_SERVER_PORT",
"5555"))
_status_server = status_server.StatusServer(
p_config=status_server_config,
p_package_name=app.PACKAGE_NAME,
p_app_control=_app_control,
p_master_connector=_master_connector,
p_is_master=True)
return _status_server
def test_constructor2(self):
config = app_control.AppControlConfigModel()
config.hostname = HOSTNAME
rule_set_configs = test_rule_handler.TestRuleHandler.create_dummy_ruleset_configs(
)
dummy_persistence = p_persistence = test_persistence.TestPersistence.create_dummy_persistence(
self._logger)
ac = app_control.AppControl(
p_config=config,
p_debug_mode=False,
p_rule_handler=test_rule_handler.TestRuleHandler.
create_dummy_rule_handler(p_persistence=dummy_persistence),
p_persistence=dummy_persistence)
self.assertIsNotNone(ac)
def test_set_metrics(self):
pc_config = prometheus.PrometheusClientConfigModel()
config = app_control.AppControlConfigModel()
pc = prometheus.PrometheusClient(p_logger=self._logger,
p_config=pc_config)
ac = app_control.AppControl(p_config=config,
p_debug_mode=False,
p_prometheus_client=pc,
p_persistence=test_persistence.
TestPersistence.create_dummy_persistence(
self._logger))
ac.set_prometheus_http_requests_summary(p_duration=1.0,
p_hostname=HOSTNAME,
p_service="/app")
ac.set_metrics()
pc.stop()
def prepare_services(self, p_full_startup=True):
super().prepare_services(p_full_startup=p_full_startup)
# TODO: Activate in memory sqlite backend for slaves
self._persistence = persistence.Persistence(
p_config=self._config[persistence.SECTION_NAME])
if not p_full_startup:
return
if self.is_master():
self._rule_handler = rule_handler.RuleHandler(
p_config=self._config[rule_handler.SECTION_NAME],
p_persistence=self._persistence)
self._master_connector = master_connector.MasterConnector(
p_config=self._config[master_connector.SECTION_NAME])
config = self._config[audio_handler.SECTION_NAME]
if config.is_active():
self._notification_handlers.append(
audio_handler.AudioHandler(p_config=config))
config = self._config[popup_handler.SECTION_NAME]
if config.is_active():
self._notification_handlers.append(
popup_handler.PopupHandler(p_config=config))
self.check_migrations()
process_handler = client_process_handler.ClientProcessHandler(
p_config=self._config[client_process_handler.SECTION_NAME],
p_process_iterator_factory=ProcessIteratorFactory())
self._client_device_handler = client_device_handler.ClientDeviceHandler(
p_config=self._config[client_device_handler.SECTION_NAME],
p_persistence=self._persistence)
self._process_handlers = {
process_handler.id: process_handler,
self._client_device_handler.id: self._client_device_handler
}
config = self._config[prometheus.SECTION_NAME]
if config.is_active():
self._prometheus_client = prometheus.PrometheusClient(
p_logger=self._logger, p_config=config)
unix_user_handler_config = self._config[unix_user_handler.SECTION_NAME]
status_server_config = self._config[status_server.SECTION_NAME]
self.init_babel(p_localeselector=self.get_request_locale)
localedir = os.path.join(os.path.dirname(__file__), "translations")
a_locale_helper = locale_helper.LocaleHelper(
p_locale_selector=self.get_request_locale, p_locale_dir=localedir)
self.add_locale_helper(a_locale_helper)
if self.is_master():
if status_server_config.is_active():
if status_server_config.admin_password is not None:
msg = "admin_user and admin_password in section [StatusSever] " \
"should be moved to section [UnixUserHandler]"
self._logger.warning(msg)
if not unix_user_handler_config.is_active():
unix_user_handler_config.admin_username = status_server_config.admin_username
unix_user_handler_config.admin_password = status_server_config.admin_password
if self.is_master(
) and not unix_user_handler_config.is_active():
msg = "admin_user and admin_password must be supplied in section [UnixUserHandler]"
raise configuration.ConfigurationException(msg)
if unix_user_handler_config.is_active():
self._user_handler = unix_user_handler.UnixUserHandler(
p_config=unix_user_handler_config,
p_exclude_user_list=[constants.APPLICATION_USER])
else:
self._user_handler = unix_user_handler.UnixUserHandler(
p_config=unix_user_handler_config)
self._login_mapping = login_mapping.LoginMapping()
self._login_mapping.read_from_configuration(
p_login_mapping_section_handler=self._login_mapping_section_handler
)
self._app_control = app_control.AppControl(
p_config=self._config[app_control.SECTION_NAME],
p_debug_mode=self._app_config.debug_mode,
p_process_handlers=self._process_handlers,
p_device_handler=self._client_device_handler,
p_persistence=self._persistence,
p_rule_handler=self._rule_handler,
p_notification_handlers=self._notification_handlers,
p_master_connector=self._master_connector,
p_prometheus_client=self._prometheus_client,
p_user_handler=self._user_handler,
p_locale_helper=self.locale_helper,
p_login_mapping=self._login_mapping)
if self._config[app_control.SECTION_NAME].scan_active:
task = base_app.RecurringTask(
p_name="app_control.scan_processes(ProcessHandler)",
p_handler_method=lambda: self._app_control.scan_processes(
p_process_handler=process_handler),
p_interval=process_handler.check_interval)
self.add_recurring_task(p_recurring_task=task)
else:
fmt = "Process scanning for this host has been deactivated in configuration"
self._logger.warning(fmt)
if self._client_device_handler:
task = base_app.RecurringTask(
p_name="app_control.scan_processes(DeviceHandler)",
p_handler_method=lambda: self._app_control.scan_processes(
p_process_handler=self._client_device_handler),
p_interval=self._client_device_handler.check_interval)
self.add_recurring_task(p_recurring_task=task)
if status_server_config.is_active():
self._status_server = status_server.StatusServer(
p_config=self._config[status_server.SECTION_NAME],
p_package_name=PACKAGE_NAME,
p_app_control=self._app_control,
p_master_connector=self._master_connector,
p_persistence=self._persistence,
p_is_master=self.is_master(),
p_locale_helper=self._locale_helper,
p_base_gettext=self.gettext,
p_languages=constants.LANGUAGES,
p_user_handler=self._user_handler)
elif self.is_master():
msg = "Master instance requires port number for web server"
raise configuration.ConfigurationException(msg)
else:
msg = "Slave instance will not start web server due to missing port number"
self._logger.warn(msg)
task = base_app.RecurringTask(
p_name="app_control.check",
p_handler_method=self._app_control.check,
p_interval=self._app_control.check_interval)
self.add_recurring_task(p_recurring_task=task)
def prepare_services(self, p_full_startup=True):
device_handler = None
if self.is_master():
self._persistence = persistence.Persistence(
p_config=self._config[persistence.SECTION_NAME])
if not p_full_startup:
return
if self.is_master():
self._rule_handler = rule_handler.RuleHandler(
p_config=self._config[rule_handler.SECTION_NAME],
p_rule_set_configs=self._rule_set_section_handler.
rule_set_configs)
self._master_connector = master_connector.MasterConnector(
p_config=self._config[master_connector.SECTION_NAME])
config = self._config[audio_handler.SECTION_NAME]
if config.is_active():
self._notification_handlers.append(
audio_handler.AudioHandler(p_config=config))
config = self._config[popup_handler.SECTION_NAME]
if config.is_active():
self._notification_handlers.append(
popup_handler.PopupHandler(p_config=config))
process_handler = client_process_handler.ClientProcessHandler(
p_config=self._config[client_process_handler.SECTION_NAME],
p_process_iterator_factory=ProcessIteratorFactory())
self._process_handlers = {process_handler.id: process_handler}
client_device_configs = self._client_device_section_handler.client_device_configs
if len(client_device_configs) > 0:
fmt = "Found {count} client device configuration entry/ies -> activating client device handler"
self._logger.info(fmt.format(count=len(client_device_configs)))
device_handler = client_device_handler.ClientDeviceHandler(
p_config=self._config[client_device_handler.SECTION_NAME],
p_client_device_configs=client_device_configs)
self._process_handlers[device_handler.id] = device_handler
self._app_control = app_control.AppControl(
p_config=self._config[app_control.SECTION_NAME],
p_debug_mode=self._app_config.debug_mode,
p_process_handlers=self._process_handlers,
p_persistence=self._persistence,
p_rule_handler=self._rule_handler,
p_notification_handlers=self._notification_handlers,
p_rule_set_configs=self._rule_set_section_handler.rule_set_configs,
p_master_connector=self._master_connector)
task = base_app.RecurringTask(
p_name="app_control.scan_processes(ProcessHandler)",
p_handler_method=lambda: self._app_control.scan_processes(
p_process_handler=process_handler),
p_interval=process_handler._config.check_interval)
self.add_recurring_task(p_recurring_task=task)
if device_handler:
task = base_app.RecurringTask(
p_name="app_control.scan_processes(DeviceHandler)",
p_handler_method=lambda: self._app_control.scan_processes(
p_process_handler=device_handler),
p_interval=device_handler._config.check_interval)
self.add_recurring_task(p_recurring_task=task)
if self._config[status_server.SECTION_NAME].is_active():
self._status_server = status_server.StatusServer(
p_config=self._config[status_server.SECTION_NAME],
p_package_name=PACKAGE_NAME,
p_app_control=self._app_control,
p_master_connector=self._master_connector,
p_is_master=self.is_master())
elif self.is_master():
msg = "Master instance requires port number for webserver"
raise configuration.ConfigurationException(msg)
else:
msg = "Slave instance will not start webserver due to missing port number"
self._logger.warn(msg)
task = base_app.RecurringTask(
p_name="app_control.check",
p_handler_method=self._app_control.check,
p_interval=self._app_control._config.check_interval)
self.add_recurring_task(p_recurring_task=task)