unpack.c

linux集群服务器软件代码包

	const char *id       = crm_element_value(xml_obj, XML_ATTR_ID);
	const char *id_rh    = crm_element_value(xml_obj, XML_CONS_ATTR_TO);
	const char *type     = crm_element_value(xml_obj, XML_ATTR_TYPE);

	resource_t *rsc_lh   = pe_find_resource(rsc_list, id_lh);
	resource_t *rsc_rh   = pe_find_resource(rsc_list, id_rh);
 
	if(rsc_lh == NULL) {
		crm_err("No resource (con=%s, rsc=%s)", id, id_lh);
		return FALSE;
	} else if(rsc_rh == NULL) {
		crm_err("No resource (con=%s, rsc=%s)", id, id_rh);
		return FALSE;
	}
	
	if(safe_str_eq(type, XML_STRENGTH_VAL_MUST)) {
		strength_e = pecs_must;
		
	} else if(safe_str_eq(type, XML_STRENGTH_VAL_SHOULD)) {
		crm_err("Type %s is no longer supported", type);
		strength_e = pecs_must;
		
	} else if(safe_str_eq(type, XML_STRENGTH_VAL_SHOULDNOT)) {
		crm_err("Type %s is no longer supported", type);
		strength_e = pecs_must_not;
		
	} else if(safe_str_eq(type, XML_STRENGTH_VAL_MUSTNOT)) {
		strength_e = pecs_must_not;

	} else {
		crm_err("Unknown value for %s: %s", XML_ATTR_TYPE, type);
		return FALSE;
	}
	return rsc_dependancy_new(id, strength_e, rsc_lh, rsc_rh);
}

gboolean
unpack_rsc_order(
	crm_data_t * xml_obj, GListPtr rsc_list, GListPtr *ordering_constraints)
{
	gboolean symetrical_bool = TRUE;
	gboolean action_is_start = TRUE;
	gboolean type_is_after   = TRUE;
	
	const char *id         = crm_element_value(xml_obj, XML_ATTR_ID);
	const char *id_lh      = crm_element_value(xml_obj, XML_CONS_ATTR_FROM);
	const char *id_rh      = crm_element_value(xml_obj, XML_CONS_ATTR_TO);
	const char *action     = crm_element_value(xml_obj, XML_CONS_ATTR_ACTION);
	const char *symetrical = crm_element_value(xml_obj, XML_CONS_ATTR_SYMETRICAL);
	const char *type       = crm_element_value(xml_obj, XML_ATTR_TYPE);

	resource_t *rsc_lh   = pe_find_resource(rsc_list, id_lh);
	resource_t *rsc_rh   = pe_find_resource(rsc_list, id_rh);

	if(xml_obj == NULL) {
		crm_err("No constraint object to process.");
		return FALSE;

	} else if(id == NULL) {
		crm_err("%s constraint must have an id", crm_element_name(xml_obj));
		return FALSE;
		
	} else if(rsc_lh == NULL || rsc_rh == NULL) {
		crm_err("Constraint %s needs two sides lh: %p rh: %p"
			" (NULL indicates missing side)",
			id, rsc_lh, rsc_rh);
		return FALSE;
	
	}

	if(safe_str_eq(symetrical, XML_BOOLEAN_FALSE)) {
		symetrical_bool = FALSE;
	}
	if(safe_str_eq(type, "before")) {
		type_is_after = FALSE;
	}
	if(safe_str_eq(action, CRMD_RSCSTATE_STOP)) {
		action_is_start = FALSE;
	}

#if 1
	if((type_is_after && action_is_start)
	   || (type_is_after == FALSE && action_is_start == FALSE)){
		if(symetrical_bool || action_is_start == FALSE) {
			order_new(rsc_lh, stop_rsc, NULL, rsc_rh, stop_rsc, NULL,
				  pecs_startstop, ordering_constraints);
		}
		
		if(symetrical_bool || action_is_start) {
			order_new(rsc_rh, start_rsc, NULL, rsc_lh, start_rsc, NULL,
				  pecs_startstop, ordering_constraints);
		}

	} else {
		if(symetrical_bool || action_is_start == FALSE) {
			order_new(rsc_rh, stop_rsc, NULL, rsc_lh, stop_rsc, NULL,
				  pecs_startstop, ordering_constraints);
		}
		if(symetrical_bool || action_is_start) {
			order_new(rsc_lh, start_rsc, NULL, rsc_rh, start_rsc, NULL,
				  pecs_startstop, ordering_constraints);
		}
	}
	
#else	
	if(type_is_after) {
		order_new(rsc_lh, stop_rsc, NULL, rsc_rh, stop_rsc, NULL,
			  pecs_startstop, ordering_constraints);
		order_new(rsc_rh, start_rsc, NULL, rsc_lh, start_rsc, NULL,
			  pecs_startstop, ordering_constraints);
	} else {
		order_new(rsc_rh, stop_rsc, NULL, rsc_lh, stop_rsc, NULL,
			  pecs_startstop, ordering_constraints);
		order_new(rsc_lh, start_rsc, NULL, rsc_rh, start_rsc, NULL,
			  pecs_startstop, ordering_constraints);
	}
#endif
	return TRUE;
}


