No OneTemporary
Actions

Size

136 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/shell/modules/cibconfig.py b/shell/modules/cibconfig.py
	index ad1ce016b6..ae6bf15f56 100644
	--- a/shell/modules/cibconfig.py
	+++ b/shell/modules/cibconfig.py
	@@ -1,2322 +1,2367 @@
	# Copyright (C) 2008 Dejan Muhamedagic <dmuhamedagic@suse.de>
	#
	# 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
	#

	import sys
	import subprocess
	import copy
	import xml.dom.minidom
	import re

	from singletonmixin import Singleton
	from userprefs import Options, UserPrefs
	from vars import Vars
	from cliformat import *
	from utils import *
	from xmlutil import *
	from msg import *
	from parse import CliParser
	from clidisplay import CliDisplay
	from cibstatus import CibStatus
	from idmgmt import IdMgmt
	from ra import RAInfo

	def show_unrecognized_elems(doc):
	try:
	conf = doc.getElementsByTagName("configuration")[0]
	except:
	common_warn("CIB has no configuration element")
	return
	for topnode in conf.childNodes:
	if not is_element(topnode):
	continue
	if is_defaults(topnode):
	continue
	if not topnode.tagName in cib_topnodes:
	common_warn("unrecognized CIB element %s" % c.tagName)
	continue
	for c in topnode.childNodes:
	if not is_element(c):
	continue
	if not c.tagName in cib_object_map:
	common_warn("unrecognized CIB element %s" % c.tagName)

	#
	# object sets (enables operations on sets of elements)
	#
	def mkset_obj(*args):
	if args and args[0] == "xml":
	obj = lambda: CibObjectSetRaw(*args[1:])
	else:
	obj = lambda: CibObjectSetCli(*args)
	return obj()

	class CibObjectSet(object):
	'''
	Edit or display a set of cib objects.
	repr() for objects representation and
	save() used to store objects into internal structures
	are defined in subclasses.
	'''
	def __init__(self, *args):
	self.obj_list = []
	def _open_url(self,src):
	import urllib
	try:
	return urllib.urlopen(src)
	except:
	pass
	if src == "-":
	return sys.stdin
	try:
	return open(src)
	except:
	pass
	common_err("could not open %s" % src)
	return False
	def init_aux_lists(self):
	'''
	Before edit, initialize two auxiliary lists which will
	hold a list of objects to be removed and a list of
	objects which were created. Then, we can create a new
	object list which will match the current state of
	affairs, i.e. the object set after the last edit.
	'''
	self.remove_objs = copy.copy(self.obj_list)
	self.add_objs = []
	def recreate_obj_list(self):
	'''
	Recreate obj_list: remove deleted objects and add
	created objects
	'''
	for obj in self.remove_objs:
	self.obj_list.remove(obj)
	self.obj_list += self.add_objs
	rmlist = []
	for obj in self.obj_list:
	if obj.invalid:
	rmlist.append(obj)
	for obj in rmlist:
	self.obj_list.remove(obj)
	def edit_save(self,s,erase = False):
	'''
	Save string s to a tmp file. Invoke editor to edit it.
	Parse/save the resulting file. In case of syntax error,
	allow user to reedit. If erase is True, erase the CIB
	first.
	If no changes are done, return silently.
	'''
	tmp = str2tmp(s)
	if not tmp:
	return False
	filehash = hash(s)
	rc = False
	while True:
	if edit_file(tmp) != 0:
	break
	try: f = open(tmp,'r')
	except IOError, msg:
	common_err(msg)
	break
	s = ''.join(f)
	f.close()
	if hash(s) == filehash: # file unchanged
	rc = True
	break
	if erase:
	cib_factory.erase()
	if not self.save(s):
	if ask("Do you want to edit again?"):
	continue
	rc = True
	break
	try: os.unlink(tmp)
	except: pass
	return rc
	def edit(self):
	if options.batch:
	common_info("edit not allowed in batch mode")
	return False
	cli_display.set_no_pretty()
	s = self.repr()
	cli_display.reset_no_pretty()
	return self.edit_save(s)
	def save_to_file(self,fname):
	if fname == "-":
	f = sys.stdout
	else:
	if not options.batch and os.access(fname,os.F_OK):
	if not ask("File %s exists. Do you want to overwrite it?"%fname):
	return False
	try: f = open(fname,"w")
	except IOError, msg:
	common_err(msg)
	return False
	rc = True
	cli_display.set_no_pretty()
	s = self.repr()
	cli_display.reset_no_pretty()
	if s:
	f.write(s)
	f.write('\n')
	elif self.obj_list:
	rc = False
	if f != sys.stdout:
	f.close()
	return rc
	def show(self):
	s = self.repr()
	if not s:
	if self.obj_list: # objects could not be displayed
	return False
	else:
	return True
	page_string(s)
	def import_file(self,method,fname):
	if not cib_factory.is_cib_sane():
	return False
	if method == "replace":
	if options.interactive and cib_factory.has_cib_changed():
	if not ask("This operation will erase all changes. Do you want to proceed?"):
	return False
	cib_factory.erase()
	f = self._open_url(fname)
	if not f:
	return False
	s = ''.join(f)
	if f != sys.stdin:
	f.close()
	return self.save(s, method == "update")
	def repr(self):
	'''
	Return a string with objects's representations (either
	CLI or XML).
	'''
	return ''
	def save(self, s, update = False):
	'''
	For each object:
	- try to find a corresponding object in obj_list
	- if (update and not found) or found:
	replace the object in the obj_list with
	the new object
	- if not found: create new
	See below for specific implementations.
	'''
	pass
	def verify2(self):
	'''
	Test objects for sanity. This is about semantics.
	'''
	rc = 0
	for obj in self.obj_list:
	rc \|= obj.check_sanity()
	return rc
	def lookup_cli(self,cli_list):
	for obj in self.obj_list:
	if obj.matchcli(cli_list):
	return obj
	def lookup(self,xml_obj_type,obj_id):
	for obj in self.obj_list:
	if obj.match(xml_obj_type,obj_id):
	return obj
	def drop_remaining(self):
	'Any remaining objects in obj_list are deleted.'
	l = [x.obj_id for x in self.remove_objs]
	return cib_factory.delete(*l)

	def get_comments(cli_list):
	if not cli_list:
	return []
	last = cli_list[len(cli_list)-1]
	try:
	if last[0] == "comments":
	cli_list.pop()
	return last[1]
	except: pass
	return []

	class CibObjectSetCli(CibObjectSet):
	'''
	Edit or display a set of cib objects (using cli notation).
	'''
	def __init__(self, *args):
	CibObjectSet.__init__(self, *args)
	self.obj_list = cib_factory.mkobj_list("cli",*args)
	def repr(self):
	"Return a string containing cli format of all objects."
	if not self.obj_list:
	return ''
	return '\n'.join(obj.repr_cli() \
	for obj in processing_sort_cli(self.obj_list))
	def process(self, cli_list, update = False):
	'''
	Create new objects or update existing ones.
	'''
	comments = get_comments(cli_list)
	myobj = obj = self.lookup_cli(cli_list)
	if update and not obj:
	obj = cib_factory.find_object_for_cli(cli_list)
	if obj:
	rc = cib_factory.update_from_cli(obj,cli_list) != False
	if myobj:
	self.remove_objs.remove(myobj)
	else:
	obj = cib_factory.create_from_cli(cli_list)
	rc = obj != None
	if rc:
	self.add_objs.append(obj)
	if rc:
	obj.set_comment(comments)
	return rc
	def save(self, s, update = False):
	'''
	Save a user supplied cli format configuration.
	On errors user is typically asked to review the
	configuration (for instance on editting).

	On syntax error (return code 1), no changes are done, but
	on semantic errors (return code 2), some changes did take
	place so object list must be updated properly.

	Finally, once syntax check passed, there's no way back,
	all changes are applied to the current configuration.

	TODO: Implement undo configuration changes.
	'''
	l = []
	rc = True
	err_buf.start_tmp_lineno()
	cp = CliParser()
	for cli_text in lines2cli(s):
	err_buf.incr_lineno()
	cli_list = cp.parse(cli_text)
	if cli_list:
	l.append(cli_list)
	elif cli_list == False:
	rc = False
	err_buf.stop_tmp_lineno()
	# we can't proceed if there was a syntax error, but we
	# can ask the user to fix problems
	if not rc:
	return rc
	self.init_aux_lists()
	if l:
	for cli_list in processing_sort_cli(l):
	if self.process(cli_list,update) == False:
	rc = False
	if not self.drop_remaining():
	# this is tricky, we don't know what was removed!
	# it could happen that the user dropped a resource
	# which was running and therefore couldn't be removed
	rc = False
	self.recreate_obj_list()
	return rc

	cib_verify = "crm_verify -V -p"
	class CibObjectSetRaw(CibObjectSet):
	'''
	Edit or display one or more CIB objects (XML).
	'''
	def __init__(self, *args):
	CibObjectSet.__init__(self, *args)
	self.obj_list = cib_factory.mkobj_list("xml",*args)
	def repr(self):
	"Return a string containing xml of all objects."
	doc = cib_factory.objlist2doc(self.obj_list)
	s = doc.toprettyxml(user_prefs.xmlindent)
	doc.unlink()
	return s
	def repr_configure(self):
	'''
	Return a string containing xml of configure and its
	children.
	'''
	doc = cib_factory.objlist2doc(self.obj_list)
	conf_node = doc.getElementsByTagName("configuration")[0]
	s = conf_node.toprettyxml(user_prefs.xmlindent)
	doc.unlink()
	return s
	def process(self, node, update = False):
	if not cib_factory.is_cib_sane():
	return False
	myobj = obj = self.lookup(node.tagName,node.getAttribute("id"))
	if update and not obj:
	obj = cib_factory.find_object_for_node(node)
	if obj:
	rc = cib_factory.update_from_node(obj,node)
	if myobj:
	self.remove_objs.remove(obj)
	else:
	new_obj = cib_factory.create_from_node(node)
	rc = new_obj != None
	if rc:
	self.add_objs.append(new_obj)
	return rc
	def save(self, s, update = False):
	try:
	doc = xml.dom.minidom.parseString(s)
	except xml.parsers.expat.ExpatError,msg:
	cib_parse_err(msg,s)
	return False
	rc = True
	sanitize_cib(doc)
	show_unrecognized_elems(doc)
	newnodes = get_interesting_nodes(doc,[])
	self.init_aux_lists()
	if newnodes:
	for node in processing_sort(newnodes):
	if not self.process(node,update):
	rc = False
	if not self.drop_remaining():
	rc = False
	doc.unlink()
	self.recreate_obj_list()
	return rc
	def verify(self):
	if not self.obj_list:
	return True
	cli_display.set_no_pretty()
	rc = pipe_string(cib_verify,self.repr())
	cli_display.reset_no_pretty()
	return rc in (0,1)
	def ptest(self, nograph, scores, verbosity):
	if not cib_factory.is_cib_sane():
	return False
	ptest = "ptest -X -%s" % verbosity.upper()
	if scores:
	ptest = "%s -s" % ptest
	if user_prefs.dotty and not nograph:
	fd,tmpfile = mkstemp()
	ptest = "%s -D %s" % (ptest,tmpfile)
	else:
	tmpfile = None
	doc = cib_factory.objlist2doc(self.obj_list)
	cib = doc.childNodes[0]
	status = cib_status.get_status()
	if not status:
	common_err("no status section found")
	return False
	cib.appendChild(doc.importNode(status,1))
	pipe_string(ptest,doc.toprettyxml())
	doc.unlink()
	if tmpfile:
	p = subprocess.Popen("%s %s" % (user_prefs.dotty,tmpfile), shell=True, bufsize=0, stdin=None, stdout=None, stderr=None, close_fds=True)
	common_info("starting %s to show transition graph"%user_prefs.dotty)
	vars.tmpfiles.append(tmpfile)
	else:
	if not nograph:
	common_info("install graphviz to see a transition graph")
	return True

	#
	# XML generate utilities
	#
	def set_id(node,oldnode,id_hint,id_required = True):
	'''
	Set the id attribute for the node.
	Procedure:
	- if the node already contains "id", keep it
	- if the old node contains "id", copy that
	- if neither is true, then create a new one using id_hint
	(exception: if not id_required, then no new id is generated)
	Finally, save the new id in id_store.
	'''
	old_id = None
	new_id = node.getAttribute("id")
	if oldnode and oldnode.getAttribute("id"):
	old_id = oldnode.getAttribute("id")
	if not new_id:
	new_id = old_id
	if not new_id:
	if id_required:
	new_id = id_store.new(node,id_hint)
	else:
	id_store.save(new_id)
	if new_id:
	node.setAttribute("id",new_id)
	if oldnode and old_id == new_id:
	set_id_used_attr(oldnode)

	def mkxmlsimple(e,oldnode,id_hint):
	'''
	Create an xml node from the (name,dict) pair. The name is the
	name of the element. The dict contains a set of attributes.
	'''
	node = cib_factory.createElement(e[0])
	for n,v in e[1]:
	if n == "$children": # this one's skipped
	continue
	if n == "operation":
	v = v.lower()
	if n.startswith('$'):
	n = n.lstrip('$')
	if (type(v) != type('') and type(v) != type(u'')) \
	or v: # skip empty strings
	node.setAttribute(n,v)
	id_ref = node.getAttribute("id-ref")
	if id_ref:
	id_ref_2 = cib_factory.resolve_id_ref(e[0],id_ref)
	node.setAttribute("id-ref",id_ref_2)
	else:
	set_id(node,lookup_node(node,oldnode),id_hint)
	return node

	def mkxmlnvpairs(e,oldnode,id_hint):
	'''
	Create xml from the (name,dict) pair. The name is the name of
	the element. The dict contains a set of nvpairs. Stuff such
	as instance_attributes.
	NB: Other tags not containing nvpairs are fine if the dict is empty.
	'''
	node = cib_factory.createElement(e[0])
	match_node = lookup_node(node,oldnode)
	#if match_node:
	#print "found nvpairs set:",match_node.tagName,match_node.getAttribute("id")
	id_ref = find_value(e[1],"$id-ref")
	if id_ref:
	id_ref_2 = cib_factory.resolve_id_ref(e[0],id_ref)
	node.setAttribute("id-ref",id_ref_2)
	if e[0] != "operations":
	return node # id_ref is the only attribute (if not operations)
	e[1].remove(["$id-ref",id_ref])
	v = find_value(e[1],"$id")
	if v:
	node.setAttribute("id",v)
	e[1].remove(["$id",v])
	else:
	if e[0] == "operations": # operations don't need no id
	set_id(node,match_node,id_hint,id_required = False)
	else:
	set_id(node,match_node,id_hint)
	try:
	subpfx = vars.subpfx_list[e[0]]
	except: subpfx = ''
	subpfx = subpfx and "%s_%s" % (id_hint,subpfx) or id_hint
	nvpair_pfx = node.getAttribute("id") or subpfx
	for n,v in e[1]:
	nvpair = cib_factory.createElement("nvpair")
	node.appendChild(nvpair)
	nvpair.setAttribute("name",n)
	if v != None:
	nvpair.setAttribute("value",v)
	set_id(nvpair,lookup_node(nvpair,match_node),nvpair_pfx)
	return node

	def mkxmlop(e,oldnode,id_hint):
	'''
	Create an operation xml from the (name,dict) pair.
	'''
	node = cib_factory.createElement(e[0])
	inst_attr = []
	for n,v in e[1]:
	if n in olist(vars.req_op_attributes + vars.op_attributes):
	node.setAttribute(n,v)
	else:
	inst_attr.append([n,v])
	tmp = cib_factory.createElement("operations")
	oldops = lookup_node(tmp,oldnode) # first find old operations
	oldop = lookup_node(node,oldops)
	set_id(node,oldop,id_hint)
	if inst_attr:
	e = ["instance_attributes",inst_attr]
	nia = mkxmlnvpairs(e,oldop,node.getAttribute("id"))
	node.appendChild(nia)
	return node

	def mkxmldate(e,oldnode,id_hint):
	'''
	Create a date_expression xml from the (name,dict) pair.
	'''
	node = cib_factory.createElement(e[0])
	operation = find_value(e[1],"operation").lower()
	node.setAttribute("operation", operation)
	old_date = lookup_node(node,oldnode) # first find old date element
	set_id(node,old_date,id_hint)
	date_spec_attr = []
	for n,v in e[1]:
	if n in olist(vars.date_ops) or n == "operation":
	continue
	elif n in vars.in_range_attrs:
	node.setAttribute(n,v)
	else:
	date_spec_attr.append([n,v])
	if not date_spec_attr:
	return node
	elem = operation == "date_spec" and "date_spec" or "duration"
	tmp = cib_factory.createElement(elem)
	old_date_spec = lookup_node(tmp,old_date) # first find old date element
	set_id(tmp,old_date_spec,id_hint)
	for n,v in date_spec_attr:
	tmp.setAttribute(n,v)
	node.appendChild(tmp)
	return node

	def mkxmlrsc_set(e,oldnode,id_hint):
	'''
	Create a resource_set xml from the (name,dict) pair.
	'''
	node = cib_factory.createElement(e[0])
	old_rsc_set = lookup_node(node,oldnode) # first find old date element
	set_id(node,old_rsc_set,id_hint)
	for ref in e[1]:
	if ref[0] == "resource_ref":
	ref_node = cib_factory.createElement(ref[0])
	ref_node.setAttribute(ref[1][0],ref[1][1])
	node.appendChild(ref_node)
	elif ref[0] in ("sequential", "action", "role"):
	node.setAttribute(ref[0], ref[1])
	return node

	conv_list = {
	"params": "instance_attributes",
	"meta": "meta_attributes",
	"property": "cluster_property_set",
	"rsc_defaults": "meta_attributes",
	"op_defaults": "meta_attributes",
	"attributes": "instance_attributes",
	"operations": "operations",
	"op": "op",
	}
	def mkxmlnode(e,oldnode,id_hint):
	'''
	Create xml from the (name,dict) pair. The name is the name of
	the element. The dict contains either a set of nvpairs or a
	set of attributes. The id is either generated or copied if
	found in the provided xml. Stuff such as instance_attributes.
	'''
	if e[0] in conv_list:
	e[0] = conv_list[e[0]]
	if e[0] in ("instance_attributes","meta_attributes","operations","cluster_property_set"):
	return mkxmlnvpairs(e,oldnode,id_hint)
	elif e[0] == "op":
	return mkxmlop(e,oldnode,id_hint)
	elif e[0] == "date_expression":
	return mkxmldate(e,oldnode,id_hint)
	elif e[0] == "resource_set":
	return mkxmlrsc_set(e,oldnode,id_hint)
	else:
	return mkxmlsimple(e,oldnode,id_hint)

	def set_nvpair(set_node,name,value):
	n_id = set_node.getAttribute("id")
	for c in set_node.childNodes:
	if is_element(c) and c.getAttribute("name") == name:
	c.setAttribute("value",value)
	return
	np = cib_factory.createElement("nvpair")
	np.setAttribute("name",name)
	np.setAttribute("value",value)
	new_id = id_store.new(np,n_id)
	np.setAttribute("id",new_id)
	set_node.appendChild(np)

	#
	# cib element classes (CibObject the parent class)
	#
	class CibObject(object):
	'''
	The top level object of the CIB. Resources and constraints.
	'''
	state_fmt = "%16s %-8s%-8s%-8s%-8s%-8s%-4s"
	set_names = {}
	def __init__(self,xml_obj_type,obj_id = None):
	if not xml_obj_type in cib_object_map:
	unsupported_err(xml_obj_type)
	return
	self.obj_type = cib_object_map[xml_obj_type][0]
	self.parent_type = cib_object_map[xml_obj_type][2]
	self.xml_obj_type = xml_obj_type
	self.origin = "" # where did it originally come from?
	self.nocli = False # we don't support this one
	self.nocli_warn = True # don't issue warnings all the time
	self.updated = False # was the object updated
	self.invalid = False # the object has been invalidated (removed)
	self.moved = False # the object has been moved (from/to a container)
	self.recreate = False # constraints to be recreated
	self.comment = '' # comment as text
	self.parent = None # object superior (group/clone/ms)
	self.children = [] # objects inferior
	if obj_id:
	if not self.mknode(obj_id):
	self = None # won't do :(
	else:
	self.obj_id = None
	self.node = None
	def dump_state(self):
	'Print object status'
	print self.state_fmt % \
	(self.obj_id,self.origin,self.updated,self.moved,self.invalid, \
	self.parent and self.parent.obj_id or "", \
	len(self.children))
	def repr_cli_xml(self,node,format):
	h = cli_display.keyword("xml")
	l = node.toprettyxml('\t').split('\n')
	l = [x for x in l if x] # drop empty lines
	if format > 0:
	return "%s %s" % (h,' \\\n'.join(l))
	else:
	return "%s %s" % (h,''.join(l))
	def repr_cli(self,node = None,format = 1):
	'''
	CLI representation for the node.
	repr_cli_head and repr_cli_child in subclasess.
	'''
	if not node:
	node = self.node
	if self.nocli:
	return self.repr_cli_xml(node,format)
	l = []
	head_s = self.repr_cli_head(node)
	if not head_s: # everybody must have a head
	return None
	l.append(head_s)
	cli_add_description(node,l)
	for c in node.childNodes:
	if not is_element(c):
	continue
	s = self.repr_cli_child(c,format)
	if s:
	l.append(s)
	return self.cli_format(l,format)
	def repr_cli_child(self,c,format):
	if c.tagName in self.set_names:
	return "%s %s" % \
	(cli_display.keyword(self.set_names[c.tagName]), \
	cli_pairs(nvpairs2list(c)))
	def cli2node(self,cli,oldnode = None):
	'''
	Convert CLI representation to a DOM node.
	Defined in subclasses.
	'''
	cli_list = mk_cli_list(cli)
	if not cli_list:
	return None
	if not oldnode:
	if self.obj_type == "property":
	oldnode = cib_factory.topnode[cib_object_map[self.xml_obj_type][2]]
	else:
	oldnode = self.node
	return self.cli_list2node(cli_list,oldnode)
	def cli_format(self,l,format):
	'''
	Format and add comment (if any).
	'''
	s = cli_format(l,format)
	return (self.comment and format >=0) and '\n'.join([self.comment,s]) or s
	def set_comment(self,l):
	s = '\n'.join(l)
	if self.comment != s:
	self.comment = s
	self.modified = True
	def pull_comments(self):
	'''
	Collect comments from within this node. Remove them from
	the parent and stuff them in self.comments as an array.
	'''
	l = []
	cnodes = [x for x in self.node.childNodes if is_comment(x)]
	for n in cnodes:
	l.append(n.data)
	n.parentNode.removeChild(n)
	# convert comments from XML node to text. Multiple comments
	# are concatenated with '\n'.
	if not l:
	self.comment = ''
	return
	s = '\n'.join(l)
	l = s.split('\n')
	for i in range(len(l)):
	if not l[i].startswith('#'):
	l[i] = '#%s' % l[i]
	self.comment = '\n'.join(l)
	def mknode(self,obj_id):
	if not cib_factory.is_cib_sane():
	return False
	if id_store.id_in_use(obj_id):
	return False
	if self.xml_obj_type in vars.defaults_tags:
	tag = "meta_attributes"
	else:
	tag = self.xml_obj_type
	self.node = cib_factory.createElement(tag)
	self.obj_id = obj_id
	self.node.setAttribute("id",self.obj_id)
	self.origin = "user"
	return True
	def mkcopy(self):
	'''
	Create a new object with the same obj_id and obj_type
	(for the purpose of CibFactory.delete_objects)
	'''
	obj_copy = CibObject(self.xml_obj_type)
	obj_copy.obj_id = self.obj_id
	obj_copy.obj_type = self.obj_type
	return obj_copy
	def can_be_renamed(self):
	'''
	Return False if this object can't be renamed.
	'''
	if is_rsc_running(self.obj_id):
	common_err("cannot rename a running resource (%s)" % self.obj_id)
	return False
	if not is_live_cib() and self.node.tagName == "node":
	common_err("cannot rename nodes")
	return False
	return True
	def attr_exists(self,attr):
	if not attr in self.node.attributes.keys():
	no_attribute_err(attr,self.obj_id)
	return False
	return True
	def cli_use_validate(self):
	'''
	Check validity of the object, as we know it. It may
	happen that we don't recognize a construct, but that the
	object is still valid for the CRM. In that case, the
	object is marked as "CLI read only", i.e. we will neither
	convert it to CLI nor try to edit it in that format.

	The validation procedure:
	we convert xml to cli and then back to xml. If the two
	xml representations match then we can understand the xml.
	'''
	if not self.node:
	return True
	if not self.attr_exists("id"):
	return False
	cli_display.set_no_pretty()
	cli_text = self.repr_cli(format = -1)
	cli_display.reset_no_pretty()
	if not cli_text:
	return False
	xml2 = self.cli2node(cli_text)
	if not xml2:
	return False
	rc = xml_cmp(self.node, xml2, show = True)
	xml2.unlink()
	return rc
	def check_sanity(self):
	'''
	Right now, this is only for primitives.
	+ And groups/clones/ms and cluster properties.
	'''
	return 0
	def matchcli(self,cli_list):
	head = cli_list[0]
	return self.obj_type == head[0] \
	and self.obj_id == find_value(head[1],"id")
	def match(self,xml_obj_type,obj_id):
	return self.xml_obj_type == xml_obj_type and self.obj_id == obj_id
	def obj_string(self):
	return "%s:%s" % (self.obj_type,self.obj_id)
	def reset_updated(self):
	self.updated = False
	self.moved = False
	self.recreate = False
	for child in self.children:
	child.reset_updated()
	def propagate_updated(self):
	if self.parent:
	self.parent.updated = self.updated
	self.parent.propagate_updated()
	def top_parent(self):
	'''Return the top parent or self'''
	if self.parent:
	return self.parent.top_parent()
	else:
	return self
	def find_child_in_node(self,child):
	for c in self.node.childNodes:
	if not is_element(c):
	continue
	if c.tagName == child.obj_type and \
	c.getAttribute("id") == child.obj_id:
	return c
	return None
	def filter(self,*args):
	"Filter objects."
	if not args:
	return True
	if args[0] == "NOOBJ":
	return False
	if args[0] == "changed":
	return self.updated or self.origin == "user"
	return self.obj_id in args

	def mk_cli_list(cli):
	'Sometimes we get a string and sometimes a list.'
	if type(cli) == type('') or type(cli) == type(u''):
	return CliParser().parse(cli)
	else:
	return cli

	class CibNode(CibObject):
	'''
	Node and node's attributes.
	'''
	set_names = { "instance_attributes": "attributes", }
	def repr_cli_head(self,node):
	obj_type = vars.cib_cli_map[node.tagName]
	node_id = node.getAttribute("id")
	uname = node.getAttribute("uname")
	s = cli_display.keyword(obj_type)
	if node_id != uname:
	s = '%s $id="%s"' % (s, node_id)
	s = '%s %s' % (s, cli_display.id(uname))
	type = node.getAttribute("type")
	if type != vars.node_default_type:
	s = '%s:%s' % (s, type)
	return s
	def cli_list2node(self,cli_list,oldnode):
	head = copy.copy(cli_list[0])
	head[0] = backtrans[head[0]]
	obj_id = find_value(head[1],"$id")
	if not obj_id:
	obj_id = find_value(head[1],"uname")
	if not obj_id:
	return None
	type = find_value(head[1],"type")
	if not type:
	type = vars.node_default_type
	head[1].append(["type",type])
	headnode = mkxmlsimple(head,cib_factory.topnode[cib_object_map[self.xml_obj_type][2]],'node')
	id_hint = headnode.getAttribute("id")
	for e in cli_list[1:]:
	n = mkxmlnode(e,oldnode,id_hint)
	headnode.appendChild(n)
	remove_id_used_attributes(cib_factory.topnode[cib_object_map[self.xml_obj_type][2]])
	return headnode

	class CibPrimitive(CibObject):
	'''
	Primitives.
	'''
	set_names = {
	"instance_attributes": "params",
	"meta_attributes": "meta",
	}
	def repr_cli_head(self,node):
	obj_type = vars.cib_cli_map[node.tagName]
	node_id = node.getAttribute("id")
	ra_type = node.getAttribute("type")
	ra_class = node.getAttribute("class")
	ra_provider = node.getAttribute("provider")
	s1 = s2 = ''
	if ra_class:
	s1 = "%s:"%ra_class
	if ra_provider:
	s2 = "%s:"%ra_provider
	s = cli_display.keyword(obj_type)
	id = cli_display.id(node_id)
	return "%s %s %s" % (s, id, ''.join((s1,s2,ra_type)))
	def repr_cli_child(self,c,format):
	if c.tagName in self.set_names:
	return "%s %s" % \
	(cli_display.keyword(self.set_names[c.tagName]), \
	cli_pairs(nvpairs2list(c)))
	elif c.tagName == "operations":
	return cli_operations(c,format)
	def cli_list2node(self,cli_list,oldnode):
	'''
	Convert a CLI description to DOM node.
	Try to preserve as many ids as possible in case there's
	an old XML version.
	'''
	head = copy.copy(cli_list[0])
	head[0] = backtrans[head[0]]
	headnode = mkxmlsimple(head,oldnode,'rsc')
	id_hint = headnode.getAttribute("id")
	operations = None
	for e in cli_list[1:]:
	n = mkxmlnode(e,oldnode,id_hint)
	if keyword_cmp(e[0], "operations"):
	operations = n
	if not keyword_cmp(e[0], "op"):
	headnode.appendChild(n)
	else:
	if not operations:
	operations = mkxmlnode(["operations",{}],oldnode,id_hint)
	headnode.appendChild(operations)
	operations.appendChild(n)
	remove_id_used_attributes(oldnode)
	return headnode
	def add_operation(self,cli_list):
	# check if there is already an op with the same interval
	head = copy.copy(cli_list[0])
	name = find_value(head[1], "name")
	interval = find_value(head[1], "interval")
	if find_operation(self.node,name,interval):
	common_err("%s already has a %s op with interval %s" % \
	(self.obj_id, name, interval))
	return None
	# drop the rsc attribute
	head[1].remove(["rsc",self.obj_id])
	# create an xml node
	mon_node = mkxmlsimple(head, None, self.obj_id)
	# get the place to append it to
	try:
	op_node = self.node.getElementsByTagName("operations")[0]
	except:
	op_node = cib_factory.createElement("operations")
	self.node.appendChild(op_node)
	op_node.appendChild(mon_node)
	# the resource is updated
	self.updated = True
	self.propagate_updated()
	return self
	def check_sanity(self):
	'''
	Check operation timeouts and if all required parameters
	are defined.
	'''
	if not self.node: # eh?
	common_err("%s: no xml (strange)" % self.obj_id)
	return user_prefs.get_check_rc()
	ra_type = self.node.getAttribute("type")
	ra_class = self.node.getAttribute("class")
	ra_provider = self.node.getAttribute("provider")
	ra = RAInfo(ra_class,ra_type,ra_provider)
	if not ra.mk_ra_node(): # no RA found?
	ra.error("no such resource agent")
	return user_prefs.get_check_rc()
	params = []
	for c in self.node.childNodes:
	if not is_element(c):
	continue
	if c.tagName == "instance_attributes":
	params += nvpairs2list(c)
	rc1 = ra.sanity_check_params(self.obj_id, params)
	actions = {}
	for c in self.node.childNodes:
	if not is_element(c):
	continue
	if c.tagName == "operations":
	for c2 in c.childNodes:
	if is_element(c2) and c2.tagName == "op":
	op,pl = op2list(c2)
	if op:
	actions[op] = pl
	default_timeout = get_default_timeout()
	rc2 = ra.sanity_check_ops(self.obj_id, actions, default_timeout)
	- return rc1 \| rc2
	+ rc3 = sanity_check_meta(self.obj_id,self.node,vars.rsc_meta_attributes)
	+ return rc1 \| rc2 \| rc3

	class CibContainer(CibObject):
	'''
	Groups and clones and ms.
	'''
	set_names = {
	"instance_attributes": "params",
	"meta_attributes": "meta",
	}
	def repr_cli_head(self,node):
	try:
	obj_type = vars.cib_cli_map[node.tagName]
	except:
	unsupported_err(node.tagName)
	return None
	node_id = node.getAttribute("id")
	children = []
	for c in node.childNodes:
	if not is_element(c):
	continue
	if (obj_type == "group" and is_primitive(c)) or \
	is_child_rsc(c):
	children.append(cli_display.rscref(c.getAttribute("id")))
	elif obj_type in vars.clonems_tags and is_child_rsc(c):
	children.append(cli_display.rscref(c.getAttribute("id")))
	s = cli_display.keyword(obj_type)
	id = cli_display.id(node_id)
	return "%s %s %s" % (s, id, ' '.join(children))
	def cli_list2node(self,cli_list,oldnode):
	head = copy.copy(cli_list[0])
	head[0] = backtrans[head[0]]
	headnode = mkxmlsimple(head,oldnode,'grp')
	id_hint = headnode.getAttribute("id")
	for e in cli_list[1:]:
	n = mkxmlnode(e,oldnode,id_hint)
	headnode.appendChild(n)
	v = find_value(head[1],"$children")
	if v:
	for child_id in v:
	obj = cib_factory.find_object(child_id)
	if obj:
	n = obj.node.cloneNode(1)
	headnode.appendChild(n)
	else:
	no_object_err(child_id)
	remove_id_used_attributes(oldnode)
	return headnode
	+ def check_sanity(self):
	+ '''
	+ Check meta attributes.
	+ '''
	+ if not self.node: # eh?
	+ common_err("%s: no xml (strange)" % self.obj_id)
	+ return user_prefs.get_check_rc()
	+ if self.obj_type == "group":
	+ l = vars.rsc_meta_attributes
	+ elif self.obj_type == "clone":
	+ l = vars.clone_meta_attributes
	+ elif self.obj_type == "ms":
	+ l = vars.clone_meta_attributes + vars.ms_meta_attributes
	+ rc = sanity_check_nvpairs(self.obj_id,self.node,l)
	+ return rc

	class CibLocation(CibObject):
	'''
	Location constraint.
	'''
	def repr_cli_head(self,node):
	obj_type = vars.cib_cli_map[node.tagName]
	node_id = node.getAttribute("id")
	rsc = cli_display.rscref(node.getAttribute("rsc"))
	s = cli_display.keyword(obj_type)
	id = cli_display.id(node_id)
	s = "%s %s %s"%(s,id,rsc)
	pref_node = node.getAttribute("node")
	score = cli_display.score(get_score(node))
	if pref_node:
	return "%s %s %s" % (s,score,pref_node)
	else:
	return s
	def repr_cli_child(self,c,format):
	if c.tagName == "rule":
	return "%s %s" % \
	(cli_display.keyword("rule"), cli_rule(c))
	def cli_list2node(self,cli_list,oldnode):
	head = copy.copy(cli_list[0])
	head[0] = backtrans[head[0]]
	headnode = mkxmlsimple(head,oldnode,'location')
	id_hint = headnode.getAttribute("id")
	oldrule = None
	for e in cli_list[1:]:
	if e[0] in ("expression","date_expression"):
	n = mkxmlnode(e,oldrule,id_hint)
	else:
	n = mkxmlnode(e,oldnode,id_hint)
	if keyword_cmp(e[0], "rule"):
	add_missing_attr(n)
	rule = n
	headnode.appendChild(n)
	oldrule = lookup_node(rule,oldnode,location_only=True)
	else:
	rule.appendChild(n)
	remove_id_used_attributes(oldnode)
	return headnode

	class CibSimpleConstraint(CibObject):
	'''
	Colocation and order constraints.
	'''
	def repr_cli_head(self,node):
	obj_type = vars.cib_cli_map[node.tagName]
	node_id = node.getAttribute("id")
	s = cli_display.keyword(obj_type)
	id = cli_display.id(node_id)
	score = cli_display.score(get_score(node))
	if node.getElementsByTagName("resource_set"):
	col = rsc_set_constraint(node,obj_type)
	else:
	col = two_rsc_constraint(node,obj_type)
	if not col:
	return None
	symm = node.getAttribute("symmetrical")
	if symm:
	col.append("symmetrical=%s"%symm)
	return "%s %s %s %s" % (s,id,score,' '.join(col))
	def repr_cli_child(self,c,format):
	pass # no children here
	def cli_list2node(self,cli_list,oldnode):
	head = copy.copy(cli_list[0])
	head[0] = backtrans[head[0]]
	headnode = mkxmlsimple(head,oldnode,'')
	id_hint = headnode.getAttribute("id")
	for e in cli_list[1:]:
	# if more than one element, it's a resource set
	n = mkxmlnode(e,oldnode,id_hint)
	headnode.appendChild(n)
	remove_id_used_attributes(oldnode)
	return headnode

	class CibProperty(CibObject):
	'''
	Cluster properties.
	'''
	def repr_cli_head(self,node):
	return '%s $id="%s"' % \
	(cli_display.keyword(self.obj_type), node.getAttribute("id"))
	def repr_cli_child(self,c,format):
	name = c.getAttribute("name")
	if "value" in c.attributes.keys():
	value = c.getAttribute("value")
	else:
	value = None
	return nvpair_format(name,value)
	def cli_list2node(self,cli_list,oldnode):
	head = copy.copy(cli_list[0])
	head[0] = backtrans[head[0]]
	obj_id = find_value(head[1],"$id")
	if not obj_id:
	obj_id = cib_object_map[self.xml_obj_type][3]
	headnode = mkxmlnode(head,oldnode,obj_id)
	remove_id_used_attributes(oldnode)
	return headnode
	def matchcli(self,cli_list):
	head = cli_list[0]
	return self.obj_type == head[0] \
	and self.obj_id == find_value(head[1],"$id")
	+ def check_sanity(self):
	+ '''
	+ Match properties with PE metadata.
	+ '''
	+ if not self.node: # eh?
	+ common_err("%s: no xml (strange)" % self.obj_id)
	+ return user_prefs.get_check_rc()
	+ l = []
	+ if self.obj_type == "property":
	+ l = get_pe_property_list() + get_crmd_property_list()
	+ elif self.obj_type == "op_defaults":
	+ l = vars.op_attributes
	+ elif self.obj_type == "rsc_defaults":
	+ l = vars.rsc_meta_attributes
	+ rc = sanity_check_nvpairs(self.obj_id,self.node,l)
	+ return rc
	#
	################################################################

	#
	# cib update interface (cibadmin)
	#
	cib_piped = "cibadmin -p"
	def cib_delete_element(obj):
	'Remove one element from the CIB.'
	if obj.xml_obj_type in vars.defaults_tags:
	node = cib_factory.createElement("meta_attributes")
	else:
	node = cib_factory.createElement(obj.xml_obj_type)
	node.setAttribute("id",obj.obj_id)
	rc = pipe_string("%s -D" % cib_piped, node.toxml())
	if rc != 0:
	update_err(obj.obj_id,'-D',node.toprettyxml())
	node.unlink()
	return rc
	def cib_update_elements(upd_list):
	'Update a set of objects in the CIB.'
	l = [x.obj_id for x in upd_list]
	o = CibObjectSetRaw(*l)
	xml = o.repr_configure()
	rc = pipe_string("%s -U" % cib_piped, xml)
	if rc != 0:
	update_err(' '.join(l),'-U',xml)
	return rc
	def cib_replace_element(obj):
	comm_node = None
	if obj.comment:
	comm_node = cib_factory.createComment(s)
	if obj.node.hasChildNodes():
	obj.node.insertBefore(comm_node, obj.node.firstChild)
	else:
	obj.node.appendChild(comm_node)
	rc = pipe_string("%s -R -o %s" % \
	(cib_piped, obj.parent_type), obj.node.toxml())
	if rc != 0:
	update_err(obj.obj_id,'-R',obj.node.toprettyxml())
	if comm_node:
	rmnode(comm_node)
	return rc
	def cib_delete_moved_children(obj):
	for c in obj.children:
	if c.origin == "cib" and c.moved:
	cib_delete_element(c)
	cib_delete_moved_children(c)

	def get_default_timeout():
	t = cib_factory.get_op_default("timeout")
	if t:
	return t
	t = cib_factory.get_property("default-action-timeout")
	if t:
	return t
	if not vars.pe_metadata:
	vars.pe_metadata = RAInfo("pengine","metadata")
	if not vars.pe_metadata:
	return 0
	- return vars.pe_metadata.param_default(property)
	+ return vars.pe_metadata.param_default("default-action-timeout")
	+def get_pe_property_list():
	+ if not vars.pe_metadata:
	+ vars.pe_metadata = RAInfo("pengine","metadata")
	+ if not vars.pe_metadata:
	+ return []
	+ return vars.pe_metadata.params().keys()
	+def get_crmd_property_list():
	+ if not vars.crmd_metadata:
	+ vars.crmd_metadata = RAInfo("crmd","metadata")
	+ if not vars.crmd_metadata:
	+ return []
	+ return vars.crmd_metadata.params().keys()

	# xml -> cli translations (and classes)
	cib_object_map = {
	"node": ( "node", CibNode, "nodes" ),
	"primitive": ( "primitive", CibPrimitive, "resources" ),
	"group": ( "group", CibContainer, "resources" ),
	"clone": ( "clone", CibContainer, "resources" ),
	"master": ( "ms", CibContainer, "resources" ),
	"rsc_location": ( "location", CibLocation, "constraints" ),
	"rsc_colocation": ( "colocation", CibSimpleConstraint, "constraints" ),
	"rsc_order": ( "order", CibSimpleConstraint, "constraints" ),
	"cluster_property_set": ( "property", CibProperty, "crm_config", "cib-bootstrap-options" ),
	"rsc_defaults": ( "rsc_defaults", CibProperty, "rsc_defaults", "rsc-options" ),
	"op_defaults": ( "op_defaults", CibProperty, "op_defaults", "op-options" ),
	}
	backtrans = odict() # generate a translation cli -> tag
	for key in cib_object_map:
	backtrans[cib_object_map[key][0]] = key
	cib_topnodes = [] # get a list of parents
	for key in cib_object_map:
	if not cib_object_map[key][2] in cib_topnodes:
	cib_topnodes.append(cib_object_map[key][2])

	cib_upgrade = "cibadmin --upgrade --force"
	class CibFactory(Singleton):
	'''
	Juggle with CIB objects.
	See check_structure below for details on the internal cib
	representation.
	'''
	shadowcmd = ">/dev/null </dev/null crm_shadow"
	def __init__(self):
	self.init_vars()
	self.regtest = options.regression_tests
	self.all_committed = True # has commit produced error
	self._no_constraint_rm_msg = False # internal (just not to produce silly messages)
	self.supported_cib_re = "^pacemaker-1[.]0$"
	def is_cib_sane(self):
	if not self.doc:
	empty_cib_err()
	return False
	return True
	#
	# check internal structures
	#
	def check_topnode(self,obj):
	if not obj.node.parentNode.isSameNode(self.topnode[obj.parent_type]):
	common_err("object %s is not linked to %s"%(obj.obj_id,obj.parent_type))
	def check_parent(self,obj,parent):
	if not obj in parent.children:
	common_err("object %s does not reference its child %s"%(parent.obj_id,obj.obj_id))
	return False
	if not parent.node.isSameNode(obj.node.parentNode):
	common_err("object %s node is not a child of its parent %s, but %s:%s"%(obj.obj_id,parent.obj_id,obj.node.tagName,obj.node.getAttribute("id")))
	return False
	def check_structure(self):
	#print "Checking structure..."
	if not self.doc:
	empty_cib_err()
	return False
	rc = True
	for obj in self.cib_objects:
	#print "Checking %s... (%s)" % (obj.obj_id,obj.nocli)
	if obj.parent:
	if self.check_parent(obj,obj.parent) == False:
	rc = False
	else:
	if self.check_topnode(obj) == False:
	rc = False
	for child in obj.children:
	if self.check_parent(child,child.parent) == False:
	rc = False
	return rc
	def regression_testing(self,param):
	# provide some help for regression testing
	# in particular by trying to provide output which is
	# easier to predict
	if param == "off":
	self.regtest = False
	elif param == "on":
	self.regtest = True
	else:
	common_warn("bad parameter for regtest: %s" % param)
	def createElement(self,tag):
	if self.doc:
	return self.doc.createElement(tag)
	else:
	empty_cib_err()
	def createComment(self,s):
	if self.doc:
	return self.doc.createComment(s)
	else:
	empty_cib_err()
	def replaceNode(self,newnode,oldnode):
	if not self.doc:
	empty_cib_err()
	return None
	if newnode.ownerDocument != self.doc:
	newnode = self.doc.importNode(newnode,1)
	oldnode.parentNode.replaceChild(newnode,oldnode)
	return newnode
	def is_cib_supported(self,cib):
	'Do we support this CIB?'
	req = cib.getAttribute("crm_feature_set")
	validator = cib.getAttribute("validate-with")
	if validator and re.match(self.supported_cib_re,validator):
	return True
	cib_ver_unsupported_err(validator,req)
	return False
	def upgrade_cib_06to10(self,force = False):
	'Upgrade the CIB from 0.6 to 1.0.'
	if not self.doc:
	empty_cib_err()
	return False
	cib = self.doc.getElementsByTagName("cib")
	if not cib:
	common_err("CIB has no cib element")
	return False
	req = cib[0].getAttribute("crm_feature_set")
	validator = cib[0].getAttribute("validate-with")
	if force or not validator or re.match("0[.]6",validator):
	return ext_cmd(cib_upgrade) == 0
	def import_cib(self):
	'Parse the current CIB (from cibadmin -Q).'
	self.doc,cib = read_cib(cibdump2doc)
	if not self.doc:
	return False
	if not cib:
	common_err("CIB has no cib element")
	self.reset()
	return False
	if not self.is_cib_supported(cib):
	self.reset()
	return False
	for attr in cib.attributes.keys():
	self.cib_attrs[attr] = cib.getAttribute(attr)
	for t in cib_topnodes:
	self.topnode[t] = get_conf_elem(self.doc, t)
	if not self.topnode[t]:
	self.topnode[t] = mk_topnode(self.doc, t)
	if not self.topnode[t]:
	common_err("could not create %s node; out of memory?" % t)
	self.reset()
	return False
	return True
	#
	# create a doc from the list of objects
	# (used by CibObjectSetRaw)
	#
	def regtest_filter(self,cib):
	for attr in ("epoch","admin_epoch"):
	if cib.getAttribute(attr):
	cib.setAttribute(attr,"0")
	for attr in ("cib-last-written",):
	if cib.getAttribute(attr):
	cib.removeAttribute(attr)
	def set_cib_attributes(self,cib):
	for attr in self.cib_attrs:
	cib.setAttribute(attr,self.cib_attrs[attr])
	if self.regtest:
	self.regtest_filter(cib)
	def objlist2doc(self,obj_list,obj_filter = None):
	'''
	Return document containing objects in obj_list.
	Must remove all children from the object list, because
	printing xml of parents will include them.
	Optional filter to sieve objects.
	'''
	doc,cib,crm_config,rsc_defaults,op_defaults,nodes,resources,constraints = new_cib()
	# get only top parents for the objects in the list
	# e.g. if we get a primitive which is part of a clone,
	# then the clone gets in, not the primitive
	# dict will weed out duplicates
	d = {}
	for obj in obj_list:
	if obj_filter and not obj_filter(obj):
	continue
	d[obj.top_parent()] = 1
	for obj in d:
	i_node = doc.importNode(obj.node,1)
	add_comment(doc,i_node,obj.comment)
	if obj.parent_type == "nodes":
	nodes.appendChild(i_node)
	elif obj.parent_type == "resources":
	resources.appendChild(i_node)
	elif obj.parent_type == "constraints":
	constraints.appendChild(i_node)
	elif obj.parent_type == "crm_config":
	crm_config.appendChild(i_node)
	elif obj.parent_type == "rsc_defaults":
	rsc_defaults.appendChild(i_node)
	elif obj.parent_type == "op_defaults":
	op_defaults.appendChild(i_node)
	self.set_cib_attributes(cib)
	return doc
	#
	# commit changed objects to the CIB
	#
	def attr_match(self,c,a):
	'Does attribute match?'
	try: cib_attr = self.cib_attrs[a]
	except: cib_attr = None
	return c.getAttribute(a) == cib_attr
	def is_current_cib_equal(self, silent = False):
	if self.overwrite:
	return True
	doc,cib = read_cib(cibdump2doc)
	if not doc:
	return False
	if not cib:
	doc.unlink()
	return False
	rc = self.attr_match(cib,'epoch') and \
	self.attr_match(cib,'admin_epoch')
	if not silent and not rc:
	common_warn("CIB changed in the meantime: won't touch it!")
	doc.unlink()
	return rc
	def state_header(self):
	'Print object status header'
	print CibObject.state_fmt % \
	("","origin","updated","moved","invalid","parent","children")
	def showobjects(self):
	self.state_header()
	for obj in self.cib_objects:
	obj.dump_state()
	if self.remove_queue:
	print "Remove queue:"
	for obj in self.remove_queue:
	obj.dump_state()
	def showqueue(self, title, upd_list):
	if upd_list:
	s = ''
	upd_list = processing_sort_cli(upd_list)
	if title == "delete":
	upd_list = reversed(upd_list)
	for obj in upd_list:
	s = s + " " + obj.obj_string()
	print "%s:%s" % (title,s)
	def showqueues(self):
	'Show what is going to happen on commit.'
	(dc,u,c,m,cc) = self.get_commit_lists()
	self.showqueue("delete", self.remove_queue + dc)
	self.showqueue("replace", u)
	self.showqueue("create", c)
	self.showqueue("create", m)
	self.showqueue("create", cc)
	def cib_objs4cibadmin(self,obj_filter):
	'''
	Filter objects from our cib_objects list. But add only
	top parents.
	For this to work, the filter must not filter out parents.
	That's guaranteed by the updated flag propagation.
	'''
	upd_list = []
	for obj in self.cib_objects:
	if not obj_filter or obj_filter(obj):
	if not obj.parent and not obj in upd_list:
	upd_list.append(obj)
	return upd_list
	def get_commit_lists(self):
	'''
	Make a set of lists of objects to be committed in the proper order.
	1: modified constraints (to be deleted)
	2: objects to be updated
	3: objects to be created
	4: objects to be created (which moved from a container)
	5: constraints to be (re)created
	'''
	dc = self.cib_objs4cibadmin(lambda o: \
	o.origin == "cib" and (o.updated or o.recreate) and is_constraint(o.node))
	u = self.cib_objs4cibadmin(lambda o: \
	o.origin != 'user' and o.updated and not is_constraint(o.node))
	c = self.cib_objs4cibadmin(lambda o: \
	o.origin == 'user' and not is_constraint(o.node))
	m = self.cib_objs4cibadmin(lambda o: \
	not o.parent and o.moved and o.origin == "cib")
	cc = self.cib_objs4cibadmin(lambda o: is_constraint(o.node) and \
	(((o.updated or o.recreate) and o.origin == "cib") or o.origin == "user"))
	return (dc,u,c,m,cc)
	def analyze_commit(self,d,u,c,m,cc):
	'''
	How to commit?
	'''
	#1. If there are elements moved into/out of a container,
	# then single elements commit. cibadmin -R wouldn't do.
	for o in self.cib_objects:
	if o.moved:
	return -1
	#2. If the set of modifications is smallish,
	# also single elements commit.
	objcnt = len(self.cib_objects)
	modcnt = len(d+u+c+m+cc)
	if modcnt <= 3 or modcnt < objcnt/4:
	return -1
	#3. Otherwise, replace the whole CIB.
	return 1
	def commit(self):
	'Commit the configuration to the CIB.'
	if not self.doc:
	empty_cib_err()
	return False
	# all_committed is updated in the invoked object methods
	self.all_committed = True
	(dc,u,c,m,cc) = self.get_commit_lists()
	if self.analyze_commit(self.remove_queue+dc,u,c,m,cc) < 0:
	# we should commit single elements
	common_debug("commit: single-element")
	if not self.mk_shadow():
	return False
	cnt = self.commit_elements(self.remove_queue+dc,u,c,m,cc)
	if self.all_committed:
	if not self.apply_shadow():
	return False
	self.rm_shadow()
	else: # it's ok to use a single cibadmin -R
	common_debug("commit: whole-cib")
	cnt = self.commit_doc()
	if cnt:
	# reload the cib!
	self.reset()
	self.initialize()
	return self.all_committed
	def commit_doc(self):
	try:
	conf_node = self.doc.getElementsByTagName("configuration")[0]
	except:
	common_error("cannot find the configuration node")
	return False
	rc = pipe_string("%s -R" % cib_piped, conf_node.toxml())
	if rc != 0:
	update_err("cib",'-R',conf_node.toprettyxml())
	return False
	return True
	def mk_shadow(self):
	'''
	Create a temporary shadow for commit/apply.
	Unless the user's already working with a shadow CIB.
	'''
	# TODO: split CibShadow into ui and mgmt part, then reuse the mgmt
	if not is_live_cib():
	return True
	self.tmp_shadow = "__crmshell.%d" % os.getpid()
	if ext_cmd("%s -c %s" % (self.shadowcmd,self.tmp_shadow)) != 0:
	common_error("creating tmp shadow %s failed" % self.tmp_shadow)
	self.tmp_shadow = ""
	return False
	os.putenv(vars.shadow_envvar,self.tmp_shadow)
	return True
	def rm_shadow(self):
	'''
	Remove the temporary shadow.
	Unless the user's already working with a shadow CIB.
	'''
	if not is_live_cib() or not self.tmp_shadow:
	return
	if ext_cmd("%s -D '%s' --force" % (self.shadowcmd,self.tmp_shadow)) != 0:
	common_error("deleting tmp shadow %s failed" % self.tmp_shadow)
	self.tmp_shadow = ""
	os.unsetenv(vars.shadow_envvar)
	def apply_shadow(self):
	'''
	Commit the temporary shadow.
	Unless the user's already working with a shadow CIB.
	'''
	if not is_live_cib():
	return True
	if not self.tmp_shadow:
	common_error("cannot commit no shadow")
	return False
	if ext_cmd("%s -C '%s' --force" % (self.shadowcmd,self.tmp_shadow)) != 0:
	common_error("committing tmp shadow %s failed" % self.tmp_shadow)
	return False
	return True
	def commit_elements(self,d,u,c,m,cc):
	cnt = 0
	# 1. remove objects (incl. modified constraints)
	cnt += self.delete_objects(d)
	# 2. update existing objects
	cnt += self.replace_objects(u)
	# 3. create new objects
	cnt += self.create_objects(c)
	# 4. create objects moved from a container
	cnt += self.create_objects(m)
	# 5. create constraints
	cnt += self.create_objects(cc)
	return cnt
	def delete_objects(self,upd_list):
	if not upd_list:
	return 0
	cnt = 0
	obj_list = processing_sort_cli(upd_list)
	for obj in reversed(obj_list):
	if cib_delete_element(obj) == 0:
	if obj in self.remove_queue:
	self.remove_queue.remove(obj)
	cnt += 1
	else:
	self.all_committed = False
	return cnt
	def create_objects(self,upd_list):
	if not upd_list:
	return 0
	for obj in upd_list:
	cib_delete_moved_children(obj)
	if cib_update_elements(upd_list) == 0:
	for obj in upd_list:
	obj.reset_updated()
	return len(upd_list)
	else:
	self.all_committed = False
	return 0
	def replace_objects(self,upd_list):
	if not upd_list:
	return 0
	cnt = 0
	for obj in processing_sort_cli(upd_list):
	#print obj.node.toprettyxml()
	cib_delete_moved_children(obj)
	if cib_replace_element(obj) == 0:
	cnt += 1
	obj.reset_updated()
	else:
	self.all_committed = False
	return cnt
	#
	# initialize cib_objects from CIB
	#
	def save_node(self,node,pnode = None):
	'''
	Need pnode (parent node) acrobacy because cluster
	properties and rsc/op_defaults hold stuff in a
	meta_attributes child.
	'''
	if not pnode:
	pnode = node
	obj = cib_object_map[pnode.tagName][1](pnode.tagName)
	obj.origin = "cib"
	obj.obj_id = node.getAttribute("id")
	obj.node = node
	self.cib_objects.append(obj)
	def populate(self):
	"Walk the cib and collect cib objects."
	all_nodes = get_interesting_nodes(self.doc,[])
	if not all_nodes:
	return
	for node in processing_sort(all_nodes):
	if is_defaults(node):
	for c in node.childNodes:
	if not is_element(c) or c.tagName != "meta_attributes":
	continue
	self.save_node(c,node)
	else:
	self.save_node(node)
	#for obj in self.cib_objects:
	# obj.pull_comments()
	for obj in self.cib_objects:
	if not obj.cli_use_validate():
	obj.nocli = True
	obj.nocli_warn = False
	obj_cli_warn(obj.obj_id)
	for obj in self.cib_objects:
	self.update_links(obj)
	def initialize(self):
	if self.doc:
	return True
	if not self.import_cib():
	return False
	sanitize_cib(self.doc)
	show_unrecognized_elems(self.doc)
	self.populate()
	return self.check_structure()
	def init_vars(self):
	self.doc = None # the cib
	self.topnode = {}
	for t in cib_topnodes:
	self.topnode[t] = None
	self.cib_attrs = {} # cib version dictionary
	self.cib_objects = [] # a list of cib objects
	self.remove_queue = [] # a list of cib objects to be removed
	self.overwrite = False # update cib unconditionally
	def reset(self):
	if not self.doc:
	return
	self.doc.unlink()
	self.init_vars()
	id_store.clear()
	def find_object(self,obj_id):
	"Find an object for id."
	for obj in self.cib_objects:
	if obj.obj_id == obj_id:
	return obj
	return None
	#
	# tab completion functions
	#
	def id_list(self):
	"List of ids (for completion)."
	return [x.obj_id for x in self.cib_objects]
	def prim_id_list(self):
	"List of primitives ids (for group completion)."
	return [x.obj_id for x in self.cib_objects if x.obj_type == "primitive"]
	def children_id_list(self):
	"List of child ids (for clone/master completion)."
	return [x.obj_id for x in self.cib_objects if x.obj_type in vars.children_tags]
	def rsc_id_list(self):
	"List of resource ids (for constraint completion)."
	return [x.obj_id for x in self.cib_objects \
	if x.obj_type in vars.resource_tags and not x.parent]
	def node_id_list(self):
	"List of node ids."
	return [x.obj_id for x in self.cib_objects \
	if x.obj_type == "node"]
	def f_prim_id_list(self):
	"List of possible primitives ids (for group completion)."
	return [x.obj_id for x in self.cib_objects \
	if x.obj_type == "primitive" and not x.parent]
	def f_children_id_list(self):
	"List of possible child ids (for clone/master completion)."
	return [x.obj_id for x in self.cib_objects \
	if x.obj_type in vars.children_tags and not x.parent]
	#
	# a few helper functions
	#
	def find_object_for_node(self,node):
	"Find an object which matches a dom node."
	for obj in self.cib_objects:
	if node.getAttribute("id") == obj.obj_id:
	return obj
	return None
	def find_object_for_cli(self,cli_list):
	"Find an object which matches the cli list."
	for obj in self.cib_objects:
	if obj.matchcli(cli_list):
	return obj
	return None

	def resolve_id_ref(self,attr_list_type,id_ref):
	'''
	User is allowed to specify id_ref either as a an object
	id or as attributes id. Here we try to figure out which
	one, i.e. if the former is the case to find the right
	id to reference.
	'''
	obj= self.find_object(id_ref)
	if obj:
	node_l = obj.node.getElementsByTagName(attr_list_type)
	if node_l:
	if len(node_l) > 1:
	common_warn("%s contains more than one %s, using first" % \
	(obj.obj_id,attr_list_type))
	id = node_l[0].getAttribute("id")
	if not id:
	common_err("%s reference not found" % id_ref)
	return id_ref # hope that user will fix that
	return id
	# verify if id_ref exists
	node_l = self.doc.getElementsByTagName(attr_list_type)
	for node in node_l:
	if node.getAttribute("id") == id_ref:
	return id_ref
	common_err("%s reference not found" % id_ref)
	return id_ref # hope that user will fix that
	def _get_attr_value(self,obj_type,attr):
	if not self.is_cib_sane():
	return None
	for obj in self.cib_objects:
	if obj.obj_type == obj_type and obj.node:
	pl = nvpairs2list(obj.node)
	v = find_value(pl, attr)
	if v:
	return v
	return None
	def get_property(self,property):
	'''
	Get the value of the given cluster property.
	'''
	return self._get_attr_value("property",property)
	def get_op_default(self,attr):
	'''
	Get the value of the attribute from op_defaults.
	'''
	return self._get_attr_value("op_defaults",attr)
	def new_object(self,obj_type,obj_id):
	"Create a new object of type obj_type."
	if id_store.id_in_use(obj_id):
	return None
	for xml_obj_type,v in cib_object_map.items():
	if v[0] == obj_type:
	obj = v[1](xml_obj_type,obj_id)
	if obj.obj_id:
	return obj
	else:
	return None
	return None
	def mkobj_list(self,mode,*args):
	obj_list = []
	for obj in self.cib_objects:
	f = lambda: obj.filter(*args)
	if not f():
	continue
	if mode == "cli" and obj.nocli and obj.nocli_warn:
	obj.nocli_warn = False
	obj_cli_warn(obj.obj_id)
	obj_list.append(obj)
	return obj_list
	def has_cib_changed(self):
	return self.mkobj_list("xml","changed") or self.remove_queue
	def verify_constraints(self,node):
	'''
	Check if all resources referenced in a constraint exist
	'''
	rc = True
	constraint_id = node.getAttribute("id")
	for obj_id in referenced_resources(node):
	if not self.find_object(obj_id):
	constraint_norefobj_err(constraint_id,obj_id)
	rc = False
	return rc
	def verify_rsc_children(self,node):
	'''
	Check prerequisites:
	a) all children must exist
	b) no child may have other parent than me
	(or should we steal children?)
	c) there may not be duplicate children
	'''
	obj_id = node.getAttribute("id")
	if not obj_id:
	common_err("element %s has no id" % node.tagName)
	return False
	try:
	obj_type = cib_object_map[node.tagName][0]
	except:
	common_err("element %s (%s) not recognized"%(node.tagName,obj_id))
	return False
	c_ids = get_rsc_children_ids(node)
	if not c_ids:
	return True
	rc = True
	c_dict = {}
	for child_id in c_ids:
	if not self.verify_child(child_id,obj_type,obj_id):
	rc = False
	if child_id in c_dict:
	common_err("in group %s child %s listed more than once"%(obj_id,child_id))
	rc = False
	c_dict[child_id] = 1
	return rc
	def verify_child(self,child_id,obj_type,obj_id):
	'Check if child exists and obj_id is (or may become) its parent.'
	child = self.find_object(child_id)
	if not child:
	no_object_err(child_id)
	return False
	if child.parent and child.parent.obj_id != obj_id:
	common_err("%s already in use at %s"%(child_id,child.parent.obj_id))
	return False
	if obj_type == "group" and child.obj_type != "primitive":
	common_err("a group may contain only primitives; %s is %s"%(child_id,child.obj_type))
	return False
	if not child.obj_type in vars.children_tags:
	common_err("%s may contain a primitive or a group; %s is %s"%(obj_type,child_id,child.obj_type))
	return False
	return True
	def verify_element(self,node):
	'''
	Can we create this object given its CLI representation.
	This is not about syntax, we're past that, but about
	semantics.
	Right now we check if the children, if any, are fit for
	the parent. And if this is a constraint, if all
	referenced resources are present.
	'''
	rc = True
	if not self.verify_rsc_children(node):
	rc = False
	if not self.verify_constraints(node):
	rc = False
	return rc
	def create_object(self,*args):
	return self.create_from_cli(CliParser().parse(list(args))) != None
	def set_property_cli(self,cli_list):
	head_pl = cli_list[0]
	obj_type = head_pl[0].lower()
	pset_id = find_value(head_pl[1],"$id")
	if pset_id:
	head_pl[1].remove(["$id",pset_id])
	else:
	pset_id = cib_object_map[backtrans[obj_type]][3]
	obj = self.find_object(pset_id)
	if not obj:
	if not is_id_valid(pset_id):
	invalid_id_err(pset_id)
	return None
	obj = self.new_object(obj_type,pset_id)
	if not obj:
	return None
	self.topnode[obj.parent_type].appendChild(obj.node)
	obj.origin = "user"
	self.cib_objects.append(obj)
	for n,v in head_pl[1]:
	set_nvpair(obj.node,n,v)
	obj.updated = True
	return obj
	def add_op(self,cli_list):
	'''Add an op to a primitive.'''
	head = cli_list[0]
	# does the referenced primitive exist
	rsc_id = find_value(head[1],"rsc")
	rsc_obj = self.find_object(rsc_id)
	if not rsc_obj:
	no_object_err(rsc_id)
	return None
	if rsc_obj.obj_type != "primitive":
	common_err("%s is not a primitive" % rsc_id)
	return None
	return rsc_obj.add_operation(cli_list)
	def create_from_cli(self,cli):
	'Create a new cib object from the cli representation.'
	cli_list = mk_cli_list(cli)
	if not cli_list:
	return None
	head = cli_list[0]
	obj_type = head[0].lower()
	obj_id = find_value(head[1],"id")
	if obj_id and not is_id_valid(obj_id):
	invalid_id_err(obj_id)
	return None
	if len(cli_list) >= 2 and cli_list[1][0] == "raw":
	doc = xml.dom.minidom.parseString(cli_list[1][1])
	return self.create_from_node(doc.childNodes[0])
	if obj_type in olist(vars.nvset_cli_names):
	return self.set_property_cli(cli_list)
	if obj_type == "op":
	return self.add_op(cli_list)
	if obj_type == "node":
	obj = self.find_object(obj_id)
	# make an exception and allow updating nodes
	if obj:
	self.merge_from_cli(obj,cli_list)
	return obj
	obj = self.new_object(obj_type,obj_id)
	if not obj:
	return None
	node = obj.cli2node(cli_list)
	return self.add_element(obj, node)
	def update_from_cli(self,obj,cli_list):
	'Update element from the cli intermediate.'
	id_store.remove_xml(obj.node)
	if len(cli_list) >= 2 and cli_list[1][0] == "raw":
	doc = xml.dom.minidom.parseString(cli_list[1][1])
	id_store.store_xml(doc.childNodes[0])
	return self.update_element(obj,doc.childNodes[0])
	return self.update_element(obj,obj.cli2node(cli_list))
	def update_from_node(self,obj,node):
	'Update element from a doc node.'
	id_store.replace_xml(obj.node,node)
	return self.update_element(obj,node)
	def update_element(self,obj,newnode):
	'Update element from a doc node.'
	if not newnode:
	return False
	if not self.is_cib_sane():
	id_store.replace_xml(newnode,obj.node)
	return False
	oldnode = obj.node
	if xml_cmp(oldnode,newnode):
	newnode.unlink()
	return True # the new and the old versions are equal
	obj.node = newnode
	if not self.test_element(obj,newnode):
	id_store.replace_xml(newnode,oldnode)
	obj.node = oldnode
	newnode.unlink()
	return False
	obj.node = self.replaceNode(newnode,oldnode)
	obj.nocli = False # try again after update
	self.adjust_children(obj)
	if not obj.cli_use_validate():
	obj.nocli_warn = True
	obj.nocli = True
	oldnode.unlink()
	obj.updated = True
	obj.propagate_updated()
	return True
	def merge_from_cli(self,obj,cli_list):
	node = obj.cli2node(cli_list)
	if not node:
	return
	rc = merge_nodes(obj.node, node)
	if rc:
	obj.updated = True
	obj.propagate_updated()
	def update_moved(self,obj):
	'Updated the moved flag. Mark affected constraints.'
	obj.moved = not obj.moved
	if obj.moved:
	for c_obj in self.related_constraints(obj):
	c_obj.recreate = True
	def adjust_children(self,obj):
	'''
	All stuff children related: manage the nodes of children,
	update the list of children for the parent, update
	parents in the children.
	'''
	new_children_ids = get_rsc_children_ids(obj.node)
	if not new_children_ids:
	return
	old_children = obj.children
	obj.children = [self.find_object(x) for x in new_children_ids]
	self._relink_orphans_to_top(old_children,obj.children)
	self._update_children(obj)
	def _relink_child_to_top(self,obj):
	'Relink a child to the top node.'
	obj.node.parentNode.removeChild(obj.node)
	self.topnode[obj.parent_type].appendChild(obj.node)
	if obj.origin == "cib":
	self.update_moved(obj)
	obj.parent = None
	def _update_children(self,obj):
	'''For composite objects: update all children nodes.
	'''
	# unlink all and find them in the new node
	for child in obj.children:
	oldnode = child.node
	child.node = obj.find_child_in_node(child)
	if child.children: # and children of children
	self._update_children(child)
	rmnode(oldnode)
	if not child.parent and child.origin == "cib":
	self.update_moved(child)
	if child.parent and child.parent != obj:
	child.parent.updated = True # the other parent updated
	child.parent = obj
	def _relink_orphans_to_top(self,old_children,new_children):
	"New orphans move to the top level for the object type."
	for child in old_children:
	if child not in new_children:
	self._relink_child_to_top(child)
	def test_element(self,obj,node):
	if not node.getAttribute("id"):
	return False
	if not self.verify_element(node):
	return False
	if user_prefs.is_check_always() \
	and obj.check_sanity() > 1:
	return False
	return True
	def update_links(self,obj):
	'''
	Update the structure links for the object (obj.children,
	obj.parent). Update also the dom nodes, if necessary.
	'''
	obj.children = []
	if obj.obj_type not in vars.container_tags:
	return
	for c in obj.node.childNodes:
	if is_child_rsc(c):
	child = self.find_object_for_node(c)
	if not child:
	missing_obj_err(c)
	continue
	child.parent = obj
	obj.children.append(child)
	if not c.isSameNode(child.node):
	rmnode(child.node)
	child.node = c
	def add_element(self,obj,node):
	obj.node = node
	obj.obj_id = node.getAttribute("id")
	if not self.test_element(obj, node):
	id_store.remove_xml(node)
	node.unlink()
	return None
	common_debug("append child %s to %s" % \
	(obj.obj_id,self.topnode[obj.parent_type].tagName))
	self.topnode[obj.parent_type].appendChild(node)
	self.adjust_children(obj)
	self.redirect_children_constraints(obj)
	if not obj.cli_use_validate():
	self.nocli_warn = True
	obj.nocli = True
	self.update_links(obj)
	obj.origin = "user"
	self.cib_objects.append(obj)
	return obj
	def create_from_node(self,node):
	'Create a new cib object from a document node.'
	if not node:
	return None
	try:
	obj_type = cib_object_map[node.tagName][0]
	except:
	return None
	if is_defaults(node):
	node = get_rscop_defaults_meta_node(node)
	if not node:
	return None
	if node.ownerDocument != self.doc:
	node = self.doc.importNode(node,1)
	obj = self.new_object(obj_type, node.getAttribute("id"))
	if not obj:
	return None
	if not id_store.store_xml(node):
	return None
	return self.add_element(obj, node)
	def cib_objects_string(self, obj_list = None):
	l = []
	if not obj_list:
	obj_list = self.cib_objects
	for obj in obj_list:
	l.append(obj.obj_string())
	return ' '.join(l)
	def _remove_obj(self,obj):
	"Remove a cib object and its children."
	# remove children first
	# can't remove them here from obj.children!
	common_debug("remove object %s" % obj.obj_string())
	for child in obj.children:
	#self._remove_obj(child)
	# just relink, don't remove children
	self._relink_child_to_top(child)
	if obj.parent: # remove obj from its parent, if any
	obj.parent.children.remove(obj)
	id_store.remove_xml(obj.node)
	rmnode(obj.node)
	obj.invalid = True
	self.add_to_remove_queue(obj)
	self.cib_objects.remove(obj)
	for c_obj in self.related_constraints(obj):
	if is_simpleconstraint(c_obj.node) and obj.children:
	# the first child inherits constraints
	rename_rscref(c_obj,obj.obj_id,obj.children[0].obj_id)
	delete_rscref(c_obj,obj.obj_id)
	if silly_constraint(c_obj.node,obj.obj_id):
	# remove invalid constraints
	self._remove_obj(c_obj)
	if not self._no_constraint_rm_msg:
	err_buf.info("hanging %s deleted" % c_obj.obj_string())
	def related_constraints(self,obj):
	if not is_resource(obj.node):
	return []
	c_list = []
	for obj2 in self.cib_objects:
	if not is_constraint(obj2.node):
	continue
	if rsc_constraint(obj.obj_id,obj2.node):
	c_list.append(obj2)
	return c_list
	def redirect_children_constraints(self,obj):
	'''
	Redirect constraints to the new parent
	'''
	for child in obj.children:
	for c_obj in self.related_constraints(child):
	self.remove_queue.append(c_obj.mkcopy())
	rename_rscref(c_obj,child.obj_id,obj.obj_id)
	# drop useless constraints which may have been created above
	for c_obj in self.related_constraints(obj):
	if silly_constraint(c_obj.node,obj.obj_id):
	self._no_constraint_rm_msg = True
	self._remove_obj(c_obj)
	self._no_constraint_rm_msg = False
	def add_to_remove_queue(self,obj):
	if obj.origin == "cib":
	self.remove_queue.append(obj)
	#print self.cib_objects_string(self.remove_queue)
	def delete_1(self,obj):
	'''
	Remove an object and its parent in case the object is the
	only child.
	'''
	if obj.parent and len(obj.parent.children) == 1:
	self.delete_1(obj.parent)
	if obj in self.cib_objects: # don't remove parents twice
	self._remove_obj(obj)
	def delete(self,*args):
	'Delete a cib object.'
	if not self.doc:
	empty_cib_err()
	return False
	rc = True
	l = []
	for obj_id in args:
	obj = self.find_object(obj_id)
	if not obj:
	no_object_err(obj_id)
	rc = False
	continue
	if is_rsc_running(obj_id):
	common_warn("resource %s is running, can't delete it" % obj_id)
	else:
	l.append(obj)
	if l:
	l = processing_sort_cli(l)
	for obj in reversed(l):
	self.delete_1(obj)
	return rc
	def remove_on_rename(self,obj):
	'''
	If the renamed object is coming from the cib, then it
	must be removed and a new one created.
	'''
	if obj.origin == "cib":
	self.remove_queue.append(obj.mkcopy())
	obj.origin = "user"
	def rename(self,old_id,new_id):
	'''
	Rename a cib object.
	- check if the resource (if it's a resource) is stopped
	- check if the new id is not taken
	- find the object with old id
	- rename old id to new id in all related objects
	(constraints)
	- if the object came from the CIB, then it must be
	deleted and the one with the new name created
	- rename old id to new id in the object
	'''
	if not self.doc:
	empty_cib_err()
	return False
	if id_store.id_in_use(new_id):
	return False
	obj = self.find_object(old_id)
	if not obj:
	no_object_err(old_id)
	return False
	if not obj.can_be_renamed():
	return False
	for c_obj in self.related_constraints(obj):
	rename_rscref(c_obj,old_id,new_id)
	self.remove_on_rename(obj)
	rename_id(obj.node,old_id,new_id)
	obj.obj_id = new_id
	id_store.rename(old_id,new_id)
	obj.updated = True
	obj.propagate_updated()
	def erase(self):
	"Remove all cib objects."
	# remove only bottom objects and no constraints
	# the rest will automatically follow
	if not self.doc:
	empty_cib_err()
	return False
	erase_ok = True
	l = []
	for obj in [obj for obj in self.cib_objects \
	if not obj.children and not is_constraint(obj.node) \
	and obj.obj_type != "node" ]:
	if is_rsc_running(obj.obj_id):
	common_warn("resource %s is running, can't delete it" % obj.obj_id)
	erase_ok = False
	else:
	l.append(obj)
	if not erase_ok:
	common_err("CIB erase aborted (nothing was deleted)")
	return False
	self._no_constraint_rm_msg = True
	for obj in l:
	self.delete(obj.obj_id)
	self._no_constraint_rm_msg = False
	remaining = 0
	for obj in self.cib_objects:
	if obj.obj_type != "node":
	remaining += 1
	if remaining > 0:
	common_err("strange, but these objects remained:")
	for obj in self.cib_objects:
	if obj.obj_type != "node":
	print >> sys.stderr, obj.obj_string()
	self.cib_objects = []
	return True
	def erase_nodes(self):
	"Remove nodes only."
	if not self.doc:
	empty_cib_err()
	return False
	l = [obj for obj in self.cib_objects if obj.obj_type == "node"]
	for obj in l:
	self.delete(obj.obj_id)
	def refresh(self):
	"Refresh from the CIB."
	self.reset()
	self.initialize()

	user_prefs = UserPrefs.getInstance()
	options = Options.getInstance()
	err_buf = ErrorBuffer.getInstance()
	vars = Vars.getInstance()
	cib_factory = CibFactory.getInstance()
	cli_display = CliDisplay.getInstance()
	cib_status = CibStatus.getInstance()
	id_store = IdMgmt.getInstance()

	# vim:ts=4:sw=4:et:
	diff --git a/shell/modules/ra.py.in b/shell/modules/ra.py.in
	index 5d11f7ff31..2b0bdc0b5a 100644
	--- a/shell/modules/ra.py.in
	+++ b/shell/modules/ra.py.in
	@@ -1,597 +1,596 @@
	# Copyright (C) 2008 Dejan Muhamedagic <dmuhamedagic@suse.de>
	#
	# 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
	#

	import os
	import sys
	import subprocess
	import copy
	import xml.dom.minidom
	import re
	import glob
	from userprefs import Options, UserPrefs
	from cache import WCache
	from vars import Vars
	from utils import *
	from msg import *

	#
	# Resource Agents interface (meta-data, parameters, etc)
	#
	ocf_root = os.getenv("OCF_ROOT")
	if not ocf_root:
	ocf_root = "@OCF_ROOT_DIR@"
	if not ocf_root:
	ocf_root = "/usr/lib/ocf"
	os.putenv("OCF_ROOT",ocf_root)
	class RaLrmd(object):
	'''
	Getting information from the resource agents.
	'''
	lrmadmin_prog = "lrmadmin"
	def __init__(self):
	self.good = self.is_lrmd_accessible()
	def lrmadmin(self, opts, xml = False):
	'''
	Get information directly from lrmd using lrmadmin.
	'''
	l = stdout2list("%s %s" % (self.lrmadmin_prog,opts))
	if l and not xml:
	l = l[1:] # skip the first line
	return l
	def is_lrmd_accessible(self):
	if not (is_program(self.lrmadmin_prog) and is_process("lrmd")):
	return False
	return subprocess.call(\
	add_sudo(">/dev/null 2>&1 %s -C" % self.lrmadmin_prog), \
	shell=True) == 0
	def meta(self, ra_class,ra_type,ra_provider):
	return self.lrmadmin("-M %s %s %s"%(ra_class,ra_type,ra_provider),True)
	def providers(self, ra_type,ra_class = "ocf"):
	'List of providers for a class:type.'
	return self.lrmadmin("-P %s %s" % (ra_class,ra_type),True)
	def classes(self):
	'List of providers for a class:type.'
	return self.lrmadmin("-C")
	def types(self, ra_class = "ocf", ra_provider = ""):
	'List of types for a class.'
	return self.lrmadmin("-T %s" % ra_class)

	class RaOS(object):
	'''
	Getting information from the resource agents (direct).
	'''
	def __init__(self):
	self.good = True
	def meta(self, ra_class,ra_type,ra_provider):
	l = []
	if ra_class == "ocf":
	l = stdout2list("%s/resource.d/%s/%s meta-data" % \
	(ocf_root,ra_provider,ra_type))
	elif ra_class == "stonith":
	l = stdout2list("stonith -m -t %s" % ra_type)
	return l
	def providers(self, ra_type,ra_class = "ocf"):
	'List of providers for a class:type.'
	l = []
	if ra_class == "ocf":
	for s in glob.glob("%s/resource.d/*/%s" % (ocf_root,ra_type)):
	a = s.split("/")
	if len(a) == 7:
	l.append(a[5])
	return l
	def classes(self):
	'List of classes.'
	return "heartbeat lsb ocf stonith".split()
	def types(self, ra_class = "ocf", ra_provider = ""):
	'List of types for a class.'
	l = []
	prov = ra_provider and ra_provider or "*"
	if ra_class == "ocf":
	l = os_types_list("%s/resource.d/%s/*" % (ocf_root,prov))
	elif ra_class == "lsb":
	l = os_types_list("/etc/init.d/*")
	elif ra_class == "stonith":
	l = stdout2list("stonith -L")
	l = list(set(l))
	l.sort()
	return l

	def ra_if():
	if vars.ra_if:
	return vars.ra_if
	vars.ra_if = RaLrmd()
	if not vars.ra_if.good:
	vars.ra_if = RaOS()
	return vars.ra_if

	def ra_classes():
	'''
	List of RA classes.
	'''
	if wcache.is_cached("ra_classes"):
	return wcache.retrieve("ra_classes")
	l = ra_if().classes()
	l.sort()
	return wcache.store("ra_classes",l)
	def ra_providers(ra_type,ra_class = "ocf"):
	'List of providers for a class:type.'
	id = "ra_providers-%s-%s" % (ra_class,ra_type)
	if wcache.is_cached(id):
	return wcache.retrieve(id)
	l = ra_if().providers(ra_type,ra_class)
	l.sort()
	return wcache.store(id,l)
	def ra_providers_all(ra_class = "ocf"):
	'''
	List of providers for a class.
	'''
	id = "ra_providers_all-%s" % ra_class
	if wcache.is_cached(id):
	return wcache.retrieve(id)
	dir = ocf_root + "/resource.d"
	l = []
	for s in os.listdir(dir):
	if os.path.isdir("%s/%s" % (dir,s)):
	l.append(s)
	l.sort()
	return wcache.store(id,l)
	def ra_types(ra_class = "ocf", ra_provider = ""):
	'''
	List of RA type for a class.
	'''
	if not ra_class:
	ra_class = "ocf"
	id = "ra_types-%s-%s" % (ra_class,ra_provider)
	if wcache.is_cached(id):
	return wcache.retrieve(id)
	if ra_provider:
	list = []
	for ra in ra_if().types(ra_class):
	if ra_provider in ra_providers(ra,ra_class):
	list.append(ra)
	else:
	list = ra_if().types(ra_class)
	list.sort()
	return wcache.store(id,list)

	def prog_meta(s):
	'''
	Do external program metadata.
	'''
	prog = "@CRM_DAEMON_DIR@/%s" % s
	l = []
	if is_program(prog):
	l = stdout2list("%s metadata" % prog)
	return l
	def get_nodes_text(n,tag):
	try:
	node = n.getElementsByTagName(tag)[0]
	for c in node.childNodes:
	if c.nodeType == c.TEXT_NODE:
	return c.data.strip()
	except: return ''

	def mk_monitor_name(role,depth):
	depth = depth == "0" and "" or ("_%s" % depth)
	return role and role != "Started" and \
	"monitor_%s%s" % (role,depth) or \
	"monitor%s" % depth
	def monitor_name_node(node):
	depth = node.getAttribute("depth") or '0'
	role = node.getAttribute("role")
	return mk_monitor_name(role,depth)
	def monitor_name_pl(pl):
	depth = find_value(pl, "depth") or '0'
	role = find_value(pl, "role")
	return mk_monitor_name(role,depth)
	def crm_msec(t):
	'''
	See lib/common/utils.c:crm_get_msec().
	'''
	convtab = {
	'ms': (1,1),
	'msec': (1,1),
	'us': (1,1000),
	'usec': (1,1000),
	'': (1000,1),
	's': (1000,1),
	'sec': (1000,1),
	'm': (60*1000,1),
	'min': (60*1000,1),
	'h': (60601000,1),
	'hr': (60601000,1),
	}
	if not t:
	return -1
	r = re.match("\s(\d+)\s([a-zA-Z]+)?", t)
	if not r:
	return -1
	if not r.group(2):
	q = ''
	else:
	q = r.group(2).lower()
	try:
	mult,div = convtab[q]
	except:
	return -1
	return (int(r.group(1))*mult)/div
	def crm_time_cmp(a, b):
	return crm_msec(a) - crm_msec(b)

	class RAInfo(object):
	'''
	A resource agent and whatever's useful about it.
	'''
	ra_tab = " " # four horses
	required_ops = ("start", "stop")
	skip_ops = ("meta-data", "validate-all")
	skip_op_attr = ("name", "depth", "role")
	def __init__(self,ra_class,ra_type,ra_provider = "heartbeat"):
	self.ra_class = ra_class
	self.ra_type = ra_type
	self.ra_provider = ra_provider
	if not self.ra_provider:
	self.ra_provider = "heartbeat"
	self.ra_node = None
	def ra_string(self):
	return self.ra_class == "ocf" and \
	"%s:%s:%s" % (self.ra_class, self.ra_provider, self.ra_type) or \
	"%s:%s" % (self.ra_class, self.ra_type)
	def error(self, s):
	common_err("%s: %s" % (self.ra_string(), s))
	def warn(self, s):
	common_warn("%s: %s" % (self.ra_string(), s))
	def add_extra_stonith_params(self):
	if not vars.stonithd_metadata:
	vars.stonithd_metadata = RAInfo("stonithd","metadata")
	if not vars.stonithd_metadata.mk_ra_node():
	return
	try:
	params_node = self.doc.getElementsByTagName("parameters")[0]
	except:
	params_node = self.doc.createElement("parameters")
	self.ra_node.appendChild(params_node)
	for n in vars.stonithd_metadata.ra_node.getElementsByTagName("parameter"):
	params_node.appendChild(self.doc.importNode(n,1))
	def mk_ra_node(self):
	'''
	Return the resource_agent node.
	'''
	if self.ra_node:
	return self.ra_node
	meta = self.meta()
	try:
	self.doc = xml.dom.minidom.parseString('\n'.join(meta))
	except:
	- #common_err("could not parse meta-data for (%s,%s,%s)" \
	- # % (self.ra_class,self.ra_type,self.ra_provider))
	+ self.error("could not parse meta-data: %s" % '\n'.join(meta))
	self.ra_node = None
	return None
	try:
	self.ra_node = self.doc.getElementsByTagName("resource-agent")[0]
	except:
	self.error("meta-data contains no resource-agent element")
	self.ra_node = None
	return None
	if self.ra_class == "stonith":
	self.add_extra_stonith_params()
	return self.ra_node
	def param_type_default(self,n):
	try:
	content = n.getElementsByTagName("content")[0]
	type = content.getAttribute("type")
	default = content.getAttribute("default")
	return type,default
	except:
	return None,None
	def params(self):
	'''
	Construct a dict of dicts: parameters are keys and
	dictionary of attributes/values are values. Cached too.
	'''
	id = "ra_params-%s" % self.ra_string()
	if wcache.is_cached(id):
	return wcache.retrieve(id)
	if not self.mk_ra_node():
	return None
	d = {}
	for pset in self.ra_node.getElementsByTagName("parameters"):
	for c in pset.getElementsByTagName("parameter"):
	name = c.getAttribute("name")
	if not name:
	continue
	required = c.getAttribute("required")
	unique = c.getAttribute("unique")
	type,default = self.param_type_default(c)
	d[name] = {
	"required": required,
	"unique": unique,
	"type": type,
	"default": default,
	}
	return wcache.store(id,d)
	def actions(self):
	'''
	Construct a dict of dicts: actions are keys and
	dictionary of attributes/values are values. Cached too.
	'''
	id = "ra_actions-%s" % self.ra_string()
	if wcache.is_cached(id):
	return wcache.retrieve(id)
	if not self.mk_ra_node():
	return None
	d = {}
	for pset in self.ra_node.getElementsByTagName("actions"):
	for c in pset.getElementsByTagName("action"):
	name = c.getAttribute("name")
	if not name or name in self.skip_ops:
	continue
	if name == "monitor":
	name = monitor_name_node(c)
	d[name] = {}
	for a in c.attributes.keys():
	if a in self.skip_op_attr:
	continue
	v = c.getAttribute(a)
	if v:
	d[name][a] = v
	# add monitor ops without role, if they don't already
	# exist
	d2 = {}
	for op in d.keys():
	if re.match("monitor_[^0-9]", op):
	norole_op = re.sub(r'monitor_[^0-9_]+_(.*)', r'monitor_\1', op)
	if not norole_op in d:
	d2[norole_op] = d[op]
	d.update(d2)
	return wcache.store(id,d)
	def reqd_params_list(self):
	'''
	List of required parameters.
	'''
	d = self.params()
	if not d: return []
	return [x for x in d if d[x]["required"] == '1']
	def param_default(self,pname):
	'''
	Parameter's default.
	'''
	d = self.params()
	- if not d: return None
	- return d[pname]["default"]
	+ try: return d[pname]["default"]
	+ except: return None
	def sanity_check_params(self, id, pl):
	'''
	pl is a list of (attribute,value) pairs.
	- are all required parameters defined
	- do all parameters exist
	'''
	rc = 0
	d = {}
	for p,v in pl:
	d[p] = v
	for p in self.reqd_params_list():
	if p not in d:
	common_err("%s: required parameter %s not defined" % (id,p))
	rc \|= user_prefs.get_check_rc()
	for p in d:
	if p not in self.params():
	common_err("%s: parameter %s does not exist" % (id,p))
	rc \|= user_prefs.get_check_rc()
	return rc
	def sanity_check_ops(self, id, ops, default_timeout):
	'''
	ops is a dict, operation names are keys and values are
	lists of (attribute,value) pairs.
	- do all operations exist
	- are timeouts sensible
	'''
	rc = 0
	n_ops = {}
	for op in ops:
	n_op = op == "monitor" and monitor_name_pl(ops[op]) or op
	n_ops[n_op] = {}
	for p,v in ops[op]:
	if p in self.skip_op_attr:
	continue
	n_ops[n_op][p] = v
	for req_op in self.required_ops:
	if req_op not in n_ops:
	n_ops[req_op] = {}
	for op in n_ops:
	if op not in self.actions():
	common_warn("%s: action %s not advertised in meta-data, it may not be supported by the RA" % (id,op))
	rc \|= 1
	continue
	try:
	adv_timeout = self.actions()[op]["timeout"]
	except:
	continue
	if "timeout" in n_ops[op]:
	v = n_ops[op]["timeout"]
	timeout_string = "specified timeout"
	else:
	v = default_timeout
	timeout_string = "default timeout"
	if crm_msec(v) < 0:
	continue
	if crm_time_cmp(adv_timeout,v) > 0:
	common_warn("%s: %s %s for %s is smaller than the advised %s" % \
	(id,timeout_string,v,op,adv_timeout))
	rc \|= 1
	return rc
	def meta(self):
	'''
	RA meta-data as raw xml.
	'''
	id = "ra_meta-%s" % self.ra_string()
	if wcache.is_cached(id):
	return wcache.retrieve(id)
	- if self.ra_class in ("pengine","stonithd"):
	+ if self.ra_class in ("crmd","pengine","stonithd"):
	l = prog_meta(self.ra_class)
	else:
	l = ra_if().meta(self.ra_class,self.ra_type,self.ra_provider)
	return wcache.store(id, l)
	def meta_pretty(self):
	'''
	Print the RA meta-data in a human readable form.
	'''
	if not self.mk_ra_node():
	return ''
	l = []
	title = self.meta_title()
	l.append(title)
	longdesc = get_nodes_text(self.ra_node,"longdesc")
	if longdesc:
	l.append(longdesc)
	if self.ra_class != "heartbeat":
	params = self.meta_parameters()
	if params:
	l.append(params.rstrip())
	actions = self.meta_actions()
	if actions:
	l.append(actions)
	return '\n\n'.join(l)
	def get_shortdesc(self,n):
	name = n.getAttribute("name")
	shortdesc = get_nodes_text(n,"shortdesc")
	longdesc = get_nodes_text(n,"longdesc")
	if shortdesc and shortdesc not in (name,longdesc,self.ra_type):
	return shortdesc
	return ''
	def meta_title(self):
	s = self.ra_string()
	shortdesc = self.get_shortdesc(self.ra_node)
	if shortdesc:
	s = "%s (%s)" % (shortdesc,s)
	return s
	def meta_param_head(self,n):
	name = n.getAttribute("name")
	if not name:
	return None
	s = name
	if n.getAttribute("required") == "1":
	s = s + "*"
	type,default = self.param_type_default(n)
	if type and default:
	s = "%s (%s, [%s])" % (s,type,default)
	elif type:
	s = "%s (%s)" % (s,type)
	shortdesc = self.get_shortdesc(n)
	s = "%s: %s" % (s,shortdesc)
	return s
	def format_parameter(self,n):
	l = []
	head = self.meta_param_head(n)
	if not head:
	self.error("no name attribute for parameter")
	return ""
	l.append(head)
	longdesc = get_nodes_text(n,"longdesc")
	if longdesc:
	longdesc = self.ra_tab + longdesc.replace("\n","\n"+self.ra_tab) + '\n'
	l.append(longdesc)
	return '\n'.join(l)
	def meta_parameter(self,param):
	if not self.mk_ra_node():
	return ''
	l = []
	for pset in self.ra_node.getElementsByTagName("parameters"):
	for c in pset.getElementsByTagName("parameter"):
	if c.getAttribute("name") == param:
	return self.format_parameter(c)
	def meta_parameters(self):
	if not self.mk_ra_node():
	return ''
	l = []
	for pset in self.ra_node.getElementsByTagName("parameters"):
	for c in pset.getElementsByTagName("parameter"):
	s = self.format_parameter(c)
	if s:
	l.append(s)
	if l:
	return "Parameters (* denotes required, [] the default):\n\n" + '\n'.join(l)
	def meta_action_head(self,n):
	name = n.getAttribute("name")
	if not name:
	return ''
	if name in self.skip_ops:
	return ''
	if name == "monitor":
	name = monitor_name_node(n)
	s = "%-13s" % name
	for a in n.attributes.keys():
	if a in self.skip_op_attr:
	continue
	v = n.getAttribute(a)
	if v:
	s = "%s %s=%s" % (s,a,v)
	return s
	def meta_actions(self):
	l = []
	for aset in self.ra_node.getElementsByTagName("actions"):
	for c in aset.getElementsByTagName("action"):
	s = self.meta_action_head(c)
	if s:
	l.append(self.ra_tab + s)
	if l:
	return "Operations' defaults (advisory minimum):\n\n" + '\n'.join(l)

	#
	# resource type definition
	#
	def ra_type_validate(s, ra_class, provider, rsc_type):
	'''
	Only ocf ra class supports providers.
	'''
	if not rsc_type:
	common_err("bad resource type specification %s"%s)
	return False
	if ra_class == "ocf":
	if not provider:
	common_err("provider could not be determined for %s"%s)
	return False
	else:
	if provider:
	common_warn("ra class %s does not support providers"%ra_class)
	return True
	return True
	def disambiguate_ra_type(s):
	'''
	Unravel [class:[provider:]]type
	'''
	l = s.split(':')
	if not l or len(l) > 3:
	return None
	if len(l) == 3:
	return l
	elif len(l) == 2:
	ra_class,ra_type = l
	else:
	ra_class = "ocf"
	ra_type = l[0]
	ra_provider = ''
	if ra_class == "ocf":
	pl = ra_providers(ra_type,ra_class)
	if pl and len(pl) == 1:
	ra_provider = pl[0]
	elif not pl:
	ra_provider = 'heartbeat'
	return ra_class,ra_provider,ra_type

	wcache = WCache.getInstance()
	vars = Vars.getInstance()
	# vim:ts=4:sw=4:et:
	diff --git a/shell/modules/vars.py.in b/shell/modules/vars.py.in
	index d1cf6a4a67..3e47de5fe1 100644
	--- a/shell/modules/vars.py.in
	+++ b/shell/modules/vars.py.in
	@@ -1,127 +1,133 @@
	# Copyright (C) 2008 Dejan Muhamedagic <dmuhamedagic@suse.de>
	#
	# 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
	#

	import os
	from singletonmixin import Singleton

	class Vars(Singleton):
	cib_cli_map = {
	"node": "node",
	"primitive": "primitive",
	"group": "group",
	"clone": "clone",
	"master": "ms",
	"rsc_location": "location",
	"rsc_colocation": "colocation",
	"rsc_order": "order",
	"cluster_property_set": "property",
	"rsc_defaults": "rsc_defaults",
	"op_defaults": "op_defaults",
	}
	container_tags = ("group", "clone", "ms", "master")
	clonems_tags = ("clone", "ms", "master")
	resource_tags = ("primitive","group","clone","ms","master")
	constraint_tags = ("rsc_location","rsc_colocation","rsc_order")
	constraint_rsc_refs = ("rsc","with-rsc","first","then")
	children_tags = ("group", "primitive")
	nvpairs_tags = ("meta_attributes", "instance_attributes")
	defaults_tags = ("rsc_defaults","op_defaults")
	resource_cli_names = ("primitive","group","clone","ms","master")
	constraint_cli_names = ("location","colocation","collocation","order")
	nvset_cli_names = ("property","rsc_defaults","op_defaults")
	op_cli_names = ("monitor", "start", "stop", "migrate_to", "migrate_from","promote","demote","notify")
	ra_operations = ("probe", "monitor", "start", "stop",
	"promote", "demote", "notify", "migrate_to", "migrate_from")
	subpfx_list = {
	"instance_attributes": "instance_attributes",
	"meta_attributes": "meta_attributes",
	"operations": "ops",
	"rule": "rule",
	"expression": "expression",
	"date_expression": "expression",
	"duration": "duration",
	"date_spec": "date_spec",
	}
	lrm_exit_codes = {
	"success": "0",
	"unknown": "1",
	"args": "2",
	"unimplemented": "3",
	"perm": "4",
	"installed": "5",
	"configured": "6",
	"not_running": "7",
	"master": "8",
	"failed_master": "9",
	}
	lrm_status_codes = {
	"pending": "-1",
	"done": "0",
	"cancelled": "1",
	"timeout": "2",
	"notsupported": "3",
	"error": "4",
	}
	node_states = ("online", "offline", "unclean")
	precious_attrs = ("id-ref",)
	time_op_attrs = ("timeout",)
	req_op_attributes = ("name", "id")
	- op_attributes = (\
	- "interval", "timeout", "requires", "enabled", "role", \
	- "on-fail", "start-delay", "allow-migrate", "interval-origin", \
	- "record-pending", "description", \
	+ op_attributes = (
	+ "interval", "timeout", "requires", "enabled", "role",
	+ "on-fail", "start-delay", "interval-origin",
	+ "record-pending", "description",
	)
	rsc_meta_attributes = (
	"allow-migrate", "is-managed", "interval-origin",
	"migration-threshold", "priority", "multiple-active",
	"failure-timeout", "resource-stickiness", "target-role",
	- "restart-type", "ordered", "notify", "on-fail",
	- "interleave", "globally-unique", "clone-max", "clone-node-max",
	- "clone-state", "master-max", "master-node-max",
	+ "restart-type", "description",
	+ )
	+ clone_meta_attributes = (
	+ "ordered", "notify", "interleave", "globally-unique",
	+ "clone-max", "clone-node-max", "clone-state", "description",
	+ )
	+ ms_meta_attributes = (
	+ "master-max", "master-node-max", "description",
	)
	score_types = {'advisory': '0','mandatory': 'INFINITY'}
	boolean_ops = ('or','and')
	binary_ops = ('lt','gt','lte','gte','eq','ne')
	binary_types = ('string' , 'version' , 'number')
	unary_ops = ('defined','not_defined')
	simple_date_ops = ('lt','gt')
	date_ops = ('lt','gt','in_range','date_spec')
	date_spec_names = '''hours monthdays weekdays yearsdays months \
	weeks years weekyears moon'''.split()
	in_range_attrs = ('start','end')
	roles_names = ('Stopped', 'Started', 'Master', 'Slave')
	actions_names = ( 'start', 'promote', 'demote', 'stop')
	node_default_type = "normal"
	node_attributes_keyw = ("attributes",)
	shadow_envvar = "CIB_shadow"

	prompt = ''
	tmpfiles = []
	this_node = os.uname()[1]
	cib_in_use = os.getenv(shadow_envvar)
	hist_file = os.environ.get('HOME')+"/.crm_history"
	rc_file = os.environ.get('HOME')+"/.crm.rc"
	tmpl_conf_dir = "%s/%s" % (os.getenv("HOME"),".crmconf")
	tmpl_dir = "@datadir@/@PACKAGE@/templates"
	pe_dir = "@PE_STATE_DIR@"
	crm_conf_dir = "@CRM_CONFIG_DIR@"

	ra_if = None # class interface to RA
	stonithd_metadata = None # stonithd meta data
	pe_metadata = None # PE meta data
	+ crmd_metadata = None # crmd meta data

	# vim:ts=4:sw=4:et:
	diff --git a/shell/modules/xmlutil.py b/shell/modules/xmlutil.py
	index f8b09042c1..3ac554b086 100644
	--- a/shell/modules/xmlutil.py
	+++ b/shell/modules/xmlutil.py
	@@ -1,708 +1,728 @@
	# Copyright (C) 2008 Dejan Muhamedagic <dmuhamedagic@suse.de>
	#
	# 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
	#

	import os
	import subprocess
	import xml.dom.minidom

	from userprefs import Options, UserPrefs
	from vars import Vars
	from msg import *
	from utils import *

	def xmlparse(f):
	try:
	doc = xml.dom.minidom.parse(f)
	except xml.parsers.expat.ExpatError,msg:
	common_err("cannot parse xml: %s" % msg)
	return None
	return doc
	def file2doc(s):
	try: f = open(s,'r')
	except IOError, msg:
	common_err(msg)
	return None
	doc = xmlparse(f)
	f.close()
	return doc

	cib_dump = "cibadmin -Ql"
	def cibdump2doc(section = None):
	doc = None
	if section:
	cmd = "%s -o %s" % (cib_dump,section)
	else:
	cmd = cib_dump
	cmd = add_sudo(cmd)
	p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
	try:
	doc = xmlparse(p.stdout)
	p.wait()
	except IOError, msg:
	common_err(msg)
	return None
	return doc
	cib_piped = "cibadmin -p"
	def commit_rsc(node):
	"Replace a resource definition using cibadmin -R"
	rc = pipe_string("%s -R -o %s" % \
	(cib_piped, "resources"), node.toxml())
	return rc == 0

	def get_conf_elem(doc, tag):
	try:
	return doc.getElementsByTagName(tag)[0]
	except:
	return None
	def read_cib(fun, params = None):
	doc = fun(params)
	if not doc:
	return doc,None
	cib = doc.childNodes[0]
	if not is_element(cib) or cib.tagName != "cib":
	cib_no_elem_err("cib")
	return doc,None
	return doc,cib

	+def sanity_check_nvpairs(id,node,attr_list):
	+ rc = 0
	+ for nvpair in node.childNodes:
	+ if not is_element(nvpair) or nvpair.tagName != "nvpair":
	+ continue
	+ n = nvpair.getAttribute("name")
	+ if n and not n in attr_list:
	+ common_err("%s: attribute %s does not exist" % (id,n))
	+ rc \|= user_prefs.get_check_rc()
	+ return rc
	+def sanity_check_meta(id,node,attr_list):
	+ rc = 0
	+ if not node or not attr_list:
	+ return rc
	+ for c in node.childNodes:
	+ if not is_element(c):
	+ continue
	+ if c.tagName == "meta_attributes":
	+ rc \|= sanity_check_nvpairs(id,c,attr_list)
	+ return rc
	def get_interesting_nodes(node,nodes):
	for c in node.childNodes:
	if is_element(c) and c.tagName in vars.cib_cli_map:
	nodes.append(c)
	get_interesting_nodes(c,nodes)
	return nodes

	def resources_xml():
	return cibdump2doc("resources")
	def rsc2node(id):
	doc = resources_xml()
	if not doc:
	return None
	nodes = get_interesting_nodes(doc,[])
	for n in nodes:
	if is_resource(n) and n.getAttribute("id") == id:
	return n
	def get_meta_param(id,param):
	rsc_meta_show = "crm_resource --meta -r '%s' -g '%s'"
	return get_stdout(rsc_meta_show % (id,param), stderr_on = False)
	def is_live_cib():
	'''We working with the live cluster?'''
	return not vars.cib_in_use and not os.getenv("CIB_file")
	def is_rsc_running(id):
	if not is_live_cib():
	return False
	rsc_node = rsc2node(id)
	if not rsc_node:
	return False
	if not is_resource(rsc_node):
	return False
	rsc_status = "crm_resource -W -r '%s'"
	test_id = rsc_clone(id) or id
	outp = get_stdout(rsc_status % test_id, stderr_on = False)
	return outp.find("running") > 0 and outp.find("NOT") == -1
	def is_rsc_clone(rsc_id):
	rsc_node = rsc2node(rsc_id)
	return is_clone(rsc_node)
	def is_rsc_ms(rsc_id):
	rsc_node = rsc2node(rsc_id)
	return is_ms(rsc_node)
	def rsc_clone(rsc_id):
	'''Get a clone of a resource.'''
	rsc_node = rsc2node(rsc_id)
	if not rsc_node or not rsc_node.parentNode:
	return None
	pnode = rsc_node.parentNode
	if is_group(pnode):
	pnode = pnode.parentNode
	if is_clonems(pnode):
	return pnode.getAttribute("id")
	def get_topmost_rsc(node):
	'''
	Return a topmost node which is a resource and contains this resource
	'''
	if is_container(node.parentNode):
	return get_topmost_rsc(node.parentNode)
	return node
	def get_cloned_rsc(rsc_id):
	rsc_node = rsc2node(rsc_id)
	if not rsc_node:
	return ""
	for c in rsc_node.childNodes:
	if is_child_rsc(c):
	return c.getAttribute("id")
	return ""
	attr_defaults_missing = {
	}
	def add_missing_attr(node):
	try:
	for defaults in attr_defaults_missing[node.tagName]:
	if not node.hasAttribute(defaults[0]):
	node.setAttribute(defaults[0],defaults[1])
	except: pass
	attr_defaults = {
	"rule": (("boolean-op","and"),),
	"expression": (("type","string"),),
	}
	def drop_attr_defaults(node, ts = 0):
	try:
	for defaults in attr_defaults[node.tagName]:
	if node.getAttribute(defaults[0]) == defaults[1]:
	node.removeAttribute(defaults[0])
	except: pass

	def is_element(xmlnode):
	return xmlnode and xmlnode.nodeType == xmlnode.ELEMENT_NODE

	def nameandid(xmlnode,level):
	if xmlnode.nodeType == xmlnode.ELEMENT_NODE:
	print level*' ',xmlnode.tagName,xmlnode.getAttribute("id"),xmlnode.getAttribute("name")

	def xmltraverse(xmlnode,fun,ts=0):
	for c in xmlnode.childNodes:
	if is_element(c):
	fun(c,ts)
	xmltraverse(c,fun,ts+1)

	def xmltraverse_thin(xmlnode,fun,ts=0):
	'''
	Skip elements which may be resources themselves.
	NB: Call this only on resource (or constraint) nodes, but
	never on cib or configuration!
	'''
	for c in xmlnode.childNodes:
	if is_element(c) and not c.tagName in ('primitive','group'):
	xmltraverse_thin(c,fun,ts+1)
	fun(xmlnode,ts)

	def xml_processnodes(xmlnode,node_filter,proc):
	'''
	Process with proc all nodes that match filter.
	'''
	node_list = []
	for child in xmlnode.childNodes:
	if node_filter(child):
	node_list.append(child)
	if child.hasChildNodes():
	xml_processnodes(child,node_filter,proc)
	if node_list:
	proc(node_list)

	# filter the cib
	def is_whitespace(node):
	return node.nodeType == node.TEXT_NODE and not node.data.strip()
	def is_comment(node):
	return node.nodeType == node.COMMENT_NODE
	def is_status_node(node):
	return is_element(node) and node.tagName == "status"

	def is_emptynvpairs(node):
	if is_element(node) and node.tagName in vars.nvpairs_tags:
	for a in vars.precious_attrs:
	if node.getAttribute(a):
	return False
	for n in node.childNodes:
	if is_element(n):
	return False
	return True
	else:
	return False
	def is_group(node):
	return is_element(node) \
	and node.tagName == "group"
	def is_ms(node):
	return is_element(node) \
	and node.tagName in ("master","ms")
	def is_clone(node):
	return is_element(node) \
	and node.tagName == "clone"
	def is_clonems(node):
	return is_element(node) \
	and node.tagName in vars.clonems_tags
	def is_container(node):
	return is_element(node) \
	and node.tagName in vars.container_tags
	def is_primitive(node):
	return is_element(node) \
	and node.tagName == "primitive"
	def is_resource(node):
	return is_element(node) \
	and node.tagName in vars.resource_tags
	def is_child_rsc(node):
	return is_element(node) \
	and node.tagName in vars.children_tags
	def is_constraint(node):
	return is_element(node) \
	and node.tagName in vars.constraint_tags
	def is_defaults(node):
	return is_element(node) \
	and node.tagName in vars.defaults_tags
	def rsc_constraint(rsc_id,cons_node):
	if not is_element(cons_node):
	return False
	for attr in cons_node.attributes.keys():
	if attr in vars.constraint_rsc_refs \
	and rsc_id == cons_node.getAttribute(attr):
	return True
	for rref in cons_node.getElementsByTagName("resource_ref"):
	if rsc_id == rref.getAttribute("id"):
	return True
	return False

	def sort_container_children(node_list):
	'''
	Make sure that attributes's nodes are first, followed by the
	elements (primitive/group). The order of elements is not
	disturbed, they are just shifted to end!
	'''
	for node in node_list:
	children = []
	for c in node.childNodes:
	if is_element(c) and c.tagName in vars.children_tags:
	children.append(c)
	for c in children:
	node.removeChild(c)
	for c in children:
	node.appendChild(c)
	def rmnode(node):
	if node and node.parentNode:
	if node.parentNode:
	node.parentNode.removeChild(node)
	node.unlink()
	def rmnodes(node_list):
	for node in node_list:
	rmnode(node)
	def printid(node_list):
	for node in node_list:
	id = node.getAttribute("id")
	if id: print "node id:",id
	def sanitize_cib(doc):
	xml_processnodes(doc,is_status_node,rmnodes)
	#xml_processnodes(doc,is_element,printid)
	xml_processnodes(doc,is_emptynvpairs,rmnodes)
	xml_processnodes(doc,is_whitespace,rmnodes)
	xml_processnodes(doc,is_comment,rmnodes)
	xml_processnodes(doc,is_container,sort_container_children)
	xmltraverse(doc,drop_attr_defaults)

	def is_simpleconstraint(node):
	return len(node.getElementsByTagName("resource_ref")) == 0

	match_list = {
	"node": ("uname",),
	"crm_config": (),
	"rsc_defaults": (),
	"op_defaults": (),
	"cluster_property_set": (),
	"instance_attributes": (),
	"meta_attributes": (),
	"operations": (),
	"nvpair": ("name",),
	"op": ("name","interval"),
	"rule": ("score","score-attribute","role"),
	"expression": ("attribute","operation","value"),
	}
	def add_comment(doc,node,s):
	'''
	Add comment s to node from doc.
	'''
	if not s:
	return
	comm_node = doc.createComment(s)
	if node.hasChildNodes():
	node.insertBefore(comm_node, node.firstChild)
	else:
	node.appendChild(comm_node)
	def set_id_used_attr(node):
	node.setAttribute("__id_used", "Yes")
	def is_id_used_attr(node):
	return node.getAttribute("__id_used") == "Yes"
	def remove_id_used_attr(node,lvl):
	if is_element(node) and is_id_used_attr(node):
	node.removeAttribute("__id_used")
	def remove_id_used_attributes(node):
	if node:
	xmltraverse(node, remove_id_used_attr)
	def lookup_node(node,oldnode,location_only = False):
	'''
	Find a child of oldnode which matches node.
	'''
	#print "lookup:",node.tagName,node.getAttribute("id")
	if not oldnode:
	return None
	#print " in:",oldnode.tagName,oldnode.getAttribute("id")
	try:
	attr_list = list(match_list[node.tagName])
	except KeyError:
	attr_list = []
	if node.getAttribute("id") and oldnode.getAttribute("id"):
	attr_list.append("id")
	for c in oldnode.childNodes:
	if not is_element(c):
	continue
	if not location_only and is_id_used_attr(c):
	continue
	#print " checking:",c.tagName,c.getAttribute("id")
	if node.tagName == c.tagName:
	failed = False
	for a in attr_list:
	if node.getAttribute(a) != c.getAttribute(a):
	failed = True
	break
	if not failed:
	#print " found:",c.tagName,c.getAttribute("id")
	return c
	return None

	def find_operation(rsc_node,name,interval):
	op_node_l = rsc_node.getElementsByTagName("operations")
	for ops in op_node_l:
	for c in ops.childNodes:
	if not is_element(c):
	continue
	if c.tagName != "op":
	continue
	if c.getAttribute("name") == name \
	and c.getAttribute("interval") == interval:
	return c

	def filter_on_tag(nl,tag):
	return [node for node in nl if node.tagName == tag]
	def nodes(node_list):
	return filter_on_tag(node_list,"node")
	def primitives(node_list):
	return filter_on_tag(node_list,"primitive")
	def groups(node_list):
	return filter_on_tag(node_list,"group")
	def clones(node_list):
	return filter_on_tag(node_list,"clone")
	def mss(node_list):
	return filter_on_tag(node_list,"master")
	def constraints(node_list):
	return filter_on_tag(node_list,"rsc_location") \
	+ filter_on_tag(node_list,"rsc_colocation") \
	+ filter_on_tag(node_list,"rsc_order")
	def properties(node_list):
	return filter_on_tag(node_list,"cluster_property_set") \
	+ filter_on_tag(node_list,"rsc_defaults") \
	+ filter_on_tag(node_list,"op_defaults")
	def processing_sort(nl):
	'''
	It's usually important to process cib objects in this order,
	i.e. simple objects first.
	'''
	return nodes(nl) + primitives(nl) + groups(nl) + mss(nl) + clones(nl) \
	+ constraints(nl) + properties(nl)

	def obj_cmp(obj1,obj2):
	return cmp(obj1.obj_id,obj2.obj_id)
	def filter_on_type(cl,obj_type):
	if type(cl[0]) == type([]):
	l = [cli_list for cli_list in cl if cli_list[0][0] == obj_type]
	if user_prefs.get_sort_elems():
	l.sort(cmp = cmp)
	else:
	l = [obj for obj in cl if obj.obj_type == obj_type]
	if user_prefs.get_sort_elems():
	l.sort(cmp = obj_cmp)
	return l
	def nodes_cli(cl):
	return filter_on_type(cl,"node")
	def primitives_cli(cl):
	return filter_on_type(cl,"primitive")
	def groups_cli(cl):
	return filter_on_type(cl,"group")
	def clones_cli(cl):
	return filter_on_type(cl,"clone")
	def mss_cli(cl):
	return filter_on_type(cl,"ms") + filter_on_type(cl,"master")
	def constraints_cli(node_list):
	return filter_on_type(node_list,"location") \
	+ filter_on_type(node_list,"colocation") \
	+ filter_on_type(node_list,"collocation") \
	+ filter_on_type(node_list,"order")
	def properties_cli(cl):
	return filter_on_type(cl,"property") \
	+ filter_on_type(cl,"rsc_defaults") \
	+ filter_on_type(cl,"op_defaults")
	def ops_cli(cl):
	return filter_on_type(cl,"op")
	def processing_sort_cli(cl):
	'''
	Return the given list in this order:
	nodes, primitives, groups, ms, clones, constraints, rest
	Both a list of objects (CibObject) and list of cli
	representations accepted.
	'''
	return nodes_cli(cl) + primitives_cli(cl) + groups_cli(cl) + mss_cli(cl) + clones_cli(cl) \
	+ constraints_cli(cl) + properties_cli(cl) + ops_cli(cl)

	def is_resource_cli(s):
	return s in olist(vars.resource_cli_names)
	def is_constraint_cli(s):
	return s in olist(vars.constraint_cli_names)

	def referenced_resources(node):
	if not is_constraint(node):
	return []
	xml_obj_type = node.tagName
	if xml_obj_type == "rsc_location":
	node_list = node.getElementsByTagName("rsc")
	elif node.getElementsByTagName("resource_ref"): # resource sets
	node_list = node.getElementsByTagName("resource_ref")
	elif xml_obj_type == "rsc_colocation":
	node_list = node.getElementsByTagName("rsc") + \
	node.getElementsByTagName("with-rsc")
	elif xml_obj_type == "rsc_order":
	node_list = node.getElementsByTagName("first") + \
	node.getElementsByTagName("then")
	return [x.getAttribute("id") for x in node_list]

	def rename_id(node,old_id,new_id):
	if node.getAttribute("id") == old_id:
	node.setAttribute("id", new_id)
	def rename_rscref_simple(c_obj,old_id,new_id):
	c_modified = False
	for attr in c_obj.node.attributes.keys():
	if attr in vars.constraint_rsc_refs and \
	c_obj.node.getAttribute(attr) == old_id:
	c_obj.node.setAttribute(attr, new_id)
	c_obj.updated = True
	c_modified = True
	return c_modified
	def delete_rscref_simple(c_obj,rsc_id):
	c_modified = False
	for attr in c_obj.node.attributes.keys():
	if attr in vars.constraint_rsc_refs and \
	c_obj.node.getAttribute(attr) == rsc_id:
	c_obj.node.removeAttribute(attr)
	c_obj.updated = True
	c_modified = True
	return c_modified
	def rset_uniq(c_obj,d):
	'''
	Drop duplicate resource references.
	'''
	l = []
	for rref in c_obj.node.getElementsByTagName("resource_ref"):
	rsc_id = rref.getAttribute("id")
	if d[rsc_id] > 1: # drop one
	l.append(rref)
	d[rsc_id] -= 1
	rmnodes(l)
	def delete_rscref_rset(c_obj,rsc_id):
	'''
	Drop all reference to rsc_id.
	'''
	c_modified = False
	l = []
	for rref in c_obj.node.getElementsByTagName("resource_ref"):
	if rsc_id == rref.getAttribute("id"):
	l.append(rref)
	c_obj.updated = True
	c_modified = True
	rmnodes(l)
	l = []
	for rset in c_obj.node.getElementsByTagName("resource_set"):
	if len(rset.getElementsByTagName("resource_ref")) == 0:
	l.append(rset)
	c_obj.updated = True
	c_modified = True
	rmnodes(l)
	return c_modified
	def rset_convert(c_obj):
	l = c_obj.node.getElementsByTagName("resource_ref")
	if len(l) != 2:
	return # eh?
	c_obj.modified = True
	cli = c_obj.repr_cli(format = -1)
	newnode = c_obj.cli2node(cli)
	if newnode:
	c_obj.node.parentNode.replaceChild(newnode,c_obj.node)
	c_obj.node.unlink()
	def rename_rscref_rset(c_obj,old_id,new_id):
	c_modified = False
	d = {}
	for rref in c_obj.node.getElementsByTagName("resource_ref"):
	rsc_id = rref.getAttribute("id")
	if rsc_id == old_id:
	rref.setAttribute("id", new_id)
	rsc_id = new_id
	c_obj.updated = True
	c_modified = True
	if not rsc_id in d:
	d[rsc_id] = 0
	else:
	d[rsc_id] += 1
	rset_uniq(c_obj,d)
	# if only two resource references remained then, to preserve
	# sanity, convert it to a simple constraint (sigh)
	cnt = 0
	for key in d:
	cnt += d[key]
	if cnt == 2:
	rset_convert(c_obj)
	return c_modified
	def rename_rscref(c_obj,old_id,new_id):
	if rename_rscref_simple(c_obj,old_id,new_id) or \
	rename_rscref_rset(c_obj,old_id,new_id):
	err_buf.info("resource references in %s updated" % c_obj.obj_string())
	def delete_rscref(c_obj,rsc_id):
	return delete_rscref_simple(c_obj,rsc_id) or \
	delete_rscref_rset(c_obj,rsc_id)
	def silly_constraint(c_node,rsc_id):
	'''
	Remove a constraint from rsc_id to rsc_id.
	Or an invalid one.
	'''
	if c_node.getElementsByTagName("resource_ref"):
	# it's a resource set
	# the resource sets have already been uniq-ed
	return len(c_node.getElementsByTagName("resource_ref")) <= 1
	cnt = 0 # total count of referenced resources have to be at least two
	rsc_cnt = 0
	for attr in c_node.attributes.keys():
	if attr in vars.constraint_rsc_refs:
	cnt += 1
	if c_node.getAttribute(attr) == rsc_id:
	rsc_cnt += 1
	if c_node.tagName == "rsc_location": # locations are never silly
	return cnt < 1
	else:
	return rsc_cnt == 2 or cnt < 2

	def get_rsc_children_ids(node):
	return [x.getAttribute("id") \
	for x in node.childNodes if is_child_rsc(x)]
	def get_rscop_defaults_meta_node(node):
	for c in node.childNodes:
	if not is_element(c) or c.tagName != "meta_attributes":
	continue
	return c
	return None

	def new_cib():
	doc = xml.dom.minidom.Document()
	cib = doc.createElement("cib")
	doc.appendChild(cib)
	configuration = doc.createElement("configuration")
	cib.appendChild(configuration)
	crm_config = doc.createElement("crm_config")
	configuration.appendChild(crm_config)
	rsc_defaults = doc.createElement("rsc_defaults")
	configuration.appendChild(rsc_defaults)
	op_defaults = doc.createElement("op_defaults")
	configuration.appendChild(op_defaults)
	nodes = doc.createElement("nodes")
	configuration.appendChild(nodes)
	resources = doc.createElement("resources")
	configuration.appendChild(resources)
	constraints = doc.createElement("constraints")
	configuration.appendChild(constraints)
	return doc,cib,crm_config,rsc_defaults,op_defaults,nodes,resources,constraints
	def mk_topnode(doc, tag):
	"Get configuration element or create/append if there's none."
	try:
	e = doc.getElementsByTagName(tag)[0]
	except:
	e = doc.createElement(tag)
	conf = doc.getElementsByTagName("configuration")[0]
	if conf:
	conf.appendChild(e)
	else:
	return None
	return e
	def new_cib_element(node,tagname,id_pfx):
	base_id = node.getAttribute("id")
	newnode = node.ownerDocument.createElement(tagname)
	newnode.setAttribute("id", "%s-%s" % (base_id,id_pfx))
	node.appendChild(newnode)
	return newnode
	def get_attr_in_set(node,attr):
	for c in node.childNodes:
	if not is_element(c):
	continue
	if c.tagName == "nvpair" and c.getAttribute("name") == attr:
	return c
	return None
	def set_attr(node,attr,value):
	'''
	Set an attribute in the attribute set.
	'''
	nvpair = get_attr_in_set(node,attr)
	if not nvpair:
	nvpair = new_cib_element(node,"nvpair",attr)
	nvpair.setAttribute("name",attr)
	nvpair.setAttribute("value",value)
	def get_set_nodes(node,setname,create = 0):
	'Return the attributes set nodes (create one if requested)'
	l = []
	for c in node.childNodes:
	if not is_element(c):
	continue
	if c.tagName == setname:
	l.append(c)
	if l:
	return l
	if create:
	l.append(new_cib_element(node,setname,setname))
	return l

	def xml_cmp(n, m, show = False):
	rc = hash(n.toxml()) == hash(m.toxml())
	if not rc and show and user_prefs.get_debug():
	print "original:",n.toprettyxml()
	print "processed:",m.toprettyxml()
	return hash(n.toxml()) == hash(m.toxml())

	def merge_nvpairs(dnode,snode):
	rc = False
	add_children = []
	for c in snode.childNodes:
	if c.tagName == "nvpair":
	dc = lookup_node(c,dnode)
	if dc:
	dc.setAttribute("value",c.getAttribute("value"))
	else:
	add_children.append(c)
	rc = True
	for c in add_children:
	dnode.appendChild(c)
	return rc

	def merge_nodes(dnode,snode):
	'''
	Import elements from snode into dnode.
	If an element is attributes set (vars.nvpairs_tags), then
	merge nvpairs by the name attribute.
	Otherwise, replace the whole element. (TBD)
	'''
	#print "1:",dnode.toprettyxml()
	#print "2:",snode.toprettyxml()
	#vars.nvpairs_tags
	rc = False # any changes done?
	if not dnode or not snode:
	return rc
	for c in snode.childNodes:
	dc = lookup_node(c,dnode)
	if not dc:
	continue
	if dc.tagName in vars.nvpairs_tags:
	rc = rc or merge_nvpairs(dc,c)
	return rc

	user_prefs = UserPrefs.getInstance()
	vars = Vars.getInstance()
	# vim:ts=4:sw=4:et:

File Metadata

Mime Type: text/x-diff
Expires: Mon, Sep 22, 11:44 PM (4 h, 33 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2403466
Default Alt Text: (136 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions