contiki/backyard/tools/chakana/shepherd.py

348 lines
13 KiB
Python

import re
import socket
import threads
import xml.dom.minidom
import thread
import chakana.error
import chakana.event
import chakana.monitor
import chakana.threads
import chakana.utils
from chakana.debug import *
class Shepherd:
"""The shepherd is a singleton class that manages the connection to COOJA
and keeps track of user monitor threads. The user initialises a
debugging scenario by creating a Shepherd object, and then calls the
newMonitor method to create Monitor objects, one for each causal
path through the system that he wishes to monitor.
The monitor threads automatically register with the shepherd. The user
can use the debugger instances to probe variables or create eventpoints.
When the monitor thread routine decides that is ready for simulation to
proceed, it calls the waitFor method to block until one of the
eventpoints occur.
When a Monitor object enters waitFor, it informs shepherd about the
eventpoints that the user is waiting for, and waits for the eventpoints
to happen. When all threads enter waiting state, the shepherd asks COOJA
to resume simulation. When an eventpoint is hit, the shepherd wakes the
Monitor that is waiting for that eventpoint.
"""
def __init__(self, threadManager, port, coojaHost = "localhost"):
debug(MajorEvent, "Creating shepherd")
self._pollConnLock = threading.Lock()
self._threadManager = threadManager
self._port = port
self._monitors = []
self._waitingMonitors = []
# Only basic eventpoints in these lists
self._eventpoints = []
self._waitingEventpoints = []
self._coojaContinueEvent = threading.Event()
self._waitMap = {}
self._coojaHost = coojaHost
self._coojaConnection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
debug(MajorEvent, "Connecting to COOJA at " + coojaHost + ":" +
str(self._port))
self._connectionLock = threading.Lock()
self._coojaConnection.connect((self._coojaHost, self._port))
self._coojaStream = self._coojaConnection.makefile()
self._coojaConnection.close()
del self._coojaConnection
self._connectionLock.acquire()
hello = self.readFromCooja()
debug(Debug, hello.toprettyxml())
self._connectionLock.release()
self._shepherdThread = threads.ManagedThread(
self._threadManager, target = self._shepherdMainLoop)
self._shepherdThread.start()
debug(Debug, "Shepherd created:\n" + repr(self))
def _shepherdMainLoop(self):
debug(Event, "Starting shepherd main loop")
while 1:
debug(Debug, "Waiting for eventpoints to enter wait state")
debug(Debug2, repr(self))
self._coojaContinueEvent.wait()
self._coojaContinueEvent.clear()
if self._coojaStream.closed:
debug(Event, "Terminating shepherd main loop")
return
debug(Debug, "Resuming COOJA")
assert(len(self._eventpoints) == len(self._waitingEventpoints))
response = self.runCommand("CONTROL_SIM", { "RESUME" : None })
id = int(response.documentElement.childNodes[0].nodeValue)
debug(MinorEvent, "Eventpoint " + str(id) + " was triggered")
# Wake up triggered eventpoint
self._waitMap[id][1].set()
# Allow new main loop startups
self._pollConnLock.release()
def quit(self):
"""Send a termination request to the debugger broker, and discard all
debuggers."""
debug(Information, "Terminating the shepherd session")
self.runCommand("EXIT_COOJA")
self._connectionLock.acquire()
self._coojaStream.close()
self._connectionLock.release()
self._coojaContinueEvent.set()
debug(Information, "Number of PID errors reported: " + str(self.threadManager().nrPIDerrors()))
for (eventpoint, event) in self._waitMap.values():
debug(Debug2, "Awakening eventpoint at exit: " + repr(eventpoint))
event.set()
def loadConfiguration(self, fileName):
return self.runCommand(
"CREATE_SIM", xmlContent = chakana.utils.readFile(fileName))
def loadConfigurationXML(self, xmlContent):
return self.runCommand(
"CREATE_SIM", xmlContent = xmlContent)
def setConfigurationXML(self, xmlContent):
return self.runCommand(
"CONF_SIM", xmlContent = xmlContent)
def setPluginsXML(self, xmlContent):
return self.runCommand(
"CONF_PLUGINS", xmlContent = xmlContent)
def newMonitor(self, routine, * args, ** kwArgs):
return self.newCustomMonitor(
chakana.monitor.Monitor, routine, * args, ** kwArgs)
def newCustomMonitor(self, Type, routine = None, * args, ** kwArgs):
"""Start a new monitor thread running routine, with * args and ** kwArgs
as arguments."""
debug(Debug, "Creating new monitor of type " + Type.__name__)
debug(Debug3, "Routine: " + repr(routine) + ", arguments: " + repr(args) +
", keyword arguments: " + repr(kwArgs))
thread = Type(self, routine, * args, ** kwArgs)
debug(MinorEvent, "New monitor thread created: " + repr(thread))
return thread
def newTimeoutMonitor(self, eventpoint, timeout, routine = None):
return self.newCustomMonitor(
chakana.monitor.TimeoutWrapperMonitor, routine, eventpoint = eventpoint, timeout = timeout)
def threadManager(self):
return self._threadManager
def registerMonitor(self, monitor):
debug(Debug, "Registering monitor: " + repr(monitor))
assert(isinstance(monitor, chakana.monitor.Monitor))
assert(not (monitor in self._monitors))
assert(not (monitor in self._waitingMonitors))
self._monitors.append(monitor)
self._monitors.sort()
debug(Debug2, repr(self))
def unregisterMonitor(self, monitor):
debug(Debug, "Unregistering monitor: " + repr(monitor))
assert(isinstance(monitor, chakana.monitor.Monitor))
assert(monitor in self._monitors)
assert(not (monitor in self._waitingMonitors))
self._monitors.remove(monitor)
def registerWaitingMonitor(self, monitor):
debug(Debug, "Registering waiting monitor: " + repr(monitor))
assert(isinstance(monitor, chakana.monitor.Monitor))
assert(monitor in self._monitors)
assert(not (monitor in self._waitingMonitors))
self._waitingMonitors.append(monitor)
self._waitingMonitors.sort()
debug(Debug2, repr(self))
def unregisterWaitingMonitor(self, monitor):
debug(Debug, "Unregistering waiting monitor: " + repr(monitor))
assert(isinstance(monitor, chakana.monitor.Monitor))
assert(monitor in self._monitors)
assert(monitor in self._waitingMonitors)
self._waitingMonitors.remove(monitor)
debug(Debug2, repr(self))
def registerBasicEventpoint(self, eventpoint):
debug(Debug2, "Registering basic eventpoint: " + repr(eventpoint))
assert(isinstance(eventpoint, chakana.event.BasicEventpoint))
assert(not (eventpoint in self._eventpoints))
self._eventpoints.append(eventpoint)
self._eventpoints.sort()
debug(Debug2, repr(self))
def unregisterBasicEventpoint(self, eventpoint):
debug(Debug2, "Unregistering basic eventpoint: " + repr(eventpoint))
assert(not (eventpoint in self._waitingEventpoints))
assert(eventpoint in self._eventpoints)
self._eventpoints.remove(eventpoint)
debug(Debug2, repr(self))
def _registerWaitingEventpoint(self, eventpoint):
debug(Debug2, "Registering waiting eventpoint: " + repr(eventpoint))
assert(not (eventpoint in self._waitingEventpoints))
assert(eventpoint in self._eventpoints)
self._waitingEventpoints.append(eventpoint)
self._waitingEventpoints.sort()
def _unregisterWaitingEventpoint(self, eventpoint):
debug(Debug2, "Unregistering waiting eventpoint: " + repr(eventpoint))
assert(eventpoint in self._waitingEventpoints)
assert(eventpoint in self._eventpoints)
self._waitingEventpoints.remove(eventpoint)
debug(Debug2, repr(self))
def pollContinuation(self):
self._pollConnLock.acquire()
if len(self._waitingMonitors) != len(self._monitors):
self._pollConnLock.release()
return
for monitor in self._monitors:
if not monitor._ready:
self._pollConnLock.release()
return
for monitor in self._monitors:
assert(not monitor._discarded)
for eventpoint in self._eventpoints:
assert(not eventpoint._discarded)
assert(self._waitingMonitors == self._monitors)
assert(self._waitingEventpoints == self._eventpoints)
debug(MinorEvent, "All monitors are waiting, activating COOJA")
assert(not self._coojaContinueEvent.isSet())
self._coojaContinueEvent.set()
def waitForCoojaEventpoint(self, eventpoint):
response = self.runCommand("ADD_EVENTPOINT", eventpoint.coojaArguments())
id = int(response.documentElement.childNodes[0].nodeValue)
debug(Debug, "Waiting for COOJA eventpoint " + str(id))
resourceAllocated = 0
while resourceAllocated == 0:
try:
self._waitMap[id] = (eventpoint, threading.Event())
resourceAllocated = 1
except thread.error:
resourceAllocated = 0
self.threadManager().registerPIDerror()
self._registerWaitingEventpoint(eventpoint)
eventpoint._isWaitingEvent.set()
resourceAllocated = 0
while resourceAllocated == 0:
try:
self._waitMap[id][1].wait()
resourceAllocated = 1
except thread.error:
resourceAllocated = 0
self.threadManager().registerPIDerror()
del self._waitMap[id]
self._unregisterWaitingEventpoint(eventpoint)
try:
self.runCommand("DELETE_EVENTPOINT", { "id" : id })
debug(Debug, "COOJA event " + str(id) + " has occurred")
except chakana.error.CoojaExit:
pass
except socket.error:
pass
def runCommand(self, name, args = None, xmlContent = ""):
debug(Debug3, "Running cooja command " + name + ", args: " + repr(args) +
" xml content: " + repr(xmlContent))
if args is None:
args = {}
self._connectionLock.acquire()
try:
if self._coojaStream.closed:
raise chakana.error.CoojaExit()
command = ['<command value="' + name + '">']
for (key, value) in args.items():
if value is None:
command.append('<' + key + '/>')
else:
command.append('<' + key + '>' + str(value) + '</' + key + '>')
command.append(xmlContent + '</command>')
commandStr = "\n".join(command + ['\n'])
debug(MinorEvent, '--> ' + commandStr)
self._coojaStream.write(commandStr)
self._coojaStream.flush()
response = self.readFromCooja()
debug(Debug, response.toprettyxml())
if response.documentElement.tagName == 'error':
raise chakana.error.CoojaError(response)
self._connectionLock.release()
return response
except socket.error:
debug(MajorEvent, 'Socket error catched')
except AttributeError:
debug(MajorEvent, 'Attribute error catched')
def readFromCooja(self):
# XXX: Assume message ends with a newline
debug(Debug, "Reading message from COOJA")
responseLines = [self._coojaStream.readline()]
debug(Debug2, "First line: " + repr(responseLines[0]))
(rootElement, slash) = re.match(r"^\s*<(\w+)(/?)>",
responseLines[0]).groups()
debug(Debug3, "Root element: " + rootElement)
if slash != "/":
while 1:
if re.search("</" + re.escape(rootElement) + ">$", responseLines[-1],
re.M):
break
responseLines.append(self._coojaStream.readline())
debug(Debug3, "Read line: " + repr(responseLines[-1]))
result = "".join(responseLines)
debug(MinorEvent, '<-- ' + result)
return xml.dom.minidom.parseString(result)
def readVariable(self, variable, ** kwArgs):
response = self.readMemory(
type = "variable", variable = variable, ** kwArgs)
arrayString = response.documentElement.childNodes[0].nodeValue.split()
bytes = map(eval, arrayString)
debug(Debug, "Read variable " + variable + " as byte array: " +
repr(bytes))
return bytes
def readInt(self, ** kwArgs):
response = self.readMemory(type = "int", ** kwArgs)
return eval(response.documentElement.childNodes[0].nodeValue)
def readMemory(self, ** kwArgs):
return self.runCommand("READ_MEMORY", kwArgs)
def killNodesInInterval(self, ** kwArgs):
return self.runCommand("KILL_NODES", kwArgs)
def sendCustomCommand(self, ** kwArgs):
return self.runCommand("CUSTOM_COMMAND", kwArgs)
def getSimulationInfo(self, ** kwArgs):
response = self.runCommand("GET_INFO", kwArgs)
return eval(response.documentElement.childNodes[0].nodeValue)
def __repr__(self):
return "\n ".join([
"Shepherd:",
"Port: " + repr(self._port),
"Monitors: " + repr(self._monitors),
"Waiting monitors: " + repr(self._waitingMonitors),
"Basic eventpoints: [" + "\n".join(map(repr, self._eventpoints)) + "]",
"Waiting eventpoints: [" + "\n".join(
map(repr, self._waitingEventpoints)) + "]",
"Wait map: " + repr(self._waitMap),
])