diff --git a/shell/modules/cibconfig.py b/shell/modules/cibconfig.py index 842d0dae77..34367cbd9e 100644 --- a/shell/modules/cibconfig.py +++ b/shell/modules/cibconfig.py @@ -1,2368 +1,2355 @@ # Copyright (C) 2008 Dejan Muhamedagic # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This software is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # import sys import subprocess import copy import xml.dom.minidom import re from singletonmixin import Singleton from userprefs import Options, UserPrefs from vars import Vars from cliformat import * from utils import * from xmlutil import * from msg import * from parse import CliParser from clidisplay import CliDisplay from cibstatus import CibStatus from idmgmt import IdMgmt -from ra import RAInfo +from ra import RAInfo, get_properties_list, get_pe_meta 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" % topnode.tagName) continue for c in topnode.childNodes: if not is_element(c): continue if not c.tagName in cib_object_map: common_warn("unrecognized CIB element %s" % c.tagName) # # object sets (enables operations on sets of elements) # def mkset_obj(*args): if args and args[0] == "xml": obj = lambda: CibObjectSetRaw(*args[1:]) else: obj = lambda: CibObjectSetCli(*args) return obj() class CibObjectSet(object): ''' Edit or display a set of cib objects. repr() for objects representation and save() used to store objects into internal structures are defined in subclasses. ''' def __init__(self, *args): self.obj_list = [] def _open_url(self,src): import urllib try: return urllib.urlopen(src) except: pass if src == "-": return sys.stdin try: return open(src) except: pass common_err("could not open %s" % src) return False def init_aux_lists(self): ''' Before edit, initialize two auxiliary lists which will hold a list of objects to be removed and a list of objects which were created. Then, we can create a new object list which will match the current state of affairs, i.e. the object set after the last edit. ''' self.remove_objs = copy.copy(self.obj_list) self.add_objs = [] def recreate_obj_list(self): ''' Recreate obj_list: remove deleted objects and add created objects ''' for obj in self.remove_objs: self.obj_list.remove(obj) self.obj_list += self.add_objs rmlist = [] for obj in self.obj_list: if obj.invalid: rmlist.append(obj) for obj in rmlist: self.obj_list.remove(obj) def edit_save(self,s,erase = False): ''' Save string s to a tmp file. Invoke editor to edit it. Parse/save the resulting file. In case of syntax error, allow user to reedit. If erase is True, erase the CIB first. If no changes are done, return silently. ''' tmp = str2tmp(s) if not tmp: return False filehash = hash(s) rc = False while True: if edit_file(tmp) != 0: break try: f = open(tmp,'r') except IOError, msg: common_err(msg) break s = ''.join(f) f.close() if hash(s) == filehash: # file unchanged rc = True break if erase: cib_factory.erase() if not self.save(s): if ask("Do you want to edit again?"): continue rc = True break try: os.unlink(tmp) except: pass return rc def edit(self): if options.batch: common_info("edit not allowed in batch mode") return False cli_display.set_no_pretty() s = self.repr() cli_display.reset_no_pretty() return self.edit_save(s) def filter_save(self,filter,s): ''' Pipe string s through a filter. Parse/save the output. If no changes are done, return silently. ''' rc,outp = filter_string(filter,s) if rc != 0: return False if hash(outp) == hash(s): return True return self.save(outp) def filter(self,filter): cli_display.set_no_pretty() s = self.repr(format = -1) cli_display.reset_no_pretty() return self.filter_save(filter,s) def save_to_file(self,fname): if fname == "-": f = sys.stdout else: if not options.batch and os.access(fname,os.F_OK): if not ask("File %s exists. Do you want to overwrite it?"%fname): return False try: f = open(fname,"w") except IOError, msg: common_err(msg) return False rc = True cli_display.set_no_pretty() s = self.repr() cli_display.reset_no_pretty() if s: f.write(s) f.write('\n') elif self.obj_list: rc = False if f != sys.stdout: f.close() return rc def show(self): s = self.repr() if not s: if self.obj_list: # objects could not be displayed return False else: return True page_string(s) def import_file(self,method,fname): if not cib_factory.is_cib_sane(): return False if method == "replace": if options.interactive and cib_factory.has_cib_changed(): if not ask("This operation will erase all changes. Do you want to proceed?"): return False cib_factory.erase() f = self._open_url(fname) if not f: return False s = ''.join(f) if f != sys.stdin: f.close() return self.save(s, method == "update") def repr(self): ''' Return a string with objects's representations (either CLI or XML). ''' return '' def save(self, s, update = False): ''' For each object: - try to find a corresponding object in obj_list - if (update and not found) or found: replace the object in the obj_list with the new object - if not found: create new See below for specific implementations. ''' pass def semantic_check(self): ''' Test objects for sanity. This is about semantics. ''' rc = 0 for obj in self.obj_list: rc |= obj.check_sanity() return rc def lookup_cli(self,cli_list): for obj in self.obj_list: if obj.matchcli(cli_list): return obj def lookup(self,xml_obj_type,obj_id): for obj in self.obj_list: if obj.match(xml_obj_type,obj_id): return obj def drop_remaining(self): 'Any remaining objects in obj_list are deleted.' l = [x.obj_id for x in self.remove_objs] return cib_factory.delete(*l) def get_comments(cli_list): if not cli_list: return [] last = cli_list[len(cli_list)-1] try: if last[0] == "comments": cli_list.pop() return last[1] except: pass return [] class CibObjectSetCli(CibObjectSet): ''' Edit or display a set of cib objects (using cli notation). ''' def __init__(self, *args): CibObjectSet.__init__(self, *args) self.obj_list = cib_factory.mkobj_list("cli",*args) def repr(self, format = 1): "Return a string containing cli format of all objects." if not self.obj_list: return '' return '\n'.join(obj.repr_cli(format = format) \ for obj in processing_sort_cli(self.obj_list)) def process(self, cli_list, update = False): ''' Create new objects or update existing ones. ''' myobj = obj = self.lookup_cli(cli_list) if update and not obj: obj = cib_factory.find_object_for_cli(cli_list) if obj: rc = cib_factory.update_from_cli(obj,cli_list,update) != False if myobj: self.remove_objs.remove(myobj) else: obj = cib_factory.create_from_cli(cli_list) rc = obj != None if rc: self.add_objs.append(obj) return rc def save(self, s, update = False): ''' Save a user supplied cli format configuration. On errors user is typically asked to review the configuration (for instance on editting). On syntax error (return code 1), no changes are done, but on semantic errors (return code 2), some changes did take place so object list must be updated properly. Finally, once syntax check passed, there's no way back, all changes are applied to the current configuration. TODO: Implement undo configuration changes. ''' l = [] id_list = [] 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: id = find_value(cli_list[0][1],"id") if id: if id in id_list: common_err("duplicate element %s" % id) rc = False id_list.append(id) l.append(cli_list) elif cli_list == False: rc = False err_buf.stop_tmp_lineno() # we can't proceed if there was a syntax error, but we # can ask the user to fix problems if not rc: return rc self.init_aux_lists() if l: for cli_list in processing_sort_cli(l): if self.process(cli_list,update) == False: rc = False if not self.drop_remaining(): # this is tricky, we don't know what was removed! # it could happen that the user dropped a resource # which was running and therefore couldn't be removed rc = False self.recreate_obj_list() return rc cib_verify = "crm_verify -V -p" class CibObjectSetRaw(CibObjectSet): ''' Edit or display one or more CIB objects (XML). ''' actions_filter = "grep LogActions: | grep -vw Leave" def __init__(self, *args): CibObjectSet.__init__(self, *args) self.obj_list = cib_factory.mkobj_list("xml",*args) def repr(self, format = "ignored"): "Return a string containing xml of all objects." doc = cib_factory.objlist2doc(self.obj_list) s = doc.toprettyxml(user_prefs.xmlindent) doc.unlink() return s def repr_configure(self): ''' Return a string containing xml of configure and its children. ''' doc = cib_factory.objlist2doc(self.obj_list) conf_node = doc.getElementsByTagName("configuration")[0] s = conf_node.toprettyxml(user_prefs.xmlindent) doc.unlink() return s def process(self, node, update = False): if not cib_factory.is_cib_sane(): return False myobj = obj = self.lookup(node.tagName,node.getAttribute("id")) if update and not obj: obj = cib_factory.find_object_for_node(node) if obj: rc = cib_factory.update_from_node(obj,node) if myobj: self.remove_objs.remove(obj) else: new_obj = cib_factory.create_from_node(node) rc = new_obj != None if rc: self.add_objs.append(new_obj) return rc def save(self, s, update = False): try: doc = xml.dom.minidom.parseString(s) except xml.parsers.expat.ExpatError,msg: cib_parse_err(msg,s) return False rc = True sanitize_cib(doc) show_unrecognized_elems(doc) newnodes = get_interesting_nodes(doc,[]) self.init_aux_lists() if newnodes: for node in processing_sort(newnodes): if not self.process(node,update): rc = False if not self.drop_remaining(): rc = False doc.unlink() self.recreate_obj_list() return rc def verify(self): if not self.obj_list: return True cli_display.set_no_pretty() rc = pipe_string(cib_verify,self.repr(format = -1)) cli_display.reset_no_pretty() return rc in (0,1) def ptest(self, nograph, scores, utilization, actions, verbosity): if not cib_factory.is_cib_sane(): return False if verbosity: if actions: verbosity = 'v' * max(3,len(verbosity)) ptest = "ptest -X -%s" % verbosity.upper() if scores: ptest = "%s -s" % ptest if utilization: ptest = "%s -U" % ptest if user_prefs.dotty and not nograph: fd,dotfile = mkstemp() ptest = "%s -D %s" % (ptest,dotfile) else: dotfile = 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)) # ptest prints to stderr if actions: ptest = "%s 2>&1 | %s | %s" % \ (ptest, self.actions_filter, user_prefs.pager) else: ptest = "%s 2>&1 | %s" % (ptest, user_prefs.pager) pipe_string(ptest,doc.toprettyxml()) doc.unlink() if dotfile: show_dot_graph(dotfile) vars.tmpfiles.append(dotfile) else: if not nograph: common_info("install graphviz to see a transition graph") return True # # XML generate utilities # def set_id(node,oldnode,id_hint,id_required = True): ''' Set the id attribute for the node. Procedure: - if the node already contains "id", keep it - if the old node contains "id", copy that - if neither is true, then create a new one using id_hint (exception: if not id_required, then no new id is generated) Finally, save the new id in id_store. ''' old_id = None new_id = node.getAttribute("id") if oldnode and oldnode.getAttribute("id"): old_id = oldnode.getAttribute("id") if not new_id: new_id = old_id if not new_id: if id_required: new_id = id_store.new(node,id_hint) else: id_store.save(new_id) if new_id: node.setAttribute("id",new_id) if oldnode and old_id == new_id: set_id_used_attr(oldnode) def mkxmlsimple(e,oldnode,id_hint): ''' Create an xml node from the (name,dict) pair. The name is the name of the element. The dict contains a set of attributes. ''' node = cib_factory.createElement(e[0]) for n,v in e[1]: if n == "$children": # this one's skipped continue if n == "operation": v = v.lower() if n.startswith('$'): n = n.lstrip('$') if (type(v) != type('') and type(v) != type(u'')) \ or v: # skip empty strings node.setAttribute(n,v) id_ref = node.getAttribute("id-ref") if id_ref: id_ref_2 = cib_factory.resolve_id_ref(e[0],id_ref) node.setAttribute("id-ref",id_ref_2) else: set_id(node,lookup_node(node,oldnode),id_hint) return node def mkxmlnvpairs(e,oldnode,id_hint): ''' Create xml from the (name,dict) pair. The name is the name of the element. The dict contains a set of nvpairs. Stuff such as instance_attributes. NB: Other tags not containing nvpairs are fine if the dict is empty. ''' xml_node_type = e[0] in vars.defaults_tags and "meta_attributes" or e[0] node = cib_factory.createElement(xml_node_type) # another exception: # cluster_property_set has nvpairs as direct children # in that case the id_hint is equal id # and this is important in case there are multiple sets if e[0] == "cluster_property_set" and id_hint: node.setAttribute("id",id_hint) 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]) elif e[0] in vars.nvset_cli_names: node.setAttribute("id",id_hint) else: if e[0] == "operations": # operations don't need no id set_id(node,match_node,id_hint,id_required = False) else: set_id(node,match_node,id_hint) try: subpfx = vars.subpfx_list[e[0]] except: subpfx = '' subpfx = subpfx and "%s_%s" % (id_hint,subpfx) or id_hint nvpair_pfx = node.getAttribute("id") or subpfx for n,v in e[1]: nvpair = cib_factory.createElement("nvpair") node.appendChild(nvpair) nvpair.setAttribute("name",n) if v != None: nvpair.setAttribute("value",v) set_id(nvpair,lookup_node(nvpair,match_node),nvpair_pfx) return node def mkxmlop(e,oldnode,id_hint): ''' Create an operation xml from the (name,dict) pair. ''' node = cib_factory.createElement(e[0]) inst_attr = [] for n,v in e[1]: if n in olist(vars.req_op_attributes + vars.op_attributes): node.setAttribute(n,v) else: inst_attr.append([n,v]) tmp = cib_factory.createElement("operations") oldops = lookup_node(tmp,oldnode) # first find old operations oldop = lookup_node(node,oldops) set_id(node,oldop,id_hint) if inst_attr: e = ["instance_attributes",inst_attr] nia = mkxmlnvpairs(e,oldop,node.getAttribute("id")) node.appendChild(nia) return node def mkxmldate(e,oldnode,id_hint): ''' Create a date_expression xml from the (name,dict) pair. ''' node = cib_factory.createElement(e[0]) operation = find_value(e[1],"operation").lower() node.setAttribute("operation", operation) old_date = lookup_node(node,oldnode) # first find old date element set_id(node,old_date,id_hint) date_spec_attr = [] for n,v in e[1]: if n in olist(vars.date_ops) or n == "operation": continue elif n in vars.in_range_attrs: node.setAttribute(n,v) else: date_spec_attr.append([n,v]) if not date_spec_attr: return node elem = operation == "date_spec" and "date_spec" or "duration" tmp = cib_factory.createElement(elem) old_date_spec = lookup_node(tmp,old_date) # first find old date element set_id(tmp,old_date_spec,id_hint) for n,v in date_spec_attr: tmp.setAttribute(n,v) node.appendChild(tmp) return node def mkxmlrsc_set(e,oldnode,id_hint): ''' Create a resource_set xml from the (name,dict) pair. ''' node = cib_factory.createElement(e[0]) old_rsc_set = lookup_node(node,oldnode) # first find old date element set_id(node,old_rsc_set,id_hint) for ref in e[1]: if ref[0] == "resource_ref": ref_node = cib_factory.createElement(ref[0]) ref_node.setAttribute(ref[1][0],ref[1][1]) node.appendChild(ref_node) elif ref[0] in ("sequential", "action", "role"): node.setAttribute(ref[0], ref[1]) return node conv_list = { "params": "instance_attributes", "meta": "meta_attributes", "property": "cluster_property_set", "rsc_defaults": "rsc_defaults", "op_defaults": "op_defaults", "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","rsc_defaults","op_defaults","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 set_nvpair(set_node,name,value): n_id = set_node.getAttribute("id") for c in set_node.childNodes: if is_element(c) and c.getAttribute("name") == name: c.setAttribute("value",value) return np = cib_factory.createElement("nvpair") np.setAttribute("name",name) np.setAttribute("value",value) new_id = id_store.new(np,n_id) np.setAttribute("id",new_id) set_node.appendChild(np) # # cib element classes (CibObject the parent class) # class CibObject(object): ''' The top level object of the CIB. Resources and constraints. ''' state_fmt = "%16s %-8s%-8s%-8s%-8s%-8s%-4s" set_names = {} def __init__(self,xml_obj_type,obj_id = None): if not xml_obj_type in cib_object_map: unsupported_err(xml_obj_type) return self.obj_type = cib_object_map[xml_obj_type][0] self.parent_type = cib_object_map[xml_obj_type][2] self.xml_obj_type = xml_obj_type self.origin = "" # where did it originally come from? self.nocli = False # we don't support this one self.nocli_warn = True # don't issue warnings all the time self.updated = False # was the object updated self.invalid = False # the object has been invalidated (removed) self.moved = False # the object has been moved (from/to a container) self.recreate = False # constraints to be recreated self.parent = None # object superior (group/clone/ms) self.children = [] # objects inferior if obj_id: if not self.mknode(obj_id): self = None # won't do :( else: self.obj_id = None self.node = None def dump_state(self): 'Print object status' print self.state_fmt % \ (self.obj_id,self.origin,self.updated,self.moved,self.invalid, \ self.parent and self.parent.obj_id or "", \ len(self.children)) def repr_cli_xml(self,node,format): h = cli_display.keyword("xml") l = node.toprettyxml('\t').split('\n') l = [x for x in l if x] # drop empty lines if format > 0: return "%s %s" % (h,' \\\n'.join(l)) else: return "%s %s" % (h,''.join(l)) def repr_cli(self,node = None,format = 1): ''' CLI representation for the node. repr_cli_head and repr_cli_child in subclasess. ''' if not node: node = self.node if self.nocli: return self.repr_cli_xml(node,format) l = [] head_s = self.repr_cli_head(node) if not head_s: # everybody must have a head return None comments = [] l.append(head_s) cli_add_description(node,l) for c in node.childNodes: if is_comment(c): comments.append(c.data) continue if not is_element(c): continue s = self.repr_cli_child(c,format) if s: l.append(s) return self.cli_format(l,comments,format) def repr_cli_child(self,c,format): if c.tagName in self.set_names: return "%s %s" % \ (cli_display.keyword(self.set_names[c.tagName]), \ cli_pairs(nvpairs2list(c))) def cli2node(self,cli,oldnode = None): ''' Convert CLI representation to a DOM node. Defined in subclasses. ''' cli_list = mk_cli_list(cli) if not cli_list: return None if not oldnode: if self.obj_type == "property": oldnode = cib_factory.topnode[cib_object_map[self.xml_obj_type][2]] else: oldnode = self.node comments = get_comments(cli_list) node = self.cli_list2node(cli_list,oldnode) if comments and node: stuff_comments(node,comments) return node def cli_format(self,l,comments,format): ''' Format and add comment (if any). ''' s = cli_format(l,format) cs = '\n'.join(comments) return (comments and format >=0) and '\n'.join([cs,s]) or s def move_comments(self): ''' Move comments to the top of the node. ''' l = [] firstelem = None for n in self.node.childNodes: if is_comment(n): if firstelem: l.append(n) else: if not firstelem and is_element(n): firstelem = n for comm_node in l: common_debug("move comm %s" % comm_node.toprettyxml()) self.node.insertBefore(comm_node, firstelem) common_debug("obj %s node: %s" % (self.obj_id,self.node.toprettyxml())) def mknode(self,obj_id): if not cib_factory.is_cib_sane(): return False if id_store.id_in_use(obj_id): return False if self.xml_obj_type in vars.defaults_tags: tag = "meta_attributes" else: tag = self.xml_obj_type self.node = cib_factory.createElement(tag) self.obj_id = obj_id self.node.setAttribute("id",self.obj_id) self.origin = "user" return True def 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 = 0) cli_display.reset_no_pretty() if not cli_text: return False common_debug("clitext: %s" % cli_text) xml2 = self.cli2node(cli_text) if not xml2: return False rc = xml_cmp(self.node, xml2, show = True) xml2.unlink() return rc def check_sanity(self): ''' Right now, this is only for primitives. And groups/clones/ms and cluster properties. ''' return 0 def matchcli(self,cli_list): head = cli_list[0] return self.obj_type == head[0] \ and self.obj_id == find_value(head[1],"id") def match(self,xml_obj_type,obj_id): return self.xml_obj_type == xml_obj_type and self.obj_id == obj_id def obj_string(self): return "%s:%s" % (self.obj_type,self.obj_id) def reset_updated(self): self.updated = False self.moved = False self.recreate = False for child in self.children: child.reset_updated() def propagate_updated(self): if self.parent: self.parent.updated = self.updated self.parent.propagate_updated() def top_parent(self): '''Return the top parent or self''' if self.parent: return self.parent.top_parent() else: return self def find_child_in_node(self,child): for c in self.node.childNodes: if not is_element(c): continue if c.tagName == child.obj_type and \ c.getAttribute("id") == child.obj_id: return c return None def filter(self,*args): "Filter objects." if not args: return True if args[0] == "NOOBJ": return False if args[0] == "changed": return self.updated or self.origin == "user" if args[0].startswith("type:"): return self.obj_type == args[0][5:] 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''): cp = CliParser() # what follows looks strange, but the last string actually matters # the previous ones may be comments and are collected by the parser for s in lines2cli(cli): cli_list = cp.parse(s) return cli_list else: return cli class CibNode(CibObject): ''' Node and node's attributes. ''' set_names = { "instance_attributes": "attributes", "utilization": "utilization", } def repr_cli_head(self,node): obj_type = vars.cib_cli_map[node.tagName] node_id = node.getAttribute("id") uname = node.getAttribute("uname") s = cli_display.keyword(obj_type) if node_id != uname: s = '%s $id="%s"' % (s, node_id) s = '%s %s' % (s, cli_display.id(uname)) type = node.getAttribute("type") if type != vars.node_default_type: s = '%s:%s' % (s, type) return s def cli_list2node(self,cli_list,oldnode): head = copy.copy(cli_list[0]) head[0] = backtrans[head[0]] obj_id = find_value(head[1],"$id") if not obj_id: obj_id = find_value(head[1],"uname") if not obj_id: return None type = find_value(head[1],"type") if not type: type = vars.node_default_type head[1].append(["type",type]) headnode = mkxmlsimple(head,cib_factory.topnode[cib_object_map[self.xml_obj_type][2]],'node') id_hint = headnode.getAttribute("uname") 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 def get_ra(node): ra_type = node.getAttribute("type") ra_class = node.getAttribute("class") ra_provider = node.getAttribute("provider") return RAInfo(ra_class,ra_type,ra_provider) class CibPrimitive(CibObject): ''' Primitives. ''' set_names = { "instance_attributes": "params", "meta_attributes": "meta", "utilization": "utilization", } def repr_cli_head(self,node): obj_type = vars.cib_cli_map[node.tagName] node_id = node.getAttribute("id") ra_type = node.getAttribute("type") ra_class = node.getAttribute("class") ra_provider = node.getAttribute("provider") s1 = s2 = '' if ra_class: s1 = "%s:"%ra_class if ra_provider: s2 = "%s:"%ra_provider s = cli_display.keyword(obj_type) id = cli_display.id(node_id) return "%s %s %s" % (s, id, ''.join((s1,s2,ra_type))) def repr_cli_child(self,c,format): if c.tagName in self.set_names: return "%s %s" % \ (cli_display.keyword(self.set_names[c.tagName]), \ cli_pairs(nvpairs2list(c))) elif c.tagName == "operations": return cli_operations(c,format) def cli_list2node(self,cli_list,oldnode): ''' Convert a CLI description to DOM node. Try to preserve as many ids as possible in case there's an old XML version. ''' head = copy.copy(cli_list[0]) head[0] = backtrans[head[0]] headnode = mkxmlsimple(head,oldnode,'rsc') id_hint = headnode.getAttribute("id") operations = None for e in cli_list[1:]: n = mkxmlnode(e,oldnode,id_hint) if keyword_cmp(e[0], "operations"): operations = n if not keyword_cmp(e[0], "op"): headnode.appendChild(n) else: if not operations: operations = mkxmlnode(["operations",{}],oldnode,id_hint) headnode.appendChild(operations) operations.appendChild(n) remove_id_used_attributes(oldnode) return headnode def add_operation(self,cli_list): # check if there is already an op with the same interval comments = get_comments(cli_list) head = copy.copy(cli_list[0]) name = find_value(head[1], "name") interval = find_value(head[1], "interval") if find_operation(self.node,name,interval): common_err("%s already has a %s op with interval %s" % \ (self.obj_id, name, interval)) return None # drop the rsc attribute head[1].remove(["rsc",self.obj_id]) # create an xml node mon_node = mkxmlsimple(head, None, self.obj_id) # get the place to append it to try: op_node = self.node.getElementsByTagName("operations")[0] except: op_node = cib_factory.createElement("operations") self.node.appendChild(op_node) op_node.appendChild(mon_node) if comments and self.node: stuff_comments(self.node,comments) # the resource is updated self.updated = True self.propagate_updated() return self def check_sanity(self): ''' Check operation timeouts and if all required parameters are defined. ''' if not self.node: # eh? common_err("%s: no xml (strange)" % self.obj_id) return user_prefs.get_check_rc() rc3 = sanity_check_meta(self.obj_id,self.node,vars.rsc_meta_attributes) ra = get_ra(self.node) if not ra.mk_ra_node(): # no RA found? if cib_factory.is_asymm_cluster(): return rc3 ra.error("no such resource agent") return user_prefs.get_check_rc() params = [] for c in self.node.childNodes: if not is_element(c): continue if c.tagName == "instance_attributes": params += nvpairs2list(c) rc1 = ra.sanity_check_params(self.obj_id, params) actions = {} for c in self.node.childNodes: if not is_element(c): continue if c.tagName == "operations": for c2 in c.childNodes: if is_element(c2) and c2.tagName == "op": op,pl = op2list(c2) if op: actions[op] = pl default_timeout = get_default_timeout() rc2 = ra.sanity_check_ops(self.obj_id, actions, default_timeout) return rc1 | rc2 | rc3 class CibContainer(CibObject): ''' Groups and clones and ms. ''' set_names = { "instance_attributes": "params", "meta_attributes": "meta", } def repr_cli_head(self,node): try: obj_type = vars.cib_cli_map[node.tagName] except: unsupported_err(node.tagName) return None node_id = node.getAttribute("id") children = [] for c in node.childNodes: if not is_element(c): continue if (obj_type == "group" and is_primitive(c)) or \ is_child_rsc(c): children.append(cli_display.rscref(c.getAttribute("id"))) elif obj_type in vars.clonems_tags and is_child_rsc(c): children.append(cli_display.rscref(c.getAttribute("id"))) s = cli_display.keyword(obj_type) id = cli_display.id(node_id) return "%s %s %s" % (s, id, ' '.join(children)) def cli_list2node(self,cli_list,oldnode): head = copy.copy(cli_list[0]) head[0] = backtrans[head[0]] headnode = mkxmlsimple(head,oldnode,'grp') id_hint = headnode.getAttribute("id") for e in cli_list[1:]: n = mkxmlnode(e,oldnode,id_hint) headnode.appendChild(n) v = find_value(head[1],"$children") if v: for child_id in v: obj = cib_factory.find_object(child_id) if obj: n = obj.node.cloneNode(1) headnode.appendChild(n) else: no_object_err(child_id) remove_id_used_attributes(oldnode) return headnode def check_sanity(self): ''' Check meta attributes. ''' if not self.node: # eh? common_err("%s: no xml (strange)" % self.obj_id) return user_prefs.get_check_rc() if self.obj_type == "group": l = vars.rsc_meta_attributes elif self.obj_type == "clone": l = vars.clone_meta_attributes elif self.obj_type == "ms": l = vars.clone_meta_attributes + vars.ms_meta_attributes rc = sanity_check_nvpairs(self.obj_id,self.node,l) return rc class CibLocation(CibObject): ''' Location constraint. ''' def repr_cli_head(self,node): obj_type = vars.cib_cli_map[node.tagName] node_id = node.getAttribute("id") rsc = cli_display.rscref(node.getAttribute("rsc")) s = cli_display.keyword(obj_type) id = cli_display.id(node_id) s = "%s %s %s"%(s,id,rsc) pref_node = node.getAttribute("node") score = cli_display.score(get_score(node)) if pref_node: return "%s %s %s" % (s,score,pref_node) else: return s def repr_cli_child(self,c,format): if c.tagName == "rule": return "%s %s" % \ (cli_display.keyword("rule"), cli_rule(c)) def cli_list2node(self,cli_list,oldnode): head = copy.copy(cli_list[0]) head[0] = backtrans[head[0]] headnode = mkxmlsimple(head,oldnode,'location') id_hint = headnode.getAttribute("id") oldrule = None for e in cli_list[1:]: if e[0] in ("expression","date_expression"): n = mkxmlnode(e,oldrule,id_hint) else: n = mkxmlnode(e,oldnode,id_hint) if keyword_cmp(e[0], "rule"): add_missing_attr(n) rule = n headnode.appendChild(n) oldrule = lookup_node(rule,oldnode,location_only=True) else: rule.appendChild(n) remove_id_used_attributes(oldnode) return headnode def check_sanity(self): ''' Check if node references match existing nodes. ''' if not self.node: # eh? common_err("%s: no xml (strange)" % self.obj_id) return user_prefs.get_check_rc() uname = self.node.getAttribute("node") if uname and uname not in cib_factory.node_id_list(): common_warn("%s: referenced node %s does not exist" % (self.obj_id,uname)) return 1 rc = 0 for enode in self.node.getElementsByTagName("expression"): if enode.getAttribute("attribute") == "#uname": uname = enode.getAttribute("value") if uname and uname not in cib_factory.node_id_list(): common_warn("%s: referenced node %s does not exist" % (self.obj_id,uname)) rc = 1 return rc class CibSimpleConstraint(CibObject): ''' Colocation and order constraints. ''' def repr_cli_head(self,node): obj_type = vars.cib_cli_map[node.tagName] node_id = node.getAttribute("id") s = cli_display.keyword(obj_type) id = cli_display.id(node_id) score = cli_display.score(get_score(node)) if node.getElementsByTagName("resource_set"): col = rsc_set_constraint(node,obj_type) else: col = two_rsc_constraint(node,obj_type) if not col: return None symm = node.getAttribute("symmetrical") if symm: col.append("symmetrical=%s"%symm) return "%s %s %s %s" % (s,id,score,' '.join(col)) def repr_cli_child(self,c,format): pass # no children here def cli_list2node(self,cli_list,oldnode): head = copy.copy(cli_list[0]) head[0] = backtrans[head[0]] headnode = mkxmlsimple(head,oldnode,'') id_hint = headnode.getAttribute("id") for e in cli_list[1:]: # if more than one element, it's a resource set n = mkxmlnode(e,oldnode,id_hint) headnode.appendChild(n) remove_id_used_attributes(oldnode) return headnode class CibProperty(CibObject): ''' Cluster properties. ''' def repr_cli_head(self,node): return '%s $id="%s"' % \ (cli_display.keyword(self.obj_type), node.getAttribute("id")) def repr_cli_child(self,c,format): name = c.getAttribute("name") if "value" in c.attributes.keys(): value = c.getAttribute("value") else: value = None return nvpair_format(name,value) def cli_list2node(self,cli_list,oldnode): head = copy.copy(cli_list[0]) head[0] = backtrans[head[0]] obj_id = find_value(head[1],"$id") if not obj_id: obj_id = cib_object_map[self.xml_obj_type][3] headnode = mkxmlnode(head,oldnode,obj_id) remove_id_used_attributes(oldnode) return headnode def matchcli(self,cli_list): head = cli_list[0] if self.obj_type != head[0]: return False # if no id specified return True # (match the first of a kind) if not find_value(head[1],"$id"): return True return self.obj_id == find_value(head[1],"$id") def check_sanity(self): ''' Match properties with PE metadata. ''' if not self.node: # eh? common_err("%s: no xml (strange)" % self.obj_id) return user_prefs.get_check_rc() l = [] if self.obj_type == "property": - l = get_pe_property_list() + get_crmd_property_list() + l = get_properties_list() l += ("dc-version","cluster-infrastructure","last-lrm-refresh") elif self.obj_type == "op_defaults": l = vars.op_attributes elif self.obj_type == "rsc_defaults": l = vars.rsc_meta_attributes rc = sanity_check_nvpairs(self.obj_id,self.node,l) return rc # ################################################################ # # cib factory # cib_piped = "cibadmin -p" def get_default_timeout(): t = cib_factory.get_op_default("timeout") if t: return t t = cib_factory.get_property("default-action-timeout") if t: return t - if not vars.pe_metadata: - vars.pe_metadata = RAInfo("pengine","metadata") - if not vars.pe_metadata: + try: + return get_pe_meta().param_default("default-action-timeout") + except: return 0 - return vars.pe_metadata.param_default("default-action-timeout") -def get_pe_property_list(): - if not vars.pe_metadata: - vars.pe_metadata = RAInfo("pengine","metadata") - if not vars.pe_metadata: - return [] - return vars.pe_metadata.params().keys() -def get_crmd_property_list(): - if not vars.crmd_metadata: - vars.crmd_metadata = RAInfo("crmd","metadata") - if not vars.crmd_metadata: - return [] - return vars.crmd_metadata.params().keys() # xml -> cli translations (and classes) cib_object_map = { "node": ( "node", CibNode, "nodes" ), "primitive": ( "primitive", CibPrimitive, "resources" ), "group": ( "group", CibContainer, "resources" ), "clone": ( "clone", CibContainer, "resources" ), "master": ( "ms", CibContainer, "resources" ), "rsc_location": ( "location", CibLocation, "constraints" ), "rsc_colocation": ( "colocation", CibSimpleConstraint, "constraints" ), "rsc_order": ( "order", CibSimpleConstraint, "constraints" ), "cluster_property_set": ( "property", CibProperty, "crm_config", "cib-bootstrap-options" ), "rsc_defaults": ( "rsc_defaults", CibProperty, "rsc_defaults", "rsc-options" ), "op_defaults": ( "op_defaults", CibProperty, "op_defaults", "op-options" ), } backtrans = odict() # generate a translation cli -> tag for key in cib_object_map: backtrans[cib_object_map[key][0]] = key cib_topnodes = [] # get a list of parents for key in cib_object_map: if not cib_object_map[key][2] in cib_topnodes: cib_topnodes.append(cib_object_map[key][2]) def can_migrate(node): for c in node.childNodes: if not is_element(c) or c.tagName != "meta_attributes": continue pl = nvpairs2list(c) if find_value(pl,"allow-migrate") == "true": return True return False cib_upgrade = "cibadmin --upgrade --force" class CibFactory(Singleton): ''' Juggle with CIB objects. See check_structure below for details on the internal cib representation. ''' shadowcmd = ">/dev/null 1: common_warn("%s contains more than one %s, using first" % \ (obj.obj_id,attr_list_type)) id = node_l[0].getAttribute("id") if not id: common_err("%s reference not found" % id_ref) return id_ref # hope that user will fix that return id # verify if id_ref exists node_l = self.doc.getElementsByTagName(attr_list_type) for node in node_l: if node.getAttribute("id") == id_ref: return id_ref common_err("%s reference not found" % id_ref) return id_ref # hope that user will fix that def _get_attr_value(self,obj_type,attr): if not self.is_cib_sane(): return None for obj in self.cib_objects: if obj.obj_type == obj_type and obj.node: pl = nvpairs2list(obj.node) v = find_value(pl, attr) if v: return v return None def get_property(self,property): ''' Get the value of the given cluster property. ''' return self._get_attr_value("property",property) def get_op_default(self,attr): ''' Get the value of the attribute from op_defaults. ''' return self._get_attr_value("op_defaults",attr) def is_asymm_cluster(self): symm = self.get_property("symmetric-cluster") return symm and symm != "true" def new_object(self,obj_type,obj_id): "Create a new object of type obj_type." if id_store.id_in_use(obj_id): return None for xml_obj_type,v in cib_object_map.items(): if v[0] == obj_type: obj = v[1](xml_obj_type,obj_id) if obj.obj_id: return obj else: return None return None def mkobj_list(self,mode,*args): obj_list = [] for obj in self.cib_objects: f = lambda: obj.filter(*args) if not f(): continue if mode == "cli" and obj.nocli and obj.nocli_warn: obj.nocli_warn = False obj_cli_warn(obj.obj_id) obj_list.append(obj) return obj_list def is_cib_empty(self): return not self.mkobj_list("cli","type:primitive") def has_cib_changed(self): return self.mkobj_list("xml","changed") or self.remove_queue def verify_constraints(self,node): ''' Check if all resources referenced in a constraint exist ''' rc = True constraint_id = node.getAttribute("id") for obj_id in referenced_resources(node): if not self.find_object(obj_id): constraint_norefobj_err(constraint_id,obj_id) rc = False return rc def verify_rsc_children(self,node): ''' Check prerequisites: a) all children must exist b) no child may have other parent than me (or should we steal children?) c) there may not be duplicate children ''' obj_id = node.getAttribute("id") if not obj_id: common_err("element %s has no id" % node.tagName) return False try: obj_type = cib_object_map[node.tagName][0] except: common_err("element %s (%s) not recognized"%(node.tagName,obj_id)) return False c_ids = get_rsc_children_ids(node) if not c_ids: return True rc = True c_dict = {} for child_id in c_ids: if not self.verify_child(child_id,obj_type,obj_id): rc = False if child_id in c_dict: common_err("in group %s child %s listed more than once"%(obj_id,child_id)) rc = False c_dict[child_id] = 1 return rc def verify_child(self,child_id,obj_type,obj_id): 'Check if child exists and obj_id is (or may become) its parent.' child = self.find_object(child_id) if not child: no_object_err(child_id) return False if child.parent and child.parent.obj_id != obj_id: common_err("%s already in use at %s"%(child_id,child.parent.obj_id)) return False if obj_type == "group" and child.obj_type != "primitive": common_err("a group may contain only primitives; %s is %s"%(child_id,child.obj_type)) return False if not child.obj_type in vars.children_tags: common_err("%s may contain a primitive or a group; %s is %s"%(obj_type,child_id,child.obj_type)) return False return True def verify_element(self,node): ''' Can we create this object given its CLI representation. This is not about syntax, we're past that, but about semantics. Right now we check if the children, if any, are fit for the parent. And if this is a constraint, if all referenced resources are present. ''' rc = True if not self.verify_rsc_children(node): rc = False if not self.verify_constraints(node): rc = False return rc def create_object(self,*args): return self.create_from_cli(CliParser().parse(list(args))) != None def set_property_cli(self,cli_list): comments = get_comments(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) if comments and obj.node: stuff_comments(obj.node,comments) obj.updated = True return obj def add_op(self,cli_list): '''Add an op to a primitive.''' head = cli_list[0] # does the referenced primitive exist rsc_id = find_value(head[1],"rsc") rsc_obj = self.find_object(rsc_id) if not rsc_obj: no_object_err(rsc_id) return None if rsc_obj.obj_type != "primitive": common_err("%s is not a primitive" % rsc_id) return None return rsc_obj.add_operation(cli_list) def create_from_cli(self,cli): 'Create a new cib object from the cli representation.' cli_list = mk_cli_list(cli) if not cli_list: return None head = cli_list[0] obj_type = head[0].lower() obj_id = find_value(head[1],"id") if obj_id and not is_id_valid(obj_id): invalid_id_err(obj_id) return None if len(cli_list) >= 2 and cli_list[1][0] == "raw": doc = xml.dom.minidom.parseString(cli_list[1][1]) return self.create_from_node(doc.childNodes[0]) if obj_type in olist(vars.nvset_cli_names): return self.set_property_cli(cli_list) if obj_type == "op": return self.add_op(cli_list) if obj_type == "node": obj = self.find_object(obj_id) # make an exception and allow updating nodes if obj: self.merge_from_cli(obj,cli_list) return obj obj = self.new_object(obj_type,obj_id) if not obj: return None node = obj.cli2node(cli_list) return self.add_element(obj, node) def update_from_cli(self,obj,cli_list,update = False): ''' Replace element from the cli intermediate. If this is an update and the element is properties, then the new properties should be merged with the old. Otherwise, users may be surprised. ''' id_store.remove_xml(obj.node) if len(cli_list) >= 2 and cli_list[1][0] == "raw": doc = xml.dom.minidom.parseString(cli_list[1][1]) id_store.store_xml(doc.childNodes[0]) return self.update_element(obj,doc.childNodes[0]) elif update and obj.obj_type in vars.nvset_cli_names: self.merge_from_cli(obj,cli_list) return True else: return self.update_element(obj,obj.cli2node(cli_list)) def update_from_node(self,obj,node): 'Update element from a doc node.' id_store.replace_xml(obj.node,node) return self.update_element(obj,node) def update_element(self,obj,newnode): 'Update element from a doc node.' if not newnode: return False if not self.is_cib_sane(): id_store.replace_xml(newnode,obj.node) return False oldnode = obj.node if xml_cmp(oldnode,newnode): newnode.unlink() return True # the new and the old versions are equal obj.node = newnode if not self.test_element(obj,newnode): id_store.replace_xml(newnode,oldnode) obj.node = oldnode newnode.unlink() return False obj.node = self.replaceNode(newnode,oldnode) obj.nocli = False # try again after update self.adjust_children(obj) if not obj.cli_use_validate(): obj.nocli_warn = True obj.nocli = True oldnode.unlink() obj.updated = True obj.propagate_updated() return True def merge_from_cli(self,obj,cli_list): node = obj.cli2node(cli_list) if not node: return if obj.obj_type in vars.nvset_cli_names: rc = merge_nvpairs(obj.node, node) else: rc = merge_nodes(obj.node, node) if rc: obj.updated = True obj.propagate_updated() def update_moved(self,obj): 'Updated the moved flag. Mark affected constraints.' obj.moved = not obj.moved if obj.moved: for c_obj in self.related_constraints(obj): c_obj.recreate = True def adjust_children(self,obj): ''' All stuff children related: manage the nodes of children, update the list of children for the parent, update parents in the children. ''' new_children_ids = get_rsc_children_ids(obj.node) if not new_children_ids: return old_children = obj.children obj.children = [self.find_object(x) for x in new_children_ids] self._relink_orphans_to_top(old_children,obj.children) self._update_children(obj) def _relink_child_to_top(self,obj): 'Relink a child to the top node.' obj.node.parentNode.removeChild(obj.node) self.topnode[obj.parent_type].appendChild(obj.node) if obj.origin == "cib": self.update_moved(obj) obj.parent = None def _update_children(self,obj): '''For composite objects: update all children nodes. ''' # unlink all and find them in the new node for child in obj.children: oldnode = child.node child.node = obj.find_child_in_node(child) if child.children: # and children of children self._update_children(child) rmnode(oldnode) if not child.parent and child.origin == "cib": self.update_moved(child) if child.parent and child.parent != obj: child.parent.updated = True # the other parent updated child.parent = obj def _relink_orphans_to_top(self,old_children,new_children): "New orphans move to the top level for the object type." for child in old_children: if child not in new_children: self._relink_child_to_top(child) def test_element(self,obj,node): if not node.getAttribute("id"): return False if not obj.xml_obj_type in vars.defaults_tags: if not self.verify_element(node): return False if user_prefs.is_check_always() \ and obj.check_sanity() > 1: return False return True def update_links(self,obj): ''' Update the structure links for the object (obj.children, obj.parent). Update also the dom nodes, if necessary. ''' obj.children = [] if obj.obj_type not in vars.container_tags: return for c in obj.node.childNodes: if is_child_rsc(c): child = self.find_object_for_node(c) if not child: missing_obj_err(c) continue child.parent = obj obj.children.append(child) if not c.isSameNode(child.node): rmnode(child.node) child.node = c def add_element(self,obj,node): obj.node = node obj.obj_id = node.getAttribute("id") if not self.test_element(obj, node): id_store.remove_xml(node) node.unlink() return None common_debug("append child %s to %s" % \ (obj.obj_id,self.topnode[obj.parent_type].tagName)) self.topnode[obj.parent_type].appendChild(node) self.adjust_children(obj) self.redirect_children_constraints(obj) if not obj.cli_use_validate(): self.nocli_warn = True obj.nocli = True self.update_links(obj) obj.origin = "user" self.cib_objects.append(obj) return obj def create_from_node(self,node): 'Create a new cib object from a document node.' if not node: return None try: obj_type = cib_object_map[node.tagName][0] except: return None if is_defaults(node): node = get_rscop_defaults_meta_node(node) if not node: return None if node.ownerDocument != self.doc: node = self.doc.importNode(node,1) obj = self.new_object(obj_type, node.getAttribute("id")) if not obj: return None if not id_store.store_xml(node): return None return self.add_element(obj, node) def cib_objects_string(self, obj_list = None): l = [] if not obj_list: obj_list = self.cib_objects for obj in obj_list: l.append(obj.obj_string()) return ' '.join(l) def _remove_obj(self,obj): "Remove a cib object and its children." # remove children first # can't remove them here from obj.children! common_debug("remove object %s" % obj.obj_string()) for child in obj.children: #self._remove_obj(child) # just relink, don't remove children self._relink_child_to_top(child) if obj.parent: # remove obj from its parent, if any obj.parent.children.remove(obj) id_store.remove_xml(obj.node) rmnode(obj.node) obj.invalid = True self.add_to_remove_queue(obj) self.cib_objects.remove(obj) for c_obj in self.related_constraints(obj): if is_simpleconstraint(c_obj.node) and obj.children: # the first child inherits constraints rename_rscref(c_obj,obj.obj_id,obj.children[0].obj_id) delete_rscref(c_obj,obj.obj_id) if silly_constraint(c_obj.node,obj.obj_id): # remove invalid constraints self._remove_obj(c_obj) if not self._no_constraint_rm_msg: err_buf.info("hanging %s deleted" % c_obj.obj_string()) def related_constraints(self,obj): if not is_resource(obj.node): return [] c_list = [] for obj2 in self.cib_objects: if not is_constraint(obj2.node): continue if rsc_constraint(obj.obj_id,obj2.node): c_list.append(obj2) return c_list def redirect_children_constraints(self,obj): ''' Redirect constraints to the new parent ''' for child in obj.children: for c_obj in self.related_constraints(child): rename_rscref(c_obj,child.obj_id,obj.obj_id) # drop useless constraints which may have been created above for c_obj in self.related_constraints(obj): if silly_constraint(c_obj.node,obj.obj_id): self._no_constraint_rm_msg = True self._remove_obj(c_obj) self._no_constraint_rm_msg = False def add_to_remove_queue(self,obj): if obj.origin == "cib": self.remove_queue.append(obj) #print self.cib_objects_string(self.remove_queue) def delete_1(self,obj): ''' Remove an object and its parent in case the object is the only child. ''' if obj.parent and len(obj.parent.children) == 1: self.delete_1(obj.parent) if obj in self.cib_objects: # don't remove parents twice self._remove_obj(obj) def delete(self,*args): 'Delete a cib object.' if not self.doc: empty_cib_err() return False rc = True l = [] for obj_id in args: obj = self.find_object(obj_id) if not obj: no_object_err(obj_id) rc = False continue if is_rsc_running(obj_id): common_warn("resource %s is running, can't delete it" % obj_id) else: l.append(obj) if l: l = processing_sort_cli(l) for obj in reversed(l): self.delete_1(obj) return rc def rename(self,old_id,new_id): ''' Rename a cib object. - check if the resource (if it's a resource) is stopped - check if the new id is not taken - find the object with old id - rename old id to new id in all related objects (constraints) - if the object came from the CIB, then it must be deleted and the one with the new name created - rename old id to new id in the object ''' if not self.doc: empty_cib_err() return False if id_store.id_in_use(new_id): return False obj = self.find_object(old_id) if not obj: no_object_err(old_id) return False if not obj.can_be_renamed(): return False for c_obj in self.related_constraints(obj): rename_rscref(c_obj,old_id,new_id) 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/completion.py b/shell/modules/completion.py index 40d27d8274..77864e7e5e 100644 --- a/shell/modules/completion.py +++ b/shell/modules/completion.py @@ -1,491 +1,490 @@ # Copyright (C) 2008 Dejan Muhamedagic # # 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 time import copy import readline from cibconfig import CibFactory from cibstatus import CibStatus from levels import Levels from ra import * from vars import Vars from utils import * from xmlutil import * 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 nodes_list(idx,delimiter = False): if delimiter: return ' ' return listnodes() def shadows_list(idx,delimiter = False): if delimiter: return ' ' return listshadows() 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 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 node_id_list(idx,delimiter = False): if delimiter: return ' ' return cib_factory.node_id_list() def node_attr_keyw_list(idx,delimiter = False): if delimiter: return ' ' return vars.node_attributes_keyw 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() # # completion for primitives including help for parameters # (help also available for properties) # 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(idx,delimiter = False): if delimiter: return '=' return vars.rsc_meta_attributes def op_attr_list(idx,delimiter = False): if delimiter: return '=' return vars.op_attributes def operations_list(): return vars.op_cli_names def prim_complete_meta(ra,delimiter = False): if delimiter: return '=' return prim_meta_attr_list(0,delimiter) 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() + l = ra.completion_params() 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") + ra = get_properties_meta() 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) + compl_help.help(prim_params_info,ra) if delimiter: return ' ' return ['*'] else: - return prim_complete_params(vars.pe_metadata,delimiter) + return prim_complete_params(ra,delimiter) # # core completer stuff # 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): levels = Levels.getInstance() 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] def setup_readline(): readline.set_history_length(100) readline.parse_and_bind("tab: complete") readline.set_completer(completer) readline.set_completer_delims(\ readline.get_completer_delims().replace('-','').replace('/','').replace('=','')) try: readline.read_history_file(vars.hist_file) except: pass # # a dict of completer functions # (feel free to add more completers) # completer_lists = { "options" : { "skill-level" : (skills_list,), "editor" : None, "pager" : None, "user" : None, "output" : None, "colorscheme" : None, "check-frequency" : None, "check-mode" : None, "sort-elements" : None, "save" : None, "show" : None, }, "cib" : { "new" : None, "delete" : (shadows_list,), "reset" : (shadows_list,), "commit" : (shadows_list,), "use" : (shadows_live_list,), "diff" : None, "list" : None, "import" : None, "cibstatus" : None, }, "template" : { "new" : (null_list,templates_list,loop), "load" : (config_list,), "edit" : (config_list,), "delete" : (config_list,), "show" : (config_list,), "apply" : (config_list_method,config_list), "list" : None, }, "resource" : { "status" : (rsc_list,), "start" : (rsc_list,), "stop" : (rsc_list,), "restart" : (rsc_list,), "promote" : (rsc_list,), "demote" : (rsc_list,), "manage" : (rsc_list,), "unmanage" : (rsc_list,), "migrate" : (rsc_list,nodes_list), "unmigrate" : (rsc_list,), "param" : (rsc_list,attr_cmds), "meta" : (rsc_list,attr_cmds), "utilization" : (rsc_list,attr_cmds), "failcount" : (rsc_list,attr_cmds,nodes_list), "cleanup" : (rsc_list,nodes_list), "refresh" : (nodes_list,), "reprobe" : (nodes_list,), }, "node" : { "status" : (nodes_list,), "show" : (nodes_list,), "standby" : (nodes_list,), "online" : (nodes_list,), "fence" : (nodes_list,), "delete" : (nodes_list,), "clearstate" : (nodes_list,), "attribute" : (nodes_list,attr_cmds), "utilization" : (nodes_list,attr_cmds), "status-attr" : (nodes_list,attr_cmds), }, "ra" : { "classes" : None, "list" : None, "providers" : None, "meta" : None, }, "cibstatus" : { "show" : None, "save" : None, "load" : None, "origin" : None, "node" : (status_node_list,node_states_list), "op" : (ra_operations_list,status_rsc_list,lrm_exit_codes_list,lrm_status_codes_list,status_node_list), "run" : None, "simulate" : None, "quorum" : None, }, "configure" : { "erase" : None, "verify" : None, "refresh" : None, "ptest" : None, "commit" : None, "upgrade" : None, "show" : (id_xml_list,id_list,loop), "edit" : (id_xml_list,id_list,loop), "filter" : (null_list,id_xml_list,id_list,loop), "delete" : (id_list,loop), "default-timeouts" : (id_list,loop), "rename" : (id_list,id_list), "save" : None, "load" : None, "node" : (node_id_list,node_attr_keyw_list), "primitive" : (null_list,ra_classes_list,primitive_complete_complex,loop), "group" : (null_list,f_prim_id_list,loop), "clone" : (null_list,f_children_id_list), "ms" : (null_list,f_children_id_list), "location" : (null_list,rsc_id_list), "colocation" : (null_list,null_list,rsc_id_list,loop), "order" : (null_list,null_list,rsc_id_list,loop), "property" : (property_complete,loop), "rsc_defaults" : (prim_complete_meta,loop), "op_defaults" : (op_attr_list,loop), "xml" : None, "monitor" : None, "ra" : None, "cib" : None, "cibstatus" : None, "template" : None, "_test" : None, "_regtest" : None, "_objects" : None, }, } def get_completer_list(level,cmd): 'Return a list of completer functions.' try: return completer_lists[level][cmd] except: return None compl_help = CompletionHelp() user_prefs = UserPrefs.getInstance() vars = Vars.getInstance() cib_status = CibStatus.getInstance() cib_factory = CibFactory.getInstance() # vim:ts=4:sw=4:et: diff --git a/shell/modules/ra.py.in b/shell/modules/ra.py.in index 6ce17cff76..067e1567c2 100644 --- a/shell/modules/ra.py.in +++ b/shell/modules/ra.py.in @@ -1,610 +1,653 @@ # Copyright (C) 2008 Dejan Muhamedagic # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This software is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # import os import sys import subprocess import copy import xml.dom.minidom import re import glob from userprefs import Options, UserPrefs from cache import WCache from vars import Vars from utils import * from msg import * # # Resource Agents interface (meta-data, parameters, etc) # ocf_root = os.getenv("OCF_ROOT") if not ocf_root: ocf_root = "@OCF_ROOT_DIR@" if not ocf_root: ocf_root = "/usr/lib/ocf" os.putenv("OCF_ROOT",ocf_root) class RaLrmd(object): ''' Getting information from the resource agents. ''' lrmadmin_prog = "lrmadmin" def __init__(self): self.good = self.is_lrmd_accessible() def lrmadmin(self, opts, xml = False): ''' Get information directly from lrmd using lrmadmin. ''' l = stdout2list("%s %s" % (self.lrmadmin_prog,opts)) if l and not xml: l = l[1:] # skip the first line return l def is_lrmd_accessible(self): if not (is_program(self.lrmadmin_prog) and is_process("lrmd")): return False return subprocess.call(\ add_sudo(">/dev/null 2>&1 %s -C" % self.lrmadmin_prog), \ shell=True) == 0 def meta(self, ra_class,ra_type,ra_provider): return self.lrmadmin("-M %s %s %s"%(ra_class,ra_type,ra_provider),True) def providers(self, ra_type,ra_class = "ocf"): 'List of providers for a class:type.' return self.lrmadmin("-P %s %s" % (ra_class,ra_type),True) def classes(self): 'List of classes.' return self.lrmadmin("-C") def types(self, ra_class = "ocf", ra_provider = ""): 'List of types for a class.' return self.lrmadmin("-T %s" % ra_class) class RaOS(object): ''' Getting information from the resource agents (direct). ''' def __init__(self): self.good = True def meta(self, ra_class,ra_type,ra_provider): l = [] if ra_class == "ocf": l = stdout2list("%s/resource.d/%s/%s meta-data" % \ (ocf_root,ra_provider,ra_type)) elif ra_class == "stonith": l = stdout2list("stonith -m -t %s" % ra_type) return l def providers(self, ra_type,ra_class = "ocf"): 'List of providers for a class:type.' l = [] if ra_class == "ocf": for s in glob.glob("%s/resource.d/*/%s" % (ocf_root,ra_type)): a = s.split("/") if len(a) == 7: l.append(a[5]) return l def classes(self): 'List of classes.' return "heartbeat lsb ocf stonith".split() def types(self, ra_class = "ocf", ra_provider = ""): 'List of types for a class.' l = [] prov = ra_provider and ra_provider or "*" if ra_class == "ocf": l = os_types_list("%s/resource.d/%s/*" % (ocf_root,prov)) elif ra_class == "lsb": l = os_types_list("/etc/init.d/*") elif ra_class == "stonith": l = stdout2list("stonith -L") l = list(set(l)) l.sort() return l def ra_if(): if vars.ra_if: return vars.ra_if vars.ra_if = RaLrmd() if not vars.ra_if.good: vars.ra_if = RaOS() return vars.ra_if def ra_classes(): ''' List of RA classes. ''' if wcache.is_cached("ra_classes"): return wcache.retrieve("ra_classes") l = ra_if().classes() l.sort() return wcache.store("ra_classes",l) def ra_providers(ra_type,ra_class = "ocf"): 'List of providers for a class:type.' id = "ra_providers-%s-%s" % (ra_class,ra_type) if wcache.is_cached(id): return wcache.retrieve(id) l = ra_if().providers(ra_type,ra_class) l.sort() return wcache.store(id,l) def ra_providers_all(ra_class = "ocf"): ''' List of providers for a class. ''' id = "ra_providers_all-%s" % ra_class if wcache.is_cached(id): return wcache.retrieve(id) dir = ocf_root + "/resource.d" l = [] for s in os.listdir(dir): if os.path.isdir("%s/%s" % (dir,s)): l.append(s) l.sort() return wcache.store(id,l) def ra_types(ra_class = "ocf", ra_provider = ""): ''' List of RA type for a class. ''' if not ra_class: ra_class = "ocf" id = "ra_types-%s-%s" % (ra_class,ra_provider) if wcache.is_cached(id): return wcache.retrieve(id) if ra_provider: list = [] for ra in ra_if().types(ra_class): if ra_provider in ra_providers(ra,ra_class): list.append(ra) else: list = ra_if().types(ra_class) list.sort() return wcache.store(id,list) +def get_pe_meta(): + if not vars.pe_metadata: + vars.pe_metadata = RAInfo("pengine","metadata") + return vars.pe_metadata +def get_crmd_meta(): + if not vars.crmd_metadata: + vars.crmd_metadata = RAInfo("crmd","metadata") + vars.crmd_metadata.set_advanced_params(vars.crmd_advanced) + return vars.crmd_metadata +def get_stonithd_meta(): + if not vars.stonithd_metadata: + vars.stonithd_metadata = RAInfo("stonithd","metadata") + return vars.stonithd_metadata +def get_properties_meta(): + if not vars.crm_properties_metadata: + get_pe_meta() + get_crmd_meta() + vars.crm_properties_metadata = copy.deepcopy(vars.crmd_metadata) + vars.crm_properties_metadata.add_ra_params(vars.pe_metadata) + return vars.crm_properties_metadata +def get_properties_list(): + try: + return get_properties_meta().params().keys() + except: + return [] + def prog_meta(prog): ''' Do external program metadata. ''' l = [] if is_program(prog): l = stdout2list("%s metadata" % prog) return l def get_nodes_text(n,tag): try: node = n.getElementsByTagName(tag)[0] for c in node.childNodes: if c.nodeType == c.TEXT_NODE: return c.data.strip() except: return '' def mk_monitor_name(role,depth): depth = depth == "0" and "" or ("_%s" % depth) return role and role != "Started" and \ "monitor_%s%s" % (role,depth) or \ "monitor%s" % depth def monitor_name_node(node): depth = node.getAttribute("depth") or '0' role = node.getAttribute("role") return mk_monitor_name(role,depth) def monitor_name_pl(pl): depth = find_value(pl, "depth") or '0' role = find_value(pl, "role") return mk_monitor_name(role,depth) def crm_msec(t): ''' See lib/common/utils.c:crm_get_msec(). ''' convtab = { 'ms': (1,1), 'msec': (1,1), 'us': (1,1000), 'usec': (1,1000), '': (1000,1), 's': (1000,1), 'sec': (1000,1), 'm': (60*1000,1), 'min': (60*1000,1), 'h': (60*60*1000,1), 'hr': (60*60*1000,1), } if not t: return -1 r = re.match("\s*(\d+)\s*([a-zA-Z]+)?", t) if not r: return -1 if not r.group(2): q = '' else: q = r.group(2).lower() try: mult,div = convtab[q] except: return -1 return (int(r.group(1))*mult)/div def crm_time_cmp(a, b): return crm_msec(a) - crm_msec(b) class RAInfo(object): ''' A resource agent and whatever's useful about it. ''' ra_tab = " " # four horses required_ops = ("start", "stop") skip_ops = ("meta-data", "validate-all") skip_op_attr = ("name", "depth", "role") def __init__(self,ra_class,ra_type,ra_provider = "heartbeat"): + self.advanced_params = [] self.ra_class = ra_class self.ra_type = ra_type self.ra_provider = ra_provider if not self.ra_provider: self.ra_provider = "heartbeat" self.ra_node = None def ra_string(self): return self.ra_class == "ocf" and \ "%s:%s:%s" % (self.ra_class, self.ra_provider, self.ra_type) or \ "%s:%s" % (self.ra_class, self.ra_type) def error(self, s): common_err("%s: %s" % (self.ra_string(), s)) def warn(self, s): common_warn("%s: %s" % (self.ra_string(), s)) + def set_advanced_params(self, l): + self.advanced_params = l def filter_crmd_attributes(self): for n in self.ra_node.getElementsByTagName("parameter"): if not n.getAttribute("name") in vars.crmd_user_attributes: n.parentNode.removeChild(n) - def add_extra_stonith_params(self): - if not vars.stonithd_metadata: - vars.stonithd_metadata = RAInfo("stonithd","metadata") - if not vars.stonithd_metadata.mk_ra_node(): + def add_ra_params(self,ra): + ''' + Add parameters from another RAInfo instance. + ''' + try: + if not self.mk_ra_node() or not ra.mk_ra_node(): + return + except: return try: params_node = self.doc.getElementsByTagName("parameters")[0] except: params_node = self.doc.createElement("parameters") self.ra_node.appendChild(params_node) - for n in vars.stonithd_metadata.ra_node.getElementsByTagName("parameter"): + for n in ra.ra_node.getElementsByTagName("parameter"): params_node.appendChild(self.doc.importNode(n,1)) def mk_ra_node(self): ''' Return the resource_agent node. ''' if self.ra_node: return self.ra_node meta = self.meta() try: self.doc = xml.dom.minidom.parseString('\n'.join(meta)) except: self.error("could not parse meta-data: %s" % '\n'.join(meta)) self.ra_node = None return None try: self.ra_node = self.doc.getElementsByTagName("resource-agent")[0] except: self.error("meta-data contains no resource-agent element") self.ra_node = None return None if self.ra_class == "stonith": - self.add_extra_stonith_params() - if self.ra_class == "crmd": - self.filter_crmd_attributes() + self.add_ra_params(get_stonithd_meta()) return self.ra_node def param_type_default(self,n): try: content = n.getElementsByTagName("content")[0] type = content.getAttribute("type") default = content.getAttribute("default") return type,default except: return None,None def params(self): ''' Construct a dict of dicts: parameters are keys and dictionary of attributes/values are values. Cached too. ''' id = "ra_params-%s" % self.ra_string() if wcache.is_cached(id): return wcache.retrieve(id) if not self.mk_ra_node(): return None d = {} for pset in self.ra_node.getElementsByTagName("parameters"): for c in pset.getElementsByTagName("parameter"): name = c.getAttribute("name") if not name: continue required = c.getAttribute("required") unique = c.getAttribute("unique") type,default = self.param_type_default(c) d[name] = { "required": required, "unique": unique, "type": type, "default": default, } return wcache.store(id,d) + def completion_params(self): + ''' + Extra method for completion, for we want to filter some + (advanced) parameters out. And we want this to be fast. + ''' + if not self.mk_ra_node(): + return None + return [c.getAttribute("name") + for c in self.ra_node.getElementsByTagName("parameter") + if c.getAttribute("name") + and c.getAttribute("name") not in self.advanced_params + ] def actions(self): ''' Construct a dict of dicts: actions are keys and dictionary of attributes/values are values. Cached too. ''' id = "ra_actions-%s" % self.ra_string() if wcache.is_cached(id): return wcache.retrieve(id) if not self.mk_ra_node(): return None d = {} for pset in self.ra_node.getElementsByTagName("actions"): for c in pset.getElementsByTagName("action"): name = c.getAttribute("name") if not name or name in self.skip_ops: continue if name == "monitor": name = monitor_name_node(c) d[name] = {} for a in c.attributes.keys(): if a in self.skip_op_attr: continue v = c.getAttribute(a) if v: d[name][a] = v # add monitor ops without role, if they don't already # exist d2 = {} for op in d.keys(): if re.match("monitor_[^0-9]", op): norole_op = re.sub(r'monitor_[^0-9_]+_(.*)', r'monitor_\1', op) if not norole_op in d: d2[norole_op] = d[op] d.update(d2) return wcache.store(id,d) def reqd_params_list(self): ''' List of required parameters. ''' d = self.params() if not d: return [] return [x for x in d if d[x]["required"] == '1'] def param_default(self,pname): ''' Parameter's default. ''' d = self.params() try: return d[pname]["default"] except: return None def sanity_check_params(self, id, pl): ''' pl is a list of (attribute,value) pairs. - are all required parameters defined - do all parameters exist ''' rc = 0 d = {} for p,v in pl: d[p] = v for p in self.reqd_params_list(): if p not in d: common_err("%s: required parameter %s not defined" % (id,p)) rc |= user_prefs.get_check_rc() for p in d: if p not in self.params(): common_err("%s: parameter %s does not exist" % (id,p)) rc |= user_prefs.get_check_rc() return rc def get_adv_timeout(self, op, node = None): if node and op == "monitor": name = monitor_name_node(node) else: name = op try: return self.actions()[name]["timeout"] except: return None def sanity_check_ops(self, id, ops, default_timeout): ''' ops is a dict, operation names are keys and values are lists of (attribute,value) pairs. - do all operations exist - are timeouts sensible ''' rc = 0 n_ops = {} for op in ops: n_op = op == "monitor" and monitor_name_pl(ops[op]) or op n_ops[n_op] = {} for p,v in ops[op]: if p in self.skip_op_attr: continue n_ops[n_op][p] = v for req_op in self.required_ops: if req_op not in n_ops: n_ops[req_op] = {} for op in n_ops: if op not in self.actions(): common_warn("%s: action %s not advertised in meta-data, it may not be supported by the RA" % (id,op)) rc |= 1 continue try: adv_timeout = self.actions()[op]["timeout"] except: continue if "timeout" in n_ops[op]: v = n_ops[op]["timeout"] timeout_string = "specified timeout" else: v = default_timeout timeout_string = "default timeout" if crm_msec(v) < 0: continue if crm_time_cmp(adv_timeout,v) > 0: common_warn("%s: %s %s for %s is smaller than the advised %s" % \ (id,timeout_string,v,op,adv_timeout)) rc |= 1 return rc def meta(self): ''' RA meta-data as raw xml. ''' id = "ra_meta-%s" % self.ra_string() if wcache.is_cached(id): return wcache.retrieve(id) if self.ra_class in vars.meta_progs: l = prog_meta(self.ra_class) else: l = ra_if().meta(self.ra_class,self.ra_type,self.ra_provider) return wcache.store(id, l) def meta_pretty(self): ''' Print the RA meta-data in a human readable form. ''' if not self.mk_ra_node(): return '' l = [] title = self.meta_title() l.append(title) longdesc = get_nodes_text(self.ra_node,"longdesc") if longdesc: l.append(longdesc) if self.ra_class != "heartbeat": params = self.meta_parameters() if params: l.append(params.rstrip()) actions = self.meta_actions() if actions: l.append(actions) return '\n\n'.join(l) def get_shortdesc(self,n): name = n.getAttribute("name") shortdesc = get_nodes_text(n,"shortdesc") longdesc = get_nodes_text(n,"longdesc") if shortdesc and shortdesc not in (name,longdesc,self.ra_type): return shortdesc return '' def meta_title(self): s = self.ra_string() shortdesc = self.get_shortdesc(self.ra_node) if shortdesc: s = "%s (%s)" % (shortdesc,s) return s def meta_param_head(self,n): name = n.getAttribute("name") if not name: return None s = name if n.getAttribute("required") == "1": s = s + "*" type,default = self.param_type_default(n) if type and default: s = "%s (%s, [%s])" % (s,type,default) elif type: s = "%s (%s)" % (s,type) shortdesc = self.get_shortdesc(n) s = "%s: %s" % (s,shortdesc) return s def format_parameter(self,n): l = [] head = self.meta_param_head(n) if not head: self.error("no name attribute for parameter") return "" l.append(head) longdesc = get_nodes_text(n,"longdesc") if longdesc: longdesc = self.ra_tab + longdesc.replace("\n","\n"+self.ra_tab) + '\n' l.append(longdesc) return '\n'.join(l) def meta_parameter(self,param): if not self.mk_ra_node(): return '' l = [] for pset in self.ra_node.getElementsByTagName("parameters"): for c in pset.getElementsByTagName("parameter"): if c.getAttribute("name") == param: return self.format_parameter(c) def meta_parameters(self): if not self.mk_ra_node(): return '' l = [] for pset in self.ra_node.getElementsByTagName("parameters"): for c in pset.getElementsByTagName("parameter"): s = self.format_parameter(c) if s: l.append(s) if l: return "Parameters (* denotes required, [] the default):\n\n" + '\n'.join(l) def meta_action_head(self,n): name = n.getAttribute("name") if not name: return '' if name in self.skip_ops: return '' if name == "monitor": name = monitor_name_node(n) s = "%-13s" % name for a in n.attributes.keys(): if a in self.skip_op_attr: continue v = n.getAttribute(a) if v: s = "%s %s=%s" % (s,a,v) return s def meta_actions(self): l = [] for aset in self.ra_node.getElementsByTagName("actions"): for c in aset.getElementsByTagName("action"): s = self.meta_action_head(c) if s: l.append(self.ra_tab + s) if l: return "Operations' defaults (advisory minimum):\n\n" + '\n'.join(l) # # resource type definition # def ra_type_validate(s, ra_class, provider, rsc_type): ''' Only ocf ra class supports providers. ''' if not rsc_type: common_err("bad resource type specification %s"%s) return False if ra_class == "ocf": if not provider: common_err("provider could not be determined for %s"%s) return False else: if provider: common_warn("ra class %s does not support providers"%ra_class) return True return True def disambiguate_ra_type(s): ''' Unravel [class:[provider:]]type ''' l = s.split(':') if not l or len(l) > 3: return None if len(l) == 3: return l elif len(l) == 2: ra_class,ra_type = l else: ra_class = "ocf" ra_type = l[0] ra_provider = '' if ra_class == "ocf": pl = ra_providers(ra_type,ra_class) if pl and len(pl) == 1: ra_provider = pl[0] elif not pl: ra_provider = 'heartbeat' return ra_class,ra_provider,ra_type wcache = WCache.getInstance() vars = Vars.getInstance() # vim:ts=4:sw=4:et: diff --git a/shell/modules/vars.py.in b/shell/modules/vars.py.in index 5c072e8d4a..498682cc12 100644 --- a/shell/modules/vars.py.in +++ b/shell/modules/vars.py.in @@ -1,139 +1,146 @@ # Copyright (C) 2008 Dejan Muhamedagic # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # # This software is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # import os from singletonmixin import Singleton class Vars(Singleton): cib_cli_map = { "node": "node", "primitive": "primitive", "group": "group", "clone": "clone", "master": "ms", "rsc_location": "location", "rsc_colocation": "colocation", "rsc_order": "order", "cluster_property_set": "property", "rsc_defaults": "rsc_defaults", "op_defaults": "op_defaults", } container_tags = ("group", "clone", "ms", "master") clonems_tags = ("clone", "ms", "master") resource_tags = ("primitive","group","clone","ms","master") constraint_tags = ("rsc_location","rsc_colocation","rsc_order") constraint_rsc_refs = ("rsc","with-rsc","first","then") children_tags = ("group", "primitive") nvpairs_tags = ("meta_attributes", "instance_attributes", "utilization") defaults_tags = ("rsc_defaults","op_defaults") resource_cli_names = ("primitive","group","clone","ms","master") constraint_cli_names = ("location","colocation","collocation","order") nvset_cli_names = ("property","rsc_defaults","op_defaults") op_cli_names = ("monitor", "start", "stop", "migrate_to", "migrate_from","promote","demote","notify") ra_operations = ("probe", "monitor", "start", "stop", "promote", "demote", "notify", "migrate_to", "migrate_from") subpfx_list = { "instance_attributes": "instance_attributes", "meta_attributes": "meta_attributes", "utilization": "utilization", "operations": "ops", "rule": "rule", "expression": "expression", "date_expression": "expression", "duration": "duration", "date_spec": "date_spec", } lrm_exit_codes = { "success": "0", "unknown": "1", "args": "2", "unimplemented": "3", "perm": "4", "installed": "5", "configured": "6", "not_running": "7", "master": "8", "failed_master": "9", } lrm_status_codes = { "pending": "-1", "done": "0", "cancelled": "1", "timeout": "2", "notsupported": "3", "error": "4", } node_states = ("online", "offline", "unclean") precious_attrs = ("id-ref",) time_op_attrs = ("timeout",) req_op_attributes = ("name", "id") op_attributes = ( "interval", "timeout", "requires", "enabled", "role", "on-fail", "start-delay", "interval-origin", "record-pending", "description", ) rsc_meta_attributes = ( "allow-migrate", "is-managed", "interval-origin", "migration-threshold", "priority", "multiple-active", "failure-timeout", "resource-stickiness", "target-role", "restart-type", "description", ) clone_meta_attributes = ( "ordered", "notify", "interleave", "globally-unique", "clone-max", "clone-node-max", "clone-state", "description", ) ms_meta_attributes = ( "master-max", "master-node-max", "description", ) score_types = {'advisory': '0','mandatory': 'INFINITY'} boolean_ops = ('or','and') binary_ops = ('lt','gt','lte','gte','eq','ne') binary_types = ('string' , 'version' , 'number') unary_ops = ('defined','not_defined') simple_date_ops = ('lt','gt') date_ops = ('lt','gt','in_range','date_spec') date_spec_names = '''hours monthdays weekdays yearsdays months \ weeks years weekyears moon'''.split() in_range_attrs = ('start','end') roles_names = ('Stopped', 'Started', 'Master', 'Slave') actions_names = ( 'start', 'promote', 'demote', 'stop') node_default_type = "normal" node_attributes_keyw = ("attributes","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" pe_dir = "@PE_STATE_DIR@" crm_conf_dir = "@CRM_CONFIG_DIR@" crm_daemon_dir = "@CRM_DAEMON_DIR@" crm_daemon_user = "@CRM_DAEMON_USER@" crm_version = "@VERSION@ (Build @BUILD_VERSION@)" ra_if = None # class interface to RA stonithd_metadata = None # stonithd meta data pe_metadata = None # PE meta data crmd_metadata = None # crmd meta data + crm_properties_metadata = None # PE + crmd meta data meta_progs = ("crmd","pengine","stonithd") - crmd_user_attributes = ("dc-deadtime","cluster-recheck-interval","expected-quorum-votes") + crmd_advanced = ( + "dc-version", + "cluster-infrastructure", + "crmd-integration-timeout", + "crmd-finalization-timeout", + "expected-quorum-votes", + ) # vim:ts=4:sw=4:et: