contiki/tools/chakana/event.py

import time
import thread

from debug import *
import threads

class Eventpoint(threads.ManagedThread):

  """ The Eventpoint class and its subclasses represent important events
  happening in the debugged system, and are the primitives that Chakana
  debugging scripts are based around.  When the user calls waitFor with an
  Eventpoint list argument, each Eventpoint thread is started.  The
  Eventpoint inserts appropriate eventpoints into COOJA or creates child
  Eventpoints.  An Eventpoint that is hit posts itself on a trigger queue
  (Queue.Queue), where it is picked up by waitFor.  The Eventpoints that
  have not been triggered are then discarded by the waitFor routine."""

  def __init__(self, shepherd):
    threads.ManagedThread.__init__(self, shepherd.threadManager())
    self._shepherd = shepherd
    self._activated = 0
    self._discarded = 0
    self._triggerQueue = None

    resourceAllocated = 0
    while resourceAllocated == 0:
      try:
        self._isWaitingEvent = threading.Event()
        resourceAllocated = 1
      except thread.error:
        resourceAllocated = 0
        shepherd.threadManager().registerPIDerror()

  def await(self, triggerQueue):
    assert not self._activated, "Eventpoints can only be used once"
    self._triggerQueue = triggerQueue
    self._activated = 1
    self.activatedHook()
    self.start()

  def doRun(self):
    debug(Debug, "Waiting for event: " + repr(self))
    if not self._discarded:
      self.doWait()
    debug(MinorEvent, "Event was triggered: " + repr(self))
    if not self._discarded:
      self._triggerQueue.put(self)
    else:
      debug(Debug, "Event is no longer waited for: " + repr(self))

  def activatedHook(self):
    pass

  def doWait(self):
    raise NotImplementedError()

  def discard(self):
    debug(Debug, "Discarding eventpoint:\n" + repr(self))
    self._discarded = 1
    if (not self._activated):
      self.start()
    for (waitingEv, event) in self.shepherd()._waitMap.values():
      if waitingEv == self:
        event.set()
    self.join()
 
  def isDiscarded(self):
    return self._discarded

  def shepherd(self):
    return self._shepherd

  def __repr__(self):
    return "\n  ".join([
      "event.Eventpoint:",
      "Id: %#x" % ((id(self) + (long(1) << 32)) % (long(1) << 32)),
      ])

class BasicEventpoint(Eventpoint):
  """Eventpoint corresponding to a single COOJA Eventpoint."""

  def __init__(self, shepherd, ** kwArgs):
    Eventpoint.__init__(self, shepherd, ** kwArgs)

  def activatedHook(self):
    self.shepherd().registerBasicEventpoint(self)

  def doWait(self):
    self.shepherd().waitForCoojaEventpoint(self)
    self.shepherd().unregisterBasicEventpoint(self)

class Watchpoint(BasicEventpoint):
  def __init__(self, shepherd, type, mote, variable, ** kwArgs):
    self._type = type
    self._mote = mote
    self._variable = variable
    BasicEventpoint.__init__(self, shepherd, ** kwArgs)
    
  def coojaArguments(self):
    return { "type" : self._type,
             "mote" : self._mote,
             "variable" : self._variable }
      
  def __repr__(self):
    return "\n  ".join([
      BasicEventpoint.__repr__(self),
      "event.Watchpoint:",
      "Type: " + repr(self._type),
      "Mote: " + repr(self._mote),
      "Variable: " + repr(self._variable)
      ])
      
class TimeEventpoint(BasicEventpoint):
  def __init__(self, shepherd, time, ** kwArgs):
    self._time = time
    BasicEventpoint.__init__(self, shepherd, ** kwArgs)

  def coojaArguments(self):
    return { "type" : "time",
             "time" : self._time }
      
  def __repr__(self):
    return "\n  ".join([
      BasicEventpoint.__repr__(self),
      "event.TimeEventpoint:",
      "Time: " + repr(self._time)
      ])


class RadioMessageCompletedEventpoint(BasicEventpoint):
  def __init__(self, shepherd, count = 1, ** kwArgs):
    self._count = count
    BasicEventpoint.__init__(self, shepherd, ** kwArgs)

  def coojaArguments(self):
    return { "type" : "radiomedium",
             "triggeron" : "completed",
             "count" : str(self._count) }

  def __repr__(self):
    return "\n  ".join([
      BasicEventpoint.__repr__(self),
      "event.RadioMessageCompletedEventpoint",
      ])

class MonitorEventpoint(Eventpoint):
  """Eventpoint that triggers after a monitor has finished."""

  def __init__(self, monitor):
    self._monitor = monitor
    Eventpoint.__init__(self, monitor.shepherd())

  def doWait(self):
    debug(Debug, "MonitorEventpoint starting " + repr(self))
    self._monitor.startMonitor()
    self._monitor.waitMonitor(self)

  def discard(self):
    self._discarded = 1
    self._monitor.discard()
    if (not self._activated):
      self.start()
      self._monitor.startMonitor()
      self._monitor.waitMonitor(self)
    else:
      self._monitor.waitMonitor(self)
    self.join()

  def __repr__(self):
    return "\n  ".join([
      Eventpoint.__repr__(self),
      "event.MonitorEventpoint:",
      "Monitor: " + repr(self._monitor)
      ])