unpack.c

linux集群服务器软件代码包

/* $Id: unpack.c,v 1.56 2005/02/20 17:00:21 andrew Exp $ */
/* 
 * Copyright (C) 2004 Andrew Beekhof <[e-mail]>
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <portability.h>
#include <crm/crm.h>
#include <crm/cib.h>
#include <crm/msg_xml.h>
#include <crm/common/xml.h>
#include <crm/common/msg.h>

#include <lrm/lrm_api.h>

#include <glib.h>

#include <heartbeat.h> /* for ONLINESTATUS */

#include <pengine.h>
#include <pe_utils.h>

int      max_valid_nodes = 0;
int      order_id        = 1;
GListPtr agent_defaults  = NULL;
gboolean stonith_enabled = FALSE;
const char* transition_timeout = "60000"; /* 1 minute */

extern const char *dc_uuid;

GListPtr match_attrs(const char *attr, const char *op, const char *value,
		     const char *type, GListPtr node_list);

gboolean unpack_rsc_to_attr(crm_data_t * xml_obj,
			    GListPtr rsc_list,
			    GListPtr node_list,
			    GListPtr *placement_constraints);

gboolean unpack_rsc_to_node(crm_data_t * xml_obj,
			    GListPtr rsc_list,
			    GListPtr node_list,
			    GListPtr *placement_constraints);

gboolean unpack_rsc_order(
	crm_data_t * xml_obj, GListPtr rsc_list, GListPtr *ordering_constraints);

gboolean unpack_rsc_dependancy(
	crm_data_t * xml_obj, GListPtr rsc_list, GListPtr *ordering_constraints);

gboolean unpack_rsc_location(
	crm_data_t * xml_obj, GListPtr rsc_list, GListPtr node_list,
	GListPtr *ordering_constraints);

gboolean unpack_lrm_rsc_state(
	node_t *node, crm_data_t * lrm_state,
	GListPtr rsc_list, GListPtr nodes,
	GListPtr *actions, GListPtr *placement_constraints);

gboolean add_node_attrs(crm_data_t * attrs, node_t *node);

gboolean unpack_healthy_resource(GListPtr *placement_constraints, GListPtr *actions,
	crm_data_t * rsc_entry, resource_t *rsc_lh, node_t *node);

gboolean unpack_failed_resource(GListPtr *placement_constraints, 
	crm_data_t * rsc_entry, resource_t *rsc_lh, node_t *node);

gboolean determine_online_status(crm_data_t * node_state, node_t *this_node);

gboolean unpack_lrm_agents(node_t *node, crm_data_t * agent_list);

gboolean is_node_unclean(crm_data_t * node_state);

gboolean rsc_dependancy_new(
	const char *id, enum con_strength strength,
	resource_t *rsc_lh, resource_t *rsc_rh);

gboolean create_ordering(
	const char *id, enum con_strength strength,
	resource_t *rsc_lh, resource_t *rsc_rh, GListPtr *ordering_constraints);

rsc_to_node_t *rsc2node_new(
	const char *id, resource_t *rsc,
	double weight, gboolean can_run, node_t *node,
	GListPtr *placement_constraints);

const char *get_agent_param(resource_t *rsc, const char *param);

const char *get_agent_param_rsc(resource_t *rsc, const char *param);

const void *get_agent_param_metadata(resource_t *rsc, const char *param);

const char *get_agent_param_global(resource_t *rsc, const char *param);

const char *param_value(crm_data_t * parent, const char *name);

gboolean
unpack_config(crm_data_t * config)
{
	const char *value = NULL;
	
	value = param_value(config, "failed_nodes");
	if(safe_str_eq(value, XML_CIB_ATTR_STONITH)) {
		crm_debug("Enabling STONITH of failed nodes");
		stonith_enabled = TRUE;
	} else {
		stonith_enabled = FALSE;
	}

	value = param_value(config, "transition_timeout");
	if(value != NULL) {
		int tmp = atoi(value);
		if(tmp > 0) {
			transition_timeout = value;
		} else {
			crm_warn("Invalid value for %s: %s",
				 "transition_timeout", value);
		}
	}
	crm_devel("%s set to: %s",
		 "transition_timeout", transition_timeout);
	
	return TRUE;
}

