def start(self, devices):
print("Initliazing and Starting Server")
self.server = WebThingServer(MultipleThings(devices, 'UnityDevices'), port=8888)
self.x = threading.Thread(target=self.server.start)
self.x.daemon = True
self.x.start()
self.started = True
class Server():
def __init__(self):
print("Server Reader to Start")
self.server = None
self.x = None
self.started = False
def start(self, devices):
print("Initliazing and Starting Server")
self.server = WebThingServer(MultipleThings(devices, 'UnityDevices'), port=8888)
self.x = threading.Thread(target=self.server.start)
self.x.daemon = True
self.x.start()
self.started = True
def stop(self):
print("Server closing")
self.server.stop()
self.started = False
class testWebThingServer(Process):
def __init__(self, name, thing, port):
Process.__init__(self)
self.name = name
self.thing = thing
self.port = port
signal.signal(signal.SIGTERM, self.exit_handler)
signal.signal(signal.SIGINT, self.exit_handler)
def run(self):
self.ioloop = tornado.ioloop.IOLoop.instance()
self.server = WebThingServer(SingleThing(self.thing.get_thing()), port=self.port)
self.server.start()
self.pid = os.getpid()
def exit_handler(self, sig, frame):
if os.getpid() == self.pid:
self.server.stop()
sys.exit()
def run_server():
location = 'og-vorraum'
w1_device_id_list = get_w1_devices()
main_loop = tornado.ioloop.IOLoop.current()
node_functions = VorraumNode(location, w1_device_id_list)
node_functions.get_sensors()
led_strip = LedStrip(
location,
main_loop,
)
motion_sensor = MotionSensor(
location,
main_loop,
led_strip,
)
server = WebThingServer(MultipleThings([
node_functions,
led_strip,
motion_sensor,
], 'LightAndTempDevice'),
port=8888)
try:
logging.info('starting the server')
print('running')
server.start()
except KeyboardInterrupt:
logging.info('stopping async tasks')
print('interrupted')
node_functions.cancel_node_async_tasks()
led_strip.cancel_led_strip_async_tasks()
motion_sensor.cancel_motion_sensor_async_tasks()
logging.info('stopping the server')
server.stop()
logging.info('done \n')
def run_server(photos_path, static_path):
"""Create our photo cycler web thing and run the server."""
if not os.path.isdir(photos_path):
print('Photos directory does not exist')
sys.exit(1)
if not os.path.isdir(static_path):
print('Static directory does not exist')
sys.exit(1)
thing = PhotoCyclerThing(photos_path, static_path)
server = WebThingServer(SingleThing(thing),
port=8888,
additional_routes=[
(
r'/static/(.*)',
tornado.web.StaticFileHandler,
{
'path': static_path
},
),
])
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run_server():
# Create a thing that represents a humidity sensor
# tempsensor1 = FakeTempSensor("A1")
# humidsensor1 = FakeHumidSensor("A1")
# tempsensor2 = FakeTempSensor("A2")
# humidsensor2 = FakeHumidSensor("A2")
tempsensor10 = FakeTempSensor("A10")
humidsensor10 = FakeHumidSensor("A10")
# If adding more than one thing, use MultipleThings() with a name.
# In the single thing case, the thing's name will be broadcast.
server = WebThingServer(MultipleThings([tempsensor10, humidsensor10],
'TempandHumidDevice'),
port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.debug('canceling the sensor update looping task')
# tempsensor1.cancel_update_level_task()
# humidsensor1.cancel_update_level_task()
# tempsensor2.cancel_update_level_task()
# humidsensor2.cancel_update_level_task()
tempsensor10.cancel_update_level_task()
humidsensor10.cancel_update_level_task()
logging.info('stopping the server')
server.stop()
logging.info('done')
def _load_runners(self):
trigger = RandomTrigger(tests_per_day=self._tests_per_day,
immediate=self._immediate)
# Load test runners
for entry_point in pkg_resources.iter_entry_points("murakami.runners"):
logging.debug("Loading test runner %s", entry_point.name)
if "tests" not in self._config:
self._config["tests"] = {}
if entry_point.name not in self._config["tests"]:
self._config["tests"][entry_point.name] = {"enabled": False}
self._runners[entry_point.name] = entry_point.load()(
config=self._config["tests"][entry_point.name],
data_cb=self._call_exporters,
location=self._location,
network_type=self._network_type,
connection_type=self._connection_type,
device_id=self._device_id,
)
# Start webthings server if enabled
if self._webthings:
self._server = WebThingServer(
SingleThing(MurakamiThing(self._runners.values())),
port=self._port,
hostname=self._hostname,
ssl_options=self._ssl_options,
additional_routes=self._additional_routes,
base_path=self._base_path,
)
# Start test scheduler if enabled
if self._tests_per_day > 0:
self._scheduler = TornadoScheduler()
self._scheduler.add_job(self._call_runners,
id="runners",
name="Test Runners",
trigger=trigger)
def run_server():
"""Create our MPD Web Thing and run the server."""
thing = MPDThing()
server = WebThingServer(SingleThing(thing), port=8888)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run_server():
thing = make_thing()
server = WebThingServer(SingleThing(thing), port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stoping the server')
server.stop()
logging.info('done')
def run_server():
thing = make_thing()
# If adding more than one thing here, be sure to set the `name`
# parameter to some string, which will be broadcast via mDNS.
# In the single thing case, the thing's name will be broadcast.
server = WebThingServer([thing], port=8888)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run_server():
weatherstation = weatherstationbme680.WeatherstationBME680()
server = WebThingServer(SingleThing(weatherstation), port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
light = SenseHatThingLight()
sensor = SenseHatThingSensor()
server = WebThingServer(MultipleThings([light, sensor], 'SenseHat'),
port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server(port: int, gpio_number: int, name: str, description: str):
light_sensor = LightSensor(gpio_number, name, description)
server = WebThingServer(SingleThing(light_sensor),
port=port,
disable_host_validation=True)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server(config):
things = make_things(config)
port = 8888
server = WebThingServer(MultipleThings(things, 'OpenWebNet'), port=port)
try:
print('starting the server on port %d'%(port,))
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
sht = SHT20(1, 0x40)
h, t = sht.all()
celsius = Value(t.C)
humidity = Value(h.RH)
thing = Thing('urn:dev:ops:humidity-temperature-sensor', 'SHT20_Anthony',
['MultiLevelSensor'])
thing.add_property(
Property(thing,
'humidity',
humidity,
metadata={
'@type': 'LevelProperty',
'title': 'Humidity',
'type': 'number',
'unit': 'percent',
'readOnly': True
}))
thing.add_property(
Property(thing,
'temperature',
celsius,
metadata={
'@type': 'LevelProperty',
'title': 'Temperature',
'type': 'number',
'unit': '°C',
'readOnly': True
}))
server = WebThingServer(SingleThing(thing), port=8889)
def update():
h, t = sht.all()
celsius.notify_of_external_update(t.C)
humidity.notify_of_external_update(h.RH)
timer = tornado.ioloop.PeriodicCallback(update, 3000)
timer.start()
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.debug('stopping update task')
timer.stop()
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
thing = SIISLight()
# If adding more than one thing, use MultipleThings() with a name.
# In the single thing case, the thing's name will be broadcast.
server = WebThingServer(SingleThing(thing), port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server(port: int, gpio_number: int, description: str):
eltakows_sensor = EltakoWsSensor(gpio_number, description)
server = WebThingServer(SingleThing(eltakows_sensor),
port=port,
disable_host_validation=True)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
eltakows_sensor.cancel_measure_task()
server.stop()
logging.info('done')
def run_server(port: int, name: str, i2c_expander: str, i2c_address: int,
description: str):
lcd = createI2C(i2c_expander, i2c_address)
display_webthing = DisplayWebThing(name, description, lcd)
server = WebThingServer(SingleThing(display_webthing),
port=port,
disable_host_validation=True)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server(port=8888, poll_delay=3.0):
sensor = LuxSensor(poll_delay=poll_delay)
server = WebThingServer(SingleThing(sensor), port=port)
try:
logging.info("starting the server")
server.start()
except KeyboardInterrupt:
logging.debug("cancelling the sensor update looping task")
sensor.cancel_update_level_task()
logging.info("stopping the server")
server.stop()
logging.info("done")
def run_server():
thing = make_thing()
flag = 0
server = WebThingServer(SingleThing(thing), port=8888)
try:
th = threading.Thread(target=run_neo, args=(thing, ))
th.deamon = True
th.start()
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
""" Start http server with REST api """
logging.info("controller: connect: %s %s" % (MAC, NAME))
controller.connect()
logging.info("controller: model: %s" % controller.getModelNumber())
thing = make_thing()
server = WebThingServer(SingleThing(thing), port=PORT)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
SensorHumidity = HumiditySensor()
server = WebThingServer(MultipleThings([SensorHumidity],
'Humidity Device'),
port=9999)
try:
logging.info('starting the sever')
server.start()
except KeyboardInterrupt:
logging.debug('canceling sesor update looping task')
SensorHumidity.cancel_update_level_task()
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server(name):
asyncio.set_event_loop(asyncio.new_event_loop())
# Create a thing that represents a opencv motion sensor
sensor = OpenCvMotionSensor()
server = WebThingServer(SingleThing(sensor), port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.debug('canceling the sensor update looping task')
sensor.cancel_update_level_task()
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
thing = VirtualRPiThing()
thing.name = 'Virtual PLAIN HTTP RPi Thing'
server = WebThingServer(things=SingleThing(thing), port=PLAIN_HTTP_RS_PORT)
try:
logging.info('Starting the server.')
logging.info('at PORT: ' + str(PLAIN_HTTP_RS_PORT))
server.start()
except KeyboardInterrupt:
logging.info('Stopping the server.')
server.stop()
logging.info('Done.')
def run_server():
tet = Tetrahedron()
tet.start()
thing = TetrahedronThing(tet)
server = WebThingServer(SingleThing(thing), port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.info('stopping the server')
server.stop()
logging.info('stopping tetrahedron')
tet.end()
tet.join()
logging.info('done')
def run_multiple_things_server():
hue_lamp = make_hue_lamp_thing()
blinds1 = make_blinds1_thing()
blinds2 = make_blinds2_thing()
things = [hue_lamp, blinds1, blinds2]
server = WebThingServer(MultipleThings(things, 'AI-MAS LAB'), port=8888)
try:
logger.info('starting the server')
server.start()
except KeyboardInterrupt:
logger.info('stopping the server')
server.stop()
logger.info('done')
def run_server():
# Create a thing that represents a dimmable light
light = ExampleDimmableLight().get_thing()
# Create a thing that represents a humidity sensor
sensor = FakeGpioHumiditySensor().get_thing()
# If adding more than one thing here, be sure to set the `name`
# parameter to some string, which will be broadcast via mDNS.
# In the single thing case, the thing's name will be broadcast.
server = WebThingServer([light, sensor],
name='LightAndTempDevice',
port=8888)
try:
server.start()
except KeyboardInterrupt:
server.stop()
def run_server():
t_sensor = TemperatureSensor('28-031997791364')
ht_sensor = HumidityTemperatureSensor(1, 0x40)
server = WebThingServer(MultipleThings([t_sensor, ht_sensor],
'Multi-sensor Device'),
port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.debug('canceling the sensor update looping task')
t_sensor.cancel_update_task()
ht_sensor.cancel_update_task()
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
# Create a thing that represents a humidity sensor
sensor = TemperatureHumiditySensor()
# If adding more than one thing, use MultipleThings() with a name.
# In the single thing case, the thing's name will be broadcast.
server = WebThingServer(SingleThing(sensor), port=8888)
try:
logging.info('starting the server')
server.start()
except KeyboardInterrupt:
logging.debug('canceling the sensor update looping task')
sensor.cancel_update_level_task()
logging.info('stopping the server')
server.stop()
logging.info('done')
def run_server():
webthings = generate_webthings("webthings-mapping.yaml")
things = [thing for thing, _ in webthings]
update_tasks = [
execute_async(task()) for _, task in webthings if task is not None
]
# TODO don't use docker hostname for production
server = WebThingServer(things=MultipleThings(things, name="home"),
port=8888,
hostname="host.docker.internal")
try:
logging.info("starting the server")
server.start()
except KeyboardInterrupt:
logging.info("stopping background tasks")
for task in update_tasks:
task.cancel()
logging.info("stopping the server")
server.stop()
