def all_protocols_servient():
"""Returns a Servient configured to use all available protocol bindings."""
servient = Servient(catalogue_port=None)
http_port = find_free_port()
http_server = HTTPServer(port=http_port)
servient.add_server(http_server)
ws_port = find_free_port()
ws_server = WebsocketServer(port=ws_port)
servient.add_server(ws_server)
if is_coap_supported():
from wotpy.protocols.coap.server import CoAPServer
coap_port = find_free_port()
coap_server = CoAPServer(port=coap_port)
servient.add_server(coap_server)
if is_mqtt_supported():
from wotpy.protocols.mqtt.server import MQTTServer
from tests.protocols.mqtt.broker import get_test_broker_url, is_test_broker_online
if is_test_broker_online():
mqtt_server = MQTTServer(broker_url=get_test_broker_url())
servient.add_server(mqtt_server)
@tornado.gen.coroutine
def start():
raise tornado.gen.Return((yield servient.start()))
wot = tornado.ioloop.IOLoop.current().run_sync(start)
td_dict = {
"id": uuid.uuid4().urn,
"title": uuid.uuid4().hex,
"properties": {
uuid.uuid4().hex: {
"observable": True,
"type": "string"
}
}
}
td = ThingDescription(td_dict)
exposed_thing = wot.produce(td.to_str())
exposed_thing.expose()
yield servient
@tornado.gen.coroutine
def shutdown():
yield servient.shutdown()
tornado.ioloop.IOLoop.current().run_sync(shutdown)
def main():
LOGGER.info("Creating COAP server on: {}".format(COAP_PORT))
coap_server = CoAPServer(port=COAP_PORT)
LOGGER.info("Creating servient with TD catalogue on: {}".format(CATALOGUE_PORT))
servient = Servient(catalogue_port=CATALOGUE_PORT)
servient.add_server(coap_server)
LOGGER.info("Starting servient")
wot = yield servient.start()
LOGGER.info("Exposing and configuring Thing")
exposed_thing = wot.produce(json.dumps(DESCRIPTION))
exposed_thing.expose()
def build_servient(parsed_args, clients_config=None):
"""Factory function to build a Servient with a set
of servers depending on the input arguments."""
logger = logging.getLogger()
logger.info("Creating servient with TD catalogue on: {}".format(
parsed_args.port_catalogue))
servient = Servient(catalogue_port=parsed_args.port_catalogue,
hostname=parsed_args.hostname,
clients_config=clients_config)
if parsed_args.port_ws > 0:
logger.info("Creating WebSocket server on: {}".format(
parsed_args.port_ws))
servient.add_server(WebsocketServer(port=parsed_args.port_ws))
if parsed_args.port_http > 0:
logger.info("Creating HTTP server on: {}".format(
parsed_args.port_http))
servient.add_server(HTTPServer(port=parsed_args.port_http))
if parsed_args.mqtt_broker:
try:
from wotpy.protocols.mqtt.server import MQTTServer
logger.info("Creating MQTT server on broker: {}".format(
parsed_args.mqtt_broker))
mqtt_server = MQTTServer(parsed_args.mqtt_broker,
servient_id=servient.hostname)
servient.add_server(mqtt_server)
logger.info("MQTT server created with ID: {}".format(
mqtt_server.servient_id))
except NotImplementedError as ex:
logger.warning(ex)
if parsed_args.port_coap > 0:
try:
from wotpy.protocols.coap.server import CoAPServer
logger.info("Creating CoAP server on: {}".format(
parsed_args.port_coap))
servient.add_server(CoAPServer(port=parsed_args.port_coap))
except NotImplementedError as ex:
logger.warning(ex)
return servient
def coap_server(request):
"""Builds a CoAPServer instance that contains an ExposedThing."""
from wotpy.protocols.coap.server import CoAPServer
exposed_thing = ExposedThing(servient=Servient(), thing=Thing(id=uuid.uuid4().urn))
exposed_thing.add_property(uuid.uuid4().hex, PropertyFragmentDict({
"type": "number",
"observable": True
}), value=Faker().pyint())
exposed_thing.add_property(uuid.uuid4().hex, PropertyFragmentDict({
"type": "string",
"observable": True
}), value=Faker().pyint())
exposed_thing.add_event(uuid.uuid4().hex, EventFragmentDict({
"type": "object"
}))
action_name = uuid.uuid4().hex
@tornado.gen.coroutine
def triple(parameters):
input_value = parameters.get("input")
raise tornado.gen.Return(input_value * 3)
exposed_thing.add_action(action_name, ActionFragmentDict({
"input": {"type": "number"},
"output": {"type": "number"}
}), triple)
port = find_free_port()
server = CoAPServer(port=port, **request.param)
server.add_exposed_thing(exposed_thing)
server.start()
@tornado.gen.coroutine
def start():
yield server.start()
tornado.ioloop.IOLoop.current().run_sync(start)
yield server
@tornado.gen.coroutine
def stop():
yield server.stop()
tornado.ioloop.IOLoop.current().run_sync(stop)
def test_start_stop():
"""The CoAP server can be started and stopped."""
coap_port = find_free_port()
coap_server = CoAPServer(port=coap_port)
ping_uri = "coap://127.0.0.1:{}/.well-known/core".format(coap_port)
@tornado.gen.coroutine
def ping():
try:
coap_client = yield aiocoap.Context.create_client_context()
request_msg = aiocoap.Message(code=aiocoap.Code.GET, uri=ping_uri)
response = yield tornado.gen.with_timeout(
datetime.timedelta(seconds=2),
coap_client.request(request_msg).response)
except Exception:
raise tornado.gen.Return(False)
raise tornado.gen.Return(response.code.is_successful())
@tornado.gen.coroutine
def test_coroutine():
assert not (yield ping())
yield coap_server.start()
assert (yield ping())
assert (yield ping())
for _ in range(5):
yield coap_server.stop()
assert not (yield ping())
yield coap_server.stop()
for _ in range(5):
yield coap_server.start()
assert (yield ping())
run_test_coroutine(test_coroutine)
def main():
global buf
LOGGER.info("Creating CoAP server on: {}".format(COAP_PORT))
coap_server = CoAPServer(port=COAP_PORT)
LOGGER.info("Creating servient with TD catalogue on: {}".format(CATALOGUE_PORT))
servient = Servient(catalogue_port=CATALOGUE_PORT)
servient.add_server(coap_server)
while len(buf) < int(sys.argv[1]):
r = random.random()
c = math.floor(r*256)
buf += format(c, 'x')
LOGGER.info("Starting servient")
wot = yield servient.start()
LOGGER.info("Exposing and configuring Thing")
exposed_thing = wot.produce(json.dumps(DESCRIPTION))
exposed_thing.set_property_read_handler("bench", bench_handler)
exposed_thing.expose()
def coap_servient():
"""Returns a Servient that exposes a CoAP server and one ExposedThing."""
from wotpy.protocols.coap.server import CoAPServer
coap_port = find_free_port()
the_coap_server = CoAPServer(port=coap_port)
servient = Servient(catalogue_port=None)
servient.add_server(the_coap_server)
@tornado.gen.coroutine
def start():
raise tornado.gen.Return((yield servient.start()))
wot = tornado.ioloop.IOLoop.current().run_sync(start)
property_name_01 = uuid.uuid4().hex
action_name_01 = uuid.uuid4().hex
event_name_01 = uuid.uuid4().hex
td_dict = {
"id": uuid.uuid4().urn,
"title": uuid.uuid4().hex,
"properties": {
property_name_01: {
"observable": True,
"type": "string"
}
},
"actions": {
action_name_01: {
"input": {
"type": "number"
},
"output": {
"type": "number"
},
}
},
"events": {
event_name_01: {
"type": "string"
}
},
}
td = ThingDescription(td_dict)
exposed_thing = wot.produce(td.to_str())
exposed_thing.expose()
@tornado.gen.coroutine
def action_handler(parameters):
input_value = parameters.get("input")
raise tornado.gen.Return(int(input_value) * 2)
exposed_thing.set_action_handler(action_name_01, action_handler)
yield servient
@tornado.gen.coroutine
def shutdown():
yield servient.shutdown()
tornado.ioloop.IOLoop.current().run_sync(shutdown)