task              221 crmd/callbacks.c             const char *task = crm_element_value(down->xml, XML_LRM_ATTR_TASK);
task              223 crmd/callbacks.c             if (safe_str_eq(task, CRM_OP_FENCE)) {
task              229 crmd/callbacks.c             } else if ((alive == FALSE) && safe_str_eq(task, CRM_OP_SHUTDOWN)) {
task              231 crmd/callbacks.c                            task, node->uname, down->id);
task              247 crmd/callbacks.c                           node->uname, (alive? "" : "not "), task, down->id);
task              293 crmd/lrm.c                      const char *rsc_id, lrmd_rsc_info_t *rsc, const char *task,
task              296 crmd/lrm.c         lrmd_event_data_t *op = construct_op(lrm_state, input->xml, rsc_id, task);
task               56 crmd/te_actions.c     const char *task = crm_element_value(pseudo->xml, XML_LRM_ATTR_TASK);
task               59 crmd/te_actions.c     if (safe_str_eq(task, CRM_OP_MAINTENANCE_NODES)) {
task               71 crmd/te_actions.c             cmd = create_request(task, pseudo->xml, node->uname,
task              228 crmd/te_actions.c     const char *task = NULL;
task              237 crmd/te_actions.c     task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              246 crmd/te_actions.c               crm_err("Corrupted command (id=%s) %s: no node", crm_str(id), crm_str(task));
task              250 crmd/te_actions.c              crm_str(id), crm_str(task), on_node,
task              262 crmd/te_actions.c     if (is_local && safe_str_eq(task, CRM_OP_SHUTDOWN)) {
task              272 crmd/te_actions.c     } else if (safe_str_eq(task, CRM_OP_SHUTDOWN)) {
task              277 crmd/te_actions.c     cmd = create_request(task, action->xml, router_node, CRM_SYSTEM_CRMD, CRM_SYSTEM_TENGINE, NULL);
task              299 crmd/te_actions.c                     action->id, task, on_node, action->timeout, graph->network_delay);
task              320 crmd/te_actions.c     const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              380 crmd/te_actions.c               crm_element_name(action->xml), crm_str(task), rsc_id, target);
task              417 crmd/te_actions.c     const char *task = NULL;
task              430 crmd/te_actions.c               crm_err("Corrupted command(id=%s) %s: no node", ID(action->xml), crm_str(task));
task              434 crmd/te_actions.c     task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK);
task              456 crmd/te_actions.c                task, task_uuid, (is_local? " locally" : ""), on_node,
task              504 crmd/te_actions.c                   action->id, task, task_uuid, on_node, action->timeout);
task              508 crmd/te_actions.c                     action->id, task, task_uuid, on_node, action->timeout, graph->network_delay);
task              575 crmd/te_actions.c     const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              590 crmd/te_actions.c         (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED))) {
task              610 crmd/te_actions.c     const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              636 crmd/te_actions.c         if (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
task              652 crmd/te_actions.c     const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              666 crmd/te_actions.c         (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED))) {
task              905 crmd/te_callbacks.c         const char *task = crm_element_value(timer->action->xml, XML_LRM_ATTR_TASK);
task              918 crmd/te_callbacks.c         } else if (safe_str_eq(task, RSC_CANCEL)) {
task               65 crmd/te_events.c                 const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task               67 crmd/te_events.c                 if (safe_str_eq(task, CRM_OP_FENCE)) {
task              127 crmd/te_events.c     char *task = NULL;
task              148 crmd/te_events.c     CRM_CHECK(parse_op_key(id, &rsc_id, &task, &interval),
task              150 crmd/te_events.c     CRM_CHECK(task != NULL, goto bail);
task              154 crmd/te_events.c     if ((interval > 0) || safe_str_eq(task, CRMD_ACTION_PROMOTE)
task              155 crmd/te_events.c         || safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
task              158 crmd/te_events.c     } else if (safe_str_eq(task, CRMD_ACTION_START)) {
task              165 crmd/te_events.c     } else if (safe_str_eq(task, CRMD_ACTION_STOP)) {
task              189 crmd/te_events.c                  rsc_id, on_uname, task, rc, value, now);
task              193 crmd/te_events.c             attr_name = crm_failcount_name(rsc_id, task, interval);
task              201 crmd/te_events.c         attr_name = crm_lastfailure_name(rsc_id, task, interval);
task              210 crmd/te_events.c     free(task);
task              240 crmd/te_events.c         const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK_KEY);
task              244 crmd/te_events.c                  action->id, task, uname, target_rc, rc,
task              358 crmd/te_events.c             const char *task = NULL;
task              362 crmd/te_events.c             task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              363 crmd/te_events.c             if (safe_str_neq(CRMD_ACTION_CANCEL, task)) {
task              367 crmd/te_events.c             task = crm_element_value(action->xml, XML_LRM_ATTR_TASK_KEY);
task              368 crmd/te_events.c             if (safe_str_neq(task, id)) {
task              369 crmd/te_events.c                 crm_trace("Wrong key %s for %s on %s", task, id, node);
task              130 crmd/te_utils.c     const char *task = NULL;
task              152 crmd/te_utils.c             task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              153 crmd/te_utils.c             if (task && safe_str_eq(task, CRM_OP_FENCE)) {
task               47 crmd/tengine.h extern const char *get_rsc_state(const char *task, enum op_status status);
task               34 include/crm/common/ipc.h #  define create_request(task, xml_data, host_to, sys_to, sys_from, uuid_from) create_request_adv(task, xml_data, host_to, sys_to, sys_from, uuid_from, __FUNCTION__)
task               36 include/crm/common/ipc.h xmlNode *create_request_adv(const char *task, xmlNode * xml_data, const char *host_to,
task              133 include/crm/common/util.h                            const char *task, const char *interval,
task              224 include/crm/crm.h static inline const char *crm_action_str(const char *task, int interval) {
task              225 include/crm/crm.h     if(safe_str_eq(task, RSC_STATUS) && !interval) {
task              228 include/crm/crm.h     return task;
task               31 include/crm/lrmd_alerts_internal.h                             const char *target, const char *task,
task              116 include/crm/pengine/common.h const char *task2text(enum action_tasks task);
task              117 include/crm/pengine/common.h enum action_tasks text2task(const char *task);
task              177 include/crm/pengine/internal.h extern action_t *custom_action(resource_t * rsc, char *key, const char *task, node_t * on_node,
task              229 include/crm/pengine/internal.h extern action_t *find_first_action(GListPtr input, const char *uuid, const char *task,
task              339 include/crm/pengine/status.h     char *task;
task              141 lib/common/attrd_client.c     const char *task = NULL;
task              161 lib/common/attrd_client.c             task = ATTRD_OP_UPDATE;
task              167 lib/common/attrd_client.c             task = ATTRD_OP_UPDATE;
task              171 lib/common/attrd_client.c             task = ATTRD_OP_REFRESH;
task              175 lib/common/attrd_client.c             task = ATTRD_OP_UPDATE_BOTH;
task              179 lib/common/attrd_client.c             task = ATTRD_OP_UPDATE_DELAY;
task              183 lib/common/attrd_client.c             task = ATTRD_OP_QUERY;
task              187 lib/common/attrd_client.c             task = ATTRD_OP_PEER_REMOVE;
task              200 lib/common/attrd_client.c     crm_xml_add(update, F_ATTRD_TASK, task);
task              105 lib/common/ipc.c create_request_adv(const char *task, xmlNode * msg_data,
task              111 lib/common/ipc.c     char *reference = generateReference(task, sys_from);
task              128 lib/common/ipc.c     crm_xml_add(request, F_CRM_TASK, task);
task              439 lib/common/operations.c crm_create_op_xml(xmlNode *parent, const char *prefix, const char *task,
task              444 lib/common/operations.c     CRM_CHECK(prefix && task && interval, return NULL);
task              447 lib/common/operations.c     crm_xml_set_id(xml_op, "%s-%s-%s", prefix, task, interval);
task              449 lib/common/operations.c     crm_xml_add(xml_op, "name", task);
task              468 lib/common/operations.c     const char *task = NULL;
task              479 lib/common/operations.c     task = op->op_type;
task              483 lib/common/operations.c     if (crm_str_eq(task, "reload", TRUE)) {
task              485 lib/common/operations.c             task = CRMD_ACTION_START;
task              487 lib/common/operations.c             task = CRMD_ACTION_STATUS;
task              490 lib/common/operations.c     } else if (dc_munges_migrate_ops && crm_str_eq(task, CRMD_ACTION_MIGRATE, TRUE)) {
task              493 lib/common/operations.c             task = CRMD_ACTION_STOP;
task              495 lib/common/operations.c             task = CRMD_ACTION_STATUS;
task              500 lib/common/operations.c                && crm_str_eq(task, CRMD_ACTION_MIGRATED, TRUE)) {
task              501 lib/common/operations.c         task = CRMD_ACTION_START;
task              504 lib/common/operations.c     key = generate_op_key(op->rsc_id, task, op->interval);
task              508 lib/common/operations.c     } else if (crm_str_eq(task, CRMD_ACTION_NOTIFY, TRUE)) {
task              555 lib/common/operations.c     crm_xml_add(xml_op, XML_LRM_ATTR_TASK, task);
task              293 lib/lrmd/lrmd_alerts.c                         const char *target, const char *task, const char *desc,
task              304 lib/lrmd/lrmd_alerts.c     params = alert_key2param(params, CRM_alert_task, task);
task              233 lib/pengine/common.c text2task(const char *task)
task              235 lib/pengine/common.c     if (safe_str_eq(task, CRMD_ACTION_STOP)) {
task              237 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_STOPPED)) {
task              239 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_START)) {
task              241 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_STARTED)) {
task              243 lib/pengine/common.c     } else if (safe_str_eq(task, CRM_OP_SHUTDOWN)) {
task              245 lib/pengine/common.c     } else if (safe_str_eq(task, CRM_OP_FENCE)) {
task              247 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_STATUS)) {
task              249 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_NOTIFY)) {
task              251 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_NOTIFIED)) {
task              253 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {
task              255 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
task              257 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_PROMOTED)) {
task              259 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_DEMOTED)) {
task              263 lib/pengine/common.c     if (safe_str_eq(task, CRMD_ACTION_CANCEL)) {
task              265 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_DELETE)) {
task              267 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_STATUS)) {
task              269 lib/pengine/common.c     } else if (safe_str_eq(task, CRM_OP_PROBED)) {
task              271 lib/pengine/common.c     } else if (safe_str_eq(task, CRM_OP_LRM_REFRESH)) {
task              273 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_MIGRATE)) {
task              275 lib/pengine/common.c     } else if (safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
task              277 lib/pengine/common.c     } else if (safe_str_eq(task, "fail")) {
task              279 lib/pengine/common.c     } else if (safe_str_eq(task, "stonith_up")) {
task              281 lib/pengine/common.c     } else if (safe_str_eq(task, "stonith_complete")) {
task              283 lib/pengine/common.c     } else if (safe_str_eq(task, "all_stopped")) {
task              286 lib/pengine/common.c     crm_trace("Unsupported action: %s", task);
task              293 lib/pengine/common.c task2text(enum action_tasks task)
task              297 lib/pengine/common.c     switch (task) {
task             2088 lib/pengine/unpack.c     const char *task = NULL;
task             2131 lib/pengine/unpack.c         task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK);
task             2133 lib/pengine/unpack.c         key = generate_op_key(rsc->id, task, interval);
task             2135 lib/pengine/unpack.c         custom_action(rsc, key, task, node, TRUE, TRUE, data_set);
task             2145 lib/pengine/unpack.c     const char *task = NULL;
task             2157 lib/pengine/unpack.c         task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK);
task             2160 lib/pengine/unpack.c         if (safe_str_eq(task, CRMD_ACTION_STOP)
task             2164 lib/pengine/unpack.c         } else if (safe_str_eq(task, CRMD_ACTION_START) || safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
task             2167 lib/pengine/unpack.c         } else if ((implied_monitor_start <= *stop_index) && safe_str_eq(task, CRMD_ACTION_STATUS)) {
task             2173 lib/pengine/unpack.c         } else if (safe_str_eq(task, CRMD_ACTION_PROMOTE) || safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
task             2195 lib/pengine/unpack.c     const char *task = NULL;
task             2243 lib/pengine/unpack.c         task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK);
task             2244 lib/pengine/unpack.c         if (safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
task             2504 lib/pengine/unpack.c     const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             2507 lib/pengine/unpack.c     if (safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
task             2537 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_MIGRATE)) {
task             2619 lib/pengine/unpack.c     const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             2627 lib/pengine/unpack.c     if(interval == 0 && safe_str_eq(task, CRMD_ACTION_STATUS)) {
task             2634 lib/pengine/unpack.c                  task, rsc->id, node->details->uname, services_ocf_exitcode_str(rc),
task             2641 lib/pengine/unpack.c                  task, rsc->id, node->details->uname, services_ocf_exitcode_str(rc),
task             2645 lib/pengine/unpack.c     action = custom_action(rsc, strdup(key), task, NULL, TRUE, FALSE, data_set);
task             2655 lib/pengine/unpack.c     if (safe_str_eq(task, CRMD_ACTION_STOP)) {
task             2658 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_MIGRATE) || safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
task             2661 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {
task             2664 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
task             2683 lib/pengine/unpack.c     } else if (compare_version("2.0", op_version) > 0 && safe_str_eq(task, CRMD_ACTION_START)) {
task             2741 lib/pengine/unpack.c     const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             2747 lib/pengine/unpack.c     if (interval == 0 && safe_str_eq(task, CRMD_ACTION_STATUS)) {
task             2767 lib/pengine/unpack.c                             task, rsc->id, node->details->uname);
task             2787 lib/pengine/unpack.c             } else if (safe_str_neq(task, CRMD_ACTION_STOP)) {
task             2796 lib/pengine/unpack.c                             task, rsc->id, node->details->uname);
task             2805 lib/pengine/unpack.c             } else if (safe_str_neq(task, CRMD_ACTION_STATUS)
task             2835 lib/pengine/unpack.c                && safe_str_eq(task, CRMD_ACTION_STOP)) {
task             2838 lib/pengine/unpack.c                             rsc->id, task, services_ocf_exitcode_str(rc), rc);
task             2863 lib/pengine/unpack.c     const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             2926 lib/pengine/unpack.c                ((strcmp(task, "start") == 0) || (strcmp(task, "monitor") == 0))) {
task             2956 lib/pengine/unpack.c     if(expired && interval == 0 && safe_str_eq(task, CRMD_ACTION_STATUS)) {
task             2989 lib/pengine/unpack.c get_action_on_fail(resource_t *rsc, const char *key, const char *task, pe_working_set_t * data_set) 
task             2992 lib/pengine/unpack.c     action_t *action = custom_action(rsc, strdup(key), task, NULL, TRUE, FALSE, data_set);
task             3001 lib/pengine/unpack.c update_resource_state(resource_t * rsc, node_t * node, xmlNode * xml_op, const char * task, int rc,
task             3015 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_STATUS)) {
task             3029 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_START)) {
task             3033 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_STOP)) {
task             3037 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {
task             3041 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_DEMOTE)) {
task             3045 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_MIGRATED)) {
task             3049 lib/pengine/unpack.c     } else if (safe_str_eq(task, CRMD_ACTION_MIGRATE)) {
task             3097 lib/pengine/unpack.c     const char *task = NULL;
task             3115 lib/pengine/unpack.c     task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             3123 lib/pengine/unpack.c     CRM_CHECK(task != NULL, return FALSE);
task             3127 lib/pengine/unpack.c     if (safe_str_eq(task, CRMD_ACTION_NOTIFY) ||
task             3128 lib/pengine/unpack.c         safe_str_eq(task, CRMD_ACTION_METADATA)) {
task             3138 lib/pengine/unpack.c                  task_key, task, task_id, status, rc, node->details->uname, role2text(rsc->role));
task             3156 lib/pengine/unpack.c     if (rc == PCMK_OCF_DEGRADED && safe_str_eq(task, CRMD_ACTION_STATUS)) {
task             3165 lib/pengine/unpack.c     } else if (rc == PCMK_OCF_DEGRADED_MASTER && safe_str_eq(task, CRMD_ACTION_STATUS)) {
task             3209 lib/pengine/unpack.c             if (safe_str_eq(task, CRMD_ACTION_START)) {
task             3213 lib/pengine/unpack.c             } else if (safe_str_eq(task, CRMD_ACTION_PROMOTE)) {
task             3216 lib/pengine/unpack.c             } else if (safe_str_eq(task, CRMD_ACTION_MIGRATE) && node->details->unclean) {
task             3227 lib/pengine/unpack.c                 if (safe_str_eq(task, CRMD_ACTION_STATUS) && interval == 0) {
task             3236 lib/pengine/unpack.c                     rsc->pending_task = strdup(task);
task             3242 lib/pengine/unpack.c             pe_rsc_trace(rsc, "%s/%s completed on %s", rsc->id, task, node->details->uname);
task             3243 lib/pengine/unpack.c             update_resource_state(rsc, node, xml_op, task, rc, *last_failure, on_fail, data_set);
task             3247 lib/pengine/unpack.c             failure_strategy = get_action_on_fail(rsc, task_key, task, data_set);
task             3265 lib/pengine/unpack.c             failure_strategy = get_action_on_fail(rsc, task_key, task, data_set);
task             3268 lib/pengine/unpack.c                     && safe_str_eq(task, CRMD_ACTION_STOP))) {
task             3273 lib/pengine/unpack.c                 update_resource_state(rsc, node, xml_op, task, target_rc, *last_failure, on_fail, data_set);
task             3290 lib/pengine/unpack.c                                task, services_ocf_exitcode_str(rc), rc);
task             3296 lib/pengine/unpack.c                             parent->id, task, services_ocf_exitcode_str(rc), rc);
task             3305 lib/pengine/unpack.c     pe_rsc_trace(rsc, "Resource %s after %s: role=%s, next=%s", rsc->id, task, role2text(rsc->role), role2text(rsc->next_role));
task              419 lib/pengine/utils.c custom_action(resource_t * rsc, char *key, const char *task,
task              427 lib/pengine/utils.c     CRM_CHECK(task != NULL, free(key); return NULL);
task              447 lib/pengine/utils.c                     task, rsc ? rsc->id : "<NULL>",
task              453 lib/pengine/utils.c                      action->id, task, rsc ? rsc->id : "<NULL>",
task              472 lib/pengine/utils.c         CRM_ASSERT(task != NULL);
task              473 lib/pengine/utils.c         action->task = strdup(task);
task              530 lib/pengine/utils.c         enum action_tasks a_task = text2task(action->task);
task              635 lib/pengine/utils.c     if (safe_str_eq(action->task, CRMD_ACTION_STOP) && safe_str_eq(value, "standby")) {
task              638 lib/pengine/utils.c     } else if (safe_str_eq(action->task, CRMD_ACTION_DEMOTE) && !value) {
task              809 lib/pengine/utils.c         safe_str_eq(action->task, RSC_STATUS) && interval == 0) {
task              979 lib/pengine/utils.c     if (safe_str_neq(action->task, RSC_START)
task              980 lib/pengine/utils.c         && safe_str_neq(action->task, RSC_PROMOTE)) {
task             1018 lib/pengine/utils.c     pe_rsc_trace(action->rsc, "\tAction %s requires: %s", action->task, value);
task             1091 lib/pengine/utils.c                !(safe_str_eq(action->task, CRMD_ACTION_STATUS) && interval == 0) &&
task             1092 lib/pengine/utils.c                 (safe_str_neq(action->task, CRMD_ACTION_START)))) {
task             1112 lib/pengine/utils.c     } else if (value == NULL && safe_str_eq(action->task, CRMD_ACTION_STOP)) {
task             1127 lib/pengine/utils.c     pe_rsc_trace(action->rsc, "\t%s failure handling: %s", action->task, value);
task             1138 lib/pengine/utils.c         if (safe_str_eq(action->task, CRMD_ACTION_PROMOTE)) {
task             1144 lib/pengine/utils.c     pe_rsc_trace(action->rsc, "\t%s failure results in: %s", action->task,
task             1320 lib/pengine/utils.c     free(action->task);
task             1343 lib/pengine/utils.c         } else if (safe_str_eq(CRMD_ACTION_CANCEL, action->task)) {
task             1363 lib/pengine/utils.c     enum action_tasks task = text2task(name);
task             1366 lib/pengine/utils.c         return task;
task             1369 lib/pengine/utils.c         switch (task) {
task             1375 lib/pengine/utils.c                 return task - 1;
task             1381 lib/pengine/utils.c     return task;
task             1385 lib/pengine/utils.c find_first_action(GListPtr input, const char *uuid, const char *task, node_t * on_node)
task             1389 lib/pengine/utils.c     CRM_CHECK(uuid || task, return NULL);
task             1397 lib/pengine/utils.c         } else if (task != NULL && safe_str_neq(task, action->task)) {
task             1889 lib/pengine/utils.c rsc_action_digest(resource_t * rsc, const char *task, const char *key,
task             1897 lib/pengine/utils.c         action_t *action = custom_action(rsc, strdup(key), task, node, TRUE, FALSE, data_set);
task             1989 lib/pengine/utils.c     const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             2002 lib/pengine/utils.c     key = generate_op_key(rsc->id, task, interval);
task             2003 lib/pengine/utils.c     data = rsc_action_digest(rsc, task, key, node, xml_op, data_set);
task             2339 lib/pengine/utils.c             reason_text = crm_strdup_printf("%s %s%c %s", change, reason->task, text?':':0, text?text:"");
task             2341 lib/pengine/utils.c             reason_text = crm_strdup_printf("%s %s %s%c %s", change, reason->rsc->id, reason->task, text?':':0, text?text:"NA");
task              196 lib/transition/graph.c         const char *task = NULL;
task              198 lib/transition/graph.c         task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              199 lib/transition/graph.c         CRM_CHECK(task != NULL, return FALSE);
task              201 lib/transition/graph.c         if (safe_str_eq(task, CRM_OP_FENCE)) {
task              486 mcp/pacemaker.c     const char *task = NULL;
task              495 mcp/pacemaker.c     task = crm_element_value(msg, F_CRM_TASK);
task              496 mcp/pacemaker.c     if (crm_str_eq(task, CRM_OP_QUIT, TRUE)) {
task              502 mcp/pacemaker.c     } else if (crm_str_eq(task, CRM_OP_RM_NODE_CACHE, TRUE)) {
task              829 mcp/pacemaker.c     const char *task = crm_element_value(xml, F_CRM_TASK);
task              832 mcp/pacemaker.c               (task? task : "process list"), (char*)msg);
task              834 mcp/pacemaker.c     if (task == NULL) {
task              847 mcp/pacemaker.c     } else if (crm_str_eq(task, CRM_OP_RM_NODE_CACHE, TRUE)) {
task              207 pengine/allocate.c     const char *task = NULL;
task              214 pengine/allocate.c     task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task              221 pengine/allocate.c     key = generate_op_key(rsc->id, task, interval);
task              229 pengine/allocate.c     free(cancel->task);
task              231 pengine/allocate.c     cancel->task = strdup(RSC_CANCEL);
task              232 pengine/allocate.c     cancel->cancel_task = strdup(task);
task              234 pengine/allocate.c     add_hash_param(cancel->meta, XML_LRM_ATTR_TASK, task);
task              253 pengine/allocate.c     const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task              257 pengine/allocate.c     if (safe_str_eq(task, RSC_STOP)) {
task              268 pengine/allocate.c         key = generate_op_key(rsc->id, task, interval);
task              288 pengine/allocate.c               rsc->id, task, interval, active_node->details->uname);
task              289 pengine/allocate.c     if (interval == 0 && safe_str_eq(task, RSC_STATUS)) {
task              291 pengine/allocate.c         task = RSC_START;
task              293 pengine/allocate.c     } else if (interval == 0 && safe_str_eq(task, RSC_MIGRATED)) {
task              295 pengine/allocate.c         task = RSC_START;
task              296 pengine/allocate.c     } else if (interval == 0 && safe_str_eq(task, RSC_PROMOTE)) {
task              298 pengine/allocate.c         task = RSC_START;
task              313 pengine/allocate.c                    rsc->id, task, interval, active_node->details->uname,
task              322 pengine/allocate.c         key = generate_op_key(rsc->id, task, interval);
task              324 pengine/allocate.c         required = custom_action(rsc, key, task, NULL, TRUE, TRUE, data_set);
task              337 pengine/allocate.c         key = generate_op_key(rsc->id, task, interval);
task              347 pengine/allocate.c             op = custom_action(rsc, key, task, active_node, TRUE, TRUE, data_set);
task              352 pengine/allocate.c             pe_rsc_trace(rsc, "Reloading '%s' action for resource %s", task, rsc->id);
task              365 pengine/allocate.c             required = custom_action(rsc, key, task, NULL, TRUE, TRUE, data_set);
task              384 pengine/allocate.c     const char *task = NULL;
task              446 pengine/allocate.c         task = crm_element_value(rsc_op, XML_LRM_ATTR_TASK);
task              451 pengine/allocate.c         if (interval == 0 && safe_str_eq(task, RSC_STATUS)) {
task              459 pengine/allocate.c         } else if (is_probe || safe_str_eq(task, RSC_START) || safe_str_eq(task, RSC_PROMOTE) || interval > 0
task              460 pengine/allocate.c                    || safe_str_eq(task, RSC_MIGRATED)) {
task             1591 pengine/allocate.c                   dc_down->task, dc_down->node->details->uname);
task             1598 pengine/allocate.c             if (safe_str_neq(CRM_OP_SHUTDOWN, node_stop->task)) {
task             1606 pengine/allocate.c                       dc_down->task, dc_down->node->details->uname);
task             1660 pengine/allocate.c         char *task = NULL;
task             1663 pengine/allocate.c         if (parse_op_key(original_key, &tmp, &task, &interval)) {
task             1664 pengine/allocate.c             key = generate_op_key(rsc->id, task, interval);
task             1676 pengine/allocate.c         free(task);
task             1828 pengine/allocate.c     enum action_tasks task = text2task(action->task);
task             1845 pengine/allocate.c               action->task, action->uuid,
task             1851 pengine/allocate.c     if (safe_str_eq(action->task, CRMD_ACTION_MIGRATE)
task             1852 pengine/allocate.c         || safe_str_eq(action->task, CRMD_ACTION_MIGRATE)) {
task             1856 pengine/allocate.c         task = stop_rsc;
task             1859 pengine/allocate.c     switch (task) {
task             1901 pengine/allocate.c                 if(task != no_action) {
task             1993 pengine/allocate.c     enum action_tasks task = text2task(action->task);
task             2013 pengine/allocate.c               action->task, action->uuid,
task             2017 pengine/allocate.c     if (safe_str_eq(action->task, CRMD_ACTION_MIGRATE)
task             2018 pengine/allocate.c         || safe_str_eq(action->task, CRMD_ACTION_MIGRATE)) {
task             2022 pengine/allocate.c         task = stop_rsc;
task             2025 pengine/allocate.c     switch (task) {
task             2085 pengine/allocate.c                 if(task == monitor_rsc && state == remote_state_failed) {
task             2135 pengine/allocate.c             safe_str_eq(action->task, CRM_OP_CLEAR_FAILCOUNT)) {
task             2287 pengine/allocate.c             } else if(safe_str_neq(first->task, RSC_START)) {
task             2453 pengine/allocate.c             && crm_str_eq(action->task, RSC_STOP, TRUE)
task             2486 pengine/allocate.c         char *task = NULL;
task             2502 pengine/allocate.c         if (safe_str_eq(action->task, CRM_OP_SHUTDOWN)) {
task             2503 pengine/allocate.c             task = strdup("Shutdown");
task             2504 pengine/allocate.c         } else if (safe_str_eq(action->task, CRM_OP_FENCE)) {
task             2506 pengine/allocate.c             task = crm_strdup_printf("Fence (%s)", op);
task             2509 pengine/allocate.c         if(task == NULL) {
task             2512 pengine/allocate.c             printf(" * %s %s '%s'\n", task, node_name, action->reason);
task             2514 pengine/allocate.c             printf(" * %s %s\n", task, node_name);
task             2516 pengine/allocate.c             crm_notice(" * %s %s '%s'\n", task, node_name, action->reason);
task             2518 pengine/allocate.c             crm_notice(" * %s %s\n", task, node_name);
task             2522 pengine/allocate.c         free(task);
task              693 pengine/clone.c         } else if (safe_str_eq(RSC_STOP, action->task)) {
task              697 pengine/clone.c         } else if (safe_str_eq(RSC_START, action->task)) {
task             1108 pengine/clone.c     if (safe_str_eq(action->task, "notify")
task             1109 pengine/clone.c         || safe_str_eq(action->task, "notified")) {
task             1136 pengine/clone.c         result = get_complex_task(child, action->task, TRUE);
task             1147 pengine/clone.c     enum action_tasks task = clone_child_action(action);
task             1149 pengine/clone.c     const char *task_s = task2text(task);
task              384 pengine/constraints.c         char *task = crm_concat(CRM_OP_RELAXED_CLONE, id, ':');
task              385 pengine/constraints.c         action_t *unordered_action = get_pseudo_op(task, data_set);
task              386 pengine/constraints.c         free(task);
task             1327 pengine/constraints.c         res = strdup(action->task);
task             1791 pengine/constraints.c         char *task = crm_concat(CRM_OP_RELAXED_SET, ID(set1), ':');
task             1792 pengine/constraints.c         action_t *unordered_action = get_pseudo_op(task, data_set);
task             1794 pengine/constraints.c         free(task);
task              511 pengine/container.c         enum action_tasks task = get_complex_task(data->child, action->task, TRUE);
task              512 pengine/container.c         switch(task) {
task              625 pengine/container.c             enum action_tasks task = clone_child_action(first);
task              626 pengine/container.c             const char *first_task = task2text(task);
task              631 pengine/container.c             if(strstr(first->task, "stop") && first_tuple && first_tuple->child) {
task              637 pengine/container.c                 first_action = find_first_action(first_tuple->child->actions, NULL, task2text(task), node);
task              639 pengine/container.c                 first_action = find_first_action(first_child->actions, NULL, task2text(task), node);
task              642 pengine/container.c             if(strstr(then->task, "mote") && then_tuple && then_tuple->child) {
task              650 pengine/container.c                 then_action = find_first_action(then_tuple->child->actions, NULL, then->task, node);
task              652 pengine/container.c                 then_action = find_first_action(then_child->actions, NULL, then->task, node);
task              673 pengine/container.c                     && crm_str_eq(then->task, RSC_STOP, TRUE) == FALSE
task              674 pengine/container.c                     && crm_str_eq(then->task, RSC_DEMOTE, TRUE) == FALSE) {
task              676 pengine/container.c                             then->task, then_child->id);
task              680 pengine/container.c                               then->task, then_child->id,
task              699 pengine/container.c                         then_child->id, then_action, task2text(task));
task              764 pengine/container.c             action_t *then_child_action = find_first_action(then_child->actions, NULL, then->task, node);
task               77 pengine/graph.c     int task = no_action;
task               96 pengine/graph.c     task = text2task(raw_task);
task               97 pengine/graph.c     switch (task) {
task              109 pengine/graph.c             task--;
task              114 pengine/graph.c             task = no_action;
task              118 pengine/graph.c             task = no_action;
task              122 pengine/graph.c     if (task != no_action) {
task              124 pengine/graph.c             uuid = generate_notify_key(rid, "confirmed-post", task2text(task + 1));
task              127 pengine/graph.c             uuid = generate_op_key(rid, task2text(task + 1), 0);
task              435 pengine/graph.c         && safe_str_eq(first->task, RSC_STOP)
task              467 pengine/graph.c         if (safe_str_neq(action->task, RSC_START)) {
task              485 pengine/graph.c     if (is_not_set(action->flags, pe_action_runnable) && safe_str_eq(action->task, RSC_START)) {
task              566 pengine/graph.c         if (first->rsc && first->rsc->variant == pe_group && safe_str_eq(first->task, RSC_START)) {
task              573 pengine/graph.c         if (then->rsc && then->rsc->variant == pe_group && safe_str_eq(then->task, RSC_START)) {
task              734 pengine/graph.c         } else if (safe_str_neq(action->task, RSC_STOP)) {
task              787 pengine/graph.c     if (safe_str_eq(action->task, CRM_OP_FENCE) || is_remote_node(action->node) == FALSE) {
task              827 pengine/graph.c     if (safe_str_eq(action->task, "stop") ||
task              828 pengine/graph.c         safe_str_eq(action->task, "demote") ||
task              829 pengine/graph.c         safe_str_eq(action->task, "migrate_from") ||
task              830 pengine/graph.c         safe_str_eq(action->task, "migrate_to")) {
task              946 pengine/graph.c     if (safe_str_eq(action->task, CRM_OP_SHUTDOWN)) {
task              952 pengine/graph.c     } else if (safe_str_eq(action->task, CRM_OP_FENCE)) {
task              964 pengine/graph.c                && safe_str_eq(action->task, CRMD_ACTION_STOP)) {
task              976 pengine/graph.c                && safe_str_eq(input->task, CRMD_ACTION_MIGRATED)) {
task             1003 pengine/graph.c     if (safe_str_eq(action->task, CRM_OP_FENCE)) {
task             1010 pengine/graph.c     } else if (safe_str_eq(action->task, CRM_OP_SHUTDOWN)) {
task             1013 pengine/graph.c     } else if (safe_str_eq(action->task, CRM_OP_CLEAR_FAILCOUNT)) {
task             1016 pengine/graph.c     } else if (safe_str_eq(action->task, CRM_OP_LRM_REFRESH)) {
task             1023 pengine/graph.c         if (safe_str_eq(action->task, CRM_OP_MAINTENANCE_NODES)) {
task             1037 pengine/graph.c     crm_xml_add(action_xml, XML_LRM_ATTR_TASK, action->task);
task             1043 pengine/graph.c         if (safe_str_eq(action->task, RSC_NOTIFY)) {
task             1055 pengine/graph.c             clone_key = generate_op_key(action->rsc->clone_name, action->task, interval);
task             1224 pengine/graph.c             enum action_tasks task = text2task(action->task);
task             1226 pengine/graph.c             if(task == action_notify || task == action_notified) {
task             1228 pengine/graph.c                 task = text2task(n_task);
task             1232 pengine/graph.c             switch (task) {
task             1261 pengine/graph.c     } else if (safe_str_eq(action->task, CRM_OP_FENCE) && action->node) {
task             1296 pengine/graph.c     } else if (is_set(action->flags, pe_action_pseudo) && safe_str_eq(action->task, CRM_OP_PROBED)) {
task             1319 pengine/graph.c             } else if (safe_str_neq(wrapper->action->task, RSC_START)) {
task             1349 pengine/graph.c         if (safe_str_neq(action->task, RSC_STATUS) && interval == NULL) {
task             1357 pengine/graph.c         || safe_str_eq(action->task, CRM_OP_FENCE)
task             1358 pengine/graph.c         || safe_str_eq(action->task, CRM_OP_SHUTDOWN)) {
task             1492 pengine/graph.c         if (action->rsc && safe_str_eq(action->task, RSC_MIGRATE)) {
task             1661 pengine/graph.c         && safe_str_eq(action->task, RSC_MIGRATE)) {
task              162 pengine/group.c         if (safe_str_eq(RSC_STOP, action->task) && is_set(action->flags, pe_action_runnable)) {
task              166 pengine/group.c         } else if (safe_str_eq(RSC_START, action->task)
task              381 pengine/group.c         enum action_tasks task = get_complex_task(child, action->task, TRUE);
task              382 pengine/group.c         const char *task_s = task2text(task);
task              395 pengine/group.c             if (safe_str_neq(task_s, action->task)
task              404 pengine/group.c         } else if (task != stop_rsc && task != action_demote) {
task              426 pengine/group.c         action_t *child_action = find_first_action(child->actions, NULL, then->task, node);
task              131 pengine/master.c         } else if (safe_str_eq(RSC_DEMOTE, action->task)) {
task              134 pengine/master.c         } else if (safe_str_eq(RSC_PROMOTE, action->task)) {
task              730 pengine/native.c             free(mon->task);
task              732 pengine/native.c             mon->task = strdup(RSC_CANCEL);
task              790 pengine/native.c         pe_rsc_info(rsc, " Start recurring %s (%llus) for %s on %s", mon->task, interval_ms / 1000,
task              911 pengine/native.c             free(cancel_op->task);
task              913 pengine/native.c             cancel_op->task = strdup(RSC_CANCEL);
task             1039 pengine/native.c             crm_notice(" Start recurring %s (%llus) for %s on %s", stopped_mon->task,
task             1423 pengine/native.c                             NULL, strdup(all_stopped->task), all_stopped,
task             1900 pengine/native.c         } else if ((then_rsc_role == RSC_ROLE_STOPPED) && safe_str_eq(then->task, RSC_STOP)) {
task             1904 pengine/native.c                    && safe_str_eq(then->task, RSC_START)
task             3073 pengine/native.c         } else if (safe_str_eq(action->task, RSC_START)
task              243 pengine/notif.c     const char *task = NULL;
task              262 pengine/notif.c     task = g_hash_table_lookup(op->meta, "notify_operation");
task              264 pengine/notif.c     pe_rsc_trace(rsc, "Creating notify actions for %s: %s (%s-%s)", op->uuid, rsc->id, value, task);
task              266 pengine/notif.c     key = generate_notify_key(rsc->id, value, task);
task              267 pengine/notif.c     trigger = custom_action(rsc, key, op->task, node,
task              308 pengine/notif.c             } else if (safe_str_eq(mon->task, RSC_CANCEL)) {
task              344 pengine/notif.c         key = generate_notify_key(rsc->id, "pre", start->task);
task              356 pengine/notif.c         add_hash_param(n_data->pre->meta, "notify_key_operation", start->task);
task              359 pengine/notif.c         key = generate_notify_key(rsc->id, "confirmed-pre", start->task);
task              371 pengine/notif.c         add_hash_param(n_data->pre_done->meta, "notify_key_operation", start->task);
task              379 pengine/notif.c         key = generate_notify_key(rsc->id, "post", end->task);
task              396 pengine/notif.c         add_hash_param(n_data->post->meta, "notify_key_operation", end->task);
task              399 pengine/notif.c         key = generate_notify_key(rsc->id, "confirmed-post", end->task);
task              416 pengine/notif.c         add_hash_param(n_data->post_done->meta, "notify_key_operation", end->task);
task              493 pengine/notif.c         enum action_tasks task;
task              506 pengine/notif.c                 task = text2task(op->task);
task              507 pengine/notif.c                 switch (task) {
task              645 pengine/notif.c     enum action_tasks task = text2task(n_data->action);
task              664 pengine/notif.c             enum action_tasks t = text2task(op->task);
task              687 pengine/notif.c         if (task == stop_rsc || task == action_demote) {
task              703 pengine/notif.c                 if (task == action_demote || stop == NULL
task              717 pengine/notif.c         } else if (task == start_rsc || task == action_promote) {
task              718 pengine/notif.c             if (task != start_rsc || start == NULL || is_set(start->flags, pe_action_optional)) {
task              109 pengine/ptest.c     if (safe_str_eq(action->task, RSC_CANCEL)) {
task              290 pengine/utils.c             if(safe_str_eq(RSC_STOP, op->task)) {
task              293 pengine/utils.c             } else if(safe_str_eq(RSC_START, op->task)) {
task              347 pengine/utils.c     switch (text2task(action->task)) {
task              433 pengine/utils.c create_pseudo_resource_op(resource_t * rsc, const char *task, bool optional, bool runnable, pe_working_set_t *data_set)
task              435 pengine/utils.c     pe_action_t *action = custom_action(rsc, generate_op_key(rsc->id, task, 0), task, NULL, optional, TRUE, data_set);
task               78 pengine/utils.h pe_action_t *create_pseudo_resource_op(resource_t * rsc, const char *task, bool optional, bool runnable, pe_working_set_t *data_set);
task             1413 tools/crm_mon.c                  xmlNode *xml_op, const char *task, const char *interval, int rc)
task             1422 tools/crm_mon.c             print_as("    + (%s) %s:", call, task);
task             1427 tools/crm_mon.c             fprintf(stream, "     <li>(%s) %s:", call, task);
task             1432 tools/crm_mon.c                     call, task);
task             1538 tools/crm_mon.c         const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             1544 tools/crm_mon.c         if (safe_str_eq(task, CRMD_ACTION_STATUS) && safe_str_eq(interval, "0")) {
task             1545 tools/crm_mon.c             task = "probe";
task             1549 tools/crm_mon.c         if (safe_str_eq(task, CRMD_ACTION_NOTIFY) || (safe_str_eq(task, "probe") && (rc == 7))) {
task             1560 tools/crm_mon.c         print_op_history(stream, data_set, node, xml_op, task, interval, rc);
task             3426 tools/crm_mon.c send_snmp_trap(const char *node, const char *rsc, const char *task, int target_rc, int rc,
task             3467 tools/crm_mon.c     add_snmp_field(trap_pdu, snmp_crm_oid_task, task);
task             3599 tools/crm_mon.c send_custom_trap(const char *node, const char *rsc, const char *task, int target_rc, int rc,
task             3618 tools/crm_mon.c     setenv("CRM_notify_task", task, 1);
task             3642 tools/crm_mon.c send_smtp_trap(const char *node, const char *rsc, const char *task, int target_rc, int rc,
task             3684 tools/crm_mon.c     len += strlen(task);
task             3692 tools/crm_mon.c     snprintf(crm_mail_subject, len, "%s - %s event for %s on %s: %s\r\n", crm_mail_prefix, task,
task             3700 tools/crm_mon.c                         "Completed operation %s for resource %s on %s\r\n", task, rsc, node);
task             3703 tools/crm_mon.c                         "Operation %s for resource %s on %s failed: %s\r\n", task, rsc, node, desc);
task             3802 tools/crm_mon.c     char *task = NULL;
task             3840 tools/crm_mon.c     if (parse_op_key(id, &rsc, &task, &interval) == FALSE) {
task             3871 tools/crm_mon.c         crm_notice("%s of %s on %s completed: %s", task, rsc, node, desc);
task             3878 tools/crm_mon.c         crm_warn("%s of %s on %s failed: %s", task, rsc, node, desc);
task             3882 tools/crm_mon.c         crm_warn("%s of %s on %s failed: %s", task, rsc, node, desc);
task             3886 tools/crm_mon.c         send_snmp_trap(node, rsc, task, target_rc, rc, status, desc);
task             3889 tools/crm_mon.c         send_smtp_trap(node, rsc, task, target_rc, rc, status, desc);
task             3892 tools/crm_mon.c         send_custom_trap(node, rsc, task, target_rc, rc, status, desc);
task             3897 tools/crm_mon.c     free(task);
task             1105 tools/crm_resource.c             const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
task             1115 tools/crm_resource.c             } else if(operation && safe_str_neq(operation, task)) {
task             1122 tools/crm_resource.c                       task, rsc->id, resource_name, node);
task             1123 tools/crm_resource.c             rc = cli_resource_delete(crmd_channel, node, rsc, task,
task              213 tools/crm_simulate.c     const char *task = action->task;
task              221 tools/crm_simulate.c     if (safe_str_eq(action->task, RSC_CANCEL)) {
task              223 tools/crm_simulate.c         task = "monitor";       /* TO-DO: Hack! */
task              233 tools/crm_simulate.c         if (safe_str_eq(action->task, RSC_NOTIFY)
task              234 tools/crm_simulate.c             || safe_str_eq(action->task, RSC_NOTIFIED)) {
task              243 tools/crm_simulate.c             key = generate_op_key(name, task, interval);
task              253 tools/crm_simulate.c     } else if (safe_str_eq(action->task, CRM_OP_FENCE)) {
task              256 tools/crm_simulate.c         action_name = crm_strdup_printf("%s%s '%s' %s", prefix ? prefix : "", action->task, op, action_host);
task              262 tools/crm_simulate.c         action_name = crm_strdup_printf("%s%s %s", prefix ? prefix : "", action->task, action_host);
task               91 tools/fake_transition.c update_failcounts(xmlNode * cib_node, const char *resource, const char *task,
task              104 tools/fake_transition.c         name = crm_failcount_name(resource, task, interval);
task              108 tools/fake_transition.c         name = crm_lastfailure_name(resource, task, interval);
task              145 tools/fake_transition.c create_op(xmlNode * cib_resource, const char *task, int interval, int outcome)
task              154 tools/fake_transition.c     op->op_type = strdup(task);
task              551 tools/fake_transition.c         char *task = NULL;
task              572 tools/fake_transition.c         parse_op_key(key, &resource, &task, &interval);
task              585 tools/fake_transition.c             update_failcounts(cib_node, resource, task, interval, outcome);
task              590 tools/fake_transition.c             op = create_op(cib_resource, task, interval, outcome);
task              601 tools/fake_transition.c         free(task);
task              611 tools/fake_transition.c     const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK_KEY);
task              615 tools/fake_transition.c     quiet_log(" * Pseudo action:   %s%s%s\n", task, node ? " on " : "", node ? node : "");
task              750 tools/fake_transition.c     const char *task = crm_element_value(action->xml, XML_LRM_ATTR_TASK);
task              756 tools/fake_transition.c         quiet_log(" * Cluster action:  %s for %s on %s\n", task, ID(rsc), node);
task              758 tools/fake_transition.c         quiet_log(" * Cluster action:  %s on %s\n", task, node);