/* do NOT free the nodes returned here */
GListPtr
match_attrs(const char *attr, const char *op, const char *value,
	    const char *type, GListPtr node_list)
{
	GListPtr result = NULL;
	
	if(attr == NULL || op == NULL) {
		crm_err("Invlaid attribute or operation in expression"
			" (\'%s\' \'%s\' \'%s\')",
			crm_str(attr), crm_str(op), crm_str(value));
		return NULL;
	}
	

	slist_iter(
		node, node_t, node_list, lpc,
		gboolean accept = FALSE;
		
		int cmp = 0;
		const char *h_val = (const char*)g_hash_table_lookup(
			node->details->attrs, attr);

		if(value != NULL && h_val != NULL) {
			if(type == NULL || (safe_str_eq(type, "string"))) {
				cmp = strcmp(h_val, value);

			} else if(safe_str_eq(type, "number")) {
				float h_val_f = atof(h_val);
				float value_f = atof(value);

				if(h_val_f < value_f) {
					cmp = -1;
				} else if(h_val_f > value_f)  {
					cmp = 1;
				} else {
					cmp = 0;
				}
				
			} else if(safe_str_eq(type, "version")) {
				cmp = compare_version(h_val, value);

			}
			
		} else if(value == NULL && h_val == NULL) {
			cmp = 0;
		} else if(value == NULL) {
			cmp = 1;
		} else {
			cmp = -1;
		}
		
		if(safe_str_eq(op, "exists")) {
			if(h_val != NULL) accept = TRUE;	

		} else if(safe_str_eq(op, "not_exists")) {
			if(h_val == NULL) accept = TRUE;

		} else if(safe_str_eq(op, "running")) {
			GListPtr rsc_list = node->details->running_rsc;
			slist_iter(
				rsc, resource_t, rsc_list, lpc2,
				if(safe_str_eq(rsc->id, attr)) {
					accept = TRUE;
				}
				);

		} else if(safe_str_eq(op, "not_running")) {
			GListPtr rsc_list = node->details->running_rsc;
			accept = TRUE;
			slist_iter(
				rsc, resource_t, rsc_list, lpc2,
				if(safe_str_eq(rsc->id, attr)) {
					accept = FALSE;
					break;
				}
				);

		} else if(safe_str_eq(op, "eq")) {
			if((h_val == value) || cmp == 0)
				accept = TRUE;

		} else if(safe_str_eq(op, "ne")) {
			if((h_val == NULL && value != NULL)
			   || (h_val != NULL && value == NULL)
			   || cmp != 0)
				accept = TRUE;

		} else if(value == NULL || h_val == NULL) {
			/* the comparision is meaningless from this point on */
			accept = FALSE;
			
		} else if(safe_str_eq(op, "lt")) {
			if(cmp < 0) accept = TRUE;
			
		} else if(safe_str_eq(op, "lte")) {
			if(cmp <= 0) accept = TRUE;
			
		} else if(safe_str_eq(op, "gt")) {
			if(cmp > 0) accept = TRUE;
			
		} else if(safe_str_eq(op, "gte")) {
			if(cmp >= 0) accept = TRUE;
			
		}
		
		if(accept) {
			crm_trace("node %s matched", node->details->uname);
			result = g_list_append(result, node);
		} else {
			crm_trace("node %s did not match", node->details->uname);
		}		   
		);
	
	return result;
}

gboolean
add_node_attrs(crm_data_t * attrs, node_t *node)
{
	const char *name  = NULL;
	const char *value = NULL;

	xml_child_iter(
		attrs, attr, NULL,
		name  = crm_element_value(attr, XML_NVPAIR_ATTR_NAME);
		value = crm_element_value(attr, XML_NVPAIR_ATTR_VALUE);
			
		if(name != NULL
		   && value != NULL
		   && safe_val(NULL, node, details) != NULL) {
			crm_verbose("Adding %s => %s", name, value);

			/* this is frustrating... no way to pass in const
			 *  keys or values yet docs say:
			 *   Note: If keys and/or values are dynamically
			 *   allocated, you should free them first.
			 */
			g_hash_table_insert(node->details->attrs,
					    crm_strdup(name),
					    crm_strdup(value));
		}
		);
 	g_hash_table_insert(node->details->attrs,
			    crm_strdup(XML_ATTR_UNAME),
			    crm_strdup(node->details->uname));
 	g_hash_table_insert(node->details->attrs,
			    crm_strdup(XML_ATTR_ID),
			    crm_strdup(node->details->id));
	if(safe_str_eq(node->details->id, dc_uuid)) {
		node->details->is_dc = TRUE;
		g_hash_table_insert(node->details->attrs,
				    crm_strdup(XML_ATTR_DC),
				    crm_strdup(XML_BOOLEAN_TRUE));
	} else {
		g_hash_table_insert(node->details->attrs,
				    crm_strdup(XML_ATTR_DC),
				    crm_strdup(XML_BOOLEAN_FALSE));
	}
	
			
	return TRUE;
}



