From e5c9eb1d2067949484f9b0342f274a5ac80fa9ba Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 10:52:05 +0200 Subject: [PATCH 01/16] monitoring: Don't show ack comments in the comments area of a host or service refs #9674 --- .../monitoring/library/Monitoring/Object/MonitoredObject.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php index 502a1a2d1..83b893192 100644 --- a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php +++ b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php @@ -252,7 +252,7 @@ abstract class MonitoredObject implements Filterable 'comment' => 'comment_data', 'type' => 'comment_type', )) - ->where('comment_type', array('comment', 'ack')) + ->where('comment_type', array('comment')) ->where('object_type', $this->type); if ($this->type === self::TYPE_SERVICE) { $comments From 4d2675659cf1dafbef65bfb8ee63e52fa45aaf0b Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 13:47:51 +0200 Subject: [PATCH 02/16] monitoring: Optimize imports in MonitoredObject --- .../monitoring/library/Monitoring/Object/MonitoredObject.php | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php index 83b893192..4d9d675c2 100644 --- a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php +++ b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php @@ -5,9 +5,9 @@ namespace Icinga\Module\Monitoring\Object; use InvalidArgumentException; use Icinga\Application\Config; -use Icinga\Exception\InvalidPropertyException; use Icinga\Data\Filter\Filter; use Icinga\Data\Filterable; +use Icinga\Exception\InvalidPropertyException; use Icinga\Module\Monitoring\Backend\MonitoringBackend; use Icinga\Web\UrlParams; @@ -517,9 +517,11 @@ abstract class MonitoredObject implements Filterable ->fetchContactgroups() ->fetchCustomvars() ->fetchDowntimes(); + // Call fetchHostgroups or fetchServicegroups depending on the object's type $fetchGroups = 'fetch' . ucfirst($this->type) . 'groups'; $this->$fetchGroups(); + return $this; } From dc5e86002b373088fc9c4f8ef850913b786ca791 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 14:07:38 +0200 Subject: [PATCH 03/16] monitoring: Reorder code in MonitoredObject --- .../Monitoring/Object/MonitoredObject.php | 591 +++++++++--------- 1 file changed, 304 insertions(+), 287 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php index 4d9d675c2..469b988dc 100644 --- a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php +++ b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php @@ -34,11 +34,60 @@ abstract class MonitoredObject implements Filterable protected $backend; /** - * Type of the Icinga object, i.e. 'host' or 'service' + * Comments * - * @var string + * @var array */ - protected $type; + protected $comments; + + /** + * Custom variables + * + * @var array + */ + protected $customvars; + + /** + * Contact groups + * + * @var array + */ + protected $contactgroups; + + /** + * Contacts + * + * @var array + */ + protected $contacts; + + /** + * Downtimes + * + * @var array + */ + protected $downtimes; + + /** + * Event history + * + * @var \Icinga\Module\Monitoring\DataView\EventHistory + */ + protected $eventhistory; + + /** + * Filter + * + * @var Filter + */ + protected $filter; + + /** + * Host groups + * + * @var array + */ + protected $hostgroups; /** * Prefix of the Icinga object, i.e. 'host_' or 'service_' @@ -54,27 +103,6 @@ abstract class MonitoredObject implements Filterable */ protected $properties; - /** - * Comments - * - * @var array - */ - protected $comments; - - /** - * Downtimes - * - * @var array - */ - protected $downtimes; - - /** - * Host groups - * - * @var array - */ - protected $hostgroups; - /** * Service groups * @@ -83,32 +111,11 @@ abstract class MonitoredObject implements Filterable protected $servicegroups; /** - * Contacts + * Type of the Icinga object, i.e. 'host' or 'service' * - * @var array + * @var string */ - protected $contacts; - - /** - * Contact groups - * - * @var array - */ - protected $contactgroups; - - /** - * Custom variables - * - * @var array - */ - protected $customvars; - - /** - * Event history - * - * @var \Icinga\Module\Monitoring\DataView\EventHistory - */ - protected $eventhistory; + protected $type; /** * Stats @@ -117,13 +124,6 @@ abstract class MonitoredObject implements Filterable */ protected $stats; - /** - * Filter - * - * @var Filter - */ - protected $filter; - /** * Create a monitored object, i.e. host or service * @@ -141,35 +141,82 @@ abstract class MonitoredObject implements Filterable */ abstract protected function getDataView(); - public function applyFilter(Filter $filter) - { - $this->getFilter()->addFilter($filter); - return $this; - } + /** + * Get the notes for this monitored object + * + * @return string The notes as a string + */ + public abstract function getNotes(); - public function setFilter(Filter $filter) - { - // Left out on purpose. Interface is deprecated. - } - - public function getFilter() - { - if ($this->filter === null) { - $this->filter = Filter::matchAll(); - } - return $this->filter; - } + /** + * Get all note urls configured for this monitored object + * + * @return array All note urls as a string + */ + public abstract function getNotesUrls(); + /** + * {@inheritdoc} + */ public function addFilter(Filter $filter) { // Left out on purpose. Interface is deprecated. } + /** + * {@inheritdoc} + */ + public function applyFilter(Filter $filter) + { + $this->getFilter()->addFilter($filter); + + return $this; + } + + /** + * {@inheritdoc} + */ + public function getFilter() + { + if ($this->filter === null) { + $this->filter = Filter::matchAll(); + } + + return $this->filter; + } + + /** + * {@inheritdoc} + */ + public function setFilter(Filter $filter) + { + // Left out on purpose. Interface is deprecated. + } + + /** + * {@inheritdoc} + */ public function where($condition, $value = null) { // Left out on purpose. Interface is deprecated. } + /** + * Require the object's type to be one of the given types + * + * @param array $oneOf + * + * @return bool + * @throws InvalidArgumentException If the object's type is not one of the given types. + */ + public function assertOneOf(array $oneOf) + { + if (! in_array($this->type, $oneOf)) { + throw new InvalidArgumentException; + } + return true; + } + /** * Fetch the object's properties * @@ -195,45 +242,6 @@ abstract class MonitoredObject implements Filterable return true; } - /** - * Get the type of the object - * - * @return string - */ - public function getType() - { - return $this->type; - } - - /** - * Require the object's type to be one of the given types - * - * @param array $oneOf - * - * @return bool - * @throws InvalidArgumentException If the object's type is not one of the given types. - */ - public function assertOneOf(array $oneOf) - { - if (! in_array($this->type, $oneOf)) { - throw new InvalidArgumentException; - } - return true; - } - - /** - * Set the object's properties - * - * @param object $properties - * - * @return $this - */ - public function setProperties($properties) - { - $this->properties = (object) $properties; - return $this; - } - /** * Fetch the object's comments * @@ -266,54 +274,58 @@ abstract class MonitoredObject implements Filterable } /** - * Fetch the object's downtimes + * Fetch the object's contact groups * * @return $this */ - public function fetchDowntimes() + public function fetchContactgroups() { - $downtimes = $this->backend->select()->from('downtime', array( - 'id' => 'downtime_internal_id', - 'objecttype' => 'object_type', - 'comment' => 'downtime_comment', - 'author_name' => 'downtime_author_name', - 'start' => 'downtime_start', - 'scheduled_start' => 'downtime_scheduled_start', - 'scheduled_end' => 'downtime_scheduled_end', - 'end' => 'downtime_end', - 'duration' => 'downtime_duration', - 'is_flexible' => 'downtime_is_flexible', - 'is_fixed' => 'downtime_is_fixed', - 'is_in_effect' => 'downtime_is_in_effect', - 'entry_time' => 'downtime_entry_time' - )) - ->where('object_type', $this->type) - ->order('downtime_is_in_effect', 'DESC') - ->order('downtime_scheduled_start', 'ASC'); + if ($this->backend->is('livestatus')) { + $this->contactgroups = array(); + return $this; + } + + $contactsGroups = $this->backend->select()->from('contactgroup', array( + 'contactgroup_name', + 'contactgroup_alias' + )); if ($this->type === self::TYPE_SERVICE) { - $downtimes + $contactsGroups ->where('service_host_name', $this->host_name) ->where('service_description', $this->service_description); } else { - $downtimes - ->where('host_name', $this->host_name); + $contactsGroups->where('host_name', $this->host_name); } - $this->downtimes = $downtimes->getQuery()->fetchAll(); + $this->contactgroups = $contactsGroups->applyFilter($this->getFilter())->getQuery()->fetchAll(); return $this; } /** - * Fetch the object's host groups + * Fetch the object's contacts * * @return $this */ - public function fetchHostgroups() + public function fetchContacts() { - $this->hostgroups = $this->backend->select() - ->from('hostgroup', array('hostgroup_name', 'hostgroup_alias')) - ->where('host_name', $this->host_name) - ->applyFilter($this->getFilter()) - ->fetchPairs(); + if ($this->backend->is('livestatus')) { + $this->contacts = array(); + return $this; + } + + $contacts = $this->backend->select()->from('contact', array( + 'contact_name', + 'contact_alias', + 'contact_email', + 'contact_pager', + )); + if ($this->type === self::TYPE_SERVICE) { + $contacts + ->where('service_host_name', $this->host_name) + ->where('service_description', $this->service_description); + } else { + $contacts->where('host_name', $this->host_name); + } + $this->contacts = $contacts->applyFilter($this->getFilter())->getQuery()->fetchAll(); return $this; } @@ -372,74 +384,39 @@ abstract class MonitoredObject implements Filterable } /** - * Fetch the object's contacts + * Fetch the object's downtimes * * @return $this */ - public function fetchContacts() + public function fetchDowntimes() { - if ($this->backend->is('livestatus')) { - $this->contacts = array(); - return $this; - } - - $contacts = $this->backend->select()->from('contact', array( - 'contact_name', - 'contact_alias', - 'contact_email', - 'contact_pager', - )); + $downtimes = $this->backend->select()->from('downtime', array( + 'id' => 'downtime_internal_id', + 'objecttype' => 'object_type', + 'comment' => 'downtime_comment', + 'author_name' => 'downtime_author_name', + 'start' => 'downtime_start', + 'scheduled_start' => 'downtime_scheduled_start', + 'scheduled_end' => 'downtime_scheduled_end', + 'end' => 'downtime_end', + 'duration' => 'downtime_duration', + 'is_flexible' => 'downtime_is_flexible', + 'is_fixed' => 'downtime_is_fixed', + 'is_in_effect' => 'downtime_is_in_effect', + 'entry_time' => 'downtime_entry_time' + )) + ->where('object_type', $this->type) + ->order('downtime_is_in_effect', 'DESC') + ->order('downtime_scheduled_start', 'ASC'); if ($this->type === self::TYPE_SERVICE) { - $contacts + $downtimes ->where('service_host_name', $this->host_name) ->where('service_description', $this->service_description); } else { - $contacts->where('host_name', $this->host_name); + $downtimes + ->where('host_name', $this->host_name); } - $this->contacts = $contacts->applyFilter($this->getFilter())->getQuery()->fetchAll(); - return $this; - } - - /** - * Fetch the object's service groups - * - * @return $this - */ - public function fetchServicegroups() - { - $this->servicegroups = $this->backend->select() - ->from('servicegroup', array('servicegroup_name', 'servicegroup_alias')) - ->where('host_name', $this->host_name) - ->where('service_description', $this->service_description) - ->applyFilter($this->getFilter()) - ->fetchPairs(); - return $this; - } - - /** - * Fetch the object's contact groups - * - * @return $this - */ - public function fetchContactgroups() - { - if ($this->backend->is('livestatus')) { - $this->contactgroups = array(); - return $this; - } - - $contactsGroups = $this->backend->select()->from('contactgroup', array( - 'contactgroup_name', - 'contactgroup_alias' - )); - if ($this->type === self::TYPE_SERVICE) { - $contactsGroups - ->where('service_host_name', $this->host_name) - ->where('service_description', $this->service_description); - } else { - $contactsGroups->where('host_name', $this->host_name); - } - $this->contactgroups = $contactsGroups->applyFilter($this->getFilter())->getQuery()->fetchAll(); + $this->downtimes = $downtimes->getQuery()->fetchAll(); return $this; } @@ -477,6 +454,37 @@ abstract class MonitoredObject implements Filterable return $this; } + /** + * Fetch the object's host groups + * + * @return $this + */ + public function fetchHostgroups() + { + $this->hostgroups = $this->backend->select() + ->from('hostgroup', array('hostgroup_name', 'hostgroup_alias')) + ->where('host_name', $this->host_name) + ->applyFilter($this->getFilter()) + ->fetchPairs(); + return $this; + } + + /** + * Fetch the object's service groups + * + * @return $this + */ + public function fetchServicegroups() + { + $this->servicegroups = $this->backend->select() + ->from('servicegroup', array('servicegroup_name', 'servicegroup_alias')) + ->where('host_name', $this->host_name) + ->where('service_description', $this->service_description) + ->applyFilter($this->getFilter()) + ->fetchPairs(); + return $this; + } + /** * Fetch stats * @@ -504,84 +512,6 @@ abstract class MonitoredObject implements Filterable return $this; } - /** - * Fetch all available data of the object - * - * @return $this - */ - public function populate() - { - $this - ->fetchComments() - ->fetchContacts() - ->fetchContactgroups() - ->fetchCustomvars() - ->fetchDowntimes(); - - // Call fetchHostgroups or fetchServicegroups depending on the object's type - $fetchGroups = 'fetch' . ucfirst($this->type) . 'groups'; - $this->$fetchGroups(); - - return $this; - } - - public function __get($name) - { - if (property_exists($this->properties, $name)) { - return $this->properties->$name; - } elseif (property_exists($this, $name) && $this->$name !== null) { - return $this->$name; - } elseif (property_exists($this, $name)) { - $fetchMethod = 'fetch' . ucfirst($name); - $this->$fetchMethod(); - return $this->$name; - } - if (substr($name, 0, strlen($this->prefix)) !== $this->prefix) { - $prefixedName = $this->prefix . strtolower($name); - if (property_exists($this->properties, $prefixedName)) { - return $this->properties->$prefixedName; - } - } - throw new InvalidPropertyException('Can\'t access property \'%s\'. Property does not exist.', $name); - } - - public function __isset($name) - { - if (property_exists($this->properties, $name)) { - return isset($this->properties->$name); - } elseif (property_exists($this, $name)) { - return isset($this->$name); - } - return false; - } - - /** - * @deprecated - */ - public static function fromParams(UrlParams $params) - { - if ($params->has('service') && $params->has('host')) { - return new Service(MonitoringBackend::instance(), $params->get('host'), $params->get('service')); - } elseif ($params->has('host')) { - return new Host(MonitoringBackend::instance(), $params->get('host')); - } - return null; - } - - /** - * The notes for this monitored object - * - * @return string The notes as a string - */ - public abstract function getNotes(); - - /** - * Get all note urls configured for this monitored object - * - * @return array All note urls as a string - */ - public abstract function getNotesUrls(); - /** * Get all action urls configured for this monitored object * @@ -595,17 +525,13 @@ abstract class MonitoredObject implements Filterable } /** - * Resolve macros in all given strings in the current object context + * Get the type of the object * - * @param array $strs An array of urls as string - * @return type + * @return string */ - protected function resolveAllStrings(array $strs) + public function getType() { - foreach ($strs as $i => $str) { - $strs[$i] = Macro::resolveMacros($str, $this); - } - return $strs; + return $this->type; } /** @@ -636,4 +562,95 @@ abstract class MonitoredObject implements Filterable } return $links; } + + /** + * Fetch all available data of the object + * + * @return $this + */ + public function populate() + { + $this + ->fetchComments() + ->fetchContacts() + ->fetchContactgroups() + ->fetchCustomvars() + ->fetchDowntimes(); + + // Call fetchHostgroups or fetchServicegroups depending on the object's type + $fetchGroups = 'fetch' . ucfirst($this->type) . 'groups'; + $this->$fetchGroups(); + + return $this; + } + + /** + * Resolve macros in all given strings in the current object context + * + * @param array $strs An array of urls as string + * @return type + */ + protected function resolveAllStrings(array $strs) + { + foreach ($strs as $i => $str) { + $strs[$i] = Macro::resolveMacros($str, $this); + } + return $strs; + } + + /** + * Set the object's properties + * + * @param object $properties + * + * @return $this + */ + public function setProperties($properties) + { + $this->properties = (object) $properties; + return $this; + } + + public function __isset($name) + { + if (property_exists($this->properties, $name)) { + return isset($this->properties->$name); + } elseif (property_exists($this, $name)) { + return isset($this->$name); + } + return false; + } + + public function __get($name) + { + if (property_exists($this->properties, $name)) { + return $this->properties->$name; + } elseif (property_exists($this, $name) && $this->$name !== null) { + return $this->$name; + } elseif (property_exists($this, $name)) { + $fetchMethod = 'fetch' . ucfirst($name); + $this->$fetchMethod(); + return $this->$name; + } + if (substr($name, 0, strlen($this->prefix)) !== $this->prefix) { + $prefixedName = $this->prefix . strtolower($name); + if (property_exists($this->properties, $prefixedName)) { + return $this->properties->$prefixedName; + } + } + throw new InvalidPropertyException('Can\'t access property \'%s\'. Property does not exist.', $name); + } + + /** + * @deprecated + */ + public static function fromParams(UrlParams $params) + { + if ($params->has('service') && $params->has('host')) { + return new Service(MonitoringBackend::instance(), $params->get('host'), $params->get('service')); + } elseif ($params->has('host')) { + return new Host(MonitoringBackend::instance(), $params->get('host')); + } + return null; + } } From 54a45ff338a1d731a1660bdd3963e25e24500418 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 14:08:43 +0200 Subject: [PATCH 04/16] monitoring: Fix PHPDoc of MonitoredObject::resolveAllStrings() --- .../monitoring/library/Monitoring/Object/MonitoredObject.php | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php index 469b988dc..72511f765 100644 --- a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php +++ b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php @@ -588,7 +588,8 @@ abstract class MonitoredObject implements Filterable * Resolve macros in all given strings in the current object context * * @param array $strs An array of urls as string - * @return type + * + * @return array */ protected function resolveAllStrings(array $strs) { From 6a684a97df07b76b31296cb8c0fc0a388948e1ef Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 14:09:16 +0200 Subject: [PATCH 05/16] monitoring: Fix missing parameter initialization in MonitoredObject::parseAttributeUrls() --- modules/monitoring/library/Monitoring/Object/MonitoredObject.php | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php index 72511f765..1def5b6e7 100644 --- a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php +++ b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php @@ -550,6 +550,7 @@ abstract class MonitoredObject implements Filterable if (empty($urlString)) { return array(); } + $links = array(); if (strpos($urlString, "' ") === false) { $links[] = $urlString; } else { From cf917b59f82a704e004d3635ae021a0004647f52 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 16:20:29 +0200 Subject: [PATCH 06/16] lib: Fix PHPDoc of DbConnection::getDbApdater() --- library/Icinga/Data/Db/DbConnection.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/Icinga/Data/Db/DbConnection.php b/library/Icinga/Data/Db/DbConnection.php index ba7a3c6f0..1e39ebf3f 100644 --- a/library/Icinga/Data/Db/DbConnection.php +++ b/library/Icinga/Data/Db/DbConnection.php @@ -112,7 +112,7 @@ class DbConnection implements Selectable, Extensible, Updatable, Reducible, Insp /** * Getter for the Zend_Db_Adapter * - * @return Zend_Db_Adapter_Abstract + * @return \Zend_Db_Adapter_Abstract */ public function getDbAdapter() { From 620c1fa6e0cbaa6f841cf3650cd0e2536d40cbcc Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 16:21:01 +0200 Subject: [PATCH 07/16] monitoring: Fix alphabetical order of query columns in the CommentQuery --- .../library/Monitoring/Backend/Ido/Query/CommentQuery.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Backend/Ido/Query/CommentQuery.php b/modules/monitoring/library/Monitoring/Backend/Ido/Query/CommentQuery.php index ea2a656fa..337021792 100644 --- a/modules/monitoring/library/Monitoring/Backend/Ido/Query/CommentQuery.php +++ b/modules/monitoring/library/Monitoring/Backend/Ido/Query/CommentQuery.php @@ -25,8 +25,8 @@ class CommentQuery extends IdoQuery 'comment_is_persistent' => 'c.comment_is_persistent', 'comment_timestamp' => 'c.comment_timestamp', 'comment_type' => 'c.comment_type', - 'object_type' => 'c.object_type', - 'instance_name' => 'c.instance_name' + 'instance_name' => 'c.instance_name', + 'object_type' => 'c.object_type' ), 'hosts' => array( 'host_display_name' => 'c.host_display_name', From df72825617bd2c99f919e84bf49345a52fd4ea06 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 16:23:04 +0200 Subject: [PATCH 08/16] monitoring/host: Fetch acknowledgement type refs #9674 --- 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 8a8c032b5..6fe058972 100644 --- a/modules/monitoring/library/Monitoring/Object/Host.php +++ b/modules/monitoring/library/Monitoring/Object/Host.php @@ -93,6 +93,7 @@ class Host extends MonitoredObject 'host_icon_image', 'host_icon_image_alt', 'host_acknowledged', + 'host_acknowledgement_type', 'host_action_url', 'host_active_checks_enabled', 'host_active_checks_enabled_changed', From a14b1ce8f7539bff38f436af8cb87bc5e9588575 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 16:23:27 +0200 Subject: [PATCH 09/16] monitoring/service: Fetch acknowledgement type refs #9674 --- 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 72341306f..72cd1c1db 100644 --- a/modules/monitoring/library/Monitoring/Object/Service.php +++ b/modules/monitoring/library/Monitoring/Object/Service.php @@ -124,6 +124,7 @@ class Service extends MonitoredObject 'service_icon_image', 'service_icon_image_alt', 'service_acknowledged', + 'service_acknowledgement_type', 'service_action_url', 'service_active_checks_enabled', 'service_active_checks_enabled_changed', From 8a1592fd126d25c6c8c501c09d1825a60ad42a82 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 16:27:50 +0200 Subject: [PATCH 10/16] monitoring/lib: Add Acknowledgement object refs #9674 --- .../Monitoring/Object/Acknowledgement.php | 215 ++++++++++++++++++ 1 file changed, 215 insertions(+) create mode 100644 modules/monitoring/library/Monitoring/Object/Acknowledgement.php diff --git a/modules/monitoring/library/Monitoring/Object/Acknowledgement.php b/modules/monitoring/library/Monitoring/Object/Acknowledgement.php new file mode 100644 index 000000000..de405823b --- /dev/null +++ b/modules/monitoring/library/Monitoring/Object/Acknowledgement.php @@ -0,0 +1,215 @@ +setProperties($properties); + } + } + + /** + * Get the author of the acknowledgement + * + * @return string + */ + public function getAuthor() + { + return $this->author; + } + + /** + * Set the author of the acknowledgement + * + * @param string $author + * + * @return $this + */ + public function setAuthor($author) + { + $this->author = (string) $author; + return $this; + } + + /** + * Get the comment of the acknowledgement + * + * @return string + */ + public function getComment() + { + return $this->comment; + } + + /** + * Set the comment of the acknowledgement + * + * @param string $comment + * + * @return $this + */ + public function setComment($comment) + { + $this->comment = (string) $comment; + + return $this; + } + + /** + * Get the entry time of the acknowledgement + * + * @return int + */ + public function getEntryTime() + { + return $this->entryTime; + } + + /** + * Set the entry time of the acknowledgement + * + * @param int $entryTime + * + * @return $this + */ + public function setEntryTime($entryTime) + { + $this->entryTime = (int) $entryTime; + + return $this; + } + + /** + * Get the expiration time of the acknowledgement + * + * @return int|null + */ + public function getExpirationTime() + { + return $this->expirationTime; + } + + /** + * Set the expiration time of the acknowledgement + * + * @param int|null $expirationTime Unix timestamp + * + * @return $this + */ + public function setExpirationTime($expirationTime = null) + { + $this->expirationTime = $expirationTime !== null ? (int) $expirationTime : null; + + return $this; + } + + /** + * Get whether the acknowledgement is sticky + * + * @return bool + */ + public function getSticky() + { + return $this->sticky; + } + + /** + * Set whether the acknowledgement is sticky + * + * @param bool $sticky + * + * @return $this + */ + public function setSticky($sticky = true) + { + $this->sticky = (bool) $sticky; + return $this; + } + + /** + * Get whether the acknowledgement expires + * + * @return bool + */ + public function expires() + { + return $this->expirationTime !== null; + } + + /** + * Set the properties of the acknowledgement + * + * @param array|object|Traversable $properties + * + * @return $this + * @throws InvalidArgumentException If the type of the given properties is invalid + */ + public function setProperties($properties) + { + if (! is_array($properties) && ! is_object($properties) && ! $properties instanceof Traversable) { + throw new InvalidArgumentException('Properties must be either an array or an instance of Traversable'); + } + foreach ($properties as $name => $value) { + $setter = 'set' . ucfirst(String::cname($name)); + if (method_exists($this, $setter)) { + $this->$setter($value); + } + } + return $this; + } +} From f0e8340fbdbbeb0d9e95875a3f23a48717a8fbc1 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 16:38:46 +0200 Subject: [PATCH 11/16] monitoring/detail: Don't display the comment of the active acknowledgement in the comment list refs #9674 --- .../Monitoring/Object/MonitoredObject.php | 87 +++++++++++++++---- 1 file changed, 70 insertions(+), 17 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php index 1def5b6e7..1bd8431a2 100644 --- a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php +++ b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php @@ -26,6 +26,13 @@ abstract class MonitoredObject implements Filterable */ const TYPE_SERVICE = 'service'; + /** + * Acknowledgement of the host or service if any + * + * @var object + */ + protected $acknowledgement; + /** * Backend to fetch object information from * @@ -224,13 +231,15 @@ abstract class MonitoredObject implements Filterable */ public function fetch() { - $this->properties = $this->getDataView()->applyFilter($this->getFilter())->getQuery()->fetchRow(); - if ($this->properties === false) { + $properties = $this->getDataView()->applyFilter($this->getFilter())->getQuery()->fetchRow(); + + if ($properties === false) { return false; } - if (isset($this->properties->host_contacts)) { + + if (isset($properties->host_contacts)) { $this->contacts = array(); - foreach (preg_split('~,~', $this->properties->host_contacts) as $contact) { + foreach (preg_split('~,~', $properties->host_contacts) as $contact) { $this->contacts[] = (object) array( 'contact_name' => $contact, 'contact_alias' => $contact, @@ -239,9 +248,24 @@ abstract class MonitoredObject implements Filterable ); } } + + $this->properties = $properties; + return true; } + /** + * Fetch the object's acknowledgement + */ + public function fetchAcknowledgement() + { + if ($this->comments === null) { + $this->fetchComments(); + } + + return $this; + } + /** * Fetch the object's comments * @@ -253,23 +277,52 @@ abstract class MonitoredObject implements Filterable $this->comments = array(); return $this; } - $comments = $this->backend->select()->from('comment', array( - 'id' => 'comment_internal_id', - 'timestamp' => 'comment_timestamp', - 'author' => 'comment_author_name', - 'comment' => 'comment_data', - 'type' => 'comment_type', - )) - ->where('comment_type', array('comment')) - ->where('object_type', $this->type); + + $commentsView = $this->backend->select()->from('comment', array( + 'author' => 'comment_author_name', + 'comment' => 'comment_data', + 'expiration' => 'comment_expiration', + 'id' => 'comment_internal_id', + 'timestamp' => 'comment_timestamp', + 'type' => 'comment_type' + )); if ($this->type === self::TYPE_SERVICE) { - $comments + $commentsView ->where('service_host_name', $this->host_name) ->where('service_description', $this->service_description); } else { - $comments->where('host_name', $this->host_name); + $commentsView->where('host_name', $this->host_name); } - $this->comments = $comments->getQuery()->fetchAll(); + $commentsView + ->where('comment_type', array('ack', 'comment')) + ->where('object_type', $this->type); + + $comments = $commentsView->fetchAll(); + + if ((bool) $this->properties->{$this->prefix . 'acknowledged'}) { + $ackCommentIdx = null; + + foreach ($comments as $i => $comment) { + if ($comment->type === 'ack') { + $this->acknowledgement = new Acknowledgement(array( + 'author' => $comment->author, + 'comment' => $comment->comment, + 'entry_time' => $comment->timestamp, + 'expiration_time' => $comment->expiration, + 'sticky' => (int) $this->properties->{$this->prefix . 'acknowledgement_type'} === 2 + )); + $ackCommentIdx = $i; + break; + } + } + + if ($ackCommentIdx !== null) { + unset($comments[$ackCommentIdx]); + } + } + + $this->comments = $comments; + return $this; } @@ -573,8 +626,8 @@ abstract class MonitoredObject implements Filterable { $this ->fetchComments() - ->fetchContacts() ->fetchContactgroups() + ->fetchContacts() ->fetchCustomvars() ->fetchDowntimes(); From 2da49ad697a7d45a2d06b98481b4b08fe8630f42 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Thu, 3 Sep 2015 16:39:56 +0200 Subject: [PATCH 12/16] monitoring/detail: Display the comment of the ack next to the ack refs #9674 --- .../show/components/acknowledgement.phtml | 28 +++++++++++++++---- 1 file changed, 23 insertions(+), 5 deletions(-) diff --git a/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml b/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml index e7b79354d..0743b6103 100644 --- a/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml +++ b/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml @@ -8,14 +8,32 @@ if (in_array((int) $object->state, array(0, 99))) { } if ($object->acknowledged): ?> + acknowledgement; + /** @var \Icinga\Module\Monitoring\Object\Acknowledgement $acknowledgement */ + ?> translate('Acknowledged') ?> - +
    +
  • +

    + translate('%s acknowledged %s'), + '' . $this->escape($acknowledgement->getAuthor()) . '', + $this->timeAgo($acknowledgement->getEntryTime()) + ) ?> + +

    +

    + (translate('Comment') ?>): + createTicketLinks($acknowledgement->getComment()), false) ?> +

    +
    • +
