diff options
Diffstat (limited to 'lib/pengine/pe_actions.c')
| -rw-r--r-- | lib/pengine/pe_actions.c | 1303 |
1 files changed, 744 insertions, 559 deletions
diff --git a/lib/pengine/pe_actions.c b/lib/pengine/pe_actions.c index ed7f0da..aaa6598 100644 --- a/lib/pengine/pe_actions.c +++ b/lib/pengine/pe_actions.c @@ -1,5 +1,5 @@ /* - * Copyright 2004-2022 the Pacemaker project contributors + * Copyright 2004-2023 the Pacemaker project contributors * * The version control history for this file may have further details. * @@ -14,29 +14,30 @@ #include <crm/crm.h> #include <crm/msg_xml.h> +#include <crm/common/scheduler_internal.h> #include <crm/pengine/internal.h> +#include <crm/common/xml_internal.h> #include "pe_status_private.h" -static void unpack_operation(pe_action_t *action, const xmlNode *xml_obj, - const pe_resource_t *container, - pe_working_set_t *data_set, guint interval_ms); +static void unpack_operation(pcmk_action_t *action, const xmlNode *xml_obj, + guint interval_ms); static void -add_singleton(pe_working_set_t *data_set, pe_action_t *action) +add_singleton(pcmk_scheduler_t *scheduler, pcmk_action_t *action) { - if (data_set->singletons == NULL) { - data_set->singletons = pcmk__strkey_table(NULL, NULL); + if (scheduler->singletons == NULL) { + scheduler->singletons = pcmk__strkey_table(NULL, NULL); } - g_hash_table_insert(data_set->singletons, action->uuid, action); + g_hash_table_insert(scheduler->singletons, action->uuid, action); } -static pe_action_t * -lookup_singleton(pe_working_set_t *data_set, const char *action_uuid) +static pcmk_action_t * +lookup_singleton(pcmk_scheduler_t *scheduler, const char *action_uuid) { - if (data_set->singletons == NULL) { + if (scheduler->singletons == NULL) { return NULL; } - return g_hash_table_lookup(data_set->singletons, action_uuid); + return g_hash_table_lookup(scheduler->singletons, action_uuid); } /*! @@ -46,21 +47,21 @@ lookup_singleton(pe_working_set_t *data_set, const char *action_uuid) * \param[in] key Action key to match * \param[in] rsc Resource to match (if any) * \param[in] node Node to match (if any) - * \param[in] data_set Cluster working set + * \param[in] scheduler Scheduler data * * \return Existing action that matches arguments (or NULL if none) */ -static pe_action_t * -find_existing_action(const char *key, const pe_resource_t *rsc, - const pe_node_t *node, const pe_working_set_t *data_set) +static pcmk_action_t * +find_existing_action(const char *key, const pcmk_resource_t *rsc, + const pcmk_node_t *node, const pcmk_scheduler_t *scheduler) { GList *matches = NULL; - pe_action_t *action = NULL; + pcmk_action_t *action = NULL; - /* When rsc is NULL, it would be quicker to check data_set->singletons, - * but checking all data_set->actions takes the node into account. + /* When rsc is NULL, it would be quicker to check scheduler->singletons, + * but checking all scheduler->actions takes the node into account. */ - matches = find_actions(((rsc == NULL)? data_set->actions : rsc->actions), + matches = find_actions(((rsc == NULL)? scheduler->actions : rsc->actions), key, node); if (matches == NULL) { return NULL; @@ -72,79 +73,78 @@ find_existing_action(const char *key, const pe_resource_t *rsc, return action; } +/*! + * \internal + * \brief Find the XML configuration corresponding to a specific action key + * + * \param[in] rsc Resource to find action configuration for + * \param[in] key "RSC_ACTION_INTERVAL" of action to find + * \param[in] include_disabled If false, do not return disabled actions + * + * \return XML configuration of desired action if any, otherwise NULL + */ static xmlNode * -find_rsc_op_entry_helper(const pe_resource_t *rsc, const char *key, - gboolean include_disabled) +find_exact_action_config(const pcmk_resource_t *rsc, const char *action_name, + guint interval_ms, bool include_disabled) { - guint interval_ms = 0; - gboolean do_retry = TRUE; - char *local_key = NULL; - const char *name = NULL; - const char *interval_spec = NULL; - char *match_key = NULL; - xmlNode *op = NULL; - xmlNode *operation = NULL; - - retry: - for (operation = pcmk__xe_first_child(rsc->ops_xml); operation != NULL; - operation = pcmk__xe_next(operation)) { + for (xmlNode *operation = first_named_child(rsc->ops_xml, XML_ATTR_OP); + operation != NULL; operation = crm_next_same_xml(operation)) { - if (pcmk__str_eq((const char *)operation->name, "op", pcmk__str_none)) { - bool enabled = false; + bool enabled = false; + const char *config_name = NULL; + const char *interval_spec = NULL; - name = crm_element_value(operation, "name"); - interval_spec = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); - if (!include_disabled && pcmk__xe_get_bool_attr(operation, "enabled", &enabled) == pcmk_rc_ok && - !enabled) { - continue; - } - - interval_ms = crm_parse_interval_spec(interval_spec); - match_key = pcmk__op_key(rsc->id, name, interval_ms); - if (pcmk__str_eq(key, match_key, pcmk__str_casei)) { - op = operation; - } - free(match_key); - - if (rsc->clone_name) { - match_key = pcmk__op_key(rsc->clone_name, name, interval_ms); - if (pcmk__str_eq(key, match_key, pcmk__str_casei)) { - op = operation; - } - free(match_key); - } - - if (op != NULL) { - free(local_key); - return op; - } + // @TODO This does not consider rules, defaults, etc. + if (!include_disabled + && (pcmk__xe_get_bool_attr(operation, "enabled", + &enabled) == pcmk_rc_ok) && !enabled) { + continue; } - } - - free(local_key); - if (do_retry == FALSE) { - return NULL; - } - do_retry = FALSE; - if (strstr(key, CRMD_ACTION_MIGRATE) || strstr(key, CRMD_ACTION_MIGRATED)) { - local_key = pcmk__op_key(rsc->id, "migrate", 0); - key = local_key; - goto retry; + interval_spec = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); + if (crm_parse_interval_spec(interval_spec) != interval_ms) { + continue; + } - } else if (strstr(key, "_notify_")) { - local_key = pcmk__op_key(rsc->id, "notify", 0); - key = local_key; - goto retry; + config_name = crm_element_value(operation, "name"); + if (pcmk__str_eq(action_name, config_name, pcmk__str_none)) { + return operation; + } } - return NULL; } +/*! + * \internal + * \brief Find the XML configuration of a resource action + * + * \param[in] rsc Resource to find action configuration for + * \param[in] action_name Action name to search for + * \param[in] interval_ms Action interval (in milliseconds) to search for + * \param[in] include_disabled If false, do not return disabled actions + * + * \return XML configuration of desired action if any, otherwise NULL + */ xmlNode * -find_rsc_op_entry(const pe_resource_t *rsc, const char *key) +pcmk__find_action_config(const pcmk_resource_t *rsc, const char *action_name, + guint interval_ms, bool include_disabled) { - return find_rsc_op_entry_helper(rsc, key, FALSE); + xmlNode *action_config = NULL; + + // Try requested action first + action_config = find_exact_action_config(rsc, action_name, interval_ms, + include_disabled); + + // For migrate_to and migrate_from actions, retry with "migrate" + // @TODO This should be either documented or deprecated + if ((action_config == NULL) + && pcmk__str_any_of(action_name, PCMK_ACTION_MIGRATE_TO, + PCMK_ACTION_MIGRATE_FROM, NULL)) { + action_config = find_exact_action_config(rsc, "migrate", 0, + include_disabled); + } + + return action_config; } /*! @@ -156,98 +156,106 @@ find_rsc_op_entry(const pe_resource_t *rsc, const char *key) * \param[in,out] rsc Resource that action is for (if any) * \param[in] node Node that action is on (if any) * \param[in] optional Whether action should be considered optional - * \param[in] for_graph Whether action should be recorded in transition graph - * \param[in,out] data_set Cluster working set + * \param[in,out] scheduler Scheduler data * * \return Newly allocated action * \note This function takes ownership of \p key. It is the caller's * responsibility to free the return value with pe_free_action(). */ -static pe_action_t * -new_action(char *key, const char *task, pe_resource_t *rsc, - const pe_node_t *node, bool optional, bool for_graph, - pe_working_set_t *data_set) +static pcmk_action_t * +new_action(char *key, const char *task, pcmk_resource_t *rsc, + const pcmk_node_t *node, bool optional, pcmk_scheduler_t *scheduler) { - pe_action_t *action = calloc(1, sizeof(pe_action_t)); + pcmk_action_t *action = calloc(1, sizeof(pcmk_action_t)); CRM_ASSERT(action != NULL); action->rsc = rsc; action->task = strdup(task); CRM_ASSERT(action->task != NULL); action->uuid = key; - action->extra = pcmk__strkey_table(free, free); - action->meta = pcmk__strkey_table(free, free); if (node) { action->node = pe__copy_node(node); } - if (pcmk__str_eq(task, CRM_OP_LRM_DELETE, pcmk__str_casei)) { + if (pcmk__str_eq(task, PCMK_ACTION_LRM_DELETE, pcmk__str_casei)) { // Resource history deletion for a node can be done on the DC - pe__set_action_flags(action, pe_action_dc); + pe__set_action_flags(action, pcmk_action_on_dc); } - pe__set_action_flags(action, pe_action_runnable); + pe__set_action_flags(action, pcmk_action_runnable); if (optional) { - pe__set_action_flags(action, pe_action_optional); + pe__set_action_flags(action, pcmk_action_optional); } else { - pe__clear_action_flags(action, pe_action_optional); + pe__clear_action_flags(action, pcmk_action_optional); } - if (rsc != NULL) { + if (rsc == NULL) { + action->meta = pcmk__strkey_table(free, free); + } else { guint interval_ms = 0; - action->op_entry = find_rsc_op_entry_helper(rsc, key, TRUE); parse_op_key(key, NULL, NULL, &interval_ms); - unpack_operation(action, action->op_entry, rsc->container, data_set, - interval_ms); + action->op_entry = pcmk__find_action_config(rsc, task, interval_ms, + true); + + /* If the given key is for one of the many notification pseudo-actions + * (pre_notify_promote, etc.), the actual action name is "notify" + */ + if ((action->op_entry == NULL) && (strstr(key, "_notify_") != NULL)) { + action->op_entry = find_exact_action_config(rsc, PCMK_ACTION_NOTIFY, + 0, true); + } + + unpack_operation(action, action->op_entry, interval_ms); } - if (for_graph) { - pe_rsc_trace(rsc, "Created %s action %d (%s): %s for %s on %s", - (optional? "optional" : "required"), - data_set->action_id, key, task, - ((rsc == NULL)? "no resource" : rsc->id), - pe__node_name(node)); - action->id = data_set->action_id++; + pe_rsc_trace(rsc, "Created %s action %d (%s): %s for %s on %s", + (optional? "optional" : "required"), + scheduler->action_id, key, task, + ((rsc == NULL)? "no resource" : rsc->id), + pe__node_name(node)); + action->id = scheduler->action_id++; - data_set->actions = g_list_prepend(data_set->actions, action); - if (rsc == NULL) { - add_singleton(data_set, action); - } else { - rsc->actions = g_list_prepend(rsc->actions, action); - } + scheduler->actions = g_list_prepend(scheduler->actions, action); + if (rsc == NULL) { + add_singleton(scheduler, action); + } else { + rsc->actions = g_list_prepend(rsc->actions, action); } return action; } /*! * \internal - * \brief Evaluate node attribute values for an action + * \brief Unpack a resource's action-specific instance parameters * - * \param[in,out] action Action to unpack attributes for - * \param[in,out] data_set Cluster working set + * \param[in] action_xml XML of action's configuration in CIB (if any) + * \param[in,out] node_attrs Table of node attributes (for rule evaluation) + * \param[in,out] scheduler Cluster working set (for rule evaluation) + * + * \return Newly allocated hash table of action-specific instance parameters */ -static void -unpack_action_node_attributes(pe_action_t *action, pe_working_set_t *data_set) +GHashTable * +pcmk__unpack_action_rsc_params(const xmlNode *action_xml, + GHashTable *node_attrs, + pcmk_scheduler_t *scheduler) { - if (!pcmk_is_set(action->flags, pe_action_have_node_attrs) - && (action->op_entry != NULL)) { - - pe_rule_eval_data_t rule_data = { - .node_hash = action->node->details->attrs, - .role = RSC_ROLE_UNKNOWN, - .now = data_set->now, - .match_data = NULL, - .rsc_data = NULL, - .op_data = NULL - }; - - pe__set_action_flags(action, pe_action_have_node_attrs); - pe__unpack_dataset_nvpairs(action->op_entry, XML_TAG_ATTR_SETS, - &rule_data, action->extra, NULL, - FALSE, data_set); - } + GHashTable *params = pcmk__strkey_table(free, free); + + pe_rule_eval_data_t rule_data = { + .node_hash = node_attrs, + .role = pcmk_role_unknown, + .now = scheduler->now, + .match_data = NULL, + .rsc_data = NULL, + .op_data = NULL + }; + + pe__unpack_dataset_nvpairs(action_xml, XML_TAG_ATTR_SETS, + &rule_data, params, NULL, + FALSE, scheduler); + return params; } /*! @@ -258,46 +266,46 @@ unpack_action_node_attributes(pe_action_t *action, pe_working_set_t *data_set) * \param[in] optional Requested optional status */ static void -update_action_optional(pe_action_t *action, gboolean optional) +update_action_optional(pcmk_action_t *action, gboolean optional) { // Force a non-recurring action to be optional if its resource is unmanaged if ((action->rsc != NULL) && (action->node != NULL) - && !pcmk_is_set(action->flags, pe_action_pseudo) - && !pcmk_is_set(action->rsc->flags, pe_rsc_managed) + && !pcmk_is_set(action->flags, pcmk_action_pseudo) + && !pcmk_is_set(action->rsc->flags, pcmk_rsc_managed) && (g_hash_table_lookup(action->meta, XML_LRM_ATTR_INTERVAL_MS) == NULL)) { pe_rsc_debug(action->rsc, "%s on %s is optional (%s is unmanaged)", action->uuid, pe__node_name(action->node), action->rsc->id); - pe__set_action_flags(action, pe_action_optional); + pe__set_action_flags(action, pcmk_action_optional); // We shouldn't clear runnable here because ... something // Otherwise require the action if requested } else if (!optional) { - pe__clear_action_flags(action, pe_action_optional); + pe__clear_action_flags(action, pcmk_action_optional); } } static enum pe_quorum_policy -effective_quorum_policy(pe_resource_t *rsc, pe_working_set_t *data_set) +effective_quorum_policy(pcmk_resource_t *rsc, pcmk_scheduler_t *scheduler) { - enum pe_quorum_policy policy = data_set->no_quorum_policy; + enum pe_quorum_policy policy = scheduler->no_quorum_policy; - if (pcmk_is_set(data_set->flags, pe_flag_have_quorum)) { - policy = no_quorum_ignore; + if (pcmk_is_set(scheduler->flags, pcmk_sched_quorate)) { + policy = pcmk_no_quorum_ignore; - } else if (data_set->no_quorum_policy == no_quorum_demote) { + } else if (scheduler->no_quorum_policy == pcmk_no_quorum_demote) { switch (rsc->role) { - case RSC_ROLE_PROMOTED: - case RSC_ROLE_UNPROMOTED: - if (rsc->next_role > RSC_ROLE_UNPROMOTED) { - pe__set_next_role(rsc, RSC_ROLE_UNPROMOTED, + case pcmk_role_promoted: + case pcmk_role_unpromoted: + if (rsc->next_role > pcmk_role_unpromoted) { + pe__set_next_role(rsc, pcmk_role_unpromoted, "no-quorum-policy=demote"); } - policy = no_quorum_ignore; + policy = pcmk_no_quorum_ignore; break; default: - policy = no_quorum_stop; + policy = pcmk_no_quorum_stop; break; } } @@ -309,50 +317,47 @@ effective_quorum_policy(pe_resource_t *rsc, pe_working_set_t *data_set) * \brief Update a resource action's runnable flag * * \param[in,out] action Action to update - * \param[in] for_graph Whether action should be recorded in transition graph - * \param[in,out] data_set Cluster working set + * \param[in,out] scheduler Scheduler data * * \note This may also schedule fencing if a stop is unrunnable. */ static void -update_resource_action_runnable(pe_action_t *action, bool for_graph, - pe_working_set_t *data_set) +update_resource_action_runnable(pcmk_action_t *action, + pcmk_scheduler_t *scheduler) { - if (pcmk_is_set(action->flags, pe_action_pseudo)) { + if (pcmk_is_set(action->flags, pcmk_action_pseudo)) { return; } if (action->node == NULL) { pe_rsc_trace(action->rsc, "%s is unrunnable (unallocated)", action->uuid); - pe__clear_action_flags(action, pe_action_runnable); + pe__clear_action_flags(action, pcmk_action_runnable); - } else if (!pcmk_is_set(action->flags, pe_action_dc) + } else if (!pcmk_is_set(action->flags, pcmk_action_on_dc) && !(action->node->details->online) && (!pe__is_guest_node(action->node) || action->node->details->remote_requires_reset)) { - pe__clear_action_flags(action, pe_action_runnable); - do_crm_log((for_graph? LOG_WARNING: LOG_TRACE), - "%s on %s is unrunnable (node is offline)", + pe__clear_action_flags(action, pcmk_action_runnable); + do_crm_log(LOG_WARNING, "%s on %s is unrunnable (node is offline)", action->uuid, pe__node_name(action->node)); - if (pcmk_is_set(action->rsc->flags, pe_rsc_managed) - && for_graph - && pcmk__str_eq(action->task, CRMD_ACTION_STOP, pcmk__str_casei) + if (pcmk_is_set(action->rsc->flags, pcmk_rsc_managed) + && pcmk__str_eq(action->task, PCMK_ACTION_STOP, pcmk__str_casei) && !(action->node->details->unclean)) { - pe_fence_node(data_set, action->node, "stop is unrunnable", false); + pe_fence_node(scheduler, action->node, "stop is unrunnable", false); } - } else if (!pcmk_is_set(action->flags, pe_action_dc) + } else if (!pcmk_is_set(action->flags, pcmk_action_on_dc) && action->node->details->pending) { - pe__clear_action_flags(action, pe_action_runnable); - do_crm_log((for_graph? LOG_WARNING: LOG_TRACE), + pe__clear_action_flags(action, pcmk_action_runnable); + do_crm_log(LOG_WARNING, "Action %s on %s is unrunnable (node is pending)", action->uuid, pe__node_name(action->node)); - } else if (action->needs == rsc_req_nothing) { + } else if (action->needs == pcmk_requires_nothing) { pe_action_set_reason(action, NULL, TRUE); if (pe__is_guest_node(action->node) - && !pe_can_fence(data_set, action->node)) { + && !pe_can_fence(scheduler, action->node)) { /* An action that requires nothing usually does not require any * fencing in order to be runnable. However, there is an exception: * such an action cannot be completed if it is on a guest node whose @@ -361,37 +366,37 @@ update_resource_action_runnable(pe_action_t *action, bool for_graph, pe_rsc_debug(action->rsc, "%s on %s is unrunnable " "(node's host cannot be fenced)", action->uuid, pe__node_name(action->node)); - pe__clear_action_flags(action, pe_action_runnable); + pe__clear_action_flags(action, pcmk_action_runnable); } else { pe_rsc_trace(action->rsc, "%s on %s does not require fencing or quorum", action->uuid, pe__node_name(action->node)); - pe__set_action_flags(action, pe_action_runnable); + pe__set_action_flags(action, pcmk_action_runnable); } } else { - switch (effective_quorum_policy(action->rsc, data_set)) { - case no_quorum_stop: + switch (effective_quorum_policy(action->rsc, scheduler)) { + case pcmk_no_quorum_stop: pe_rsc_debug(action->rsc, "%s on %s is unrunnable (no quorum)", action->uuid, pe__node_name(action->node)); - pe__clear_action_flags(action, pe_action_runnable); + pe__clear_action_flags(action, pcmk_action_runnable); pe_action_set_reason(action, "no quorum", true); break; - case no_quorum_freeze: + case pcmk_no_quorum_freeze: if (!action->rsc->fns->active(action->rsc, TRUE) || (action->rsc->next_role > action->rsc->role)) { pe_rsc_debug(action->rsc, "%s on %s is unrunnable (no quorum)", action->uuid, pe__node_name(action->node)); - pe__clear_action_flags(action, pe_action_runnable); + pe__clear_action_flags(action, pcmk_action_runnable); pe_action_set_reason(action, "quorum freeze", true); } break; default: //pe_action_set_reason(action, NULL, TRUE); - pe__set_action_flags(action, pe_action_runnable); + pe__set_action_flags(action, pcmk_action_runnable); break; } } @@ -405,19 +410,20 @@ update_resource_action_runnable(pe_action_t *action, bool for_graph, * \param[in] action New action */ static void -update_resource_flags_for_action(pe_resource_t *rsc, const pe_action_t *action) +update_resource_flags_for_action(pcmk_resource_t *rsc, + const pcmk_action_t *action) { - /* @COMPAT pe_rsc_starting and pe_rsc_stopping are not actually used - * within Pacemaker, and should be deprecated and eventually removed + /* @COMPAT pcmk_rsc_starting and pcmk_rsc_stopping are deprecated and unused + * within Pacemaker, and will eventually be removed */ - if (pcmk__str_eq(action->task, CRMD_ACTION_STOP, pcmk__str_casei)) { - pe__set_resource_flags(rsc, pe_rsc_stopping); + if (pcmk__str_eq(action->task, PCMK_ACTION_STOP, pcmk__str_casei)) { + pe__set_resource_flags(rsc, pcmk_rsc_stopping); - } else if (pcmk__str_eq(action->task, CRMD_ACTION_START, pcmk__str_casei)) { - if (pcmk_is_set(action->flags, pe_action_runnable)) { - pe__set_resource_flags(rsc, pe_rsc_starting); + } else if (pcmk__str_eq(action->task, PCMK_ACTION_START, pcmk__str_casei)) { + if (pcmk_is_set(action->flags, pcmk_action_runnable)) { + pe__set_resource_flags(rsc, pcmk_rsc_starting); } else { - pe__clear_resource_flags(rsc, pe_rsc_starting); + pe__clear_resource_flags(rsc, pcmk_rsc_starting); } } } @@ -428,80 +434,121 @@ valid_stop_on_fail(const char *value) return !pcmk__strcase_any_of(value, "standby", "demote", "stop", NULL); } -static const char * -unpack_operation_on_fail(pe_action_t * action) +/*! + * \internal + * \brief Validate (and possibly reset) resource action's on_fail meta-attribute + * + * \param[in] rsc Resource that action is for + * \param[in] action_name Action name + * \param[in] action_config Action configuration XML from CIB (if any) + * \param[in,out] meta Table of action meta-attributes + */ +static void +validate_on_fail(const pcmk_resource_t *rsc, const char *action_name, + const xmlNode *action_config, GHashTable *meta) { const char *name = NULL; const char *role = NULL; - const char *on_fail = NULL; const char *interval_spec = NULL; - const char *value = g_hash_table_lookup(action->meta, XML_OP_ATTR_ON_FAIL); + const char *value = g_hash_table_lookup(meta, XML_OP_ATTR_ON_FAIL); + char *key = NULL; + char *new_value = NULL; - if (pcmk__str_eq(action->task, CRMD_ACTION_STOP, pcmk__str_casei) + // Stop actions can only use certain on-fail values + if (pcmk__str_eq(action_name, PCMK_ACTION_STOP, pcmk__str_none) && !valid_stop_on_fail(value)) { pcmk__config_err("Resetting '" XML_OP_ATTR_ON_FAIL "' for %s stop " "action to default value because '%s' is not " - "allowed for stop", action->rsc->id, value); - return NULL; - - } else if (pcmk__str_eq(action->task, CRMD_ACTION_DEMOTE, pcmk__str_casei) && !value) { - // demote on_fail defaults to monitor value for promoted role if present - xmlNode *operation = NULL; + "allowed for stop", rsc->id, value); + g_hash_table_remove(meta, XML_OP_ATTR_ON_FAIL); + return; + } - CRM_CHECK(action->rsc != NULL, return NULL); + /* Demote actions default on-fail to the on-fail value for the first + * recurring monitor for the promoted role (if any). + */ + if (pcmk__str_eq(action_name, PCMK_ACTION_DEMOTE, pcmk__str_none) + && (value == NULL)) { - for (operation = pcmk__xe_first_child(action->rsc->ops_xml); - (operation != NULL) && (value == NULL); - operation = pcmk__xe_next(operation)) { + /* @TODO This does not consider promote options set in a meta-attribute + * block (which may have rules that need to be evaluated) rather than + * XML properties. + */ + for (xmlNode *operation = first_named_child(rsc->ops_xml, XML_ATTR_OP); + operation != NULL; operation = crm_next_same_xml(operation)) { bool enabled = false; + const char *promote_on_fail = NULL; - if (!pcmk__str_eq((const char *)operation->name, "op", pcmk__str_none)) { + /* We only care about explicit on-fail (if promote uses default, so + * can demote) + */ + promote_on_fail = crm_element_value(operation, XML_OP_ATTR_ON_FAIL); + if (promote_on_fail == NULL) { continue; } + + // We only care about recurring monitors for the promoted role name = crm_element_value(operation, "name"); role = crm_element_value(operation, "role"); - on_fail = crm_element_value(operation, XML_OP_ATTR_ON_FAIL); - interval_spec = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); - if (!on_fail) { - continue; - } else if (pcmk__xe_get_bool_attr(operation, "enabled", &enabled) == pcmk_rc_ok && !enabled) { + if (!pcmk__str_eq(name, PCMK_ACTION_MONITOR, pcmk__str_none) + || !pcmk__strcase_any_of(role, PCMK__ROLE_PROMOTED, + PCMK__ROLE_PROMOTED_LEGACY, NULL)) { continue; - } else if (!pcmk__str_eq(name, "monitor", pcmk__str_casei) - || !pcmk__strcase_any_of(role, RSC_ROLE_PROMOTED_S, - RSC_ROLE_PROMOTED_LEGACY_S, - NULL)) { + } + interval_spec = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); + if (crm_parse_interval_spec(interval_spec) == 0) { continue; - } else if (crm_parse_interval_spec(interval_spec) == 0) { + } + + // We only care about enabled monitors + if ((pcmk__xe_get_bool_attr(operation, "enabled", + &enabled) == pcmk_rc_ok) && !enabled) { continue; - } else if (pcmk__str_eq(on_fail, "demote", pcmk__str_casei)) { + } + + // Demote actions can't default to on-fail="demote" + if (pcmk__str_eq(promote_on_fail, "demote", pcmk__str_casei)) { continue; } - value = on_fail; + // Use value from first applicable promote action found + key = strdup(XML_OP_ATTR_ON_FAIL); + new_value = strdup(promote_on_fail); + CRM_ASSERT((key != NULL) && (new_value != NULL)); + g_hash_table_insert(meta, key, new_value); } - } else if (pcmk__str_eq(action->task, CRM_OP_LRM_DELETE, pcmk__str_casei)) { - value = "ignore"; + return; + } - } else if (pcmk__str_eq(value, "demote", pcmk__str_casei)) { - name = crm_element_value(action->op_entry, "name"); - role = crm_element_value(action->op_entry, "role"); - interval_spec = crm_element_value(action->op_entry, + if (pcmk__str_eq(action_name, PCMK_ACTION_LRM_DELETE, pcmk__str_none) + && !pcmk__str_eq(value, "ignore", pcmk__str_casei)) { + key = strdup(XML_OP_ATTR_ON_FAIL); + new_value = strdup("ignore"); + CRM_ASSERT((key != NULL) && (new_value != NULL)); + g_hash_table_insert(meta, key, new_value); + return; + } + + // on-fail="demote" is allowed only for certain actions + if (pcmk__str_eq(value, "demote", pcmk__str_casei)) { + name = crm_element_value(action_config, "name"); + role = crm_element_value(action_config, "role"); + interval_spec = crm_element_value(action_config, XML_LRM_ATTR_INTERVAL); - if (!pcmk__str_eq(name, CRMD_ACTION_PROMOTE, pcmk__str_casei) - && (!pcmk__str_eq(name, CRMD_ACTION_STATUS, pcmk__str_casei) - || !pcmk__strcase_any_of(role, RSC_ROLE_PROMOTED_S, - RSC_ROLE_PROMOTED_LEGACY_S, NULL) + if (!pcmk__str_eq(name, PCMK_ACTION_PROMOTE, pcmk__str_none) + && (!pcmk__str_eq(name, PCMK_ACTION_MONITOR, pcmk__str_none) + || !pcmk__strcase_any_of(role, PCMK__ROLE_PROMOTED, + PCMK__ROLE_PROMOTED_LEGACY, NULL) || (crm_parse_interval_spec(interval_spec) == 0))) { pcmk__config_err("Resetting '" XML_OP_ATTR_ON_FAIL "' for %s %s " "action to default value because 'demote' is not " - "allowed for it", action->rsc->id, name); - return NULL; + "allowed for it", rsc->id, name); + g_hash_table_remove(meta, XML_OP_ATTR_ON_FAIL); + return; } } - - return value; } static int @@ -510,7 +557,7 @@ unpack_timeout(const char *value) int timeout_ms = crm_get_msec(value); if (timeout_ms < 0) { - timeout_ms = crm_get_msec(CRM_DEFAULT_OP_TIMEOUT_S); + timeout_ms = PCMK_DEFAULT_ACTION_TIMEOUT_MS; } return timeout_ms; } @@ -579,346 +626,475 @@ unpack_start_delay(const char *value, GHashTable *meta) return start_delay; } +/*! + * \internal + * \brief Find a resource's most frequent recurring monitor + * + * \param[in] rsc Resource to check + * + * \return Operation XML configured for most frequent recurring monitor for + * \p rsc (if any) + */ static xmlNode * -find_min_interval_mon(pe_resource_t * rsc, gboolean include_disabled) +most_frequent_monitor(const pcmk_resource_t *rsc) { - guint interval_ms = 0; guint min_interval_ms = G_MAXUINT; - const char *name = NULL; - const char *interval_spec = NULL; xmlNode *op = NULL; - xmlNode *operation = NULL; - - for (operation = pcmk__xe_first_child(rsc->ops_xml); - operation != NULL; - operation = pcmk__xe_next(operation)) { - if (pcmk__str_eq((const char *)operation->name, "op", pcmk__str_none)) { - bool enabled = false; - - name = crm_element_value(operation, "name"); - interval_spec = crm_element_value(operation, XML_LRM_ATTR_INTERVAL); - if (!include_disabled && pcmk__xe_get_bool_attr(operation, "enabled", &enabled) == pcmk_rc_ok && - !enabled) { - continue; - } + for (xmlNode *operation = first_named_child(rsc->ops_xml, XML_ATTR_OP); + operation != NULL; operation = crm_next_same_xml(operation)) { + bool enabled = false; + guint interval_ms = 0; + const char *interval_spec = crm_element_value(operation, + XML_LRM_ATTR_INTERVAL); - if (!pcmk__str_eq(name, RSC_STATUS, pcmk__str_casei)) { - continue; - } + // We only care about enabled recurring monitors + if (!pcmk__str_eq(crm_element_value(operation, "name"), + PCMK_ACTION_MONITOR, pcmk__str_none)) { + continue; + } + interval_ms = crm_parse_interval_spec(interval_spec); + if (interval_ms == 0) { + continue; + } - interval_ms = crm_parse_interval_spec(interval_spec); + // @TODO This does not account for rules, defaults, etc. + if ((pcmk__xe_get_bool_attr(operation, "enabled", + &enabled) == pcmk_rc_ok) && !enabled) { + continue; + } - if (interval_ms && (interval_ms < min_interval_ms)) { - min_interval_ms = interval_ms; - op = operation; - } + if (interval_ms < min_interval_ms) { + min_interval_ms = interval_ms; + op = operation; } } - return op; } /*! - * \brief Unpack operation XML into an action structure + * \internal + * \brief Unpack action meta-attributes * - * Unpack an operation's meta-attributes (normalizing the interval, timeout, - * and start delay values as integer milliseconds), requirements, and - * failure policy. + * \param[in,out] rsc Resource that action is for + * \param[in] node Node that action is on + * \param[in] action_name Action name + * \param[in] interval_ms Action interval (in milliseconds) + * \param[in] action_config Action XML configuration from CIB (if any) * - * \param[in,out] action Action to unpack into - * \param[in] xml_obj Operation XML (or NULL if all defaults) - * \param[in] container Resource that contains affected resource, if any - * \param[in,out] data_set Cluster state - * \param[in] interval_ms How frequently to perform the operation + * Unpack a resource action's meta-attributes (normalizing the interval, + * timeout, and start delay values as integer milliseconds) from its CIB XML + * configuration (including defaults). + * + * \return Newly allocated hash table with normalized action meta-attributes */ -static void -unpack_operation(pe_action_t *action, const xmlNode *xml_obj, - const pe_resource_t *container, - pe_working_set_t *data_set, guint interval_ms) +GHashTable * +pcmk__unpack_action_meta(pcmk_resource_t *rsc, const pcmk_node_t *node, + const char *action_name, guint interval_ms, + const xmlNode *action_config) { - int timeout_ms = 0; - const char *value = NULL; - bool is_probe = false; + GHashTable *meta = NULL; + char *name = NULL; + char *value = NULL; + const char *timeout_spec = NULL; + const char *str = NULL; pe_rsc_eval_data_t rsc_rule_data = { - .standard = crm_element_value(action->rsc->xml, XML_AGENT_ATTR_CLASS), - .provider = crm_element_value(action->rsc->xml, XML_AGENT_ATTR_PROVIDER), - .agent = crm_element_value(action->rsc->xml, XML_EXPR_ATTR_TYPE) + .standard = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS), + .provider = crm_element_value(rsc->xml, XML_AGENT_ATTR_PROVIDER), + .agent = crm_element_value(rsc->xml, XML_EXPR_ATTR_TYPE), }; pe_op_eval_data_t op_rule_data = { - .op_name = action->task, - .interval = interval_ms + .op_name = action_name, + .interval = interval_ms, }; pe_rule_eval_data_t rule_data = { - .node_hash = NULL, - .role = RSC_ROLE_UNKNOWN, - .now = data_set->now, + .node_hash = (node == NULL)? NULL : node->details->attrs, + .role = pcmk_role_unknown, + .now = rsc->cluster->now, .match_data = NULL, .rsc_data = &rsc_rule_data, - .op_data = &op_rule_data + .op_data = &op_rule_data, }; - CRM_CHECK(action && action->rsc, return); - - is_probe = pcmk_is_probe(action->task, interval_ms); + meta = pcmk__strkey_table(free, free); // Cluster-wide <op_defaults> <meta_attributes> - pe__unpack_dataset_nvpairs(data_set->op_defaults, XML_TAG_META_SETS, &rule_data, - action->meta, NULL, FALSE, data_set); - - // Determine probe default timeout differently - if (is_probe) { - xmlNode *min_interval_mon = find_min_interval_mon(action->rsc, FALSE); - - if (min_interval_mon) { - value = crm_element_value(min_interval_mon, XML_ATTR_TIMEOUT); - if (value) { - crm_trace("\t%s: Setting default timeout to minimum-interval " - "monitor's timeout '%s'", action->uuid, value); - g_hash_table_replace(action->meta, strdup(XML_ATTR_TIMEOUT), - strdup(value)); + pe__unpack_dataset_nvpairs(rsc->cluster->op_defaults, XML_TAG_META_SETS, + &rule_data, meta, NULL, FALSE, rsc->cluster); + + // Derive default timeout for probes from recurring monitor timeouts + if (pcmk_is_probe(action_name, interval_ms)) { + xmlNode *min_interval_mon = most_frequent_monitor(rsc); + + if (min_interval_mon != NULL) { + /* @TODO This does not consider timeouts set in meta_attributes + * blocks (which may also have rules that need to be evaluated). + */ + timeout_spec = crm_element_value(min_interval_mon, + XML_ATTR_TIMEOUT); + if (timeout_spec != NULL) { + pe_rsc_trace(rsc, + "Setting default timeout for %s probe to " + "most frequent monitor's timeout '%s'", + rsc->id, timeout_spec); + name = strdup(XML_ATTR_TIMEOUT); + value = strdup(timeout_spec); + CRM_ASSERT((name != NULL) && (value != NULL)); + g_hash_table_insert(meta, name, value); } } } - if (xml_obj) { - xmlAttrPtr xIter = NULL; - + if (action_config != NULL) { // <op> <meta_attributes> take precedence over defaults - pe__unpack_dataset_nvpairs(xml_obj, XML_TAG_META_SETS, &rule_data, - action->meta, NULL, TRUE, data_set); + pe__unpack_dataset_nvpairs(action_config, XML_TAG_META_SETS, &rule_data, + meta, NULL, TRUE, rsc->cluster); /* Anything set as an <op> XML property has highest precedence. * This ensures we use the name and interval from the <op> tag. + * (See below for the only exception, fence device start/probe timeout.) */ - for (xIter = xml_obj->properties; xIter; xIter = xIter->next) { - const char *prop_name = (const char *)xIter->name; - const char *prop_value = crm_element_value(xml_obj, prop_name); + for (xmlAttrPtr attr = action_config->properties; + attr != NULL; attr = attr->next) { + name = strdup((const char *) attr->name); + value = strdup(pcmk__xml_attr_value(attr)); - g_hash_table_replace(action->meta, strdup(prop_name), strdup(prop_value)); + CRM_ASSERT((name != NULL) && (value != NULL)); + g_hash_table_insert(meta, name, value); } } - g_hash_table_remove(action->meta, "id"); + g_hash_table_remove(meta, XML_ATTR_ID); // Normalize interval to milliseconds if (interval_ms > 0) { - g_hash_table_replace(action->meta, strdup(XML_LRM_ATTR_INTERVAL), - crm_strdup_printf("%u", interval_ms)); + name = strdup(XML_LRM_ATTR_INTERVAL); + CRM_ASSERT(name != NULL); + value = crm_strdup_printf("%u", interval_ms); + g_hash_table_insert(meta, name, value); } else { - g_hash_table_remove(action->meta, XML_LRM_ATTR_INTERVAL); - } - - /* - * Timeout order of precedence: - * 1. pcmk_monitor_timeout (if rsc has pcmk_ra_cap_fence_params - * and task is start or a probe; pcmk_monitor_timeout works - * by default for a recurring monitor) - * 2. explicit op timeout on the primitive - * 3. default op timeout - * a. if probe, then min-interval monitor's timeout - * b. else, in XML_CIB_TAG_OPCONFIG - * 4. CRM_DEFAULT_OP_TIMEOUT_S - * - * #1 overrides general rule of <op> XML property having highest - * precedence. + g_hash_table_remove(meta, XML_LRM_ATTR_INTERVAL); + } + + /* Timeout order of precedence (highest to lowest): + * 1. pcmk_monitor_timeout resource parameter (only for starts and probes + * when rsc has pcmk_ra_cap_fence_params; this gets used for recurring + * monitors via the executor instead) + * 2. timeout configured in <op> (with <op timeout> taking precedence over + * <op> <meta_attributes>) + * 3. timeout configured in <op_defaults> <meta_attributes> + * 4. PCMK_DEFAULT_ACTION_TIMEOUT_MS */ + + // Check for pcmk_monitor_timeout if (pcmk_is_set(pcmk_get_ra_caps(rsc_rule_data.standard), pcmk_ra_cap_fence_params) - && (pcmk__str_eq(action->task, RSC_START, pcmk__str_casei) - || is_probe)) { - - GHashTable *params = pe_rsc_params(action->rsc, action->node, data_set); + && (pcmk__str_eq(action_name, PCMK_ACTION_START, pcmk__str_none) + || pcmk_is_probe(action_name, interval_ms))) { + + GHashTable *params = pe_rsc_params(rsc, node, rsc->cluster); + + timeout_spec = g_hash_table_lookup(params, "pcmk_monitor_timeout"); + if (timeout_spec != NULL) { + pe_rsc_trace(rsc, + "Setting timeout for %s %s to " + "pcmk_monitor_timeout (%s)", + rsc->id, action_name, timeout_spec); + name = strdup(XML_ATTR_TIMEOUT); + value = strdup(timeout_spec); + CRM_ASSERT((name != NULL) && (value != NULL)); + g_hash_table_insert(meta, name, value); + } + } - value = g_hash_table_lookup(params, "pcmk_monitor_timeout"); + // Normalize timeout to positive milliseconds + name = strdup(XML_ATTR_TIMEOUT); + CRM_ASSERT(name != NULL); + timeout_spec = g_hash_table_lookup(meta, XML_ATTR_TIMEOUT); + g_hash_table_insert(meta, name, pcmk__itoa(unpack_timeout(timeout_spec))); + + // Ensure on-fail has a valid value + validate_on_fail(rsc, action_name, action_config, meta); + + // Normalize start-delay + str = g_hash_table_lookup(meta, XML_OP_ATTR_START_DELAY); + if (str != NULL) { + unpack_start_delay(str, meta); + } else { + long long start_delay = 0; - if (value) { - crm_trace("\t%s: Setting timeout to pcmk_monitor_timeout '%s', " - "overriding default", action->uuid, value); - g_hash_table_replace(action->meta, strdup(XML_ATTR_TIMEOUT), - strdup(value)); + str = g_hash_table_lookup(meta, XML_OP_ATTR_ORIGIN); + if (unpack_interval_origin(str, action_config, interval_ms, + rsc->cluster->now, &start_delay)) { + name = strdup(XML_OP_ATTR_START_DELAY); + CRM_ASSERT(name != NULL); + g_hash_table_insert(meta, name, + crm_strdup_printf("%lld", start_delay)); } } + return meta; +} - // Normalize timeout to positive milliseconds - value = g_hash_table_lookup(action->meta, XML_ATTR_TIMEOUT); - timeout_ms = unpack_timeout(value); - g_hash_table_replace(action->meta, strdup(XML_ATTR_TIMEOUT), - pcmk__itoa(timeout_ms)); +/*! + * \internal + * \brief Determine an action's quorum and fencing dependency + * + * \param[in] rsc Resource that action is for + * \param[in] action_name Name of action being unpacked + * + * \return Quorum and fencing dependency appropriate to action + */ +enum rsc_start_requirement +pcmk__action_requires(const pcmk_resource_t *rsc, const char *action_name) +{ + const char *value = NULL; + enum rsc_start_requirement requires = pcmk_requires_nothing; + + CRM_CHECK((rsc != NULL) && (action_name != NULL), return requires); - if (!pcmk__strcase_any_of(action->task, RSC_START, RSC_PROMOTE, NULL)) { - action->needs = rsc_req_nothing; + if (!pcmk__strcase_any_of(action_name, PCMK_ACTION_START, + PCMK_ACTION_PROMOTE, NULL)) { value = "nothing (not start or promote)"; - } else if (pcmk_is_set(action->rsc->flags, pe_rsc_needs_fencing)) { - action->needs = rsc_req_stonith; + } else if (pcmk_is_set(rsc->flags, pcmk_rsc_needs_fencing)) { + requires = pcmk_requires_fencing; value = "fencing"; - } else if (pcmk_is_set(action->rsc->flags, pe_rsc_needs_quorum)) { - action->needs = rsc_req_quorum; + } else if (pcmk_is_set(rsc->flags, pcmk_rsc_needs_quorum)) { + requires = pcmk_requires_quorum; value = "quorum"; } else { - action->needs = rsc_req_nothing; value = "nothing"; } - pe_rsc_trace(action->rsc, "%s requires %s", action->uuid, value); + pe_rsc_trace(rsc, "%s of %s requires %s", action_name, rsc->id, value); + return requires; +} - value = unpack_operation_on_fail(action); +/*! + * \internal + * \brief Parse action failure response from a user-provided string + * + * \param[in] rsc Resource that action is for + * \param[in] action_name Name of action + * \param[in] interval_ms Action interval (in milliseconds) + * \param[in] value User-provided configuration value for on-fail + * + * \return Action failure response parsed from \p text + */ +enum action_fail_response +pcmk__parse_on_fail(const pcmk_resource_t *rsc, const char *action_name, + guint interval_ms, const char *value) +{ + const char *desc = NULL; + bool needs_remote_reset = false; + enum action_fail_response on_fail = pcmk_on_fail_ignore; if (value == NULL) { + // Use default } else if (pcmk__str_eq(value, "block", pcmk__str_casei)) { - action->on_fail = action_fail_block; - g_hash_table_insert(action->meta, strdup(XML_OP_ATTR_ON_FAIL), strdup("block")); - value = "block"; // The above could destroy the original string + on_fail = pcmk_on_fail_block; + desc = "block"; } else if (pcmk__str_eq(value, "fence", pcmk__str_casei)) { - action->on_fail = action_fail_fence; - value = "node fencing"; - - if (!pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)) { + if (pcmk_is_set(rsc->cluster->flags, pcmk_sched_fencing_enabled)) { + on_fail = pcmk_on_fail_fence_node; + desc = "node fencing"; + } else { pcmk__config_err("Resetting '" XML_OP_ATTR_ON_FAIL "' for " - "operation '%s' to 'stop' because 'fence' is not " - "valid when fencing is disabled", action->uuid); - action->on_fail = action_fail_stop; - action->fail_role = RSC_ROLE_STOPPED; - value = "stop resource"; + "%s of %s to 'stop' because 'fence' is not " + "valid when fencing is disabled", + action_name, rsc->id); + on_fail = pcmk_on_fail_stop; + desc = "stop resource"; } } else if (pcmk__str_eq(value, "standby", pcmk__str_casei)) { - action->on_fail = action_fail_standby; - value = "node standby"; + on_fail = pcmk_on_fail_standby_node; + desc = "node standby"; } else if (pcmk__strcase_any_of(value, "ignore", PCMK__VALUE_NOTHING, NULL)) { - action->on_fail = action_fail_ignore; - value = "ignore"; + desc = "ignore"; } else if (pcmk__str_eq(value, "migrate", pcmk__str_casei)) { - action->on_fail = action_fail_migrate; - value = "force migration"; + on_fail = pcmk_on_fail_ban; + desc = "force migration"; } else if (pcmk__str_eq(value, "stop", pcmk__str_casei)) { - action->on_fail = action_fail_stop; - action->fail_role = RSC_ROLE_STOPPED; - value = "stop resource"; + on_fail = pcmk_on_fail_stop; + desc = "stop resource"; } else if (pcmk__str_eq(value, "restart", pcmk__str_casei)) { - action->on_fail = action_fail_recover; - value = "restart (and possibly migrate)"; + on_fail = pcmk_on_fail_restart; + desc = "restart (and possibly migrate)"; } else if (pcmk__str_eq(value, "restart-container", pcmk__str_casei)) { - if (container) { - action->on_fail = action_fail_restart_container; - value = "restart container (and possibly migrate)"; - + if (rsc->container == NULL) { + pe_rsc_debug(rsc, + "Using default " XML_OP_ATTR_ON_FAIL + " for %s of %s because it does not have a container", + action_name, rsc->id); } else { - value = NULL; + on_fail = pcmk_on_fail_restart_container; + desc = "restart container (and possibly migrate)"; } } else if (pcmk__str_eq(value, "demote", pcmk__str_casei)) { - action->on_fail = action_fail_demote; - value = "demote instance"; + on_fail = pcmk_on_fail_demote; + desc = "demote instance"; } else { - pe_err("Resource %s: Unknown failure type (%s)", action->rsc->id, value); - value = NULL; + pcmk__config_err("Using default '" XML_OP_ATTR_ON_FAIL "' for " + "%s of %s because '%s' is not valid", + action_name, rsc->id, value); } - /* defaults */ - if (value == NULL && container) { - action->on_fail = action_fail_restart_container; - value = "restart container (and possibly migrate) (default)"; + /* Remote node connections are handled specially. Failures that result + * in dropping an active connection must result in fencing. The only + * failures that don't are probes and starts. The user can explicitly set + * on-fail="fence" to fence after start failures. + */ + if (pe__resource_is_remote_conn(rsc) + && !pcmk_is_probe(action_name, interval_ms) + && !pcmk__str_eq(action_name, PCMK_ACTION_START, pcmk__str_none)) { + needs_remote_reset = true; + if (!pcmk_is_set(rsc->flags, pcmk_rsc_managed)) { + desc = NULL; // Force default for unmanaged connections + } + } - /* For remote nodes, ensure that any failure that results in dropping an - * active connection to the node results in fencing of the node. - * - * There are only two action failures that don't result in fencing. - * 1. probes - probe failures are expected. - * 2. start - a start failure indicates that an active connection does not already - * exist. The user can set op on-fail=fence if they really want to fence start - * failures. */ - } else if (((value == NULL) || !pcmk_is_set(action->rsc->flags, pe_rsc_managed)) - && pe__resource_is_remote_conn(action->rsc, data_set) - && !(pcmk__str_eq(action->task, CRMD_ACTION_STATUS, pcmk__str_casei) - && (interval_ms == 0)) - && !pcmk__str_eq(action->task, CRMD_ACTION_START, pcmk__str_casei)) { - - if (!pcmk_is_set(action->rsc->flags, pe_rsc_managed)) { - action->on_fail = action_fail_stop; - action->fail_role = RSC_ROLE_STOPPED; - value = "stop unmanaged remote node (enforcing default)"; + if (desc != NULL) { + // Explicit value used, default not needed - } else { - if (pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)) { - value = "fence remote node (default)"; - } else { - value = "recover remote node connection (default)"; - } + } else if (rsc->container != NULL) { + on_fail = pcmk_on_fail_restart_container; + desc = "restart container (and possibly migrate) (default)"; - if (action->rsc->remote_reconnect_ms) { - action->fail_role = RSC_ROLE_STOPPED; + } else if (needs_remote_reset) { + if (pcmk_is_set(rsc->flags, pcmk_rsc_managed)) { + if (pcmk_is_set(rsc->cluster->flags, + pcmk_sched_fencing_enabled)) { + desc = "fence remote node (default)"; + } else { + desc = "recover remote node connection (default)"; } - action->on_fail = action_fail_reset_remote; + on_fail = pcmk_on_fail_reset_remote; + } else { + on_fail = pcmk_on_fail_stop; + desc = "stop unmanaged remote node (enforcing default)"; } - } else if (value == NULL && pcmk__str_eq(action->task, CRMD_ACTION_STOP, pcmk__str_casei)) { - if (pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)) { - action->on_fail = action_fail_fence; - value = "resource fence (default)"; - + } else if (pcmk__str_eq(action_name, PCMK_ACTION_STOP, pcmk__str_none)) { + if (pcmk_is_set(rsc->cluster->flags, pcmk_sched_fencing_enabled)) { + on_fail = pcmk_on_fail_fence_node; + desc = "resource fence (default)"; } else { - action->on_fail = action_fail_block; - value = "resource block (default)"; + on_fail = pcmk_on_fail_block; + desc = "resource block (default)"; } - } else if (value == NULL) { - action->on_fail = action_fail_recover; - value = "restart (and possibly migrate) (default)"; + } else { + on_fail = pcmk_on_fail_restart; + desc = "restart (and possibly migrate) (default)"; } - pe_rsc_trace(action->rsc, "%s failure handling: %s", - action->uuid, value); + pe_rsc_trace(rsc, "Failure handling for %s-interval %s of %s: %s", + pcmk__readable_interval(interval_ms), action_name, + rsc->id, desc); + return on_fail; +} - value = NULL; - if (xml_obj != NULL) { - value = g_hash_table_lookup(action->meta, "role_after_failure"); - if (value) { - pe_warn_once(pe_wo_role_after, - "Support for role_after_failure is deprecated and will be removed in a future release"); - } +/*! + * \internal + * \brief Determine a resource's role after failure of an action + * + * \param[in] rsc Resource that action is for + * \param[in] action_name Action name + * \param[in] on_fail Failure handling for action + * \param[in] meta Unpacked action meta-attributes + * + * \return Resource role that results from failure of action + */ +enum rsc_role_e +pcmk__role_after_failure(const pcmk_resource_t *rsc, const char *action_name, + enum action_fail_response on_fail, GHashTable *meta) +{ + const char *value = NULL; + enum rsc_role_e role = pcmk_role_unknown; + + // Set default for role after failure specially in certain circumstances + switch (on_fail) { + case pcmk_on_fail_stop: + role = pcmk_role_stopped; + break; + + case pcmk_on_fail_reset_remote: + if (rsc->remote_reconnect_ms != 0) { + role = pcmk_role_stopped; + } + break; + + default: + break; } - if (value != NULL && action->fail_role == RSC_ROLE_UNKNOWN) { - action->fail_role = text2role(value); + + // @COMPAT Check for explicitly configured role (deprecated) + value = g_hash_table_lookup(meta, "role_after_failure"); + if (value != NULL) { + pe_warn_once(pcmk__wo_role_after, + "Support for role_after_failure is deprecated " + "and will be removed in a future release"); + if (role == pcmk_role_unknown) { + role = text2role(value); + } } - /* defaults */ - if (action->fail_role == RSC_ROLE_UNKNOWN) { - if (pcmk__str_eq(action->task, CRMD_ACTION_PROMOTE, pcmk__str_casei)) { - action->fail_role = RSC_ROLE_UNPROMOTED; + + if (role == pcmk_role_unknown) { + // Use default + if (pcmk__str_eq(action_name, PCMK_ACTION_PROMOTE, pcmk__str_none)) { + role = pcmk_role_unpromoted; } else { - action->fail_role = RSC_ROLE_STARTED; + role = pcmk_role_started; } } - pe_rsc_trace(action->rsc, "%s failure results in: %s", - action->uuid, role2text(action->fail_role)); + pe_rsc_trace(rsc, "Role after %s %s failure is: %s", + rsc->id, action_name, role2text(role)); + return role; +} - value = g_hash_table_lookup(action->meta, XML_OP_ATTR_START_DELAY); - if (value) { - unpack_start_delay(value, action->meta); - } else { - long long start_delay = 0; +/*! + * \internal + * \brief Unpack action configuration + * + * Unpack a resource action's meta-attributes (normalizing the interval, + * timeout, and start delay values as integer milliseconds), requirements, and + * failure policy from its CIB XML configuration (including defaults). + * + * \param[in,out] action Resource action to unpack into + * \param[in] xml_obj Action configuration XML (NULL for defaults only) + * \param[in] interval_ms How frequently to perform the operation + */ +static void +unpack_operation(pcmk_action_t *action, const xmlNode *xml_obj, + guint interval_ms) +{ + const char *value = NULL; - value = g_hash_table_lookup(action->meta, XML_OP_ATTR_ORIGIN); - if (unpack_interval_origin(value, xml_obj, interval_ms, data_set->now, - &start_delay)) { - g_hash_table_replace(action->meta, strdup(XML_OP_ATTR_START_DELAY), - crm_strdup_printf("%lld", start_delay)); - } - } + action->meta = pcmk__unpack_action_meta(action->rsc, action->node, + action->task, interval_ms, xml_obj); + action->needs = pcmk__action_requires(action->rsc, action->task); + + value = g_hash_table_lookup(action->meta, XML_OP_ATTR_ON_FAIL); + action->on_fail = pcmk__parse_on_fail(action->rsc, action->task, + interval_ms, value); + + action->fail_role = pcmk__role_after_failure(action->rsc, action->task, + action->on_fail, action->meta); } /*! @@ -929,31 +1105,26 @@ unpack_operation(pe_action_t *action, const xmlNode *xml_obj, * \param[in] task Action name (must be non-NULL) * \param[in] on_node Node that action is on (if any) * \param[in] optional Whether action should be considered optional - * \param[in] save_action Whether action should be recorded in transition graph - * \param[in,out] data_set Cluster working set + * \param[in,out] scheduler Scheduler data * - * \return Action object corresponding to arguments - * \note This function takes ownership of (and might free) \p key. If - * \p save_action is true, \p data_set will own the returned action, - * otherwise it is the caller's responsibility to free the return value - * with pe_free_action(). + * \return Action object corresponding to arguments (guaranteed not to be + * \c NULL) + * \note This function takes ownership of (and might free) \p key, and + * \p scheduler takes ownership of the returned action (the caller should + * not free it). */ -pe_action_t * -custom_action(pe_resource_t *rsc, char *key, const char *task, - const pe_node_t *on_node, gboolean optional, gboolean save_action, - pe_working_set_t *data_set) +pcmk_action_t * +custom_action(pcmk_resource_t *rsc, char *key, const char *task, + const pcmk_node_t *on_node, gboolean optional, + pcmk_scheduler_t *scheduler) { - pe_action_t *action = NULL; + pcmk_action_t *action = NULL; - CRM_ASSERT((key != NULL) && (task != NULL) && (data_set != NULL)); - - if (save_action) { - action = find_existing_action(key, rsc, on_node, data_set); - } + CRM_ASSERT((key != NULL) && (task != NULL) && (scheduler != NULL)); + action = find_existing_action(key, rsc, on_node, scheduler); if (action == NULL) { - action = new_action(key, task, rsc, on_node, optional, save_action, - data_set); + action = new_action(key, task, rsc, on_node, optional, scheduler); } else { free(key); } @@ -961,28 +1132,38 @@ custom_action(pe_resource_t *rsc, char *key, const char *task, update_action_optional(action, optional); if (rsc != NULL) { - if (action->node != NULL) { - unpack_action_node_attributes(action, data_set); - } + if ((action->node != NULL) && (action->op_entry != NULL) + && !pcmk_is_set(action->flags, pcmk_action_attrs_evaluated)) { - update_resource_action_runnable(action, save_action, data_set); + GHashTable *attrs = action->node->details->attrs; - if (save_action) { - update_resource_flags_for_action(rsc, action); + if (action->extra != NULL) { + g_hash_table_destroy(action->extra); + } + action->extra = pcmk__unpack_action_rsc_params(action->op_entry, + attrs, scheduler); + pe__set_action_flags(action, pcmk_action_attrs_evaluated); } + + update_resource_action_runnable(action, scheduler); + update_resource_flags_for_action(rsc, action); + } + + if (action->extra == NULL) { + action->extra = pcmk__strkey_table(free, free); } return action; } -pe_action_t * -get_pseudo_op(const char *name, pe_working_set_t * data_set) +pcmk_action_t * +get_pseudo_op(const char *name, pcmk_scheduler_t *scheduler) { - pe_action_t *op = lookup_singleton(data_set, name); + pcmk_action_t *op = lookup_singleton(scheduler, name); if (op == NULL) { - op = custom_action(NULL, strdup(name), name, NULL, TRUE, TRUE, data_set); - pe__set_action_flags(op, pe_action_pseudo|pe_action_runnable); + op = custom_action(NULL, strdup(name), name, NULL, TRUE, scheduler); + pe__set_action_flags(op, pcmk_action_pseudo|pcmk_action_runnable); } return op; } @@ -991,15 +1172,15 @@ static GList * find_unfencing_devices(GList *candidates, GList *matches) { for (GList *gIter = candidates; gIter != NULL; gIter = gIter->next) { - pe_resource_t *candidate = gIter->data; + pcmk_resource_t *candidate = gIter->data; if (candidate->children != NULL) { matches = find_unfencing_devices(candidate->children, matches); - } else if (!pcmk_is_set(candidate->flags, pe_rsc_fence_device)) { + } else if (!pcmk_is_set(candidate->flags, pcmk_rsc_fence_device)) { continue; - } else if (pcmk_is_set(candidate->flags, pe_rsc_needs_unfencing)) { + } else if (pcmk_is_set(candidate->flags, pcmk_rsc_needs_unfencing)) { matches = g_list_prepend(matches, candidate); } else if (pcmk__str_eq(g_hash_table_lookup(candidate->meta, @@ -1013,8 +1194,8 @@ find_unfencing_devices(GList *candidates, GList *matches) } static int -node_priority_fencing_delay(const pe_node_t *node, - const pe_working_set_t *data_set) +node_priority_fencing_delay(const pcmk_node_t *node, + const pcmk_scheduler_t *scheduler) { int member_count = 0; int online_count = 0; @@ -1023,13 +1204,13 @@ node_priority_fencing_delay(const pe_node_t *node, GList *gIter = NULL; // `priority-fencing-delay` is disabled - if (data_set->priority_fencing_delay <= 0) { + if (scheduler->priority_fencing_delay <= 0) { return 0; } /* No need to request a delay if the fencing target is not a normal cluster * member, for example if it's a remote node or a guest node. */ - if (node->details->type != node_member) { + if (node->details->type != pcmk_node_variant_cluster) { return 0; } @@ -1038,10 +1219,10 @@ node_priority_fencing_delay(const pe_node_t *node, return 0; } - for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) { - pe_node_t *n = gIter->data; + for (gIter = scheduler->nodes; gIter != NULL; gIter = gIter->next) { + pcmk_node_t *n = gIter->data; - if (n->details->type != node_member) { + if (n->details->type != pcmk_node_variant_cluster) { continue; } @@ -1077,54 +1258,58 @@ node_priority_fencing_delay(const pe_node_t *node, return 0; } - return data_set->priority_fencing_delay; + return scheduler->priority_fencing_delay; } -pe_action_t * -pe_fence_op(pe_node_t *node, const char *op, bool optional, - const char *reason, bool priority_delay, pe_working_set_t *data_set) +pcmk_action_t * +pe_fence_op(pcmk_node_t *node, const char *op, bool optional, + const char *reason, bool priority_delay, + pcmk_scheduler_t *scheduler) { char *op_key = NULL; - pe_action_t *stonith_op = NULL; + pcmk_action_t *stonith_op = NULL; if(op == NULL) { - op = data_set->stonith_action; + op = scheduler->stonith_action; } - op_key = crm_strdup_printf("%s-%s-%s", CRM_OP_FENCE, node->details->uname, op); + op_key = crm_strdup_printf("%s-%s-%s", + PCMK_ACTION_STONITH, node->details->uname, op); - stonith_op = lookup_singleton(data_set, op_key); + stonith_op = lookup_singleton(scheduler, op_key); if(stonith_op == NULL) { - stonith_op = custom_action(NULL, op_key, CRM_OP_FENCE, node, TRUE, TRUE, data_set); + stonith_op = custom_action(NULL, op_key, PCMK_ACTION_STONITH, node, + TRUE, scheduler); add_hash_param(stonith_op->meta, XML_LRM_ATTR_TARGET, node->details->uname); add_hash_param(stonith_op->meta, XML_LRM_ATTR_TARGET_UUID, node->details->id); add_hash_param(stonith_op->meta, "stonith_action", op); - if (pcmk_is_set(data_set->flags, pe_flag_enable_unfencing)) { + if (pcmk_is_set(scheduler->flags, pcmk_sched_enable_unfencing)) { /* Extra work to detect device changes */ GString *digests_all = g_string_sized_new(1024); GString *digests_secure = g_string_sized_new(1024); - GList *matches = find_unfencing_devices(data_set->resources, NULL); + GList *matches = find_unfencing_devices(scheduler->resources, NULL); char *key = NULL; char *value = NULL; for (GList *gIter = matches; gIter != NULL; gIter = gIter->next) { - pe_resource_t *match = gIter->data; + pcmk_resource_t *match = gIter->data; const char *agent = g_hash_table_lookup(match->meta, XML_ATTR_TYPE); op_digest_cache_t *data = NULL; - data = pe__compare_fencing_digest(match, agent, node, data_set); - if(data->rc == RSC_DIGEST_ALL) { + data = pe__compare_fencing_digest(match, agent, node, + scheduler); + if (data->rc == pcmk__digest_mismatch) { optional = FALSE; crm_notice("Unfencing node %s because the definition of " "%s changed", pe__node_name(node), match->id); - if (!pcmk__is_daemon && data_set->priv != NULL) { - pcmk__output_t *out = data_set->priv; + if (!pcmk__is_daemon && scheduler->priv != NULL) { + pcmk__output_t *out = scheduler->priv; out->info(out, "notice: Unfencing node %s because the " @@ -1157,7 +1342,7 @@ pe_fence_op(pe_node_t *node, const char *op, bool optional, free(op_key); } - if (data_set->priority_fencing_delay > 0 + if (scheduler->priority_fencing_delay > 0 /* It's a suitable case where `priority-fencing-delay` applies. * At least add `priority-fencing-delay` field as an indicator. */ @@ -1174,15 +1359,16 @@ pe_fence_op(pe_node_t *node, const char *op, bool optional, * the targeting node. So that it takes precedence over any possible * `pcmk_delay_base/max`. */ - char *delay_s = pcmk__itoa(node_priority_fencing_delay(node, data_set)); + char *delay_s = pcmk__itoa(node_priority_fencing_delay(node, + scheduler)); g_hash_table_insert(stonith_op->meta, strdup(XML_CONFIG_ATTR_PRIORITY_FENCING_DELAY), delay_s); } - if(optional == FALSE && pe_can_fence(data_set, node)) { - pe__clear_action_flags(stonith_op, pe_action_optional); + if(optional == FALSE && pe_can_fence(scheduler, node)) { + pe__clear_action_flags(stonith_op, pcmk_action_optional); pe_action_set_reason(stonith_op, reason, false); } else if(reason && stonith_op->reason == NULL) { @@ -1193,13 +1379,13 @@ pe_fence_op(pe_node_t *node, const char *op, bool optional, } void -pe_free_action(pe_action_t * action) +pe_free_action(pcmk_action_t *action) { if (action == NULL) { return; } - g_list_free_full(action->actions_before, free); /* pe_action_wrapper_t* */ - g_list_free_full(action->actions_after, free); /* pe_action_wrapper_t* */ + g_list_free_full(action->actions_before, free); + g_list_free_full(action->actions_after, free); if (action->extra) { g_hash_table_destroy(action->extra); } @@ -1215,7 +1401,8 @@ pe_free_action(pe_action_t * action) } int -pe_get_configured_timeout(pe_resource_t *rsc, const char *action, pe_working_set_t *data_set) +pe_get_configured_timeout(pcmk_resource_t *rsc, const char *action, + pcmk_scheduler_t *scheduler) { xmlNode *child = NULL; GHashTable *action_meta = NULL; @@ -1224,8 +1411,8 @@ pe_get_configured_timeout(pe_resource_t *rsc, const char *action, pe_working_set pe_rule_eval_data_t rule_data = { .node_hash = NULL, - .role = RSC_ROLE_UNKNOWN, - .now = data_set->now, + .role = pcmk_role_unknown, + .now = scheduler->now, .match_data = NULL, .rsc_data = NULL, .op_data = NULL @@ -1240,10 +1427,11 @@ pe_get_configured_timeout(pe_resource_t *rsc, const char *action, pe_working_set } } - if (timeout_spec == NULL && data_set->op_defaults) { + if (timeout_spec == NULL && scheduler->op_defaults) { action_meta = pcmk__strkey_table(free, free); - pe__unpack_dataset_nvpairs(data_set->op_defaults, XML_TAG_META_SETS, - &rule_data, action_meta, NULL, FALSE, data_set); + pe__unpack_dataset_nvpairs(scheduler->op_defaults, XML_TAG_META_SETS, + &rule_data, action_meta, NULL, FALSE, + scheduler); timeout_spec = g_hash_table_lookup(action_meta, XML_ATTR_TIMEOUT); } @@ -1252,7 +1440,7 @@ pe_get_configured_timeout(pe_resource_t *rsc, const char *action, pe_working_set timeout_ms = crm_get_msec(timeout_spec); if (timeout_ms < 0) { - timeout_ms = crm_get_msec(CRM_DEFAULT_OP_TIMEOUT_S); + timeout_ms = PCMK_DEFAULT_ACTION_TIMEOUT_MS; } if (action_meta != NULL) { @@ -1262,16 +1450,16 @@ pe_get_configured_timeout(pe_resource_t *rsc, const char *action, pe_working_set } enum action_tasks -get_complex_task(const pe_resource_t *rsc, const char *name) +get_complex_task(const pcmk_resource_t *rsc, const char *name) { enum action_tasks task = text2task(name); - if ((rsc != NULL) && (rsc->variant == pe_native)) { + if ((rsc != NULL) && (rsc->variant == pcmk_rsc_variant_primitive)) { switch (task) { - case stopped_rsc: - case started_rsc: - case action_demoted: - case action_promoted: + case pcmk_action_stopped: + case pcmk_action_started: + case pcmk_action_demoted: + case pcmk_action_promoted: crm_trace("Folding %s back into its atomic counterpart for %s", name, rsc->id); --task; @@ -1294,14 +1482,14 @@ get_complex_task(const pe_resource_t *rsc, const char *name) * * \return First action in list that matches criteria, or NULL if none */ -pe_action_t * +pcmk_action_t * find_first_action(const GList *input, const char *uuid, const char *task, - const pe_node_t *on_node) + const pcmk_node_t *on_node) { CRM_CHECK(uuid || task, return NULL); for (const GList *gIter = input; gIter != NULL; gIter = gIter->next) { - pe_action_t *action = (pe_action_t *) gIter->data; + pcmk_action_t *action = (pcmk_action_t *) gIter->data; if (uuid != NULL && !pcmk__str_eq(uuid, action->uuid, pcmk__str_casei)) { continue; @@ -1324,7 +1512,7 @@ find_first_action(const GList *input, const char *uuid, const char *task, } GList * -find_actions(GList *input, const char *key, const pe_node_t *on_node) +find_actions(GList *input, const char *key, const pcmk_node_t *on_node) { GList *gIter = input; GList *result = NULL; @@ -1332,7 +1520,7 @@ find_actions(GList *input, const char *key, const pe_node_t *on_node) CRM_CHECK(key != NULL, return NULL); for (; gIter != NULL; gIter = gIter->next) { - pe_action_t *action = (pe_action_t *) gIter->data; + pcmk_action_t *action = (pcmk_action_t *) gIter->data; if (!pcmk__str_eq(key, action->uuid, pcmk__str_casei)) { continue; @@ -1358,7 +1546,7 @@ find_actions(GList *input, const char *key, const pe_node_t *on_node) } GList * -find_actions_exact(GList *input, const char *key, const pe_node_t *on_node) +find_actions_exact(GList *input, const char *key, const pcmk_node_t *on_node) { GList *result = NULL; @@ -1369,7 +1557,7 @@ find_actions_exact(GList *input, const char *key, const pe_node_t *on_node) } for (GList *gIter = input; gIter != NULL; gIter = gIter->next) { - pe_action_t *action = (pe_action_t *) gIter->data; + pcmk_action_t *action = (pcmk_action_t *) gIter->data; if ((action->node != NULL) && pcmk__str_eq(key, action->uuid, pcmk__str_casei) @@ -1397,7 +1585,7 @@ find_actions_exact(GList *input, const char *key, const pe_node_t *on_node) * without a node will be assigned to node. */ GList * -pe__resource_actions(const pe_resource_t *rsc, const pe_node_t *node, +pe__resource_actions(const pcmk_resource_t *rsc, const pcmk_node_t *node, const char *task, bool require_node) { GList *result = NULL; @@ -1423,16 +1611,18 @@ pe__resource_actions(const pe_resource_t *rsc, const pe_node_t *node, * \note It is the caller's responsibility to free() the result. */ char * -pe__action2reason(const pe_action_t *action, enum pe_action_flags flag) +pe__action2reason(const pcmk_action_t *action, enum pe_action_flags flag) { const char *change = NULL; switch (flag) { - case pe_action_runnable: - case pe_action_migrate_runnable: + case pcmk_action_runnable: change = "unrunnable"; break; - case pe_action_optional: + case pcmk_action_migratable: + change = "unmigrateable"; + break; + case pcmk_action_optional: change = "required"; break; default: @@ -1446,7 +1636,8 @@ pe__action2reason(const pe_action_t *action, enum pe_action_flags flag) action->task); } -void pe_action_set_reason(pe_action_t *action, const char *reason, bool overwrite) +void pe_action_set_reason(pcmk_action_t *action, const char *reason, + bool overwrite) { if (action->reason != NULL && overwrite) { pe_rsc_trace(action->rsc, "Changing %s reason from '%s' to '%s'", @@ -1468,20 +1659,14 @@ void pe_action_set_reason(pe_action_t *action, const char *reason, bool overwrit * * \param[in,out] rsc Resource to clear * \param[in] node Node to clear history on - * \param[in,out] data_set Cluster working set - * - * \return New action to clear resource history */ -pe_action_t * -pe__clear_resource_history(pe_resource_t *rsc, const pe_node_t *node, - pe_working_set_t *data_set) +void +pe__clear_resource_history(pcmk_resource_t *rsc, const pcmk_node_t *node) { - char *key = NULL; + CRM_ASSERT((rsc != NULL) && (node != NULL)); - CRM_ASSERT(rsc && node); - key = pcmk__op_key(rsc->id, CRM_OP_LRM_DELETE, 0); - return custom_action(rsc, key, CRM_OP_LRM_DELETE, node, FALSE, TRUE, - data_set); + custom_action(rsc, pcmk__op_key(rsc->id, PCMK_ACTION_LRM_DELETE, 0), + PCMK_ACTION_LRM_DELETE, node, FALSE, rsc->cluster); } #define sort_return(an_int, why) do { \ @@ -1646,19 +1831,19 @@ sort_op_by_callid(gconstpointer a, gconstpointer b) * * \return New action object corresponding to arguments */ -pe_action_t * -pe__new_rsc_pseudo_action(pe_resource_t *rsc, const char *task, bool optional, +pcmk_action_t * +pe__new_rsc_pseudo_action(pcmk_resource_t *rsc, const char *task, bool optional, bool runnable) { - pe_action_t *action = NULL; + pcmk_action_t *action = NULL; CRM_ASSERT((rsc != NULL) && (task != NULL)); action = custom_action(rsc, pcmk__op_key(rsc->id, task, 0), task, NULL, - optional, TRUE, rsc->cluster); - pe__set_action_flags(action, pe_action_pseudo); + optional, rsc->cluster); + pe__set_action_flags(action, pcmk_action_pseudo); if (runnable) { - pe__set_action_flags(action, pe_action_runnable); + pe__set_action_flags(action, pcmk_action_runnable); } return action; } @@ -1673,7 +1858,7 @@ pe__new_rsc_pseudo_action(pe_resource_t *rsc, const char *task, bool optional, * \note This is more efficient than calling add_hash_param(). */ void -pe__add_action_expected_result(pe_action_t *action, int expected_result) +pe__add_action_expected_result(pcmk_action_t *action, int expected_result) { char *name = NULL; |