gboolean
unpack_rsc_location(
	crm_data_t * xml_obj,
	GListPtr rsc_list, GListPtr node_list, GListPtr *placement_constraints)
{
/*

  <constraints>
     <rsc_location rsc="Filesystem-whatever-1" timestamp="..." lifetime="...">
     	<rule score="+50.0" result="can">
<!ATTLIST node_expression
	  id         CDATA #REQUIRED
	  attribute  CDATA #REQUIRED
	  operation  (lt|gt|lte|gte|eq|ne|exists|not_exists)
	  value      CDATA #IMPLIED
	  type	     (integer|string|version)    'string'>

	</rule>
     	<rule score="+500.0">
       		<node_expression match="cpu:50GHz" />
	</rule>
     	<rule result="cannot">
       		<node_expression not_match="san"/>
	</rule>
...

   Translation:

   Further translation:
       
*/
	gboolean were_rules = FALSE;
	const char *id_lh   = crm_element_value(xml_obj, "rsc");
	const char *id      = crm_element_value(xml_obj, XML_ATTR_ID);
	resource_t *rsc_lh = pe_find_resource(rsc_list, id_lh);

	if(rsc_lh == NULL) {
		crm_warn("No resource (con=%s, rsc=%s)", id, id_lh);
		return FALSE;
	}
			
	xml_child_iter(
		xml_obj, rule, XML_TAG_RULE,

		gboolean first_expr = TRUE;
		gboolean can_run    = FALSE;
		gboolean do_and     = TRUE;
		gboolean rule_has_expressions;

		const char *rule_id = crm_element_value(rule, XML_ATTR_ID);
		const char *score   = crm_element_value(rule, XML_RULE_ATTR_SCORE);
		const char *result  = crm_element_value(rule, XML_RULE_ATTR_RESULT);
		const char *boolean = crm_element_value(rule, XML_RULE_ATTR_BOOLEAN_OP);
		GListPtr match_L    = NULL;
		GListPtr old_list   = NULL;
		float score_f       = atof(score?score:"0.0");

		rsc_to_node_t *new_con = NULL;

		were_rules = TRUE;
		
		if(safe_str_eq(boolean, "or")) {
			do_and = FALSE;
		}

		if(result == NULL || (safe_str_eq(result, "can"))) {
			can_run = TRUE;
		}

		new_con = rsc2node_new(rule_id, rsc_lh, score_f,
				       can_run, NULL, placement_constraints);

		if(new_con == NULL) {
			continue;
		}
		
		rule_has_expressions = FALSE;
		xml_child_iter(
			rule, expr, XML_TAG_EXPRESSION,

			const char *attr  = crm_element_value(
				expr, XML_EXPR_ATTR_ATTRIBUTE);
			const char *op    = crm_element_value(
				expr, XML_EXPR_ATTR_OPERATION);
			const char *value = crm_element_value(
				expr, XML_EXPR_ATTR_VALUE);
			const char *type  = crm_element_value(
				expr, XML_EXPR_ATTR_TYPE);
			
			rule_has_expressions = TRUE;
			crm_trace("processing expression: %s",
				  crm_element_value(expr, XML_ATTR_ID));

			match_L = match_attrs(
				attr, op, value, type, node_list);
			
			if(first_expr) {
				new_con->node_list_rh =	node_list_dup(
					match_L, FALSE);
				first_expr = FALSE;
				continue;
			}

			old_list = new_con->node_list_rh;

			if(do_and) {
				crm_trace("do_and");
				
				new_con->node_list_rh = node_list_and(
					old_list, match_L, FALSE);
			} else {
				crm_trace("do_or");
				
				new_con->node_list_rh = node_list_or(
					old_list, match_L, FALSE);
			}
			pe_free_shallow_adv(match_L,  FALSE);
			pe_free_shallow_adv(old_list, TRUE);
			);

		if(rule_has_expressions == FALSE) {
			/* feels like a hack */
			crm_devel("Rule %s had no expressions,"
				  " adding all nodes", crm_element_value(rule, XML_ATTR_ID));
			
			new_con->node_list_rh = node_list_dup(node_list,FALSE);
		}
		
		if(new_con->node_list_rh == NULL) {
			crm_warn("No matching nodes for constraint/rule %s/%s",
				 id, crm_element_value(rule, XML_ATTR_ID));
		}
		
		crm_devel_action(print_rsc_to_node("Added", new_con, FALSE));
		);

	if(were_rules == FALSE) {
		crm_err("no rules for constraint %s", id);
	}
	
	return TRUE;
}