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_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 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 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 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 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 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_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 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)