def test_custom_protocol(self): # pylint: disable=no-self-use """ A subclass of Server which overrides the protocol_class attribute will have an instance of that class as its protocol after its listen() method is called. """ # Make a custom Protocol and Server to go with hit. class CoconutProtocol(KademliaProtocol): pass class HuskServer(Server): protocol_class = CoconutProtocol # An ordinary server does NOT have a CoconutProtocol as its protocol... loop = asyncio.get_event_loop() server = Server() loop.run_until_complete(server.listen(8469)) assert not isinstance(server.protocol, CoconutProtocol) server.stop() # ...but our custom server does. husk_server = HuskServer() loop.run_until_complete(husk_server.listen(8469)) assert isinstance(husk_server.protocol, CoconutProtocol) husk_server.stop()
async def run_test(): server = Server() def async_return(result): f = asyncio.Future() f.set_result(result) return f get_signed_value = get_signed_value_with_keys(priv_key_path='kademlia/tests/resources/key.der', pub_key_path='kademlia/tests/resources/public.der') get_signed_message = get_signed_message_with_keys(priv_key_path='kademlia/tests/resources/key.der', pub_key_path='kademlia/tests/resources/public.der') key_test = 'test key' dkey_test = digest(key_test) data = json.dumps(get_signed_value(dkey_test, 'data', PersistMode.SECURED).to_json()) value = get_signed_value(dkey_test, data, PersistMode.SECURED) server._call_remote_persist = Mock(return_value=async_return(True)) server.get = Mock(return_value=async_return(get_signed_message(dkey_test, data))) server.set_digest = Mock(return_value=async_return(True)) Server._get_dtl_record = Mock(return_value=True) await server.set('test key', value) server.get.assert_called_with('test key') server.stop()
def initialize_dht( bootstrap_ip_port_pair_list: List[Tuple[str, int]], listen_port: int, ) -> None: """ connects to the distributed hash table if no bootstrap ip port pair list is given, it starts a new dht :param bootstrap_ip_port_pair_list: list of ip port tuples to connect to \ the dht :param listen_port: port to listen on :return: instance of server """ global _node_instance get_logger("kademlia") logger.debug("set up DHT: %s", str(bootstrap_ip_port_pair_list)) node = Server(storage=DropPeerDHTStorage()) node.listen(listen_port) loop = asyncio.get_event_loop() if len(bootstrap_ip_port_pair_list) > 0: loop.run_until_complete(node.bootstrap(bootstrap_ip_port_pair_list)) _node_instance = node
def kad_server_join(network_port, profile_port, neighbor_ip, neighbor_port, username): handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) log = logging.getLogger('kademlia') log.addHandler(handler) log.setLevel(logging.DEBUG) aio = asyncio.new_event_loop() kad = Server() aio.run_until_complete(kad.listen(network_port)) aio.run_until_complete(kad.bootstrap([(neighbor_ip, neighbor_port)])) aio.run_until_complete(asyncio.sleep(1)) # set a value for the key "my-key" on the network aio.run_until_complete( kad.set(username, 'http://' + socket.gethostname() + ':' + str(profile_port))) aio.run_until_complete(asyncio.sleep(2)) # run forever since we are the first node try: main_loop(aio, kad) except KeyboardInterrupt: pass finally: kad.stop() aio.close()
def test_custom_protocol(self): """ A subclass of Server which overrides the protocol_class attribute will have an instance of that class as its protocol after its listen() method is called. """ # Make a custom Protocol and Server to go with hit. class CoconutProtocol(KademliaProtocol): pass class HuskServer(Server): protocol_class = CoconutProtocol # An ordinary server does NOT have a CoconutProtocol as its protocol... server = Server() server.listen(8469) self.assertNotIsInstance(server.protocol, CoconutProtocol) server.stop() # ...but our custom server does. husk_server = HuskServer() husk_server.listen(8469) self.assertIsInstance(husk_server.protocol, CoconutProtocol) husk_server.stop()
def __init__(self, bootstrapHost: str = 'bootstrap'): self.server = Server() self.server.listen(8469) self.has_list = [] # Hack to get the "deafult" IP s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('1.1.1.1', 80)) self.local_ip = s.getsockname()[0] s.close() #self.local_ip = socket.gethostbyname(socket.gethostname()) bootstrap_ip = socket.gethostbyname(bootstrapHost) self.bootstrap_node = (bootstrap_ip, 8469) self.loop = asyncio.get_event_loop() self.loop.set_debug(True) self.loop.run_until_complete( self.server.bootstrap([self.bootstrap_node])) neighbors = self.server.bootstrappableNeighbors() for node in neighbors: print("DHT Peer found! {0}:{1}".format(node[0], node[1])) print("Starting TCP transfer server") self.tcpThread = threading.Thread(target=self.startTCPServer) self.tcpThread.start()
def start_node(port, BTIp="", BTPort=0): handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s\ - %(levelname)s - %(message)s') handler.setFormatter(formatter) # DEBUG if DEBUG: log = logging.getLogger('kademlia') log.addHandler(handler) log.setLevel(logging.DEBUG) loop = asyncio.get_event_loop() if DEBUG: loop.set_debug(True) server = Server() loop.run_until_complete(server.listen(port)) # the first peer don't do that if BTPort != 0: bootstrap_node = (BTIp, int(BTPort)) loop.run_until_complete(server.bootstrap([bootstrap_node])) return (server, loop)
def refresh_mirror( working_dir, first_block, last_block ): """ Refresh the mirror: * process all new invalidations * grab and mirror any new profiles from the DHT This gets called by Twisted every time there ought to be a new block. """ from twisted.python import log from kademlia.network import Server # make soure our bitcoind cached block index is up-to-speed nameop_sequence = sync_blockchain( working_dir, first_block, last_block ) if nameop_sequence is None: log.error("sync_blockchain(%s-%s) failed" % (first_block, last_block)) return None # synchronize name registrations... server = Server() server.listen( dht.plugin.DHT_SERVER_PORT ) server.bootstrap( dht.plugin.DEFAULT_DHT_SERVERS ).addCallback( connect_done, server ) pass
def send(port, key, message): handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) log = logging.getLogger('kademlia') log.addHandler(handler) log.setLevel(logging.DEBUG) loop = asyncio.get_event_loop() loop.set_debug(True) server = Server() server.listen(8469) bootstrap_node = ("0.0.0.0", int(port)) loop.run_until_complete(server.bootstrap([bootstrap_node])) result = loop.run_until_complete(server.get(key)) loop.run_until_complete( server.set(key, str(result) + str(datetime.datetime.now()) + " " + message)) result = loop.run_until_complete(server.get(key)) server.stop() #loop.close() print("************************************************") print(key, "\n", result + "\n") print("************************************************")
async def run(): server = Server() await server.listen(8469) bootstrap_node = (sys.argv[2], int(sys.argv[3])) await server.bootstrap([bootstrap_node]) await server.set(sys.argv[4], sys.argv[5]) server.stop()
async def test_storing(bootstrap_node): with server_context(Server()) as server: await server.listen(bootstrap_node[1] + 1) await server.bootstrap([bootstrap_node]) await server.set('key', 'value') result = await server.get('key') assert result == 'value'
def __init__(self, port=DEFAULT_PORT, evt_loop=None): self.set_logging() if not evt_loop: evt_loop = asyncio.get_event_loop() self.loop = evt_loop self.node = Server() self.port = port self.start_server()
def peer_kademlia_join(): temp = Server() loop.run_until_complete(temp.listen(5678)) loop.run_until_complete(temp.bootstrap([(master_ip, 5678)])) msg = stamp("{} has joined the P2P network.".format(peer_name)) print(msg) global node node = temp
def __init__(self, name="KademliaUser%d" % random.randint(1, 1000), port=emu_config.kademlia_default_port, peerlist=None): super(KademliaUser, self).__init__(name=name) self.kademliaServer = Server() self.port = port self.peerlist = peerlist if peerlist is not None else []
def bootstrap_node(event_loop): server = Server() event_loop.run_until_complete(server.listen(8468)) try: yield ('127.0.0.1', 8468) finally: server.stop()
async def run(): server = Server() await server.listen(8469) bootstrap_node = (sys.argv[1], int(sys.argv[2])) await server.bootstrap([bootstrap_node]) result = await server.get(sys.argv[3]) print("Get result:", result) server.stop()
def __init__(self, ip_address=BOOSTRAP_IP, port=BOOSTRAP_PORT): self.server = Server() self.server.listen(UDHT_PORT) self.loop = asyncio.get_event_loop() self.loop.set_debug(True) bootstrap_node = (ip_address, int(port)) self.loop.run_until_complete(self.server.bootstrap([bootstrap_node]))
def __init__(self, *initial_peers: Tuple[str, int], port=8081, start=False): super().__init__() self.port, self.initial_peers = port, initial_peers self._pipe, self.pipe = mp.Pipe(duplex=False) self.server = Server() if start: self.start()
async def test_storing(bootstrap_node): server = Server() await server.listen(bootstrap_node[1] + 1) await server.bootstrap([bootstrap_node]) await server.set('key', 'value') result = await server.get('key') assert result == 'value' server.stop()
def test_default_protocol(self): """ An ordinary Server object will initially not have a protocol, but will have a KademliaProtocol object as its protocol after its listen() method is called. """ server = Server() self.assertIsNone(server.protocol) server.listen(8469) self.assertIsInstance(server.protocol, KademliaProtocol) server.stop()
def test_default_protocol(self): # pylint: disable=no-self-use """ An ordinary Server object will initially not have a protocol, but will have a KademliaProtocol object as its protocol after its listen() method is called. """ loop = asyncio.get_event_loop() with server_context(Server()) as server: assert server.protocol is None loop.run_until_complete(server.listen(8469)) assert isinstance(server.protocol, KademliaProtocol)
async def run(): server = Server() await server.listen(8469) bootstrap_node = (sys.argv[1], int(sys.argv[2])) await server.bootstrap([bootstrap_node]) await server.set(sys.argv[3], sys.argv[4]) print("sleeping for 5 seconds") time.sleep(5) print("waking up to fetch stored value") result = await server.get(sys.argv[3]) print("Get result:", result) server.stop()
def test_default_protocol(self): """ An ordinary Server object will initially not have a protocol, but will have a KademliaProtocol object as its protocol after its listen() method is called. """ loop = asyncio.get_event_loop() server = Server() self.assertIsNone(server.protocol) loop.run_until_complete(server.listen(8469)) self.assertIsInstance(server.protocol, KademliaProtocol) server.stop()
def test_custom_event_loop(self): custom_loop = asyncio.new_event_loop() server = Server() server.listen(8468) custom_loop = asyncio.new_event_loop() server2 = Server(custom_event_loop=custom_loop) server_thread = threading.Thread(target=setup_extra_server, args=[server2, custom_loop]) server_thread.start() # testing using the custom event loop loop = asyncio.get_event_loop() loop.run_until_complete(server.bootstrap([("localhost", 8469)])) loop.run_until_complete(server.set("test", "test1")) rec_value = loop.run_until_complete(server.get("test")) server.stop() stop_extra_server(server2, custom_loop) server_thread.join() assert rec_value == "test1"
async def run(): server = Server() await server.listen(7077) bootstrap_node = (sys.argv[1], 7077) await server.bootstrap([bootstrap_node]) while True: time.sleep(3) key = random_string(8) await server.set(key, random_string(64)) await server.get(key)
def chat(port, chatname): node = Server() node.listen(port) loop = asyncio.get_event_loop() loop.run_until_complete(node.bootstrap([("0.0.0.0", 8468)])) chatlist = loop.run_until_complete(node.get("chatlist")) loop.run_until_complete(node.set("chatlist", str(chatlist) + "\n" + chatname + "\n")) node.stop()
def __init__(self, *initial_peers: Tuple[str, int], port=8081, start=False, daemon=True): super().__init__() self.port, self.initial_peers = port, initial_peers self._pipe, self.pipe = mp.Pipe(duplex=False) self.ready = mp.Event() self.server = Server() self.daemon = daemon if start: self.run_in_background(await_ready=True)
def user(port, username): node = Server() node.listen(port) loop = asyncio.get_event_loop() loop.run_until_complete(node.bootstrap([("0.0.0.0", 8468)])) userlist = loop.run_until_complete(node.get("userlist")) loop.run_until_complete(node.set("userlist", str(userlist) + "\n" + username + "\n")) node.stop()
def initiate(self): if self.server is None: self.loop = asyncio.get_event_loop() self.server = Server(ksize=100, alpha=10) self.loop.run_until_complete(self.server.listen(self.port)) handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) log = logging.getLogger('kademlia') log.addHandler(handler) log.setLevel(logging.DEBUG) self.loop.set_debug(True)
def master_kademlia_join(loop): node = Server() loop.run_until_complete(node.listen(5678)) try: msg = stamp("{} has joined the P2P network.".format(master_name)) send_to_hub(msg) print(msg) loop.run_forever() except KeyboardInterrupt: pass finally: node.stop() loop.close() return node