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
