From 748eb69d894630539e90fac293331f80be55d762 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 13:45:27 +0200 Subject: [PATCH 01/24] monioring/lib: Reorder query columns in the ServicestatusQuery --- .../Backend/Ido/Query/ServicestatusQuery.php | 131 +++++++++--------- 1 file changed, 66 insertions(+), 65 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php index b1f3591ad..01e44bea7 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php @@ -19,9 +19,6 @@ class ServicestatusQuery extends IdoQuery * {@inheritdoc} */ protected $columnMap = array( - 'instances' => array( - 'instance_name' => 'i.instance_name' - ), 'hostgroups' => array( 'hostgroup' => 'hgo.name1 COLLATE latin1_general_ci', 'hostgroup_alias' => 'hg.alias COLLATE latin1_general_ci', @@ -48,8 +45,8 @@ class ServicestatusQuery extends IdoQuery 'host_check_execution_time' => 'hs.execution_time', 'host_check_latency' => 'hs.latency', 'host_check_source' => 'hs.check_source', - 'host_check_type' => 'hs.check_type', 'host_check_timeperiod_object_id' => 'hs.check_timeperiod_object_id', + 'host_check_type' => 'hs.check_type', 'host_current_check_attempt' => 'hs.current_check_attempt', 'host_current_notification_number' => 'hs.current_notification_number', 'host_event_handler' => 'hs.event_handler', @@ -92,10 +89,6 @@ class ServicestatusQuery extends IdoQuery 'host_process_performance_data' => 'hs.process_performance_data', 'host_retry_check_interval' => 'hs.retry_check_interval', 'host_scheduled_downtime_depth' => 'hs.scheduled_downtime_depth', - 'host_state' => 'CASE WHEN hs.has_been_checked = 0 OR hs.has_been_checked IS NULL THEN 99 ELSE hs.current_state END', - 'host_state_type' => 'hs.state_type', - 'host_status_update_time' => 'hs.status_update_time', - 'host_unhandled' => 'CASE WHEN (hs.problem_has_been_acknowledged + hs.scheduled_downtime_depth) = 0 THEN 1 ELSE 0 END', 'host_severity' => 'CASE WHEN hs.current_state = 0 THEN CASE WHEN hs.has_been_checked = 0 OR hs.has_been_checked IS NULL @@ -131,7 +124,15 @@ class ServicestatusQuery extends IdoQuery CASE WHEN hs.state_type = 1 THEN 8 ELSE 0 - END' + END', + 'host_state' => 'CASE WHEN hs.has_been_checked = 0 OR hs.has_been_checked IS NULL THEN 99 ELSE hs.current_state END', + 'host_state_type' => 'hs.state_type', + 'host_status_update_time' => 'hs.status_update_time', + 'host_unhandled' => 'CASE WHEN (hs.problem_has_been_acknowledged + hs.scheduled_downtime_depth) = 0 THEN 1 ELSE 0 END' + + ), + 'instances' => array( + 'instance_name' => 'i.instance_name' ), 'services' => array( 'host' => 'so.name1 COLLATE latin1_general_ci', @@ -154,65 +155,61 @@ class ServicestatusQuery extends IdoQuery 'servicegroup_alias' => 'sg.alias COLLATE latin1_general_ci' ), 'servicestatus' => array( - 'service_state_type' => 'ss.state_type', - 'service_output' => 'ss.output', - 'service_long_output' => 'ss.long_output', - 'service_perfdata' => 'ss.perfdata', - 'service_check_source' => 'ss.check_source', 'service_acknowledged' => 'ss.problem_has_been_acknowledged', - 'service_check_command' => 'ss.check_command', - 'service_last_time_ok' => 'ss.last_time_ok', - 'service_last_time_warning' => 'ss.last_time_warning', - 'service_last_time_critical' => 'ss.last_time_critical', - 'service_last_time_unknown' => 'ss.last_time_unknown', - 'service_current_check_attempt' => 'ss.current_check_attempt', - 'service_max_check_attempts' => 'ss.max_check_attempts', - 'service_attempt' => 'ss.current_check_attempt || \'/\' || ss.max_check_attempts', - 'service_last_check' => 'UNIX_TIMESTAMP(ss.last_check)', - 'service_next_check' => 'UNIX_TIMESTAMP(ss.next_check)', - 'service_check_type' => 'ss.check_type', - 'service_last_hard_state_change' => 'UNIX_TIMESTAMP(ss.last_hard_state_change)', - 'service_last_hard_state' => 'ss.last_hard_state', - 'service_last_notification' => 'UNIX_TIMESTAMP(ss.last_notification)', - 'service_next_notification' => 'UNIX_TIMESTAMP(ss.next_notification)', - 'service_no_more_notifications' => 'ss.no_more_notifications', - 'service_problem_has_been_acknowledged' => 'ss.problem_has_been_acknowledged', 'service_acknowledgement_type' => 'ss.acknowledgement_type', - 'service_current_notification_number' => 'ss.current_notification_number', - 'service_percent_state_change' => 'ss.percent_state_change', - 'service_check_latency' => 'ss.latency', - 'service_check_execution_time' => 'ss.execution_time', - 'service_scheduled_downtime_depth' => 'ss.scheduled_downtime_depth', - 'service_failure_prediction_enabled' => 'ss.failure_prediction_enabled', - 'service_process_performance_data' => 'ss.process_performance_data', - 'service_modified_service_attributes' => 'ss.modified_service_attributes', - 'service_event_handler' => 'ss.event_handler', - 'service_normal_check_interval' => 'ss.normal_check_interval', - 'service_retry_check_interval' => 'ss.retry_check_interval', - 'service_check_timeperiod_object_id' => 'ss.check_timeperiod_object_id', - 'service_status_update_time' => 'ss.status_update_time', - 'service_passive_checks_enabled' => 'ss.passive_checks_enabled', - 'service_is_reachable' => 'ss.is_reachable', - 'service_passive_checks_enabled_changed' => 'CASE WHEN ss.passive_checks_enabled=s.passive_checks_enabled THEN 0 ELSE 1 END', 'service_active_checks_enabled' => 'ss.active_checks_enabled', 'service_active_checks_enabled_changed' => 'CASE WHEN ss.active_checks_enabled=s.active_checks_enabled THEN 0 ELSE 1 END', + 'service_attempt' => 'ss.current_check_attempt || \'/\' || ss.max_check_attempts', + 'service_check_command' => 'ss.check_command', + 'service_check_execution_time' => 'ss.execution_time', + 'service_check_latency' => 'ss.latency', + 'service_check_source' => 'ss.check_source', + 'service_check_timeperiod_object_id' => 'ss.check_timeperiod_object_id', + 'service_check_type' => 'ss.check_type', + 'service_current_check_attempt' => 'ss.current_check_attempt', + 'service_current_notification_number' => 'ss.current_notification_number', + 'service_event_handler' => 'ss.event_handler', 'service_event_handler_enabled' => 'ss.event_handler_enabled', 'service_event_handler_enabled_changed' => 'CASE WHEN ss.event_handler_enabled=s.event_handler_enabled THEN 0 ELSE 1 END', + 'service_failure_prediction_enabled' => 'ss.failure_prediction_enabled', 'service_flap_detection_enabled' => 'ss.flap_detection_enabled', 'service_flap_detection_enabled_changed' => 'CASE WHEN ss.flap_detection_enabled=s.flap_detection_enabled THEN 0 ELSE 1 END', - 'service_obsessing' => 'ss.obsess_over_service', - 'service_obsessing_changed' => 'CASE WHEN ss.obsess_over_service=s.obsess_over_service THEN 0 ELSE 1 END', 'service_handled' => 'CASE WHEN (ss.problem_has_been_acknowledged + ss.scheduled_downtime_depth + COALESCE(hs.current_state, 0)) > 0 THEN 1 ELSE 0 END', 'service_hard_state' => 'CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL THEN 99 ELSE CASE WHEN ss.state_type = 1 THEN ss.current_state ELSE ss.last_hard_state END END', + 'service_in_downtime' => 'CASE WHEN (ss.scheduled_downtime_depth = 0 OR ss.scheduled_downtime_depth IS NULL) THEN 0 ELSE 1 END', 'service_is_flapping' => 'ss.is_flapping', 'service_is_passive_checked' => 'CASE WHEN ss.active_checks_enabled = 0 AND ss.passive_checks_enabled = 1 THEN 1 ELSE 0 END', + 'service_is_reachable' => 'ss.is_reachable', + 'service_last_check' => 'UNIX_TIMESTAMP(ss.last_check)', + 'service_last_hard_state' => 'ss.last_hard_state', + 'service_last_hard_state_change' => 'UNIX_TIMESTAMP(ss.last_hard_state_change)', + 'service_last_notification' => 'UNIX_TIMESTAMP(ss.last_notification)', 'service_last_state_change' => 'UNIX_TIMESTAMP(ss.last_state_change)', + 'service_last_time_critical' => 'ss.last_time_critical', + 'service_last_time_ok' => 'ss.last_time_ok', + 'service_last_time_unknown' => 'ss.last_time_unknown', + 'service_last_time_warning' => 'ss.last_time_warning', + 'service_long_output' => 'ss.long_output', + 'service_max_check_attempts' => 'ss.max_check_attempts', + 'service_modified_service_attributes' => 'ss.modified_service_attributes', + 'service_next_check' => 'UNIX_TIMESTAMP(ss.next_check)', + 'service_next_notification' => 'UNIX_TIMESTAMP(ss.next_notification)', + 'service_no_more_notifications' => 'ss.no_more_notifications', + 'service_normal_check_interval' => 'ss.normal_check_interval', 'service_notifications_enabled' => 'ss.notifications_enabled', 'service_notifications_enabled_changed' => 'CASE WHEN ss.notifications_enabled=s.notifications_enabled THEN 0 ELSE 1 END', - 'service_in_downtime' => 'CASE WHEN (ss.scheduled_downtime_depth = 0 OR ss.scheduled_downtime_depth IS NULL) THEN 0 ELSE 1 END', - 'service_state' => 'CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL THEN 99 ELSE ss.current_state END', - 'service_unhandled' => 'CASE WHEN (ss.problem_has_been_acknowledged + ss.scheduled_downtime_depth + COALESCE(hs.current_state, 0)) = 0 THEN 1 ELSE 0 END', + 'service_obsessing' => 'ss.obsess_over_service', + 'service_obsessing_changed' => 'CASE WHEN ss.obsess_over_service=s.obsess_over_service THEN 0 ELSE 1 END', + 'service_output' => 'ss.output', + 'service_passive_checks_enabled' => 'ss.passive_checks_enabled', + 'service_passive_checks_enabled_changed' => 'CASE WHEN ss.passive_checks_enabled=s.passive_checks_enabled THEN 0 ELSE 1 END', + 'service_percent_state_change' => 'ss.percent_state_change', + 'service_perfdata' => 'ss.perfdata', 'service_problem' => 'CASE WHEN COALESCE(ss.current_state, 0) = 0 THEN 0 ELSE 1 END', + 'service_problem_has_been_acknowledged' => 'ss.problem_has_been_acknowledged', + 'service_process_performance_data' => 'ss.process_performance_data', + 'service_retry_check_interval' => 'ss.retry_check_interval', + 'service_scheduled_downtime_depth' => 'ss.scheduled_downtime_depth', 'service_severity' => 'CASE WHEN ss.current_state = 0 THEN CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL @@ -253,7 +250,11 @@ class ServicestatusQuery extends IdoQuery CASE WHEN ss.state_type = 1 THEN 8 ELSE 0 - END' + END', + 'service_state' => 'CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL THEN 99 ELSE ss.current_state END', + 'service_state_type' => 'ss.state_type', + 'service_status_update_time' => 'ss.status_update_time', + 'service_unhandled' => 'CASE WHEN (ss.problem_has_been_acknowledged + ss.scheduled_downtime_depth + COALESCE(hs.current_state, 0)) = 0 THEN 1 ELSE 0 END' ) ); @@ -282,18 +283,6 @@ class ServicestatusQuery extends IdoQuery $this->joinedVirtualTables['services'] = true; } - /** - * Join instances - */ - protected function joinInstances() - { - $this->select->join( - array('i' => $this->prefix . 'instances'), - 'i.instance_id = so.instance_id', - array() - ); - } - /** * Join host groups */ @@ -338,6 +327,18 @@ class ServicestatusQuery extends IdoQuery ); } + /** + * Join instances + */ + protected function joinInstances() + { + $this->select->join( + array('i' => $this->prefix . 'instances'), + 'i.instance_id = so.instance_id', + array() + ); + } + /** * Join service groups */ From bb67642d4b956052e4d80cc980be2e031735870d Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 15:33:55 +0200 Subject: [PATCH 02/24] monitoring/detail: Hide next check counter if the service is pending --- .../views/scripts/show/components/checkstatistics.phtml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index 415b66b76..c2338749c 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -55,7 +55,9 @@ if ($object->getType() === $object::TYPE_HOST) { ); } } ?> - timeUntil($object->next_check) ?> + state !== 99) { + echo $this->timeUntil($object->next_check); + } ?> From 90e6ea77c532e681bdc5a8f54c9b9bbd7506e38c Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 15:35:32 +0200 Subject: [PATCH 03/24] monitoring/lib: Reorder query columns in Host --- modules/monitoring/library/Monitoring/Object/Host.php | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Object/Host.php b/modules/monitoring/library/Monitoring/Object/Host.php index 6fe058972..7d7f6f125 100644 --- a/modules/monitoring/library/Monitoring/Object/Host.php +++ b/modules/monitoring/library/Monitoring/Object/Host.php @@ -89,9 +89,6 @@ class Host extends MonitoredObject protected function getDataView() { $columns = array( - 'instance_name', - 'host_icon_image', - 'host_icon_image_alt', 'host_acknowledged', 'host_acknowledgement_type', 'host_action_url', @@ -111,6 +108,8 @@ class Host extends MonitoredObject 'host_flap_detection_enabled', 'host_flap_detection_enabled_changed', 'host_handled', + 'host_icon_image', + 'host_icon_image_alt', 'host_in_downtime', 'host_is_flapping', 'host_is_reachable', @@ -134,7 +133,8 @@ class Host extends MonitoredObject 'host_perfdata', 'host_process_perfdata' => 'host_process_performance_data', 'host_state', - 'host_state_type' + 'host_state_type', + 'instance_name', ); if ($this->backend->getType() === 'livestatus') { $columns[] = 'host_contacts'; From 7a7214d626108090ed969b48f46294b112c30b84 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 15:35:52 +0200 Subject: [PATCH 04/24] monitoring/host: Select host_attempt --- modules/monitoring/library/Monitoring/Object/Host.php | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/monitoring/library/Monitoring/Object/Host.php b/modules/monitoring/library/Monitoring/Object/Host.php index 7d7f6f125..4427887e6 100644 --- a/modules/monitoring/library/Monitoring/Object/Host.php +++ b/modules/monitoring/library/Monitoring/Object/Host.php @@ -96,6 +96,7 @@ class Host extends MonitoredObject 'host_active_checks_enabled_changed', 'host_address', 'host_alias', + 'host_attempt', 'host_check_command', 'host_check_execution_time', 'host_check_latency', From 3401d09b59478eba16cdc40b1e53ec48afee6091 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 15:37:07 +0200 Subject: [PATCH 05/24] monitoring/detail: Hide last check counter if the service is pending --- .../views/scripts/show/components/checkstatistics.phtml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index c2338749c..aeafd42be 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -20,7 +20,9 @@ if ($object->getType() === $object::TYPE_HOST) { - timeAgo($object->last_check) ?> + state !== 99) { + echo $this->timeUntil($object->last_check); + } ?> From e64c2947ea14228f35f782798309d36a0f99a034 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 15:42:02 +0200 Subject: [PATCH 06/24] monitoring: Reduce complexity of the checkstatistics view script --- .../show/components/checkstatistics.phtml | 47 +++++++------------ 1 file changed, 18 insertions(+), 29 deletions(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index aeafd42be..228983d1f 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -1,17 +1,5 @@ getType() === $object::TYPE_HOST) { - $isService = false; - $checkAttempts = $object->host_current_check_attempt . '/' . $object->host_max_check_attempts; - $stateType = (int) $object->host_state_type; -} else { - $isService = true; - $checkAttempts = $object->service_attempt; - $stateType = (int) $object->service_state_type; -} - ?> @@ -21,15 +9,16 @@ if ($object->getType() === $object::TYPE_HOST) { echo $checkNowForm; } ?> state !== 99) { - echo $this->timeUntil($object->last_check); + echo $this->timeAgo($object->last_check); } ?> + translate('Next check') ?> hasPermission('monitoring/command/schedule-check')) { - if ($isService) { + if ($object->getType() === $object::TYPE_SERVICE) { echo $this->qlink( $this->translate('Reschedule'), 'monitoring/service/reschedule-check', @@ -62,25 +51,25 @@ if ($object->getType() === $object::TYPE_HOST) { } ?> + translate('Check attempts') ?> - - (translate('soft state') ?>) - - (translate('hard state') ?>) - + + attempt ?> + (state_type === 0 ? $this->translate('soft state') : $this->translate('hard state') ?>) + + check_execution_time): ?> - - translate('Check execution time') ?> - check_execution_time === null - ? '-' : round((float) $object->check_execution_time, 3) - ?>s - + + translate('Check execution time') ?> + check_execution_time, 3) ?>s + + check_latency): ?> - - translate('Check latency') ?> - check_latency ?>s - + + translate('Check latency') ?> + check_latency ?>s + From bef84ad3948e31a4a11f8efacdb9d8ec0a94bb71 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 15:43:13 +0200 Subject: [PATCH 07/24] monitoring/detail: Read "Last update" instead of "Last check" if the host or service is not active checked refs #8378 --- .../views/scripts/show/components/checkstatistics.phtml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index 228983d1f..d2b08b6b7 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -3,7 +3,7 @@ ?> - translate('Last check') ?> + active_checks_enabled ? $this->translate('Last check') : $this->translate('Last update') ?> Date: Fri, 4 Sep 2015 15:48:45 +0200 Subject: [PATCH 08/24] monitoring/detail: Read "Next update" instead of "Next check" if the host or service is not active checked refs #8378 --- .../show/components/checkstatistics.phtml | 70 +++++++++---------- 1 file changed, 35 insertions(+), 35 deletions(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index d2b08b6b7..fb6a575c0 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -15,41 +15,41 @@ - translate('Next check') ?> - - hasPermission('monitoring/command/schedule-check')) { - if ($object->getType() === $object::TYPE_SERVICE) { - echo $this->qlink( - $this->translate('Reschedule'), - 'monitoring/service/reschedule-check', - array('host' => $object->getHost()->getName(), 'service' => $object->getName()), - array( - 'icon' => 'reschedule', - 'data-base-target' => '_self', - 'title' => $this->translate( - 'Schedule the next active check at a different time than the current one' - ) - ) - ); - } else { - echo $this->qlink( - $this->translate('Reschedule'), - 'monitoring/host/reschedule-check', - array('host' => $object->getName()), - array( - 'icon' => 'reschedule', - 'data-base-target' => '_self', - 'title' => $this->translate( - 'Schedule the next active check at a different time than the current one' - ) - ) - ); - } - } ?> - state !== 99) { - echo $this->timeUntil($object->next_check); - } ?> - + active_checks_enabled ? $this->translate('Next check') : $this->translate('Next update') ?> + + hasPermission('monitoring/command/schedule-check')) { + if ($object->getType() === $object::TYPE_SERVICE) { + echo $this->qlink( + $this->translate('Reschedule'), + 'monitoring/service/reschedule-check', + array('host' => $object->getHost()->getName(), 'service' => $object->getName()), + array( + 'icon' => 'reschedule', + 'data-base-target' => '_self', + 'title' => $this->translate( + 'Schedule the next active check at a different time than the current one' + ) + ) + ); + } else { + echo $this->qlink( + $this->translate('Reschedule'), + 'monitoring/host/reschedule-check', + array('host' => $object->getName()), + array( + 'icon' => 'reschedule', + 'data-base-target' => '_self', + 'title' => $this->translate( + 'Schedule the next active check at a different time than the current one' + ) + ) + ); + } + } ?> + state !== 99) { + echo $this->timeUntil($object->next_check); + } ?> + From 562fec68cf56532f3ec1b468cdd1762bda0107c4 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 16:18:41 +0200 Subject: [PATCH 09/24] monitoring/servicestatus: Add columns service_next_update and service_next_update_is_late refs #8378 --- .../Backend/Ido/Query/ServicestatusQuery.php | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php index 01e44bea7..3d2c0447c 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php @@ -194,6 +194,39 @@ class ServicestatusQuery extends IdoQuery 'service_modified_service_attributes' => 'ss.modified_service_attributes', 'service_next_check' => 'UNIX_TIMESTAMP(ss.next_check)', 'service_next_notification' => 'UNIX_TIMESTAMP(ss.next_notification)', + 'service_next_update' => 'CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL + THEN + NULL + ELSE + UNIX_TIMESTAMP(ss.last_check) + + CASE WHEN + COALESCE(ss.current_state, 0) = 0 + THEN + ss.normal_check_interval + ELSE + ss.retry_check_interval + END * 60 + + FLOOR(ss.execution_time) * 2 + END', + // TODO(el): Remove column once we support service_expected_update>now + 'service_next_update_is_late' => 'CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL + THEN + 0 + ELSE + CASE WHEN (UNIX_TIMESTAMP(ss.last_check) + + CASE WHEN COALESCE(ss.current_state, 0) = 0 + THEN + ss.normal_check_interval + ELSE + ss.retry_check_interval + END * 60 + + FLOOR(ss.execution_time) * 2) > CURRENT_TIMESTAMP() + THEN + 1 + ELSE + 0 + END + END', 'service_no_more_notifications' => 'ss.no_more_notifications', 'service_normal_check_interval' => 'ss.normal_check_interval', 'service_notifications_enabled' => 'ss.notifications_enabled', From e5ff81aa8472b1bd19858254ea30bd7b3f3a4c90 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 16:20:23 +0200 Subject: [PATCH 10/24] monitoring/hoststatus: Add columns host_next_update and host_next_update_is_late refs #8378 --- .../Backend/Ido/Query/HoststatusQuery.php | 33 +++++++++++++++++++ .../Backend/Ido/Query/ServicestatusQuery.php | 2 +- 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php index d3d4cfcb8..2cfa6c129 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php @@ -77,6 +77,39 @@ class HoststatusQuery extends IdoQuery 'host_modified_host_attributes' => 'hs.modified_host_attributes', 'host_next_check' => 'CASE hs.should_be_scheduled WHEN 1 THEN UNIX_TIMESTAMP(hs.next_check) ELSE NULL END', 'host_next_notification' => 'UNIX_TIMESTAMP(hs.next_notification)', + 'host_next_update' => 'CASE WHEN hs.has_been_checked = 0 OR hs.has_been_checked IS NULL + THEN + NULL + ELSE + UNIX_TIMESTAMP(hs.last_check) + + CASE WHEN + COALESCE(hs.current_state, 0) = 0 + THEN + hs.normal_check_interval + ELSE + hs.retry_check_interval + END * 60 + + FLOOR(hs.execution_time) * 2 + END', + // TODO(el): Remove column once we support host_next_update>now + 'host_next_update_is_late' => 'CASE WHEN hs.has_been_checked = 0 OR hs.has_been_checked IS NULL + THEN + 0 + ELSE + CASE WHEN (UNIX_TIMESTAMP(hs.last_check) + + CASE WHEN COALESCE(hs.current_state, 0) = 0 + THEN + hs.normal_check_interval + ELSE + hs.retry_check_interval + END * 60 + + FLOOR(hs.execution_time) * 2) > CURRENT_TIMESTAMP() + THEN + 1 + ELSE + 0 + END + END', 'host_no_more_notifications' => 'hs.no_more_notifications', 'host_normal_check_interval' => 'hs.normal_check_interval', 'host_notifications_enabled' => 'hs.notifications_enabled', diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php index 3d2c0447c..68854ef4e 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php @@ -208,7 +208,7 @@ class ServicestatusQuery extends IdoQuery END * 60 + FLOOR(ss.execution_time) * 2 END', - // TODO(el): Remove column once we support service_expected_update>now + // TODO(el): Remove column once we support service_next_update>now 'service_next_update_is_late' => 'CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL THEN 0 From a10652abfc61c45f36fd5ac3f0e1e22e11a671e7 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 16:22:16 +0200 Subject: [PATCH 11/24] monitoring/service: Select next_update refs #8378 --- modules/monitoring/library/Monitoring/Object/Service.php | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/monitoring/library/Monitoring/Object/Service.php b/modules/monitoring/library/Monitoring/Object/Service.php index 72cd1c1db..0294bb852 100644 --- a/modules/monitoring/library/Monitoring/Object/Service.php +++ b/modules/monitoring/library/Monitoring/Object/Service.php @@ -149,6 +149,7 @@ class Service extends MonitoredObject 'service_last_state_change', 'service_long_output', 'service_next_check', + 'service_next_update', 'service_notes', 'service_notes_url', 'service_notifications_enabled', From 24f3d42d96dcd95df8e708e58a834b68b5005dd5 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 16:22:31 +0200 Subject: [PATCH 12/24] monitoring/host: Select next_update refs #8378 --- modules/monitoring/library/Monitoring/Object/Host.php | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/monitoring/library/Monitoring/Object/Host.php b/modules/monitoring/library/Monitoring/Object/Host.php index 4427887e6..145f7c7c2 100644 --- a/modules/monitoring/library/Monitoring/Object/Host.php +++ b/modules/monitoring/library/Monitoring/Object/Host.php @@ -121,6 +121,7 @@ class Host extends MonitoredObject 'host_max_check_attempts', 'host_name', 'host_next_check', + 'host_next_update', 'host_notes', 'host_notes_url', 'host_notifications_enabled', From 363f6271d93b1f0f2fd0643de5ff204e7a5c53fd Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 17:14:16 +0200 Subject: [PATCH 13/24] monitoring/detail: Show the expected next update if the host or service is not actively checked refs #8378 --- .../views/scripts/show/components/checkstatistics.phtml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index fb6a575c0..bb967b4e0 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -47,7 +47,11 @@ } } ?> state !== 99) { - echo $this->timeUntil($object->next_check); + if ((bool) $object->active_checks_enabled) { + echo $this->timeUntil($object->next_check); + } else { + echo sprintf($this->translate('expected %s'), $this->timeUntil($object->next_update)); + } } ?> From 7464742afebd762620dbc072ec46ec185ccec4ab Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 17:18:07 +0200 Subject: [PATCH 14/24] monitoring/detail: Hide Reschedule link if the host or service is not actively checked refs #8378 --- .../views/scripts/show/components/checkstatistics.phtml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index bb967b4e0..7df82b32d 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -17,7 +17,7 @@ active_checks_enabled ? $this->translate('Next check') : $this->translate('Next update') ?> - hasPermission('monitoring/command/schedule-check')) { + active_checks_enabled && $this->hasPermission('monitoring/command/schedule-check')) { if ($object->getType() === $object::TYPE_SERVICE) { echo $this->qlink( $this->translate('Reschedule'), From 20fd99944b9a319653103b7430b82f1200805095 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 18:09:25 +0200 Subject: [PATCH 15/24] monitoring/detail: Add $activeChecksEnabled variable in the checkstatistics view script refs #8378 --- .../views/scripts/show/components/checkstatistics.phtml | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index 7df82b32d..b69e0af0f 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -1,9 +1,10 @@ active_checks_enabled; ?> - active_checks_enabled ? $this->translate('Last check') : $this->translate('Last update') ?> + translate('Last check') : $this->translate('Last update') ?> - active_checks_enabled ? $this->translate('Next check') : $this->translate('Next update') ?> + translate('Next check') : $this->translate('Next update') ?> - active_checks_enabled && $this->hasPermission('monitoring/command/schedule-check')) { + hasPermission('monitoring/command/schedule-check')) { if ($object->getType() === $object::TYPE_SERVICE) { echo $this->qlink( $this->translate('Reschedule'), @@ -47,7 +48,7 @@ } } ?> state !== 99) { - if ((bool) $object->active_checks_enabled) { + if ($activeChecksEnabled) { echo $this->timeUntil($object->next_check); } else { echo sprintf($this->translate('expected %s'), $this->timeUntil($object->next_update)); From fe1c6d33fa41e67e2d0a0266c0a7d44d2656fc5d Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 10:21:17 +0200 Subject: [PATCH 16/24] font: Add icon-circle refs #8378 --- application/fonts/fontello-ifont/config.json | 6 ++++++ .../fonts/fontello-ifont/css/ifont-codes.css | 3 ++- .../fontello-ifont/css/ifont-embedded.css | 15 ++++++++------- .../fontello-ifont/css/ifont-ie7-codes.css | 3 ++- .../fonts/fontello-ifont/css/ifont-ie7.css | 3 ++- .../fonts/fontello-ifont/css/ifont.css | 15 ++++++++------- application/fonts/fontello-ifont/demo.html | 11 ++++++----- public/font/ifont.eot | Bin 30472 -> 30868 bytes public/font/ifont.svg | 3 +++ public/font/ifont.ttf | Bin 30316 -> 30712 bytes public/font/ifont.woff | Bin 18512 -> 18720 bytes 11 files changed, 37 insertions(+), 22 deletions(-) diff --git a/application/fonts/fontello-ifont/config.json b/application/fonts/fontello-ifont/config.json index 83a7a4e1f..0a92f9db4 100644 --- a/application/fonts/fontello-ifont/config.json +++ b/application/fonts/fontello-ifont/config.json @@ -540,6 +540,12 @@ "code": 59414, "src": "fontawesome" }, + { + "uid": "130380e481a7defc690dfb24123a1f0c", + "css": "circle", + "code": 59516, + "src": "fontawesome" + }, { "uid": "266d5d9adf15a61800477a5acf9a4462", "css": "chart-bar", diff --git a/application/fonts/fontello-ifont/css/ifont-codes.css b/application/fonts/fontello-ifont/css/ifont-codes.css index c63f3d67b..bad7cc794 100644 --- a/application/fonts/fontello-ifont/css/ifont-codes.css +++ b/application/fonts/fontello-ifont/css/ifont-codes.css @@ -120,4 +120,5 @@ .icon-left-small:before { content: '\e876'; } /* '' */ .icon-right-small:before { content: '\e877'; } /* '' */ .icon-up-small:before { content: '\e878'; } /* '' */ -.icon-pin:before { content: '\e879'; } /* '' */ \ No newline at end of file +.icon-pin:before { content: '\e879'; } /* '' */ +.icon-circle:before { content: '\e87c'; } /* '' */ \ No newline at end of file diff --git a/application/fonts/fontello-ifont/css/ifont-embedded.css b/application/fonts/fontello-ifont/css/ifont-embedded.css index be3bd9f5f..85789ebf4 100644 --- a/application/fonts/fontello-ifont/css/ifont-embedded.css +++ b/application/fonts/fontello-ifont/css/ifont-embedded.css @@ -1,15 +1,15 @@ @font-face { font-family: 'ifont'; - src: url('../font/ifont.eot?94758086'); - src: url('../font/ifont.eot?94758086#iefix') format('embedded-opentype'), - url('../font/ifont.svg?94758086#ifont') format('svg'); + src: url('../font/ifont.eot?37366472'); + src: url('../font/ifont.eot?37366472#iefix') format('embedded-opentype'), + url('../font/ifont.svg?37366472#ifont') format('svg'); font-weight: normal; font-style: normal; } @font-face { font-family: 'ifont'; - src: url('data:application/octet-stream;base64,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') format('woff'), - url('data:application/octet-stream;base64,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') format('truetype'); + src: url('data:application/octet-stream;base64,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') format('woff'), + url('data:application/octet-stream;base64,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') format('truetype'); } /* Chrome hack: SVG is rendered more smooth in Windozze. 100% magic, uncomment if you need it. */ /* Note, that will break hinting! In other OS-es font will be not as sharp as it could be */ @@ -17,7 +17,7 @@ @media screen and (-webkit-min-device-pixel-ratio:0) { @font-face { font-family: 'ifont'; - src: url('../font/ifont.svg?94758086#ifont') format('svg'); + src: url('../font/ifont.svg?37366472#ifont') format('svg'); } } */ @@ -173,4 +173,5 @@ .icon-left-small:before { content: '\e876'; } /* '' */ .icon-right-small:before { content: '\e877'; } /* '' */ .icon-up-small:before { content: '\e878'; } /* '' */ -.icon-pin:before { content: '\e879'; } /* '' */ \ No newline at end of file +.icon-pin:before { content: '\e879'; } /* '' */ +.icon-circle:before { content: '\e87c'; } /* '' */ \ No newline at end of file diff --git a/application/fonts/fontello-ifont/css/ifont-ie7-codes.css b/application/fonts/fontello-ifont/css/ifont-ie7-codes.css index 133ae3d3d..85c75f62c 100644 --- a/application/fonts/fontello-ifont/css/ifont-ie7-codes.css +++ b/application/fonts/fontello-ifont/css/ifont-ie7-codes.css @@ -120,4 +120,5 @@ .icon-left-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .icon-right-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .icon-up-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } -.icon-pin { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } \ No newline at end of file +.icon-pin { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } +.icon-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } \ No newline at end of file diff --git a/application/fonts/fontello-ifont/css/ifont-ie7.css b/application/fonts/fontello-ifont/css/ifont-ie7.css index 017aa95d9..bc04c804c 100644 --- a/application/fonts/fontello-ifont/css/ifont-ie7.css +++ b/application/fonts/fontello-ifont/css/ifont-ie7.css @@ -131,4 +131,5 @@ .icon-left-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .icon-right-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .icon-up-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } -.icon-pin { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } \ No newline at end of file +.icon-pin { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } +.icon-circle { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } \ No newline at end of file diff --git a/application/fonts/fontello-ifont/css/ifont.css b/application/fonts/fontello-ifont/css/ifont.css index cec41bbe9..b96a6aa02 100644 --- a/application/fonts/fontello-ifont/css/ifont.css +++ b/application/fonts/fontello-ifont/css/ifont.css @@ -1,10 +1,10 @@ @font-face { font-family: 'ifont'; - src: url('../font/ifont.eot?612849'); - src: url('../font/ifont.eot?612849#iefix') format('embedded-opentype'), - url('../font/ifont.woff?612849') format('woff'), - url('../font/ifont.ttf?612849') format('truetype'), - url('../font/ifont.svg?612849#ifont') format('svg'); + src: url('../font/ifont.eot?82929165'); + src: url('../font/ifont.eot?82929165#iefix') format('embedded-opentype'), + url('../font/ifont.woff?82929165') format('woff'), + url('../font/ifont.ttf?82929165') format('truetype'), + url('../font/ifont.svg?82929165#ifont') format('svg'); font-weight: normal; font-style: normal; } @@ -14,7 +14,7 @@ @media screen and (-webkit-min-device-pixel-ratio:0) { @font-face { font-family: 'ifont'; - src: url('../font/ifont.svg?612849#ifont') format('svg'); + src: url('../font/ifont.svg?82929165#ifont') format('svg'); } } */ @@ -175,4 +175,5 @@ .icon-left-small:before { content: '\e876'; } /* '' */ .icon-right-small:before { content: '\e877'; } /* '' */ .icon-up-small:before { content: '\e878'; } /* '' */ -.icon-pin:before { content: '\e879'; } /* '' */ \ No newline at end of file +.icon-pin:before { content: '\e879'; } /* '' */ +.icon-circle:before { content: '\e87c'; } /* '' */ \ No newline at end of file diff --git a/application/fonts/fontello-ifont/demo.html b/application/fonts/fontello-ifont/demo.html index 5dd0dd304..1dab15c02 100644 --- a/application/fonts/fontello-ifont/demo.html +++ b/application/fonts/fontello-ifont/demo.html @@ -229,11 +229,11 @@ body { } @font-face { font-family: 'ifont'; - src: url('./font/ifont.eot?91269362'); - src: url('./font/ifont.eot?91269362#iefix') format('embedded-opentype'), - url('./font/ifont.woff?91269362') format('woff'), - url('./font/ifont.ttf?91269362') format('truetype'), - url('./font/ifont.svg?91269362#ifont') format('svg'); + src: url('./font/ifont.eot?83291894'); + src: url('./font/ifont.eot?83291894#iefix') format('embedded-opentype'), + url('./font/ifont.woff?83291894') format('woff'), + url('./font/ifont.ttf?83291894') format('truetype'), + url('./font/ifont.svg?83291894#ifont') format('svg'); font-weight: normal; font-style: normal; } @@ -483,6 +483,7 @@ body {
icon-up-small0xe878
icon-pin0xe879
+
icon-circle0xe87c
Generated by fontello.com
diff --git a/public/font/ifont.eot b/public/font/ifont.eot index ebb59302202aa7439bda37ccd48f133152432a20..cd0ce4f868f3c2c4df93ad2c86c93976832f7282 100644 GIT binary patch delta 746 zcmYjPUr19?82`R|wtKJV-sWsmQN%w(TqI7o>3lGvAV}(6vPd_t+gx{lF7uXVYwIDw zhXQ3jNAwW%5ELVf2r3W@DTom2C3@%~6A2bkQ25yl)t6Cb24tt z+%<-22!UTDxD!k2!In9(6JUIs$lZ8w#>DS|>D(1OhUwf3Jc8-GLwJ8CE0l_*du)s;P!ArE@3%G8*@T{M z?CZrYPc3@OAiCSIK^s7SquYTVpKu7ZRuo<;n$n_v$Pj3pukluny~@?p>c;bgIQwY( zVFn*Kxuz&op=i8~DyV>;IJaV1E1P8iRw`yme1ybRXaOJa<^3H^P7xRxAc?A)tG}hewaUjF{qIQhAXteg zTQ7{&9{dIh+aLyByE+E{^m~6Or9vrcd(2J(%Pri zsj?Yl@|ylpz)Y?={9VK}UZO?L$XC|MlSYpoP3f`FL|xFbLJ2FHOjH@MGLyF(O#KZS CWzDMq delta 338 zcmbR8k+I_)BO6CK14B;PL^d;)-CqsFCpzTU*D^3LyaD2{X! ztV97Q4g^^xK!Pi+AU(HZ!h}d5zkz{)yC6NWxBw_F0OaQYX^!-q%Cuw8H_J0HFil`! zh&hmvnwY}=b>#vEhWG%WyjccNfFqCP3XtCc-1;@1Eze3O%(oVf4) zbt?vj#2G-rAGwJY1&l_#RSXPCKm!>R@)C1XkBHR$1oAfkEm>KRUtCguG5j$DLuw2I z11oPqQEI{6Z01%5hSCp{TNvFLD<_{}bY!gD%*S*;R+$lK1Q3fGeBB+-Z}XLboB0J$ zgy9muhbV-WeL6WI(VVe*^NhqdjFTrM|6l{DXQ + + + \ No newline at end of file diff --git a/public/font/ifont.ttf b/public/font/ifont.ttf index adf4527fb33e8ea159016c204e697fa5992aa3eb..6fe3bcdfcd41bc2e3255d16be1b868e5bc1e0044 100644 GIT binary patch delta 768 zcmYk4O=uHA6vyA&X?C}>F>OuSQYifhrBO>0UEB0fDF`0?ICv1mDmLAw`D(tFbk*9% zO)mux6(WHiMLYO3MLc-0mVgJVwqhFJS|bj;H#5I^Gyne#Q!3%+ z7t8?yfCFZM!RX0TK6PmCu~{M|iqpZQroXz@vIu}jD2@j&8Xd%`C9K55dL(%@pC6{V z9YE0|+N4gr9w5F+y&Oqg4zKK~^8g5WfDuPDq>W4Eb9DCTOC7=xS;{sQNw5K92J z-9QOBqmQ){g$3=W!+XQK?vr*71GBg=_DMjqV1~Ynn8ho!$q0XCT|6D{4aPFTL}(*y>F zm;)K9i7D(~S1w>+hz|hDn`LCA)+ci0v0MQPbN~fZGIC2QmL&jL4DoA#7QV^JPfpx- z|GE_eL*fje;E&wIiULL>-YN!$B%px|3VDgSsYgWWeggR$fR?N*$S*FbzZm|Qfgv@9 zfq|8`peVKAZZ>l(14HQtp!#YCM&^9R2@I?Z986VAdw?Q66aN`9R!%lxbY!gDT*P=k zRv8o=KrC+Xb$2|!%~u9)<`+N_hD-b&q7Yj4>Et5`=8V;w|0KL&octx}2OBsDt2h5j be$K>LJ^4}Ex6Sv`KQl8iFl_#s&CCM;epYFs diff --git a/public/font/ifont.woff b/public/font/ifont.woff index f6f187cfcac6afda6600072d5c50e80d4446836c..a1ee0870c71872dead6352488b6c55703aa11ff5 100644 GIT binary patch delta 16177 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 NzGymo;<2RV{{czMxAg!3 delta 16042 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 From 8347e126b8acc62df67daf07a54d5202964b76c2 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:05:36 +0200 Subject: [PATCH 17/24] monitoring: Remove next_update_is_late column from the host status query refs #8378 --- .../Backend/Ido/Query/HoststatusQuery.php | 27 +++---------------- 1 file changed, 4 insertions(+), 23 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php index 2cfa6c129..e3e00b1a7 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php @@ -83,32 +83,13 @@ class HoststatusQuery extends IdoQuery ELSE UNIX_TIMESTAMP(hs.last_check) + CASE WHEN - COALESCE(hs.current_state, 0) = 0 + COALESCE(hs.current_state, 0) > 0 AND hs.state_type = 0 THEN - hs.normal_check_interval - ELSE hs.retry_check_interval - END * 60 - + FLOOR(hs.execution_time) * 2 - END', - // TODO(el): Remove column once we support host_next_update>now - 'host_next_update_is_late' => 'CASE WHEN hs.has_been_checked = 0 OR hs.has_been_checked IS NULL - THEN - 0 - ELSE - CASE WHEN (UNIX_TIMESTAMP(hs.last_check) - + CASE WHEN COALESCE(hs.current_state, 0) = 0 - THEN - hs.normal_check_interval - ELSE - hs.retry_check_interval - END * 60 - + FLOOR(hs.execution_time) * 2) > CURRENT_TIMESTAMP() - THEN - 1 ELSE - 0 - END + hs.normal_check_interval + END * 60 + + CEIL(hs.execution_time) * 2 END', 'host_no_more_notifications' => 'hs.no_more_notifications', 'host_normal_check_interval' => 'hs.normal_check_interval', From 30a5f57b7d98c346e00204ca80780e57837d7bea Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:06:02 +0200 Subject: [PATCH 18/24] monitoring: Remove next_update_is_late column from the service status query refs #8378 --- .../Backend/Ido/Query/ServicestatusQuery.php | 27 +++---------------- 1 file changed, 4 insertions(+), 23 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php index 68854ef4e..3a39cdbc3 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php @@ -200,32 +200,13 @@ class ServicestatusQuery extends IdoQuery ELSE UNIX_TIMESTAMP(ss.last_check) + CASE WHEN - COALESCE(ss.current_state, 0) = 0 + COALESCE(ss.current_state, 0) > 0 AND ss.state_type = 0 THEN - ss.normal_check_interval - ELSE ss.retry_check_interval - END * 60 - + FLOOR(ss.execution_time) * 2 - END', - // TODO(el): Remove column once we support service_next_update>now - 'service_next_update_is_late' => 'CASE WHEN ss.has_been_checked = 0 OR ss.has_been_checked IS NULL - THEN - 0 - ELSE - CASE WHEN (UNIX_TIMESTAMP(ss.last_check) - + CASE WHEN COALESCE(ss.current_state, 0) = 0 - THEN - ss.normal_check_interval - ELSE - ss.retry_check_interval - END * 60 - + FLOOR(ss.execution_time) * 2) > CURRENT_TIMESTAMP() - THEN - 1 ELSE - 0 - END + ss.normal_check_interval + END * 60 + + CEIL(ss.execution_time) * 2 END', 'service_no_more_notifications' => 'ss.no_more_notifications', 'service_normal_check_interval' => 'ss.normal_check_interval', From 644148e9ac2975bbb43dc61033e3ad7ad97d780a Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:07:08 +0200 Subject: [PATCH 19/24] monitoring/css: Add atomic definitions for foreground colors according to states refs #8378 --- modules/monitoring/public/css/colors.less | 42 +++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/modules/monitoring/public/css/colors.less b/modules/monitoring/public/css/colors.less index c7e5ef5c6..a8b314426 100644 --- a/modules/monitoring/public/css/colors.less +++ b/modules/monitoring/public/css/colors.less @@ -41,3 +41,45 @@ .bg-state-pending { background-color: @colorPending; } + +.fg-color-ok, +.fg-color-up { + color: @colorOk; +} + +.fg-color-warning { + color: @colorWarning; + + &.handled { + color: @colorWarningHandled; + } +} + +.fg-color-critical, +.fg-color-down { + color: @colorCritical; + + &.handled { + color: @colorCriticalHandled; + } +} + +.fg-color-unreachable { + color: @colorUnreachable; + + &.handled { + color: @colorUnreachableHandled; + } +} + +.fg-color-unknown { + color: @colorUnknown; + + &.handled { + color: @colorUnknownHandled; + } +} + +.fg-color-pending { + color: @colorPending; +} From e155e1514a361b2f58ac2e690ca4fb36b79eeb42 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:07:55 +0200 Subject: [PATCH 20/24] monitoring/css: Rename prefix for background colors from bg-state to bg-color --- .../views/scripts/list/servicegrid.phtml | 2 +- modules/monitoring/public/css/colors.less | 16 ++++++++-------- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/modules/monitoring/application/views/scripts/list/servicegrid.phtml b/modules/monitoring/application/views/scripts/list/servicegrid.phtml index 3c9078683..e458f230c 100644 --- a/modules/monitoring/application/views/scripts/list/servicegrid.phtml +++ b/modules/monitoring/application/views/scripts/list/servicegrid.phtml @@ -77,7 +77,7 @@ $hostFilter = '(host_name=' . implode('|host_name=', array_keys($pivotData)) . ' ), array( 'aria-describedby' => $ariaDescribedById, - 'class' => 'bg-state-' . Service::getStateText($service->service_state) . ($service->service_handled ? ' handled' : ''), + 'class' => 'bg-color-' . Service::getStateText($service->service_state) . ($service->service_handled ? ' handled' : ''), 'title' => $this->escape($service->service_output), 'aria-label' => sprintf( $this->translate('Show detailed information for service %s on host %s'), diff --git a/modules/monitoring/public/css/colors.less b/modules/monitoring/public/css/colors.less index a8b314426..7b931d166 100644 --- a/modules/monitoring/public/css/colors.less +++ b/modules/monitoring/public/css/colors.less @@ -1,11 +1,11 @@ /*! Icinga Web 2 | (c) 2013-2015 Icinga Development Team | GPLv2+ */ -.bg-state-ok, -.bg-state-up { +.bg-color-ok, +.bg-color-up { background-color: @colorOk; } -.bg-state-warning { +.bg-color-warning { background-color: @colorWarning; &.handled { @@ -13,8 +13,8 @@ } } -.bg-state-critical, -.bg-state-down { +.bg-color-critical, +.bg-color-down { background-color: @colorCritical; &.handled { @@ -22,7 +22,7 @@ } } -.bg-state-unreachable { +.bg-color-unreachable { background-color: @colorUnreachable; &.handled { @@ -30,7 +30,7 @@ } } -.bg-state-unknown { +.bg-color-unknown { background-color: @colorUnknown; &.handled { @@ -38,7 +38,7 @@ } } -.bg-state-pending { +.bg-color-pending { background-color: @colorPending; } From d21f635819b750c3f513b5f3650370b4c3cb86e7 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:08:37 +0200 Subject: [PATCH 21/24] monitoring/detail: Show an icon if the check result is late refs #8378 --- .../scripts/show/components/checkstatistics.phtml | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml index b69e0af0f..ee4c6bc1d 100644 --- a/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checkstatistics.phtml @@ -6,12 +6,15 @@ $activeChecksEnabled = (bool) $object->active_checks_enabled; translate('Last check') : $this->translate('Last update') ?> - - state !== 99) { - echo $this->timeAgo($object->last_check); - } ?> + + state !== 99) { + echo $this->timeAgo($object->last_check); + } ?> + next_update < time()) { + echo $this->icon('circle', $this->translate('Check result is late'), array('class' => 'fg-color-critical')); + } ?> From 9667445e4730231027aae31a9bda591af3e5eca1 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:11:07 +0200 Subject: [PATCH 22/24] monitoring/dashboard: Add late host and service check results dashlets to the Overdue dashboard refs #8378 --- modules/monitoring/configuration.php | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/modules/monitoring/configuration.php b/modules/monitoring/configuration.php index 2d61274ec..b9b8118a8 100644 --- a/modules/monitoring/configuration.php +++ b/modules/monitoring/configuration.php @@ -264,6 +264,14 @@ $dashboard->add( * Most Overdue */ $dashboard = $this->dashboard($this->translate('Overdue')); +$dashboard->add( + $this->translate('Late Host Check Results'), + 'monitoring/list/hosts?host_next_updateadd( + $this->translate('Late Service Check Results'), + 'monitoring/list/services?service_next_updateadd( $this->translate('Acknowledgements Active For At Least Three Days'), 'monitoring/list/comments?comment_type=Ack&comment_timestamp<-3 days&sort=comment_timestamp&dir=asc' From a569b1915394410e4bb9c515cb2d4f1d927e3a6f Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:12:25 +0200 Subject: [PATCH 23/24] monitoring: Increase time before a check result is marked as late refs #8378 --- .../library/Monitoring/Backend/Ido/Query/HoststatusQuery.php | 4 ++-- .../Monitoring/Backend/Ido/Query/ServicestatusQuery.php | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php index e3e00b1a7..307140b7a 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/HoststatusQuery.php @@ -88,8 +88,8 @@ class HoststatusQuery extends IdoQuery hs.retry_check_interval ELSE hs.normal_check_interval - END * 60 - + CEIL(hs.execution_time) * 2 + END * 60 * 2 + + CEIL(hs.execution_time) END', 'host_no_more_notifications' => 'hs.no_more_notifications', 'host_normal_check_interval' => 'hs.normal_check_interval', diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php index 3a39cdbc3..7e573fde0 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/ServicestatusQuery.php @@ -205,8 +205,8 @@ class ServicestatusQuery extends IdoQuery ss.retry_check_interval ELSE ss.normal_check_interval - END * 60 - + CEIL(ss.execution_time) * 2 + END * 60 * 2 + + CEIL(ss.execution_time) END', 'service_no_more_notifications' => 'ss.no_more_notifications', 'service_normal_check_interval' => 'ss.normal_check_interval', From d7aca56c4398ccda3dac53e154e37e8a86246866 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Mon, 7 Sep 2015 11:28:15 +0200 Subject: [PATCH 24/24] monitoring/detail: Use an icon for displaying reachability --- .../views/scripts/show/components/checksource.phtml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/modules/monitoring/application/views/scripts/show/components/checksource.phtml b/modules/monitoring/application/views/scripts/show/components/checksource.phtml index 07e63e835..bc90581d1 100644 --- a/modules/monitoring/application/views/scripts/show/components/checksource.phtml +++ b/modules/monitoring/application/views/scripts/show/components/checksource.phtml @@ -14,7 +14,11 @@ translate('Reachable') ?> - is_reachable ? $this->translate('Yes') : $this->translate('No') ?> + is_reachable) { + echo $this->icon('circle', $this->translate('Is reachable'), array('class' => 'fg-color-ok')); + } else { + echo $this->icon('circle', $this->translate('Not reachable'), array('class' => 'fg-color-critical')); + } ?>