afonso/core-extra
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

refactored service interaction use names with a _, and cleanup up some of the CoreServices methods

Browse source
This commit is contained in:
Blake J. Harnden 2018-06-15 14:03:27 -07:00
parent 0bf9c99910
commit e80736061f
27 changed files with 958 additions and 885 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

133
daemon/core/corehandlers.py
View file

@ -42,8 +42,8 @@ from core.enumerations import SessionTlvs
from core.misc import nodeutils
from core.misc import structutils
from core.misc import utils
from core.service import CoreService
from core.service import ServiceManager
from core.service import ServiceShim
class CoreHandler(SocketServer.BaseRequestHandler):
@ -1072,10 +1072,10 @@ class CoreHandler(SocketServer.BaseRequestHandler):
# sort groups by name and map services to groups
groups = set()
group_map = {}
for service in ServiceManager.services.itervalues():
group = service._group
for service_name in ServiceManager.services.itervalues():
group = service_name.group
groups.add(group)
group_map.setdefault(group, []).append(service)
group_map.setdefault(group, []).append(service_name)
groups = sorted(groups, key=lambda x: x.lower())
# define tlv values in proper order
@ -1086,15 +1086,15 @@ class CoreHandler(SocketServer.BaseRequestHandler):
start_index = 1
logger.info("sorted groups: %s", groups)
for group in groups:
services = sorted(group_map[group], key=lambda x: x._name.lower())
services = sorted(group_map[group], key=lambda x: x.name.lower())
logger.info("sorted services for group(%s): %s", group, services)
end_index = start_index + len(services) - 1
group_strings.append("%s:%s-%s" % (group, start_index, end_index))
start_index = start_index + len(services)
for service in services:
captions.append(service._name)
start_index += len(services)
for service_name in services:
captions.append(service_name.name)
values.append("0")
if service._custom_needed:
if service_name.custom_needed:
possible_values.append("1")
else:
possible_values.append("")
@ -1111,30 +1111,31 @@ class CoreHandler(SocketServer.BaseRequestHandler):
node = self.session.get_object(node_id)
if node is None:
logger.warn("Request to configure service for unknown node %s", node_id)
logger.warn("request to configure service for unknown node %s", node_id)
return replies
servicesstring = opaque.split(':')
services, unknown = self.session.services.servicesfromopaque(opaque, node.objid)
for u in unknown:
logger.warn("Request for unknown service '%s'" % u)
services = ServiceShim.servicesfromopaque(opaque)
if not services:
return replies
servicesstring = opaque.split(":")
if len(servicesstring) == 3:
# a file request: e.g. "service:zebra:quagga.conf"
file_data = self.session.services.getservicefile(services, node, servicesstring[2])
file_name = servicesstring[2]
service_name = services[0]
file_data = self.session.services.getservicefile(service_name, node, file_name, services)
self.session.broadcast_file(file_data)
# short circuit this request early to avoid returning response below
return replies
# the first service in the list is the one being configured
svc = services[0]
service_name = services[0]
# send back:
# dirs, configs, startindex, startup, shutdown, metadata, config
type_flag = ConfigFlags.UPDATE.value
data_types = tuple(repeat(ConfigDataTypes.STRING.value, len(svc.keys)))
values = svc.tovaluelist(node, services)
data_types = tuple(repeat(ConfigDataTypes.STRING.value, len(ServiceShim.keys)))
service = self.session.services.getcustomservice(node_id, service_name, default_service=True)
values = ServiceShim.tovaluelist(service, node, services)
captions = None
possible_values = None
groups = None
@ -1173,15 +1174,21 @@ class CoreHandler(SocketServer.BaseRequestHandler):
self.session.services.defaultservices[key] = values
logger.debug("default services for type %s set to %s", key, values)
elif node_id:
# store service customized config in self.customservices[]
services, unknown = self.session.services.servicesfromopaque(opaque, node_id)
for u in unknown:
logger.warn("request for unknown service: %s", u)
services = ServiceShim.servicesfromopaque(opaque)
if services:
svc = services[0]
service_name = services[0]
# set custom service for node
self.session.services.setcustomservice(node_id, service_name)
# set custom values for custom service
service = self.session.services.getcustomservice(node_id, service_name)
if not service:
raise ValueError("custom service(%s) for node(%s) does not exist", service_name, node_id)
values = ConfigShim.str_to_dict(values)
self.session.services.setcustomservice(node_id, svc, values)
for name, value in values.iteritems():
ServiceShim.setvalue(service, name, value)
return replies
@ -1324,7 +1331,7 @@ class CoreHandler(SocketServer.BaseRequestHandler):
if file_type is not None:
if file_type.startswith("service:"):
_, service_name = file_type.split(':')[:2]
self.session.add_node_service_file(node_num, service_name, file_name, source_name, data)
self.session.services.setservicefile(node_num, service_name, file_name, data)
return ()
elif file_type.startswith("hook:"):
_, state = file_type.split(':')[:2]
@ -1430,7 +1437,7 @@ class CoreHandler(SocketServer.BaseRequestHandler):
# TODO: register system for event message handlers,
# like confobjs
if name.startswith("service:"):
self.session.services_event(event_data)
self.handle_service_event(event_data)
handled = True
elif name.startswith("mobility:"):
self.session.mobility_event(event_data)
@ -1463,6 +1470,72 @@ class CoreHandler(SocketServer.BaseRequestHandler):
return ()
def handle_service_event(self, event_data):
"""
Handle an Event Message used to start, stop, restart, or validate
a service on a given node.
:param EventData event_data: event data to handle
:return: nothing
"""
event_type = event_data.event_type
node_id = event_data.node
name = event_data.name
try:
node = self.session.get_object(node_id)
except KeyError:
logger.warn("ignoring event for service '%s', unknown node '%s'", name, node_id)
return
fail = ""
unknown = []
services = ServiceShim.servicesfromopaque(name)
for service_name in services:
service = self.session.services.getcustomservice(node_id, service_name, default_service=True)
if not service:
unknown.append(service_name)
continue
if event_type == EventTypes.STOP.value or event_type == EventTypes.RESTART.value:
status = self.session.services.stopnodeservice(node, service)
if status != "0":
fail += "Stop %s," % service.name
if event_type == EventTypes.START.value or event_type == EventTypes.RESTART.value:
status = self.session.services.node_service_startup(node, service, services)
if status != "0":
fail += "Start %s(%s)," % service.name
if event_type == EventTypes.PAUSE.value:
status = self.session.services.validatenodeservice(node, service, services)
if status != 0:
fail += "%s," % service.name
if event_type == EventTypes.RECONFIGURE.value:
self.session.services.node_service_reconfigure(node, service, services)
fail_data = ""
if len(fail) > 0:
fail_data += "Fail:" + fail
unknown_data = ""
num = len(unknown)
if num > 0:
for u in unknown:
unknown_data += u
if num > 1:
unknown_data += ", "
num -= 1
logger.warn("Event requested for unknown service(s): %s", unknown_data)
unknown_data = "Unknown:" + unknown_data
event_data = EventData(
node=node_id,
event_type=event_type,
name=name,
data=fail_data + ";" + unknown_data,
time="%s" % time.time()
)
self.session.broadcast_event(event_data)
def handle_session_message(self, message):
"""
Session Message handler
@ -1620,10 +1693,10 @@ class CoreHandler(SocketServer.BaseRequestHandler):
# service customizations
service_configs = self.session.services.getallconfigs()
for node_id, service in service_configs:
opaque = "service:%s" % service._name
data_types = tuple(repeat(ConfigDataTypes.STRING.value, len(CoreService.keys)))
opaque = "service:%s" % service.name
data_types = tuple(repeat(ConfigDataTypes.STRING.value, len(ServiceShim.keys)))
node = self.session.get_object(node_id)
values = CoreService.tovaluelist(node, node.services)
values = ServiceShim.tovaluelist(service, node, node.services)
config_data = ConfigData(
message_type=0,
node=node_id,

2
daemon/core/coreobj.py
View file

@ -218,7 +218,7 @@ class PyCoreObj(object):
if hasattr(self, "services") and len(self.services) != 0:
nodeservices = []
for s in self.services:
nodeservices.append(s._name)
nodeservices.append(s.name)
services = "|".join(nodeservices)
node_data = NodeData(

27
daemon/core/emulator/coreemu.py
View file

@ -507,8 +507,7 @@ class EmuSession(Session):
if _type in [NodeTypes.DEFAULT, NodeTypes.PHYSICAL]:
node.type = node_options.model
logger.debug("set node type: %s", node.type)
services = "|".join(node_options.services) or None
self.services.addservicestonode(node, node.type, services)
self.services.addservicestonode(node, node.type, node_options.services)
# boot nodes if created after runtime, LcxNodes, Physical, and RJ45 are all PyCoreNodes
is_boot_node = isinstance(node, PyCoreNode) and not nodeutils.is_node(node, NodeTypes.RJ45)
@ -697,21 +696,6 @@ class EmuSession(Session):
state = ":%s" % state
self.set_hook(state, file_name, source_name, data)
def add_node_service_file(self, node_id, service_name, file_name, source_name, data):
"""
Add a service file for a node.
:param int node_id: node to add service file to
:param str service_name: service file to add
:param str file_name: file name to use
:param str source_name: source file
:param str data: file data to save
:return: nothing
"""
# hack to conform with old logic until updated
service_name = ":%s" % service_name
self.services.setservicefile(node_id, service_name, file_name, source_name, data)
def add_node_file(self, node_id, source_name, file_name, data):
"""
Add a file to a node.
@ -749,15 +733,6 @@ class EmuSession(Session):
"""
self.event_loop.run()
def services_event(self, event_data):
"""
Handle a service event.
:param core.data.EventData event_data: event data to handle
:return:
"""
self.services.handleevent(event_data)
def mobility_event(self, event_data):
"""
Handle a mobility event.

684
daemon/core/service.py
View file