const char *
param_value(crm_data_t * parent, const char *name) 
{
	crm_data_t * a_default = find_entity(
		parent, XML_CIB_TAG_NVPAIR, name, FALSE);

	if(a_default == NULL) {
		crm_warn("Option %s not set", name);
		return NULL;
	}
	
	return crm_element_value(a_default, XML_NVPAIR_ATTR_VALUE);
}

const char *
get_agent_param(resource_t *rsc, const char *param)
{
	const char *value = NULL;

	if(param == NULL) {
		return NULL;
	}
	
	value = get_agent_param_rsc(rsc, param);
	if(value == NULL) {
		value = get_agent_param_metadata(rsc, param);
	}
	if(value == NULL) {
		value = get_agent_param_global(rsc, param);
	}
	
	return value;
}

const char *
get_agent_param_rsc(resource_t *rsc, const char *param)
{
	crm_data_t * xml_rsc = rsc->xml;
	return crm_element_value(xml_rsc, param);
}

const void *
get_agent_param_metadata(resource_t *rsc, const char *param)
{
	return NULL;
}

const char *
get_agent_param_global(resource_t *rsc, const char *param)
{
	const char * value = NULL;/*g_hashtable_lookup(agent_global_defaults, param); */
	if(value == NULL) {
		crm_err("No global value default for %s", param);
	}
	return value;
}

gboolean
unpack_global_defaults(crm_data_t * defaults)
{
	return TRUE;
}


gboolean
unpack_nodes(crm_data_t * xml_nodes, GListPtr *nodes)
{
	node_t *new_node   = NULL;
	crm_data_t * attrs   = NULL;
	const char *id     = NULL;
	const char *uname  = NULL;
	const char *type   = NULL;

	crm_verbose("Begining unpack...");
	xml_child_iter(
		xml_nodes, xml_obj, XML_CIB_TAG_NODE,

		id     = crm_element_value(xml_obj, XML_ATTR_ID);
		uname  = crm_element_value(xml_obj, XML_ATTR_UNAME);
		type   = crm_element_value(xml_obj, XML_ATTR_TYPE);
		crm_verbose("Processing node %s/%s", uname, id);

		attrs = find_xml_node(xml_obj, "attributes", FALSE);
		
		if(id == NULL) {
			crm_err("Must specify id tag in <node>");
			continue;
		}
		if(type == NULL) {
			crm_err("Must specify type tag in <node>");
			continue;
		}
		crm_malloc(new_node, sizeof(node_t));
		if(new_node == NULL) {
			return FALSE;
		}
		
		new_node->weight = 1.0;
		new_node->fixed  = FALSE;
		crm_malloc(new_node->details,
			   sizeof(struct node_shared_s));

		if(new_node->details == NULL) {
			crm_free(new_node);
			return FALSE;
		}

		crm_verbose("Creaing node for entry %s/%s", uname, id);
		new_node->details->id		= id;
		new_node->details->uname	= uname;
		new_node->details->type		= node_ping;
		new_node->details->online	= FALSE;
		new_node->details->unclean	= TRUE; /* all nodes are unclean until we've seen their status entry */
		new_node->details->shutdown	= FALSE;
		new_node->details->running_rsc	= NULL;
		new_node->details->agents	= NULL;
		new_node->details->attrs        = g_hash_table_new(
			g_str_hash, g_str_equal);
		
		if(safe_str_eq(type, "member")) {
			new_node->details->type = node_member;
		}

		add_node_attrs(attrs, new_node);
		*nodes = g_list_append(*nodes, new_node);    
		crm_verbose("Done with node %s",
			    crm_element_value(xml_obj, XML_ATTR_UNAME));

		crm_devel_action(print_node("Added", new_node, FALSE));
		);
  
	*nodes = g_list_sort(*nodes, sort_node_weight);

	return TRUE;
}

gboolean 
unpack_resources(crm_data_t * xml_resources,
		 GListPtr *resources,
		 GListPtr *actions,
		 GListPtr *ordering_constraints,
		 GListPtr all_nodes)
{
	crm_verbose("Begining unpack...");
	xml_child_iter(
		xml_resources, xml_obj, NULL,

		resource_t *new_rsc = NULL;
		if(common_unpack(xml_obj, &new_rsc)) {
			*resources = g_list_append(*resources, new_rsc);
			crm_devel_action(
				print_resource("Added", new_rsc, FALSE));
		} else {
			crm_err("Failed unpacking resource %s",
				crm_element_value(xml_obj, XML_ATTR_ID));
		}
		);
	
	*resources = g_list_sort(*resources, sort_rsc_priority);

	return TRUE;
}

