class TestScopedServers(TestCase):
def setUp(self):
self.manager = Manager()
# Debugger().register(self.manager)
self.server1 = BaseServer(("localhost", 8000), channel="site1")
self.server1.register(self.manager);
ScopeDispatcher(channel="site1").register(self.server1)
Root1().register(self.manager)
self.server2 = BaseServer(("localhost", 8001), channel="site2")
self.server2.register(self.manager);
ScopeDispatcher(channel="site2").register(self.server2)
Root2().register(self.manager)
self.manager.start()
def tearDown(self):
self.manager.stop()
def test_access(self):
f = urlopen(self.server1.base)
s = f.read()
self.assertEqual(s, b"Hello from site 1!")
f = urlopen(self.server2.base)
s = f.read()
self.assertEqual(s, b"Hello from site 2!")
class TestScopedServers(TestCase):
def setUp(self):
self.manager = Manager()
# Debugger().register(self.manager)
self.server1 = BaseServer(("localhost", 8000), channel="site1")
self.server1.register(self.manager)
ScopeDispatcher(channel="site1").register(self.server1)
Root1().register(self.manager)
self.server2 = BaseServer(("localhost", 8001), channel="site2")
self.server2.register(self.manager)
ScopeDispatcher(channel="site2").register(self.server2)
Root2().register(self.manager)
self.manager.start()
def tearDown(self):
self.manager.stop()
def test_access(self):
f = urlopen(self.server1.base)
s = f.read()
self.assertEqual(s, b"Hello from site 1!")
f = urlopen(self.server2.base)
s = f.read()
self.assertEqual(s, b"Hello from site 2!")
def test_disps():
manager = Manager()
server1 = BaseServer(0, channel="site1")
server1.register(manager)
PrefixingDispatcher(channel="site1").register(server1)
Dispatcher(channel="site1").register(server1)
Root1().register(manager)
server2 = BaseServer(("localhost", 0), channel="site2")
server2.register(manager)
PrefixingDispatcher(channel="site2").register(server2)
Dispatcher(channel="site2").register(server2)
Root2().register(manager)
DummyRoot().register(manager)
manager.start()
f = urlopen(server1.http.base, timeout=3)
s = f.read()
assert s == b"Hello from site 1!"
f = urlopen(server2.http.base, timeout=3)
s = f.read()
assert s == b"Hello from site 2!"
def test_disps():
manager = Manager()
server1 = BaseServer(0, channel="site1")
server1.register(manager)
PrefixingDispatcher(channel="site1").register(server1)
Dispatcher(channel="site1").register(server1)
Root1().register(manager)
server2 = BaseServer(("localhost", 0), channel="site2")
server2.register(manager)
PrefixingDispatcher(channel="site2").register(server2)
Dispatcher(channel="site2").register(server2)
Root2().register(manager)
DummyRoot().register(manager)
manager.start()
f = urlopen(server1.http.base, timeout=3)
s = f.read()
assert s == b"Hello from site 1!"
f = urlopen(server2.http.base, timeout=3)
s = f.read()
assert s == b"Hello from site 2!"
def setUp(self):
self.manager = Manager()
# Debugger().register(self.manager)
self.server1 = BaseServer(("localhost", 8000), channel="site1")
self.server1.register(self.manager)
ScopeDispatcher(channel="site1").register(self.server1)
Root1().register(self.manager)
self.server2 = BaseServer(("localhost", 8001), channel="site2")
self.server2.register(self.manager)
ScopeDispatcher(channel="site2").register(self.server2)
Root2().register(self.manager)
self.manager.start()
def setup_broker(self, cfg):
"""
Currently only creates a dummy Broker object for registering Applications to.
:param cfg:
:return:
"""
self.__broker = Broker()
def main():
broker = Manager()
alarm = FireAlarm(broker)
# bomb = Bomb(broker)
# bomb = DudBomb(broker)
bomb = SensorBomb(broker)
gas = Gasoline(broker)
# logger = Logger(broker)
logger = LogEventSink(broker)
reporter = EventReporter(broker)
reporter.add_sink(logger)
DummyTemperatureVirtualSensor(broker)
# alarm.subscribe(Fire)
broker.run()
def main():
broker = Manager()
alarm = FireAlarm(broker)
# bomb = Bomb(broker)
# bomb = DudBomb(broker)
bomb = SensorBomb(broker)
gas = Gasoline(broker)
# logger = Logger(broker)
logger = LogEventSink(broker)
reporter = EventReporter(broker)
reporter.add_sink(logger)
DummyTemperatureVirtualSensor(broker)
# alarm.subscribe(Fire)
broker.run()
def test_access(self):
self.manager = Manager()
Debugger().register(self.manager)
self.server = BaseServer(("localhost", 8000))
self.server.register(self.manager)
Dispatcher().register(self.server)
Root().register(self.manager)
Leaf().register(self.manager)
self.manager.start()
f = urlopen(self.server.base + "/test.txt")
s = f.read()
self.assertEqual(s, b"Hello world!")
f = urlopen(self.server.base + "/test/test.txt")
s = f.read()
self.assertEqual(s, b"Hello world!")
self.manager.stop()
class TestVPathArgs(TestCase):
def test_access(self):
self.manager = Manager()
Debugger().register(self.manager)
self.server = BaseServer(("localhost", 8000))
self.server.register(self.manager);
Dispatcher().register(self.server)
Root().register(self.manager)
Leaf().register(self.manager)
self.manager.start()
f = urlopen(self.server.base + "/test.txt")
s = f.read()
self.assertEqual(s, b"Hello world!")
f = urlopen(self.server.base + "/test/test.txt")
s = f.read()
self.assertEqual(s, b"Hello world!")
self.manager.stop()
def setUp(self):
self.manager = Manager()
# Debugger().register(self.manager)
self.server1 = BaseServer(("localhost", 8000), channel="site1")
self.server1.register(self.manager);
ScopeDispatcher(channel="site1").register(self.server1)
Root1().register(self.manager)
self.server2 = BaseServer(("localhost", 8001), channel="site2")
self.server2.register(self.manager);
ScopeDispatcher(channel="site2").register(self.server2)
Root2().register(self.manager)
self.manager.start()
def __init__(self):
Manager.__init__(self)
AbstractBroker.__init__(self)
def __init__(self):
Manager.__init__(self)
AbstractBroker.__init__(self)
class ScaleClient:
"""This class parses a configuration file and subsequently creates, configures, and manages each component of the
overall Scale Client software.
"""
def __init__(self, config_filename):
self.__broker = None
self.__reporter = None
self.__sensors = []
self.__applications = None
try:
log.info("Reading config file: %s" % config_filename)
with open(config_filename) as cfile:
cfg = yaml.load(cfile)
# lower-case all top-level headings to tolerate different capitalizations
cfg = {k.lower(): v for k, v in cfg.items()}
# verify required entries present
# required_entries = ('main',)
# for ent in required_entries:
# if ent not in cfg:
# raise Exception("Required entry %s not present in config file." % ent)
# call appropriate handlers for each section in the appropriate order
if "main" in cfg:
self.setup_broker(cfg["main"])
self.setup_reporter(cfg["main"])
else:
self.setup_broker({})
self.setup_reporter({})
if "eventsinks" in cfg:
self.setup_event_sinks(cfg["eventsinks"])
if "sensors" in cfg:
self.setup_sensors(cfg["sensors"])
if "networks" in cfg:
self.setup_network(cfg["networks"])
if "applications" in cfg:
self.setup_applications(cfg["applications"])
except IOError as e:
log.error("Error reading config file: %s" % e)
exit(1)
def setup_reporter(self, cfg):
if self.__broker is None:
self.setup_broker(cfg)
self.__reporter = EventReporter(self.__broker)
def setup_broker(self, cfg):
"""
Currently only creates a dummy Broker object for registering Applications to.
:param cfg:
:return:
"""
self.__broker = Broker()
def setup_event_sinks(self, sink_configurations):
for sink_config in (sink.values()[0] for sink in sink_configurations):
# need to get class definition to call constructor
if "class" not in sink_config:
log.warn("Skipping EventSink with no class definition: %s" % sink_config)
continue
try:
# this line lets us tolerate just e.g. mqtt_event_sink.MQTTEventSink as a relative pathname
cls_name = (
sink_config["class"]
if "scale_client.event_sinks" in sink_config["class"]
else "scale_client.event_sinks." + sink_config["class"]
)
cls = self._get_class_by_name(cls_name)
# make a copy of config so we can tweak it to expose only correct kwargs
new_sink_config = sink_config.copy()
new_sink_config.pop("class")
sink = cls(self.__broker, **new_sink_config)
self.__reporter.add_sink(sink)
log.info("EventSink created from config: %s" % sink_config)
except Exception as e:
log.error("Unexpected error while creating EventSink: %s" % e)
def setup_applications(self, application_configurations):
n_applications = 0
for application_config in (c.values()[0] for c in application_configurations):
# need to get class definition to call constructor
if "class" not in application_config:
log.warn("Skipping virtual application with no class definition: %s" % application_config)
continue
try:
cls_name = (
application_config["class"]
if "scale_client.applications" in application_config["class"]
else "scale_client.applications." + application_config["class"]
)
cls = self._get_class_by_name(cls_name)
# copy config s so we can tweak it as necessary to expose only correct kwargs
new_application_config = application_config.copy()
new_application_config.pop("class")
cls(self.__broker, **new_application_config)
n_applications += 1
log.info("Application created from config: %s" % application_config)
except Exception as e:
log.error("Unexpected error (%s) while creating application: %s" % (e, application_config))
continue
def setup_sensors(self, sensor_configurations):
n_sensors = 0
for sensor_config in (c.values()[0] for c in sensor_configurations):
# need to get class definition to call constructor
if "class" not in sensor_config:
log.warn("Skipping virtual sensor with no class definition: %s" % sensor_config)
continue
try:
cls_name = (
sensor_config["class"]
if "scale_client.sensors" in sensor_config["class"]
else "scale_client.sensors." + sensor_config["class"]
)
cls = self._get_class_by_name(cls_name)
# copy config so we can tweak it as necessary to expose only correct kwargs
new_sensor_config = sensor_config.copy()
new_sensor_config.pop("class")
dev_name = new_sensor_config.get("dev_name", "vs%i" % n_sensors)
new_sensor_config.pop("dev_name", dev_name)
cls(self.__broker, device=DeviceDescriptor(dev_name), **new_sensor_config)
n_sensors += 1
log.info("Virtual sensor created from config: %s" % sensor_config)
except Exception as e:
log.error("Unexpected error (%s) while creating virtual sensor: %s" % (e, sensor_config))
continue
def setup_network(self, network_configurations):
for network_config in (c.values()[0] for c in network_configurations):
# need to get class definition to call constructor
if "class" not in network_config:
log.warn("Skipping network config with no class definition: %s" % network_config)
continue
try:
cls_name = (
network_config["class"]
if "scale_client.network" in network_config["class"]
else "scale_client.network." + network_config["class"]
)
cls = self._get_class_by_name(cls_name)
# copy config s so we can tweak it as necessary to expose only correct kwargs
new_network_config = network_config.copy()
new_network_config.pop("class")
cls(self.__broker, **new_network_config)
log.info("Virtual sensor created from config: %s" % network_config)
except Exception as e:
log.error("Unexpected error (%s) while setting network class: %s" % (e, network_config))
def run(self):
"""Currently just loop forever to allow the other threads to do their work."""
# TODO: handle this with less overhead?
self.__broker.run()
def _get_class_by_name(self, kls):
"""Imports and returns a class reference for the full module name specified in regular Python import format"""
# TODO: download definition from some repository if necessary
# The following code taken from http://stackoverflow.com/questions/452969/does-python-have-an-equivalent-to-java-class-forname
parts = kls.split(".")
module = ".".join(parts[:-1])
m = __import__(module)
for comp in parts[1:]:
m = getattr(m, comp)
return m
class Root(Controller):
def index(self):
"""Index Request Handler
Controller(s) expose implicitly methods as request handlers.
Request Handlers can still be customized by using the ``@expose``
decorator. For example exposing as a different path.
"""
return "Hello World! (wsgi)"
# Create singleton application
wsgi_adapter = None
if not wsgi_adapter:
application = Manager(channel="app")
Debugger().register(application)
dispatcher = Dispatcher(channel="app").register(application)
Root().register(dispatcher)
wsgi_adapter = WSGIApplication(channel="app").register(application)
Thread(target=application.run).start()
if __name__ == '__main__':
server = Server(("0.0.0.0", 8888))
Gateway({"/": wsgi_adapter}).register(server)
server.run()
else:
wsgi_adapter
