def test_data_is_not_bytes(self):
client = Client()
client.connect_local(port=7050)
push = client.push()
with pytest.raises(TypeError):
push(u'msg')
def test_port_under_range(self):
client = Client()
with pytest.raises(ValueError):
client.connect_local(port=1023)
with pytest.raises(ValueError):
client.disconnect_local(port=1023)
with pytest.raises(ValueError):
Server(port=1023)
def get_listener(*channels: Channel):
# Connects the client to as many servers as desired
client = Client()
# connect to all ports
ports = sum([channel.ports for channel in channels], [])
for port in ports:
client.connect_local(port=port)
# Assigns an iterable to wait for incoming messages with the topics
return get_mapped_stream(client, *channels)
def test_subscribed_topics_are_not_bytes(self):
client = Client()
client.connect_local(port=7099)
client.sub(topics=[b'topic1'])
with pytest.raises(TypeError):
client.sub(topics=[u'topic1'])
with pytest.raises(TypeError):
client.sub(topics=[b'topic1', u'topic2'])
def test_there_was_no_connection_to_disconnect(self):
client = Client()
client.connect_local(port=1024)
with pytest.raises(ValueError):
client.disconnect_local(port=1025)
client.disconnect_local(port=1024)
with pytest.raises(ValueError):
client.disconnect_local(port=1024)
def test_connection_after_pattern_was_established(self):
client = Client()
listen_for_push = client.pull()
client.connect_local(port=1024)
with pytest.raises(ValueError):
client.connect_local(port=1024)
client.disconnect_local(port=1024)
with pytest.raises(ValueError):
client.disconnect_local(port=1024)
def test_disconnect_all(self):
client = Client()
client.connect_local(port=1024)
client.connect_local(port=1025)
client.connect_local(port=1026)
client.connect_local(port=1027)
client.disconnect_all()
client.connect_local(port=1024)
client.connect_local(port=1025)
client.connect_local(port=1026)
client.connect_local(port=1027)
def test_port_on_range(self):
client = Client()
client.connect_local(port=1024)
client.disconnect_local(port=1024)
client.connect_local(port=7000)
client.disconnect_local(port=7000)
client.connect_local(port=65535)
client.disconnect_local(port=65535)
def test_connection_already_exist(self):
client = Client()
client.connect_local(port=1024)
with pytest.raises(ValueError):
client.connect_local(port=1024)
client.disconnect_local(port=1024)
client.connect_local(port=1024)
def test_pair_client_cannot_connect_more_than_once(self):
client = Client()
client.connect_local(port=7200)
client.connect_local(port=7201)
with pytest.raises(RuntimeError):
client.pair()
client = Client()
client.connect_local(port=7200)
client.pair()
with pytest.raises(RuntimeError):
client.connect_local(port=7201)
def listen_for_pub_with_embedded_topic():
client = Client()
client.connect_local(port=7894)
return client.sub(topics=[b'sh'])
def push():
client = Client()
client.connect_local(port=7891)
return client.push()
def listen_for_pub_with_embedded_topic():
client = Client()
client.connect_local(port=7894)
return client.sub(topics=[b'sh'])
def listen_for_pub_with_empty_topic():
client = Client()
client.connect_local(port=7896)
return client.sub()
from zeroless import (Client, Server)
import json
from aura.managers import SemanticManager as graph
from aura.managers import StorageManager as db
from aura.managers import helpers
zmq_device = Client()
zmq_device.connect_local(port=helpers.ports['device_manager'])
push_to_device = zmq_device.push()
def create_condition(condition):
print("create_condition")
# TaskManager -> StorageManager
db.store('conditions', condition)
def update_condition():
# TaskManager -> StorageManager
print("update_condition")
def remove_condition():
# TaskManager -> StorageManager
print("remove_condition")
def send_command(device, command):
# TaskManager -> DeviceManager
print("send_command")
import logging
from zeroless import (Client, log)
# Setup console logging
consoleHandler = logging.StreamHandler()
log.setLevel(logging.DEBUG)
log.addHandler(consoleHandler)
# Connects the client to as many servers as desired
client = Client()
client.connect_local(port=12345)
# Initiate a push client
# And assigns a callable to push messages
push = client.push()
for msg in [b"Msg1", b"Msg2", b"Msg3"]:
push(msg)
def __build_watcher(self):
client = Client()
client.connect_local(port=self.PORT)
return client
from aura.managers import StorageManager as db
from aura.managers import SemanticManager as graph
from zeroless import (Client, Server)
from aura.managers import helpers
import json
zmq_broker = Client()
zmq_broker.connect_local(port=helpers.ports['broker'])
push_to_broker = zmq_broker.push()
zmq_task = Client()
zmq_task.connect_local(port=helpers.ports['task_manager'])
push_to_task = zmq_task.push()
def verify(collection, obj_id):
return (db.get(collection, obj_id) != None)
def create(collection, obj):
if not verify(collection, obj['@id']):
graph.parse(json.dumps(obj))
db.store(collection, obj)
else:
print("Already have " + str(obj['@id']) + " in database.")
def notify_unknown_object(obj_type, obj_id):
obj = {}
obj['id'] = obj_id
obj['type'] = obj_type
push_to_broker(json.dumps(obj).encode())
def send_command(device, command):
from zeroless import (Client, Server)
import json
from aura.managers import SemanticManager as graph
from aura.managers import StorageManager as db
from aura.managers import helpers
zmq_device = Client()
zmq_device.connect_local(port=helpers.ports['device_manager'])
push_to_device = zmq_device.push()
def create_condition(condition):
print("create_condition")
# TaskManager -> StorageManager
db.store('conditions', condition)
def update_condition():
# TaskManager -> StorageManager
print("update_condition")
def remove_condition():
# TaskManager -> StorageManager
print("remove_condition")
def send_command(device, command):
# TaskManager -> DeviceManager
print("send_command")
from zeroless import Client
# Connects the client to as many servers as desired
client = Client()
client.connect_local(port=12345)
# Initiate a subscriber client
# Assigns an iterable to wait for incoming messages with any topic
listen_for_pub = client.sub()
for topic, id, msg in listen_for_pub:
print(topic, ' - ', id, ' - ', msg)
def listen_for_pub():
client = Client()
client.connect_local(port=7893)
return client.sub()
def request_gens():
client = Client()
client.connect_local(port=7892)
return client.request()
from aura.managers import StorageManager as db
from aura.managers import SemanticManager as graph
from zeroless import Client, Server
from aura.managers import helpers
import json
zmq_broker = Client()
zmq_broker.connect_local(port=helpers.ports["broker"])
push_to_broker = zmq_broker.push()
zmq_task = Client()
zmq_task.connect_local(port=helpers.ports["task_manager"])
push_to_task = zmq_task.push()
def verify(collection, obj_id):
return db.get(collection, obj_id) != None
def create(collection, obj):
if not verify(collection, obj["@id"]):
graph.parse(json.dumps(obj))
db.store(collection, obj)
else:
print("Already have " + str(obj["@id"]) + " in database.")
def notify_unknown_object(obj_type, obj_id):
obj = {}
obj["id"] = obj_id
obj["type"] = obj_type
def pair():
client = Client()
client.connect_local(port=7890)
send, _ = client.pair()
return send
def listen_for_pub_with_empty_topic():
client = Client()
client.connect_local(port=7896)
return client.sub()
def listen_for_pub():
client = Client()
client.connect_local(port=7893)
return client.sub()
def push():
client = Client()
client.connect_local(port=7891)
return client.push()
def request_gens():
client = Client()
client.connect_local(port=7892)
return client.request()
