restree.c

/*
  Copyright Red Hat, Inc. 2004-2006

  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, or (at your option) any
  later version.

  This program 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 program; see the file COPYING.  If not, write to the
  Free Software Foundation, Inc.,  675 Mass Ave, Cambridge, 
  MA 02139, USA.

  Fix for #193859 - relocation of a service w/o umounting file-systems
    by Navid Sheikhol-Eslami [ navid at redhat dot com ]
*/
#include <libxml/parser.h>
#include <libxml/xmlmemory.h>
#include <libxml/xpath.h>
#include <stdlib.h>
#include <stdio.h>
#include <list.h>
#include <sys/wait.h>
#include <resgroup.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <reslist.h>
#include <assert.h>
#include <xmlconf.h>


/* XXX from resrules.c */
int store_childtype(resource_child_t **childp, char *name, int start,
		    int stop, int forbid, int flags);
int _res_op(xmlNode **xpp, xmlNode *rmp, resource_node_t **tree, resource_t *first, char *type);
static inline int
_res_op_internal(xmlNode **xpp, xmlNode *rmp, resource_node_t **tree, resource_t *first,
		 char *type, resource_node_t *node);

/* XXX from reslist.c */
void * act_dup(resource_act_t *acts);


/**
   Fold a resource into an XML node.

   @param xpp		XML node pp
   @param rmp		resources block pp
   @param node		Resource tree node we're dealing with
   @param op		Operation to perform (stop/start/etc.)
   @param depth		OCF Check level/depth
   @return		Return value of script.
   @see			build_env
 */
int
res_do_flatten(xmlNode **xpp, xmlNode *rmp, resource_node_t *node, const char *arg,
	       int depth)
{
	xmlNode *n, *r;
	resource_attr_t *ra;
	resource_t *res = node->rn_resource;
	char *val;
	char buf[256];
	int x, y;

	n = xmlNewNode(NULL, (xmlChar *)node->rn_resource->r_rule->rr_type);

	xmlSetProp(n, (xmlChar *)"rgmanager-meta-agent",
		   (xmlChar *)basename(node->rn_resource->r_rule->rr_agent));

	/* Multiple-instance resources must be decomposed into separate
	   resources */
	if (node->rn_resource->r_refs > 1) {
		snprintf(buf, sizeof(buf), "%s_%d",
			 primary_attr_value(node->rn_resource),
			 node->rn_resource->r_incarnations);
		++node->rn_resource->r_incarnations;
	} else {
		snprintf(buf, sizeof(buf), "%s",
			 primary_attr_value(node->rn_resource));
	}

	for (x = 0; node->rn_resource->r_attrs &&
		    node->rn_resource->r_attrs[x].ra_name; x++) {
		ra = &node->rn_resource->r_attrs[x];

		if (ra->ra_flags & RA_PRIMARY) {
			xmlSetProp(n, (xmlChar *)ra->ra_name, (xmlChar *)buf);
		} else {
			val = attr_value(node, res->r_attrs[x].ra_name);
			if (!val)
				continue;

			for (y = 0; res->r_rule->rr_attrs[y].ra_name; y++) {
				if (strcmp(ra->ra_name,
					   res->r_rule->rr_attrs[y].ra_name))
					continue;

				if (!res->r_rule->rr_attrs[y].ra_value ||
				    strcmp(val, res->r_rule->rr_attrs[y].ra_value))
					xmlSetProp(n, (xmlChar *)ra->ra_name, (xmlChar *)val);
			}
		}
	}

	if (!*xpp) {
		/* Add top-level container */
		*xpp = n;
	} else {
		if (!rmp) {
			xmlAddChild(*xpp, n);
		} else {
			r = xmlNewNode(NULL, (xmlChar *)node->rn_resource->r_rule->rr_type);
			xmlSetProp(r, (xmlChar *)"ref", (xmlChar *)primary_attr_value(node->rn_resource));
			xmlAddChild(rmp, n);
			xmlAddChild(*xpp, r);
		}
	}

	return 0;
}