From 331c01c371112388e3a3e1f874a662594cff27a4 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 12:13:43 +0200 Subject: [PATCH 13/16] fontello: Add icon-pin for sticky acknowledgements refs #9674 --- 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 29952 -> 30472 bytes public/font/ifont.svg | 7 ++++++- public/font/ifont.ttf | Bin 29796 -> 30316 bytes public/font/ifont.woff | Bin 18220 -> 18512 bytes 11 files changed, 40 insertions(+), 23 deletions(-) diff --git a/application/fonts/fontello-ifont/config.json b/application/fonts/fontello-ifont/config.json index 3a7894589..83a7a4e1f 100644 --- a/application/fonts/fontello-ifont/config.json +++ b/application/fonts/fontello-ifont/config.json @@ -672,6 +672,12 @@ "code": 59492, "src": "entypo" }, + { + "uid": "p57wgnf4glngbchbucdi029iptu8oxb8", + "css": "pin", + "code": 59513, + "src": "typicons" + }, { "uid": "c16a63e911bc47b46dc2a7129d2f0c46", "css": "down-small", diff --git a/application/fonts/fontello-ifont/css/ifont-codes.css b/application/fonts/fontello-ifont/css/ifont-codes.css index 78c477ddb..c63f3d67b 100644 --- a/application/fonts/fontello-ifont/css/ifont-codes.css +++ b/application/fonts/fontello-ifont/css/ifont-codes.css @@ -119,4 +119,5 @@ .icon-down-small:before { content: '\e875'; } /* '' */ .icon-left-small:before { content: '\e876'; } /* '' */ .icon-right-small:before { content: '\e877'; } /* '' */ -.icon-up-small:before { content: '\e878'; } /* '' */ \ No newline at end of file +.icon-up-small:before { content: '\e878'; } /* '' */ +.icon-pin:before { content: '\e879'; } /* '' */ \ 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 c069e28e6..be3bd9f5f 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?12843713'); - src: url('../font/ifont.eot?12843713#iefix') format('embedded-opentype'), - url('../font/ifont.svg?12843713#ifont') format('svg'); + src: url('../font/ifont.eot?94758086'); + src: url('../font/ifont.eot?94758086#iefix') format('embedded-opentype'), + url('../font/ifont.svg?94758086#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?12843713#ifont') format('svg'); + src: url('../font/ifont.svg?94758086#ifont') format('svg'); } } */ @@ -172,4 +172,5 @@ .icon-down-small:before { content: '\e875'; } /* '' */ .icon-left-small:before { content: '\e876'; } /* '' */ .icon-right-small:before { content: '\e877'; } /* '' */ -.icon-up-small:before { content: '\e878'; } /* '' */ \ No newline at end of file +.icon-up-small:before { content: '\e878'; } /* '' */ +.icon-pin:before { content: '\e879'; } /* '' */ \ 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 4f30af4af..133ae3d3d 100644 --- a/application/fonts/fontello-ifont/css/ifont-ie7-codes.css +++ b/application/fonts/fontello-ifont/css/ifont-ie7-codes.css @@ -119,4 +119,5 @@ .icon-down-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .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 = ' '); } \ No newline at end of file +.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 diff --git a/application/fonts/fontello-ifont/css/ifont-ie7.css b/application/fonts/fontello-ifont/css/ifont-ie7.css index c0047b50a..017aa95d9 100644 --- a/application/fonts/fontello-ifont/css/ifont-ie7.css +++ b/application/fonts/fontello-ifont/css/ifont-ie7.css @@ -130,4 +130,5 @@ .icon-down-small { *zoom: expression( this.runtimeStyle['zoom'] = '1', this.innerHTML = ' '); } .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 = ' '); } \ No newline at end of file +.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 diff --git a/application/fonts/fontello-ifont/css/ifont.css b/application/fonts/fontello-ifont/css/ifont.css index 971bf44b3..cec41bbe9 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?54745533'); - src: url('../font/ifont.eot?54745533#iefix') format('embedded-opentype'), - url('../font/ifont.woff?54745533') format('woff'), - url('../font/ifont.ttf?54745533') format('truetype'), - url('../font/ifont.svg?54745533#ifont') format('svg'); + 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'); 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?54745533#ifont') format('svg'); + src: url('../font/ifont.svg?612849#ifont') format('svg'); } } */ @@ -174,4 +174,5 @@ .icon-down-small:before { content: '\e875'; } /* '' */ .icon-left-small:before { content: '\e876'; } /* '' */ .icon-right-small:before { content: '\e877'; } /* '' */ -.icon-up-small:before { content: '\e878'; } /* '' */ \ No newline at end of file +.icon-up-small:before { content: '\e878'; } /* '' */ +.icon-pin:before { content: '\e879'; } /* '' */ \ No newline at end of file diff --git a/application/fonts/fontello-ifont/demo.html b/application/fonts/fontello-ifont/demo.html index 5cfd8dbf8..5dd0dd304 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?11424534'); - src: url('./font/ifont.eot?11424534#iefix') format('embedded-opentype'), - url('./font/ifont.woff?11424534') format('woff'), - url('./font/ifont.ttf?11424534') format('truetype'), - url('./font/ifont.svg?11424534#ifont') format('svg'); + 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'); font-weight: normal; font-style: normal; } @@ -482,6 +482,7 @@ body {
icon-up-small0xe878
+
icon-pin0xe879
Generated by fontello.com
diff --git a/public/font/ifont.eot b/public/font/ifont.eot index d249dc858a0a8ca823f797e153d4462539005cfb..ebb59302202aa7439bda37ccd48f133152432a20 100644 GIT binary patch delta 1156 zcmYk4UuauZ9LImZbJN=_U3-(7n{;AtlW5a&b8lACG^t&eZbe4O!w?ITmC+_^(_}M$ zu4~%duDI+$rEDrKdD(-5%?B|cGRVM(G4Y|3J@~MRAd2FHNQVURCE^}T{hc%glY7qj z{X3uYJ->Ue|AAY7qG&AxyXOanu`R{<^( z5IlucKE3O__MH5CbV$u8u9hlK-~0_AeF31W*SL~4etAoH4`A&ts^0_@iq#Kr1~;nT z;%VHd_c3#>0FLSwG1c!K9FV0Rky-V?uv7H; z!;z4yi;N&f6hvnqc8qq4M>;h;<&WY2BD5=rQNADj>Iqeys%YpOjrlFX$XKhSPLDEe zGRQvWsp-*w_ri%VJ?ukuN@G;jx*eO3(SxIjOakNCM0`-?r8~6n3cRee0iv(!#Uv z90|wIU~}zV71~DFLsZqHda%r~2gj`waDTr8pB^v77$vq!O^# zT8|o^4V*pN=ezy({K+E`_Y=AASVf;4b}RN;15ec4UeBxgwE?^Q)Ezl8bH31SEw$G@ z)_kxiO*f%Oc*dLkofMZ3*1_Ma$%QCx)^9D;5T8|Nlfiyw<=yKHvW3}dA^GFT7phhL zJ8&lOSR2q1T2A{!`$?bGZ|L{+pMzpB7)-WL+pMpo_84wf&n`D?SVj{!@G9}A(z`;) pwp=V1^woSSm$T*4E2RUo=gOr_wqsk@jDw(HTq=;ndMnG0{s$MD4afih delta 631 zcmXX?OK1~O6utK)9i!12OB!ov(>SJSOebR*(=n7VCMDEb)P>cemfBA9#U$-uVu%Vx z7r_V$E!pU%fxKLCm*o8ubf*(r3-$Inco8W`{?m6e3doH}v7T)}d99#j2 zWLG#@U#|qUmB3Qr765EgO^4H}_NKV+DFBA3Cd0X`opd^h6kR)FT0C7^UOrDe4`9^d zYDOd7L_9*>5Kmo=-MK&h3Vl(m(jktYLO-F0y8^4Kf(2|O_l*#^icy<&Z zObhjE+U2PBA*m|@WImJsI-o9JzKcgOTYiZ_%vL*DeyY%HHlOHbbRrmF4_M&<2rvQ) z9E0va*LcwHJABAJ$oKV_O-7CxJVOI!PGquV*=y!_5f!u`0jGje8~j%~QAF8>4e0_9Wu|HlB*$(p7t^SDFrcbPGMtb zLg=xHHpaX8oYmRGdU;!9|1gRnQM_k!w`1`5fY&?e^)^0Q9S*O9x$ynLR)nAV#ypC0 zK~Wlu7Q0=r+c&y;S&z%Y@zv7wvu*tdpam=Sx!wL>VAQpK3*K(;8)$ii2EL3V&jlD_dimRa3mC Jt8z)U^B;P9oR9zj diff --git a/public/font/ifont.svg b/public/font/ifont.svg index e712cc6d6..38195f793 100644 --- a/public/font/ifont.svg +++ b/public/font/ifont.svg @@ -111,7 +111,7 @@ - + @@ -123,6 +123,11 @@ + + + + + \ No newline at end of file diff --git a/public/font/ifont.ttf b/public/font/ifont.ttf index e222d9669d61df8958676d197d075499686c9cc5..adf4527fb33e8ea159016c204e697fa5992aa3eb 100644 GIT binary patch delta 1170 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 Date: Fri, 4 Sep 2015 13:01:49 +0200 Subject: [PATCH 14/16] monitoring/lib: Add translate parameter to MonitoredObject::getType() --- .../Monitoring/Object/MonitoredObject.php | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php index 1bd8431a2..0896cd266 100644 --- a/modules/monitoring/library/Monitoring/Object/MonitoredObject.php +++ b/modules/monitoring/library/Monitoring/Object/MonitoredObject.php @@ -580,11 +580,27 @@ abstract class MonitoredObject implements Filterable /** * Get the type of the object * - * @return string + * @param bool $translate + * + * @return string */ - public function getType() + public function getType($translate = false) { - return $this->type; + if ($translate !== false) { + switch ($this->type) { + case self::TYPE_HOST: + $type = mt('montiroing', 'host'); + break; + case self::TYPE_SERVICE: + $type = mt('monitoring', 'service'); + break; + default: + throw new InvalidArgumentException('Invalid type ' . $this->type); + } + } else { + $type = $this->type; + } + return $type; } /** From 90f606fbd4b85a144f510ef95c26a326160aa8e0 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 13:03:28 +0200 Subject: [PATCH 15/16] monitoring: Fix tooltip of the sticky flag for acks --- .../forms/Command/Object/AcknowledgeProblemCommandForm.php | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/monitoring/application/forms/Command/Object/AcknowledgeProblemCommandForm.php b/modules/monitoring/application/forms/Command/Object/AcknowledgeProblemCommandForm.php index ef6d626b3..3503253ef 100644 --- a/modules/monitoring/application/forms/Command/Object/AcknowledgeProblemCommandForm.php +++ b/modules/monitoring/application/forms/Command/Object/AcknowledgeProblemCommandForm.php @@ -111,8 +111,8 @@ class AcknowledgeProblemCommandForm extends ObjectsCommandForm 'label' => $this->translate('Sticky Acknowledgement'), 'value' => true, 'description' => $this->translate( - 'If you want the acknowledgement to disable notifications until the host or service recovers,' - . ' check this option.' + 'If you want the acknowledgement to remain until the host or service recovers even if the host' + . ' or service changes state, check this option.' ) ) ), From 56e495049ca6f1ed760093f408006243339e0c10 Mon Sep 17 00:00:00 2001 From: Eric Lippmann Date: Fri, 4 Sep 2015 13:04:14 +0200 Subject: [PATCH 16/16] monitoring/detail: Indicate whether an ack is sticky refs #9674 --- .../scripts/show/components/acknowledgement.phtml | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml b/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml index 0743b6103..d32fd81c9 100644 --- a/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml +++ b/modules/monitoring/application/views/scripts/show/components/acknowledgement.phtml @@ -23,10 +23,21 @@ if ($object->acknowledged): ?> '' . $this->escape($acknowledgement->getAuthor()) . '', $this->timeAgo($acknowledgement->getEntryTime()) ) ?> - getSticky()) { + echo $this->icon('pin', sprintf( + $this->translate( + 'Acknowledgement remains until the %1$s recovers even if the %1$s changes state' + ), + $object->getType(true) + )); + } + if (isset($removeAckForm)) { + // Form is unset if the current user lacks the respective permission // Form is unset if the current user lacks the respective permission echo $removeAckForm; - } ?> + } + ?>

(translate('Comment') ?>):