static action_t *
find_rsc_action(resource_t * rsc, const char *key, gboolean active_only, GListPtr * list)
{
action_t *match = NULL;
GListPtr possible = NULL;
GListPtr active = NULL;
possible = find_actions(rsc->actions, key, NULL);
if (active_only) {
GListPtr gIter = possible;
for (; gIter != NULL; gIter = gIter->next) {
action_t *op = (action_t *) gIter->data;
if (is_set(op->flags, pe_action_optional) == FALSE) {
active = g_list_prepend(active, op);
}
}
if (active && g_list_length(active) == 1) {
match = g_list_nth_data(active, 0);
}
if (list) {
*list = active;
active = NULL;
}
} else if (possible && g_list_length(possible) == 1) {
match = g_list_nth_data(possible, 0);
}
if (list) {
*list = possible;
possible = NULL;
}
if (possible) {
g_list_free(possible);
}
if (active) {
g_list_free(active);
}
return match;
}
void Perso::main_loop()
{
std::string answer;
bool death;
std::list<std::string>::iterator it;
int num_item;
death = false;
while (this->_invent._nourriture > 0 && death == false)
{
if ((this->_time % 126) == 0)
{
this->_time = 0;
this->_invent._nourriture--;
}
if (this->_action.size() < 10)
{
find_actions();
num_item = 0;
for (it = this->_action.begin(); (it != this->_action.end() || this->_action.size() > 0); ++it)
{
if (num_item > 0)
--it;
std::cout << "Action = " << *it;
answer = this->server_answer(*it);
this->execute_commands(answer, &death, *it);
it = this->_action.begin();
num_item++;
}
this->_action.clear();
}
else
{
}
if (this->_sav->cpt >= 100)
{
this->_sav->mouv.pop_front();
}
}
}
action_t *
custom_action(resource_t * rsc, char *key, const char *task,
node_t * on_node, gboolean optional, gboolean save_action,
pe_working_set_t * data_set)
{
action_t *action = NULL;
GListPtr possible_matches = NULL;
CRM_CHECK(key != NULL, return NULL);
CRM_CHECK(task != NULL, return NULL);
if (save_action && rsc != NULL) {
possible_matches = find_actions(rsc->actions, key, on_node);
}
if (possible_matches != NULL) {
if (g_list_length(possible_matches) > 1) {
pe_warn("Action %s for %s on %s exists %d times",
task, rsc ? rsc->id : "<NULL>",
on_node ? on_node->details->uname : "<NULL>", g_list_length(possible_matches));
}
action = g_list_nth_data(possible_matches, 0);
crm_trace("Found existing action (%d) %s for %s on %s",
action->id, task, rsc ? rsc->id : "<NULL>",
on_node ? on_node->details->uname : "<NULL>");
g_list_free(possible_matches);
}
if (action == NULL) {
if (save_action) {
crm_trace("Creating%s action %d: %s for %s on %s",
optional ? "" : " manditory", data_set->action_id, key,
rsc ? rsc->id : "<NULL>", on_node ? on_node->details->uname : "<NULL>");
}
action = calloc(1, sizeof(action_t));
if (save_action) {
action->id = data_set->action_id++;
} else {
action->id = 0;
}
action->rsc = rsc;
CRM_ASSERT(task != NULL);
action->task = strdup(task);
if (on_node) {
action->node = node_copy(on_node);
}
action->uuid = strdup(key);
pe_set_action_bit(action, pe_action_failure_is_fatal);
pe_set_action_bit(action, pe_action_runnable);
if (optional) {
pe_set_action_bit(action, pe_action_optional);
} else {
pe_clear_action_bit(action, pe_action_optional);
}
/*
Implied by calloc()...
action->actions_before = NULL;
action->actions_after = NULL;
action->pseudo = FALSE;
action->dumped = FALSE;
action->processed = FALSE;
action->seen_count = 0;
*/
action->extra = g_hash_table_new_full(crm_str_hash, g_str_equal, free, free);
action->meta = g_hash_table_new_full(crm_str_hash, g_str_equal, free, free);
if (save_action) {
data_set->actions = g_list_prepend(data_set->actions, action);
}
if (rsc != NULL) {
action->op_entry = find_rsc_op_entry_helper(rsc, key, TRUE);
unpack_operation(action, action->op_entry, data_set);
if (save_action) {
rsc->actions = g_list_prepend(rsc->actions, action);
}
}
if (save_action) {
crm_trace("Action %d created", action->id);
}
}
if (optional == FALSE) {
crm_trace("Action %d (%s) marked manditory", action->id, action->uuid);
pe_clear_action_bit(action, pe_action_optional);
}
if (rsc != NULL) {
enum action_tasks a_task = text2task(action->task);
int warn_level = LOG_DEBUG_3;
if (save_action) {
warn_level = LOG_WARNING;
}
if (is_set(action->flags, pe_action_have_node_attrs) == FALSE
&& action->node != NULL && action->op_entry != NULL) {
pe_set_action_bit(action, pe_action_have_node_attrs);
unpack_instance_attributes(data_set->input, action->op_entry, XML_TAG_ATTR_SETS,
action->node->details->attrs,
action->extra, NULL, FALSE, data_set->now);
}
if (is_set(action->flags, pe_action_pseudo)) {
/* leave untouched */
} else if (action->node == NULL) {
pe_clear_action_bit(action, pe_action_runnable);
} else if (is_not_set(rsc->flags, pe_rsc_managed)
&& g_hash_table_lookup(action->meta, XML_LRM_ATTR_INTERVAL) == NULL) {
crm_debug("Action %s (unmanaged)", action->uuid);
pe_set_action_bit(action, pe_action_optional);
/* action->runnable = FALSE; */
} else if (action->node->details->online == FALSE) {
pe_clear_action_bit(action, pe_action_runnable);
do_crm_log(warn_level, "Action %s on %s is unrunnable (offline)",
action->uuid, action->node->details->uname);
if (is_set(action->rsc->flags, pe_rsc_managed)
&& save_action && a_task == stop_rsc) {
do_crm_log(warn_level, "Marking node %s unclean", action->node->details->uname);
action->node->details->unclean = TRUE;
}
} else if (action->node->details->pending) {
pe_clear_action_bit(action, pe_action_runnable);
do_crm_log(warn_level, "Action %s on %s is unrunnable (pending)",
action->uuid, action->node->details->uname);
} else if (action->needs == rsc_req_nothing) {
crm_trace("Action %s doesnt require anything", action->uuid);
pe_set_action_bit(action, pe_action_runnable);
#if 0
/*
* No point checking this
* - if we dont have quorum we cant stonith anyway
*/
} else if (action->needs == rsc_req_stonith) {
crm_trace("Action %s requires only stonith", action->uuid);
action->runnable = TRUE;
#endif
} else if (is_set(data_set->flags, pe_flag_have_quorum) == FALSE
&& data_set->no_quorum_policy == no_quorum_stop) {
pe_clear_action_bit(action, pe_action_runnable);
crm_debug("%s\t%s (cancelled : quorum)", action->node->details->uname, action->uuid);
} else if (is_set(data_set->flags, pe_flag_have_quorum) == FALSE
&& data_set->no_quorum_policy == no_quorum_freeze) {
crm_trace("Check resource is already active");
if (rsc->fns->active(rsc, TRUE) == FALSE) {
pe_clear_action_bit(action, pe_action_runnable);
crm_debug("%s\t%s (cancelled : quorum freeze)",
action->node->details->uname, action->uuid);
}
} else {
crm_trace("Action %s is runnable", action->uuid);
pe_set_action_bit(action, pe_action_runnable);
}
if (save_action) {
switch (a_task) {
case stop_rsc:
set_bit(rsc->flags, pe_rsc_stopping);
break;
case start_rsc:
clear_bit(rsc->flags, pe_rsc_starting);
if (is_set(action->flags, pe_action_runnable)) {
set_bit(rsc->flags, pe_rsc_starting);
}
break;
default:
break;
}
}
}
free(key);
return action;
}
int main (int parArgc, char* parArgv[]) {
size_t z;
size_t actions_count;
char** actions;
char* action_path;
char* specified_action;
size_t action_path_length;
size_t selected_action;
char** argv;
int retval;
int should_quit;
find_actions(&actions, &actions_count);
retval = manage_commandline(parArgc, parArgv, actions, actions_count, &should_quit);
if (should_quit) {
free_actions(actions, actions_count);
return retval;
}
if (0 == actions_count) {
fprintf(stderr, "No actions found in \"%s\"\n", ACTIONS_SEARCH_PATH);
return 1;
}
if (1 < parArgc)
specified_action = parArgv[1];
else
specified_action = "";
assert((actions and actions_count) or (not actions and not actions_count));
selected_action = foreach_avail_action(&same_action, actions, actions_count, specified_action);
if (actions_count == selected_action) {
//Find a possible mispelling and show a hint to the user if any
selected_action = foreach_avail_action(&find_similar, actions, actions_count, specified_action);
if (selected_action < actions_count) {
fprintf(stderr, "Unrecognized action \"%s\" - maybe you meant \"%s\"?\n",
specified_action,
get_actionname(actions[selected_action])
);
}
else {
fprintf(stderr, "Unrecognized action \"%s\"\n", specified_action);
}
free_actions(actions, actions_count);
return 2;
}
action_path_length = lengthof(ACTIONS_SEARCH_PATH) - 1;
if (ACTIONS_SEARCH_PATH[lengthof(ACTIONS_SEARCH_PATH) - 2] != '/') {
++action_path_length;
}
action_path_length += strlen(actions[selected_action]);
++action_path_length;
action_path = malloc(action_path_length);
memcpy(action_path, ACTIONS_SEARCH_PATH, lengthof(ACTIONS_SEARCH_PATH) - 1);
z = lengthof(ACTIONS_SEARCH_PATH) - 1;
if (ACTIONS_SEARCH_PATH[lengthof(ACTIONS_SEARCH_PATH) - 2] != '/') {
action_path[lengthof(ACTIONS_SEARCH_PATH) - 1] = '/';
++z;
}
strcpy(action_path + z, actions[selected_action]);
free_actions(actions, actions_count);
argv = malloc(sizeof(char*) * (parArgc - 1 + 1));
argv[0] = action_path;
for (z = 2; z < (size_t)parArgc; ++z) {
argv[z - 1] = parArgv[z];
}
argv[parArgc - 1] = NULL;
/*printf("would call %s\n", action_path);*/
retval = execv(action_path, argv);
if (retval < 0) {
fprintf(stderr, "Error executing \"%s\": %d:\n%s\n", action_path, errno, strerror(errno));
free(action_path);
return 1;
}
/* the program won't get here, but just to be clean... */
free(action_path);
return 0;
}