static inline void
assign_restart_policy(resource_t *curres, resource_node_t *parent,
		      resource_node_t *node, char *base)
{
	char *val;
	int max_restarts = 0;
	time_t restart_expire_time = 0;
	char tok[1024];

	if (!curres || !node)
		return;
	if (parent &&
	    !(node->rn_flags & RF_INDEPENDENT))
		return;

	if (node->rn_flags & RF_INDEPENDENT) {
		/* per-resource-node failures / expire times */
		snprintf(tok, sizeof(tok), "%s/@__max_restarts", base);
		if (conf_get(tok, &val) == 0) {
			max_restarts = atoi(val);
			if (max_restarts <= 0)
				max_restarts = 0;
			free(val);
		}
	
		snprintf(tok, sizeof(tok), "%s/@__restart_expire_time", base);
		if (conf_get(tok, &val) == 0) {
			restart_expire_time = (time_t)expand_time(val);
			if ((int64_t)restart_expire_time <= 0)
				restart_expire_time = 0;
			free(val);
		}

		//if (restart_expire_time == 0 || max_restarts == 0)
			return;
		//goto out_assign;
	}

	val = (char *)res_attr_value(curres, "max_restarts");
	if (!val)
		return;
	max_restarts = atoi(val);
	if (max_restarts <= 0)
		return;
	val = res_attr_value(curres, "restart_expire_time");
	if (val) {
		restart_expire_time = (time_t)expand_time(val);
		if ((int64_t)restart_expire_time < 0)
			return;
	}

//out_assign:
	return;
}


static inline int
do_load_resource(char *base,
	         resource_rule_t *rule,
	         resource_node_t **tree,
		 resource_t **reslist,
		 resource_node_t *parent,
		 resource_node_t **newnode)
{
	char tok[512];
	char *ref;
	resource_node_t *node;
	resource_t *curres;
	time_t failure_expire = 0;
	int max_failures = 0;

	snprintf(tok, sizeof(tok), "%s/@ref", base);

	if (conf_get(tok, &ref) != 0) {
		/* There wasn't an existing resource. See if there
		   is one defined inline */
		curres = load_resource(rule, base);
		if (!curres) {
			/* No ref and no new one inline == 
			   no more of the selected type */
			return 1;
		}

	       	if (store_resource(reslist, curres) != 0) {
	 		fprintf(stderr,"Error storing %s resource\n",
	 		       curres->r_rule->rr_type);
	 		destroy_resource(curres);
			return -1;
	 	}

		curres->r_flags = RF_INLINE;

	} else {

		curres = find_resource_by_ref(reslist, rule->rr_type,
						      ref);
		if (!curres) {
			fprintf(stderr,"Error: Reference to nonexistent "
			       "resource %s (type %s)\n", ref,
			       rule->rr_type);
			free(ref);
			return -1;
		}

		if (curres->r_flags & RF_INLINE) {
			fprintf(stderr,"Error: Reference to inlined "
			       "resource %s (type %s) is illegal\n",
			       ref, rule->rr_type);
			free(ref);
			return -1;
		}
		free(ref);
	}

	/* Load it if its max refs hasn't been exceeded */
	if (rule->rr_maxrefs && (curres->r_refs >= rule->rr_maxrefs)){
		fprintf(stderr,"Warning: Max references exceeded for resource"
		       " %s (type %s)\n", curres->r_attrs[0].ra_name,
		       rule->rr_type);
		return -1;
	}

	node = malloc(sizeof(*node));
	if (!node)
		return -1;

	memset(node, 0, sizeof(*node));

	//printf("New resource tree node: %s:%s \n", curres->r_rule->rr_type,curres->r_attrs->ra_value);

	node->rn_child = NULL;
	node->rn_parent = parent;
	node->rn_resource = curres;
	node->rn_state = RES_STOPPED;
	node->rn_flags = 0;
	node->rn_actions = (resource_act_t *)act_dup(curres->r_actions);

	if (parent) {
		/* Independent subtree / non-critical for top-level is
		 * not useful and can interfere with restart thresholds for
		 * non critical resources */
		snprintf(tok, sizeof(tok), "%s/@__independent_subtree", base);
		if (conf_get(tok, &ref) == 0) {
			if (atoi(ref) == 1 || strcasecmp(ref, "yes") == 0)
				node->rn_flags |= RF_INDEPENDENT;
			if (atoi(ref) == 2 || strcasecmp(ref, "non-critical") == 0) {
				curres->r_flags |= RF_NON_CRITICAL;
			}
			free(ref);
		}
	}

	snprintf(tok, sizeof(tok), "%s/@__enforce_timeouts", base);
	if (conf_get(tok, &ref) == 0) {
		if (atoi(ref) > 0 || strcasecmp(ref, "yes") == 0)
			node->rn_flags |= RF_ENFORCE_TIMEOUTS;
		free(ref);
	}

	/* per-resource-node failures / expire times */
	snprintf(tok, sizeof(tok), "%s/@__max_failures", base);
	if (conf_get(tok, &ref) == 0) {
		max_failures = atoi(ref);
		if (max_failures < 0)
			max_failures = 0;
		free(ref);
	}

	snprintf(tok, sizeof(tok), "%s/@__failure_expire_time", base);
	if (conf_get(tok, &ref) == 0) {
		failure_expire = (time_t)expand_time(ref);
		if ((int64_t)failure_expire < 0)
			failure_expire = 0;
		free(ref);
	}

	if (max_failures && failure_expire) {
		/*
		node->rn_failure_counter = restart_init(failure_expire,
							max_failures);
		 */
	}

	curres->r_refs++;

	if (curres->r_refs > 1 &&
	    (curres->r_flags & RF_NON_CRITICAL)) {
		res_build_name(tok, sizeof(tok), curres);
		fprintf(stderr,"Non-critical flag for %s is being cleared due to multiple references.\n", tok);
		curres->r_flags &= ~RF_NON_CRITICAL;
	}

	if (curres->r_flags & RF_NON_CRITICAL) {
		/* Independent subtree is implied if a
		 * resource is non-critical
		 */
		node->rn_flags |= RF_NON_CRITICAL | RF_INDEPENDENT;

	}

	assign_restart_policy(curres, parent, node, base);

	*newnode = node;

	list_insert(tree, node);

	return 0;
}


