760 lines
30 KiB
Python
760 lines
30 KiB
Python
#
|
|
# CORE
|
|
# Copyright (c)2010-2012 the Boeing Company.
|
|
# See the LICENSE file included in this distribution.
|
|
#
|
|
# author: Jeff Ahrenholz <jeffrey.m.ahrenholz@boeing.com>
|
|
#
|
|
'''
|
|
service.py: definition of CoreService class that is subclassed to define
|
|
startup services and routing for nodes. A service is typically a daemon
|
|
program launched when a node starts that provides some sort of
|
|
service. The CoreServices class handles configuration messages for sending
|
|
a list of available services to the GUI and for configuring individual
|
|
services.
|
|
'''
|
|
|
|
import sys, os, shlex
|
|
|
|
from itertools import repeat
|
|
from core.api import coreapi
|
|
from core.conf import ConfigurableManager, Configurable
|
|
from core.misc.utils import maketuplefromstr, expandcorepath
|
|
|
|
servicelist = []
|
|
|
|
def addservice(service):
|
|
global servicelist
|
|
i = 0
|
|
found = -1
|
|
for s in servicelist:
|
|
if s._group == service._group:
|
|
found = i
|
|
elif (found >= 0):
|
|
# insert service into list next to existing group
|
|
i = found + 1
|
|
break
|
|
i += 1
|
|
servicelist.insert(i, service)
|
|
|
|
class CoreServices(ConfigurableManager):
|
|
''' Class for interacting with a list of available startup services for
|
|
nodes. Mostly used to convert a CoreService into a Config API
|
|
message. This class lives in the Session object and remembers
|
|
the default services configured for each node type, and any
|
|
custom service configuration. A CoreService is not a Configurable.
|
|
'''
|
|
_name = "services"
|
|
_type = coreapi.CORE_TLV_REG_UTILITY
|
|
|
|
def __init__(self, session):
|
|
ConfigurableManager.__init__(self, session)
|
|
# dict of default services tuples, key is node type
|
|
self.defaultservices = {}
|
|
# dict of tuple of service objects, key is node number
|
|
self.customservices = {}
|
|
importcmd = "from core.services import *"
|
|
exec(importcmd)
|
|
paths = self.session.getcfgitem('custom_services_dir')
|
|
if paths:
|
|
for path in paths.split(','):
|
|
path = path.strip()
|
|
self.importcustom(path)
|
|
|
|
def importcustom(self, path):
|
|
''' Import services from a myservices directory.
|
|
'''
|
|
if not path or len(path) == 0:
|
|
return
|
|
if not os.path.isdir(path):
|
|
self.session.warn("invalid custom service directory specified" \
|
|
": %s" % path)
|
|
return
|
|
try:
|
|
parentdir, childdir = os.path.split(path)
|
|
if childdir == "services":
|
|
raise ValueError, "use a unique custom services dir name, " \
|
|
"not 'services'"
|
|
sys.path.append(parentdir)
|
|
exec("from %s import *" % childdir)
|
|
except Exception, e:
|
|
self.session.warn("error importing custom services from " \
|
|
"%s:\n%s" % (path, e))
|
|
|
|
def reset(self):
|
|
''' Called when config message with reset flag is received
|
|
'''
|
|
self.defaultservices.clear()
|
|
self.customservices.clear()
|
|
|
|
def get(self):
|
|
''' Get the list of available services.
|
|
'''
|
|
global servicelist
|
|
return servicelist
|
|
|
|
def getservicebyname(self, name):
|
|
''' Get a service class from the global servicelist given its name.
|
|
Returns None when the name is not found.
|
|
'''
|
|
global servicelist
|
|
for s in servicelist:
|
|
if s._name == name:
|
|
return s
|
|
return None
|
|
|
|
def getdefaultservices(self, type):
|
|
''' Get the list of default services that should be enabled for a
|
|
node for the given node type.
|
|
'''
|
|
r = []
|
|
if type in self.defaultservices:
|
|
defaults = self.defaultservices[type]
|
|
for name in defaults:
|
|
s = self.getservicebyname(name)
|
|
if s is None:
|
|
self.session.warn("default service %s is unknown" % name)
|
|
else:
|
|
r.append(s)
|
|
return r
|
|
|
|
def getcustomservice(self, objid, service):
|
|
''' Get any custom service configured for the given node that
|
|
matches the specified service name. If no custom service
|
|
is found, return the specified service.
|
|
'''
|
|
if objid in self.customservices:
|
|
for s in self.customservices[objid]:
|
|
if s._name == service._name:
|
|
return s
|
|
return service
|
|
|
|
def setcustomservice(self, objid, service, values):
|
|
''' Store service customizations in an instantiated service object
|
|
using a list of values that came from a config message.
|
|
'''
|
|
if service._custom:
|
|
s = service
|
|
else:
|
|
# instantiate the class, for storing config customization
|
|
s = service()
|
|
# values are new key=value format; not all keys need to be present
|
|
# a missing key means go with the default
|
|
if Configurable.haskeyvalues(values):
|
|
for v in values:
|
|
key, value = v.split('=', 1)
|
|
s.setvalue(key, value)
|
|
# old-style config, list of values
|
|
else:
|
|
s.fromvaluelist(values)
|
|
|
|
# assume custom service already in dict
|
|
if service._custom:
|
|
return
|
|
# add the custom service to dict
|
|
if objid in self.customservices:
|
|
self.customservices[objid] += (s, )
|
|
else:
|
|
self.customservices[objid] = (s, )
|
|
|
|
def addservicestonode(self, node, nodetype, services_str, verbose):
|
|
''' Populate the node.service list using (1) the list of services
|
|
requested from the services TLV, (2) using any custom service
|
|
configuration, or (3) using the default services for this node type.
|
|
'''
|
|
if services_str is not None:
|
|
services = services_str.split('|')
|
|
for name in services:
|
|
s = self.getservicebyname(name)
|
|
if s is None:
|
|
self.session.warn("configured service %s for node %s is " \
|
|
"unknown" % (name, node.name))
|
|
continue
|
|
if verbose:
|
|
self.session.info("adding configured service %s to " \
|
|
"node %s" % (s._name, node.name))
|
|
s = self.getcustomservice(node.objid, s)
|
|
node.addservice(s)
|
|
else:
|
|
services = self.getdefaultservices(nodetype)
|
|
for s in services:
|
|
if verbose:
|
|
self.session.info("adding default service %s to node %s" % \
|
|
(s._name, node.name))
|
|
s = self.getcustomservice(node.objid, s)
|
|
node.addservice(s)
|
|
|
|
def getallconfigs(self):
|
|
''' Return (nodenum, service) tuples for all stored configs.
|
|
Used when reconnecting to a session or opening XML.
|
|
'''
|
|
r = []
|
|
for nodenum in self.customservices:
|
|
for s in self.customservices[nodenum]:
|
|
r.append( (nodenum, s) )
|
|
return r
|
|
|
|
def getallfiles(self, service):
|
|
''' Return all customized files stored with a service.
|
|
Used when reconnecting to a session or opening XML.
|
|
'''
|
|
r = []
|
|
if not service._custom:
|
|
return r
|
|
for filename in service._configs:
|
|
data = self.getservicefiledata(service, filename)
|
|
if data is None:
|
|
continue
|
|
r.append( (filename, data) )
|
|
return r
|
|
|
|
def bootnodeservices(self, node):
|
|
''' Start all services on a node.
|
|
'''
|
|
services = sorted(node.services,
|
|
key=lambda service: service._startindex)
|
|
for s in services:
|
|
try:
|
|
t = float(s._starttime)
|
|
if t > 0.0:
|
|
fn = self.bootnodeservice
|
|
self.session.evq.add_event(t, fn, node, s, services)
|
|
continue
|
|
except ValueError:
|
|
pass
|
|
self.bootnodeservice(node, s, services)
|
|
|
|
def bootnodeservice(self, node, s, services):
|
|
''' Start a service on a node. Create private dirs, generate config
|
|
files, and execute startup commands.
|
|
'''
|
|
if s._custom:
|
|
self.bootnodecustomservice(node, s, services)
|
|
return
|
|
if node.verbose:
|
|
node.info("starting service %s (%s)" % (s._name, s._startindex))
|
|
for d in s._dirs:
|
|
try:
|
|
node.privatedir(d)
|
|
except Exception, e:
|
|
node.warn("Error making node %s dir %s: %s" % \
|
|
(node.name, d, e))
|
|
for filename in s.getconfigfilenames(node.objid, services):
|
|
cfg = s.generateconfig(node, filename, services)
|
|
node.nodefile(filename, cfg)
|
|
for cmd in s.getstartup(node, services):
|
|
try:
|
|
# NOTE: this wait=False can be problematic!
|
|
node.cmd(shlex.split(cmd), wait = False)
|
|
except Exception, e:
|
|
node.warn("error starting command %s: %s" % (cmd, e))
|
|
|
|
def bootnodecustomservice(self, node, s, services):
|
|
''' Start a custom service on a node. Create private dirs, use supplied
|
|
config files, and execute supplied startup commands.
|
|
'''
|
|
if node.verbose:
|
|
node.info("starting service %s (%s)(custom)" % (s._name, s._startindex))
|
|
for d in s._dirs:
|
|
try:
|
|
node.privatedir(d)
|
|
except Exception, e:
|
|
node.warn("Error making node %s dir %s: %s" % \
|
|
(node.name, d, e))
|
|
for i, filename in enumerate(s._configs):
|
|
if len(filename) == 0:
|
|
continue
|
|
cfg = self.getservicefiledata(s, filename)
|
|
if cfg is None:
|
|
cfg = s.generateconfig(node, filename, services)
|
|
# cfg may have a file:/// url for copying from a file
|
|
try:
|
|
if self.copyservicefile(node, filename, cfg):
|
|
continue
|
|
except IOError, e:
|
|
node.warn("Error copying service file %s" % filename)
|
|
node.exception(coreapi.CORE_EXCP_LEVEL_ERROR,
|
|
"service:%s" % s._name,
|
|
"error copying service file '%s': %s" % (filename, e))
|
|
continue
|
|
node.nodefile(filename, cfg)
|
|
|
|
for cmd in s._startup:
|
|
try:
|
|
# NOTE: this wait=False can be problematic!
|
|
node.cmd(shlex.split(cmd), wait = False)
|
|
except:
|
|
node.warn("error starting command %s" % cmd)
|
|
|
|
def copyservicefile(self, node, filename, cfg):
|
|
''' Given a configured service filename and config, determine if the
|
|
config references an existing file that should be copied.
|
|
Returns True for local files, False for generated.
|
|
'''
|
|
if cfg[:7] == 'file://':
|
|
src = cfg[7:]
|
|
src = src.split('\n')[0]
|
|
src = expandcorepath(src, node.session, node)
|
|
# TODO: glob here
|
|
node.nodefilecopy(filename, src, mode = 0644)
|
|
return True
|
|
return False
|
|
|
|
|
|
def validatenodeservices(self, node):
|
|
''' Run validation commands for all services on a node.
|
|
'''
|
|
services = sorted(node.services,
|
|
key=lambda service: service._startindex)
|
|
for s in services:
|
|
self.validatenodeservice(node, s, services)
|
|
|
|
def validatenodeservice(self, node, s, services):
|
|
''' Run the validation command(s) for a service.
|
|
'''
|
|
if node.verbose:
|
|
node.info("validating service %s (%s)" % (s._name, s._startindex))
|
|
if s._custom:
|
|
validate_cmds = s._validate
|
|
else:
|
|
validate_cmds = s.getvalidate(node, services)
|
|
for cmd in validate_cmds:
|
|
if node.verbose:
|
|
node.info("validating service %s using: %s" % (s._name, cmd))
|
|
try:
|
|
(status, result) = node.cmdresult(shlex.split(cmd))
|
|
if status != 0:
|
|
raise ValueError, "non-zero exit status"
|
|
except:
|
|
node.warn("validation command '%s' failed" % cmd)
|
|
node.exception(coreapi.CORE_EXCP_LEVEL_ERROR,
|
|
"service:%s" % s._name,
|
|
"validate command failed: %s" % cmd)
|
|
|
|
def stopnodeservices(self, node):
|
|
''' Stop all services on a node.
|
|
'''
|
|
services = sorted(node.services,
|
|
key=lambda service: service._startindex)
|
|
for s in services:
|
|
self.stopnodeservice(node, s)
|
|
|
|
def stopnodeservice(self, node, s):
|
|
''' Stop a service on a node.
|
|
'''
|
|
for cmd in s._shutdown:
|
|
try:
|
|
# NOTE: this wait=False can be problematic!
|
|
node.cmd(shlex.split(cmd), wait = False)
|
|
except:
|
|
node.warn("error running stop command %s" % cmd)
|
|
|
|
|
|
def configure_request(self, msg):
|
|
''' Receive configuration message for configuring services.
|
|
With a request flag set, a list of services has been requested.
|
|
When the opaque field is present, a specific service is being
|
|
configured or requested.
|
|
'''
|
|
objname = msg.gettlv(coreapi.CORE_TLV_CONF_OBJ)
|
|
conftype = msg.gettlv(coreapi.CORE_TLV_CONF_TYPE)
|
|
nodenum = msg.gettlv(coreapi.CORE_TLV_CONF_NODE)
|
|
sessionnum = msg.gettlv(coreapi.CORE_TLV_CONF_SESSION)
|
|
opaque = msg.gettlv(coreapi.CORE_TLV_CONF_OPAQUE)
|
|
|
|
# send back a list of available services
|
|
if opaque is None:
|
|
global servicelist
|
|
tf = coreapi.CONF_TYPE_FLAGS_NONE
|
|
datatypes = tuple(repeat(coreapi.CONF_DATA_TYPE_BOOL,
|
|
len(servicelist)))
|
|
vals = "|".join(repeat('0', len(servicelist)))
|
|
names = map(lambda x: x._name, servicelist)
|
|
captions = "|".join(names)
|
|
possiblevals = ""
|
|
for s in servicelist:
|
|
if s._custom_needed:
|
|
possiblevals += '1'
|
|
possiblevals += '|'
|
|
groups = self.buildgroups(servicelist)
|
|
# send back the properties for this service
|
|
else:
|
|
if nodenum is None:
|
|
return None
|
|
n = self.session.obj(nodenum)
|
|
if n is None:
|
|
self.session.warn("Request to configure service %s for " \
|
|
"unknown node %s" % (svc._name, nodenum))
|
|
return None
|
|
servicesstring = opaque.split(':')
|
|
services = self.servicesfromopaque(opaque, n.objid)
|
|
if len(services) < 1:
|
|
return None
|
|
if len(servicesstring) == 3:
|
|
# a file request: e.g. "service:zebra:quagga.conf"
|
|
return self.getservicefile(services, n, servicesstring[2])
|
|
|
|
# the first service in the list is the one being configured
|
|
svc = services[0]
|
|
# send back:
|
|
# dirs, configs, startindex, startup, shutdown, metadata, config
|
|
tf = coreapi.CONF_TYPE_FLAGS_UPDATE
|
|
datatypes = tuple(repeat(coreapi.CONF_DATA_TYPE_STRING,
|
|
len(svc.keys)))
|
|
vals = svc.tovaluelist(n, services)
|
|
captions = None
|
|
possiblevals = None
|
|
groups = None
|
|
|
|
tlvdata = ""
|
|
if nodenum is not None:
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_NODE,
|
|
nodenum)
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_OBJ,
|
|
self._name)
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_TYPE, tf)
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_DATA_TYPES,
|
|
datatypes)
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_VALUES,
|
|
vals)
|
|
if captions:
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_CAPTIONS,
|
|
captions)
|
|
if possiblevals:
|
|
tlvdata += coreapi.CoreConfTlv.pack(
|
|
coreapi.CORE_TLV_CONF_POSSIBLE_VALUES, possiblevals)
|
|
if groups:
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_GROUPS,
|
|
groups)
|
|
if sessionnum is not None:
|
|
tlvdata += coreapi.CoreConfTlv.pack(
|
|
coreapi.CORE_TLV_CONF_SESSION, sessionnum)
|
|
if opaque:
|
|
tlvdata += coreapi.CoreConfTlv.pack(coreapi.CORE_TLV_CONF_OPAQUE,
|
|
opaque)
|
|
return coreapi.CoreConfMessage.pack(0, tlvdata)
|
|
|
|
|
|
def configure_values(self, msg, values):
|
|
''' Receive configuration message for configuring services.
|
|
With a request flag set, a list of services has been requested.
|
|
When the opaque field is present, a specific service is being
|
|
configured or requested.
|
|
'''
|
|
nodenum = msg.gettlv(coreapi.CORE_TLV_CONF_NODE)
|
|
opaque = msg.gettlv(coreapi.CORE_TLV_CONF_OPAQUE)
|
|
|
|
errmsg = "services config message that I don't know how to handle"
|
|
if values is None:
|
|
self.session.info(errmsg)
|
|
return None
|
|
else:
|
|
values = values.split('|')
|
|
|
|
if opaque is None:
|
|
# store default services for a node type in self.defaultservices[]
|
|
data_types = msg.gettlv(coreapi.CORE_TLV_CONF_DATA_TYPES)
|
|
if values is None or data_types is None or \
|
|
data_types[0] != coreapi.CONF_DATA_TYPE_STRING:
|
|
self.session.info(errmsg)
|
|
return None
|
|
key = values.pop(0)
|
|
self.defaultservices[key] = values
|
|
self.session.info("default services for type %s set to %s" % \
|
|
(key, values))
|
|
else:
|
|
# store service customized config in self.customservices[]
|
|
if nodenum is None:
|
|
return None
|
|
services = self.servicesfromopaque(opaque, nodenum)
|
|
if len(services) < 1:
|
|
return None
|
|
svc = services[0]
|
|
self.setcustomservice(nodenum, svc, values)
|
|
return None
|
|
|
|
def servicesfromopaque(self, opaque, objid):
|
|
''' Build a list of services from an opaque data string.
|
|
'''
|
|
services = []
|
|
servicesstring = opaque.split(':')
|
|
if servicesstring[0] != "service":
|
|
return []
|
|
servicenames = servicesstring[1].split(',')
|
|
for name in servicenames:
|
|
s = self.getservicebyname(name)
|
|
s = self.getcustomservice(objid, s)
|
|
if s is None:
|
|
self.session.warn("Request for unknown service '%s'" % name)
|
|
return []
|
|
services.append(s)
|
|
return services
|
|
|
|
def buildgroups(self, servicelist):
|
|
''' Build a string of groups for use in a configuration message given
|
|
a list of services. The group list string has the format
|
|
"title1:1-5|title2:6-9|10-12", where title is an optional group title
|
|
and i-j is a numeric range of value indices; groups are
|
|
separated by commas.
|
|
'''
|
|
i = 0
|
|
r = ""
|
|
lastgroup = "<undefined>"
|
|
for service in servicelist:
|
|
i += 1
|
|
group = service._group
|
|
if group != lastgroup:
|
|
lastgroup = group
|
|
# finish previous group
|
|
if i > 1:
|
|
r += "-%d|" % (i -1)
|
|
# optionally include group title
|
|
if group == "":
|
|
r += "%d" % i
|
|
else:
|
|
r += "%s:%d" % (group, i)
|
|
# finish the last group list
|
|
if i > 0:
|
|
r += "-%d" % i
|
|
return r
|
|
|
|
def getservicefile(self, services, node, filename):
|
|
''' Send a File Message when the GUI has requested a service file.
|
|
The file data is either auto-generated or comes from an existing config.
|
|
'''
|
|
svc = services[0]
|
|
# get the filename and determine the config file index
|
|
if svc._custom:
|
|
cfgfiles = svc._configs
|
|
else:
|
|
cfgfiles = svc.getconfigfilenames(node.objid, services)
|
|
if filename not in cfgfiles:
|
|
self.session.warn("Request for unknown file '%s' for service '%s'" \
|
|
% (filename, services[0]))
|
|
return None
|
|
|
|
# get the file data
|
|
data = self.getservicefiledata(svc, filename)
|
|
if data is None:
|
|
data = "%s" % (svc.generateconfig(node, filename, services))
|
|
else:
|
|
data = "%s" % data
|
|
filetypestr = "service:%s" % svc._name
|
|
|
|
# send a file message
|
|
flags = coreapi.CORE_API_ADD_FLAG
|
|
tlvdata = coreapi.CoreFileTlv.pack(coreapi.CORE_TLV_FILE_NODE, node.objid)
|
|
tlvdata += coreapi.CoreFileTlv.pack(coreapi.CORE_TLV_FILE_NAME, filename)
|
|
tlvdata += coreapi.CoreFileTlv.pack(coreapi.CORE_TLV_FILE_TYPE, filetypestr)
|
|
tlvdata += coreapi.CoreFileTlv.pack(coreapi.CORE_TLV_FILE_DATA, data)
|
|
reply = coreapi.CoreFileMessage.pack(flags, tlvdata)
|
|
return reply
|
|
|
|
def getservicefiledata(self, service, filename):
|
|
''' Get the customized file data associated with a service. Return None
|
|
for invalid filenames or missing file data.
|
|
'''
|
|
try:
|
|
i = service._configs.index(filename)
|
|
except ValueError:
|
|
return None
|
|
if i >= len(service._configtxt) or service._configtxt[i] is None:
|
|
return None
|
|
return service._configtxt[i]
|
|
|
|
def setservicefile(self, nodenum, type, filename, srcname, data):
|
|
''' Receive a File Message from the GUI and store the customized file
|
|
in the service config. The filename must match one from the list of
|
|
config files in the service.
|
|
'''
|
|
if len(type.split(':')) < 2:
|
|
self.session.warn("Received file type did not contain service info.")
|
|
return
|
|
if srcname is not None:
|
|
raise NotImplementedError
|
|
(svcid, svcname) = type.split(':')[:2]
|
|
svc = self.getservicebyname(svcname)
|
|
svc = self.getcustomservice(nodenum, svc)
|
|
if svc is None:
|
|
self.session.warn("Received filename for unknown service '%s'" % \
|
|
svcname)
|
|
return
|
|
cfgfiles = svc._configs
|
|
if filename not in cfgfiles:
|
|
self.session.warn("Received unknown file '%s' for service '%s'" \
|
|
% (filename, svcname))
|
|
return
|
|
i = cfgfiles.index(filename)
|
|
configtxtlist = list(svc._configtxt)
|
|
numitems = len(configtxtlist)
|
|
if numitems < i+1:
|
|
# add empty elements to list to support index assignment
|
|
for j in range(1, (i + 2) - numitems):
|
|
configtxtlist += None,
|
|
configtxtlist[i] = data
|
|
svc._configtxt = configtxtlist
|
|
|
|
def handleevent(self, msg):
|
|
''' Handle an Event Message used to start, stop, restart, or validate
|
|
a service on a given node.
|
|
'''
|
|
eventtype = msg.gettlv(coreapi.CORE_TLV_EVENT_TYPE)
|
|
nodenum = msg.gettlv(coreapi.CORE_TLV_EVENT_NODE)
|
|
name = msg.gettlv(coreapi.CORE_TLV_EVENT_NAME)
|
|
try:
|
|
node = self.session.obj(nodenum)
|
|
except KeyError:
|
|
self.session.warn("Ignoring event for service '%s', unknown node " \
|
|
"'%s'" % (name, nodenum))
|
|
return
|
|
|
|
services = self.servicesfromopaque(name, nodenum)
|
|
for s in services:
|
|
if eventtype == coreapi.CORE_EVENT_STOP or \
|
|
eventtype == coreapi.CORE_EVENT_RESTART:
|
|
self.stopnodeservice(node, s)
|
|
if eventtype == coreapi.CORE_EVENT_START or \
|
|
eventtype == coreapi.CORE_EVENT_RESTART:
|
|
if s._custom:
|
|
cmds = s._startup
|
|
else:
|
|
cmds = s.getstartup(node, services)
|
|
for cmd in cmds:
|
|
try:
|
|
node.cmd(shlex.split(cmd), wait = False)
|
|
except:
|
|
node.warn("error starting command %s" % cmd)
|
|
if eventtype == coreapi.CORE_EVENT_PAUSE:
|
|
self.validatenodeservice(node, s, services)
|
|
|
|
|
|
class CoreService(object):
|
|
''' Parent class used for defining services.
|
|
'''
|
|
# service name should not include spaces
|
|
_name = ""
|
|
# group string allows grouping services together
|
|
_group = ""
|
|
# list name(s) of services that this service depends upon
|
|
_depends = ()
|
|
keys = ["dirs","files","startidx","cmdup","cmddown","cmdval","meta","starttime"]
|
|
# private, per-node directories required by this service
|
|
_dirs = ()
|
|
# config files written by this service
|
|
_configs = ()
|
|
# index used to determine start order with other services
|
|
_startindex = 0
|
|
# time in seconds after runtime to run startup commands
|
|
_starttime = ""
|
|
# list of startup commands
|
|
_startup = ()
|
|
# list of shutdown commands
|
|
_shutdown = ()
|
|
# list of validate commands
|
|
_validate = ()
|
|
# metadata associated with this service
|
|
_meta = ""
|
|
# custom configuration text
|
|
_configtxt = ()
|
|
_custom = False
|
|
_custom_needed = False
|
|
|
|
def __init__(self):
|
|
''' Services are not necessarily instantiated. Classmethods may be used
|
|
against their config. Services are instantiated when a custom
|
|
configuration is used to override their default parameters.
|
|
'''
|
|
self._custom = True
|
|
|
|
@classmethod
|
|
def getconfigfilenames(cls, nodenum, services):
|
|
''' Return the tuple of configuration file filenames. This default method
|
|
returns the cls._configs tuple, but this method may be overriden to
|
|
provide node-specific filenames that may be based on other services.
|
|
'''
|
|
return cls._configs
|
|
|
|
@classmethod
|
|
def generateconfig(cls, node, filename, services):
|
|
''' Generate configuration file given a node object. The filename is
|
|
provided to allow for multiple config files. The other services are
|
|
provided to allow interdependencies (e.g. zebra and OSPF).
|
|
Return the configuration string to be written to a file or sent
|
|
to the GUI for customization.
|
|
'''
|
|
raise NotImplementedError
|
|
|
|
@classmethod
|
|
def getstartup(cls, node, services):
|
|
''' Return the tuple of startup commands. This default method
|
|
returns the cls._startup tuple, but this method may be
|
|
overriden to provide node-specific commands that may be
|
|
based on other services.
|
|
'''
|
|
return cls._startup
|
|
|
|
@classmethod
|
|
def getvalidate(cls, node, services):
|
|
''' Return the tuple of validate commands. This default method
|
|
returns the cls._validate tuple, but this method may be
|
|
overriden to provide node-specific commands that may be
|
|
based on other services.
|
|
'''
|
|
return cls._validate
|
|
|
|
@classmethod
|
|
def tovaluelist(cls, node, services):
|
|
''' Convert service properties into a string list of key=value pairs,
|
|
separated by "|".
|
|
'''
|
|
valmap = [cls._dirs, cls._configs, cls._startindex, cls._startup,
|
|
cls._shutdown, cls._validate, cls._meta, cls._starttime]
|
|
if not cls._custom:
|
|
# this is always reached due to classmethod
|
|
valmap[valmap.index(cls._configs)] = \
|
|
cls.getconfigfilenames(node.objid, services)
|
|
valmap[valmap.index(cls._startup)] = \
|
|
cls.getstartup(node, services)
|
|
vals = map( lambda a,b: "%s=%s" % (a, str(b)), cls.keys, valmap)
|
|
return "|".join(vals)
|
|
|
|
def fromvaluelist(self, values):
|
|
''' Convert list of values into properties for this instantiated
|
|
(customized) service.
|
|
'''
|
|
# TODO: support empty value? e.g. override default meta with ''
|
|
for key in self.keys:
|
|
try:
|
|
self.setvalue(key, values[self.keys.index(key)])
|
|
except IndexError:
|
|
# old config does not need to have new keys
|
|
pass
|
|
|
|
def setvalue(self, key, value):
|
|
if key not in self.keys:
|
|
raise ValueError
|
|
# this handles data conversion to int, string, and tuples
|
|
if value:
|
|
if key == "startidx":
|
|
value = int(value)
|
|
elif key == "meta":
|
|
value = str(value)
|
|
else:
|
|
value = maketuplefromstr(value, str)
|
|
|
|
if key == "dirs":
|
|
self._dirs = value
|
|
elif key == "files":
|
|
self._configs = value
|
|
elif key == "startidx":
|
|
self._startindex = value
|
|
elif key == "cmdup":
|
|
self._startup = value
|
|
elif key == "cmddown":
|
|
self._shutdown = value
|
|
elif key == "cmdval":
|
|
self._validate = value
|
|
elif key == "meta":
|
|
self._meta = value
|
|
elif key == "starttime":
|
|
self._starttime = value
|