~therealmik/+junk/python-ocfra

###

# OCF RA Script Framework

# By Michael Samuel <michael.samuel@ipsystems.com.au>

# 

# OCF Resource Script Class

###

from action import Action

from parameter import Parameter, STRING, INTEGER, BOOLEAN

from errors import *

from xml.etree import ElementTree

import os

import sys

import traceback

try:

	from collections import OrderedDict as _odict

except ImportError:

	_odict = dict

class _ocf_reskeys(dict):

	def __init__(self, params):

		self._params = params

	def __missing__(self, key):

		p = self._params[key]

		try:

			return p.datatype.topython(os.environ[p.envname])

		except KeyError:

			if p.default is not None:

				self[p.name] = p.default

				return p.default

			else:

				raise

	__getattr__ = dict.__getitem__

class OCFEnvironment(object):

	def __init__(self, params):

		self.instance = os.environ.get("OCF_RESOURCE_INSTANCE", "__noinstance__")

		self.tempdir = os.environ.get("HA_RSCTMP", "/tmp")

		try:

			self.check_level = int(os.environ["OCF_CHECK_LEVEL"])

		except KeyError:

			pass

		self.params = _ocf_reskeys(params)

class ResourceAgent(object):

	"""ResourceAgent is the main class for creating your OCF resource agent.

	@name The name of your resource agent (`basename $0` in the shell script wrapper)

	@version A version string (number?) for this agent.  1.0 would be a good start."""

	def __init__(self, name, version, longdesc, shortdesc):

		self.name = name

		self.version = version

		self.longdesc = longdesc

		self.shortdesc = shortdesc

		self.actions = _odict()

		self.parameters = _odict()

		self.validations = []

		self.add_action("meta-data", {"timeout": "10s"}, self.meta_data)

		self.add_action("validate-all", {"timeout": "10s"}, self.validate_all)

		self.add_validation(self.validate_parameters)

	def add_action(self, *args, **kwargs):

		"""Add an action that the script supports

	@name The name of the action (eg. start) - Must have at-least start, stop. meta-data and validate-all are

	      provided for you

	@parameters A dict of default parameters for this action.  timeout is mandatory.  example: { "timeout": "10s" }

	@callback A callable (function or method) to be executed on this action.  Is always an OCFEnvironment object"""

		a = Action(*args, **kwargs)

		self.actions[a.name] = a

	def add_parameter(self, *args, **kwargs):

		p = Parameter(*args, **kwargs)

		self.parameters[p.name] = p

	def add_validation(self, callback):

		self.validations.append(callback)

	def usage(self):

		return "Usage: %s <%s>" % (self.name, "|".join(self.actions.keys()))

	def run(self, argv):

		if isinstance(argv, str):

			action = argv

		elif len(argv) != 2:

			print >>sys.stderr, self.usage()

			raise OCF_ERR_UNIMPLEMENTED(self.usage())

		else:

			action = sys.argv[1]

		try:

			if not self.actions.has_key(action):

				raise OCF_ERR_UNIMPLEMENTED(self.usage())

			a = self.actions[action]

			a.callback(OCFEnvironment(self.parameters))

		except OcfError, e:

			if e.message:

				print >>sys.stderr, e.message

			raise

		except Exception, e:

			traceback.print_exc(file=sys.stderr)

			sys.exit(1)

	def meta_data(self, env=None):

		eResourceAgent = ElementTree.Element("resource-agent", {"name": self.name, "version": self.version})

		ElementTree.SubElement(eResourceAgent, "version").text = "1.0"

		ElementTree.SubElement(eResourceAgent, "longdesc", {"lang": "en"}).text = self.longdesc

		ElementTree.SubElement(eResourceAgent, "shortdesc", {"lang": "en"}).text = self.shortdesc

		eParameters = ElementTree.SubElement(eResourceAgent, "parameters")

		for p in (p.getelement() for p in self.parameters.itervalues()):

			eParameters.append(p)

		eActions = ElementTree.SubElement(eResourceAgent, "actions")

		for a in (a.getelement() for a in self.actions.itervalues()):

			eActions.append(a)

		sys.stdout.write("""<?xml version="1.0"?>

<!DOCTYPE resource-agent SYSTEM "ra-api-1.dtd">

""")

		ElementTree.ElementTree(eResourceAgent).write(sys.stdout)

		sys.stdout.write("\n")

	def validate_all(self, env=None):

		for validator in self.validations:

			validator(env)

	def validate_parameters(self, env=None):

		for parameter in self.parameters.itervalues():

			if not os.environ.has_key(parameter.envname):

				if parameter.required:

					raise OCF_ERR_CONFIGURED("Required parameter \"%s\" missing" % parameter.name)

				continue

			try:

				value = parameter.datatype.topython(os.environ[parameter.envname])

				parameter.validate(value)

			except ValueError, e:

				raise ErrConfigured("Invalid value for parameter %s: %s", (parameter.name, e.message))