@ -6,18 +6,110 @@ The CoreServices class handles configuration messages for sending
a list of available services to the GUI and for configuring individual
services.
"""
import time
from core import CoreCommandError
from core import logger
from core.data import EventData
from core.data import FileData
from core.enumerations import EventTypes
from core.enumerations import MessageFlags
from core.enumerations import RegisterTlvs
from core.misc import utils
class ServiceShim(object):
keys = ["dirs", "files", "startidx", "cmdup", "cmddown", "cmdval", "meta", "starttime"]
@classmethod
def tovaluelist(cls, service, node, services):
"""
Convert service properties into a string list of key=value pairs,
separated by "|".
:param CoreService service: service to get value list for
:param core.netns.nodes.CoreNode node: node to get value list for
:param list[CoreService] services: services for node
:return: value list string
:rtype: str
"""
valmap = [service.dirs, service.configs, service.startindex, service.startup,
service.shutdown, service.validate, service.meta, service.starttime]
if not service.custom:
# this is always reached due to classmethod
valmap[valmap.index(service.configs)] = service.getconfigfilenames(node.objid, services)
valmap[valmap.index(service.startup)] = service.getstartup(node, services)
vals = map(lambda a, b: "%s=%s" % (a, str(b)), cls.keys, valmap)
return "|".join(vals)
@classmethod
def fromvaluelist(cls, service, values):
"""
Convert list of values into properties for this instantiated
(customized) service.
:param CoreService service: service to get value list for
:param dict values: value list to set properties from
:return: nothing
"""
# TODO: support empty value? e.g. override default meta with ''
for key in cls.keys:
try:
cls.setvalue(service, key, values[cls.keys.index(key)])
except IndexError:
# old config does not need to have new keys
logger.exception("error indexing into key")
@classmethod
def setvalue(cls, service, key, value):
"""
Set values for this service.
:param CoreService service: service to get value list for
:param str key: key to set value for
:param value: value of key to set
:return: nothing
"""
if key not in cls.keys:
raise ValueError('key `%s` not in `%s`' % (key, cls.keys))
# 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 = utils.make_tuple_fromstr(value, str)
if key == "dirs":
service.dirs = value
elif key == "files":
service.configs = value
elif key == "startidx":
service.startindex = value
elif key == "cmdup":
service.startup = value
elif key == "cmddown":
service.shutdown = value
elif key == "cmdval":
service.validate = value
elif key == "meta":
service.meta = value
elif key == "starttime":
service.starttime = value
@classmethod
def servicesfromopaque(self, opaque):
"""
Build a list of services from an opaque data string.
:param str opaque: opaque data string
:return: services
:rtype: list
"""
servicesstring = opaque.split(':')
if servicesstring[0] != "service":
return []
return servicesstring[1].split(',')
class ServiceManager(object):
"""
Manages services available for CORE nodes to use.
@ -33,7 +125,7 @@ class ServiceManager(object):
:return: nothing
"""
logger.info("loading service: %s", service.__name__)
name = service._name
name = service.name
if name in cls.services:
raise ValueError("duplicate service being added: %s" % name)
cls.services[name] = service
@ -45,7 +137,7 @@ class ServiceManager(object):
:param str name: name of the service to retrieve
:return: service if it exists, None otherwise
:rtype: CoreService
:rtype: CoreService.class
"""
return cls.services.get(name)
@ -60,7 +152,7 @@ class ServiceManager(object):
"""
services = utils.load_classes(path, CoreService)
for service in services:
if not service._name:
if not service.name:
continue
service.on_load()
cls.add(service)
@ -76,7 +168,6 @@ class CoreServices(object):
"""
name = "services"
config_type = RegisterTlvs.UTILITY.value
_invalid_custom_names = ("core", "api", "emane", "misc", "netns", "phys", "services")
def __init__(self, session):
"""
@ -84,7 +175,6 @@ class CoreServices(object):
:param core.session.Session session: session this manager is tied to
"""
# ConfigurableManager.__init__(self)
self.session = session
# dict of default services tuples, key is node type
self.defaultservices = {}
@ -109,99 +199,79 @@ class CoreServices(object):
:param service_type: service type to get default services for
:return: default services
:rtype: list
:rtype: list[CoreService]
"""
logger.debug("getting default services for type: %s", service_type)
results = []
if service_type in self.defaultservices:
defaults = self.defaultservices[service_type]
for name in defaults:
logger.debug("checking for service with service manager: %s", name)
service = ServiceManager.get(name)
if not service:
logger.warn("default service %s is unknown", name)
else:
results.append(service)
defaults = self.defaultservices.get(service_type, [])
for name in defaults:
logger.debug("checking for service with service manager: %s", name)
service = ServiceManager.get(name)
if not service:
logger.warn("default service %s is unknown", name)
else:
results.append(service)
return results
def getcustomservice(self, object_id, service):
def getcustomservice(self, node_id, service_name, default_service=False):
"""
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.
:param int object_id: object id to get service from
:param CoreService service: custom service to retrieve
:param int node_id: object id to get service from
:param str service_name: name of service to retrieve
:param bool default_service: True to return default service when custom does not exist, False returns None
:return: custom service from the node
:rtype: CoreService
"""
if object_id in self.customservices:
for s in self.customservices[object_id]:
if s._name == service._name:
return s
return service
node_services = self.customservices.setdefault(node_id, {})
default = None
if default_service:
default = ServiceManager.get(service_name)
return node_services.get(service_name, default)
def setcustomservice(self, object_id, service, config):
def setcustomservice(self, node_id, service_name):
"""
Store service customizations in an instantiated service object
using a list of values that came from a config message.
:param int object_id: object id to set custom service for
:param class service: service to set
:param dict config: values to
:return:
"""
logger.debug("setting custom service(%s) for node(%s): %s", object_id, service, config)
if service._custom:
s = service
else:
# instantiate the class, for storing config customization
s = service()
# set custom service configuration
for name, value in config.iteritems():
s.setvalue(name, value)
# assume custom service already in dict
if service._custom:
return
# add the custom service to dict
if object_id in self.customservices:
self.customservices[object_id] += (s,)
else:
self.customservices[object_id] = (s,)
def addservicestonode(self, node, nodetype, services_str):
"""
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.
:param core.coreobj.PyCoreNode node: node to add services to
:param str nodetype: node type to add services to
:param str services_str: string formatted service list
:param int node_id: object id to set custom service for
:param str service_name: name of service to set
:return: nothing
"""
if services_str is not None:
logger.info("setting custom services for node(%s)", node.name)
services = services_str.split("|")
for name in services:
s = ServiceManager.get(name)
if s is None:
logger.warn("configured service %s for node %s is unknown", name, node.name)
continue
logger.info("adding service to node(%s): %s", node.name, s._name)
s = self.getcustomservice(node.objid, s)
node.addservice(s)
else:
logger.info("setting default services for node(%s) type (%s)", node.name, nodetype)
services = self.getdefaultservices(nodetype)
for s in services:
logger.info("adding service to node(%s): %s", node.name, s._name)
s = self.getcustomservice(node.objid, s)
node.addservice(s)
logger.debug("setting custom service(%s) for node: %s", node_id, service_name)
service = self.getcustomservice(node_id, service_name)
if not service:
service_class = ServiceManager.get(service_name)
service = service_class()
def getallconfigs(self, use_clsmap=True):
# add the custom service to dict
node_services = self.customservices.setdefault(node_id, {})
node_services[service.name] = service
def addservicestonode(self, node, node_type, services=None):
"""
Add services to a node.
:param core.coreobj.PyCoreNode node: node to add services to
:param str node_type: node type to add services to
:param list[str] services: services to add to node
:return: nothing
"""
if not services:
logger.info("using default services for node(%s) type(%s)", node.name, node_type)
services = self.defaultservices.get(node_type, [])
logger.info("setting services for node(%s): %s", node.name, services)
for service_name in services:
service = self.getcustomservice(node.objid, service_name, default_service=True)
if not service:
logger.warn("unknown service(%s) for node(%s)", service_name, node.name)
continue
logger.info("adding service to node(%s): %s", node.name, service_name)
node.addservice(service)
def getallconfigs(self):
"""
Return (nodenum, service) tuples for all stored configs. Used when reconnecting to a
session or opening XML.
@ -211,9 +281,9 @@ class CoreServices(object):
:rtype: list
"""
configs = []
for nodenum in self.customservices:
for service in self.customservices[nodenum]:
configs.append((nodenum, service))
for node_id in self.customservices.iterkeys():
for service in self.customservices[node_id].itervalues():
configs.append((node_id, service))
return configs
def getallfiles(self, service):
@ -226,11 +296,11 @@ class CoreServices(object):
"""
files = []
if not service._custom:
if not service.custom:
return files
for filename in service._configs:
data = self.getservicefiledata(service, filename)
for filename in service.configs:
data = service.configtxt.get(filename)
if data is None:
continue
files.append((filename, data))
@ -244,19 +314,19 @@ class CoreServices(object):
:param core.netns.vnode.LxcNode node: node to start services on
:return: nothing
"""
services = sorted(node.services, key=lambda service: service._startindex)
services = sorted(node.services, key=lambda x: x.startindex)
use_startup_service = any(map(self.is_startup_service, services))
for s in services:
if len(str(s._starttime)) > 0:
for service in services:
if len(str(service.starttime)) > 0:
try:
t = float(s._starttime)
if t > 0.0:
starttime = float(service.starttime)
if starttime > 0.0:
fn = self.bootnodeservice
self.session.event_loop.add_event(t, fn, node, s, services, False)
self.session.event_loop.add_event(starttime, fn, node, service, services, False)
continue
except ValueError:
logger.exception("error converting start time to float")
self.bootnodeservice(node, s, services, use_startup_service)
self.bootnodeservice(node, service, services, use_startup_service)
def bootnodeservice(self, node, service, services, use_startup_service):
"""
@ -269,12 +339,12 @@ class CoreServices(object):
:param bool use_startup_service: flag to use startup services or not
:return: nothing
"""
if service._custom:
if service.custom:
self.bootnodecustomservice(node, service, services, use_startup_service)
return
logger.info("starting node(%s) service: %s (%s)", node.name, service._name, service._startindex)
for directory in service._dirs:
logger.info("starting node(%s) service: %s (%s)", node.name, service.name, service.startindex)
for directory in service.dirs:
node.privatedir(directory)
for filename in service.getconfigfilenames(node.objid, services):
@ -299,18 +369,17 @@ class CoreServices(object):
:param bool use_startup_service: flag to use startup services or not
:return: nothing
"""
logger.info("starting service(%s) %s (%s)(custom)", service, service._name, service._startindex)
for directory in service._dirs:
logger.info("starting node(%s) service(custom): %s (%s)", node.name, service.name, service.startindex)
for directory in service.dirs:
node.privatedir(directory)
logger.info("service configurations: %s", service._configs)
for i, filename in enumerate(service._configs):
logger.info("service configurations: %s", service.configs)
for filename in service.configs:
logger.info("generating service config: %s", filename)
if len(filename) == 0:
continue
cfg = self.getservicefiledata(service, filename)
cfg = service.configtxt.get(filename)
if cfg is None:
cfg = service.generateconfig(node, filename, services)
# cfg may have a file:/// url for copying from a file
try:
if self.copyservicefile(node, filename, cfg):
@ -323,7 +392,7 @@ class CoreServices(object):
if use_startup_service and not self.is_startup_service(service):
return
for args in service._startup:
for args in service.startup:
# TODO: this wait=False can be problematic!
node.cmd(args, wait=False)
@ -355,9 +424,9 @@ class CoreServices(object):
:param core.netns.vnode.LxcNode node: node to validate services for
:return: nothing
"""
services = sorted(node.services, key=lambda service: service._startindex)
for s in services:
self.validatenodeservice(node, s, services)
services = sorted(node.services, key=lambda service: service.startindex)
for service in services:
self.validatenodeservice(node, service, services)
def validatenodeservice(self, node, service, services):
"""
@ -369,22 +438,20 @@ class CoreServices(object):
:return: service validation status
:rtype: int
"""
logger.info("validating service for node (%s): %s (%s)", node.name, service._name, service._startindex)
if service._custom:
validate_cmds = service._validate
logger.info("validating service for node (%s): %s (%s)", node.name, service.name, service.startindex)
if service.custom:
validate_cmds = service.validate
else:
validate_cmds = service.getvalidate(node, services)
status = 0
# has validate commands
if validate_cmds:
for args in validate_cmds:
logger.info("validating service %s using: %s", service._name, args)
try:
node.check_cmd(args)
except CoreCommandError:
logger.exception("validate command failed")
status = -1
for args in validate_cmds:
logger.info("validating service %s using: %s", service.name, args)
try:
node.check_cmd(args)
except CoreCommandError:
logger.exception("validate command failed")
status = -1
return status
@ -395,9 +462,9 @@ class CoreServices(object):
:param core.netns.nodes.CoreNode node: node to stop services on
:return: nothing
"""
services = sorted(node.services, key=lambda service: service._startindex)
for s in services:
self.stopnodeservice(node, s)
services = sorted(node.services, key=lambda x: x.startindex)
for service in services:
self.stopnodeservice(node, service)
def stopnodeservice(self, node, service):
"""
@ -409,68 +476,57 @@ class CoreServices(object):
:rtype: str
"""
status = "0"
if service._shutdown:
for args in service._shutdown:
try:
node.check_cmd(args)
except CoreCommandError:
logger.exception("error running stop command %s", args)
# TODO: determine if its ok to just return the bad exit status
status = "-1"
for args in service.shutdown:
try:
node.check_cmd(args)
except CoreCommandError:
logger.exception("error running stop command %s", args)
# TODO: determine if its ok to just return the bad exit status
status = "-1"
return status
def servicesfromopaque(self, opaque, object_id):
"""
Build a list of services from an opaque data string.
:param str opaque: opaque data string
:param int object_id: object id
:return: services and unknown services lists tuple
:rtype: tuple
"""
services = []
unknown = []
servicesstring = opaque.split(':')
if servicesstring[0] != "service":
return []
servicenames = servicesstring[1].split(',')
for name in servicenames:
s = ServiceManager.get(name)
s = self.getcustomservice(object_id, s)
if s is None:
unknown.append(name)
else:
services.append(s)
return services, unknown
def getservicefile(self, services, node, filename):
def getservicefile(self, service_name, node, filename, services):
"""
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.
:param list services: service list
:param str service_name: service to get file from
:param core.netns.vnode.LxcNode node: node to get service file from
:param str filename: file name to retrieve
:param list[str] services: list of services associated with node
:return: file message for node
"""
svc = services[0]
# get the filename and determine the config file index
if svc._custom:
cfgfiles = svc._configs
# get service to get file from
service = self.getcustomservice(node.objid, service_name, default_service=True)
if not service:
raise ValueError("invalid service: %s", service_name)
# get service for node
node_services = []
for service_name in services:
node_service = self.getcustomservice(node.objid, service_name, default_service=True)
if not node_service:
logger.warn("unknown service: %s", service)
continue
node_services.append(node_service)
# retrieve config files for default/custom service
if service.custom:
config_files = service.configs
else:
cfgfiles = svc.getconfigfilenames(node.objid, services)
if filename not in cfgfiles:
logger.warn("Request for unknown file '%s' for service '%s'" % (filename, services[0]))
return None
config_files = service.getconfigfilenames(node.objid, node_services)
if filename not in config_files:
raise ValueError("unknown service(%s) config file: %s", service_name, filename)
# get the file data
data = self.getservicefiledata(svc, filename)
data = service.configtxt.get(filename)
if data is None:
data = "%s" % svc.generateconfig(node, filename, services)
data = "%s" % service.generateconfig(node, filename, services)
else:
data = "%s" % data
filetypestr = "service:%s" % svc._name
filetypestr = "service:%s" % service.name
return FileData(
message_type=MessageFlags.ADD.value,
node=node.objid,
@ -479,141 +535,85 @@ class CoreServices(object):
data=data
)
def getservicefiledata(self, service, filename):
"""
Get the customized file data associated with a service. Return None
for invalid filenames or missing file data.
:param CoreService service: service to get file data from
:param str filename: file name to get data from
:return: 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):
def setservicefile(self, node_id, service_name, filename, 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.
:param int nodenum: node id to set service file
:param str type: file type to set
:param int node_id: node id to set service file
:param str service_name: service name to set file for
:param str filename: file name to set
:param str srcname: source name of file to set
:param data: data for file to set
:return: nothing
"""
if len(type.split(':')) < 2:
logger.warn("Received file type did not contain service info.")
return
if srcname is not None:
raise NotImplementedError
svcid, svcname = type.split(':')[:2]
svc = ServiceManager.get(svcname)
svc = self.getcustomservice(nodenum, svc)
# attempt to set custom service, if needed
self.setcustomservice(node_id, service_name)
# retrieve custom service
svc = self.getcustomservice(node_id, service_name)
if svc is None:
logger.warn("Received filename for unknown service '%s'" % svcname)
logger.warn("received filename for unknown service: %s", service_name)
return
cfgfiles = svc._configs
# validate file being set is valid
cfgfiles = svc.configs
if filename not in cfgfiles:
logger.warn("Received unknown file '%s' for service '%s'" % (filename, svcname))
logger.warn("received unknown file '%s' for service '%s'", filename, service_name)
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, event_data):
# set custom service file data
svc.configtxt[filename] = data
def node_service_startup(self, node, service, services):
"""
Handle an Event Message used to start, stop, restart, or validate
a service on a given node.
Startup a node service.
:param EventData event_data: event data to handle
:param PyCoreNode node: node to reconfigure service for
:param CoreService service: service to reconfigure
:param list[CoreService] services: node services
:return: status of startup
:rtype: str
"""
if service.custom:
cmds = service.startup
else:
cmds = service.getstartup(node, services)
status = "0"
for args in cmds:
try:
node.check_cmd(args)
except CoreCommandError:
logger.exception("error starting command")
status = "-1"
return status
def node_service_reconfigure(self, node, service, services):
"""
Reconfigure a node service.
:param PyCoreNode node: node to reconfigure service for
:param CoreService service: service to reconfigure
:param list[CoreService] services: node services
:return: nothing
"""
event_type = event_data.event_type
node_id = event_data.node
name = event_data.name
if service.custom:
cfgfiles = service.configs
else:
cfgfiles = service.getconfigfilenames(node.objid, services)
try:
node = self.session.get_object(node_id)
except KeyError:
logger.warn("Ignoring event for service '%s', unknown node '%s'", name, node_id)
return
for filename in cfgfiles:
if filename[:7] == "file:///":
# TODO: implement this
raise NotImplementedError
fail = ""
services, unknown = self.servicesfromopaque(name, node_id)
for s in services:
if event_type == EventTypes.STOP.value or event_type == EventTypes.RESTART.value:
status = self.stopnodeservice(node, s)
if status != "0":
fail += "Stop %s," % s._name
if event_type == EventTypes.START.value or event_type == EventTypes.RESTART.value:
if s._custom:
cmds = s._startup
else:
cmds = s.getstartup(node, services)
if len(cmds) > 0:
for args in cmds:
try:
node.check_cmd(args)
except CoreCommandError:
logger.exception("error starting command")
fail += "Start %s(%s)," % (s._name, args)
if event_type == EventTypes.PAUSE.value:
status = self.validatenodeservice(node, s, services)
if status != 0:
fail += "%s," % s._name
if event_type == EventTypes.RECONFIGURE.value:
if s._custom:
cfgfiles = s._configs
else:
cfgfiles = s.getconfigfilenames(node.objid, services)
if len(cfgfiles) > 0:
for filename in cfgfiles:
if filename[:7] == "file:///":
# TODO: implement this
raise NotImplementedError
cfg = self.getservicefiledata(s, filename)
if cfg is None:
cfg = s.generateconfig(node, filename, services)
cfg = service.configtxt.get(filename)
if cfg is None:
cfg = service.generateconfig(node, filename, services)
node.nodefile(filename, cfg)
fail_data = ""
if len(fail) > 0:
fail_data += "Fail:" + fail
unknown_data = ""
num = len(unknown)
if num > 0:
for u in unknown:
unknown_data += u
if num > 1:
unknown_data += ", "
num -= 1
logger.warn("Event requested for unknown service(s): %s", unknown_data)
unknown_data = "Unknown:" + unknown_data
event_data = EventData(
node=node_id,
event_type=event_type,
name=name,
data=fail_data + ";" + unknown_data,
time="%s" % time.time()
)
self.session.broadcast_event(event_data)
node.nodefile(filename, cfg)
class CoreService(object):
@ -621,45 +621,42 @@ class CoreService(object):
Parent class used for defining services.
"""
# service name should not include spaces
_name = ""
name = None
# group string allows grouping services together
_group = ""
group = None
# list name(s) of services that this service depends upon
_depends = ()
keys = ["dirs", "files", "startidx", "cmdup", "cmddown", "cmdval", "meta", "starttime"]
depends = ()
# private, per-node directories required by this service
_dirs = ()
dirs = ()
# config files written by this service
_configs = ()
# configs = []
configs = ()
# index used to determine start order with other services
_startindex = 0
startindex = 0
# time in seconds after runtime to run startup commands
_starttime = ""
starttime = 0
# list of startup commands
_startup = ()
# startup = []
startup = ()
# list of shutdown commands
_shutdown = ()
shutdown = ()
# list of validate commands
_validate = ()
validate = ()
# metadata associated with this service
_meta = ""
meta = None
# custom configuration text
_configtxt = ()
_custom = False
_custom_needed = False
configtxt = {}
custom = False
custom_needed = False
def __init__(self):
"""
@ -667,7 +664,16 @@ class CoreService(object):
against their config. Services are instantiated when a custom
configuration is used to override their default parameters.
"""
self._custom = True
self.custom = True
self.dirs = self.__class__.dirs
self.configs = self.__class__.configs
self.startindex = self.__class__.startindex
self.startup = self.__class__.startup
self.shutdown = self.__class__.shutdown
self.validate = self.__class__.validate
self.meta = self.__class__.meta
self.starttime = self.__class__.starttime
self.configtxt = self.__class__.configtxt
@classmethod
def on_load(cls):
@ -685,7 +691,7 @@ class CoreService(object):
:return: class configuration files
:rtype: tuple
"""
return cls._configs
return cls.configs
@classmethod
def generateconfig(cls, node, filename, services):
@ -716,7 +722,7 @@ class CoreService(object):
:return: startup commands
:rtype: tuple
"""
return cls._startup
return cls.startup
@classmethod
def getvalidate(cls, node, services):
@ -731,76 +737,4 @@ class CoreService(object):
:return: validation commands
:rtype: tuple
"""
return cls._validate
@classmethod
def tovaluelist(cls, node, services):
"""
Convert service properties into a string list of key=value pairs,
separated by "|".
:param core.netns.nodes.CoreNode node: node to get value list for
:param list services: services for node
:return: value list string
:rtype: str
"""
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.
:param list values: value list to set properties from
:return: nothing
"""
# 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
logger.exception("error indexing into key")
def setvalue(self, key, value):
"""
Set values for this service.
:param str key: key to set value for
:param value: value of key to set
:return: nothing
"""
if key not in self.keys:
raise ValueError('key `%s` not in `%s`' % (key, self.keys))
# 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 = utils.make_tuple_fromstr(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
return cls.validate

65
daemon/core/services/bird.py
View file

@ -9,22 +9,22 @@ class Bird(CoreService):
"""
Bird router support
"""
_name = "bird"
_group = "BIRD"
_depends = ()
_dirs = ("/etc/bird",)
_configs = ("/etc/bird/bird.conf",)
_startindex = 35
_startup = ("bird -c %s" % (_configs[0]),)
_shutdown = ("killall bird",)
_validate = ("pidof bird",)
name = "bird"
group = "BIRD"
depends = ()
dirs = ("/etc/bird",)
configs = ("/etc/bird/bird.conf",)
startindex = 35
startup = ("bird -c %s" % (configs[0]),)
shutdown = ("killall bird",)
validate = ("pidof bird",)
@classmethod
def generateconfig(cls, node, filename, services):
"""
Return the bird.conf file contents.
"""
if filename == cls._configs[0]:
if filename == cls.configs[0]:
return cls.generateBirdConf(node, services)
else:
raise ValueError
@ -35,7 +35,7 @@ class Bird(CoreService):
Helper to return the first IPv4 address of a node as its router ID.
"""
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
continue
for a in ifc.addrlist:
if a.find(".") >= 0:
@ -73,11 +73,11 @@ protocol device {
scan time 10; # Scan interfaces every 10 seconds
}
""" % (cls._name, cls.routerid(node))
""" % (cls.name, cls.routerid(node))
# Generate protocol specific configurations
for s in services:
if cls._name not in s._depends:
if cls.name not in s.depends:
continue
cfg += s.generatebirdconfig(node)
@ -90,15 +90,15 @@ class BirdService(CoreService):
common to Bird's routing daemons.
"""
_name = None
_group = "BIRD"
_depends = ("bird",)
_dirs = ()
_configs = ()
_startindex = 40
_startup = ()
_shutdown = ()
_meta = "The config file for this service can be found in the bird service."
name = None
group = "BIRD"
depends = ("bird",)
dirs = ()
configs = ()
startindex = 40
startup = ()
shutdown = ()
meta = "The config file for this service can be found in the bird service."
@classmethod
def generatebirdconfig(cls, node):
@ -106,14 +106,15 @@ class BirdService(CoreService):
@classmethod
def generatebirdifcconfig(cls, node):
''' Use only bare interfaces descriptions in generated protocol
"""
Use only bare interfaces descriptions in generated protocol
configurations. This has the slight advantage of being the same
everywhere.
'''
"""
cfg = ""
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
continue
cfg += ' interface "%s";\n' % ifc.name
@ -125,8 +126,8 @@ class BirdBgp(BirdService):
BGP BIRD Service (configuration generation)
"""
_name = "BIRD_BGP"
_custom_needed = True
name = "BIRD_BGP"
custom_needed = True
@classmethod
def generatebirdconfig(cls, node):
@ -156,7 +157,7 @@ class BirdOspf(BirdService):
OSPF BIRD Service (configuration generation)
"""
_name = "BIRD_OSPFv2"
name = "BIRD_OSPFv2"
@classmethod
def generatebirdconfig(cls, node):
@ -181,7 +182,7 @@ class BirdRadv(BirdService):
RADV BIRD Service (configuration generation)
"""
_name = "BIRD_RADV"
name = "BIRD_RADV"
@classmethod
def generatebirdconfig(cls, node):
@ -209,7 +210,7 @@ class BirdRip(BirdService):
RIP BIRD Service (configuration generation)
"""
_name = "BIRD_RIP"
name = "BIRD_RIP"
@classmethod
def generatebirdconfig(cls, node):
@ -231,8 +232,8 @@ class BirdStatic(BirdService):
Static Bird Service (configuration generation)
"""
_name = "BIRD_static"
_custom_needed = True
name = "BIRD_static"
custom_needed = True
@classmethod
def generatebirdconfig(cls, node):

22
daemon/core/services/dockersvc.py
View file

@ -112,16 +112,16 @@ class DockerService(CoreService):
This is a service which will allow running docker containers in a CORE
node.
"""
_name = "Docker"
_group = "Docker"
_depends = ()
_dirs = ('/var/lib/docker/containers/', '/run/shm', '/run/resolvconf',)
_configs = ('docker.sh',)
_startindex = 50
_startup = ('sh docker.sh',)
_shutdown = ('service docker stop',)
name = "Docker"
group = "Docker"
depends = ()
dirs = ('/var/lib/docker/containers/', '/run/shm', '/run/resolvconf',)
configs = ('docker.sh',)
startindex = 50
startup = ('sh docker.sh',)
shutdown = ('service docker stop',)
# Container image to start
_image = ""
image = ""
@classmethod
def generateconfig(cls, node, filename, services):
@ -139,7 +139,7 @@ class DockerService(CoreService):
# distros may just be docker
cfg += 'service docker start\n'
cfg += "# you could add a command to start a image here eg:\n"
if not cls._image:
if not cls.image:
cfg += "# docker run -d --net host --name coreDock <imagename>\n"
else:
cfg += """\
@ -150,7 +150,7 @@ until [ $result -eq 0 ]; do
# this is to alleviate contention to docker's SQLite database
sleep 0.3
done
""" % (cls._image,)
""" % (cls.image,)
return cfg
@classmethod

129
daemon/core/services/nrl.py
View file

@ -13,14 +13,14 @@ class NrlService(CoreService):
Parent class for NRL services. Defines properties and methods
common to NRL's routing daemons.
"""""
_name = None
_group = "ProtoSvc"
_depends = ()
_dirs = ()
_configs = ()
_startindex = 45
_startup = ()
_shutdown = ()
name = None
group = "ProtoSvc"
depends = ()
dirs = ()
configs = ()
startindex = 45
startup = ()
shutdown = ()
@classmethod
def generateconfig(cls, node, filename, services):
@ -34,7 +34,7 @@ class NrlService(CoreService):
interface's prefix length, so e.g. '/32' can turn into '/24'.
"""
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
continue
for a in ifc.addrlist:
if a.find(".") >= 0:
@ -46,12 +46,12 @@ class NrlService(CoreService):
class MgenSinkService(NrlService):
_name = "MGEN_Sink"
_configs = ("sink.mgen",)
_startindex = 5
_startup = ("mgen input sink.mgen",)
_validate = ("pidof mgen",)
_shutdown = ("killall mgen",)
name = "MGEN_Sink"
configs = ("sink.mgen",)
startindex = 5
startup = ("mgen input sink.mgen",)
validate = ("pidof mgen",)
shutdown = ("killall mgen",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -63,7 +63,7 @@ class MgenSinkService(NrlService):
@classmethod
def getstartup(cls, node, services):
cmd = cls._startup[0]
cmd = cls.startup[0]
cmd += " output /tmp/mgen_%s.log" % node.name
return cmd,
@ -72,27 +72,26 @@ class NrlNhdp(NrlService):
"""
NeighborHood Discovery Protocol for MANET networks.
"""
_name = "NHDP"
_startup = ("nrlnhdp",)
_shutdown = ("killall nrlnhdp",)
_validate = ("pidof nrlnhdp",)
name = "NHDP"
startup = ("nrlnhdp",)
shutdown = ("killall nrlnhdp",)
validate = ("pidof nrlnhdp",)
@classmethod
def getstartup(cls, node, services):
"""
Generate the appropriate command-line based on node interfaces.
"""
cmd = cls._startup[0]
cmd = cls.startup[0]
cmd += " -l /var/log/nrlnhdp.log"
cmd += " -rpipe %s_nhdp" % node.name
servicenames = map(lambda x: x._name, services)
servicenames = map(lambda x: x.name, services)
if "SMF" in servicenames:
cmd += " -flooding ecds"
cmd += " -smfClient %s_smf" % node.name
netifs = filter(lambda x: not getattr(x, 'control', False), \
node.netifs())
netifs = filter(lambda x: not getattr(x, 'control', False), node.netifs())
if len(netifs) > 0:
interfacenames = map(lambda x: x.name, netifs)
cmd += " -i "
@ -105,11 +104,11 @@ class NrlSmf(NrlService):
"""
Simplified Multicast Forwarding for MANET networks.
"""
_name = "SMF"
_startup = ("sh startsmf.sh",)
_shutdown = ("killall nrlsmf",)
_validate = ("pidof nrlsmf",)
_configs = ("startsmf.sh",)
name = "SMF"
startup = ("sh startsmf.sh",)
shutdown = ("killall nrlsmf",)
validate = ("pidof nrlsmf",)
configs = ("startsmf.sh",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -123,7 +122,7 @@ class NrlSmf(NrlService):
comments = ""
cmd = "nrlsmf instance %s_smf" % node.name
servicenames = map(lambda x: x._name, services)
servicenames = map(lambda x: x.name, services)
netifs = filter(lambda x: not getattr(x, 'control', False), node.netifs())
if len(netifs) == 0:
return ""
@ -156,17 +155,17 @@ class NrlOlsr(NrlService):
"""
Optimized Link State Routing protocol for MANET networks.
"""
_name = "OLSR"
_startup = ("nrlolsrd",)
_shutdown = ("killall nrlolsrd",)
_validate = ("pidof nrlolsrd",)
name = "OLSR"
startup = ("nrlolsrd",)
shutdown = ("killall nrlolsrd",)
validate = ("pidof nrlolsrd",)
@classmethod
def getstartup(cls, node, services):
"""
Generate the appropriate command-line based on node interfaces.
"""
cmd = cls._startup[0]
cmd = cls.startup[0]
# are multiple interfaces supported? No.
netifs = list(node.netifs())
if len(netifs) > 0:
@ -175,7 +174,7 @@ class NrlOlsr(NrlService):
cmd += " -l /var/log/nrlolsrd.log"
cmd += " -rpipe %s_olsr" % node.name
servicenames = map(lambda x: x._name, services)
servicenames = map(lambda x: x.name, services)
if "SMF" in servicenames and not "NHDP" in servicenames:
cmd += " -flooding s-mpr"
cmd += " -smfClient %s_smf" % node.name
@ -189,21 +188,21 @@ class NrlOlsrv2(NrlService):
"""
Optimized Link State Routing protocol version 2 for MANET networks.
"""
_name = "OLSRv2"
_startup = ("nrlolsrv2",)
_shutdown = ("killall nrlolsrv2",)
_validate = ("pidof nrlolsrv2",)
name = "OLSRv2"
startup = ("nrlolsrv2",)
shutdown = ("killall nrlolsrv2",)
validate = ("pidof nrlolsrv2",)
@classmethod
def getstartup(cls, node, services):
"""
Generate the appropriate command-line based on node interfaces.
"""
cmd = cls._startup[0]
cmd = cls.startup[0]
cmd += " -l /var/log/nrlolsrv2.log"
cmd += " -rpipe %s_olsrv2" % node.name
servicenames = map(lambda x: x._name, services)
servicenames = map(lambda x: x.name, services)
if "SMF" in servicenames:
cmd += " -flooding ecds"
cmd += " -smfClient %s_smf" % node.name
@ -223,19 +222,19 @@ class OlsrOrg(NrlService):
"""
Optimized Link State Routing protocol from olsr.org for MANET networks.
"""
_name = "OLSRORG"
_configs = ("/etc/olsrd/olsrd.conf",)
_dirs = ("/etc/olsrd",)
_startup = ("olsrd",)
_shutdown = ("killall olsrd",)
_validate = ("pidof olsrd",)
name = "OLSRORG"
configs = ("/etc/olsrd/olsrd.conf",)
dirs = ("/etc/olsrd",)
startup = ("olsrd",)
shutdown = ("killall olsrd",)
validate = ("pidof olsrd",)
@classmethod
def getstartup(cls, node, services):
"""
Generate the appropriate command-line based on node interfaces.
"""
cmd = cls._startup[0]
cmd = cls.startup[0]
netifs = filter(lambda x: not getattr(x, 'control', False), node.netifs())
if len(netifs) > 0:
interfacenames = map(lambda x: x.name, netifs)
@ -572,24 +571,24 @@ class MgenActor(NrlService):
"""
# a unique name is required, without spaces
_name = "MgenActor"
name = "MgenActor"
# you can create your own group here
_group = "ProtoSvc"
group = "ProtoSvc"
# list of other services this service depends on
_depends = ()
depends = ()
# per-node directories
_dirs = ()
dirs = ()
# generated files (without a full path this file goes in the node's dir,
# e.g. /tmp/pycore.12345/n1.conf/)
_configs = ('start_mgen_actor.sh',)
configs = ('start_mgen_actor.sh',)
# this controls the starting order vs other enabled services
_startindex = 50
startindex = 50
# list of startup commands, also may be generated during startup
_startup = ("sh start_mgen_actor.sh",)
startup = ("sh start_mgen_actor.sh",)
# list of validation commands
_validate = ("pidof mgen",)
validate = ("pidof mgen",)
# list of shutdown commands
_shutdown = ("killall mgen",)
shutdown = ("killall mgen",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -603,7 +602,7 @@ class MgenActor(NrlService):
comments = ""
cmd = "mgenBasicActor.py -n %s -a 0.0.0.0" % node.name
servicenames = map(lambda x: x._name, services)
servicenames = map(lambda x: x.name, services)
netifs = filter(lambda x: not getattr(x, 'control', False), node.netifs())
if len(netifs) == 0:
return ""
@ -616,12 +615,12 @@ class Arouted(NrlService):
"""
Adaptive Routing
"""
_name = "arouted"
_configs = ("startarouted.sh",)
_startindex = NrlService._startindex + 10
_startup = ("sh startarouted.sh",)
_shutdown = ("pkill arouted",)
_validate = ("pidof arouted",)
name = "arouted"
configs = ("startarouted.sh",)
startindex = NrlService.startindex + 10
startup = ("sh startarouted.sh",)
shutdown = ("pkill arouted",)
validate = ("pidof arouted",)
@classmethod
def generateconfig(cls, node, filename, services):

138
daemon/core/services/quagga.py
View file

@ -10,33 +10,33 @@ from core.service import CoreService
class Zebra(CoreService):
_name = "zebra"
_group = "Quagga"
_dirs = ("/usr/local/etc/quagga", "/var/run/quagga")
_configs = (
name = "zebra"
group = "Quagga"
dirs = ("/usr/local/etc/quagga", "/var/run/quagga")
configs = (
"/usr/local/etc/quagga/Quagga.conf",
"quaggaboot.sh",
"/usr/local/etc/quagga/vtysh.conf"
)
_startindex = 35
_startup = ("sh quaggaboot.sh zebra",)
_shutdown = ("killall zebra",)
_validate = ("pidof zebra",)
startindex = 35
startup = ("sh quaggaboot.sh zebra",)
shutdown = ("killall zebra",)
validate = ("pidof zebra",)
@classmethod
def generateconfig(cls, node, filename, services):
"""
Return the Quagga.conf or quaggaboot.sh file contents.
"""
if filename == cls._configs[0]:
if filename == cls.configs[0]:
return cls.generateQuaggaConf(node, services)
elif filename == cls._configs[1]:
elif filename == cls.configs[1]:
return cls.generateQuaggaBoot(node, services)
elif filename == cls._configs[2]:
elif filename == cls.configs[2]:
return cls.generateVtyshConf(node, services)
else:
raise ValueError("file name (%s) is not a known configuration: %s",
filename, cls._configs)
filename, cls.configs)
@classmethod
def generateVtyshConf(cls, node, services):
@ -67,12 +67,12 @@ class Zebra(CoreService):
want_ipv4 = False
want_ipv6 = False
for s in services:
if cls._name not in s._depends:
if cls.name not in s.depends:
continue
ifccfg = s.generatequaggaifcconfig(node, ifc)
if s._ipv4_routing:
if s.ipv4_routing:
want_ipv4 = True
if s._ipv6_routing:
if s.ipv6_routing:
want_ipv6 = True
cfgv6 += ifccfg
else:
@ -93,7 +93,7 @@ class Zebra(CoreService):
cfg += "!\n"
for s in services:
if cls._name not in s._depends:
if cls.name not in s.depends:
continue
cfg += s.generatequaggaconfig(node)
return cfg
@ -212,7 +212,7 @@ if [ "$1" != "zebra" ]; then
fi
confcheck
bootquagga
""" % (cls._configs[0], quagga_sbin_search, quagga_bin_search, constants.QUAGGA_STATE_DIR)
""" % (cls.configs[0], quagga_sbin_search, quagga_bin_search, constants.QUAGGA_STATE_DIR)
class QuaggaService(CoreService):
@ -220,18 +220,18 @@ class QuaggaService(CoreService):
Parent class for Quagga services. Defines properties and methods
common to Quagga's routing daemons.
"""
_name = None
_group = "Quagga"
_depends = ("zebra",)
_dirs = ()
_configs = ()
_startindex = 40
_startup = ()
_shutdown = ()
_meta = "The config file for this service can be found in the Zebra service."
name = None
group = "Quagga"
depends = ("zebra",)
dirs = ()
configs = ()
startindex = 40
startup = ()
shutdown = ()
meta = "The config file for this service can be found in the Zebra service."
_ipv4_routing = False
_ipv6_routing = False
ipv4_routing = False
ipv6_routing = False
@staticmethod
def routerid(node):
@ -239,7 +239,7 @@ class QuaggaService(CoreService):
Helper to return the first IPv4 address of a node as its router ID.
"""
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
continue
for a in ifc.addrlist:
if a.find(".") >= 0:
@ -280,11 +280,11 @@ class Ospfv2(QuaggaService):
not build its own configuration file but has hooks for adding to the
unified Quagga.conf file.
"""
_name = "OSPFv2"
_startup = ()
_shutdown = ("killall ospfd",)
_validate = ("pidof ospfd",)
_ipv4_routing = True
name = "OSPFv2"
startup = ()
shutdown = ("killall ospfd",)
validate = ("pidof ospfd",)
ipv4_routing = True
@staticmethod
def mtucheck(ifc):
@ -355,12 +355,12 @@ class Ospfv3(QuaggaService):
not build its own configuration file but has hooks for adding to the
unified Quagga.conf file.
"""
_name = "OSPFv3"
_startup = ()
_shutdown = ("killall ospf6d",)
_validate = ("pidof ospf6d",)
_ipv4_routing = True
_ipv6_routing = True
name = "OSPFv3"
startup = ()
shutdown = ("killall ospf6d",)
validate = ("pidof ospf6d",)
ipv4_routing = True
ipv6_routing = True
@staticmethod
def minmtu(ifc):
@ -436,8 +436,8 @@ class Ospfv3mdr(Ospfv3):
configuration file but has hooks for adding to the
unified Quagga.conf file.
"""
_name = "OSPFv3MDR"
_ipv4_routing = True
name = "OSPFv3MDR"
ipv4_routing = True
@classmethod
def generatequaggaifcconfig(cls, node, ifc):
@ -464,13 +464,13 @@ class Bgp(QuaggaService):
Peers must be manually configured, with a full mesh for those
having the same AS number.
"""
_name = "BGP"
_startup = ()
_shutdown = ("killall bgpd",)
_validate = ("pidof bgpd",)
_custom_needed = True
_ipv4_routing = True
_ipv6_routing = True
name = "BGP"
startup = ()
shutdown = ("killall bgpd",)
validate = ("pidof bgpd",)
custom_needed = True
ipv4_routing = True
ipv6_routing = True
@classmethod
def generatequaggaconfig(cls, node):
@ -489,11 +489,11 @@ class Rip(QuaggaService):
"""
The RIP service provides IPv4 routing for wired networks.
"""
_name = "RIP"
_startup = ()
_shutdown = ("killall ripd",)
_validate = ("pidof ripd",)
_ipv4_routing = True
name = "RIP"
startup = ()
shutdown = ("killall ripd",)
validate = ("pidof ripd",)
ipv4_routing = True
@classmethod
def generatequaggaconfig(cls, node):
@ -512,11 +512,11 @@ class Ripng(QuaggaService):
"""
The RIP NG service provides IPv6 routing for wired networks.
"""
_name = "RIPNG"
_startup = ()
_shutdown = ("killall ripngd",)
_validate = ("pidof ripngd",)
_ipv6_routing = True
name = "RIPNG"
startup = ()
shutdown = ("killall ripngd",)
validate = ("pidof ripngd",)
ipv6_routing = True
@classmethod
def generatequaggaconfig(cls, node):
@ -536,11 +536,11 @@ class Babel(QuaggaService):
The Babel service provides a loop-avoiding distance-vector routing
protocol for IPv6 and IPv4 with fast convergence properties.
"""
_name = "Babel"
_startup = ()
_shutdown = ("killall babeld",)
_validate = ("pidof babeld",)
_ipv6_routing = True
name = "Babel"
startup = ()
shutdown = ("killall babeld",)
validate = ("pidof babeld",)
ipv6_routing = True
@classmethod
def generatequaggaconfig(cls, node):
@ -565,11 +565,11 @@ class Xpimd(QuaggaService):
"""
PIM multicast routing based on XORP.
"""
_name = 'Xpimd'
_startup = ()
_shutdown = ('killall xpimd',)
_validate = ('pidof xpimd',)
_ipv4_routing = True
name = 'Xpimd'
startup = ()
shutdown = ('killall xpimd',)
validate = ('pidof xpimd',)
ipv4_routing = True
@classmethod
def generatequaggaconfig(cls, node):

52
daemon/core/services/sdn.py
View file

@ -11,14 +11,14 @@ class SdnService(CoreService):
"""
Parent class for SDN services.
"""
_name = None
_group = "SDN"
_depends = ()
_dirs = ()
_configs = ()
_startindex = 50
_startup = ()
_shutdown = ()
name = None
group = "SDN"
depends = ()
dirs = ()
configs = ()
startindex = 50
startup = ()
shutdown = ()
@classmethod
def generateconfig(cls, node, filename, services):
@ -26,27 +26,27 @@ class SdnService(CoreService):
class OvsService(SdnService):
_name = "OvsService"
_group = "SDN"
_depends = ()
_dirs = ("/etc/openvswitch", "/var/run/openvswitch", "/var/log/openvswitch")
_configs = ('OvsService.sh',)
_startindex = 50
_startup = ('sh OvsService.sh',)
_shutdown = ('killall ovs-vswitchd', 'killall ovsdb-server')
name = "OvsService"
group = "SDN"
depends = ()
dirs = ("/etc/openvswitch", "/var/run/openvswitch", "/var/log/openvswitch")
configs = ('OvsService.sh',)
startindex = 50
startup = ('sh OvsService.sh',)
shutdown = ('killall ovs-vswitchd', 'killall ovsdb-server')
@classmethod
def generateconfig(cls, node, filename, services):
# Check whether the node is running zebra
has_zebra = 0
for s in services:
if s._name == "zebra":
if s.name == "zebra":
has_zebra = 1
# Check whether the node is running an SDN controller
has_sdn_ctrlr = 0
for s in services:
if s._name == "ryuService":
if s.name == "ryuService":
has_sdn_ctrlr = 1
cfg = "#!/bin/sh\n"
@ -100,14 +100,14 @@ class OvsService(SdnService):
class RyuService(SdnService):
_name = "ryuService"
_group = "SDN"
_depends = ()
_dirs = ()
_configs = ('ryuService.sh',)
_startindex = 50
_startup = ('sh ryuService.sh',)
_shutdown = ('killall ryu-manager',)
name = "ryuService"
group = "SDN"
depends = ()
dirs = ()
configs = ('ryuService.sh',)
startindex = 50
startup = ('sh ryuService.sh',)
shutdown = ('killall ryu-manager',)
@classmethod
def generateconfig(cls, node, filename, services):

58
daemon/core/services/security.py
View file

@ -9,14 +9,14 @@ from core.service import CoreService
class VPNClient(CoreService):
_name = "VPNClient"
_group = "Security"
_configs = ('vpnclient.sh',)
_startindex = 60
_startup = ('sh vpnclient.sh',)
_shutdown = ("killall openvpn",)
_validate = ("pidof openvpn",)
_custom_needed = True
name = "VPNClient"
group = "Security"
configs = ('vpnclient.sh',)
startindex = 60
startup = ('sh vpnclient.sh',)
shutdown = ("killall openvpn",)
validate = ("pidof openvpn",)
custom_needed = True
@classmethod
def generateconfig(cls, node, filename, services):
@ -36,14 +36,14 @@ class VPNClient(CoreService):
class VPNServer(CoreService):
_name = "VPNServer"
_group = "Security"
_configs = ('vpnserver.sh',)
_startindex = 50
_startup = ('sh vpnserver.sh',)
_shutdown = ("killall openvpn",)
_validate = ("pidof openvpn",)
_custom_needed = True
name = "VPNServer"
group = "Security"
configs = ('vpnserver.sh',)
startindex = 50
startup = ('sh vpnserver.sh',)
shutdown = ("killall openvpn",)
validate = ("pidof openvpn",)
custom_needed = True
@classmethod
def generateconfig(cls, node, filename, services):
@ -64,13 +64,13 @@ class VPNServer(CoreService):
class IPsec(CoreService):
_name = "IPsec"
_group = "Security"
_configs = ('ipsec.sh',)
_startindex = 60
_startup = ('sh ipsec.sh',)
_shutdown = ("killall racoon",)
_custom_needed = True
name = "IPsec"
group = "Security"
configs = ('ipsec.sh',)
startindex = 60
startup = ('sh ipsec.sh',)
shutdown = ("killall racoon",)
custom_needed = True
@classmethod
def generateconfig(cls, node, filename, services):
@ -92,12 +92,12 @@ class IPsec(CoreService):
class Firewall(CoreService):
_name = "Firewall"
_group = "Security"
_configs = ('firewall.sh',)
_startindex = 20
_startup = ('sh firewall.sh',)
_custom_needed = True
name = "Firewall"
group = "Security"
configs = ('firewall.sh',)
startindex = 20
startup = ('sh firewall.sh',)
custom_needed = True
@classmethod
def generateconfig(cls, node, filename, services):

24
daemon/core/services/startup.py
View file

@ -8,15 +8,15 @@ class Startup(CoreService):
"""
A CORE service to start other services in order, serially
"""
_name = 'startup'
_group = 'Utility'
_depends = ()
_dirs = ()
_configs = ('startup.sh',)
_startindex = maxint
_startup = ('sh startup.sh',)
_shutdown = ()
_validate = ()
name = 'startup'
group = 'Utility'
depends = ()
dirs = ()
configs = ('startup.sh',)
startindex = maxint
startup = ('sh startup.sh',)
shutdown = ()
validate = ()
@staticmethod
def is_startup_service(s):
@ -24,13 +24,13 @@ class Startup(CoreService):
@classmethod
def generateconfig(cls, node, filename, services):
if filename != cls._configs[0]:
if filename != cls.configs[0]:
return ''
script = '#!/bin/sh\n' \
'# auto-generated by Startup (startup.py)\n\n' \
'exec > startup.log 2>&1\n\n'
for s in sorted(services, key=lambda x: x._startindex):
if cls.is_startup_service(s) or len(str(s._starttime)) > 0:
for s in sorted(services, key=lambda x: x.startindex):
if cls.is_startup_service(s) or len(str(s.starttime)) > 0:
continue
start = '\n'.join(s.getstartup(node, services))
if start:

26
daemon/core/services/ucarp.py
View file

@ -8,29 +8,29 @@ UCARP_ETC = "/usr/local/etc/ucarp"
class Ucarp(CoreService):
_name = "ucarp"
_group = "Utility"
_depends = ( )
_dirs = (UCARP_ETC,)
_configs = (
name = "ucarp"
group = "Utility"
depends = ( )
dirs = (UCARP_ETC,)
configs = (
UCARP_ETC + "/default.sh", UCARP_ETC + "/default-up.sh", UCARP_ETC + "/default-down.sh", "ucarpboot.sh",)
_startindex = 65
_startup = ("sh ucarpboot.sh",)
_shutdown = ("killall ucarp",)
_validate = ("pidof ucarp",)
startindex = 65
startup = ("sh ucarpboot.sh",)
shutdown = ("killall ucarp",)
validate = ("pidof ucarp",)
@classmethod
def generateconfig(cls, node, filename, services):
"""
Return the default file contents
"""
if filename == cls._configs[0]:
if filename == cls.configs[0]:
return cls.generateUcarpConf(node, services)
elif filename == cls._configs[1]:
elif filename == cls.configs[1]:
return cls.generateVipUp(node, services)
elif filename == cls._configs[2]:
elif filename == cls.configs[2]:
return cls.generateVipDown(node, services)
elif filename == cls._configs[3]:
elif filename == cls.configs[3]:
return cls.generateUcarpBoot(node, services)
else:
raise ValueError

168
daemon/core/services/utility.py
View file

@ -16,14 +16,14 @@ class UtilService(CoreService):
"""
Parent class for utility services.
"""
_name = None
_group = "Utility"
_depends = ()
_dirs = ()
_configs = ()
_startindex = 80
_startup = ()
_shutdown = ()
name = None
group = "Utility"
depends = ()
dirs = ()
configs = ()
startindex = 80
startup = ()
shutdown = ()
@classmethod
def generateconfig(cls, node, filename, services):
@ -31,10 +31,10 @@ class UtilService(CoreService):
class IPForwardService(UtilService):
_name = "IPForward"
_configs = ("ipforward.sh",)
_startindex = 5
_startup = ("sh ipforward.sh",)
name = "IPForward"
configs = ("ipforward.sh",)
startindex = 5
startup = ("sh ipforward.sh",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -67,9 +67,9 @@ class IPForwardService(UtilService):
class DefaultRouteService(UtilService):
_name = "DefaultRoute"
_configs = ("defaultroute.sh",)
_startup = ("sh defaultroute.sh",)
name = "DefaultRoute"
configs = ("defaultroute.sh",)
startup = ("sh defaultroute.sh",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -101,9 +101,9 @@ class DefaultRouteService(UtilService):
class DefaultMulticastRouteService(UtilService):
_name = "DefaultMulticastRoute"
_configs = ("defaultmroute.sh",)
_startup = ("sh defaultmroute.sh",)
name = "DefaultMulticastRoute"
configs = ("defaultmroute.sh",)
startup = ("sh defaultmroute.sh",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -113,7 +113,7 @@ class DefaultMulticastRouteService(UtilService):
cfg += "as needed\n"
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
continue
if os.uname()[0] == "Linux":
rtcmd = "ip route add 224.0.0.0/4 dev"
@ -126,10 +126,10 @@ class DefaultMulticastRouteService(UtilService):
class StaticRouteService(UtilService):
_name = "StaticRoute"
_configs = ("staticroute.sh",)
_startup = ("sh staticroute.sh",)
_custom_needed = True
name = "StaticRoute"
configs = ("staticroute.sh",)
startup = ("sh staticroute.sh",)
custom_needed = True
@classmethod
def generateconfig(cls, node, filename, services):
@ -165,12 +165,12 @@ class StaticRouteService(UtilService):
class SshService(UtilService):
_name = "SSH"
_configs = ("startsshd.sh", "/etc/ssh/sshd_config",)
_dirs = ("/etc/ssh", "/var/run/sshd",)
_startup = ("sh startsshd.sh",)
_shutdown = ("killall sshd",)
_validate = ()
name = "SSH"
configs = ("startsshd.sh", "/etc/ssh/sshd_config",)
dirs = ("/etc/ssh", "/var/run/sshd",)
startup = ("sh startsshd.sh",)
shutdown = ("killall sshd",)
validate = ()
@classmethod
def generateconfig(cls, node, filename, services):
@ -178,8 +178,8 @@ class SshService(UtilService):
Use a startup script for launching sshd in order to wait for host
key generation.
"""
sshcfgdir = cls._dirs[0]
sshstatedir = cls._dirs[1]
sshcfgdir = cls.dirs[0]
sshstatedir = cls.dirs[1]
sshlibdir = "/usr/lib/openssh"
if filename == "startsshd.sh":
return """\
@ -233,12 +233,12 @@ UseDNS no
class DhcpService(UtilService):
_name = "DHCP"
_configs = ("/etc/dhcp/dhcpd.conf",)
_dirs = ("/etc/dhcp",)
_startup = ("dhcpd",)
_shutdown = ("killall dhcpd",)
_validate = ("pidof dhcpd",)
name = "DHCP"
configs = ("/etc/dhcp/dhcpd.conf",)
dirs = ("/etc/dhcp",)
startup = ("dhcpd",)
shutdown = ("killall dhcpd",)
validate = ("pidof dhcpd",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -296,11 +296,11 @@ class DhcpClientService(UtilService):
"""
Use a DHCP client for all interfaces for addressing.
"""
_name = "DHCPClient"
_configs = ("startdhcpclient.sh",)
_startup = ("sh startdhcpclient.sh",)
_shutdown = ("killall dhclient",)
_validate = ("pidof dhclient",)
name = "DHCPClient"
configs = ("startdhcpclient.sh",)
startup = ("sh startdhcpclient.sh",)
shutdown = ("killall dhclient",)
validate = ("pidof dhclient",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -327,12 +327,12 @@ class FtpService(UtilService):
"""
Start a vsftpd server.
"""
_name = "FTP"
_configs = ("vsftpd.conf",)
_dirs = ("/var/run/vsftpd/empty", "/var/ftp",)
_startup = ("vsftpd ./vsftpd.conf",)
_shutdown = ("killall vsftpd",)
_validate = ("pidof vsftpd",)
name = "FTP"
configs = ("vsftpd.conf",)
dirs = ("/var/run/vsftpd/empty", "/var/ftp",)
startup = ("vsftpd ./vsftpd.conf",)
shutdown = ("killall vsftpd",)
validate = ("pidof vsftpd",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -359,14 +359,14 @@ class HttpService(UtilService):
"""
Start an apache server.
"""
_name = "HTTP"
_configs = ("/etc/apache2/apache2.conf", "/etc/apache2/envvars",
"/var/www/index.html",)
_dirs = ("/etc/apache2", "/var/run/apache2", "/var/log/apache2",
"/run/lock", "/var/lock/apache2", "/var/www",)
_startup = ("chown www-data /var/lock/apache2", "apache2ctl start",)
_shutdown = ("apache2ctl stop",)
_validate = ("pidof apache2",)
name = "HTTP"
configs = ("/etc/apache2/apache2.conf", "/etc/apache2/envvars",
"/var/www/index.html",)
dirs = ("/etc/apache2", "/var/run/apache2", "/var/log/apache2",
"/run/lock", "/var/lock/apache2", "/var/www",)
startup = ("chown www-data /var/lock/apache2", "apache2ctl start",)
shutdown = ("apache2ctl stop",)
validate = ("pidof apache2",)
APACHEVER22, APACHEVER24 = (22, 24)
@ -375,11 +375,11 @@ class HttpService(UtilService):
"""
Generate an apache2.conf configuration file.
"""
if filename == cls._configs[0]:
if filename == cls.configs[0]:
return cls.generateapache2conf(node, filename, services)
elif filename == cls._configs[1]:
elif filename == cls.configs[1]:
return cls.generateenvvars(node, filename, services)
elif filename == cls._configs[2]:
elif filename == cls.configs[2]:
return cls.generatehtml(node, filename, services)
else:
return ""
@ -561,7 +561,7 @@ export LANG
<p>The web server software is running but no content has been added, yet.</p>
""" % node.name
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
continue
body += "<li>%s - %s</li>\n" % (ifc.name, ifc.addrlist)
return "<html><body>%s</body></html>" % body
@ -571,14 +571,14 @@ class PcapService(UtilService):
"""
Pcap service for logging packets.
"""
_name = "pcap"
_configs = ("pcap.sh",)
_dirs = ()
_startindex = 1
_startup = ("sh pcap.sh start",)
_shutdown = ("sh pcap.sh stop",)
_validate = ("pidof tcpdump",)
_meta = "logs network traffic to pcap packet capture files"
name = "pcap"
configs = ("pcap.sh",)
dirs = ()
startindex = 1
startup = ("sh pcap.sh start",)
shutdown = ("sh pcap.sh stop",)
validate = ("pidof tcpdump",)
meta = "logs network traffic to pcap packet capture files"
@classmethod
def generateconfig(cls, node, filename, services):
@ -595,7 +595,7 @@ if [ "x$1" = "xstart" ]; then
"""
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
cfg += '# '
redir = "< /dev/null"
cfg += "tcpdump ${DUMPOPTS} -w %s.%s.pcap -i %s %s &\n" % \
@ -611,12 +611,12 @@ fi;
class RadvdService(UtilService):
_name = "radvd"
_configs = ("/etc/radvd/radvd.conf",)
_dirs = ("/etc/radvd",)
_startup = ("radvd -C /etc/radvd/radvd.conf -m logfile -l /var/log/radvd.log",)
_shutdown = ("pkill radvd",)
_validate = ("pidof radvd",)
name = "radvd"
configs = ("/etc/radvd/radvd.conf",)
dirs = ("/etc/radvd",)
startup = ("radvd -C /etc/radvd/radvd.conf -m logfile -l /var/log/radvd.log",)
shutdown = ("pkill radvd",)
validate = ("pidof radvd",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -626,7 +626,7 @@ class RadvdService(UtilService):
"""
cfg = "# auto-generated by RADVD service (utility.py)\n"
for ifc in node.netifs():
if hasattr(ifc, 'control') and ifc.control == True:
if hasattr(ifc, 'control') and ifc.control is True:
continue
prefixes = map(cls.subnetentry, ifc.addrlist)
if len(prefixes) < 1:
@ -671,11 +671,11 @@ class AtdService(UtilService):
"""
Atd service for scheduling at jobs
"""
_name = "atd"
_configs = ("startatd.sh",)
_dirs = ("/var/spool/cron/atjobs", "/var/spool/cron/atspool")
_startup = ("sh startatd.sh",)
_shutdown = ("pkill atd",)
name = "atd"
configs = ("startatd.sh",)
dirs = ("/var/spool/cron/atjobs", "/var/spool/cron/atspool")
startup = ("sh startatd.sh",)
shutdown = ("pkill atd",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -692,6 +692,6 @@ class UserDefinedService(UtilService):
"""
Dummy service allowing customization of anything.
"""
_name = "UserDefined"
_startindex = 50
_meta = "Customize this service to do anything upon startup."
name = "UserDefined"
startindex = 50
meta = "Customize this service to do anything upon startup."

58
daemon/core/services/xorp.py
View file

@ -11,15 +11,15 @@ class XorpRtrmgr(CoreService):
XORP router manager service builds a config.boot file based on other
enabled XORP services, and launches necessary daemons upon startup.
"""
_name = "xorp_rtrmgr"
_group = "XORP"
_depends = ()
_dirs = ("/etc/xorp",)
_configs = ("/etc/xorp/config.boot",)
_startindex = 35
_startup = ("xorp_rtrmgr -d -b %s -l /var/log/%s.log -P /var/run/%s.pid" % (_configs[0], _name, _name),)
_shutdown = ("killall xorp_rtrmgr",)
_validate = ("pidof xorp_rtrmgr",)
name = "xorp_rtrmgr"
group = "XORP"
depends = ()
dirs = ("/etc/xorp",)
configs = ("/etc/xorp/config.boot",)
startindex = 35
startup = ("xorp_rtrmgr -d -b %s -l /var/log/%s.log -P /var/run/%s.pid" % (configs[0], name, name),)
shutdown = ("killall xorp_rtrmgr",)
validate = ("pidof xorp_rtrmgr",)
@classmethod
def generateconfig(cls, node, filename, services):
@ -40,10 +40,10 @@ class XorpRtrmgr(CoreService):
for s in services:
try:
s._depends.index(cls._name)
s.depends.index(cls.name)
cfg += s.generatexorpconfig(node)
except ValueError:
logger.exception("error getting value from service: %s", cls._name)
logger.exception("error getting value from service: %s", cls.name)
return cfg
@ -74,15 +74,15 @@ class XorpService(CoreService):
Parent class for XORP services. Defines properties and methods
common to XORP's routing daemons.
"""
_name = None
_group = "XORP"
_depends = ("xorp_rtrmgr",)
_dirs = ()
_configs = ()
_startindex = 40
_startup = ()
_shutdown = ()
_meta = "The config file for this service can be found in the xorp_rtrmgr service."
name = None
group = "XORP"
depends = ("xorp_rtrmgr",)
dirs = ()
configs = ()
startindex = 40
startup = ()
shutdown = ()
meta = "The config file for this service can be found in the xorp_rtrmgr service."
@staticmethod
def fea(forwarding):
@ -165,7 +165,7 @@ class XorpOspfv2(XorpService):
not build its own configuration file but has hooks for adding to the
unified XORP configuration file.
"""
_name = "XORP_OSPFv2"
name = "XORP_OSPFv2"
@classmethod
def generatexorpconfig(cls, node):
@ -200,7 +200,7 @@ class XorpOspfv3(XorpService):
not build its own configuration file but has hooks for adding to the
unified XORP configuration file.
"""
_name = "XORP_OSPFv3"
name = "XORP_OSPFv3"
@classmethod
def generatexorpconfig(cls, node):
@ -227,8 +227,8 @@ class XorpBgp(XorpService):
"""
IPv4 inter-domain routing. AS numbers and peers must be customized.
"""
_name = "XORP_BGP"
_custom_needed = True
name = "XORP_BGP"
custom_needed = True
@classmethod
def generatexorpconfig(cls, node):
@ -257,7 +257,7 @@ class XorpRip(XorpService):
RIP IPv4 unicast routing.
"""
_name = "XORP_RIP"
name = "XORP_RIP"
@classmethod
def generatexorpconfig(cls, node):
@ -289,7 +289,7 @@ class XorpRipng(XorpService):
"""
RIP NG IPv6 unicast routing.
"""
_name = "XORP_RIPNG"
name = "XORP_RIPNG"
@classmethod
def generatexorpconfig(cls, node):
@ -324,7 +324,7 @@ class XorpPimSm4(XorpService):
"""
PIM Sparse Mode IPv4 multicast routing.
"""
_name = "XORP_PIMSM4"
name = "XORP_PIMSM4"
@classmethod
def generatexorpconfig(cls, node):
@ -383,7 +383,7 @@ class XorpPimSm6(XorpService):
"""
PIM Sparse Mode IPv6 multicast routing.
"""
_name = "XORP_PIMSM6"
name = "XORP_PIMSM6"
@classmethod
def generatexorpconfig(cls, node):
@ -442,7 +442,7 @@ class XorpOlsr(XorpService):
"""
OLSR IPv4 unicast MANET routing.
"""
_name = "XORP_OLSR"
name = "XORP_OLSR"
@classmethod
def generatexorpconfig(cls, node):

23
daemon/core/xml/xmlparser0.py
View file

@ -4,7 +4,7 @@ from core import logger
from core.conf import ConfigShim
from core.enumerations import NodeTypes
from core.misc import nodeutils
from core.service import ServiceManager
from core.service import ServiceManager, ServiceShim
from core.xml import xmlutils
@ -316,7 +316,10 @@ class CoreDocumentParser0(object):
# associate nodes with services
for objid in sorted(svclists.keys()):
n = self.session.get_object(objid)
self.session.services.addservicestonode(node=n, nodetype=n.type, services_str=svclists[objid])
services = svclists[objid]
if services:
services = services.split("|")
self.session.services.addservicestonode(node=n, node_type=n.type, services=services)
def parseservice(self, service, n):
"""
@ -367,16 +370,20 @@ class CoreDocumentParser0(object):
filename = file.getAttribute("name")
files.append(filename)
data = xmlutils.get_text_child(file)
typestr = "service:%s:%s" % (name, filename)
self.session.services.setservicefile(nodenum=n.objid, type=typestr,
filename=filename,
srcname=None, data=data)
self.session.services.setservicefile(node_id=n.objid, service_name=name, filename=filename, data=data)
if len(files):
values.append("files=%s" % files)
if not bool(service.getAttribute("custom")):
return True
values = ConfigShim.str_to_dict(values)
self.session.services.setcustomservice(n.objid, svc, values)
self.session.services.setcustomservice(n.objid, svc)
# set custom values for custom service
svc = self.session.services.getcustomservice(n.objid, None)
if not svc:
raise ValueError("custom service(%s) for node(%s) does not exist", svc.name, n.objid)
values = ConfigShim.str_to_dict("|".join(values))
for name, value in values.iteritems():
ServiceShim.setvalue(svc, name, value)
return True
def parsehooks(self, hooks):

21
daemon/core/xml/xmlparser1.py
View file

@ -8,7 +8,7 @@ from core.conf import ConfigShim
from core.enumerations import NodeTypes
from core.misc import nodeutils
from core.misc.ipaddress import MacAddress
from core.service import ServiceManager
from core.service import ServiceManager, ServiceShim
from core.xml import xmlutils
@ -639,17 +639,19 @@ class CoreDocumentParser1(object):
custom = service.getAttribute('custom')
if custom and custom.lower() == 'true':
values = ConfigShim.str_to_dict(values)
self.session.services.setcustomservice(node.objid, session_service, values)
self.session.services.setcustomservice(node.objid, session_service.name)
values = ConfigShim.str_to_dict("|".join(values))
for key, value in values.iteritems():
ServiceShim.setvalue(session_service, key, value)
# NOTE: if a custom service is used, setservicefile() must be
# called after the custom service exists
for typestr, filename, data in files:
svcname = typestr.split(":")[1]
self.session.services.setservicefile(
nodenum=node.objid,
type=typestr,
node_id=node.objid,
service_name=svcname,
filename=filename,
srcname=None,
data=data
)
return str(name)
@ -678,10 +680,13 @@ class CoreDocumentParser1(object):
services_str = None # default services will be added
else:
return
if services_str:
services_str = services_str.split("|")
self.session.services.addservicestonode(
node=node,
nodetype=node_type,
services_str=services_str
node_type=node_type,
services=services_str
)
def set_object_presentation(self, obj, element, node_type):

24
daemon/core/xml/xmlwriter0.py
View file

@ -284,7 +284,7 @@ class CoreDocumentWriter0(Document):
for svc in defaults:
s = self.createElement("Service")
spn.appendChild(s)
s.setAttribute("name", str(svc._name))
s.setAttribute("name", str(svc.name))
def addservices(self, node):
"""
@ -302,17 +302,17 @@ class CoreDocumentWriter0(Document):
for svc in node.services:
s = self.createElement("Service")
spn.appendChild(s)
s.setAttribute("name", str(svc._name))
s.setAttribute("startup_idx", str(svc._startindex))
if svc._starttime != "":
s.setAttribute("start_time", str(svc._starttime))
s.setAttribute("name", str(svc.name))
s.setAttribute("startup_idx", str(svc.startindex))
if svc.starttime != "":
s.setAttribute("start_time", str(svc.starttime))
# only record service names if not a customized service
if not svc._custom:
if not svc.custom:
continue
s.setAttribute("custom", str(svc._custom))
xmlutils.add_elements_from_list(self, s, svc._dirs, "Directory", "name")
s.setAttribute("custom", str(svc.custom))
xmlutils.add_elements_from_list(self, s, svc.dirs, "Directory", "name")
for fn in svc._configs:
for fn in svc.configs:
if len(fn) == 0:
continue
f = self.createElement("File")
@ -327,9 +327,9 @@ class CoreDocumentWriter0(Document):
txt = self.createTextNode(data)
f.appendChild(txt)
xmlutils.add_text_elements_from_list(self, s, svc._startup, "Command", (("type", "start"),))
xmlutils.add_text_elements_from_list(self, s, svc._shutdown, "Command", (("type", "stop"),))
xmlutils.add_text_elements_from_list(self, s, svc._validate, "Command", (("type", "validate"),))
xmlutils.add_text_elements_from_list(self, s, svc.startup, "Command", (("type", "start"),))
xmlutils.add_text_elements_from_list(self, s, svc.shutdown, "Command", (("type", "stop"),))
xmlutils.add_text_elements_from_list(self, s, svc.validate, "Command", (("type", "validate"),))
def addaddresses(self, i, netif):
"""

29
daemon/core/xml/xmlwriter1.py
View file

@ -277,7 +277,7 @@ class ScenarioPlan(XmlElement):
for svc in defaults:
s = self.createElement("service")
spn.appendChild(s)
s.setAttribute("name", str(svc._name))
s.setAttribute("name", str(svc.name))
if defaultservices.hasChildNodes():
self.appendChild(defaultservices)
@ -680,24 +680,24 @@ class DeviceElement(NamedXmlElement):
for svc in device_object.services:
s = self.createElement("service")
spn.appendChild(s)
s.setAttribute("name", str(svc._name))
s.setAttribute("startup_idx", str(svc._startindex))
if svc._starttime != "":
s.setAttribute("start_time", str(svc._starttime))
s.setAttribute("name", str(svc.name))
s.setAttribute("startup_idx", str(svc.startindex))
if svc.starttime != "":
s.setAttribute("start_time", str(svc.starttime))
# only record service names if not a customized service
if not svc._custom:
if not svc.custom:
continue
s.setAttribute("custom", str(svc._custom))
xmlutils.add_elements_from_list(self, s, svc._dirs, "directory", "name")
s.setAttribute("custom", str(svc.custom))
xmlutils.add_elements_from_list(self, s, svc.dirs, "directory", "name")
for fn in svc._configs:
for fn in svc.configs:
if len(fn) == 0:
continue
f = self.createElement("file")
f.setAttribute("name", fn)
# all file names are added to determine when a file has been deleted
s.appendChild(f)
data = self.coreSession.services.getservicefiledata(svc, fn)
data = svc.configtxt.get(fn)
if data is None:
# this includes only customized file contents and skips
# the auto-generated files
@ -705,12 +705,9 @@ class DeviceElement(NamedXmlElement):
txt = self.createTextNode("\n" + data)
f.appendChild(txt)
xmlutils.add_text_elements_from_list(self, s, svc._startup, "command",
(("type", "start"),))
xmlutils.add_text_elements_from_list(self, s, svc._shutdown, "command",
(("type", "stop"),))
xmlutils.add_text_elements_from_list(self, s, svc._validate, "command",
(("type", "validate"),))
xmlutils.add_text_elements_from_list(self, s, svc.startup, "command", (("type", "start"),))
xmlutils.add_text_elements_from_list(self, s, svc.shutdown, "command", (("type", "stop"),))
xmlutils.add_text_elements_from_list(self, s, svc.validate, "command", (("type", "validate"),))
class ChannelElement(NamedXmlElement):

2
daemon/examples/netns/howmanynodes.py
View file

@ -159,7 +159,7 @@ def main():
n.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
n.cmd([constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"])
if options.services is not None:
session.services.addservicestonode(n, "", options.services)
session.services.addservicestonode(n, "", options.services.split("|"))
n.boot()
nodelist.append(n)
if i % 25 == 0:

3
daemon/examples/netns/wlanemanetests.py
View file

@ -429,8 +429,7 @@ class Experiment(object):
self.net.link(prev.netif(0), tmp.netif(0))
prev = tmp
def createemanesession(self, numnodes, verbose=False, cls=None,
values=None):
def createemanesession(self, numnodes, verbose=False, cls=None, values=None):
""" Build a topology consisting of the given number of LxcNodes
connected to an EMANE WLAN.
"""

14
daemon/tests/conftest.py
View file

@ -7,7 +7,6 @@ import os
import pytest
from mock.mock import MagicMock
from core import services
from core.api.coreapi import CoreConfMessage
from core.api.coreapi import CoreEventMessage
from core.api.coreapi import CoreExecMessage
@ -29,6 +28,7 @@ from core.enumerations import NodeTlvs
from core.enumerations import NodeTypes
from core.misc import ipaddress
from core.misc.ipaddress import MacAddress
from core.service import ServiceManager
EMANE_SERVICES = "zebra|OSPFv3MDR|IPForward"
@ -199,6 +199,7 @@ class CoreServerTest(object):
self.request_handler.handle_message(message)
def shutdown(self):
self.server.coreemu.shutdown()
self.server.shutdown()
self.server.server_close()
@ -223,6 +224,9 @@ def session():
# shutdown coreemu
coreemu.shutdown()
# clear services, since they will be reloaded
ServiceManager.services.clear()
@pytest.fixture(scope="module")
def ip_prefixes():
@ -231,9 +235,6 @@ def ip_prefixes():
@pytest.fixture()
def cored():
# load default services
services.load()
# create and return server
server = CoreServerTest()
yield server
@ -241,6 +242,11 @@ def cored():
# cleanup
server.shutdown()
#
# cleanup services
ServiceManager.services.clear()
def ping(from_node, to_node, ip_prefixes, count=3):
address = ip_prefixes.ip4_address(to_node)

32
daemon/tests/myservices/sample.py
View file

@ -6,22 +6,22 @@ from core.service import CoreService
class MyService(CoreService):
_name = "MyService"
_group = "Utility"
_depends = ()
_dirs = ()
_configs = ('myservice.sh',)
_startindex = 50
_startup = ('sh myservice.sh',)
_shutdown = ()
name = "MyService"
group = "Utility"
depends = ()
dirs = ()
configs = ('myservice.sh',)
startindex = 50
startup = ('sh myservice.sh',)
shutdown = ()
class MyService2(CoreService):
_name = "MyService2"
_group = "Utility"
_depends = ()
_dirs = ()
_configs = ('myservice.sh',)
_startindex = 50
_startup = ('sh myservice.sh',)
_shutdown = ()
name = "MyService2"
group = "Utility"
depends = ()
dirs = ()
configs = ('myservice.sh',)
startindex = 50
startup = ('sh myservice.sh',)
shutdown = ()

12
daemon/tests/test_core.py
View file

@ -15,10 +15,8 @@ from core.enumerations import NodeTypes
from core.mobility import BasicRangeModel
from core.mobility import Ns2ScriptedMobility
from core.netns.vnodeclient import VnodeClient
from core.service import ServiceManager
_PATH = os.path.abspath(os.path.dirname(__file__))
_SERVICES_PATH = os.path.join(_PATH, "myservices")
_MOBILITY_FILE = os.path.join(_PATH, "mobility.scen")
_WIRED = [
NodeTypes.PEER_TO_PEER,
@ -51,16 +49,6 @@ def ping(from_node, to_node, ip_prefixes):
class TestCore:
def test_import_service(self):
"""
Test importing a custom service.
:param conftest.Core core: core fixture to test with
"""
ServiceManager.add_services(_SERVICES_PATH)
assert ServiceManager.get("MyService")
assert ServiceManager.get("MyService2")
@pytest.mark.parametrize("net_type", _WIRED)
def test_wired_ping(self, session, net_type, ip_prefixes):
"""

3
daemon/tests/test_gui.py
View file

@ -101,7 +101,7 @@ def run_cmd(node, exec_cmd):
class TestGui:
def test_broker(self, session, cored):
def test_broker(self, cored):
"""
Test session broker creation.
@ -119,6 +119,7 @@ class TestGui:
daemon = "localhost"
# add server
session = cored.server.coreemu.create_session()
session.broker.addserver(daemon, "127.0.0.1", CORE_API_PORT)
# setup server

18
daemon/tests/test_services.py Normal file
View file

@ -0,0 +1,18 @@
import os
from core.service import ServiceManager
_PATH = os.path.abspath(os.path.dirname(__file__))
_SERVICES_PATH = os.path.join(_PATH, "myservices")
class TestServices:
def test_import_service(self):
"""
Test importing a custom service.
:param conftest.Core core: core fixture to test with
"""
ServiceManager.add_services(_SERVICES_PATH)
assert ServiceManager.get("MyService")
assert ServiceManager.get("MyService2")

70
daemon/tests/test_xml.py
View file

@ -6,6 +6,7 @@ from core.emane.ieee80211abg import EmaneIeee80211abgModel
from core.emulator.emudata import NodeOptions
from core.enumerations import NodeTypes
from core.mobility import BasicRangeModel
from core.services.utility import SshService
_XML_VERSIONS = [
"0.0",
@ -68,6 +69,75 @@ class TestXml:
assert session.get_object(n1_id)
assert session.get_object(n2_id)
@pytest.mark.parametrize("version", _XML_VERSIONS)
def test_xml_ptp_services(self, session, tmpdir, version, ip_prefixes):
"""
Test xml client methods for a ptp neetwork.
:param session: session for test
:param tmpdir: tmpdir to create data in
:param str version: xml version to write and parse
:param ip_prefixes: generates ip addresses for nodes
"""
# create ptp
ptp_node = session.add_node(_type=NodeTypes.PEER_TO_PEER)
# create nodes
node_options = NodeOptions(model="host")
node_one = session.add_node(node_options=node_options)
node_two = session.add_node()
# link nodes to ptp net
for node in [node_one, node_two]:
interface = ip_prefixes.create_interface(node)
session.add_link(node.objid, ptp_node.objid, interface_one=interface)
# set custom values for node service\
custom_start = 50
session.services.setcustomservice(node_one.objid, SshService.name)
service = session.services.getcustomservice(node_one.objid, SshService.name)
service.startindex = custom_start
service_file = SshService.configs[0]
file_data = "# test"
session.services.setservicefile(node_one.objid, SshService.name, service_file, file_data)
# instantiate session
session.instantiate()
# get ids for nodes
n1_id = node_one.objid
n2_id = node_two.objid
# save xml
xml_file = tmpdir.join("session.xml")
file_path = xml_file.strpath
session.save_xml(file_path, version)
# verify xml file was created and can be parsed
assert xml_file.isfile()
assert ElementTree.parse(file_path)
# stop current session, clearing data
session.shutdown()
# verify nodes have been removed from session
with pytest.raises(KeyError):
assert not session.get_object(n1_id)
with pytest.raises(KeyError):
assert not session.get_object(n2_id)
# load saved xml
session.open_xml(file_path, start=True)
# retrieve custom service
service = session.services.getcustomservice(node_one.objid, SshService.name)
# verify nodes have been recreated
assert session.get_object(n1_id)
assert session.get_object(n2_id)
assert service.startindex == custom_start
assert service.configtxt.get(service_file) == file_data
@pytest.mark.parametrize("version", _XML_VERSIONS)
def test_xml_mobility(self, session, tmpdir, version, ip_prefixes):
"""

6
ns3/examples/ns3wifirandomwalk.py
View file

@ -16,13 +16,13 @@ import sys
import ns.core
import ns.network
from corens3.obj import Ns3Session
from corens3.obj import Ns3WifiNet
from core import logger
from core.misc import ipaddress
from core.misc import nodemaps
from core.misc import nodeutils
from corens3.obj import Ns3Session
from corens3.obj import Ns3WifiNet
def add_to_server(session):
@ -60,7 +60,7 @@ def wifisession(opt):
node = session.addnode(name="n%d" % i)
node.newnetif(wifi, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)])
nodes.append(node)
session.services.addservicestonode(node, "router", services_str)
session.services.addservicestonode(node, "router", services_str.split("|"))
session.services.bootnodeservices(node)
session.setuprandomwalkmobility(bounds=(1000.0, 750.0, 0))