[Cluster-devel] conga/luci/site/luci/Extensions LuciValidation.py

[rmccabe@sourceware.org <rmccabe@sourceware.org>]

CVSROOT:	/cvs/cluster
Module name:	conga
Changes by:	rmccabe at sourceware.org	2007-12-12 15:43:15

Added files:
	luci/site/luci/Extensions: LuciValidation.py 

Log message:
	Separate out cluster form post validation to allow async validation

Patches:
http://sourceware.org/cgi-bin/cvsweb.cgi/conga/luci/site/luci/Extensions/LuciValidation.py.diff?cvsroot=cluster&r1=NONE&r2=1.1

/cvs/cluster/conga/luci/site/luci/Extensions/LuciValidation.py,v  -->  standard output
revision 1.1
--- conga/luci/site/luci/Extensions/LuciValidation.py
+++ -	2007-12-12 15:43:15.733027000 +0000
@@ -0,0 +1,1185 @@
+# Copyright (C) 2007 Red Hat, Inc.
+#
+# This program is free software; you can redistribute
+# it and/or modify it under the terms of version 2 of the
+# GNU General Public License as published by the
+# Free Software Foundation.
+
+from ClusterModel.RefObject import RefObject
+from ClusterModel.Service import Service
+from ClusterModel.Method import Method
+from ClusterModel.Fence import Fence
+from ClusterModel.FailoverDomain import FailoverDomain
+from ClusterModel.FailoverDomainNode import FailoverDomainNode
+from ClusterModel.QuorumD import QuorumD
+from ClusterModel.Heuristic import Heuristic
+from ClusterModel.FenceXVMd import FenceXVMd
+from ClusterModel.Lockserver import Lockserver
+from ClusterModel.Vm import Vm
+
+from conga_constants import LUCI_DEBUG_MODE, FDOM, FDOM_ADD, SERVICE_CONFIG, SERVICE_ADD, VM_CONFIG, VM_ADD
+from FenceHandler import validateFenceDevice, validateNewFenceDevice, validate_fenceinstance, FD_VAL_SUCCESS 
+
+from LuciSyslog import get_logger
+from xml.dom import minidom
+from ResourceHandler import create_resource
+from LuciZope import GetReqVars
+
+luci_log = get_logger()
+
+def validate_node_fence_config(model, request):
+	errors = list()
+
+	fvar = GetReqVars(request,
+			[ 'fence_xml', 'fence_level', 'nodename', 'clustername' ])
+
+	if fvar['fence_xml'] is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vNFC0: no fence_xml for node %s' \
+				% fvar['nodename'])
+		return (False, {'errors': ['No fence data was supplied']})
+
+	if fvar['fence_level'] is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vNFC1: no fence level for %s' \
+				% fvar['nodename'])
+		return (False, {'errors': ['No fence level was supplied']})
+
+	try:
+		fence_level = int(fvar['fence_level'])
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vNFC2: invalid fence level: %s: %r %s' \
+				% (fvar['fence_level'], e, str(e)))
+		return (False, {'errors': ['"%s" is an invalid fence level' % fvar['fence_level'] ]})
+
+	nodename = fvar['nodename']
+	if nodename is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vNFC3: no nodename: %r %s' % (e, str(e)))
+		return (False, {'errors': ['No node name was given']})
+
+	clustername = fvar['clustername']
+	if clustername is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vNFC4: no clustername: %r %s' % (e, str(e)))
+		return (False, {'errors': ['No cluster name was given']})
+
+	try:
+		doc = minidom.parseString(fvar['fence_xml'])
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vNFC7: error: %r %s' % (e, str(e)))
+		return (False, {'errors': ['The fence data submitted is not properly formed']})
+
+	try:
+		node = model.retrieveNodeByName(nodename)
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vNFC8: unable to find node name %s in current node list: %r %s' % (nodename, e, str(e)))
+		return (False, {'errors': ['Unable to find the cluster node %s in the node list' % nodename ]})
+
+	levels = node.getFenceLevels()
+	try:
+		method_id = levels[fence_level - 1].getAttribute('name')
+		if not method_id:
+			raise Exception, 'No method ID'
+		fence_method = Method()
+		fence_method.addAttribute('name', str(method_id))
+		levels[fence_level - 1] = fence_method
+	except Exception, e:
+		method_id = fence_level
+		fence_method = Method()
+		fence_method.addAttribute('name', str(method_id))
+
+	forms = doc.getElementsByTagName('form')
+	if len(forms) < 1:
+		delete_target = None
+		for l in levels:
+			# delete the fence level
+			if l.getAttribute('name') == method_id:
+				delete_target = l
+				break
+		if delete_target is not None:
+			try:
+				node.getChildren()[0].removeChild(delete_target)
+			except Exception, e:
+				if LUCI_DEBUG_MODE is True:
+					luci_log.debug_verbose('vNFC9: %s: %r %s' \
+						% (method_id, e, str(e)))
+				return (False, {'errors': ['An error occurred while deleting fence method %s' % method_id ]})
+		else:
+			return (True, {'messages': ['No changes were made'] })
+
+	form_hash = {}
+	for i in forms:
+		form_id = i.getAttribute('id')
+		if not form_id:
+			continue
+		ielems = i.getElementsByTagName('input')
+		if not ielems or len(ielems) < 1:
+			continue
+
+		dummy_form = {}
+
+		for i in ielems:
+			try:
+				input_type = str(i.getAttribute('type'))
+			except Exception, e:
+				if LUCI_DEBUG_MODE is True:
+					luci_log.debug_verbose('vNFC10: input type: %r %s' \
+						% (e, str(e)))
+				continue
+
+			if not input_type or input_type == 'button':
+				continue
+
+			try:
+				dummy_form[str(i.getAttribute('name'))] = str(i.getAttribute('value'))
+			except Exception, e:
+				if LUCI_DEBUG_MODE is True:
+					luci_log.debug_verbose('vNFC11: parsing XML: %r %s' \
+						% (e, str(e)))
+
+		if len(dummy_form) < 1:
+			continue
+
+		if dummy_form.has_key('fence_instance'):
+			try:
+				parent = dummy_form['parent_fencedev']
+			except:
+				if LUCI_DEBUG_MODE is True:
+					luci_log.debug_verbose('vNFC12: no parent for instance')
+				return (False, {'errors': [ 'Unable to determine what device the current instance uses' ]})
+
+			try:
+				form_hash[parent][1].append(dummy_form)
+				del dummy_form['fence_instance']
+			except Exception, e:
+				if LUCI_DEBUG_MODE is True:
+					luci_log.debug_verbose('vNFC13: no parent for instance')
+				return (False, {'errors': [ 'Unable to determine what device the current instance uses' ]})
+		else:
+			form_hash[form_id] = (dummy_form, list())
+
+	fh_keys = form_hash.keys()
+	fh_keys.sort()
+	for i in fh_keys:
+		fencedev_name = None
+		fencedev_unknown = False
+
+		try:
+			fence_form, instance_list = form_hash[i]
+		except Exception, e:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('vNFC14: %r %s' % (e, str(e)))
+			continue
+
+		try:
+			fence_type = fence_form['fence_type']
+			if not fence_type:
+				raise Exception, 'fence type is blank'
+		except Exception, e:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('vNFC15: %s: %r %s' % (i, e, str(e)))
+			fence_type = None
+
+		if fence_form.has_key('existing_device'):
+			try:
+				fencedev_name = fence_form['name']
+				if not fencedev_name.strip():
+					raise Exception, 'no fence name'
+			except Exception, e:
+				errors.append('You must provide a unique name for all fence devices')
+				continue
+
+			if fence_type is None:
+				# An unknown fence device agent. Pull the data out of
+				# the model and persist it and all instances.
+				# All we care about is its name.
+				fencedev_unknown = True
+			else:
+				if not fence_form.has_key('sharable'):
+					# If it's a shared fence device that already exists, the
+					# user could not have edited it (without playing dirty
+					# games), so it's safe to pull the existing entry from
+					# the model. All we need is the device name, and nothing
+					# else needs to be done here.
+					#
+					# For an existing non-shared device update the device
+					# in the model, since the user could have edited it.
+					retcode, retmsg = validateFenceDevice(fence_form, model)
+					if retcode != FD_VAL_SUCCESS:
+						errors.extend(retmsg)
+						continue
+					else:
+						fencedev_name = retmsg
+
+					# Add back the tags under the method block
+					# for the fence instance
+					if type == 'fence_manual':
+						instance_list.append({'name': fencedev_name, 'nodename': nodename })
+					else:
+						instance_list.append({'name': fencedev_name })
+		else:
+			# The user created a new fence device.
+			retcode, retmsg = validateNewFenceDevice(fence_form, model)
+			if retcode != FD_VAL_SUCCESS:
+				errors.extend(retmsg)
+				continue
+			else:
+				fencedev_name = retmsg
+
+			# If it's not shared, we need to create an instance form
+			# so the appropriate XML goes into the <method> block inside
+			# <node><fence>. All we need for that is the device name.
+			if not fence_form.has_key('sharable'):
+				if type == 'fence_manual':
+					instance_list.append({'name': fencedev_name, 'nodename': nodename })
+				else:
+					instance_list.append({'name': fencedev_name })
+
+		if fencedev_unknown is True:
+			# Save any instances for this fence device.
+			# XXX FIX ME - instances must be saved.
+			pass
+
+		for inst in instance_list:
+			retcode, retobj = validate_fenceinstance(inst, fencedev_name, fence_type)
+			if retcode != FD_VAL_SUCCESS:
+				errors.extend(retobj)
+				continue
+			fence_method.addChild(retobj)
+
+		if len(node.getChildren()) > 0:
+			# There's already a <fence> block
+			found_target = False
+			for idx in xrange(len(levels)):
+				if levels[idx].getAttribute('name') == method_id:
+					found_target = True
+					break
+
+			if found_target is False:
+				# There's a fence block, but no relevant method
+				# block
+				node.getChildren()[0].addChild(fence_method)
+		else:
+			# There is no <fence> tag under the node yet.
+			fence_node = Fence()
+			fence_node.addChild(fence_method)
+			node.addChild(fence_node)
+
+	if len(errors) > 0:
+		return (False, {'errors': errors })
+	return (True, {})
+
+def validate_clusvc_add(model, request):
+	errors = list()
+	fvar = GetReqVars(request, [ 'form_xml', 'domain', 'recovery', 'svc_name', 'action' ])
+
+	form_xml = fvar['form_xml']
+	if form_xml is None:
+		form_xml = ''
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vSA0: no form_xml')
+
+	forms = []
+	if form_xml.strip():
+		try:
+			doc = minidom.parseString(form_xml)
+			forms = doc.getElementsByTagName('form')
+			if len(forms) < 1:
+				raise Exception, 'invalid XML'
+		except Exception, e:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('vSA1: error: %r %s: %r' % (e, str(e), form_xml))
+			return (False, { 'errors': [ 'The resource data submitted for this service is not properly formed' ]})
+
+	form_hash = {}
+	form_hash['toplevel'] = { 'form': None, 'kids': [] }
+	for i in forms:
+		form_id = i.getAttribute('id')
+		form_parent = i.getAttribute('parent')
+		if not form_id or not form_parent:
+			continue
+		ielems = i.getElementsByTagName('input')
+		if not ielems or len(ielems) < 1:
+			continue
+		if not form_id in form_hash:
+			form_hash[form_id] = {'form': i, 'kids': []}
+		elif not form_hash[form_id]['form']:
+			form_hash[form_id]['form'] = i
+		if not form_parent in form_hash:
+			form_hash[form_parent] = {'form': None, 'kids': []}
+		form_hash[form_parent]['kids'].append(form_id)
+		dummy_form = {}
+
+		for i in ielems:
+			try:
+				input_type = str(i.getAttribute('type'))
+			except:
+				continue
+			if not input_type or input_type == 'button':
+				continue
+			try:
+				dummy_form[str(i.getAttribute('name'))] = str(i.getAttribute('value'))
+			except Exception, e:
+				if LUCI_DEBUG_MODE is True:
+					luci_log.debug_verbose('vSA2: parsing XML: %r %s' \
+						% (e, str(e)))
+
+		try:
+			res_type = dummy_form['type'].strip()
+			if not res_type:
+				raise Exception, 'no resource type'
+		except Exception, e:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('vSA3: %r %s' % (e, str(e)))
+			return (False, { 'errors': [ 'No resource type was specified' ]})
+
+		try:
+			if res_type == 'ip':
+				dummy_form['resourceName'] = dummy_form['ip_address']
+		except Exception, e:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('vSA3a: type is ip but no addr: %r %s' \
+					% (e, str(e)))
+			return (False, { 'errors': [ 'No IP address was given' ]})
+
+		try:
+			if dummy_form.has_key('immutable'):
+				newRes = model.getResourceByName(dummy_form['resourceName'])
+				resObj = RefObject(newRes)
+				resObj.setRef(newRes.getName())
+			else:
+				resObj = create_resource(res_type, dummy_form, model)
+		except Exception, e:
+			resObj = None
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('vSA4: type %s: %r %s' \
+					% (res_type, e, str(e)))
+
+		if resObj is None:
+			return (False, { 'errors': [ 'An error occurred while adding %s' % res_type ]})
+
+		if dummy_form.has_key('__independent_subtree'):
+			resObj.addAttribute('__independent_subtree', '1')
+		else:
+			resObj.removeAttribute('__independent_subtree')
+		form_hash[form_id]['obj'] = resObj
+
+	if len(errors) > 0:
+		return (False, {'errors': errors})
+
+	fdom = fvar['domain']
+
+	recovery = fvar['recovery']
+	if recovery is not None and recovery != 'restart' and recovery != 'relocate' and recovery != 'disable':
+		errors.append('You entered an invalid recovery option: "%s" Valid options are "restart" "relocate" and "disable."')
+
+	service_name = fvar['svc_name']
+	if service_name is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vSA5: no service name')
+		errors.append('No service name was given')
+
+	autostart = '1'
+	try:
+		if not request.form.has_key('autostart') or request.form['autostart'] == '0':
+			autostart = '0'
+	except Exception, e:
+		autostart = None
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vSA5a: error getting autostart: %r %s' \
+				% (e, str(e)))
+
+	exclusive = '0'
+	try:
+		if not request.form.has_key('exclusive') or request.form['exclusive'] != '1':
+			exclusive = '0'
+		else:
+			exclusive = '1'
+	except Exception, e:
+		exclusive = '0'
+
+	try:
+		cur_service = model.retrieveServiceByName(service_name)
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vSA5c: no service named %s found: %r %s' \
+				% (service_name, e, str(e)))
+		cur_service = None
+
+	action = fvar['action']
+	if action is None:
+		return (False, {'errors': [ 'No action was given for service %s' % service_name ] })
+
+	if action == 'edit':
+		if cur_service is None:
+			return (False, {'errors': [ 'The service %s could not be found for editing' % service_name ]})
+		model.deleteService(service_name)
+	elif action == 'add':
+		if cur_service is not None:
+			return (False, {'errors': [ 'A service with the name %s already exists' % service_name ]})
+	else:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('vSA4a: unknown action %s' \
+				% request.form['action'])
+		return (False, {'errors': [ 'An unknown action was specified' ]})
+
+	def buildSvcTree(parent, child_id_list):
+		for i in child_id_list:
+			try:
+				child = form_hash[i]['obj']
+				if not child:
+					raise Exception, 'No object for %s' % i
+			except Exception, e:
+				if LUCI_DEBUG_MODE is True:
+					luci_log.debug_verbose('bST0: %r %s' % (e, str(e)))
+				continue
+			parent.addChild(child)
+			if 'kids' in form_hash[i]:
+				buildSvcTree(child, form_hash[i]['kids'])
+
+	new_service = Service()
+	new_service.addAttribute('name', service_name)
+	if fdom:
+		new_service.addAttribute('domain', fdom)
+	if recovery:
+		new_service.addAttribute('recovery', recovery)
+	new_service.addAttribute('exclusive', str(exclusive))
+	if autostart is not None:
+		new_service.attr_hash['autostart'] = autostart
+
+	buildSvcTree(new_service, form_hash['toplevel']['kids'])
+	model.resourcemanager_ptr.addChild(new_service)
+	model.setModified(True)
+
+	if action == 'edit':
+		action_type = SERVICE_CONFIG
+		action_msg = 'Configuring service "%s"' % service_name
+	else:
+		action_type = SERVICE_ADD
+		action_msg = 'Creating service "%s"' % service_name
+
+	return (True, { 'action_type': action_type, 'action_msg': action_msg })
+
+def validate_clures_add(model, request):
+	fvar = GetReqVars(request, [ 'type' ])
+
+	res_type = fvar['type']
+	if res_type is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('VRA0: type is blank')
+		return (False, { 'errors': [ 'No resource type was given']})
+
+	try:
+		res = create_resource(res_type, request.form, model)
+	except Exception, e:
+		return (False, { 'errors': e } )
+
+	resname = ''
+	try:
+		resname = res.getName()
+		model.getResourcesPtr().addChild(res)
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('EditResource0: %r %s' % (e, str(e)))
+		return (False, { 'errors': [ 'Error configuring resource %s %s: ' % (resname, str(e)) ] })
+	return (True, { 'res_name': resname })
+
+def validate_fdom(model, request):
+	errors = list()
+	fvar = GetReqVars(request, [ 'clustername', 'name', 'oldname' ])
+
+	name = fvar['name']
+	if name is None:
+		errors.append('No name was given for this failover domain')
+
+	prioritized = False
+	try:
+		prioritized = request.form.has_key('prioritized')
+	except:
+		prioritized = False
+
+	restricted = False
+	try:
+		restricted = request.form.has_key('restricted')
+	except:
+		restricted = False
+
+	nofailback = False
+	try:
+		nofailback = request.form.has_key('nofailback')
+	except:
+		nofailback = False
+
+	oldname = fvar['oldname']
+
+	if oldname is None or oldname != name:
+		if model.getFailoverDomainByName(name) is not None:
+			errors.append('A failover domain named "%s" already exists' % name)
+
+	fdom = None
+	if oldname is not None:
+		fdom = model.getFailoverDomainByName(oldname)
+		if fdom is None:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('validateFdom1: No fdom named %s exists' % oldname)
+			errors.append('No failover domain named "%s" exists' % oldname)
+		else:
+			fdom.addAttribute('name', name)
+			fdom.children = list()
+	else:
+		fdom = FailoverDomain()
+		fdom.addAttribute('name', name)
+
+	if fdom is None or len(errors) > 0:
+		return (False, {'errors': errors })
+
+	if prioritized:
+		fdom.addAttribute('ordered', '1')
+	else:
+		fdom.addAttribute('ordered', '0')
+
+	if restricted:
+		fdom.addAttribute('restricted', '1')
+	else:
+		fdom.addAttribute('restricted', '0')
+
+	if nofailback:
+		fdom.addAttribute('nofailback', '1')
+	else:
+		fdom.addAttribute('nofailback', '0')
+
+	for i in model.getNodeNames():
+		if request.form.has_key(i):
+			fdn = FailoverDomainNode()
+			fdn.addAttribute('name', i)
+			if prioritized:
+				priority = 1
+				try:
+					priority = int(request.form['__PRIORITY__%s' % i].strip())
+					if priority < 1:
+						priority = 1
+				except Exception, e:
+					priority = 1
+				fdn.addAttribute('priority', str(priority))
+			fdom.addChild(fdn)
+
+	try:
+		fdom_ptr = model.getFailoverDomainPtr()
+		if not oldname:
+			fdom_ptr.addChild(fdom)
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('validateFdom2: %r %s' % (e, str(e)))
+		errors.append('Unable to update the cluster configuration')
+
+	if len(errors) > 0:
+		return (False, { 'errors': errors })
+
+	if oldname:
+		action = FDOM
+		status_msg = 'Updating failover domain "%s"' % oldname
+	else:
+		action = FDOM_ADD
+		status_msg = 'Creating failover domain "%s"' % name
+
+	return (True, { 'msg': status_msg, 'action': action })
+
+def validate_config_mcast(model, form):
+	gulm_ptr = model.getGULMPtr()
+	if gulm_ptr:
+		return (False, { 'errors': ['Multicast cannot be used with GULM locking']})
+	errors = list()
+	try:
+		mcast_val = form['mcast'].strip().lower()
+		if mcast_val != 'true' and mcast_val != 'false':
+			raise KeyError, mcast_val
+		if mcast_val == 'true':
+			mcast_manual = True
+		else:
+			mcast_manual = False
+	except KeyError, e:
+		errors.append('An invalid multicast selection was made')
+		return (False, {'errors': errors})
+
+	mcast_interface = None
+	if form.has_key('mcast_interface'):
+		mcast_interface = form['mcast_interface'].strip()
+
+	if mcast_manual is True and form.has_key('cluster_version') and form['cluster_version'].strip() == 'rhel4' and not mcast_interface:
+		errors.append('No multicast interface was specified')
+		return (False, {'errors': errors})
+
+	if mcast_manual is True:
+		import socket
+		try:
+			addr_str = form['mcast_address'].strip()
+			socket.inet_pton(socket.AF_INET, addr_str)
+		except KeyError, e:
+			addr_str = None
+			errors.append('No multicast address was given')
+		except socket.error, e:
+			try:
+				socket.inet_pton(socket.AF_INET6, addr_str)
+			except socket.error, e:
+				addr_str = None
+				errors.append('An invalid multicast address was given: %s')
+	else:
+		addr_str = None
+
+	try:
+		if not addr_str:
+			if mcast_interface:
+				errors.append('A multicast interface was specified, but no multicast address was given')
+				return (False, {'errors': errors})
+			model.del_cluster_multicast()
+		else:
+			model.set_cluster_multicast(addr_str, mcast_if=mcast_interface)
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug('Error updating mcast properties: %r %s' \
+				% (e, str(e)))
+		errors.append('Unable to update cluster multicast properties')
+
+	if len(errors) > 0:
+		return (False, {'errors': errors})
+
+	return (True, {})
+
+def validate_config_qdisk(model, form):
+	errors = list()
+
+	gulm_ptr = model.getGULMPtr()
+	if gulm_ptr is not None:
+		return (False, { 'errors': ['Quorum disk cannot be used with GULM locking']})
+
+	try:
+		qdisk_val = form['quorumd'].strip().lower()
+		if qdisk_val != 'true' and qdisk_val != 'false':
+			raise KeyError(qdisk_val)
+		if qdisk_val == 'true':
+			qdisk_val = 1
+		else:
+			qdisk_val = 0
+	except KeyError, e:
+		return (False, {'errors': ['An invalid quorum partition selection was made']})
+
+	cp = model.getClusterPtr()
+	qdp = model.getQuorumdPtr()
+
+	if not qdisk_val:
+		if qdp:
+			try:
+				cp.removeChild(qdp)
+			except Exception, e:
+				return (False, {'errors': [ 'Error disabling quorum partition: %s' % str(e) ] })
+		return (True, {})
+
+	try:
+		interval = int(form['interval'])
+		if interval < 0:
+			raise ValueError, 'Interval must be 0 or greater'
+	except KeyError, e:
+		errors.append('No Interval value was given')
+	except ValueError, e:
+		errors.append('An invalid Interval value was given: %s' % str(e))
+
+	try:
+		votes = int(form['votes'])
+		if votes < 1:
+			raise ValueError, 'Votes must be greater than 0'
+	except KeyError, e:
+		errors.append('No Votes value was given')
+	except ValueError, e:
+		errors.append('An invalid Votes value was given: %s' % str(e))
+
+	try:
+		tko = int(form['tko'])
+		if tko < 0:
+			raise ValueError, 'TKO must be 0 or greater'
+	except KeyError, e:
+		errors.append('No TKO value was given')
+	except ValueError, e:
+		errors.append('An invalid TKO value was given: %s' % str(e))
+
+	try:
+		min_score = int(form['min_score'])
+		if min_score < 1:
+			raise ValueError('Minimum Score must be greater than 0')
+	except KeyError, e:
+		errors.append('No Minimum Score value was given')
+	except ValueError, e:
+		errors.append('An invalid Minimum Score value was given: %s' % str(e))
+
+	# Either device or label must be present
+	device = None
+	try:
+		device = form['device'].strip()
+	except:
+		device = None
+
+	label = None
+	try:
+		label = form['label'].strip()
+	except:
+		label = None
+
+	if not device and not label:
+		errors.append('No Device or Label value was given')
+
+	num_heuristics = 0
+	try:
+		num_heuristics = int(form['num_heuristics']) + 1
+		if num_heuristics < 1:
+			raise ValueError, form['num_heuristics']
+	except KeyError, e:
+		errors.append('No number of heuristics was given')
+	except ValueError, e:
+		errors.append('An invalid number of heuristics was given: %s' % str(e))
+
+	heuristics = list()
+	for i in xrange(num_heuristics):
+		try:
+			h = form['heuristic%d' % i]
+			if not h or len(h) != 3 or not (h[0].strip() and h[1].strip() and h[2].strip()):
+				continue
+		except:
+			continue
+
+		try:
+			hprog = h[0]
+			if not hprog:
+				raise Exception, 'no hprog'
+		except Exception, e:
+			errors.append('No program was given for heuristic %d' % (i + 1))
+		try:
+			hint = int(h[1])
+			if hint < 1:
+				raise ValueError, 'Heuristic interval values must be greater than 0'
+		except KeyError, e:
+			errors.append('No interval was given for heuristic %d' % (i + 1))
+		except ValueError, e:
+			errors.append('An invalid interval was given for heuristic %d: %s' \
+				% ((i + 1), str(e)))
+
+		try:
+			hscore = int(h[2])
+			if hscore < 1:
+				raise ValueError, 'Heuristic scores must be greater than 0'
+		except KeyError, e:
+			errors.append('No score was given for heuristic %d' % (i + 1))
+		except ValueError, e:
+			errors.append('An invalid score was given for heuristic %d: %s' \
+				% ((i + 1), str(e)))
+
+		heuristics.append([ hprog, hint, hscore ])
+
+	if len(errors) > 0:
+		return (False, {'errors': errors })
+
+	qd = QuorumD()
+	qd.addAttribute('interval', str(interval))
+	qd.addAttribute('votes', str(votes))
+	qd.addAttribute('tko', str(tko))
+	qd.addAttribute('min_score', str(min_score))
+
+	if device:
+		qd.addAttribute('device', str(device))
+	else:
+		qd.addAttribute('label', str(label))
+
+	if qdp:
+		try:
+			cp.removeChild(qdp)
+		except:
+			pass
+	cp.addChild(qd)
+
+	for h in heuristics:
+		new_h = Heuristic()
+		new_h.addAttribute('program', str(h[0]))
+		new_h.addAttribute('interval', str(h[1]))
+		new_h.addAttribute('score', str(h[2]))
+		qd.addChild(new_h)
+
+	if len(errors) > 0:
+		return (False, {'errors': errors })
+
+	return (True, {})
+
+def validate_config_fence(model, form):
+	errors = list()
+
+	if model.getGULMPtr() is not None:
+		return (False, {'errors': [ 'GULM clusters do not support fenced' ]})
+
+	try:
+		post_fail_delay = int(form['post_fail_delay'])
+		if post_fail_delay < 0:
+			raise ValueError('post fail delay values must be 0 or greater')
+	except KeyError, e:
+		errors.append('No post fail delay was given')
+	except ValueError, e:
+		errors.append('Invalid post fail delay: %s' % str(e))
+
+	try:
+		post_join_delay = int(form['post_join_delay'])
+		if post_join_delay < 0:
+			raise ValueError('post join delay values must be 0 or greater')
+	except KeyError, e:
+		errors.append('No post join delay was given')
+	except ValueError, e:
+		errors.append('Invalid post join delay: %s' % str(e))
+
+	run_xvmd = form.has_key('run_xvmd')
+
+	if run_xvmd is True and not model.hasFenceXVM():
+		fenceXVMd = FenceXVMd()
+		model.addFenceXVM(fenceXVMd)
+	elif not run_xvmd:
+		model.delFenceXVM()
+
+	try:
+		fd = model.getFenceDaemonPtr()
+		old_pj_delay = fd.getPostJoinDelay()
+		old_pf_delay = fd.getPostFailDelay()
+
+		if post_join_delay == old_pj_delay and post_fail_delay == old_pf_delay:
+			errors.append('No fence daemon properties were changed')
+		else:
+			fd.setPostJoinDelay(str(post_join_delay))
+			fd.setPostFailDelay(str(post_fail_delay))
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('Unable to update fence daemon properties: %r %s' % (e, str(e)))
+		errors.append('An error occurred while attempting to update fence daemon properties: %s' % str(e))
+
+	if len(errors) > 0:
+		return (False, {'errors': errors })
+
+	return (True, {})
+
+def validate_config_gulm(model, form):
+	gulm_ptr = model.getGULMPtr()
+	if not gulm_ptr:
+		return (False, {'errors': [ 'This cluster is not using GULM locking' ]})
+
+	node_list = map(lambda x: x.getName(), gulm_ptr.getChildren())
+	for i in model.getNodeNames():
+		if not i in node_list:
+			node_list.append(i)
+
+	gulm_lockservers = list()
+	for node in node_list:
+		if form.has_key(node) and form[node] == 'on':
+			ls = Lockserver()
+			ls.addAttribute('name', node)
+			gulm_lockservers.append(ls)
+
+	try:
+		xlockservers = filter(lambda x: x.strip(), form['__GULM__'])
+	except:
+		xlockservers = list()
+
+	for i in xlockservers:
+		if not i in node_list:
+			ls = Lockserver()
+			ls.addAttribute('name', i)
+			gulm_lockservers.append(ls)
+
+	num_ls = len(gulm_lockservers)
+	if not num_ls in (1, 3, 5):
+		return (False, {'errors': [ 'You must have exactly 1, 3, or 5 GULM lock servers. You submitted %d lock servers' % num_ls ]})
+
+	model.GULM_ptr.children = gulm_lockservers
+	return (True, {})
+
+def validate_config_general(model, form):
+	errors = list()
+
+	try:
+		cp = model.getClusterPtr()
+		old_name = model.getClusterAlias()
+		old_ver = int(cp.getConfigVersion())
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('getConfigVersion: %s' % str(e))
+		errors.append('unable to determine the current configuration version')
+		return (False, {'errors': errors})
+
+	try:
+		cluster_name = form['cluname'].strip()
+		if not cluster_name:
+			raise KeyError('cluname')
+	except KeyError, e:
+		errors.append('No cluster name was given')
+
+	if len(cluster_name) > 15:
+		errors.append('A cluster\'s name must be less than 16 characters long')
+
+	try:
+		version_num = int(form['cfgver'])
+		if version_num < old_ver:
+			raise ValueError, 'configuration version number must be %d or greater' % old_ver
+	except KeyError, e:
+		errors.append('No cluster configuration version was given')
+	except ValueError, e:
+		errors.append('An invalid configuration version was given: %s' % str(e))
+
+	if len(errors) < 1:
+		try:
+			if cluster_name != old_name:
+				cp.addAttribute('alias', cluster_name)
+			cp.setConfigVersion(str(version_num))
+		except Exception, e:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('unable to update general properties: %r %s' % (e, str(e)))
+			errors.append('Unable to update the cluster configuration')
+
+	try:
+		cluster_version = form['cluster_version'].strip()
+		if cluster_version != 'rhel5':
+			raise Exception, 'not rhel5'
+	except:
+		if len(errors) > 0:
+			return (False, {'errors': errors})
+		return (True, {})
+
+	totem = model.getTotemPtr()
+	if totem is None:
+		totem = model.addTotemPtr()
+
+	try:
+		token = form['token'].strip()
+		if not token:
+			raise KeyError, 'token'
+		token = int(token)
+		if token < 1:
+			raise ValueError, '%d is an invalid value for token timeout' % token
+		totem.addAttribute('token', str(token))
+	except KeyError, e:
+		try:
+			totem.removeAttribute('token')
+		except:
+			pass
+	except Exception, e:
+		errors.append(str(e))
+
+	try:
+		trblc = form['token_retransmits_before_loss_const'].strip()
+		if not trblc:
+			raise KeyError, 'token_retransmits_before_loss_const'
+		trblc = int(trblc)
+		if trblc < 1:
+			raise ValueError, '%d is an invalid value for number of token retransmits before loss' % trblc
+		totem.addAttribute('token_retransmits_before_loss_const', str(trblc))
+	except KeyError, e:
+		try:
+			totem.removeAttribute('token_retransmits_before_loss_const')
+		except:
+			pass
+	except Exception, e:
+		errors.append(str(e))
+
+	try:
+		join = form['join'].strip()
+		if not join:
+			raise KeyError, 'join'
+		join = int(join)
+		if join < 1:
+			raise ValueError, '%d is an invalid value for join timeout' % join
+		totem.addAttribute('join', str(join))
+	except KeyError, e:
+		try:
+			totem.removeAttribute('join')
+		except:
+			pass
+	except Exception, e:
+		errors.append(str(e))
+
+	try:
+		consensus = form['consensus'].strip()
+		if not consensus:
+			raise KeyError, 'consensus'
+		consensus = int(consensus)
+		if consensus < 1:
+			raise ValueError, '%d is an invalid value for consensus timeout' % consensus
+		totem.addAttribute('consensus', str(consensus))
+	except KeyError, e:
+		try:
+			totem.removeAttribute('consensus')
+		except:
+			pass
+	except Exception, e:
+		errors.append(str(e))
+
+	if len(errors) > 0:
+		return (False, {'errors': errors})
+	return (True, {})
+
+def validate_cluster_daemon_form(self, request):
+	errors = list()
+
+	fvar = GetReqVars(request, [ 'nodename' ])
+	nodename = fvar['nodename']
+	if nodename is None:
+		errors.append('Unable to determine the current node name')
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('VDP1: no nodename was given')
+
+	disable_list = list()
+	enable_list = list()
+
+	for i in request.form.items():
+		try:
+			if i[0][:11] == '__daemon__:':
+				daemon_prop = i[1]
+				if len(daemon_prop) == 2:
+					if daemon_prop[1] == '1':
+						disable_list.append(daemon_prop[0])
+				else:
+					if daemon_prop[1] == '0' and daemon_prop[2] == 'on':
+						enable_list.append(daemon_prop[0])
+		except Exception, e:
+			if LUCI_DEBUG_MODE is True:
+				luci_log.debug_verbose('VDP3: error: %s: %r %s' \
+					% (str(i), e, str(e)))
+
+	if len(enable_list) < 1 and len(disable_list) < 1:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('VDP4: no changes made')
+		errors.append('No changes to daemon properies were made on node "%s"' \
+			% nodename)
+
+	if len(errors) > 0:
+		return (False, {'errors': errors})
+
+	return (True, { 'enable_list': enable_list, 'disable_list': disable_list })
+
+def validate_vmsvc_form(model, request):
+	errors = list()
+
+	fvar = GetReqVars(request, [ 'vmname', 'oldname', 'vmpath', 'recovery', 'domain', ])
+
+	vm_name = fvar['vmname']
+	if vm_name is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('validateVM2: no vm name')
+		errors.append('No virtual machine name was given')
+
+	vm_path = fvar['vmpath']
+	if vm_path is None:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('validateVM3: no vm path')
+		errors.append('No path to the virtual machine configuration directory was given for VM service "%s"' % vm_name)
+
+	autostart = 1
+	if request.form.has_key('autostart'):
+		autostart = 1
+	else:
+		autostart = 0
+
+	exclusive = 0
+	if request.form.has_key('exclusive'):
+		exclusive = 1
+	else:
+		exclusive = 0
+
+	recovery = fvar['recovery']
+	if recovery is not None and recovery != 'restart' and recovery != 'relocate' and recovery != 'disable':
+		errors.append('You entered an invalid recovery option "%s" for VM service "%s". Valid options are "restart" "relocate" and "disable"' % (recovery, vm_name))
+
+	if len(errors) > 0:
+		return (False, {'errors': errors })
+
+	isNew = False
+	old_name = fvar['oldname']
+	if old_name is None:
+		isNew = True
+
+	delete_vm = False
+	if request.form.has_key('delete'):
+		try:
+			xvm = model.retrieveVMsByName(old_name)
+			if not xvm:
+				raise Exception, 'not found'
+			rmptr = model.getResourceManagerPtr()
+			rmptr.removeChild(xvm)
+			delete_vm = True
+		except:
+			return (False, { 'errors': [ 'No virtual machine service named "%s" exists' % old_name ]})
+	else:
+		if isNew is True:
+			xvm = Vm()
+			xvm.addAttribute('name', vm_name)
+			xvm.addAttribute('path', vm_path)
+			rmptr = model.getResourceManagerPtr()
+			rmptr.addChild(xvm)
+		else:
+			try:
+				xvm = model.retrieveVMsByName(old_name)
+				if not xvm:
+					raise Exception, 'not found'
+			except:
+				return (False, { 'errors': [ 'No virtual machine service named "%s" exists' % old_name ]})
+			xvm.addAttribute('name', vm_name)
+			xvm.addAttribute('path', vm_path)
+
+	xvm.addAttribute('autostart', str(autostart))
+	xvm.addAttribute('exclusive', str(exclusive))
+
+	fdom = fvar['domain']
+	if fdom:
+		xvm.addAttribute('domain', fdom)
+	else:
+		try:
+			xvm.removeAttribute('domain')
+		except:
+			pass
+
+	if recovery:
+		xvm.addAttribute('recovery', recovery)
+	else:
+		try:
+			xvm.removeAttribute('recovery')
+		except:
+			pass
+
+	if delete_vm is True:
+		action = VM_CONFIG
+		status_msg = 'Deleting virtual machine service "%s"' % vm_name
+	elif isNew is True:
+		action = VM_ADD
+		status_msg = 'Creating virtual machine service "%s"' % vm_name
+	else:
+		action = VM_CONFIG
+		status_msg = 'Configuring virtual machine service "%s"' % vm_name
+
+	return (True, { 'action_type': action, 'action_msg': status_msg })
+
+def validate_fence_del(model, request):
+	fvar = GetReqVars(request, [ 'orig_name' ])
+
+	fencedev_name = fvar['orig_name']
+	if fencedev_name is None:
+		return (False, { 'errors': [ 'No fence device name in form submission' ] })
+
+	try:
+		fdev = model.getFenceDeviceByName(fencedev_name)
+		if fdev:
+			if model.deleteFenceDevice(fdev) is not True:
+				raise Exception, 'failed to remove %s' % fdev.getName()
+			model.removeFenceInstancesForFenceDevice(fencedev_name)
+		else:
+			raise Exception, 'no fence device named "%s" was found' \
+					% fencedev_name
+	except Exception, e:
+		if LUCI_DEBUG_MODE is True:
+			luci_log.debug_verbose('DFD3: %s: %r %s' \
+				% (fencedev_name, e, str(e)))
+		return (False, { 'errors': [ 'Error removing fence device %s: %s' \
+										% (fencedev_name, str(e)) ]})
+	return (True, { 'name': fencedev_name })