def test_raw_mode(self):
print_header("TEST_RAW_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, mode='raw', max_length=10)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
assert self.factory.pending_connections
_, self.conn = self.factory.accept()
assert not self.factory.pending_connections
print_header("Test_Data_Received")
####################################################################
assert self.conn.data_available is False
yield threads.defer_to_thread(self.client_socket.send, "abcdefghijklmnopqrstuvxyz123456789")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "abcdefghij"
assert self.conn.data_get() == "klmnopqrst"
assert self.conn.data_get() == "uvxyz12345"
assert self.conn.data_get() == "6789"
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def test_default_line_mode(self):
print_header("TEST_DEFAULT_LINE_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
assert not self.factory.connections
assert not self.factory.pending_connections
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
assert self.factory.pending_connections
_, self.conn = self.factory.accept()
####################################################################
####################################################################
print_header("Test_Line_Received")
####################################################################
assert self.conn.data_available is False
yield threads.defer_to_thread(self.client_socket.send, "sending string \r\n")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "sending string "
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def test_service_discovery_ignore(self, monkeypatch):
q = Queue.Queue()
def callback(addrs):
_log.debug("Callback discovery got %s" % addrs)
q.put(addrs)
iface = "0.0.0.0"
network = "test_super_network"
ip = "192.168.199.199"
port = 80
_sd = SSDPServiceDiscovery(iface)
server, client = _sd.start()
_sd.register_service(network, ip, port)
yield threads.defer_to_thread(time.sleep, 0.2)
_sd.start_search(callback, stop=True)
try:
services = yield threads.defer_to_thread(q.get, timeout=4)
assert False
except:
pass
_sd.stop()
def test_late_start(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
def started_cb(started):
self.q.put(started)
self.storage = storage.Storage()
self.storage.set("test", "1", 1, None)
self.storage.set("test", "2", 2, None)
self.storage.set("test", "3", 3, None)
assert "test1" in self.storage.localstore
assert "test2" in self.storage.localstore
assert "test3" in self.storage.localstore
yield threads.defer_to_thread(self.storage.start, CalvinCB(started_cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value
assert "test1" not in self.storage.localstore
assert "test2" not in self.storage.localstore
assert "test3" not in self.storage.localstore
yield threads.defer_to_thread(self.storage.get, "test", "3", CalvinCB(func=cb))
value = self.q.get(timeout=0.2)
assert value["value"] == 3
yield threads.defer_to_thread(self.storage.stop)
def test_raw_mode(self):
print_header("TEST_RAW_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, mode='raw', max_length=10)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
assert self.factory.pending_connections
_, self.conn = self.factory.accept()
assert not self.factory.pending_connections
print_header("Test_Data_Received")
####################################################################
assert self.conn.data_available is False
yield threads.defer_to_thread(self.client_socket.send, "abcdefghijklmnopqrstuvxyz123456789")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "abcdefghij"
assert self.conn.data_get() == "klmnopqrst"
assert self.conn.data_get() == "uvxyz12345"
assert self.conn.data_get() == "6789"
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def test_many_clients(self):
print_header("TEST_MANY_CLIENTS")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(
scheduler.trigger_loop, mode='raw', max_length=10)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
clients = []
for i in range(100):
clients.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
for c in clients:
yield threads.defer_to_thread(c.connect, ('localhost', 8123))
yield threads.defer_to_thread(hundred_connection_made, self.factory)
assert len(self.factory.pending_connections) == 100
for i in range(100):
_, self.conn = self.factory.accept()
assert not self.factory.pending_connections
def test_many_clients(self):
print_header("TEST_MANY_CLIENTS")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, mode='raw', max_length=10)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
clients = []
for i in range(100):
clients.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
for c in clients:
yield threads.defer_to_thread(c.connect, ('localhost', 8123))
yield threads.defer_to_thread(hundred_connection_made, self.factory)
assert len(self.factory.pending_connections) == 100
for i in range(100):
_, self.conn = self.factory.accept()
assert not self.factory.pending_connections
def test_service_discovery_ignore(self, monkeypatch):
q = Queue.Queue()
def callback(addrs):
_log.debug("Callback discovery got %s" % addrs)
q.put(addrs)
iface = "0.0.0.0"
network = "test_super_network"
ip = "192.168.199.199"
port = 80
_sd = SSDPServiceDiscovery(iface)
server, client = _sd.start()
_sd.register_service(network, ip, port)
yield threads.defer_to_thread(time.sleep, .2)
_sd.start_search(callback, stop=True)
try:
services = yield threads.defer_to_thread(q.get, timeout=4)
assert False
except:
pass
_sd.stop()
def test_node_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
yield threads.defer_to_thread(time.sleep, 2)
node = TestNode("127.0.0.1:5000")
yield threads.defer_to_thread(self.storage.add_node, node, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_node, node.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] == {'uri': node.uri}
yield threads.defer_to_thread(self.storage.delete_node, node.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_node, node.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is None
def test_application_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
yield threads.defer_to_thread(time.sleep, 2)
application = appmanager.Application(calvinuuid.uuid(
'APP'), "test_app", [calvinuuid.uuid('ACTOR'), calvinuuid.uuid('ACTOR')])
yield threads.defer_to_thread(self.storage.add_application, application, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_application, application.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"]["name"] == application.name
yield threads.defer_to_thread(self.storage.delete_application, application.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_application, application.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is None
def test_actor_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
yield threads.defer_to_thread(time.sleep, 2)
port1 = TestPort("out", "out")
port2 = TestPort("in", "in", )
port1.peers = [("local", port2.id)]
port2.peer = ("local", port1.id)
actor = TestActor("actor1", "type1", {}, {port1.name: port1})
yield threads.defer_to_thread(self.storage.add_actor, actor, calvinuuid.uuid("NODE"), cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_actor, actor.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"]["name"] == actor.name
yield threads.defer_to_thread(self.storage.delete_actor, actor.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_actor, actor.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is None
def test_actor_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
yield threads.defer_to_thread(time.sleep, 2)
port1 = TestPort("out", "out")
port2 = TestPort("in", "in", )
port1.peers = [("local", port2.id)]
port2.peers = [("local", port1.id)]
actor = TestActor("actor1", "type1", {}, {port1.name: port1})
yield threads.defer_to_thread(self.storage.add_actor, actor, calvinuuid.uuid("NODE"), cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_actor, actor.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"]["name"] == actor.name
yield threads.defer_to_thread(self.storage.delete_actor, actor.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_actor, actor.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is None
def test_node_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
yield threads.defer_to_thread(time.sleep, 2)
node = TestNode("127.0.0.1:5000")
yield threads.defer_to_thread(self.storage.add_node, node, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_node, node.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] == {'uri': node.uri}
yield threads.defer_to_thread(self.storage.delete_node, node, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_node, node.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is None
def test_application_functions(self):
self.q = Queue.Queue()
def cb(key, value):
self.q.put({"key": key, "value": value})
yield threads.defer_to_thread(time.sleep, 2)
application = appmanager.Application(calvinuuid.uuid(
'APP'), "test_app", [calvinuuid.uuid('ACTOR'), calvinuuid.uuid('ACTOR')])
yield threads.defer_to_thread(self.storage.add_application, application, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_application, application.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"]["name"] == application.name
yield threads.defer_to_thread(self.storage.delete_application, application.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is True
yield threads.defer_to_thread(self.storage.get_application, application.id, cb=CalvinCB(cb))
yield threads.defer_to_thread(time.sleep, 2)
value = self.q.get(timeout=0.2)
assert value["value"] is None
def atest_dht_single(self, monkeypatch):
from twisted.python import log
log.startLogging(sys.stdout)
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
defer.setDebugging(True)
def server_started(a, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([a, args])
try:
a = AutoDHTServer()
a.start(iface, cb=CalvinCB(server_started, "1"))
# Wait for start
assert q.get(timeout=2) == ["1", self._sucess_start]
assert a.set(key="APA", value="banan").wait() == True
assert a.get(key="APA").wait() == "banan"
except Exception as e:
_log.exception("Failed")
pytest.fail(traceback.format_exc())
finally:
if a:
yield threads.defer_to_thread(a.stop)
def atest_dht_single(self, monkeypatch):
from twisted.python import log
log.startLogging(sys.stdout)
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
defer.setDebugging(True)
def server_started(a, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([a, args])
try:
a = AutoDHTServer()
a.start(iface, cb=CalvinCB(server_started, "1"))
# Wait for start
assert q.get(timeout=2) == ["1", self._sucess_start]
assert a.set(key="APA", value="banan").wait() == True
assert a.get(key="APA").wait() == "banan"
except Exception as e:
_log.exception("Failed")
pytest.fail(traceback.format_exc())
finally:
if a:
yield threads.defer_to_thread(a.stop)
def test_args_in_line_mode(self):
print_header("TEST_ARGS_IN_LINE_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, delimiter='end', max_length=3)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
_, self.conn = self.factory.accept()
print_header("Test_Short_Line_Received")
####################################################################
yield threads.defer_to_thread(self.client_socket.send, "123end")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "123"
print_header("Test_Long_Line_Received")
####################################################################
yield threads.defer_to_thread(self.client_socket.send, "1234end")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "1234"
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def test_args_in_line_mode(self):
print_header("TEST_ARGS_IN_LINE_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(scheduler.trigger_loop, delimiter='end', max_length=3)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
yield threads.defer_to_thread(self.client_socket.connect, ('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
_, self.conn = self.factory.accept()
print_header("Test_Short_Line_Received")
####################################################################
yield threads.defer_to_thread(self.client_socket.send, "123end")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "123"
print_header("Test_Long_Line_Received")
####################################################################
yield threads.defer_to_thread(self.client_socket.send, "1234end")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "1234"
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def wait_for(function, condition=lambda x: x(), timeout=1):
for a in range(int(timeout / .1)):
if condition(function):
break
yield threads.defer_to_thread(time.sleep, .1)
if not condition(function):
print("Timeout while waiting for function %s with condition %s" %
(function, condition))
def _post_update(self, text):
if not self._in_progress:
self._in_progress = threads.defer_to_thread(self._api.update_status, status=text)
self._in_progress.addCallback(self.cb_post_update)
self._in_progress.addErrback(self.cb_error)
self._time_last_message = datetime.now()
self._previous_message = text
else:
self.next_message = text
def test_service_discovery_filter(self, monkeypatch):
q = Queue.Queue()
def callback_filter(addrs):
_log.debug("Callback filter got %s" % addrs)
q.put(addrs)
iface = "0.0.0.0"
network = "test_super_network"
ip = "192.168.199.200"
port = 80
_sd = SSDPServiceDiscovery(iface, ignore_self=False)
_sd.start()
_sd.register_service("APA", ip, port)
_sd.set_client_filter("BANAN")
yield threads.defer_to_thread(time.sleep, 0.2)
_sd.start_search(callback_filter, stop=True)
try:
services = yield threads.defer_to_thread(q.get, timeout=0.5)
assert False
except:
pass
_sd.stop_search()
def callback_filter_get(addrs):
_log.debug("Callback filter got %s" % addrs)
q.put(addrs)
_sd.set_client_filter("APA")
_sd.start_search(callback_filter_get, stop=True)
try:
services = yield threads.defer_to_thread(q.get, timeout=4)
assert ("192.168.199.200", 80) in services
except:
traceback.print_exc()
assert False
_sd.stop()
def test_service_discovery_filter(self, monkeypatch):
q = Queue.Queue()
def callback_filter(addrs):
_log.debug("Callback filter got %s" % addrs)
q.put(addrs)
iface = "0.0.0.0"
network = "test_super_network"
ip = "192.168.199.200"
port = 80
_sd = SSDPServiceDiscovery(iface, ignore_self=False)
_sd.start()
_sd.register_service("APA", ip, port)
_sd.set_client_filter("BANAN")
yield threads.defer_to_thread(time.sleep, .2)
_sd.start_search(callback_filter, stop=True)
try:
services = yield threads.defer_to_thread(q.get, timeout=.5)
assert False
except:
pass
_sd.stop_search()
def callback_filter_get(addrs):
_log.debug("Callback filter got %s" % addrs)
q.put(addrs)
_sd.set_client_filter("APA")
_sd.start_search(callback_filter_get, stop=True)
try:
services = yield threads.defer_to_thread(q.get, timeout=4)
assert ("192.168.199.200", 80) in services
except:
traceback.print_exc()
assert False
_sd.stop()
def show(self, text, textcolor, bgcolor):
if not textcolor:
textcolor = (0xff,0xff,0xff)
if not bgcolor:
bgcolor = (0,0,0)
if self.defer is None:
self.sense.set_rotation(90, False)
self.defer = threads.defer_to_thread(self.sense.show_message, text, text_colour=textcolor, back_colour=bgcolor)
self.defer.addCallback(self.cb_show_text)
self.defer.addErrback(self.cb_show_text)
def request_image(self):
"""
The request will be handled in a separate thread,
a handle is returned which can be used to receive
the image when available.
"""
self._req_counter += 1
handle = self._req_counter
request = {"handle": handle, "image": None}
self._requests.append(request)
defered = threads.defer_to_thread(self._request_image, handle)
defered.addErrback(self._cb_error)
return handle
def show(self, text, textcolor, bgcolor):
if not textcolor:
textcolor = (0xff, 0xff, 0xff)
if not bgcolor:
bgcolor = (0, 0, 0)
if self.defer is None:
self.sense.set_rotation(90, False)
self.defer = threads.defer_to_thread(self.sense.show_message,
text,
text_colour=textcolor,
back_colour=bgcolor)
self.defer.addCallback(self.cb_show_text)
self.defer.addErrback(self.cb_show_text)
def test_default_line_mode(self):
print_header("TEST_DEFAULT_LINE_MODE")
print_header("Setup")
scheduler = Scheduler_stub()
self.factory = server_connection.ServerProtocolFactory(
scheduler.trigger_loop)
self.factory.start('localhost', 8123)
self.conn = None
self.client_socket = None
print_header("Test_Connection")
##################################################################
self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
assert not self.factory.connections
assert not self.factory.pending_connections
yield threads.defer_to_thread(self.client_socket.connect,
('localhost', 8123))
yield threads.defer_to_thread(connection_made, self.factory)
assert self.factory.pending_connections
_, self.conn = self.factory.accept()
####################################################################
####################################################################
print_header("Test_Line_Received")
####################################################################
assert self.conn.data_available is False
yield threads.defer_to_thread(self.client_socket.send,
"sending string \r\n")
yield threads.defer_to_thread(data_available, self.conn)
assert self.conn.data_get() == "sending string "
print_header("Teardown")
self.factory.stop()
yield threads.defer_to_thread(no_more_connections, self.factory)
def connect(self, notifier):
self._client = opcua.Client(self._endpoint)
d = threads.defer_to_thread(self._client.connect)
d.addCallback(notifier)
d.addErrback(self._retry_connect, notifier)
def _setup_subscription(self, subscription):
self.subscription = subscription
d = threads.defer_to_thread(self._collect_variables)
d.addCallback(self._subscribe_changes)
d.addErrback(self._subscribe_error)
def _subscribe_changes(self, variables):
d = threads.defer_to_thread(self._subscribe_variables, variables)
d.addErrback(self._subscribe_error)
def test_callback(self, monkeypatch):
from twisted.python import log
log.startLogging(sys.stdout)
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa,args])
def set_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
def get_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
try:
amount_of_servers = 3
a = AutoDHTServer()
a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
servers = []
while servers.__len__() < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get, timeout=2)
except Queue.Empty:
_log.debug("Queue empty!")
break
if server not in servers:
servers.append(server)
_log.debug("Servers added: {}.".format(servers))
else:
_log.debug("Server: {} already started.".format(server))
for server in range(1, amount_of_servers + 1):
assert [str(server), self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
yield threads.defer_to_thread(q.queue.clear)
a.set(key="APA", value="banan", cb=CalvinCB(set_cb))
set_value = yield threads.defer_to_thread(q.get, timeout=2)
assert ("APA", True) == set_value
yield threads.defer_to_thread(time.sleep, 1)
yield threads.defer_to_thread(q.queue.clear)
a.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
yield threads.defer_to_thread(time.sleep, 1)
yield threads.defer_to_thread(q.queue.clear)
b.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
except Exception as e:
_log.exception("Failed")
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa,args])
try:
amount_of_servers = 1
# Twisted is using 20 threads so having > 20 server
# causes threadlocks really easily.
servers = []
callbacks = []
for servno in range(0, amount_of_servers):
a = evilAutoDHTServer()
servers.append(a)
callback = CalvinCB(server_started, str(servno))
servers[servno].start(iface, network="Niklas", cb=callback, type="poison", name="evil")
# servers[servno].start(iface, network="Hej", cb=callback, type="eclipse", name="evil")
# servers[servno].start(iface, network="Hej", cb=callback, type="sybil")
# servers[servno].start(iface, network="Hej", cb=callback, type="insert")
callbacks.append(callback)
print("Starting {}".format(servers[servno].dht_server.port.getHost().port))
# Wait for start
started = []
while len(started) < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get)
except Queue.Empty:
_log.debug("Queue empty!")
#raise
if server not in started:
started.append(server)
_log.debug("DHT Servers added: {}".format(started))
callbacks[int(server[0][0])].func = lambda *args, **kvargs:None
else:
_log.debug("Server: {} already started." \
" {} out of {}".format(started,
len(started),
amount_of_servers))
_log.debug("All {} out of {} started".format(started,
len(started),
amount_of_servers))
for servno in range(0, amount_of_servers):
assert [str(servno), self._sucess_start] in started
yield threads.defer_to_thread(q.queue.clear)
yield threads.defer_to_thread(time.sleep, 15)
evilPort = servers[0].dht_server.port.getHost().port
drawNetworkState("start_graph.png", servers, amount_of_servers)
servers[0].dht_server.kserver.protocol.turn_evil(evilPort)
print("Node with port {} turned evil".format(servers[servno].dht_server.port.getHost().port))
yield threads.defer_to_thread(time.sleep, 12)
# assert get_value[0] == "banan"
# assert get_value[1] == "bambu"
# assert get_value[2] == "morot"
yield threads.defer_to_thread(time.sleep, 5)
print("Attacking node exiting")
except AssertionError as e:
print("Server {} with port {} got wrong value".format(servno, servers[servno].dht_server.port.getHost().port))
pytest.fail(traceback.format_exc())
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
for server in servers:
name_dir = os.path.join(_cert_conf["CA_default"]["runtimes_dir"], "evil")
shutil.rmtree(os.path.join(name_dir, "others"), ignore_errors=True)
os.mkdir(os.path.join(name_dir, "others"))
server.stop()
yield threads.defer_to_thread(time.sleep, 5)
def show_text(self, text):
if self.defer is None:
self.sense.set_rotation(90, False)
self.defer = threads.defer_to_thread(self.sense.show_message, text)
self.defer.addCallback(self.cb_show_text)
self.defer.addErrback(self.cb_show_text)
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
try:
a = AutoDHTServer()
d = a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
d = b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
# Wait for start
servers = []
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
assert ["1", self._sucess_start] in servers
assert ["2", self._sucess_start] in servers
assert ["3", self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
set_def = a.set(key="APA", value="banan")
set_value = yield threads.defer_to_thread(set_def.wait)
assert set_value
get_def = a.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
yield threads.defer_to_thread(time.sleep, .5)
get_def = b.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
def teardown_class(self):
yield threads.defer_to_thread(self.storage.stop)
yield threads.defer_to_thread(time.sleep, 2)
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa,args])
try:
amount_of_servers = 3
a = AutoDHTServer()
d = a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
d = b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
# Wait for start
servers = []
while servers.__len__() < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get, timeout=2)
except Queue.Empty:
_log.debug("Queue empty!")
break
if server not in servers:
servers.append(server)
_log.debug("DHT Servers added: {}".format(servers))
else:
_log.debug("Server: {} already started.".format(server))
for server in range(1, amount_of_servers + 1):
assert [str(server), self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
set_def = a.set(key="APA", value="banan")
set_value = yield threads.defer_to_thread(set_def.wait)
assert set_value
get_def = a.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
yield threads.defer_to_thread(time.sleep, .5)
get_def = b.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
def show_text(self, text):
if self.defer is None:
self.clear()
self.defer = threads.defer_to_thread(self.lcd.message, text)
self.defer.addCallback(self.cb_show_text)
self.defer.addErrback(self.cb_show_text)
def setup_class(self):
self.storage = storage.Storage()
yield threads.defer_to_thread(self.storage.start)
yield threads.defer_to_thread(time.sleep, 2)
def show_text(self, text):
if self.defer is None:
self.clear()
self.defer = threads.defer_to_thread(self.lcd.message, text)
self.defer.addCallback(self.cb_show_text)
self.defer.addErrback(self.cb_show_text)
def setup_class(self):
self.storage = storage.Storage(DummyNode())
self.storage.start()
yield threads.defer_to_thread(time.sleep, .01)
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
try:
amount_of_servers = 3
a = AutoDHTServer()
d = a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
d = b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
# Wait for start
servers = []
while servers.__len__() < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get, timeout=2)
except Queue.Empty:
_log.debug("Queue empty!")
break
if server not in servers:
servers.append(server)
_log.debug("DHT Servers added: {}".format(servers))
else:
_log.debug("Server: {} already started.".format(server))
for server in range(1, amount_of_servers + 1):
assert [str(server), self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
set_def = a.set(key="APA", value="banan")
set_value = yield threads.defer_to_thread(set_def.wait)
assert set_value
get_def = a.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
yield threads.defer_to_thread(time.sleep, 0.5)
get_def = b.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
def setup_class(self):
self.storage = storage.Storage()
yield threads.defer_to_thread(self.storage.start)
yield threads.defer_to_thread(time.sleep, 2)
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
try:
amount_of_servers = 5
# Twisted is using 20 threads so having > 20 server
# causes threadlocks really easily.
servers = []
callbacks = []
for servno in range(0, amount_of_servers):
uri = "http://{}:500{}".format(ip_addr, servno)
control_uri = "http://{}:502{}".format(ip_addr, servno)
rt_cred = runtime_credentials.RuntimeCredentials(
name=name + str(servno),
domain=domain,
security_dir=testdir)
node_id = rt_cred.node_id
a = AutoDHTServer(node_id, control_uri, rt_cred)
servers.append(a)
callback = CalvinCB(server_started, str(servno))
servers[servno].start(iface,
network="Niklas",
cb=callback,
name=name + "{}".format(servno))
callbacks.append(callback)
# Wait for start
started = []
while len(started) < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get)
except Queue.Empty:
_log.debug("Queue empty!")
#raise
if server not in started:
started.append(server)
_log.debug("DHT Servers added: {}".format(started))
callbacks[int(
server[0][0])].func = lambda *args, **kvargs: None
else:
_log.debug("Server: {} already started." \
" {} out of {}".format(started,
len(started),
amount_of_servers))
_log.debug("All {} out of {} started".format(
started, len(started), amount_of_servers))
for servno in range(0, amount_of_servers):
assert [str(servno), self._sucess_start] in started
yield threads.defer_to_thread(q.queue.clear)
yield threads.defer_to_thread(time.sleep, 8)
key = "APA"
value = "banan"
set_def = servers[0].set(key=key, value=value)
set_value = yield threads.defer_to_thread(set_def.wait, 10)
assert set_value
print("Node with port {} posted key={}, value={}".format(
servers[0].dht_server.port.getHost().port, key, value))
get_def = servers[0].get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait, 10)
assert get_value == "banan"
print("Node with port {} confirmed key={}, value={} was reachable".
format(servers[0].dht_server.port.getHost().port, key,
value))
drawNetworkState("2nice_graph.png", servers, amount_of_servers)
yield threads.defer_to_thread(time.sleep, 7)
drawNetworkState("2middle_graph.png", servers, amount_of_servers)
yield threads.defer_to_thread(time.sleep, 7)
drawNetworkState("2end_graph.png", servers, amount_of_servers)
get_def = servers[0].get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait, 10)
assert get_value == "banan"
print("Node with port {} got right value: {}".format(
servers[0].dht_server.port.getHost().port, get_value))
for i in range(0, amount_of_servers):
name_dir = certificate.get_own_credentials_path(
name + "{}".format(i), security_dir=testdir)
filenames = os.listdir(os.path.join(name_dir, "others"))
print("Node with port {} has {} certificates in store".format(
servers[i].dht_server.port.getHost().port, len(filenames)))
except AssertionError as e:
print("Node with port {} got wrong value: {}, should have been {}".
format(servers[0].dht_server.port.getHost().port, get_value,
value))
pytest.fail(traceback.format_exc())
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
yield threads.defer_to_thread(time.sleep, 10)
i = 0
for server in servers:
name_dir = certificate.get_own_credentials_path(
name + "{}".format(i), security_dir=testdir)
shutil.rmtree(os.path.join(name_dir, "others"),
ignore_errors=True)
os.mkdir(os.path.join(name_dir, "others"))
i += 1
server.stop()
def teardown_class(self):
yield threads.defer_to_thread(self.storage.stop)
yield threads.defer_to_thread(time.sleep, 2)
def notifier(dummy=None):
d = threads.defer_to_thread(self._client.create_subscription, self.INTERVAL, self.SubscriptionHandler(handler, self._watchdog))
d.addCallback(self._setup_subscription)
d.addErrback(self._subscribe_error)
def test_callback(self, monkeypatch):
from twisted.python import log
log.startLogging(sys.stdout)
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
def set_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
def get_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
try:
a = AutoDHTServer()
a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
# Wait for start
servers = []
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
assert ["1", self._sucess_start] in servers
assert ["2", self._sucess_start] in servers
assert ["3", self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
a.set(key="APA", value="banan", cb=CalvinCB(set_cb))
set_value = yield threads.defer_to_thread(q.get, timeout=2)
assert ("APA", True) == set_value
yield threads.defer_to_thread(time.sleep, 1)
a.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
yield threads.defer_to_thread(time.sleep, 1)
b.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
except Exception as e:
_log.exception("Failed")
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
def test_callback(self, monkeypatch):
from twisted.python import log
log.startLogging(sys.stdout)
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
def set_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
def get_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
try:
amount_of_servers = 3
a = AutoDHTServer()
a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
servers = []
while servers.__len__() < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get, timeout=2)
except Queue.Empty:
_log.debug("Queue empty!")
break
if server not in servers:
servers.append(server)
_log.debug("Servers added: {}.".format(servers))
else:
_log.debug("Server: {} already started.".format(server))
for server in range(1, amount_of_servers + 1):
assert [str(server), self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
yield threads.defer_to_thread(q.queue.clear)
a.set(key="APA", value="banan", cb=CalvinCB(set_cb))
set_value = yield threads.defer_to_thread(q.get, timeout=2)
assert ("APA", True) == set_value
yield threads.defer_to_thread(time.sleep, 1)
yield threads.defer_to_thread(q.queue.clear)
a.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
yield threads.defer_to_thread(time.sleep, 1)
yield threads.defer_to_thread(q.queue.clear)
b.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
except Exception as e:
_log.exception("Failed")
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
def test_callback(self, monkeypatch):
from twisted.python import log
log.startLogging(sys.stdout)
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
def set_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
def get_cb(*args):
_log.debug("** %s" % repr(args))
q.put(args)
try:
a = AutoDHTServer()
a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
# Wait for start
servers = []
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
assert ["1", self._sucess_start] in servers
assert ["2", self._sucess_start] in servers
assert ["3", self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
a.set(key="APA", value="banan", cb=CalvinCB(set_cb))
set_value = yield threads.defer_to_thread(q.get, timeout=2)
assert ("APA", True) == set_value
yield threads.defer_to_thread(time.sleep, 1)
a.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
yield threads.defer_to_thread(time.sleep, 1)
b.get(key="APA", cb=CalvinCB(get_cb))
get_value = yield threads.defer_to_thread(q.get, timeout=2)
assert get_value == ("APA", "banan")
except Exception as e:
_log.exception("Failed")
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
try:
amount_of_servers = 1
# Twisted is using 20 threads so having > 20 server
# causes threadlocks really easily.
servers = []
callbacks = []
for servno in range(0, amount_of_servers):
a = evilAutoDHTServer()
servers.append(a)
callback = CalvinCB(server_started, str(servno))
servers[servno].start(iface,
network="Niklas",
cb=callback,
type="poison",
name=name)
# servers[servno].start(iface, network="Hej", cb=callback, type="eclipse", name=name)
# servers[servno].start(iface, network="Hej", cb=callback, type="sybil")
# servers[servno].start(iface, network="Hej", cb=callback, type="insert")
callbacks.append(callback)
print("Starting {}".format(
servers[servno].dht_server.port.getHost().port))
# Wait for start
started = []
while len(started) < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get)
except Queue.Empty:
_log.debug("Queue empty!")
#raise
if server not in started:
started.append(server)
_log.debug("DHT Servers added: {}".format(started))
callbacks[int(
server[0][0])].func = lambda *args, **kvargs: None
else:
_log.debug("Server: {} already started." \
" {} out of {}".format(started,
len(started),
amount_of_servers))
_log.debug("All {} out of {} started".format(
started, len(started), amount_of_servers))
for servno in range(0, amount_of_servers):
assert [str(servno), self._sucess_start] in started
yield threads.defer_to_thread(q.queue.clear)
yield threads.defer_to_thread(time.sleep, 15)
evilPort = servers[0].dht_server.port.getHost().port
drawNetworkState("start_graph.png", servers, amount_of_servers)
servers[0].dht_server.kserver.protocol.turn_evil(evilPort)
print("Node with port {} turned evil".format(
servers[servno].dht_server.port.getHost().port))
yield threads.defer_to_thread(time.sleep, 12)
# assert get_value[0] == "banan"
# assert get_value[1] == "bambu"
# assert get_value[2] == "morot"
yield threads.defer_to_thread(time.sleep, 5)
print("Attacking node exiting")
except AssertionError as e:
print("Server {} with port {} got wrong value".format(
servno, servers[servno].dht_server.port.getHost().port))
pytest.fail(traceback.format_exc())
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
i = 0
for server in servers:
name_dir = certificate.get_own_credentials_path(
name, security_dir=testdir)
shutil.rmtree(os.path.join(name_dir, "others"),
ignore_errors=True)
os.mkdir(os.path.join(name_dir, "others"))
i += 1
server.stop()
yield threads.defer_to_thread(time.sleep, 5)
def teardown_class(self):
yield threads.defer_to_thread(time.sleep, .001)
def show_text(self, text):
if self.defer is None:
self.sense.set_rotation(90, False)
self.defer = threads.defer_to_thread(self.sense.show_message, text)
self.defer.addCallback(self.cb_show_text)
self.defer.addErrback(self.cb_show_text)
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa,args])
try:
amount_of_servers = 5
# Twisted is using 20 threads so having > 20 server
# causes threadlocks really easily.
servers = []
callbacks = []
for servno in range(0, amount_of_servers):
a = AutoDHTServer()
servers.append(a)
callback = CalvinCB(server_started, str(servno))
servers[servno].start(iface, network="Niklas", cb=callback, name=name + "{}".format(servno))
callbacks.append(callback)
# Wait for start
started = []
while len(started) < amount_of_servers:
try:
server = yield threads.defer_to_thread(q.get)
except Queue.Empty:
_log.debug("Queue empty!")
#raise
if server not in started:
started.append(server)
_log.debug("DHT Servers added: {}".format(started))
callbacks[int(server[0][0])].func = lambda *args, **kvargs:None
else:
_log.debug("Server: {} already started." \
" {} out of {}".format(started,
len(started),
amount_of_servers))
_log.debug("All {} out of {} started".format(started,
len(started),
amount_of_servers))
for servno in range(0, amount_of_servers):
assert [str(servno), self._sucess_start] in started
yield threads.defer_to_thread(q.queue.clear)
yield threads.defer_to_thread(time.sleep, 8)
key = "KANIN"
value = "morot"
set_def = servers[0].set(key=key, value=value)
set_value = yield threads.defer_to_thread(set_def.wait, 10)
assert set_value
print("Node with port {} posted key={}, value={}".format(servers[0].dht_server.port.getHost().port, key, value))
get_def = servers[0].get(key="KANIN")
get_value = yield threads.defer_to_thread(get_def.wait, 10)
assert get_value == "morot"
print("Node with port {} confirmed key={}, value={} was reachable".format(servers[0].dht_server.port.getHost().port, key, value))
drawNetworkState("1nice_graph.png", servers, amount_of_servers)
yield threads.defer_to_thread(time.sleep, 7)
drawNetworkState("1middle_graph.png", servers, amount_of_servers)
yield threads.defer_to_thread(time.sleep, 7)
drawNetworkState("1end_graph.png", servers, amount_of_servers)
get_def = servers[0].get(key="KANIN")
get_value = yield threads.defer_to_thread(get_def.wait, 10)
assert get_value == "morot"
print("Node with port {} got right value: {}".format(servers[0].dht_server.port.getHost().port, get_value))
for i in range(0, amount_of_servers):
name_dir = os.path.join(_cert_conf["CA_default"]["runtimes_dir"], "{}{}".format(name, i))
filenames = os.listdir(os.path.join(name_dir, "others"))
print("Node with port {} has {} certificates in store".format(servers[i].dht_server.port.getHost().port, len(filenames)))
except AssertionError as e:
print("Node with port {} got wrong value: {}, should have been {}".format(servers[0].dht_server.port.getHost().port, get_value, value))
pytest.fail(traceback.format_exc())
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
yield threads.defer_to_thread(time.sleep, 10)
i = 0
for server in servers:
name_dir = os.path.join(_cert_conf["CA_default"]["runtimes_dir"], name + "{}".format(i))
shutil.rmtree(os.path.join(name_dir, "others"), ignore_errors=True)
os.mkdir(os.path.join(name_dir, "others"))
i += 1
server.stop()
def test_dht_multi(self, monkeypatch):
iface = "0.0.0.0"
a = None
b = None
q = Queue.Queue()
def server_started(aa, *args):
for b in args:
if isinstance(b, twisted.python.failure.Failure):
b.printTraceback()
else:
_log.debug("** %s" % b)
q.put([aa, args])
try:
a = AutoDHTServer()
d = a.start(iface, cb=CalvinCB(server_started, "1"))
b = AutoDHTServer()
d = b.start(iface, cb=CalvinCB(server_started, "2"))
c = AutoDHTServer()
c.start(iface, cb=CalvinCB(server_started, "3"))
# Wait for start
servers = []
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
server = yield threads.defer_to_thread(q.get, timeout=2)
servers.append(server)
assert ["1", self._sucess_start] in servers
assert ["2", self._sucess_start] in servers
assert ["3", self._sucess_start] in servers
yield threads.defer_to_thread(time.sleep, 1)
set_def = a.set(key="APA", value="banan")
set_value = yield threads.defer_to_thread(set_def.wait)
assert set_value
get_def = a.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
yield threads.defer_to_thread(time.sleep, 0.5)
get_def = b.get(key="APA")
get_value = yield threads.defer_to_thread(get_def.wait)
assert get_value == "banan"
except Exception as e:
traceback.print_exc()
pytest.fail(traceback.format_exc())
finally:
if a:
a.stop()
if b:
b.stop()
if c:
c.stop()
yield threads.defer_to_thread(time.sleep, 1)