/**
   Build the resource tree.  If a new resource is defined inline, add it to
   the resource list.  All rules, however, must have already been read in.

   @param tree		Tree to modify/insert on to
   @param parent	Parent node, if one exists.
   @param rule		Rule surrounding the new node
   @param rulelist	List of all rules allowed in the tree.
   @param reslist	List of all currently defined resources
   @param base		Base CCS path.
   @see			destroy_resource_tree
 */
#define RFL_FOUND 0x1
#define RFL_FORBID 0x2
static int
build_tree(resource_node_t **tree,
	   resource_node_t *parent,
	   resource_rule_t *rule,
	   resource_rule_t **rulelist,
	   resource_t **reslist, char *base)
{
	char tok[512];
	resource_rule_t *childrule;
	resource_node_t *node;
	char *ref;
	char *tmp;
	int ccount = 0, x = 0, y = 0, flags = 0;

	//printf("DESCEND: %s / %s\n", rule?rule->rr_type:"(none)", base);

	/* Pass 1: typed / defined children */
	for (y = 0; rule && rule->rr_childtypes &&
     	     rule->rr_childtypes[y].rc_name; y++) {
		
	
		flags = 0;
		list_for(rulelist, childrule, x) {
			if (strcmp(rule->rr_childtypes[y].rc_name,
				   childrule->rr_type))
				continue;

			flags |= RFL_FOUND;

			if (rule->rr_childtypes[y].rc_forbid)
				flags |= RFL_FORBID;

			break;
		}

		if (flags & RFL_FORBID)
			/* Allow all *but* forbidden */
			continue;

		if (!(flags & RFL_FOUND))
			/* Not found?  Wait for pass 2 */
			continue;

		//printf("looking for %s %s @ %s\n",
			//rule->rr_childtypes[y].rc_name,
			//childrule->rr_type, base);
		for (x = 1; ; x++) {

			/* Search for base/type[x]/@ref - reference an existing
			   	resource */
			snprintf(tok, sizeof(tok), "%s/%s[%d]", base,
				 childrule->rr_type, x);

			flags = 1;
			switch(do_load_resource(tok, childrule, tree,
						reslist, parent, &node)) {
			case -1:
				continue;
			case 1:
				/* 1 == no more */
				//printf("No resource found @ %s\n", tok);
				flags = 0;
				break;
			case 0:
				break;
			}
			if (!flags)
				break;

			/* Got a child :: bump count */
			snprintf(tok, sizeof(tok), "%s/%s[%d]", base,
				 childrule->rr_type, x);

			/* Kaboom */
			build_tree(&node->rn_child, node, childrule,
				   rulelist, reslist, tok);

		}
	}


	/* Pass 2: untyped children */
	for (ccount=1; ; ccount++) {
		snprintf(tok, sizeof(tok), "%s/child::*[%d]", base, ccount);

		if (conf_get(tok, &ref) != 0) {
			/* End of the line. */
			//printf("End of the line: %s\n", tok);
			break;
		}

		tmp = strchr(ref, '=');
		if (tmp) {
			*tmp = 0;
		} else {
			/* no = sign... bad */
			free(ref);
			continue;
		}

		/* Find the resource rule */
		flags = 0;
		list_for(rulelist, childrule, x) {
			if (!strcasecmp(childrule->rr_type, ref)) {
				/* Ok, matching rule found */
				flags = 1;
				break;
			}
		}
		/* No resource rule matching the child?  Press on... */
		if (!flags) {
			free(ref);
			continue;
		}

		flags = 0;
		/* Don't descend on anything we should have already picked
		   up on in the above loop */
		for (y = 0; rule && rule->rr_childtypes &&
		     rule->rr_childtypes[y].rc_name; y++) {
			/* SKIP defined child types of any type */
			if (strcmp(rule->rr_childtypes[y].rc_name, ref))
				continue;
			if (rule->rr_childtypes[y].rc_flags == 0) {
				/* 2 = defined as a real child */
				flags = 2;
				break;
			}

			flags = 1;
			break;
		}

		free(ref);
		if (flags == 2)
			continue;

		x = 1;
		switch(do_load_resource(tok, childrule, tree,
				        reslist, parent, &node)) {
		case -1:
			continue;
		case 1:
			/* no more found */
			x = 0;
			fprintf(stderr,"No resource found @ %s\n", tok);
			break;
		case 0:
			/* another is found */
			break;
		}
		if (!x) /* no more found */
			break;

		/* childrule = rule set of this child at this point */
		/* tok = set above; if we got this far, we're all set */
		/* Kaboom */

		build_tree(&node->rn_child, node, childrule,
			   rulelist, reslist, tok);
	}

	//printf("ASCEND: %s / %s\n", rule?rule->rr_type:"(none)", base);
	return 0;
}


