def __init__(self, servercfg, dl):
self.server_started = Signal()
self.server_stopped = Signal()
self.servercfg = servercfg
self.dl = dl
cherrypy.engine.subscribe("start", self.on_start)
cherrypy.engine.subscribe("stop", self.on_stop)
def __init__(self, cfg, dl):
# signals
self.session_new = Signal(["session_id", "session_monitors"])
self.session_switch = Signal(["session_id"])
self.cfg = cfg
self.session_counter = 0
self.sessions = {}
self.session_id_format = "{uniq_id} - {date} - {time}"
dl.data_updated.connect(self.on_data_arrived)
class BaseFigure(object):
'''
A Panel with a line plot in it
'''
def __init__(self, **kwargs):
self.figure_updated = Signal()
self.figure = Figure((1,1))
self.axes = self.figure.add_subplot(111)
def accept_data(self, **kwargs):
'''
Handles a request from the HTTP server
'''
self.do_accept_data(**kwargs)
self.figure_updated.emit(figure=self)
def clear(self):
self.axes.cla()
self.axes.draw()
self.axes.Refresh()
class DataListener(object):
"""
HTTP Service that listens to requests and forwards them
upwards through the data_updated Signal
"""
def __init__(self):
self.data_updated = Signal(["monitor_name", "args"])
@cherrypy.expose
def index(self, **kwargs):
if "monitor_name" not in kwargs:
raise Exception("Data name not found")
monitor_name = kwargs.pop("monitor_name")
# pub.sendMessage('DATA', (monitor_name, kwargs))
self.data_updated.emit(monitor_name=monitor_name, args=kwargs)
def _cp_dispatch(self, vpath):
assert len(vpath) == 1
cherrypy.request.params["monitor_name"] = vpath.pop()
return self
class ListeningService(object):
def __init__(self, servercfg, dl):
self.server_started = Signal()
self.server_stopped = Signal()
self.servercfg = servercfg
self.dl = dl
cherrypy.engine.subscribe("start", self.on_start)
cherrypy.engine.subscribe("stop", self.on_stop)
def on_start(self):
self.server_started.emit()
def on_stop(self):
self.server_stopped.emit()
def start(self):
cherrypy.config.update(self.servercfg)
cherrypy.tree.mount(self.dl, "", None)
if hasattr(cherrypy.engine, "signal_handler"):
cherrypy.engine.signal_handler.subscribe()
if hasattr(cherrypy.engine, "console_control_handler"):
cherrypy.engine.console_control_handler.subscribe()
cherrypy.engine.start()
def stop(self):
cherrypy.engine.stop()
def exit(self):
cherrypy.engine.exit()
def block(self):
cherrypy.engine.block()
class SessionManager:
""" A Session consist of a collection of DataMonitors
The SessionManager connects to a DataListener (dl) and sends
all data that it receives to the corresponding DataThreadMonitor
in the active Session.
"""
def __init__(self, cfg, dl):
# signals
self.session_new = Signal(["session_id", "session_monitors"])
self.session_switch = Signal(["session_id"])
self.cfg = cfg
self.session_counter = 0
self.sessions = {}
self.session_id_format = "{uniq_id} - {date} - {time}"
dl.data_updated.connect(self.on_data_arrived)
def switch_new_session(self):
self.switch_session(self.new_session())
def new_session(self):
self.session_counter = self.session_counter + 1
session_id = self.session_id_format.format(
uniq_id=self.session_counter,
date=datetime.datetime.now().strftime("%Y-%m-%d"),
time=datetime.datetime.now().strftime("%H:%M"),
)
self.sessions[session_id] = {}
new_session = {}
if "tabs" in self.cfg["elements"]:
for tab_name, elements in self.cfg["elements"]["tabs"].iteritems():
new_session[tab_name] = {}
for monitor_name, data_cfg in elements.iteritems():
self.sessions[session_id][monitor_name] = DataThreadMonitor(data_cfg)
new_session[tab_name][monitor_name] = self.sessions[session_id][monitor_name]
else:
new_session["default"] = {}
for monitor_name, data_cfg in self.cfg["elements"].iteritems():
self.sessions[session_id][monitor_name] = DataThreadMonitor(data_cfg)
new_session["default"][monitor_name] = self.sessions[session_id][monitor_name]
# pub.sendMessage("SESSION NEW", (session_id,
# self.get_session_monitors(session_id)))
self.session_new.emit(session_id=session_id, session_monitors=new_session)
return session_id
def get_session_monitors(self, session_id):
return self.sessions[session_id]
def current_session(self):
return self.sessions[self.current_session_id]
def switch_session(self, session_id):
self.current_session_id = session_id
# pub.sendMessage("SESSION SWICH", session_id)
self.session_switch.emit(session_id=session_id)
return session_id
def clone_session(self, session_id):
other_session = self.get_session_monitors(session_id)
for monitor_name, monitor in self.current_session().iteritems():
monitor.ghost_clone(other_session[monitor_name])
def on_data_arrived(self, monitor_name, args, **kwargs):
try:
print monitor_name
self.current_session()[monitor_name].accept_data(**args)
except KeyError:
logger.error("Monitor {0} not found".format(monitor_name))
def save(self, out_dir):
for session_id, monitors in self.sessions.iteritems():
session_out_dir = os.path.join(out_dir, str(session_id))
mkdir_p(session_out_dir)
for monitor_name, monitor in monitors.iteritems():
monitor.save(os.path.join(session_out_dir, monitor_name + ".png"))
def clear(self):
for monitor_name, monitor in self.current_session().iteritems():
monitor.clear()
def __init__(self, **kwargs):
self.figure_updated = Signal()
self.figure = Figure((1,1))
self.axes = self.figure.add_subplot(111)
def __init__(self):
self.data_updated = Signal(["monitor_name", "args"])
