/* any node in list1 or list2 and not in the other gets a score of -INFINITY */
void
node_list_exclude(GHashTable * hash, GListPtr list, gboolean merge_scores)
{
GHashTable *result = hash;
node_t *other_node = NULL;
GListPtr gIter = list;
GHashTableIter iter;
node_t *node = NULL;
g_hash_table_iter_init(&iter, hash);
while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) {
other_node = pe_find_node_id(list, node->details->id);
if (other_node == NULL) {
node->weight = -INFINITY;
} else if (merge_scores) {
node->weight = merge_weights(node->weight, other_node->weight);
}
}
for (; gIter != NULL; gIter = gIter->next) {
node_t *node = (node_t *) gIter->data;
other_node = pe_hash_table_lookup(result, node->details->id);
if (other_node == NULL) {
node_t *new_node = node_copy(node);
new_node->weight = -INFINITY;
g_hash_table_insert(result, (gpointer) new_node->details->id, new_node);
}
}
}
static node_t *
parent_node_instance(const resource_t *rsc, node_t *node)
{
node_t *ret = NULL;
if(node != NULL) {
ret = pe_find_node_id(
rsc->parent->allowed_nodes, node->details->id);
}
return ret;
}
/* are the contents of list1 and list2 equal
* nodes with weight < 0 are ignored if filter == TRUE
*
* slow but linear
*
*/
gboolean
node_list_eq(GListPtr list1, GListPtr list2, gboolean filter)
{
node_t *other_node;
GListPtr lhs = list1;
GListPtr rhs = list2;
slist_iter(
node, node_t, lhs, lpc,
if(node == NULL || (filter && node->weight < 0)) {
continue;
}
other_node = (node_t*)
pe_find_node_id(rhs, node->details->id);
if(other_node == NULL || other_node->weight < 0) {
return FALSE;
}
);
static void
check_actions_for(crm_data_t *rsc_entry, node_t *node, pe_working_set_t *data_set)
{
const char *id = NULL;
const char *task = NULL;
int interval = 0;
const char *interval_s = NULL;
GListPtr op_list = NULL;
GListPtr sorted_op_list = NULL;
const char *rsc_id = ID(rsc_entry);
gboolean is_probe = FALSE;
int start_index = 0, stop_index = 0;
resource_t *rsc = pe_find_resource(data_set->resources, rsc_id);
CRM_CHECK(rsc != NULL, return);
CRM_CHECK(node != NULL, return);
CRM_CHECK(rsc_id != NULL, return);
if(is_set(rsc->flags, pe_rsc_orphan)) {
crm_debug_2("Skipping param check for %s: orphan", rsc->id);
return;
} else if(pe_find_node_id(rsc->running_on, node->details->id) == NULL) {
crm_debug_2("Skipping param check for %s: no longer active on %s",
rsc->id, node->details->uname);
return;
}
crm_debug_3("Processing %s on %s", rsc->id, node->details->uname);
if(check_rsc_parameters(rsc, node, rsc_entry, data_set)) {
DeleteRsc(rsc, node, FALSE, data_set);
}
xml_child_iter_filter(
rsc_entry, rsc_op, XML_LRM_TAG_RSC_OP,
op_list = g_list_append(op_list, rsc_op);
);
/**
* This is the main function to update resource table v2.
* Return the number of resources.
*/
static int
update_resources_recursively(GListPtr reslist, GListPtr nodelist, int index)
{
GListPtr gIter1 = NULL;
if (reslist == NULL) {
return index;
}
/*
* Set resource info to resource table v2 from data_set,
* and add it to Glib's array.
*/
for(gIter1 = reslist; gIter1 != NULL; gIter1 = gIter1->next) {
resource_t *rsc = gIter1->data;
GListPtr gIter2 = NULL;
cl_log(LOG_DEBUG, "resource %s processing.", rsc->id);
for(gIter2 = nodelist; gIter2 != NULL; gIter2 = gIter2->next) {
node_t *node = gIter2->data;
struct hb_rsinfov2 *rsinfo;
enum rsc_role_e rsstate;
rsinfo = (struct hb_rsinfov2 *) malloc(sizeof(struct hb_rsinfov2));
if (!rsinfo) {
cl_log(LOG_CRIT, "malloc resource info v2 failed.");
return HA_FAIL;
}
rsinfo->resourceid = strdup(rsc->id);
rsinfo->type = PE_OBJ_TYPES2AGENTTYPE(rsc->variant);
/* using a temp var to suppress casting warning of the compiler */
rsstate = rsc->fns->state(rsc, TRUE);
{
GListPtr running_on_nodes = NULL;
rsc->fns->location(rsc, &running_on_nodes, TRUE);
if (pe_find_node_id(
running_on_nodes, node->details->id) == NULL) {
/*
* if the resource is not running on current node,
* its status is "stopped(1)".
*/
rsstate = RSC_ROLE_STOPPED;
}
g_list_free(running_on_nodes);
}
rsinfo->status = RSC_ROLE_E2AGENTSTATUS(rsstate);
rsinfo->node = strdup(node->details->uname);
if (is_not_set(rsc->flags, pe_rsc_managed)) {
rsinfo->is_managed = LHARESOURCEISMANAGED_UNMANAGED;
} else {
rsinfo->is_managed = LHARESOURCEISMANAGED_MANAGED;
}
/* get fail-count from <status> */
{
char *attr_name = NULL;
char *attr_value = NULL;
crm_data_t *tmp_xml = NULL;
attr_name = crm_concat("fail-count", rsinfo->resourceid, '-');
attr_value = g_hash_table_lookup(node->details->attrs,
attr_name);
rsinfo->failcount = crm_parse_int(attr_value, "0");
free(attr_name);
free_xml(tmp_xml);
}
if (rsc->parent != NULL) {
rsinfo->parent = strdup(rsc->parent->id);
} else {
rsinfo->parent = strdup("");
}
/*
* if the resource stops, and its fail-count is 0,
* don't list it up.
*/
if (rsinfo->status != LHARESOURCESTATUS_STOPPED ||
rsinfo->failcount > 0) {
rsinfo->index = index++;
g_ptr_array_add(gResourceTableV2, (gpointer *)rsinfo);
} else {
free(rsinfo->resourceid);
free(rsinfo->node);
free(rsinfo->parent);
free(rsinfo);
}
} /* end slist_iter(node) */
/* add resources recursively for group/clone/master */
index = update_resources_recursively(rsc->children,
nodelist, index);
} /* end slist_iter(rsc) */
return index;
}
int
master_score(resource_t * rsc, node_t * node, int not_set_value)
{
char *attr_name;
char *name = rsc->id;
const char *attr_value = NULL;
int score = not_set_value, len = 0;
if (rsc->children) {
GListPtr gIter = rsc->children;
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child = (resource_t *) gIter->data;
int c_score = master_score(child, node, not_set_value);
if (score == not_set_value) {
score = c_score;
} else {
score += c_score;
}
}
return score;
}
if (rsc->fns->state(rsc, TRUE) < RSC_ROLE_STARTED) {
return score;
}
if (node != NULL) {
node_t *match = pe_find_node_id(rsc->running_on, node->details->id);
if (match == NULL) {
crm_trace("%s is not active on %s - ignoring", rsc->id, node->details->uname);
return score;
}
match = pe_hash_table_lookup(rsc->allowed_nodes, node->details->id);
if (match == NULL) {
return score;
} else if (match->weight < 0) {
crm_trace("%s on %s has score: %d - ignoring",
rsc->id, match->details->uname, match->weight);
return score;
}
}
if (rsc->clone_name) {
/* Use the name the lrm knows this resource as,
* since that's what crm_master would have used too
*/
name = rsc->clone_name;
}
len = 8 + strlen(name);
crm_malloc0(attr_name, len);
sprintf(attr_name, "master-%s", name);
if (node) {
attr_value = g_hash_table_lookup(node->details->attrs, attr_name);
crm_trace("%s: %s[%s] = %s", rsc->id, attr_name, node->details->uname, crm_str(attr_value));
}
if (attr_value != NULL) {
score = char2score(attr_value);
}
crm_free(attr_name);
return score;
}
static int
master_score(resource_t * rsc, node_t * node, int not_set_value)
{
char *attr_name;
char *name = rsc->id;
const char *attr_value = NULL;
int score = not_set_value, len = 0;
if (rsc->children) {
GListPtr gIter = rsc->children;
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child = (resource_t *) gIter->data;
int c_score = master_score(child, node, not_set_value);
if (score == not_set_value) {
score = c_score;
} else {
score += c_score;
}
}
return score;
}
if (node == NULL) {
if (rsc->fns->state(rsc, TRUE) < RSC_ROLE_STARTED) {
pe_rsc_trace(rsc, "Ingoring master score for %s: unknown state", rsc->id);
return score;
}
} else {
node_t *match = pe_find_node_id(rsc->running_on, node->details->id);
node_t *known = pe_hash_table_lookup(rsc->known_on, node->details->id);
if (is_not_set(rsc->flags, pe_rsc_unique) && filter_anonymous_instance(rsc, node)) {
pe_rsc_trace(rsc, "Anonymous clone %s is allowed on %s", rsc->id, node->details->uname);
} else if (match == NULL && known == NULL) {
pe_rsc_trace(rsc, "%s (aka. %s) has been filtered on %s - ignoring", rsc->id,
rsc->clone_name, node->details->uname);
return score;
}
match = pe_hash_table_lookup(rsc->allowed_nodes, node->details->id);
if (match == NULL) {
return score;
} else if (match->weight < 0) {
pe_rsc_trace(rsc, "%s on %s has score: %d - ignoring",
rsc->id, match->details->uname, match->weight);
return score;
}
}
if (rsc->clone_name) {
/* Use the name the lrm knows this resource as,
* since that's what crm_master would have used too
*/
name = rsc->clone_name;
}
len = 8 + strlen(name);
attr_name = calloc(1, len);
sprintf(attr_name, "master-%s", name);
if (node) {
attr_value = g_hash_table_lookup(node->details->attrs, attr_name);
pe_rsc_trace(rsc, "%s: %s[%s] = %s", rsc->id, attr_name, node->details->uname,
crm_str(attr_value));
}
if (attr_value != NULL) {
score = char2score(attr_value);
}
free(attr_name);
return score;
}