| /* |
| * Copyright (C) 2015-2017 Andrew Beekhof <andrew@beekhof.net> |
| * |
| * This source code is licensed under the GNU Lesser General Public License |
| * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY. |
| */ |
| |
| #include <crm_internal.h> |
| #include <crm/crm.h> |
| #include <crm/msg_xml.h> |
| #include <crm/pengine/rules.h> |
| #include <crm/common/alerts_internal.h> |
| #include <crm/pengine/rules_internal.h> |
| |
| #ifdef RHEL7_COMPAT |
| /* @COMPAT An early implementation of alerts was backported to RHEL 7, |
| * even though it was never in an upstream release. |
| */ |
| static char *notify_script = NULL; |
| static char *notify_target = NULL; |
| |
| void |
| pe_enable_legacy_alerts(const char *script, const char *target) |
| { |
| static bool need_warning = TRUE; |
| |
| free(notify_script); |
| notify_script = (script && *script && strcmp(script, "/dev/null"))? |
| strdup(script) : NULL; |
| |
| free(notify_target); |
| notify_target = target && *target? strdup(target): NULL; |
| |
| if (notify_script || notify_target) { |
| if (need_warning) { |
| crm_warn("Support for 'notification-agent' and 'notification-target' cluster options" |
| " is deprecated and will be removed in a future release" |
| " (use alerts feature instead)"); |
| need_warning = FALSE; |
| } |
| } |
| } |
| #endif |
| |
| static void |
| get_meta_attrs_from_cib(xmlNode *basenode, crm_alert_entry_t *entry, |
| guint *max_timeout) |
| { |
| GHashTable *config_hash = crm_str_table_new(); |
| crm_time_t *now = crm_time_new(NULL); |
| const char *value = NULL; |
| |
| unpack_instance_attributes(basenode, basenode, XML_TAG_META_SETS, NULL, |
| config_hash, NULL, FALSE, now); |
| crm_time_free(now); |
| |
| value = g_hash_table_lookup(config_hash, XML_ALERT_ATTR_TIMEOUT); |
| if (value) { |
| entry->timeout = crm_get_msec(value); |
| if (entry->timeout <= 0) { |
| if (entry->timeout == 0) { |
| crm_trace("Alert %s uses default timeout of %dmsec", |
| entry->id, CRM_ALERT_DEFAULT_TIMEOUT_MS); |
| } else { |
| crm_warn("Alert %s has invalid timeout value '%s', using default %dmsec", |
| entry->id, (char*)value, CRM_ALERT_DEFAULT_TIMEOUT_MS); |
| } |
| entry->timeout = CRM_ALERT_DEFAULT_TIMEOUT_MS; |
| } else { |
| crm_trace("Alert %s uses timeout of %dmsec", |
| entry->id, entry->timeout); |
| } |
| if (entry->timeout > *max_timeout) { |
| *max_timeout = entry->timeout; |
| } |
| } |
| value = g_hash_table_lookup(config_hash, XML_ALERT_ATTR_TSTAMP_FORMAT); |
| if (value) { |
| /* hard to do any checks here as merely anything can |
| * can be a valid time-format-string |
| */ |
| entry->tstamp_format = strdup(value); |
| crm_trace("Alert %s uses timestamp format '%s'", |
| entry->id, entry->tstamp_format); |
| } |
| |
| g_hash_table_destroy(config_hash); |
| } |
| |
| static void |
| get_envvars_from_cib(xmlNode *basenode, crm_alert_entry_t *entry) |
| { |
| xmlNode *child; |
| |
| if ((basenode == NULL) || (entry == NULL)) { |
| return; |
| } |
| |
| child = first_named_child(basenode, XML_TAG_ATTR_SETS); |
| if (child == NULL) { |
| return; |
| } |
| |
| if (entry->envvars == NULL) { |
| entry->envvars = crm_str_table_new(); |
| } |
| |
| for (child = first_named_child(child, XML_CIB_TAG_NVPAIR); child != NULL; |
| child = crm_next_same_xml(child)) { |
| |
| const char *name = crm_element_value(child, XML_NVPAIR_ATTR_NAME); |
| const char *value = crm_element_value(child, XML_NVPAIR_ATTR_VALUE); |
| |
| if (value == NULL) { |
| value = ""; |
| } |
| g_hash_table_insert(entry->envvars, strdup(name), strdup(value)); |
| crm_trace("Alert %s: added environment variable %s='%s'", |
| entry->id, name, value); |
| } |
| } |
| |
| static void |
| unpack_alert_filter(xmlNode *basenode, crm_alert_entry_t *entry) |
| { |
| xmlNode *select = first_named_child(basenode, XML_CIB_TAG_ALERT_SELECT); |
| xmlNode *event_type = NULL; |
| uint32_t flags = crm_alert_none; |
| |
| for (event_type = __xml_first_child_element(select); event_type != NULL; |
| event_type = __xml_next_element(event_type)) { |
| |
| const char *tagname = crm_element_name(event_type); |
| |
| if (tagname == NULL) { |
| continue; |
| |
| } else if (!strcmp(tagname, XML_CIB_TAG_ALERT_FENCING)) { |
| flags |= crm_alert_fencing; |
| |
| } else if (!strcmp(tagname, XML_CIB_TAG_ALERT_NODES)) { |
| flags |= crm_alert_node; |
| |
| } else if (!strcmp(tagname, XML_CIB_TAG_ALERT_RESOURCES)) { |
| flags |= crm_alert_resource; |
| |
| } else if (!strcmp(tagname, XML_CIB_TAG_ALERT_ATTRIBUTES)) { |
| xmlNode *attr; |
| const char *attr_name; |
| int nattrs = 0; |
| |
| flags |= crm_alert_attribute; |
| for (attr = first_named_child(event_type, XML_CIB_TAG_ALERT_ATTR); |
| attr != NULL; |
| attr = crm_next_same_xml(attr)) { |
| |
| attr_name = crm_element_value(attr, XML_NVPAIR_ATTR_NAME); |
| if (attr_name) { |
| if (nattrs == 0) { |
| g_strfreev(entry->select_attribute_name); |
| entry->select_attribute_name = NULL; |
| } |
| ++nattrs; |
| entry->select_attribute_name = realloc_safe(entry->select_attribute_name, |
| (nattrs + 1) * sizeof(char*)); |
| entry->select_attribute_name[nattrs - 1] = strdup(attr_name); |
| entry->select_attribute_name[nattrs] = NULL; |
| } |
| } |
| } |
| } |
| |
| if (flags != crm_alert_none) { |
| entry->flags = flags; |
| crm_debug("Alert %s receives events: attributes:%s, fencing:%s, nodes:%s, resources:%s", |
| entry->id, |
| (flags & crm_alert_attribute)? |
| (entry->select_attribute_name? "some" : "all") : "no", |
| (flags & crm_alert_fencing)? "yes" : "no", |
| (flags & crm_alert_node)? "yes" : "no", |
| (flags & crm_alert_resource)? "yes" : "no"); |
| } |
| } |
| |
| static void |
| unpack_alert(xmlNode *alert, crm_alert_entry_t *entry, guint *max_timeout) |
| { |
| get_envvars_from_cib(alert, entry); |
| get_meta_attrs_from_cib(alert, entry, max_timeout); |
| unpack_alert_filter(alert, entry); |
| } |
| |
| /*! |
| * \internal |
| * \brief Unpack a CIB alerts section |
| * |
| * \param[in] alerts XML of alerts section |
| * |
| * \return List of unpacked alert entries |
| * |
| * \note Unlike most unpack functions, this is not used by the pengine itself, |
| * but is supplied for use by daemons that need to send alerts. |
| */ |
| GListPtr |
| pe_unpack_alerts(xmlNode *alerts) |
| { |
| xmlNode *alert; |
| crm_alert_entry_t *entry; |
| guint max_timeout = 0; |
| GListPtr alert_list = NULL; |
| |
| if (alerts) { |
| #ifdef RHEL7_COMPAT |
| if (notify_script) { |
| crm_warn("Ignoring deprecated notification configuration because alerts available"); |
| } |
| #endif |
| } else { |
| #ifdef RHEL7_COMPAT |
| if (notify_script) { |
| entry = crm_alert_entry_new("legacy_notification", notify_script); |
| entry->recipient = strdup(notify_target); |
| entry->tstamp_format = strdup(CRM_ALERT_DEFAULT_TSTAMP_FORMAT); |
| alert_list = g_list_prepend(alert_list, entry); |
| crm_warn("Deprecated notification syntax in use (alerts syntax is preferable)"); |
| } |
| #endif |
| return alert_list; |
| } |
| |
| for (alert = first_named_child(alerts, XML_CIB_TAG_ALERT); |
| alert != NULL; alert = crm_next_same_xml(alert)) { |
| |
| xmlNode *recipient; |
| int recipients = 0; |
| const char *alert_id = ID(alert); |
| const char *alert_path = crm_element_value(alert, XML_ALERT_ATTR_PATH); |
| |
| /* The schema should enforce this, but to be safe ... */ |
| if ((alert_id == NULL) || (alert_path == NULL)) { |
| crm_warn("Ignoring invalid alert without id and path"); |
| continue; |
| } |
| |
| entry = crm_alert_entry_new(alert_id, alert_path); |
| |
| unpack_alert(alert, entry, &max_timeout); |
| |
| if (entry->tstamp_format == NULL) { |
| entry->tstamp_format = strdup(CRM_ALERT_DEFAULT_TSTAMP_FORMAT); |
| } |
| |
| crm_debug("Alert %s: path=%s timeout=%dms tstamp-format='%s' %u vars", |
| entry->id, entry->path, entry->timeout, entry->tstamp_format, |
| (entry->envvars? g_hash_table_size(entry->envvars) : 0)); |
| |
| for (recipient = first_named_child(alert, XML_CIB_TAG_ALERT_RECIPIENT); |
| recipient != NULL; recipient = crm_next_same_xml(recipient)) { |
| |
| crm_alert_entry_t *recipient_entry = crm_dup_alert_entry(entry); |
| |
| recipients++; |
| recipient_entry->recipient = strdup(crm_element_value(recipient, |
| XML_ALERT_ATTR_REC_VALUE)); |
| unpack_alert(recipient, recipient_entry, &max_timeout); |
| alert_list = g_list_prepend(alert_list, recipient_entry); |
| crm_debug("Alert %s has recipient %s with value %s and %d envvars", |
| entry->id, ID(recipient), recipient_entry->recipient, |
| (recipient_entry->envvars? |
| g_hash_table_size(recipient_entry->envvars) : 0)); |
| } |
| |
| if (recipients == 0) { |
| alert_list = g_list_prepend(alert_list, entry); |
| } else { |
| crm_free_alert_entry(entry); |
| } |
| } |
| return alert_list; |
| } |
| |
| /*! |
| * \internal |
| * \brief Free an alert list generated by pe_unpack_alerts() |
| * |
| * \param[in] alert_list Alert list to free |
| */ |
| void |
| pe_free_alert_list(GListPtr alert_list) |
| { |
| if (alert_list) { |
| g_list_free_full(alert_list, (GDestroyNotify) crm_free_alert_entry); |
| } |
| } |