/**
   Set up to call build_tree.  Hides the nastiness from the user.

   @param tree		Tree pointer.  Should start as a pointer to NULL.
   @param rulelist	List of all rules allowed
   @param reslist	List of all currently defined resources
   @return 		0
   @see			build_tree destroy_resource_tree
 */
int
build_resource_tree(resource_node_t **tree,
		    resource_rule_t **rulelist,
		    resource_t **reslist)
{
	resource_node_t *root = NULL;
	char tok[512];

	snprintf(tok, sizeof(tok), "%s", RESOURCE_TREE_ROOT);

	/* Find and build the list of root nodes */
	build_tree(&root, NULL, NULL/*curr*/, rulelist, reslist, tok);

	if (root)
		*tree = root;

	return 0;
}


/**
   Deconstruct a resource tree.

   @param tree		Tree to obliterate.
   @see			build_resource_tree
 */
void
destroy_resource_tree(resource_node_t **tree)
{
	resource_node_t *node;

	while ((node = *tree)) {
		if ((*tree)->rn_child)
			destroy_resource_tree(&(*tree)->rn_child);

		list_remove(tree, node);

		if(node->rn_actions){
			free(node->rn_actions);
		}
		free(node);
	}
}


static inline int
_do_child_levels(xmlNode **xpp, xmlNode *rmp, resource_node_t **tree, resource_t *first)
{
	resource_node_t *node = *tree;
	resource_t *res = node->rn_resource;
	resource_rule_t *rule = res->r_rule;
	int l, lev, x, rv = 0;

	for (l = 1; l <= RESOURCE_MAX_LEVELS; l++) {

		for (x = 0; rule->rr_childtypes &&
		     rule->rr_childtypes[x].rc_name; x++) {

			lev = rule->rr_childtypes[x].rc_startlevel;

			if (!lev || lev != l)
				continue;

			/* Do op on all children at our level */
			rv |= _res_op(xpp, rmp, &node->rn_child, first,
			     	     rule->rr_childtypes[x].rc_name);

			if (rv & SFL_FAILURE)
				return rv;
		}

		if (rv != 0)
			return rv;
	}

	return rv;
}


static inline int
_xx_child_internal(xmlNode **xpp, xmlNode *rmp, resource_node_t *node, resource_t *first,
		   resource_node_t *child)
{
	int x;
	resource_rule_t *rule = node->rn_resource->r_rule;

	for (x = 0; rule->rr_childtypes &&
     	     rule->rr_childtypes[x].rc_name; x++) {
		if (!strcmp(child->rn_resource->r_rule->rr_type,
			    rule->rr_childtypes[x].rc_name)) {
			if (rule->rr_childtypes[x].rc_startlevel ||
			    rule->rr_childtypes[x].rc_stoplevel) {
				return 0;
			}
		}
	}

	return _res_op_internal(xpp, rmp, &child, first,
	 		       child->rn_resource->r_rule->rr_type,
			       child);
}


