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 fetch(cls, url, timeout_secs=None):
"""Accepts an url argument and returns a Future
that resolves with a Thing Description string."""
timeout_secs = timeout_secs or DEFAULT_FETCH_TIMEOUT_SECS
http_client = AsyncHTTPClient()
http_request = HTTPRequest(url, request_timeout=timeout_secs)
http_response = yield http_client.fetch(http_request)
td_doc = json.loads(http_response.body)
td = ThingDescription(td_doc)
raise tornado.gen.Return(td.to_str())
def websocket_servient():
"""Returns a Servient that exposes a Websockets server and one ExposedThing."""
ws_port = find_free_port()
ws_server = WebsocketServer(port=ws_port)
servient = Servient(catalogue_port=None)
servient.add_server(ws_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
property_name_02 = uuid.uuid4().hex
action_name_01 = uuid.uuid4().hex
event_name_01 = uuid.uuid4().hex
td_dict = {
"id": uuid.uuid4().urn,
"name": uuid.uuid4().hex,
"properties": {
property_name_01: {
"observable": True,
"type": "string"
},
property_name_02: {
"observable": True,
"type": "string"
}
},
"actions": {
action_name_01: {
"input": {
"type": "object"
},
"output": {
"type": "string"
},
}
},
"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")
arg_b = input_value.get("arg_b") or uuid.uuid4().hex
raise tornado.gen.Return(input_value.get("arg_a") + arg_b)
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)
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)
def test_consumed_client_protocols_preference():
"""The Servient selects different protocol clients to consume Things
depending on the protocol choices displayed on the Thing Description."""
servient = Servient(catalogue_port=None)
@tornado.gen.coroutine
def servient_start():
raise tornado.gen.Return((yield servient.start()))
@tornado.gen.coroutine
def servient_shutdown():
yield servient.shutdown()
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)
client_server_map = {
HTTPClient: http_server,
WebsocketClient: ws_server
}
wot = tornado.ioloop.IOLoop.current().run_sync(servient_start)
prop_name = uuid.uuid4().hex
td_produce = ThingDescription({
"id": uuid.uuid4().urn,
"name": uuid.uuid4().hex,
"properties": {
prop_name: {
"observable": True,
"type": "string"
}
}
})
exposed_thing = wot.produce(td_produce.to_str())
exposed_thing.expose()
td_forms_all = ThingDescription.from_thing(exposed_thing.thing)
client_01 = servient.select_client(td_forms_all, prop_name)
client_01_class = client_01.__class__
assert client_01_class in six.iterkeys(client_server_map)
tornado.ioloop.IOLoop.current().run_sync(servient_shutdown)
servient.remove_server(client_server_map[client_01_class].protocol)
tornado.ioloop.IOLoop.current().run_sync(servient_start)
td_forms_removed = ThingDescription.from_thing(exposed_thing.thing)
client_02 = servient.select_client(td_forms_removed, prop_name)
client_02_class = client_02.__class__
assert client_02_class != client_01_class
assert client_02_class in six.iterkeys(client_server_map)
tornado.ioloop.IOLoop.current().run_sync(servient_shutdown)