Function clone_action_flags

pengine/clone.c:1127–1181

}

enum pe_action_flags
clone_action_flags(action_t * action, node_t * node)
{
    GListPtr gIter = NULL;
    gboolean any_runnable = FALSE;
    gboolean check_runnable = TRUE;
    enum action_tasks task = clone_child_action(action);
    enum pe_action_flags flags = (pe_action_optional | pe_action_runnable | pe_action_pseudo);
    const char *task_s = task2text(task);

    gIter = action->rsc->children;
    for (; gIter != NULL; gIter = gIter->next) {
        action_t *child_action = NULL;
        resource_t *child = (resource_t *) gIter->data;

        child_action =
            find_first_action(child->actions, NULL, task_s, child->children ? NULL : node);
        pe_rsc_trace(child, "Checking for %s in %s on %s", task_s, child->id,
                  node ? node->details->uname : "none");
        if (child_action) {
            enum pe_action_flags child_flags = child->cmds->action_flags(child_action, node);

            if (is_set(flags, pe_action_optional)
                && is_set(child_flags, pe_action_optional) == FALSE) {
                pe_rsc_trace(child, "%s is manditory because of %s", action->uuid, child_action->uuid);
                flags = crm_clear_bit(__FUNCTION__, action->rsc->id, flags, pe_action_optional);
                pe_clear_action_bit(action, pe_action_optional);
            }
            if (is_set(child_flags, pe_action_runnable)) {
                any_runnable = TRUE;
            }

        } else {

            GListPtr gIter2 = child->actions;

            for (; gIter2 != NULL; gIter2 = gIter2->next) {
                action_t *op = (action_t *) gIter2->data;

                pe_rsc_trace(child, "%s on %s (%s)", op->uuid, op->node ? op->node->details->uname : "none",
                          op->task);
            }
        }
    }

    if (check_runnable && any_runnable == FALSE) {
        pe_rsc_trace(action->rsc, "%s is not runnable because no children are", action->uuid);
        flags = crm_clear_bit(__FUNCTION__, action->rsc->id, flags, pe_action_runnable);
        if (node == NULL) {
            pe_clear_action_bit(action, pe_action_runnable);
        }
    }

    return flags;
}

static enum pe_graph_flags
clone_update_actions_interleave(action_t * first, action_t * then, node_t * node,