diff --git a/shell/modules/cibconfig.py b/shell/modules/cibconfig.py
index 71e21fe738..f255199f79 100644
--- a/shell/modules/cibconfig.py
+++ b/shell/modules/cibconfig.py
@@ -1,2775 +1,2785 @@
# 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 utils import *
from xmlutil import *
from msg import *
from parse import CliParser
from clidisplay import CliDisplay
from cibstatus import CibStatus
def id_in_use(obj_id):
if id_store.is_used(obj_id):
id_used_err(obj_id)
return True
return False
class IdMgmt(Singleton):
'''
Make sure that ids are unique.
'''
def __init__(self):
self._id_store = {}
self.ok = True # error var
def new(self,node,pfx):
'''
Create a unique id for the xml node.
'''
name = node.getAttribute("name")
if node.tagName == "nvpair":
node_id = "%s-%s" % (pfx,name)
elif node.tagName == "op":
interval = node.getAttribute("interval")
if interval:
node_id = "%s-%s-%s" % (pfx,name,interval)
else:
node_id = "%s-%s" % (pfx,name)
else:
try:
hint = hints_list[node.tagName]
except: hint = ''
if hint:
node_id = "%s-%s" % (pfx,hint)
else:
node_id = "%s" % pfx
if self.is_used(node_id):
for cnt in range(99): # shouldn't really get here
try_id = "%s-%d" % (node_id,cnt)
if not self.is_used(try_id):
node_id = try_id
break
self.save(node_id)
return node_id
def check_node(self,node,lvl):
node_id = node.getAttribute("id")
if not node_id:
return
if id_in_use(node_id):
self.ok = False
return
def _store_node(self,node,lvl):
self.save(node.getAttribute("id"))
def _drop_node(self,node,lvl):
self.remove(node.getAttribute("id"))
def check_xml(self,node):
self.ok = True
xmltraverse_thin(node,self.check_node)
return self.ok
def store_xml(self,node):
if not self.check_xml(node):
return False
xmltraverse_thin(node,self._store_node)
return True
def remove_xml(self,node):
xmltraverse_thin(node,self._drop_node)
def replace_xml(self,oldnode,newnode):
self.remove_xml(oldnode)
if not self.store_xml(newnode):
self.store_xml(oldnode)
return False
return True
def is_used(self,node_id):
return node_id in self._id_store
def save(self,node_id):
if not node_id: return
self._id_store[node_id] = 1
def rename(self,old_id,new_id):
if not old_id or not new_id: return
if not self.is_used(old_id): return
if self.is_used(new_id): return
self.remove(old_id)
self.save(new_id)
def remove(self,node_id):
if not node_id: return
try:
del self._id_store[node_id]
except KeyError:
pass
def clear(self):
self._id_store = {}
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]
l.sort(cmp = cmp)
else:
l = [obj for obj in cl if obj.obj_type == obj_type]
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 vars.resource_cli_names
def is_constraint_cli(s):
return s in vars.constraint_cli_names
def referenced_resources_cli(cli_list):
id_list = []
head = cli_list[0]
obj_type = head[0]
if not is_constraint_cli(obj_type):
return []
if obj_type == "location":
id_list.append(find_value(head[1],"rsc"))
elif len(cli_list) > 1: # resource sets
for l in cli_list[1][1]:
if l[0] == "resource_ref":
id_list.append(l[1][1])
elif obj_type == "colocation":
id_list.append(find_value(head[1],"rsc"))
id_list.append(find_value(head[1],"with-rsc"))
elif obj_type == "order":
id_list.append(find_value(head[1],"first"))
id_list.append(find_value(head[1],"then"))
return id_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 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)
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 []
def lines2cli(s):
'''
Convert a string into a list of lines. Replace continuation
characters. Strip white space, left and right. Drop empty lines.
'''
cl = []
l = s.split('\n')
cum = []
for p in l:
p = p.strip()
if p.endswith('\\'):
p = p.rstrip('\\')
cum.append(p)
else:
cum.append(p)
cl.append(''.join(cum).strip())
cum = []
if cum: # in case s ends with backslash
cl.append(''.join(cum))
return [x for x in cl if x]
#
# 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)
def repr(self):
'''
Return a string with objects's representations (either
CLI or XML).
'''
return ''
def save(self,s):
'''
For each object:
- try to find a corresponding object in obj_list
- if not found: create new
- if found: replace the object in the obj_list with
the new object
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)
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):
'''
Create new objects or update existing ones.
'''
comments = get_comments(cli_list)
obj = self.lookup_cli(cli_list)
if obj:
rc = obj.update_from_cli(cli_list) != False
self.remove_objs.remove(obj)
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):
'''
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) == 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):
if not cib_factory.is_cib_sane():
return False
obj = self.lookup(node.tagName,node.getAttribute("id"))
if obj:
rc = obj.update_from_node(node) != False
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):
try:
doc = xml.dom.minidom.parseString(s)
except xml.parsers.expat.ExpatError,msg:
cib_parse_err(msg)
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):
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
#
hints_list = {
"instance_attributes": "instance_attributes",
"meta_attributes": "meta_attributes",
+ "utilization": "utilization",
"operations": "ops",
"rule": "rule",
"expression": "expression",
}
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 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 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:
hint = hints_list[e[0]]
except: hint = ''
hint = hint and "%s_%s" % (id_hint,hint) or id_hint
nvpair_pfx = node.getAttribute("id") or hint
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 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 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",
+ "utilization": "utilization",
"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"):
+ if e[0] in ("instance_attributes","meta_attributes","operations","cluster_property_set","utilization"):
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 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 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)
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())
#
# CLI format generation utilities (from XML)
#
def cli_format(pl,format):
if format > 0:
return ' \\\n\t'.join(pl)
else:
return ' '.join(pl)
def nvpair_format(n,v):
return v == None and cli_display.attr_name(n) \
or '%s="%s"'%(cli_display.attr_name(n),cli_display.attr_value(v))
def cli_pairs(pl):
'Return a string of name="value" pairs (passed in a list of pairs).'
l = []
for n,v in pl:
l.append(nvpair_format(n,v))
return ' '.join(l)
def op2list(node):
pl = []
action = ""
for name in node.attributes.keys():
if name == "name":
action = node.getAttribute(name)
elif name != "id": # skip the id
pl.append([name,node.getAttribute(name)])
if not action:
common_err("op is invalid (no name)")
return action,pl
def op_instattr(node):
pl = []
for c in node.childNodes:
if not is_element(c):
continue
if c.tagName != "instance_attributes":
common_err("only instance_attributes are supported in operations")
else:
pl += nvpairs2list(c)
return pl
def cli_op(node):
action,pl = op2list(node)
if not action:
return ""
pl += op_instattr(node)
return "%s %s %s" % (cli_display.keyword("op"),action,cli_pairs(pl))
def cli_operations(node,format = 1):
l = []
node_id = node.getAttribute("id")
s = ''
if node_id:
s = '$id="%s"' % node_id
idref = node.getAttribute("id-ref")
if idref:
s = '%s $id-ref="%s"' % (s,idref)
if s:
l.append("%s %s" % (cli_display.keyword("operations"),s))
for c in node.childNodes:
if is_element(c) and c.tagName == "op":
l.append(cli_op(c))
return cli_format(l,format)
def date_exp2cli(node):
l = []
operation = node.getAttribute("operation")
l.append(cli_display.keyword("date"))
l.append(cli_display.keyword(operation))
if operation in vars.simple_date_ops:
value = node.getAttribute(operation == 'lt' and "end" or "start")
l.append('"%s"' % cli_display.attr_value(value))
else:
if operation == 'in_range':
for name in vars.in_range_attrs:
v = node.getAttribute(name)
if v:
l.append(nvpair_format(name,v))
for c in node.childNodes:
if is_element(c) and c.tagName in ("duration","date_spec"):
pl = []
for name in c.attributes.keys():
if name != "id":
pl.append([name,c.getAttribute(name)])
l.append(cli_pairs(pl))
return ' '.join(l)
def binary_op_format(op):
l = op.split(':')
if len(l) == 2:
return "%s:%s" % (l[0], cli_display.keyword(l[1]))
else:
return cli_display.keyword(op)
def exp2cli(node):
operation = node.getAttribute("operation")
type = node.getAttribute("type")
if type:
operation = "%s:%s" % (type, operation)
attribute = node.getAttribute("attribute")
value = node.getAttribute("value")
if not value:
return "%s %s" % (binary_op_format(operation),attribute)
else:
return "%s %s %s" % (attribute,binary_op_format(operation),value)
def get_score(node):
score = node.getAttribute("score")
if not score:
score = node.getAttribute("score-attribute")
else:
if score.find("INFINITY") >= 0:
score = score.replace("INFINITY","inf")
return score + ":"
def cli_rule(node):
s = []
node_id = node.getAttribute("id")
if node_id:
s.append('$id="%s"' % node_id)
else:
idref = node.getAttribute("id-ref")
if idref:
return '$id-ref="%s"' % idref
rsc_role = node.getAttribute("role")
if rsc_role:
s.append('$role="%s"' % rsc_role)
s.append(cli_display.score(get_score(node)))
bool_op = node.getAttribute("boolean-op")
if not bool_op:
bool_op = "and"
exp = []
for c in node.childNodes:
if not is_element(c):
continue
if c.tagName == "date_expression":
exp.append(date_exp2cli(c))
elif c.tagName == "expression":
exp.append(exp2cli(c))
expression = (" %s "%cli_display.keyword(bool_op)).join(exp)
return "%s %s" % (' '.join(s),expression)
def node_head(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_add_description(node,l):
desc = node.getAttribute("description")
if desc:
l.append(nvpair_format("description",desc))
def primitive_head(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 cont_head(node):
obj_type = vars.cib_cli_map[node.tagName]
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 location_head(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 mkrscrole(node,n):
rsc = cli_display.rscref(node.getAttribute(n))
rsc_role = node.getAttribute(n + "-role")
if rsc_role:
return "%s:%s"%(rsc,rsc_role)
else:
return rsc
def mkrscaction(node,n):
rsc = cli_display.rscref(node.getAttribute(n))
rsc_action = node.getAttribute(n + "-action")
if rsc_action:
return "%s:%s"%(rsc,rsc_action)
else:
return rsc
def rsc_set_constraint(node,obj_type):
col = []
cnt = 0
for n in node.getElementsByTagName("resource_set"):
sequential = True
if n.getAttribute("sequential") == "false":
sequential = False
if not sequential:
col.append("(")
role = n.getAttribute("role")
action = n.getAttribute("action")
for r in n.getElementsByTagName("resource_ref"):
rsc = cli_display.rscref(r.getAttribute("id"))
q = (obj_type == "colocation") and role or action
col.append(q and "%s:%s"%(rsc,q) or rsc)
cnt += 1
if not sequential:
col.append(")")
if cnt <= 2: # a degenerate thingie
col.insert(0,"_rsc_set_")
return col
def two_rsc_constraint(node,obj_type):
col = []
if obj_type == "colocation":
col.append(mkrscrole(node,"rsc"))
col.append(mkrscrole(node,"with-rsc"))
else:
col.append(mkrscaction(node,"first"))
col.append(mkrscaction(node,"then"))
return col
def simple_constraint_head(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)
symm = node.getAttribute("symmetrical")
if symm:
col.append("symmetrical=%s"%symm)
return "%s %s %s %s" % (s,id,score,' '.join(col))
#
################################################################
#
# 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"
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.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(self,node = None,format = 1):
'''
CLI representation for the node. Defined in subclasses.
'''
return ''
def cli2node(self,cli,oldnode = None):
'''
Convert CLI representation to a DOM node.
Defined in subclasses.
'''
return None
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 save_xml(self,node):
self.obj_id = node.getAttribute("id")
self.node = node
def mknode(self,obj_id):
if not cib_factory.is_cib_sane():
return False
if 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.
'''
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 update_links(self):
'''
Update the structure links for the object (self.children,
self.parent). Update also the dom nodes, if necessary.
'''
self.children = []
if self.obj_type not in vars.container_tags:
return
for c in self.node.childNodes:
if is_child_rsc(c):
child = cib_factory.find_object_for_node(c)
if not child:
missing_obj_err(c)
continue
child.parent = self
self.children.append(child)
if not c.isSameNode(child.node):
rmnode(child.node)
child.node = c
def update_from_cli(self,cli_list):
'Update ourselves from the cli intermediate.'
if not cib_factory.is_cib_sane():
return False
if not cib_factory.verify_cli(cli_list):
return False
oldnode = self.node
id_store.remove_xml(oldnode)
newnode = self.cli2node(cli_list)
if not newnode:
id_store.store_xml(oldnode)
return False
if xml_cmp(oldnode,newnode):
newnode.unlink()
return True # the new and the old versions are equal
self.node = newnode
if user_prefs.is_check_always() \
and self.check_sanity() > 1:
id_store.remove_xml(newnode)
id_store.store_xml(oldnode)
self.node = oldnode
newnode.unlink()
return False
oldnode.parentNode.replaceChild(newnode,oldnode)
cib_factory.adjust_children(self,cli_list)
oldnode.unlink()
self.updated = True
self.propagate_updated()
return True
def update_from_node(self,node):
'Update ourselves from a doc node.'
if not node:
return False
if not cib_factory.is_cib_sane():
return False
oldxml = self.node
newxml = node
if xml_cmp(oldxml,newxml):
return True # the new and the old versions are equal
if not id_store.replace_xml(oldxml,newxml):
return False
oldxml.unlink()
self.node = cib_factory.doc.importNode(newxml,1)
cib_factory.topnode[self.parent_type].appendChild(self.node)
self.update_links()
self.updated = True
self.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.
'''
def repr_cli(self,node = None,format = 1):
'''
We assume that uname is unique.
'''
if not node:
node = self.node
l = []
l.append(node_head(node))
cli_add_description(node,l)
for c in node.childNodes:
if not is_element(c):
continue
if c.tagName == "instance_attributes":
l.append("%s %s" % \
(cli_display.keyword("attributes"), \
cli_pairs(nvpairs2list(c))))
+ elif c.tagName == "utilization":
+ l.append("%s %s" % \
+ (cli_display.keyword("utilization"), \
+ cli_pairs(nvpairs2list(c))))
return self.cli_format(l,format)
def cli2node(self,cli,oldnode = None):
cli_list = mk_cli_list(cli)
if not cli_list:
return None
if not oldnode:
oldnode = self.node
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.
'''
def repr_cli(self,node = None,format = 1):
if not node:
node = self.node
l = []
l.append(primitive_head(node))
cli_add_description(node,l)
for c in node.childNodes:
if not is_element(c):
continue
if c.tagName == "instance_attributes":
l.append("%s %s" % \
(cli_display.keyword("params"), \
cli_pairs(nvpairs2list(c))))
elif c.tagName == "meta_attributes":
l.append("%s %s" % \
(cli_display.keyword("meta"), \
cli_pairs(nvpairs2list(c))))
+ elif c.tagName == "utilization":
+ l.append("%s %s" % \
+ (cli_display.keyword("utilization"), \
+ cli_pairs(nvpairs2list(c))))
elif c.tagName == "operations":
l.append(cli_operations(c,format))
return self.cli_format(l,format)
def cli2node(self,cli,oldnode = None):
'''
Convert a CLI description to DOM node.
Try to preserve as many ids as possible in case there's
an old XML version.
'''
cli_list = mk_cli_list(cli)
if not cli_list:
return None
if not oldnode:
oldnode = self.node
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 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()
from ra import RAInfo
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
rc2 = ra.sanity_check_ops(self.obj_id, actions)
return rc1 | rc2
class CibContainer(CibObject):
'''
Groups and clones and ms.
'''
def repr_cli(self,node = None,format = 1):
if not node:
node = self.node
l = []
l.append(cont_head(node))
cli_add_description(node,l)
for c in node.childNodes:
if not is_element(c):
continue
if c.tagName == "instance_attributes":
l.append("%s %s" % \
(cli_display.keyword("params"), \
cli_pairs(nvpairs2list(c))))
elif c.tagName == "meta_attributes":
l.append("%s %s" % \
(cli_display.keyword("meta"), \
cli_pairs(nvpairs2list(c))))
return self.cli_format(l,format)
def cli2node(self,cli,oldnode = None):
cli_list = mk_cli_list(cli)
if not cli_list:
return None
if not oldnode:
oldnode = self.node
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
class CibLocation(CibObject):
'''
Location constraint.
'''
def repr_cli(self,node = None,format = 1):
if not node:
node = self.node
l = []
l.append(location_head(node))
for c in node.childNodes:
if not is_element(c):
continue
if c.tagName == "rule":
l.append("%s %s" % \
(cli_display.keyword("rule"), cli_rule(c)))
return self.cli_format(l,format)
def cli2node(self,cli,oldnode = None):
cli_list = mk_cli_list(cli)
if not cli_list:
return None
if not oldnode:
oldnode = self.node
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(self,node = None,format = 1):
if not node:
node = self.node
l = []
l.append(simple_constraint_head(node))
return self.cli_format(l,format)
def cli2node(self,cli,oldnode = None):
cli_list = mk_cli_list(cli)
if not cli_list:
return None
if not oldnode:
oldnode = self.node
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(self,node = None,format = 1):
if not node:
node = self.node
l = []
l.append(cli_display.keyword(self.obj_type))
properties = nvpairs2list(node, add_id = True)
for n,v in properties:
if n == "$id":
l[0] = '%s %s="%s"' % (l[0],n,v)
else:
l.append(nvpair_format(n,v))
return self.cli_format(l,format)
def cli2node(self,cli,oldnode = None):
cli_list = mk_cli_list(cli)
if not cli_list:
return None
if not oldnode:
oldnode = cib_factory.topnode[cib_object_map[self.xml_obj_type][2]]
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")
#
################################################################
#
# 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)
def get_cib_default(property):
if cib_factory.is_cib_sane():
return cib_factory.get_property(property)
# 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.
'''
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 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)
self.missing_topnodes.append(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 add_missing_topnodes(self):
cib_create_topnode = "cibadmin -C -o configuration -X"
for tag in self.missing_topnodes:
if not self.topnode[tag].hasChildNodes():
continue
if ext_cmd("%s '<%s/>'" % (cib_create_topnode, tag)) != 0:
common_err("could not create %s in the cib" % tag)
return False
return True
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, obj_filter):
upd_list = self.cib_objs4cibadmin(obj_filter)
if title == "delete":
upd_list += self.remove_queue
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.'
# 1. remove objects (incl. modified constraints)
self.showqueue("delete", lambda o:
o.origin == "cib" and (o.updated or o.recreate) and is_constraint(o.node))
# 2. update existing objects
self.showqueue("replace", lambda o: \
o.origin != 'user' and o.updated and not is_constraint(o.node))
# 3. create new objects
self.showqueue("create", lambda o: \
o.origin == 'user' and not is_constraint(o.node))
# 4. create objects moved from a container
self.showqueue("create", lambda o: \
not o.parent and o.moved and o.origin == "cib")
# 5. create constraints
self.showqueue("create", lambda o: is_constraint(o.node) and \
(((o.updated or o.recreate) and o.origin == "cib") or o.origin == "user"))
def commit(self):
'Commit the configuration to the CIB.'
if not self.doc:
empty_cib_err()
return False
if not self.add_missing_topnodes():
return False
# all_committed is updated in the invoked object methods
self.all_committed = True
cnt = 0
# 1. remove objects (incl. modified constraints)
cnt += self.delete_objects(lambda o:
o.origin == "cib" and (o.updated or o.recreate) and is_constraint(o.node))
# 2. update existing objects
cnt += self.replace_objects(lambda o: \
o.origin != 'user' and o.updated and not is_constraint(o.node))
# 3. create new objects
cnt += self.create_objects(lambda o: \
o.origin == 'user' and not is_constraint(o.node))
# 4. create objects moved from a container
cnt += self.create_objects(lambda o: \
not o.parent and o.moved and o.origin == "cib")
# 5. create constraints
cnt += self.create_objects(lambda o: is_constraint(o.node) and \
(((o.updated or o.recreate) and o.origin == "cib") or o.origin == "user"))
if cnt:
# reload the cib!
self.reset()
self.initialize()
return self.all_committed
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 delete_objects(self,obj_filter):
cnt = 0
upd_list = self.cib_objs4cibadmin(obj_filter)
if not (self.remove_queue + upd_list):
return 0
obj_list = processing_sort_cli(self.remove_queue + 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,obj_filter):
upd_list = self.cib_objs4cibadmin(obj_filter)
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,obj_filter):
cnt = 0
upd_list = self.cib_objs4cibadmin(obj_filter)
if not upd_list:
return 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"
self.cib_objects.append(obj)
obj.save_xml(node)
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
for obj in self.cib_objects:
obj.update_links()
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.missing_topnodes = []
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 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 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_property(self,property):
'''
Get the value of the given cluster property.
'''
for obj in self.cib_objects:
if obj.obj_type == "property" and obj.node:
pl = nvpairs2list(obj.node)
v = find_value(pl, property)
if v:
return v
return None
def new_object(self,obj_type,obj_id):
"Create a new object of type obj_type."
if 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:
obj_cli_err(obj.obj_id)
continue
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,cli_list):
'''
Check if all resources referenced in a constraint exist
'''
rc = True
head = cli_list[0]
constraint_id = find_value(head[1],"id")
for obj_id in referenced_resources_cli(cli_list):
if not self.find_object(obj_id):
constraint_norefobj_err(constraint_id,obj_id)
rc = False
return rc
def verify_children(self,cli_list):
'''
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
'''
head = cli_list[0]
obj_type = head[0]
obj_id = find_value(head[1],"id")
c_ids = find_value(head[1],"$children")
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_cli(self,cli_list):
'''
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_children(cli_list):
rc = False
if not self.verify_constraints(cli_list):
rc = False
return rc
def create_object(self,*args):
s = []
s += args
return self.create_from_cli(CliParser().parse(s)) != 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 = cib_factory.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
# check if there is already an op with the same interval
name = find_value(head[1], "name")
interval = find_value(head[1], "interval")
if find_operation(rsc_obj.node,name,interval):
common_err("%s already has a %s op with interval %s" % \
(rsc_id, name, interval))
return None
# drop the rsc attribute
head[1].remove(["rsc",rsc_id])
# create an xml node
mon_node = mkxmlsimple(head, None, rsc_id)
# get the place to append it to
try:
op_node = rsc_obj.node.getElementsByTagName("operations")[0]
except:
op_node = self.createElement("operations")
rsc_obj.node.appendChild(op_node)
op_node.appendChild(mon_node)
# the resource is updated
rsc_obj.updated = True
rsc_obj.propagate_updated()
return rsc_obj
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
if not self.verify_cli(cli_list):
return None
head = cli_list[0]
obj_type = head[0].lower()
if obj_type in vars.nvset_cli_names:
return self.set_property_cli(cli_list)
if obj_type == "op":
return self.add_op(cli_list)
obj_id = find_value(head[1],"id")
if not is_id_valid(obj_id):
invalid_id_err(obj_id)
return None
obj = self.new_object(obj_type,obj_id)
if not obj:
return None
obj.node = obj.cli2node(cli_list)
if user_prefs.is_check_always() \
and obj.check_sanity() > 1:
id_store.remove_xml(obj.node)
obj.node.unlink()
return None
self.topnode[obj.parent_type].appendChild(obj.node)
self.adjust_children(obj,cli_list)
obj.origin = "user"
for child in obj.children:
# redirect constraints to the new parent
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
self.cib_objects.append(obj)
return obj
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,cli_list):
'''
All stuff children related: manage the nodes of children,
update the list of children for the parent, update
parents in the children.
'''
head = cli_list[0]
children_ids = find_value(head[1],"$children")
if not children_ids:
return
new_children = []
for child_id in children_ids:
new_children.append(self.find_object(child_id))
self._relink_orphans(obj,new_children)
obj.children = new_children
self._update_children(obj)
def _relink_child(self,obj):
'Relink a child to the top node.'
obj.node.parentNode.removeChild(obj.node)
self.topnode[obj.parent_type].appendChild(obj.node)
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:
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(self,obj,new_children):
"New orphans move to the top level for the object type."
for child in obj.children:
if child not in new_children:
self._relink_child(child)
def add_obj(self,obj_type,node):
obj = self.new_object(obj_type, node.getAttribute("id"))
if not obj:
return None
obj.save_xml(node)
if not obj.cli_use_validate():
obj.nocli = True
obj.update_links()
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
obj_type = cib_object_map[node.tagName][0]
node = self.doc.importNode(node,1)
obj = None
if is_defaults(node):
for c in node.childNodes:
if not is_element(c) or c.tagName != "meta_attributes":
continue
obj = self.add_obj(obj_type,c)
else:
obj = self.add_obj(obj_type,node)
if obj:
self.topnode[obj.parent_type].appendChild(node)
return obj
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(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 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_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/parse.py b/shell/modules/parse.py
index 3461c2250c..2dfbd924e0 100644
--- a/shell/modules/parse.py
+++ b/shell/modules/parse.py
@@ -1,621 +1,620 @@
# 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 shlex
import re
from utils import *
from vars import Vars
from msg import *
from ra import disambiguate_ra_type, ra_type_validate
#
# CLI parsing utilities
# WARNING: ugly code ahead (to be replaced some day by a proper
# yacc parser, if there's such a thing)
#
def cli_parse_rsctype(s, pl):
'''
Parse the resource type.
'''
ra_class,provider,rsc_type = disambiguate_ra_type(s)
if not ra_type_validate(s,ra_class,provider,rsc_type):
return None
pl.append(["class",ra_class])
if ra_class == "ocf":
pl.append(["provider",provider])
pl.append(["type",rsc_type])
def is_attribute(p,a):
return p.startswith(a + '=')
def cli_parse_attr_strict(s,pl):
'''
Parse attributes in the 'p=v' form.
'''
if s and '=' in s[0]:
n,v = s[0].split('=',1)
if not n:
return
pl.append([n,v])
cli_parse_attr_strict(s[1:],pl)
def cli_parse_attr(s,pl):
'''
Parse attributes in the 'p=v' form.
Allow also the 'p' form (no value) unless p is one of the
attr_list_keyw words.
'''
- attr_lists_keyw = olist(["params","meta","operations","op","attributes"])
+ attr_lists_keyw = olist(["params","meta","utilization","operations","op","attributes"])
if s:
if s[0] in attr_lists_keyw:
return
if '=' in s[0]:
n,v = s[0].split('=',1)
else:
n = s[0]; v = None
if not n:
return
pl.append([n,v])
cli_parse_attr(s[1:],pl)
def is_only_id(pl,keyw):
if len(pl) > 1:
common_err("%s: only single $id or $id-ref attribute is allowed" % keyw)
return False
if len(pl) == 1 and pl[0][0] not in ("$id","$id-ref"):
common_err("%s: only single $id or $id-ref attribute is allowed" % keyw)
return False
return True
def check_operation(pl):
op_name = find_value(pl,"name")
if not op_name in vars.op_cli_names:
common_warn("%s: operation not recognized" % op_name)
if op_name == "monitor" and not find_value(pl,"interval"):
common_err("monitor requires interval")
return False
return True
def parse_resource(s):
el_type = s[0].lower()
if el_type == "master": # ugly kludge :(
el_type = "ms"
- attr_lists_keyw = olist(["params","meta"])
+ attr_lists_keyw = olist(["params","meta","utilization"])
cli_list = []
# the head
head = []
head.append(["id",s[1]])
i = 3
if el_type == "primitive":
cli_parse_rsctype(s[2],head)
if not find_value(head,"type"):
syntax_err(s[2:], context = "primitive")
return False
else:
cl = []
cl.append(s[2])
if el_type == "group":
while i < len(s):
if s[i] in attr_lists_keyw:
break
elif is_attribute(s[i],"description"):
break
else:
cl.append(s[i])
i += 1 # skip to the next token
head.append(["$children",cl])
try: # s[i] may be out of range
if is_attribute(s[i],"description"):
cli_parse_attr(s[i:i+1],head)
i += 1 # skip to the next token
except: pass
cli_list.append([el_type,head])
# the rest
state = 0 # 1: reading operations; 2: operations read
while len(s) > i+1:
pl = []
keyw = s[i].lower()
if keyw in attr_lists_keyw:
if state == 1:
state = 2
elif el_type == "primitive" and state == 0 and keyword_cmp(keyw, "operations"):
state = 1
elif el_type == "primitive" and state <= 1 and keyword_cmp(keyw, "op"):
if state == 0:
state = 1
pl.append(["name",s[i+1]])
else:
syntax_err(s[i:], context = 'primitive')
return False
if keyword_cmp(keyw, "op"):
if len(s) > i+2:
cli_parse_attr(s[i+2:],pl)
if not check_operation(pl):
return False
else:
cli_parse_attr(s[i+1:],pl)
if len(pl) == 0:
syntax_err(s[i:], context = 'primitive')
return False
if keyword_cmp(keyw, "operations") and not is_only_id(pl,keyw):
return False
i += len(pl)+1
# interval is obligatory for ops, supply 0 if not there
if keyword_cmp(keyw, "op") and not find_value(pl,"interval"):
pl.append(["interval","0"])
cli_list.append([keyw,pl])
if len(s) > i:
syntax_err(s[i:], context = 'primitive')
return False
return cli_list
def parse_op(s):
if len(s) != 3:
syntax_err(s, context = s[0])
return False
cli_list = []
head_pl = []
# this is an op
cli_list.append(["op",head_pl])
if not cli_parse_rsc_role(s[1],head_pl):
return False
if not cli_parse_op_times(s[2],head_pl):
return False
# rename rsc-role to role
for i in range(len(head_pl)):
if head_pl[i][0] == "rsc-role":
head_pl[i][0] = "role"
break
# add the operation name
head_pl.append(["name",s[0]])
return cli_list
def cli_parse_score(score,pl,noattr = False):
if score.endswith(':'):
score = score.rstrip(':')
else:
syntax_err(score, context = 'score')
return False
if score in vars.score_types:
pl.append(["score",vars.score_types[score]])
elif re.match("^[+-]?(inf|infinity|INFINITY|[[0-9]+)$",score):
score = score.replace("infinity","INFINITY")
score = score.replace("inf","INFINITY")
pl.append(["score",score])
elif score:
if noattr:
common_err("attribute not allowed for score in orders")
return False
else:
pl.append(["score-attribute",score])
return True
def is_binary_op(s):
l = s.split(':')
if len(l) == 2:
return l[0] in vars.binary_types and l[1] in vars.binary_ops
elif len(l) == 1:
return l[0] in vars.binary_ops
else:
return False
def cli_parse_binary_op(s,pl):
l = s.split(':')
if len(l) == 2:
pl.append(["type",l[0]])
pl.append(["operation",l[1]])
else:
pl.append(["operation",l[0]])
def cli_parse_expression(s,pl):
if len(s) > 1 and s[0] in vars.unary_ops:
pl.append(["operation",s[0]])
pl.append(["attribute",s[1]])
elif len(s) > 2 and is_binary_op(s[1]):
pl.append(["attribute",s[0]])
cli_parse_binary_op(s[1],pl)
pl.append(["value",s[2]])
else:
return False
return True
def cli_parse_dateexpr(s,pl):
if len(s) < 3:
return False
if s[1] not in vars.date_ops:
return False
pl.append(["operation",s[1]])
if s[1] in vars.simple_date_ops:
pl.append([keyword_cmp(s[1], 'lt') and "end" or "start",s[2]])
return True
cli_parse_attr_strict(s[2:],pl)
return True
def parse_rule(s):
if not keyword_cmp(s[0], "rule"):
syntax_err(s,context = "rule")
return 0,None
rule_list = []
head_pl = []
rule_list.append([s[0].lower(),head_pl])
i = 1
cli_parse_attr_strict(s[i:],head_pl)
i += len(head_pl)
if find_value(head_pl,"$id-ref"):
return i,rule_list
if not cli_parse_score(s[i],head_pl):
return i,None
i += 1
bool_op = ''
while len(s) > i+1:
pl = []
if keyword_cmp(s[i], "date"):
fun = cli_parse_dateexpr
elem = "date_expression"
else:
fun = cli_parse_expression
elem = "expression"
if not fun(s[i:],pl):
syntax_err(s[i:],context = "rule")
return i,None
rule_list.append([elem,pl])
i += len(pl)
if find_value(pl, "type"):
i -= 1 # reduce no of tokens by one if there was "type:op"
if elem == "date_expression":
i += 1 # increase no of tokens by one if it was date expression
if len(s) > i and s[i] in vars.boolean_ops:
if bool_op and not keyword_cmp(bool_op, s[i]):
common_err("rule contains different bool operations: %s" % ' '.join(s))
return i,None
else:
bool_op = s[i].lower()
i += 1
if len(s) > i and keyword_cmp(s[i], "rule"):
break
if bool_op and not keyword_cmp(bool_op, 'and'):
head_pl.append(["boolean-op",bool_op])
return i,rule_list
def parse_location(s):
cli_list = []
head_pl = []
head_pl.append(["id",s[1]])
head_pl.append(["rsc",s[2]])
cli_list.append([s[0].lower(),head_pl])
if len(s) == 5 and not keyword_cmp(s[3], "rule"): # the short node preference form
if not cli_parse_score(s[3],head_pl):
return False
head_pl.append(["node",s[4]])
return cli_list
i = 3
while i < len(s):
numtoks,l = parse_rule(s[i:])
if not l:
return False
cli_list += l
i += numtoks
if len(s) < i:
syntax_err(s[i:],context = "location")
return False
return cli_list
def cli_opt_symmetrical(p,pl):
if not p:
return True
pl1 = []
cli_parse_attr([p],pl1)
if len(pl1) != 1 or not find_value(pl1,"symmetrical"):
syntax_err(p,context = "order")
return False
pl += pl1
return True
def cli_parse_rsc_role(s,pl,attr_pfx = ''):
l = s.split(':')
pl.append([attr_pfx+"rsc",l[0]])
if len(l) == 2:
if l[1] not in vars.roles_names:
bad_def_err("resource role",s)
return False
pl.append([attr_pfx+"rsc-role",l[1]])
elif len(l) > 2:
bad_def_err("resource role",s)
return False
return True
def cli_parse_op_times(s,pl):
l = s.split(':')
pl.append(["interval",l[0]])
if len(l) == 2:
pl.append(["timeout",l[1]])
elif len(l) > 2:
bad_def_err("op times",s)
return False
return True
class ResourceSet(object):
'''
Constraint resource set parser. Parses sth like:
a ( b c:start ) d:Master e ...
Appends one or more lists to cli_list.
Lists are in form:
list :: ["resource_set",set_pl]
set_pl :: [["sequential","false"], ["action"|"role",action|role],
["resource_ref",["id",rsc]], ...]
(the first two elements of set_pl are optional)
Action/role change makes a new resource set.
'''
def __init__(self,type,s,cli_list):
self.type = type
self.valid_q = (type == "order") and vars.actions_names or vars.roles_names
self.q_attr = (type == "order") and "action" or "role"
self.tokens = s
self.cli_list = cli_list
self.reset_set()
self.sequential = True
self.fix_parentheses()
def fix_parentheses(self):
newtoks = []
for p in self.tokens:
if p.startswith('(') and len(p) > 1:
newtoks.append('(')
newtoks.append(p[1:])
elif p.endswith(')') and len(p) > 1:
newtoks.append(p[0:len(p)-1])
newtoks.append(')')
else:
newtoks.append(p)
self.tokens = newtoks
def reset_set(self):
self.set_pl = []
self.prev_q = '' # previous qualifier (action or role)
self.curr_attr = '' # attribute (action or role)
def save_set(self):
if not self.set_pl:
return
if self.curr_attr:
self.set_pl.insert(0,[self.curr_attr,self.prev_q])
if not self.sequential:
self.set_pl.insert(0,["sequential","false"])
self.cli_list.append(["resource_set",self.set_pl])
self.reset_set()
def splitrsc(self,p):
l = p.split(':')
return (len(l) == 1) and [p,''] or l
def parse(self):
tokpos = -1
for p in self.tokens:
tokpos += 1
if p == "_rsc_set_":
continue # a degenerate resource set
if p == '(':
if self.set_pl: # save the set before
self.save_set()
self.sequential = False
continue
if p == ')':
if self.sequential: # no '('
syntax_err(self.tokens[tokpos:],context = self.type)
return False
if not self.set_pl: # empty sets not allowed
syntax_err(self.tokens[tokpos:],context = self.type)
return False
self.save_set()
self.sequential = True
continue
rsc,q = self.splitrsc(p)
if q != self.prev_q: # one set can't have different roles/actions
self.save_set()
self.prev_q = q
if q:
if q not in self.valid_q:
common_err("%s: invalid %s in %s" % (q,self.q_attr,self.type))
return False
if not self.curr_attr:
self.curr_attr = self.q_attr
else:
self.curr_attr = ''
self.set_pl.append(["resource_ref",["id",rsc]])
if not self.sequential: # no ')'
syntax_err(self.tokens[tokpos:],context = self.type)
return False
if self.set_pl: # save the final set
self.save_set()
return True
def parse_colocation(s):
cli_list = []
head_pl = []
type = s[0]
if type == "collocation": # another ugly :(
type = "colocation"
cli_list.append([type,head_pl])
if len(s) < 5:
syntax_err(s,context = "colocation")
return False
head_pl.append(["id",s[1]])
if not cli_parse_score(s[2],head_pl):
return False
if len(s) == 5:
if not cli_parse_rsc_role(s[3],head_pl):
return False
if not cli_parse_rsc_role(s[4],head_pl,'with-'):
return False
else:
resource_set_obj = ResourceSet(type,s[3:],cli_list)
if not resource_set_obj.parse():
return False
return cli_list
def cli_parse_rsc_action(s,pl,rsc_pos):
l = s.split(':')
pl.append([rsc_pos,l[0]])
if len(l) == 2:
if l[1] not in vars.actions_names:
bad_def_err("resource action",s)
return False
pl.append([rsc_pos+"-action",l[1]])
elif len(l) > 1:
bad_def_err("resource action",s)
return False
return True
def parse_order(s):
cli_list = []
head_pl = []
type = "order"
cli_list.append([s[0],head_pl])
if len(s) < 5:
syntax_err(s,context = "order")
return False
head_pl.append(["id",s[1]])
if not cli_parse_score(s[2],head_pl,noattr = True):
return False
# save symmetrical for later (if it exists)
symm = ""
if is_attribute(s[len(s)-1],"symmetrical"):
symm = s.pop()
if len(s) == 5:
if not cli_parse_rsc_action(s[3],head_pl,'first'):
return False
if not cli_parse_rsc_action(s[4],head_pl,'then'):
return False
else:
resource_set_obj = ResourceSet(type,s[3:],cli_list)
if not resource_set_obj.parse():
return False
if not cli_opt_symmetrical(symm,head_pl):
return False
return cli_list
def parse_constraint(s):
if keyword_cmp(s[0], "location"):
return parse_location(s)
elif s[0] in olist(["colocation","collocation"]):
return parse_colocation(s)
elif keyword_cmp(s[0], "order"):
return parse_order(s)
def parse_property(s):
cli_list = []
head_pl = []
cli_list.append([s[0],head_pl])
cli_parse_attr(s[1:],head_pl)
if len(head_pl) < 0 or len(s) > len(head_pl)+1:
syntax_err(s, context = s[0])
return False
return cli_list
def cli_parse_uname(s, pl):
l = s.split(':')
if not l or len(l) > 2:
return None
pl.append(["uname",l[0]])
if len(l) == 2:
pl.append(["type",l[1]])
def parse_node(s):
cli_list = []
# the head
head = []
# optional $id
id = ''
opt_id_l = []
i = 1
cli_parse_attr_strict(s[i:],opt_id_l)
if opt_id_l:
id = find_value(opt_id_l,"$id")
i += 1
# uname[:type]
cli_parse_uname(s[i],head)
uname = find_value(head,"uname")
if not uname:
return False
head.append(["id",id and id or uname])
# drop type if default
type = find_value(head,"type")
if type == vars.node_default_type:
head.remove(["type",type])
cli_list.append([s[0],head])
if len(s) == i:
return cli_list
# the rest
i += 1
try: # s[i] may be out of range
if is_attribute(s[i],"description"):
cli_parse_attr(s[i:i+1],head)
i += 1 # skip to the next token
except: pass
- keyw = vars.node_attributes_keyw # some day there may be more than one
while len(s) > i+1:
- if not keyword_cmp(s[i], keyw):
+ if not s[i] in vars.node_attributes_keyw:
syntax_err(s[i:], context = 'node')
return False
pl = []
cli_parse_attr(s[i+1:],pl)
if len(pl) == 0:
syntax_err(s[i:], context = 'node')
return False
+ cli_list.append([s[i],pl])
i += len(pl)+1
- cli_list.append([keyw,pl])
if len(s) > i:
syntax_err(s[i:], context = 'node')
return False
return cli_list
class CliParser(object):
parsers = {
"primitive": (3,parse_resource),
"group": (3,parse_resource),
"clone": (3,parse_resource),
"ms": (3,parse_resource),
"master": (3,parse_resource),
"location": (3,parse_constraint),
"colocation": (3,parse_constraint),
"collocation": (3,parse_constraint),
"order": (3,parse_constraint),
"monitor": (3,parse_op),
"node": (2,parse_node),
"property": (2,parse_property),
"rsc_defaults": (2,parse_property),
"op_defaults": (2,parse_property),
}
def __init__(self):
self.comments = []
def parse(self,s):
'''
Input: a list of tokens (or a CLI format string).
Return: a list of items; each item is a tuple
with two members: a string (tag) and a nvpairs or
attributes dict.
'''
cli_list = ''
if type(s) == type(u''):
s = s.encode('ascii')
if type(s) == type(''):
if s and s.startswith('#'):
#self.comments.append(s)
return None
try:
s = shlex.split(s)
except ValueError, msg:
common_err(msg)
return False
# but there shouldn't be any newlines (?)
while '\n' in s:
s.remove('\n')
if not s:
return None
if s[0] not in self.parsers.keys():
syntax_err(s)
return False
mintoks,parser_fn = self.parsers[s[0]]
if len(s) < mintoks:
syntax_err(s)
return False
cli_list = parser_fn(s)
if not cli_list:
return False
if self.comments:
cli_list.append(["comments",self.comments])
self.comments = []
return cli_list
vars = Vars.getInstance()
# vim:ts=4:sw=4:et:
diff --git a/shell/modules/ui.py.in b/shell/modules/ui.py.in
index 5e204551ea..6aae230aa0 100644
--- a/shell/modules/ui.py.in
+++ b/shell/modules/ui.py.in
@@ -1,1745 +1,1746 @@
# 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 re
import os
import readline
import time
from help import HelpSystem, cmd_help
from vars import Vars
from cache import WCache
from levels import Levels
from cibconfig import mkset_obj, CibFactory
from cibstatus import CibStatus
from template import LoadTemplate
from ra import *
from msg import *
from utils import *
from xmlutil import *
def cmd_end(cmd,dir = ".."):
"Go up one level."
levels.droplevel()
def cmd_exit(cmd):
"Exit the crm program"
cmd_end(cmd)
if options.interactive:
print "bye"
try:
readline.write_history_file(hist_file)
except:
pass
for f in vars.tmpfiles:
os.unlink(f)
sys.exit()
class UserInterface(object):
'''
Stuff common to all user interface classes.
'''
global_cmd_aliases = {
"quit": ("bye","exit"),
"end": ("cd","up"),
}
def __init__(self):
self.cmd_table = odict()
self.cmd_table["help"] = (self.help,(0,1),0)
self.cmd_table["quit"] = (self.exit,(0,0),0)
self.cmd_table["end"] = (self.end,(0,1),0)
self.cmd_aliases = self.global_cmd_aliases.copy()
def end_game(self, no_questions_asked = False):
pass
def help(self,cmd,topic = ''):
"usage: help [<topic>]"
cmd_help(self.help_table,topic)
def end(self,cmd,dir = ".."):
"usage: end"
self.end_game()
cmd_end(cmd,dir)
def exit(self,cmd):
"usage: exit"
self.end_game()
cmd_exit(cmd)
class CliOptions(UserInterface):
'''
Manage user preferences
'''
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("options")
self.cmd_table["skill-level"] = (self.set_skill_level,(1,1),0,(skills_list,))
self.cmd_table["editor"] = (self.set_editor,(1,1),0)
self.cmd_table["pager"] = (self.set_pager,(1,1),0)
self.cmd_table["user"] = (self.set_crm_user,(0,1),0)
self.cmd_table["output"] = (self.set_output,(1,1),0)
self.cmd_table["colorscheme"] = (self.set_colors,(1,1),0)
self.cmd_table["check-frequency"] = (self.set_check_frequency,(1,1),0)
self.cmd_table["check-mode"] = (self.set_check_mode,(1,1),0)
self.cmd_table["save"] = (self.save_options,(0,0),0)
self.cmd_table["show"] = (self.show_options,(0,0),0)
setup_aliases(self)
def set_skill_level(self,cmd,skill_level):
"""usage: skill-level <level>
level: operator | administrator | expert"""
return user_prefs.set_skill_level(skill_level)
def set_editor(self,cmd,prog):
"usage: editor <program>"
return user_prefs.set_editor(prog)
def set_pager(self,cmd,prog):
"usage: pager <program>"
return user_prefs.set_pager(prog)
def set_crm_user(self,cmd,user = ''):
"usage: user [<crm_user>]"
return user_prefs.set_crm_user(user)
def set_output(self,cmd,otypes):
"usage: output <type>"
return user_prefs.set_output(otypes)
def set_colors(self,cmd,scheme):
"usage: colorscheme <colors>"
return user_prefs.set_colors(scheme)
def set_check_frequency(self,cmd,freq):
"usage: check-frequence <freq>"
return user_prefs.set_check_freq(freq)
def set_check_mode(self,cmd,mode):
"usage: check-mode <mode>"
return user_prefs.set_check_mode(mode)
def show_options(self,cmd):
"usage: show"
return user_prefs.write_rc(sys.stdout)
def save_options(self,cmd):
"usage: save"
return user_prefs.save_options(vars.rc_file)
def end_game(self, no_questions_asked = False):
if no_questions_asked and not options.interactive:
self.save_options("save")
def listshadows():
return stdout2list("ls @CRM_CONFIG_DIR@ | fgrep shadow. | sed 's/^shadow\.//'")
def shadowfile(name):
return "@CRM_CONFIG_DIR@/shadow.%s" % name
def shadow2doc(name):
return file2doc(shadowfile(name))
class CibShadow(UserInterface):
'''
CIB shadow management class
'''
extcmd = ">/dev/null </dev/null crm_shadow"
extcmd_stdout = "</dev/null crm_shadow"
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("cib")
self.cmd_table["new"] = (self.new,(1,3),1)
self.cmd_table["delete"] = (self.delete,(1,1),1,(shadows_list,))
self.cmd_table["reset"] = (self.reset,(1,1),1,(shadows_list,))
self.cmd_table["commit"] = (self.commit,(1,1),1,(shadows_list,))
self.cmd_table["use"] = (self.use,(0,2),1,(shadows_live_list,))
self.cmd_table["diff"] = (self.diff,(0,0),1)
self.cmd_table["list"] = (self.list,(0,0),1)
self.cmd_table["cibstatus"] = StatusMgmt
self.chkcmd()
setup_aliases(self)
def chkcmd(self):
try:
ext_cmd("%s 2>&1" % self.extcmd)
except os.error:
no_prog_err(self.extcmd)
return False
return True
def new(self,cmd,name,*args):
"usage: new <shadow_cib> [withstatus] [force]"
if not is_filename_sane(name):
return False
new_cmd = "%s -c '%s'" % (self.extcmd,name)
for par in args:
if not par in ("force","--force","withstatus"):
syntax_err((cmd,name,par), context = 'new')
return False
if user_prefs.get_force() or "force" in args or "--force" in args:
new_cmd = "%s --force" % new_cmd
if ext_cmd(new_cmd) == 0:
common_info("%s shadow CIB created"%name)
self.use("use",name)
if "withstatus" in args:
cib_status.load("shadow:%s" % name)
def delete(self,cmd,name):
"usage: delete <shadow_cib>"
if not is_filename_sane(name):
return False
if vars.cib_in_use == name:
common_err("%s shadow CIB is in use"%name)
return False
if ext_cmd("%s -D '%s' --force" % (self.extcmd,name)) == 0:
common_info("%s shadow CIB deleted"%name)
else:
common_err("failed to delete %s shadow CIB"%name)
return False
def reset(self,cmd,name):
"usage: reset <shadow_cib>"
if not is_filename_sane(name):
return False
if ext_cmd("%s -r '%s'" % (self.extcmd,name)) == 0:
common_info("copied live CIB to %s"%name)
else:
common_err("failed to copy live CIB to %s"%name)
return False
def commit(self,cmd,name):
"usage: commit <shadow_cib>"
if not is_filename_sane(name):
return False
if ext_cmd("%s -C '%s' --force" % (self.extcmd,name)) == 0:
common_info("commited '%s' shadow CIB to the cluster"%name)
wcache.clear()
else:
common_err("failed to commit the %s shadow CIB"%name)
return False
def diff(self,cmd):
"usage: diff"
s = get_stdout(add_sudo("%s -d" % self.extcmd_stdout))
page_string(s)
def list(self,cmd):
"usage: list"
if options.regression_tests:
for t in listshadows():
print t
else:
multicolumn(listshadows())
def _use(self,name,withstatus):
# Choose a shadow cib for further changes. If the name
# provided is empty, then choose the live (cluster) cib.
# Don't allow ' in shadow names
if not name or name == "live":
os.unsetenv(vars.shadow_envvar)
vars.cib_in_use = ""
if withstatus:
cib_status.load("live")
else:
os.putenv(vars.shadow_envvar,name)
vars.cib_in_use = name
if withstatus:
cib_status.load("shadow:%s" % name)
def use(self,cmd,name = '', withstatus = ''):
"usage: use [<shadow_cib>] [withstatus]"
# check the name argument
if name and not is_filename_sane(name):
return False
if name and name != "live":
if not os.access(shadowfile(name),os.F_OK):
common_err("%s: no such shadow CIB"%name)
return False
if withstatus and withstatus != "withstatus":
syntax_err((cmd,withstatus), context = 'use')
return False
# If invoked from configure
# take special precautions
try:
prev_level = levels.previous().myname()
except:
prev_level = ''
if prev_level != "cibconfig":
self._use(name,withstatus)
return True
if not cib_factory.has_cib_changed():
self._use(name,withstatus)
# new CIB: refresh the CIB factory
cib_factory.refresh()
return True
saved_cib = vars.cib_in_use
self._use(name,'') # don't load the status yet
if not cib_factory.is_current_cib_equal(silent = True):
# user made changes and now wants to switch to a
# different and unequal CIB; we refuse to cooperate
common_err("the requested CIB is different from the current one")
if user_prefs.get_force():
common_info("CIB overwrite forced")
elif not ask("All changes will be dropped. Do you want to proceed?"):
self._use(saved_cib,'') # revert to the previous CIB
return False
self._use(name,withstatus) # now load the status too
return True
def listtemplates():
l = []
for f in os.listdir(vars.tmpl_dir):
if os.path.isfile("%s/%s" % (vars.tmpl_dir,f)):
l.append(f)
return l
def listconfigs():
l = []
for f in os.listdir(vars.tmpl_conf_dir):
if os.path.isfile("%s/%s" % (vars.tmpl_conf_dir,f)):
l.append(f)
return l
def check_transition(inp,state,possible_l):
if not state in possible_l:
common_err("input (%s) in wrong state %s" % (inp,state))
return False
return True
class Template(UserInterface):
'''
Configuration templates.
'''
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("template")
self.cmd_table["new"] = (self.new,(2,),1,(null_list,templates_list,loop))
self.cmd_table["load"] = (self.load,(0,1),1,(config_list,))
self.cmd_table["edit"] = (self.edit,(0,1),1,(config_list,))
self.cmd_table["delete"] = (self.delete,(1,2),1,(config_list,))
self.cmd_table["show"] = (self.show,(0,1),0,(config_list,))
self.cmd_table["apply"] = (self.apply,(0,2),1,(config_list_method,config_list))
self.cmd_table["list"] = (self.list,(0,1),0)
setup_aliases(self)
self.init_dir()
self.curr_conf = ''
def init_dir(self):
'''Create the conf directory, link to templates'''
if not os.path.isdir(vars.tmpl_conf_dir):
try:
os.makedirs(vars.tmpl_conf_dir)
except os.error,msg:
common_err("makedirs: %s"%msg)
return
def get_depends(self,tmpl):
'''return a list of required templates'''
# Not used. May need it later.
try:
tf = open("%s/%s" % (vars.tmpl_dir, tmpl),"r")
except IOError,msg:
common_err("open: %s"%msg)
return
l = []
for s in tf:
a = s.split()
if len(a) >= 2 and a[0] == '%depends_on':
l += a[1:]
tf.close()
return l
def replace_params(self,s,user_data):
change = False
for i in range(len(s)):
word = s[i]
for p in user_data:
# is parameter in the word?
pos = word.find('%' + p)
if pos < 0:
continue
endpos = pos + len('%' + p)
# and it isn't part of another word?
if re.match("[A-Za-z0-9]", word[endpos:endpos+1]):
continue
# if the value contains a space or
# it is a value of an attribute
# put quotes around it
if user_data[p].find(' ') >= 0 or word[pos-1:pos] == '=':
v = '"' + user_data[p] + '"'
else:
v = user_data[p]
word = word.replace('%' + p, v)
change = True # we did replace something
if change:
s[i] = word
if 'opt' in s:
if not change:
s = []
else:
s.remove('opt')
return s
def generate(self,l,user_data):
'''replace parameters (user_data) and generate output
'''
l2 = []
for piece in l:
piece2 = []
for s in piece:
s = self.replace_params(s,user_data)
if s:
piece2.append(' '.join(s))
if piece2:
l2.append(' \\\n\t'.join(piece2))
return '\n'.join(l2)
def process(self,config = ''):
'''Create a cli configuration from the current config'''
try:
f = open("%s/%s" % (vars.tmpl_conf_dir, config or self.curr_conf),'r')
except IOError,msg:
common_err("open: %s"%msg)
return ''
l = []
piece = []
user_data = {}
# states
START = 0; PFX = 1; DATA = 2; GENERATE = 3
state = START
err_buf.start_tmp_lineno()
rc = True
for inp in f:
err_buf.incr_lineno()
if inp.startswith('#'):
continue
if type(inp) == type(u''):
inp = inp.encode('ascii')
inp = inp.strip()
try:
s = shlex.split(inp)
except ValueError, msg:
common_err(msg)
continue
while '\n' in s:
s.remove('\n')
if not s:
if state == GENERATE and piece:
l.append(piece)
piece = []
elif s[0] in ("%name","%depends_on","%suggests"):
continue
elif s[0] == "%pfx":
if check_transition(inp,state,(START,DATA)) and len(s) == 2:
pfx = s[1]
state = PFX
elif s[0] == "%required":
if check_transition(inp,state,(PFX,)):
state = DATA
data_reqd = True
elif s[0] == "%optional":
if check_transition(inp,state,(PFX,DATA)):
state = DATA
data_reqd = False
elif s[0] == "%%":
if state != DATA:
common_warn("user data in wrong state %s" % state)
if len(s) < 2:
common_warn("parameter name missing")
elif len(s) == 2:
if data_reqd:
common_err("required parameter %s not set" % s[1])
rc = False
elif len(s) == 3:
user_data["%s:%s" % (pfx,s[1])] = s[2]
else:
common_err("%s: syntax error" % inp)
elif s[0] == "%generate":
if check_transition(inp,state,(DATA,)):
state = GENERATE
piece = []
elif state == GENERATE:
if s:
piece.append(s)
else:
common_err("<%s> unexpected" % inp)
if piece:
l.append(piece)
err_buf.stop_tmp_lineno()
f.close()
if not rc:
return ''
return self.generate(l,user_data)
def new(self,cmd,name,*args):
"usage: new <config> <template> [<template> ...] [params name=value ...]"
if not is_filename_sane(name):
return False
if os.path.isfile("%s/%s" % (vars.tmpl_conf_dir, name)):
common_err("config %s exists; delete it first" % name)
return False
lt = LoadTemplate(name)
rc = True
mode = 0
params = {}
for s in args:
if mode == 0 and s == "params":
params["id"] = name
mode = 1
elif mode == 1:
a = s.split('=')
if len(a) != 2:
syntax_err(args, context = 'new')
rc = False
else:
params[a[0]] = a[1]
elif not lt.load_template(s):
rc = False
if rc:
lt.post_process(params)
if not rc or not lt.write_config(name):
return False
self.curr_conf = name
def config_exists(self,name):
if not is_filename_sane(name):
return False
if not os.path.isfile("%s/%s" % (vars.tmpl_conf_dir, name)):
common_err("%s: no such config" % name)
return False
return True
def delete(self,cmd,name,force = ''):
"usage: delete <config> [force]"
if force:
if force != "force" and force != "--force":
syntax_err((cmd,force), context = 'delete')
return False
if not self.config_exists(name):
return False
if name == self.curr_conf:
if not force and not user_prefs.get_force() and \
not ask("Do you really want to remove config %s which is in use?" % self.curr_conf):
return False
else:
self.curr_conf = ''
os.remove("%s/%s" % (vars.tmpl_conf_dir, name))
def load(self,cmd,name = ''):
"usage: load [<config>]"
if not name:
self.curr_conf = ''
return True
if not self.config_exists(name):
return False
self.curr_conf = name
def edit(self,cmd,name = ''):
"usage: edit [<config>]"
if not name and not self.curr_conf:
common_err("please load a config first")
return False
if name:
if not self.config_exists(name):
return False
edit_file("%s/%s" % (vars.tmpl_conf_dir, name))
else:
edit_file("%s/%s" % (vars.tmpl_conf_dir, self.curr_conf))
def show(self,cmd,name = ''):
"usage: show [<config>]"
if not name and not self.curr_conf:
common_err("please load a config first")
return False
if name:
if not self.config_exists(name):
return False
print self.process(name)
else:
print self.process()
def apply(self,cmd,*args):
"usage: apply [<method>] [<config>]"
method = "replace"
name = ''
if len(args) > 0:
i = 0
if args[0] in ("replace","update"):
method = args[0]
i += 1
if len(args) > i:
name = args[i]
if not name and not self.curr_conf:
common_err("please load a config first")
return False
if name:
if not self.config_exists(name):
return False
s = self.process(name)
else:
s = self.process()
if not s:
return False
tmp = str2tmp(s)
if not tmp:
return False
set_obj = mkset_obj("NOOBJ")
rc = set_obj.import_file(method,tmp)
try: os.unlink(tmp)
except: pass
return rc
def list(self,cmd,templates = ''):
"usage: list [templates]"
if templates == "templates":
multicolumn(listtemplates())
else:
multicolumn(listconfigs())
def manage_attr(cmd,attr_ext_commands,*args):
if len(args) < 3:
bad_usage(cmd,' '.join(args))
return False
attr_cmd = None
try:
attr_cmd = attr_ext_commands[args[1]]
except KeyError:
bad_usage(cmd,' '.join(args))
return False
if not attr_cmd:
bad_usage(cmd,' '.join(args))
return False
if args[1] == 'set':
if len(args) == 4:
if not is_name_sane(args[0]) \
or not is_name_sane(args[2]) \
or not is_value_sane(args[3]):
return False
return ext_cmd(attr_cmd%(args[0],args[2],args[3])) == 0
else:
bad_usage(cmd,' '.join(args))
return False
elif args[1] in ('delete','show'):
if len(args) == 3:
if not is_name_sane(args[0]) \
or not is_name_sane(args[2]):
return False
return ext_cmd(attr_cmd%(args[0],args[2])) == 0
else:
bad_usage(cmd,' '.join(args))
return False
else:
bad_usage(cmd,' '.join(args))
return False
def cleanup_resource(rsc,node):
if not is_name_sane(rsc) or not is_name_sane(node):
return False
if is_rsc_clone(rsc) or is_rsc_ms(rsc):
base = get_cloned_rsc(rsc)
if not base:
return False
clone_max = get_max_clone(rsc)
rc = True
for n in range(clone_max):
if ext_cmd(RscMgmt.rsc_cleanup % ("%s:%d" % (base,n), node)) != 0:
rc = False
else:
rc = ext_cmd(RscMgmt.rsc_cleanup%(rsc,node)) != 0
return rc
class RscMgmt(UserInterface):
'''
Resources management class
'''
rsc_status_all = "crm_resource -L"
rsc_status = "crm_resource -W -r '%s'"
rsc_showxml = "crm_resource -q -r '%s'"
rsc_setrole = "crm_resource --meta -r '%s' -p target-role -v '%s'"
rsc_manage = "crm_resource --meta -r '%s' -p is-managed -v '%s'"
rsc_migrate = "crm_resource -M -r '%s'"
rsc_migrateto = "crm_resource -M -r '%s' -H '%s'"
rsc_unmigrate = "crm_resource -U -r '%s'"
rsc_cleanup = "crm_resource -C -r '%s' -H '%s'"
rsc_param = {
'set': "crm_resource -r '%s' -p '%s' -v '%s'",
'delete': "crm_resource -r '%s' -d '%s'",
'show': "crm_resource -r '%s' -g '%s'",
}
rsc_meta = {
'set': "crm_resource --meta -r '%s' -p '%s' -v '%s'",
'delete': "crm_resource --meta -r '%s' -d '%s'",
'show': "crm_resource --meta -r '%s' -g '%s'",
}
rsc_failcount = {
'set': "crm_failcount -r '%s' -N '%s' -v '%s'",
'delete': "crm_failcount -r '%s' -N '%s' -D",
'show': "crm_failcount -r '%s' -N '%s' -G",
}
rsc_refresh = "crm_resource -R"
rsc_refresh_node = "crm_resource -R -H '%s'"
rsc_reprobe = "crm_resource -P"
rsc_reprobe_node = "crm_resource -P -H '%s'"
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("resource")
self.cmd_table["status"] = (self.status,(0,1),0,(rsc_list,))
self.cmd_table["start"] = (self.start,(1,1),0,(rsc_list,))
self.cmd_table["stop"] = (self.stop,(1,1),0,(rsc_list,))
self.cmd_table["restart"] = (self.restart,(1,1),0,(rsc_list,))
self.cmd_table["promote"] = (self.promote,(1,1),0,(rsc_list,))
self.cmd_table["demote"] = (self.demote,(1,1),0,(rsc_list,))
self.cmd_table["manage"] = (self.manage,(1,1),0,(rsc_list,))
self.cmd_table["unmanage"] = (self.unmanage,(1,1),0,(rsc_list,))
self.cmd_table["migrate"] = (self.migrate,(1,2),0,(rsc_list,nodes_list))
self.cmd_table["unmigrate"] = (self.unmigrate,(1,1),0,(rsc_list,))
self.cmd_table["param"] = (self.param,(3,4),1,(rsc_list,attr_cmds))
self.cmd_table["meta"] = (self.meta,(3,4),1,(rsc_list,attr_cmds))
self.cmd_table["failcount"] = (self.failcount,(3,4),0,(rsc_list,attr_cmds,nodes_list))
self.cmd_table["cleanup"] = (self.cleanup,(1,2),1,(rsc_list,nodes_list))
self.cmd_table["refresh"] = (self.refresh,(0,1),0,(nodes_list,))
self.cmd_table["reprobe"] = (self.reprobe,(0,1),0,(nodes_list,))
self.cmd_aliases.update({
"status": ("show","list",),
"migrate": ("move",),
"unmigrate": ("unmove",),
})
setup_aliases(self)
def status(self,cmd,rsc = None):
"usage: status [<rsc>]"
if rsc:
if not is_name_sane(rsc):
return False
return ext_cmd(self.rsc_status % rsc) == 0
else:
return ext_cmd(self.rsc_status_all) == 0
def start(self,cmd,rsc):
"usage: start <rsc>"
if not is_name_sane(rsc):
return False
return ext_cmd(self.rsc_setrole%(rsc,"Started")) == 0
def restart(self,cmd,rsc):
"usage: restart <rsc>"
if not is_name_sane(rsc):
return False
if not self.stop("stop",rsc):
return False
return self.start("start",rsc)
def stop(self,cmd,rsc):
"usage: stop <rsc>"
if not is_name_sane(rsc):
return False
return ext_cmd(self.rsc_setrole%(rsc,"Stopped")) == 0
def promote(self,cmd,rsc):
"usage: promote <rsc>"
if not is_name_sane(rsc):
return False
if not is_rsc_ms(rsc):
common_err("%s is not a master-slave resource" % rsc)
return False
return ext_cmd(self.rsc_setrole%(rsc,"Master")) == 0
def demote(self,cmd,rsc):
"usage: demote <rsc>"
if not is_name_sane(rsc):
return False
if not is_rsc_ms(rsc):
common_err("%s is not a master-slave resource" % rsc)
return False
return ext_cmd(self.rsc_setrole%(rsc,"Slave")) == 0
def manage(self,cmd,rsc):
"usage: manage <rsc>"
if not is_name_sane(rsc):
return False
return ext_cmd(self.rsc_manage%(rsc,"true")) == 0
def unmanage(self,cmd,rsc):
"usage: unmanage <rsc>"
if not is_name_sane(rsc):
return False
return ext_cmd(self.rsc_manage%(rsc,"false")) == 0
def migrate(self,cmd,*args):
"""usage: migrate <rsc> [<node>]"""
if not is_name_sane(args[0]):
return False
if len(args) == 1:
return ext_cmd(self.rsc_migrate%args[0]) == 0
else:
if not is_name_sane(args[1]):
return False
return ext_cmd(self.rsc_migrateto%(args[0],args[1])) == 0
def unmigrate(self,cmd,rsc):
"usage: unmigrate <rsc>"
if not is_name_sane(rsc):
return False
return ext_cmd(self.rsc_unmigrate%rsc) == 0
def cleanup(self,cmd,*args):
"usage: cleanup <rsc> [<node>]"
# Cleanup a resource on a node. Omit node to cleanup on
# all live nodes.
if len(args) == 2: # remove
return cleanup_resource(args[0],args[1])
else:
rv = True
for n in listnodes():
if not cleanup_resource(args[0],n):
rv = False
return rv
def failcount(self,cmd,*args):
"""usage:
failcount <rsc> set <node> <value>
failcount <rsc> delete <node>
failcount <rsc> show <node>"""
d = lambda: manage_attr(cmd,self.rsc_failcount,*args)
return d()
def param(self,cmd,*args):
"""usage:
param <rsc> set <param> <value>
param <rsc> delete <param>
param <rsc> show <param>"""
d = lambda: manage_attr(cmd,self.rsc_param,*args)
return d()
def meta(self,cmd,*args):
"""usage:
meta <rsc> set <attr> <value>
meta <rsc> delete <attr>
meta <rsc> show <attr>"""
d = lambda: manage_attr(cmd,self.rsc_meta,*args)
return d()
def refresh(self,cmd,*args):
'usage: refresh [<node>]'
if len(args) == 1:
if not is_name_sane(args[0]):
return False
return ext_cmd(self.rsc_refresh_node%args[0]) == 0
else:
return ext_cmd(self.rsc_refresh) == 0
def reprobe(self,cmd,*args):
'usage: reprobe [<node>]'
if len(args) == 1:
if not is_name_sane(args[0]):
return False
return ext_cmd(self.rsc_reprobe_node%args[0]) == 0
else:
return ext_cmd(self.rsc_reprobe) == 0
def print_node(uname,id,node_type,other,inst_attr,offline):
"""
Try to pretty print a node from the cib. Sth like:
uname(id): node_type
attr1: v1
attr2: v2
"""
s_offline = offline and "(offline)" or ""
if uname == id:
print "%s: %s%s" % (uname,node_type,s_offline)
else:
print "%s(%s): %s%s" % (uname,id,node_type,s_offline)
for a in other:
print "\t%s: %s" % (a,other[a])
for a,v in inst_attr:
print "\t%s: %s" % (a,v)
class NodeMgmt(UserInterface):
'''
Nodes management class
'''
node_standby = "crm_standby -N '%s' -v '%s'"
node_delete = "cibadmin -D -o nodes -X '<node uname=\"%s\"/>'"
node_delete_status = "cibadmin -D -o status -X '<node_state uname=\"%s\"/>'"
hb_delnode = "@libdir@/heartbeat/hb_delnode '%s'"
crm_node = "crm_node"
node_fence = "crm_attribute -t status -U '%s' -n terminate -v true"
dc = "crmadmin -D"
node_attr = {
'set': "crm_attribute -t nodes -U '%s' -n '%s' -v '%s'",
'delete': "crm_attribute -D -t nodes -U '%s' -n '%s'",
'show': "crm_attribute -G -t nodes -U '%s' -n '%s'",
}
node_status = {
'set': "crm_attribute -t status -U '%s' -n '%s' -v '%s'",
'delete': "crm_attribute -D -t status -U '%s' -n '%s'",
'show': "crm_attribute -G -t status -U '%s' -n '%s'",
}
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("node")
self.cmd_table["status"] = (self.status,(0,1),0,(nodes_list,))
self.cmd_table["show"] = (self.show,(0,1),0,(nodes_list,))
self.cmd_table["standby"] = (self.standby,(0,1),0,(nodes_list,))
self.cmd_table["online"] = (self.online,(0,1),0,(nodes_list,))
self.cmd_table["fence"] = (self.fence,(1,1),0,(nodes_list,))
self.cmd_table["delete"] = (self.delete,(1,1),0,(nodes_list,))
self.cmd_table["attribute"] = (self.attribute,(3,4),0,(nodes_list,attr_cmds))
self.cmd_table["status-attr"] = (self.status_attr,(3,4),0,(nodes_list,attr_cmds))
self.cmd_aliases.update({
"show": ("list",),
})
setup_aliases(self)
def status(self,cmd,node = None):
'usage: status [<node>]'
return ext_cmd("%s -o nodes"%cib_dump) == 0
def show(self,cmd,node = None):
'usage: show [<node>]'
doc = cibdump2doc()
if not doc:
return False
nodes_node = get_conf_elem(doc, "nodes")
status = get_conf_elem(doc, "status")
if not nodes_node:
return False
for c in nodes_node.childNodes:
if not is_element(c) or c.tagName != "node":
continue
if node and c.getAttribute("uname") != node:
continue
type = uname = id = ""
inst_attr = []
other = {}
for attr in c.attributes.keys():
v = c.getAttribute(attr)
if attr == "type":
type = v
elif attr == "uname":
uname = v
elif attr == "id":
id = v
else:
other[attr] = v
for c2 in c.childNodes:
if not is_element(c2):
continue
if c2.tagName == "instance_attributes":
inst_attr += nvpairs2list(c2)
offline = False
for c2 in status.getElementsByTagName("node_state"):
if uname != c2.getAttribute("uname"):
continue
offline = c2.getAttribute("crmd") == "offline"
print_node(uname,id,type,other,inst_attr,offline)
def standby(self,cmd,node = None):
'usage: standby [<node>]'
if not node:
node = this_node
if not is_name_sane(node):
return False
return ext_cmd(self.node_standby%(node,"on")) == 0
def online(self,cmd,node = None):
'usage: online [<node>]'
if not node:
node = this_node
if not is_name_sane(node):
return False
return ext_cmd(self.node_standby%(node,"off")) == 0
def fence(self,cmd,node):
'usage: fence <node>'
if not node:
node = this_node
if not is_name_sane(node):
return False
return ext_cmd(self.node_fence%(node)) == 0
def delete(self,cmd,node):
'usage: delete <node>'
if not is_name_sane(node):
return False
rc = True
if cluster_stack() == "heartbeat":
rc = ext_cmd(self.hb_delnode%node) == 0
else:
node_states = {}
for s in stdout2list("%s -l" % self.crm_node):
a = s.split()
if len(a) != 3:
common_warn("%s bad format: %s" % (self.crm_node,s))
continue
# fmt: id uname status
# remove only those in state "lost"
if a[1] == node:
node_states[a[2]] = 1
if a[2] == "lost":
if ext_cmd("%s --force -R %s" % (self.crm_node,a[0])) != 0:
rc = False
if not "lost" in node_states:
common_err('node %s/state "lost" not found in the id list' % node)
if "member" in node_states:
common_info("node %s appears to be still active" % node)
common_info("check output of %s -l" % self.crm_node)
rc = False
if rc:
if ext_cmd(self.node_delete%node) != 0 or \
ext_cmd(self.node_delete_status%node) != 0:
rc = False
return rc
def attribute(self,cmd,*args):
"""usage:
attribute <node> set <rsc> <value>
attribute <node> delete <rsc>
attribute <node> show <rsc>"""
d = lambda: manage_attr(cmd,self.node_attr,*args)
return d()
def status_attr(self,cmd,*args):
"""usage:
status-attr <node> set <rsc> <value>
status-attr <node> delete <rsc>
status-attr <node> show <rsc>"""
d = lambda: manage_attr(cmd,self.node_status,*args)
return d()
class RA(UserInterface):
'''
CIB shadow management class
'''
provider_classes = ["ocf"]
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("ra")
self.cmd_table["classes"] = (self.classes,(0,0),0)
self.cmd_table["list"] = (self.list,(1,2),1)
self.cmd_table["providers"] = (self.providers,(1,1),1)
self.cmd_table["meta"] = (self.meta,(1,3),1)
self.cmd_aliases.update({
"meta": ("info",),
})
setup_aliases(self)
def classes(self,cmd):
"usage: classes"
for c in ra_classes():
if c in self.provider_classes:
print "%s / %s" % (c,' '.join(ra_providers_all(c)))
else:
print "%s" % c
def providers(self,cmd,ra_type):
"usage: providers <ra>"
print ' '.join(ra_providers(ra_type))
def list(self,cmd,c,p = None):
"usage: list <class> [<provider>]"
if not c in ra_classes():
common_err("class %s does not exist" % c)
return False
if p and not p in ra_providers_all(c):
common_err("there is no provider %s for class %s" % (p,c))
return False
if options.regression_tests:
for t in ra_types(c,p):
print t
else:
multicolumn(ra_types(c,p))
def meta(self,cmd,*args):
"usage: meta [<class>:[<provider>:]]<type>"
if len(args) > 1: # obsolete syntax
ra_type = args[0]
ra_class = args[1]
if len(args) < 3:
ra_provider = "heartbeat"
else:
ra_provider = args[2]
else:
ra_class,ra_provider,ra_type = disambiguate_ra_type(args[0])
ra = RAInfo(ra_class,ra_type,ra_provider)
if not ra.mk_ra_node():
return False
try:
page_string(ra.meta_pretty())
except:
return False
class StatusMgmt(UserInterface):
'''
The CIB status section management user interface class
'''
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("cibstatus")
self.cmd_table["show"] = (self.show,(0,1),1)
self.cmd_table["save"] = (self.save,(0,1),2)
self.cmd_table["load"] = (self.load,(1,1),2)
self.cmd_table["origin"] = (self.origin,(0,0),1)
self.cmd_table["node"] = (self.edit_node,(2,2),2,(status_node_list,node_states_list))
self.cmd_table["op"] = (self.edit_op,(3,5),2,(ra_operations_list,status_rsc_list,lrm_exit_codes_list,lrm_status_codes_list,status_node_list))
setup_aliases(self)
def myname(self):
'''Just return some id.'''
return "cibstatus"
def load(self,cmd,org):
"usage: load {<file>|shadow:<cib>|live}"
return cib_status.load(org)
def save(self,cmd,dest = None):
"usage: save [<file>|shadow:<cib>]"
return cib_status.save(dest)
def origin(self,cmd):
"usage: origin"
state = cib_status.modified and " (modified)" or ""
print "%s%s" % (cib_status.origin,state)
def show(self,cmd,changed = ""):
"usage: show [changed]"
if changed:
if changed != "changed":
syntax_err((cmd,changed))
return False
else:
return cib_status.list_changes()
return cib_status.show()
def edit_node(self,cmd,node,state):
"usage: node <node> {online|offline|unclean}"
return cib_status.edit_node(node,state)
def edit_op(self,cmd,op,rsc,rc,op_status = None,node = ''):
"usage: op <operation> <resource> <exit_code> [<op_status>] [<node>]"
if rc in vars.lrm_exit_codes:
num_rc = vars.lrm_exit_codes[rc]
else:
num_rc = rc
if not num_rc.isdigit():
common_err("%s exit code invalid" % num_rc)
return False
num_op_status = op_status
if op_status:
if op_status in vars.lrm_status_codes:
num_op_status = vars.lrm_status_codes[op_status]
if not num_op_status.isdigit():
common_err("%s operation status invalid" % num_op_status)
return False
return cib_status.edit_op(op,rsc,num_rc,num_op_status,node)
class CibConfig(UserInterface):
'''
The configuration class
'''
def __init__(self):
UserInterface.__init__(self)
self.help_table = help_sys.load_level("configure")
self.cmd_table["erase"] = (self.erase,(0,1),1)
self.cmd_table["verify"] = (self.verify,(0,0),1)
self.cmd_table["refresh"] = (self.refresh,(0,0),1)
self.cmd_table["ptest"] = (self.ptest,(0,3),1)
self.cmd_table["commit"] = (self.commit,(0,1),1)
self.cmd_table["upgrade"] = (self.upgrade,(0,1),1)
self.cmd_table["show"] = (self.show,(0,),1,(id_xml_list,id_list,loop))
self.cmd_table["edit"] = (self.edit,(0,),1,(id_xml_list,id_list,loop))
self.cmd_table["delete"] = (self.delete,(1,),1,(id_list,loop))
self.cmd_table["rename"] = (self.rename,(2,2),1,(id_list,))
self.cmd_table["save"] = (self.save,(1,2),1)
self.cmd_table["load"] = (self.load,(2,3),1)
self.cmd_table["node"] = (self.conf_node,(1,),1)
self.cmd_table["primitive"] = (self.conf_primitive,(2,),1,(null_list, \
ra_classes_list, primitive_complete_complex, loop))
self.cmd_table["group"] = (self.conf_group,(2,),1,(null_list,f_prim_id_list,loop))
self.cmd_table["clone"] = (self.conf_clone,(2,),1,(null_list,f_children_id_list))
self.cmd_table["ms"] = (self.conf_ms,(2,),1,(null_list,f_children_id_list))
self.cmd_table["location"] = (self.conf_location,(2,),1,(null_list,rsc_id_list))
self.cmd_table["colocation"] = (self.conf_colocation,(2,),1,(null_list,null_list,rsc_id_list,loop))
self.cmd_table["order"] = (self.conf_order,(2,),1,(null_list,null_list,rsc_id_list,loop))
self.cmd_table["property"] = (self.conf_property,(1,),1,(property_complete,loop))
self.cmd_table["rsc_defaults"] = (self.conf_rsc_defaults,(1,),1)
self.cmd_table["op_defaults"] = (self.conf_op_defaults,(1,),1)
self.cmd_table["monitor"] = (self.conf_monitor,(2,2),1)
self.cmd_table["ra"] = RA
self.cmd_table["cib"] = CibShadow
self.cmd_table["cibstatus"] = StatusMgmt
self.cmd_table["template"] = Template
self.cmd_table["_test"] = (self.check_structure,(0,0),1)
self.cmd_table["_regtest"] = (self.regression_testing,(1,1),1)
self.cmd_table["_queues"] = (self.showqueues,(0,0),1)
self.cmd_table["_objects"] = (self.showobjects,(0,0),1)
self.cmd_aliases.update({
"colocation": ("collocation",),
"ms": ("master",),
})
setup_aliases(self)
cib_factory.initialize()
def myname(self):
'''Just return some id.'''
return "cibconfig"
def check_structure(self,cmd):
return cib_factory.check_structure()
def regression_testing(self,cmd,param):
return cib_factory.regression_testing(param)
def showqueues(self,cmd):
cib_factory.showqueues()
def showobjects(self,cmd):
cib_factory.showobjects()
def show(self,cmd,*args):
"usage: show [xml] [<id>...]"
if not cib_factory.is_cib_sane():
return False
err_buf.buffer() # keep error messages
set_obj = mkset_obj(*args)
err_buf.release() # show them, but get an ack from the user
return set_obj.show()
def edit(self,cmd,*args):
"usage: edit [xml] [<id>...]"
if not cib_factory.is_cib_sane():
return False
err_buf.buffer() # keep error messages
set_obj = mkset_obj(*args)
err_buf.release() # show them, but get an ack from the user
return set_obj.edit()
def verify(self,cmd):
"usage: verify"
if not cib_factory.is_cib_sane():
return False
set_obj = mkset_obj("xml")
rc1 = set_obj.verify()
if user_prefs.check_frequency != "never":
rc2 = set_obj.verify2()
else:
rc2 = 0
return rc1 and rc2 <= 1
def save(self,cmd,*args):
"usage: save [xml] <filename>"
if not cib_factory.is_cib_sane():
return False
if args[0] == "xml":
f = args[1]
set_obj = mkset_obj("xml")
else:
f = args[0]
set_obj = mkset_obj()
return set_obj.save_to_file(f)
def load(self,cmd,*args):
"usage: load [xml] {replace|update} {<url>|<path>}"
if not cib_factory.is_cib_sane():
return False
if args[0] == "xml":
if len(args) != 3:
syntax_err(args, context = 'load')
return False
url = args[2]
method = args[1]
set_obj = mkset_obj("xml","NOOBJ")
else:
if len(args) != 2:
syntax_err(args, context = 'load')
return False
url = args[1]
method = args[0]
set_obj = mkset_obj("NOOBJ")
return set_obj.import_file(method,url)
def delete(self,cmd,*args):
"usage: delete <id> [<id>...]"
if not cib_factory.is_cib_sane():
return False
return cib_factory.delete(*args)
def rename(self,cmd,old_id,new_id):
"usage: rename <old_id> <new_id>"
if not cib_factory.is_cib_sane():
return False
return cib_factory.rename(old_id,new_id)
def erase(self,cmd,nodes = None):
"usage: erase [nodes]"
if not cib_factory.is_cib_sane():
return False
if nodes:
if nodes == "nodes":
return cib_factory.erase_nodes()
else:
syntax_err((cmd,nodes), context = 'erase')
else:
return cib_factory.erase()
def refresh(self,cmd):
"usage: refresh"
if not cib_factory.is_cib_sane():
return False
if options.interactive and cib_factory.has_cib_changed():
if not ask("All changes will be dropped. Do you want to proceed?"):
return
cib_factory.refresh()
def ptest(self,cmd,*args):
"usage: ptest [nograph] [v...] [scores]"
if not cib_factory.is_cib_sane():
return False
verbosity = 'vv' # default verbosity
nograph = False
scores = False
for p in args:
if p == "nograph":
nograph = True
elif p == "scores":
scores = True
elif re.match("^vv*$", p):
verbosity = p
else:
bad_usage(cmd,' '.join(args))
return False
set_obj = mkset_obj("xml")
return set_obj.ptest(nograph, scores, verbosity)
def commit(self,cmd,force = None):
"usage: commit [force]"
if force and force != "force":
syntax_err((cmd,force))
return False
if not cib_factory.is_cib_sane():
return False
if not cib_factory.has_cib_changed():
common_info("apparently there is nothing to commit")
common_info("try changing something first")
return
wcache.clear()
rc1 = cib_factory.is_current_cib_equal()
rc2 = self.verify("verify")
if rc1 and rc2:
return cib_factory.commit()
if force or user_prefs.get_force():
common_info("commit forced")
return cib_factory.commit()
if ask("Do you still want to commit?"):
return cib_factory.commit()
return False
def upgrade(self,cmd,force = None):
"usage: upgrade [force]"
if not cib_factory.is_cib_sane():
return False
if force and force != "force":
syntax_err((cmd,force))
return False
if user_prefs.get_force() or force:
return cib_factory.upgrade_cib_06to10(True)
else:
return cib_factory.upgrade_cib_06to10()
def __conf_object(self,cmd,*args):
"The configure object command."
if not cib_factory.is_cib_sane():
return False
f = lambda: cib_factory.create_object(cmd,*args)
return f()
def conf_node(self,cmd,*args):
"""usage: node <uname>[:<type>]
[attributes <param>=<value> [<param>=<value>...]]"""
return self.__conf_object(cmd,*args)
def conf_primitive(self,cmd,*args):
"""usage: primitive <rsc> [<class>:[<provider>:]]<type>
[params <param>=<value> [<param>=<value>...]]
[meta <attribute>=<value> [<attribute>=<value>...]]
+ [utilization <attribute>=<value> [<attribute>=<value>...]]
[operations id_spec
[op op_type [<attribute>=<value>...] ...]]"""
return self.__conf_object(cmd,*args)
def conf_group(self,cmd,*args):
"""usage: group <name> <rsc> [<rsc>...]
[params <param>=<value> [<param>=<value>...]]
[meta <attribute>=<value> [<attribute>=<value>...]]"""
return self.__conf_object(cmd,*args)
def conf_clone(self,cmd,*args):
"""usage: clone <name> <rsc>
[params <param>=<value> [<param>=<value>...]]
[meta <attribute>=<value> [<attribute>=<value>...]]"""
return self.__conf_object(cmd,*args)
def conf_ms(self,cmd,*args):
"""usage: ms <name> <rsc>
[params <param>=<value> [<param>=<value>...]]
[meta <attribute>=<value> [<attribute>=<value>...]]"""
return self.__conf_object(cmd,*args)
def conf_location(self,cmd,*args):
"""usage: location <id> <rsc> {node_pref|rules}
node_pref :: <score>: <node>
rules ::
rule [id_spec] [$role=<role>] <score>: <expression>
[rule [id_spec] [$role=<role>] <score>: <expression> ...]
id_spec :: $id=<id> | $id-ref=<id>
score :: <number> | <attribute> | [-]inf
expression :: <simple_exp> [bool_op <simple_exp> ...]
bool_op :: or | and
simple_exp :: <attribute> [type:]<binary_op> <value>
| <unary_op> <attribute>
| date <date_expr>
type :: string | version | number
binary_op :: lt | gt | lte | gte | eq | ne
unary_op :: defined | not_defined"""
return self.__conf_object(cmd,*args)
def conf_colocation(self,cmd,*args):
"""usage: colocation <id> <score>: <rsc>[:<role>] <rsc>[:<role>]
"""
return self.__conf_object(cmd,*args)
def conf_order(self,cmd,*args):
"""usage: order <id> score-type: <first-rsc>[:<action>] <then-rsc>[:<action>]
[symmetrical=<bool>]"""
return self.__conf_object(cmd,*args)
def conf_property(self,cmd,*args):
"usage: property [$id=<set_id>] <option>=<value>"
return self.__conf_object(cmd,*args)
def conf_rsc_defaults(self,cmd,*args):
"usage: rsc_defaults [$id=<set_id>] <option>=<value>"
return self.__conf_object(cmd,*args)
def conf_op_defaults(self,cmd,*args):
"usage: op_defaults [$id=<set_id>] <option>=<value>"
return self.__conf_object(cmd,*args)
def conf_monitor(self,cmd,*args):
"usage: monitor <rsc>[:<role>] <interval>[:<timeout>]"
return self.__conf_object(cmd,*args)
def end_game(self, no_questions_asked = False):
if cib_factory.has_cib_changed():
if no_questions_asked or not options.interactive or \
ask("There are changes pending. Do you want to commit them?"):
self.commit("commit")
cib_factory.reset()
wcache.clear()
class TopLevel(UserInterface):
'''
The top level.
'''
crm_mon = "crm_mon -1"
status_opts = {
"bynode": "-n",
"inactive": "-r",
"ops": "-o",
"timing": "-t",
"failcounts": "-f",
}
help_table = odict()
help_table["."] = ("","""This is the CRM command line interface program.""")
help_table["cib"] = ("manage shadow CIBs", """
A shadow CIB is a regular cluster configuration which is kept in
a file. The CRM and the CRM tools may manage a shadow CIB in the
same way as the live CIB (i.e. the current cluster configuration).
A shadow CIB may be applied to the cluster in one step.
""")
help_table["resource"] = ("resources management", """
Everything related to resources management is available at this
level. Most commands are implemented using the crm_resource(8)
program.
""")
help_table["node"] = ("nodes management", """
A few node related tasks such as node standby are implemented
here.
""")
help_table["options"] = ("user preferences", """
Several user preferences are available. Note that it is possible
to save the preferences to a startup file.
""")
help_table["configure"] = ("CRM cluster configuration", """
The configuration level.
Note that you can change the working CIB at the cib level. It is
advisable to configure shadow CIBs and then commit them to the
cluster.
""")
help_table["ra"] = ("resource agents information center", """
This level contains commands which show various information about
the installed resource agents. It is available both at the top
level and at the `configure` level.
""")
help_table["status"] = ("show cluster status", """
Show cluster status. The status is displayed by crm_mon. Supply
additional arguments for more information or different format.
See crm_mon(8) for more details.
Usage:
...............
status [<option> ...]
option :: bynode | inactive | ops | timing | failcounts
...............
""")
help_table["quit"] = ("exit the program", "")
help_table["help"] = ("show help", "")
help_table["end"] = ("go back one level", "")
def __init__(self):
UserInterface.__init__(self)
self.cmd_table['cib'] = CibShadow
self.cmd_table['resource'] = RscMgmt
self.cmd_table['configure'] = CibConfig
self.cmd_table['node'] = NodeMgmt
self.cmd_table['options'] = CliOptions
self.cmd_table['status'] = (self.status,(0,5),0)
self.cmd_table['ra'] = RA
setup_aliases(self)
def status(self,cmd,*args):
"""usage: status [<option> ...]
option :: bynode | inactive | ops | timing | failcounts
"""
status_cmd = self.crm_mon
for par in args:
if par in self.status_opts:
status_cmd = "%s %s" % (status_cmd, self.status_opts[par])
else:
syntax_err((cmd,par), context = 'status')
return False
return ext_cmd(status_cmd) == 0
class CompletionHelp(object):
'''
Print some help on whatever last word in the line.
'''
timeout = 60 # don't print again and again
def __init__(self):
self.laststamp = 0
self.lastitem = ''
def help(self,f,*args):
words = readline.get_line_buffer().split()
if not words:
return
key = words[-1]
if key.endswith('='):
key = key[0:-1]
if self.lastitem == key and \
time.time() - self.laststamp < self.timeout:
return
help_s = f(key,*args)
if help_s:
print "\n%s" % help_s
print "%s%s" % (vars.prompt,readline.get_line_buffer()),
self.laststamp = time.time()
self.lastitem = key
def attr_cmds(idx,delimiter = False):
if delimiter:
return ' '
return ["delete","set","show"]
def listnodes():
if wcache.is_cached("listnodes"):
return wcache.retrieve("listnodes")
nodes = []
doc = cibdump2doc("nodes")
if not doc:
return []
nodes_node = get_conf_elem(doc, "nodes")
if not nodes_node:
return []
for c in nodes_node.childNodes:
if not is_element(c):
continue
if c.tagName != "node":
continue
if c.getAttribute("type") == 'normal':
nodes.append(c.getAttribute("uname"))
return wcache.store("node_list",nodes)
def nodes_list(idx,delimiter = False):
if delimiter:
return ' '
return listnodes()
def shadows_list(idx,delimiter = False):
if delimiter:
return ' '
return listshadows()
def templates_list(idx,delimiter = False):
if delimiter:
return ' '
return listtemplates()
def config_list(idx,delimiter = False):
if delimiter:
return ' '
return listconfigs()
def config_list_method(idx,delimiter = False):
if delimiter:
return ' '
return listconfigs() + ["replace","update"]
def shadows_live_list(idx,delimiter = False):
if delimiter:
return ' '
return listshadows() + ['live']
def rsc_list(idx,delimiter = False):
if delimiter:
return ' '
doc = resources_xml()
if not doc:
return []
nodes = get_interesting_nodes(doc,[])
return [x.getAttribute("id") for x in nodes if is_resource(x)]
def null_list(idx,delimiter = False):
if delimiter:
return ' '
return []
def loop(idx,delimiter = False):
"just a marker in a list"
pass
def id_xml_list(idx,delimiter = False):
if delimiter:
return ' '
return cib_factory.id_list() + ['xml','changed']
def id_list(idx,delimiter = False):
if delimiter:
return ' '
return cib_factory.id_list()
def f_prim_id_list(idx,delimiter = False):
if delimiter:
return ' '
return cib_factory.f_prim_id_list()
def f_children_id_list(idx,delimiter = False):
if delimiter:
return ' '
return cib_factory.f_children_id_list()
def rsc_id_list(idx,delimiter = False):
if delimiter:
return ' '
return cib_factory.rsc_id_list()
def status_node_list(idx,delimiter = False):
if delimiter:
return ' '
return cib_status.status_node_list()
def status_rsc_list(idx,delimiter = False):
if delimiter:
return ' '
return cib_status.status_rsc_list()
def node_states_list(idx,delimiter = False):
if delimiter:
return ' '
return vars.node_states
def ra_operations_list(idx,delimiter = False):
if delimiter:
return ' '
return vars.ra_operations
def lrm_exit_codes_list(idx,delimiter = False):
if delimiter:
return ' '
return vars.lrm_exit_codes.keys()
def lrm_status_codes_list(idx,delimiter = False):
if delimiter:
return ' '
return vars.lrm_status_codes.keys()
def skills_list(idx,delimiter = False):
if delimiter:
return ' '
return user_prefs.skill_levels.keys()
def ra_classes_list(idx,delimiter = False):
if delimiter:
return ':'
return ra_classes()
def get_primitive_type(words):
try:
idx = words.index("primitive") + 2
type_word = words[idx]
except: type_word = ''
return type_word
def ra_type_list(toks,idx,delimiter):
if idx == 2:
if toks[0] == "ocf":
dchar = ':'
l = ra_providers_all()
else:
dchar = ' '
l = ra_types(toks[0])
elif idx == 3:
dchar = ' '
if toks[0] == "ocf":
l = ra_types(toks[0],toks[1])
else:
l = ra_types(toks[0])
if delimiter:
return dchar
return l
def prim_meta_attr_list():
return vars.meta_attributes
def op_attr_list():
return vars.op_attributes
def operations_list():
return vars.op_cli_names
def prim_complete_meta(ra,delimiter):
if delimiter:
return '='
return prim_meta_attr_list()
def prim_complete_op(ra,delimiter):
words = split_buffer()
if (readline.get_line_buffer()[-1] == ' ' and words[-1] == "op") \
or (readline.get_line_buffer()[-1] != ' ' and words[-2] == "op"):
dchar = ' '
l = operations_list()
else:
if readline.get_line_buffer()[-1] == '=':
dchar = ' '
l = []
else:
dchar = '='
l = op_attr_list()
if delimiter:
return dchar
return l
def prim_complete_params(ra,delimiter):
if readline.get_line_buffer()[-1] == '=':
dchar = ' '
l = []
else:
dchar = '='
l = ra.params().keys()
if delimiter:
return dchar
return l
def prim_params_info(key,ra):
return ra.meta_parameter(key)
def meta_attr_info(key,ra):
pass
def op_attr_info(key,ra):
pass
def get_lastkeyw(words,keyw):
revwords = copy.copy(words)
revwords.reverse()
for w in revwords:
if w in keyw:
return w
def primitive_complete_complex(idx,delimiter = False):
'''
This completer depends on the content of the line, i.e. on
previous tokens, in particular on the type of the RA.
'''
completers_set = {
"params": (prim_complete_params, prim_params_info),
"meta": (prim_complete_meta, meta_attr_info),
"op": (prim_complete_op, op_attr_info),
}
# manage the resource type
words = readline.get_line_buffer().split()
type_word = get_primitive_type(words)
toks = type_word.split(':')
if toks[0] != "ocf":
idx += 1
if idx in (2,3):
return ra_type_list(toks,idx,delimiter)
# create an ra object
ra = None
ra_class,provider,rsc_type = disambiguate_ra_type(type_word)
if ra_type_validate(type_word,ra_class,provider,rsc_type):
ra = RAInfo(ra_class,rsc_type,provider)
keywords = completers_set.keys()
if idx == 4:
if delimiter:
return ' '
return keywords
lastkeyw = get_lastkeyw(words,keywords)
if '=' in words[-1] and readline.get_line_buffer()[-1] != ' ':
if not delimiter and lastkeyw and \
readline.get_line_buffer()[-1] == '=' and len(words[-1]) > 1:
compl_help.help(completers_set[lastkeyw][1],ra)
if delimiter:
return ' '
return ['*']
else:
if lastkeyw:
return completers_set[lastkeyw][0](ra,delimiter)
def property_complete(idx,delimiter = False):
'''
This completer depends on the content of the line, i.e. on
previous tokens.
'''
if not vars.pe_metadata:
vars.pe_metadata = RAInfo("pengine","metadata")
words = readline.get_line_buffer().split()
if '=' in words[-1] and readline.get_line_buffer()[-1] != ' ':
if not delimiter and \
readline.get_line_buffer()[-1] == '=' and len(words[-1]) > 1:
compl_help.help(prim_params_info,vars.pe_metadata)
if delimiter:
return ' '
return ['*']
else:
return prim_complete_params(vars.pe_metadata,delimiter)
def lookup_dynamic(fun_list,idx,f_idx,words):
if not fun_list:
return []
if fun_list[f_idx] == loop:
f_idx -= 1
f = fun_list[f_idx]
w = words[0]
wordlist = f(idx)
delimiter = f(idx,1)
if len(wordlist) == 1 and wordlist[0] == '*':
return lookup_dynamic(fun_list,idx+1,f_idx+1,words[1:])
elif len(words) == 1:
return [x+delimiter for x in wordlist if x.startswith(w)]
return lookup_dynamic(fun_list,idx+1,f_idx+1,words[1:])
def lookup_words(ctab,words):
if not ctab:
return []
if type(ctab) == type(()):
return lookup_dynamic(ctab,0,0,words)
if len(words) == 1:
return [x+' ' for x in ctab if x.startswith(words[0])]
elif words[0] in ctab.keys():
return lookup_words(ctab[words[0]],words[1:])
return []
def split_buffer():
p = readline.get_line_buffer()
p = p.replace(':',' ').replace('=',' ')
return p.split()
def completer(txt,state):
words = split_buffer()
if readline.get_begidx() == readline.get_endidx():
words.append('')
matched = lookup_words(levels.completion_tab,words)
matched.append(None)
return matched[state]
help_sys = HelpSystem()
compl_help = CompletionHelp()
user_prefs = UserPrefs.getInstance()
options = Options.getInstance()
err_buf = ErrorBuffer.getInstance()
vars = Vars.getInstance()
wcache = WCache.getInstance()
levels = Levels.getInstance(TopLevel)
cib_status = CibStatus.getInstance()
cib_factory = CibFactory.getInstance()
# vim:ts=4:sw=4:et:
diff --git a/shell/modules/vars.py.in b/shell/modules/vars.py.in
index 8a8a9c9ef0..5f2d54f75e 100644
--- a/shell/modules/vars.py.in
+++ b/shell/modules/vars.py.in
@@ -1,113 +1,113 @@
# 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 utils import olist
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")
+ nvpairs_tags = ("meta_attributes", "instance_attributes", "utilization")
defaults_tags = ("rsc_defaults","op_defaults")
resource_cli_names = olist(["primitive","group","clone","ms","master"])
constraint_cli_names = olist(["location","colocation","collocation","order"])
nvset_cli_names = olist(["property","rsc_defaults","op_defaults"])
op_cli_names = olist(["monitor", "start", "stop", "migrate_to", "migrate_from","promote","demote","notify"])
ra_operations = ("probe", "monitor", "start", "stop",
"promote", "demote", "notify", "migrate_to", "migrate_from")
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 = olist(["name", "id"])
op_attributes = olist([\
"interval", "timeout", "requires", "enabled", "role", \
"on-fail", "start-delay", "allow-migrate", "interval-origin", \
"record-pending", "description", \
])
meta_attributes = (\
"allow-migrate", "globally-unique", "is-managed", \
"migration-threshold", "priority", "multiple-active", \
"failure-timeout", "resource-stickiness", "target-role", \
)
score_types = {'advisory': '0','mandatory': 'INFINITY'}
boolean_ops = olist(['or','and'])
binary_ops = olist(['lt','gt','lte','gte','eq','ne'])
binary_types = ('string' , 'version' , 'number')
unary_ops = olist(['defined','not_defined'])
simple_date_ops = olist(['lt','gt'])
date_ops = olist(['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"
+ node_attributes_keyw = olist(["attributes","utilization"])
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"
ra_if = None # class interface to RA
stonithd_metadata = None # stonithd meta data
pe_metadata = None # PE meta data
# vim:ts=4:sw=4:et:
diff --git a/shell/modules/xmlutil.py b/shell/modules/xmlutil.py
index 59408aa31d..8467f1b365 100644
--- a/shell/modules/xmlutil.py
+++ b/shell/modules/xmlutil.py
@@ -1,401 +1,402 @@
# 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 cache import WCache
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
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 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():
if wcache.is_cached("rsc_xml"):
return wcache.retrieve("rsc_xml")
doc = cibdump2doc("resources")
if not doc:
return []
return wcache.store("rsc_xml",doc)
def rsc2node(id):
if wcache.is_cached("rsc_%s_node" % id):
return wcache.retrieve("rsc_%s_node" % id)
doc = resources_xml()
if not doc:
return []
nodes = get_interesting_nodes(doc,[])
for n in nodes:
if is_resource(n) and n.getAttribute("id") == id:
return wcache.store("rsc_%s_node" % id, 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_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 ""
def get_max_clone(id):
v = get_meta_param(id,"clone-max")
try:
cnt = int(v)
except:
cnt = len(listnodes())
return cnt
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": (),
+ "utilization": (),
"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"),oldnode.tagName,oldnode.getAttribute("id")
if not oldnode:
return None
try:
attr_list = match_list[node.tagName]
except KeyError:
attr_list = []
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 nvpairs2list(node, add_id = False):
'''
Convert nvpairs to a list of pairs.
The id attribute is normally skipped, since they tend to be
long and therefore obscure the relevant content. For some
elements, however, they are included (e.g. properties).
'''
pl = []
# if there's id-ref, there can be then _only_ id-ref
value = node.getAttribute("id-ref")
if value:
pl.append(["$id-ref",value])
return pl
if add_id or \
(not node.childNodes and len(node.attributes) == 1):
value = node.getAttribute("id")
if value:
pl.append(["$id",value])
for c in node.childNodes:
if not is_element(c):
continue
if c.tagName == "attributes":
pl = nvpairs2list(c)
name = c.getAttribute("name")
if "value" in c.attributes.keys():
value = c.getAttribute("value")
else:
value = None
pl.append([name,value])
return pl
vars = Vars.getInstance()
wcache = WCache.getInstance()
# vim:ts=4:sw=4:et: