def devices_view(self): with persistence.SessionContext(p_persistence=self._persistence) as session_context: request = flask.request with tools.TimingContext(lambda duration: self.measure(p_hostname=request.remote_addr, p_service=request.url_rule, p_duration=duration)): devices = self._appcontrol.get_sorted_devices(session_context) forms = self.get_devices_forms(p_devices=devices) valid_and_submitted = True submitted = False for form in forms.values(): if not form.validate_on_submit(): valid_and_submitted = False if form.is_submitted(): submitted = True if valid_and_submitted: self.save_devices_data(devices, forms) if request.form['submit'] == HTML_KEY_NEW_DEVICE: self._persistence.add_new_device(p_session_context=session_context, p_name_pattern=self.gettext("New device {id}")) # TODO: after adding new device Devices window should be opened for new device else: for device in devices: if request.form['submit'] == device.delete_html_key: self._persistence.delete_device(device.id) return flask.redirect(flask.url_for("little_brother.devices")) if not submitted: for device in devices: forms[device.device_name].load_from_model(p_model=device) return flask.render_template( DEVICES_HTML_TEMPLATE, rel_font_size=self.get_rel_font_size(), devices=devices, authentication=self.get_authenication_info(), forms=forms, new_device_html_key=HTML_KEY_NEW_DEVICE, new_device_submit_value=HTML_KEY_NEW_DEVICE, navigation={ 'current_view': DEVICES_VIEW_NAME }, )
def index_view(self): request = flask.request with tools.TimingContext(lambda duration: self.measure(p_hostname=request.remote_addr, p_service=request.url_rule, p_duration=duration)): with persistence.SessionContext(p_persistence=self._persistence) as session_context: user_infos = self._appcontrol.get_user_status_infos(p_session_context=session_context) page = flask.render_template( INDEX_HTML_TEMPLATE, rel_font_size=self.get_rel_font_size(), user_infos=user_infos, has_downtime_today=self.has_downtime_today(p_user_infos=user_infos), app_control_config=self._appcontrol._config, authentication=self.get_authenication_info(), navigation={ 'current_view': INDEX_VIEW_NAME}, ) return page
def save_devices_data(self, p_devices, p_forms): with persistence.SessionContext(p_persistence=self._persistence) as session_context: session = session_context.get_session() changed = False for device in p_devices: form = p_forms[device.device_name] device = persistence.Device.get_by_device_name(p_session=session, p_device_name=device.device_name) if device is not None and form.differs_from_model(p_model=device): form.save_to_model(p_model=device) changed = True session.commit() session.close() if changed: self._persistence.clear_cache()
def test_process_statistics_get_empty_stat_infos(self): start_time = datetime.datetime.utcnow() rule_set_configs = test_data.get_dummy_ruleset_configs( p_ruleset_config=test_data.RULESET_CONFIGS_USER1_ALL_RESTRICTIONS) dummy_persistence = test_persistence.TestPersistence.create_dummy_persistence( self._logger) session_context = persistence.SessionContext( p_persistence=dummy_persistence) dummy_persistence.add_new_user(p_session_context=session_context, p_username=test_data.USER_1) migrator = db_migrations.DatabaseMigrations( p_logger=self._logger, p_persistence=dummy_persistence) migrator.migrate_ruleset_configs(p_ruleset_configs=rule_set_configs) sis = process_statistics.get_empty_stat_infos( p_user_map=dummy_persistence.user_map(session_context), p_reference_time=start_time, p_max_lookback_in_days=5, p_min_activity_duration=30) self.assertIsNotNone(sis)
def about_view(self): with persistence.SessionContext(p_persistence=self._persistence) as session_context: request = flask.request with tools.TimingContext(lambda duration: self.measure(p_hostname=request.remote_addr, p_service=request.url_rule, p_duration=duration)): page = flask.render_template( ABOUT_HTML_TEMPLATE, rel_font_size=self.get_rel_font_size(), user_infos=self._appcontrol.get_user_status_infos(session_context), settings=settings.settings, extended_settings=settings.extended_settings, git_metadata=git.git_metadata, authentication=self.get_authenication_info(), languages=sorted([(a_locale, a_language) for a_locale, a_language in self._languages.items()]), navigation={ 'current_view': ABOUT_VIEW_NAME} ) return page
def test_priority(self): dummy_persistence = test_persistence.TestPersistence.create_dummy_persistence(self._logger) session_context = persistence.SessionContext(p_persistence=dummy_persistence) a_rule_handler = self.create_dummy_rule_handler(p_persistence=dummy_persistence) migrator = db_migrations.DatabaseMigrations(p_logger=self._logger, p_persistence=dummy_persistence) migrator.migrate_ruleset_configs(self.create_dummy_ruleset_configs()) active_rule_set = a_rule_handler.get_active_ruleset(p_session_context=session_context, p_username=TEST_USER, p_reference_date=NORMAL_DAY_1) self.assertIsNotNone(active_rule_set) self.assertEqual(active_rule_set.context, simple_context_rule_handlers.DEFAULT_CONTEXT_RULE_HANDLER_NAME) active_rule_set = a_rule_handler.get_active_ruleset(p_session_context=session_context, p_username=TEST_USER, p_reference_date=WEEKEND_DAY_1) self.assertIsNotNone(active_rule_set) self.assertEqual(active_rule_set.context, simple_context_rule_handlers.WEEKPLAN_CONTEXT_RULE_HANDLER_NAME) active_rule_set = a_rule_handler.get_active_ruleset(p_session_context=session_context, p_username=TEST_USER, p_reference_date=WEEKEND_DAY_2) self.assertIsNotNone(active_rule_set) self.assertEqual(active_rule_set.context, simple_context_rule_handlers.WEEKPLAN_CONTEXT_RULE_HANDLER_NAME) active_rule_set = a_rule_handler.get_active_ruleset(p_session_context=session_context, p_username=TEST_USER, p_reference_date=VACATION_DAY_1) self.assertIsNotNone(active_rule_set) self.assertEqual(active_rule_set.context, german_vacation_context_rule_handler.CALENDAR_CONTEXT_RULE_HANDLER_NAME) active_rule_set = a_rule_handler.get_active_ruleset(p_session_context=session_context, p_username=TEST_USER, p_reference_date=VACATION_DAY_2) self.assertIsNotNone(active_rule_set) self.assertEqual(active_rule_set.context, german_vacation_context_rule_handler.CALENDAR_CONTEXT_RULE_HANDLER_NAME) active_rule_set = a_rule_handler.get_active_ruleset(p_session_context=session_context, p_username=TEST_USER, p_reference_date=WEEKEND_DAY_3) self.assertIsNotNone(active_rule_set) self.assertEqual(active_rule_set.context, simple_context_rule_handlers.WEEKPLAN_CONTEXT_RULE_HANDLER_NAME)
def test_existing_host(self): config = client_device_handler.ClientDeviceHandlerConfigModel() device_config = client_device_handler.ClientDeviceConfigModel( p_section_name="my_device") device_config.username = test_data.USER_1 device_config.hostname = "localhost" device_config.min_activity_duration = 0 device_configs = {device_config.section_name: device_config} dummy_persistence = test_persistence.TestPersistence.create_dummy_persistence( self._logger) session_context = persistence.SessionContext( p_persistence=dummy_persistence) dummy_persistence.add_new_user(p_session_context=session_context, p_username=test_data.USER_1) migrator = db_migrations.DatabaseMigrations( p_logger=self._logger, p_persistence=dummy_persistence) migrator.migrate_client_device_configs(device_configs) process_handler = client_device_handler.ClientDeviceHandler( p_config=config, p_persistence=dummy_persistence) process_handler.scan_processes( p_session_context=session_context, p_server_group=None, p_login_mapping=None, p_host_name=None, p_process_regex_map=None, p_reference_time=datetime.datetime.now()) events = process_handler.scan_processes( p_session_context=session_context, p_server_group=None, p_login_mapping=None, p_host_name=None, p_process_regex_map=None, p_reference_time=datetime.datetime.now()) self.check_list_has_n_elements(p_list=events, p_n=1)
def get_device_info(self, p_device_name): with persistence.SessionContext(p_persistence=self._persistence) as session_context: device_info = self._device_infos.get(p_device_name) device = self._persistence.device_map(session_context).get(p_device_name) if device is not None: if device_info is None: device_info = DeviceInfo(p_device_name=p_device_name, p_max_active_ping_delay=device.max_active_ping_delay, p_min_activity_duration=device.min_activity_duration, p_sample_size=device.sample_size, p_hostname=device.hostname) self._device_infos[p_device_name] = device_info else: device_info.update_max_active_ping_delay(device.max_active_ping_delay) device_info.update_min_activity_duration(device.min_activity_duration) device_info.update_hostname(device.hostname) device_info.update_sample_size(device.sample_size) return device_info
def admin_view(self): request = flask.request with tools.TimingContext(lambda duration: self.measure(p_hostname=request.remote_addr, p_service=request.url_rule, p_duration=duration)): with persistence.SessionContext(p_persistence=self._persistence) as session_context: admin_infos = self._appcontrol.get_admin_infos(p_session_context=session_context) forms = self.get_admin_forms(p_admin_infos=admin_infos) valid_and_submitted = True submitted = False for form in forms.values(): if not form.validate_on_submit(): valid_and_submitted = False if form.is_submitted(): submitted = True if valid_and_submitted: self.save_admin_data(admin_infos, forms) return flask.redirect(flask.url_for("little_brother.admin")) if not submitted: for admin_info in admin_infos: for day_info in admin_info.day_infos: forms[day_info.html_key].load_from_model(p_model=day_info.override) return flask.render_template( ADMIN_HTML_TEMPLATE, rel_font_size=self.get_rel_font_size(), admin_infos=admin_infos, authentication=self.get_authenication_info(), forms=forms, navigation={ 'current_view': ADMIN_VIEW_NAME}, )
def save_users_data(self, p_users, p_forms): with persistence.SessionContext(p_persistence=self._persistence) as session_context: session = session_context.get_session() changed = False for user in p_users: form = p_forms[user.html_key] persistent_user = persistence.User.get_by_username(p_session=session, p_username=user.username) if persistent_user is not None and form.differs_from_model(p_model=persistent_user): form.save_to_model(p_model=persistent_user) changed = True for ruleset in user.rulesets: form = p_forms[ruleset.html_key] persistent_ruleset = persistence.RuleSet.get_by_id(p_session=session, p_id=ruleset.id) if persistent_ruleset is not None and form.differs_from_model(p_model=persistent_ruleset): form.save_to_model(p_model=persistent_ruleset) changed = True for user2device in user.devices: form = p_forms[user2device.html_key] persistent_user2device = persistence.User2Device.get_by_id(p_session=session, p_id=user2device.id) if persistent_user2device is not None and form.differs_from_model(p_model=persistent_user2device): form.save_to_model(p_model=persistent_user2device) changed = True if changed: session.commit() self._persistence.clear_cache() self._appcontrol.send_config_to_all_slaves() self._appcontrol.reset_users(p_session_context=session_context)
def scan_processes(self, p_session_context, p_reference_time, p_server_group, p_login_mapping, p_host_name, p_process_regex_map): events = [] with persistence.SessionContext(p_persistence=self._persistence) as session_context: for device in self._persistence.devices(p_session_context): self.ping_device(p_reference_time=p_reference_time, p_device=device) for device_info in self._device_infos.values(): if device_info.device_name not in self._persistence.device_map(session_context): # Clear statistics for old device names so that they are correctly reported in Prometheus device_info.clear_moving_average() for device in self._persistence.devices(session_context): device_info = self.get_device_info(p_device_name=device.device_name) if device_info.requires_process_start_event(p_reference_time=p_reference_time): # Send process start event for monitored users (if required) for user2device in device.users: current_pinfo = self.get_current_active_pinfo(device.hostname, p_username=user2device.user.username) if user2device.active: if current_pinfo is None: event = admin_event.AdminEvent( p_event_type=admin_event.EVENT_TYPE_PROCESS_START, p_hostname=device_info.hostname, p_hostlabel=device_info.device_name, p_processhandler=self.id, p_username=user2device.user.username, p_percent=user2device.percent, p_process_start_time=p_reference_time) events.append(event) else: if current_pinfo is not None: event = self.create_admin_event_process_end_from_pinfo( p_pinfo=current_pinfo, p_reference_time=p_reference_time) events.append(event) else: # Send process stop event for non monitored users (if required) for user2device in device.users: current_pinfo = self.get_current_active_pinfo(device.hostname, p_username=user2device.user.username) if current_pinfo is not None: event = self.create_admin_event_process_end_from_pinfo( p_pinfo=current_pinfo, p_reference_time=p_reference_time) events.append(event) active_hostnames = [device_info.hostname for device_info in self._device_infos.values() if device_info.is_up] for pinfo in self._process_infos.values(): # If the end time of a current entry is None AND the process was started on the local host AND # the process is no longer running THEN send an EVENT_TYPE_PROCESS_END event! if pinfo.end_time is None and pinfo.hostname not in active_hostnames: event = self.create_admin_event_process_end_from_pinfo( p_pinfo=pinfo, p_reference_time=p_reference_time) events.append(event) return events
def get_number_of_monitored_devices(self): with persistence.SessionContext(p_persistence=self._persistence) as session_context: return len(self._persistence.devices(session_context))
def users_view(self): with persistence.SessionContext(p_persistence=self._persistence) as session_context: request = flask.request with tools.TimingContext(lambda duration: self.measure(p_hostname=request.remote_addr, p_service=request.url_rule, p_duration=duration)): users = self._appcontrol.get_sorted_users(session_context) forms = self.get_users_forms(p_users=users, p_session_context=session_context) valid_and_submitted = True submitted = False for form in forms.values(): if not form.validate_on_submit(): valid_and_submitted = False if form.is_submitted(): submitted = True if valid_and_submitted: self.save_users_data(users, forms) if request.form['submit'] == HTML_KEY_NEW_USER: username = forms[HTML_KEY_NEW_USER].username.data self._appcontrol.add_new_user(p_session_context=session_context, p_username=username, p_locale=self._locale_helper.locale) # TODO: after adding new user Users window should be opened for new user else: for user in users: if request.form['submit'] == user.delete_html_key: self._persistence.delete_user(user.username) self._appcontrol.send_config_to_all_slaves() elif request.form['submit'] == user.new_ruleset_html_key: self._persistence.add_ruleset(user.username) elif request.form['submit'] == user.new_device_html_key: device_id = int(forms[user.new_device_html_key].device_id.data) self._persistence.add_device(p_device_id=device_id, p_username=user.username) else: for ruleset in user.rulesets: if request.form['submit'] == ruleset.delete_html_key: self._persistence.delete_ruleset(p_ruleset_id=ruleset.id) elif request.form['submit'] == ruleset.move_down_html_key: self._persistence.move_down_ruleset(p_ruleset_id=ruleset.id) elif request.form['submit'] == ruleset.move_up_html_key: self._persistence.move_up_ruleset(p_ruleset_id=ruleset.id) for user2device in user.devices: if request.form['submit'] == user2device.delete_html_key: self._persistence.delete_user2device(p_user2device_id=user2device.id) return flask.redirect(flask.url_for("little_brother.users")) if not submitted: for user in users: forms[user.html_key].load_from_model(p_model=user) for ruleset in user.rulesets: forms[ruleset.html_key].load_from_model(p_model=ruleset) # provide a callback function so that the RuleSet can retrieve context summaries ruleset.get_context_rule_handler = self._appcontrol.get_context_rule_handler for user2device in user.devices: forms[user2device.html_key].load_from_model(p_model=user2device) return flask.render_template( USERS_HTML_TEMPLATE, rel_font_size=self.get_rel_font_size(), users=users, authentication=self.get_authenication_info(), forms=forms, new_user_html_key=HTML_KEY_NEW_USER, new_user_submit_value=HTML_KEY_NEW_USER, navigation={ 'current_view': USERS_VIEW_NAME }, )