static inline int
_do_child_default_level(xmlNode **xpp, xmlNode *rmp, resource_node_t **tree, resource_t *first)
{
	resource_node_t *node = *tree, *child;
	int y, rv = 0;

	list_for(&node->rn_child, child, y) {
		rv |= _xx_child_internal(xpp, rmp, node, first, child);

		if (rv & SFL_FAILURE)
			return rv;
	}

	return rv;
}


/**
   Nasty codependent function.  Perform an operation by numerical level
   at some point in the tree.  This allows indirectly-dependent resources
   (such as IP addresses and user scripts) to have ordering without requiring
   a direct dependency.

   @param tree		Resource tree to search/perform operations on
   @param first		Resource we're looking to perform the operation on,
   			if one exists.
   @param ret		Unused, but will be used to store status information
   			such as resources consumed, etc, in the future.
   @param op		Operation to perform if either first is found,
   			or no first is declared (in which case, all nodes
			in the subtree).
   @see			_res_op res_exec
 */
int
_res_op_by_level(xmlNode **xpp, xmlNode *rmp, resource_node_t **tree, resource_t *first)
{
	resource_node_t *node = *tree;
	resource_t *res = node->rn_resource;
	resource_rule_t *rule = res->r_rule;
	int rv = 0;

	if (!rule->rr_childtypes)
		return _res_op(xpp, rmp, &node->rn_child, first, NULL);

	rv |= _do_child_levels(xpp, rmp, tree, first);
       	if (rv & SFL_FAILURE)
		return rv;

	/* default level after specified ones */
	rv |= _do_child_default_level(xpp, rmp, tree, first);

	return rv;
}


/**
   Nasty codependent function.  Perform an operation by type for all siblings
   at some point in the tree.  This allows indirectly-dependent resources
   (such as IP addresses and user scripts) to have ordering without requiring
   a direct dependency.

   @param tree		Resource tree to search/perform operations on
   @param first		Resource we're looking to perform the operation on,
   			if one exists.
   @param type		Type to look for.
   @see			_res_op_by_level res_exec
 */
static inline int
_res_op_internal(xmlNode **xpp, xmlNode *rmp,
		 resource_node_t __attribute__ ((unused)) **tree,
		 resource_t *first,
		 char *type, 
		 resource_node_t *node)
{
	int rv = 0, me;

	/* Restore default operation. */

	/* If we're starting by type, do that funky thing. */
	if (type && strlen(type) &&
	    strcmp(node->rn_resource->r_rule->rr_type, type))
		return 0;

	/* If the resource is found, all nodes in the subtree must
	   have the operation performed as well. */
	me = !first || (node->rn_resource == first);

	/* Start starts before children */
	if (me) {

		rv = res_do_flatten(xpp, rmp, node, NULL, 0);

	}

	if (node->rn_child) {
                rv |= _res_op_by_level(xpp, rmp, &node, me?NULL:first);
	}
	
	return rv;
}


/**
   Nasty codependent function.  Perform an operation by type for all siblings
   at some point in the tree.  This allows indirectly-dependent resources
   (such as IP addresses and user scripts) to have ordering without requiring
   a direct dependency.

   @param tree		Resource tree to search/perform operations on
   @param first		Resource we're looking to perform the operation on,
   			if one exists.
   @param type		Type to look for.
   @see			_res_op_by_level res_exec
 */
int
_res_op(xmlNode **xpp, xmlNode *rmp, resource_node_t **tree, resource_t *first,
	char *type)
{
  	resource_node_t *node;
 	int count = 0, rv = 0;
 	
	list_for(tree, node, count) {
 		rv |= _res_op_internal(xpp, rmp, tree, first, type, node);

 		if (rv & SFL_FAILURE) 
 			return rv;
 	}

	return rv;
}


/**
   Flatten resources for a service and return the pointer to it.

   @param tree		Tree to search for our resource.
   @param res		Resource to start/stop
   @param ret		Unused
 */
int
res_flatten(xmlNode **xpp, xmlNode *rmp, resource_node_t **tree, resource_t *res)
{
	return _res_op(xpp, rmp, tree, res, NULL);
}