gboolean 
unpack_constraints(crm_data_t * xml_constraints,
		   GListPtr nodes, GListPtr resources,
		   GListPtr *placement_constraints,
		   GListPtr *ordering_constraints)
{
	crm_verbose("Begining unpack...");
	xml_child_iter(
		xml_constraints, xml_obj, NULL,

		const char *id = crm_element_value(xml_obj, XML_ATTR_ID);
		if(id == NULL) {
			crm_err("Constraint <%s...> must have an id",
				crm_element_name(xml_obj));
			continue;
		}

		crm_verbose("Processing constraint %s %s", crm_element_name(xml_obj),id);
		if(safe_str_eq(XML_CONS_TAG_RSC_ORDER, crm_element_name(xml_obj))) {
			unpack_rsc_order(
				xml_obj, resources, ordering_constraints);

		} else if(safe_str_eq(XML_CONS_TAG_RSC_DEPEND, crm_element_name(xml_obj))) {
			unpack_rsc_dependancy(
				xml_obj, resources, ordering_constraints);

		} else if(safe_str_eq(XML_CONS_TAG_RSC_LOCATION, crm_element_name(xml_obj))) {
			unpack_rsc_location(
				xml_obj, resources, nodes, placement_constraints);

		} else {
			crm_err("Unsupported constraint type: %s", crm_element_name(xml_obj));
		}
		);

	return TRUE;
}

rsc_to_node_t *
rsc2node_new(const char *id, resource_t *rsc,
	     double weight, gboolean can, node_t *node,
	     GListPtr *placement_constraints)
{
	rsc_to_node_t *new_con = NULL;

	if(rsc == NULL || id == NULL) {
		crm_err("Invalid constraint %s for rsc=%p", crm_str(id), rsc);
		return NULL;
	}

	crm_malloc(new_con, sizeof(rsc_to_node_t));
	if(new_con != NULL) {
		new_con->id           = id;
		new_con->rsc_lh       = rsc;
		new_con->node_list_rh = NULL;
		new_con->can          = can;
		
		if(can) {
			new_con->weight = weight;
		} else {
			new_con->weight = -1;
		}
		
		if(node != NULL) {
			new_con->node_list_rh = g_list_append(NULL, node);
		}
		
		*placement_constraints = g_list_append(*placement_constraints, new_con);
	}
	
	return new_con;
}




/* remove nodes that are down, stopping */
/* create +ve rsc_to_node constraints between resources and the nodes they are running on */
/* anything else? */
gboolean
unpack_status(crm_data_t * status,
	      GListPtr nodes, GListPtr rsc_list,
	      GListPtr *actions, GListPtr *placement_constraints)
{
	const char *uname     = NULL;

	crm_data_t * lrm_rsc    = NULL;
	crm_data_t * lrm_agents = NULL;
	crm_data_t * attrs      = NULL;
	node_t    *this_node  = NULL;
	
	crm_verbose("Begining unpack");
	xml_child_iter(
		status, node_state, XML_CIB_TAG_STATE,

/*		id         = crm_element_value(node_state, XML_ATTR_ID); */
		uname = crm_element_value(node_state,    XML_ATTR_UNAME);
		attrs = find_xml_node(node_state, XML_LRM_TAG_ATTRIBUTES,FALSE);

		lrm_rsc    = find_xml_node(node_state, XML_CIB_TAG_LRM, FALSE);
		lrm_agents = find_xml_node(lrm_rsc, XML_LRM_TAG_AGENTS, FALSE);

		lrm_rsc = find_xml_node(lrm_rsc, XML_LRM_TAG_RESOURCES, FALSE);

		crm_verbose("Processing node %s", uname);
		this_node = pe_find_node(nodes, uname);

		if(uname == NULL) {
			/* error */
			continue;

		} else if(this_node == NULL) {
			crm_warn("Node %s in status section no longer exists",
				uname);
			continue;
		}

		/* Mark the node as provisionally clean
		 * - at least we have seen it in the current cluster's lifetime
		 */
		this_node->details->unclean = FALSE;
		
		crm_verbose("Adding runtime node attrs");
		add_node_attrs(attrs, this_node);

		crm_verbose("determining node state");
		determine_online_status(node_state, this_node);

		crm_verbose("Processing lrm resource entries");
		unpack_lrm_rsc_state(this_node, lrm_rsc, rsc_list, nodes,
				     actions, placement_constraints);