def __init__(self, filename):
self.msg_f = MsgFactory(PYMDHT_VERSION, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_addrs = set()
self._file = open(filename)
self.reactor = ThreadedReactor(self._main_loop, PORT,
self._on_datagram_received)
self.reactor.start()
def __init__(self, filename):
self.msg_f = MsgFactory(VERSION_LABEL, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_subnet_addrs = {}
self._found_nodes = []
self._file = open(filename)
self.reactor = ThreadedReactor(self._main_loop, PORT,
self._on_datagram_received)
self.reactor.start()
class BootstrapChecker(object):
def __init__(self, filename):
self.msg_f = MsgFactory(PYMDHT_VERSION, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_addrs = set()
self._file = open(filename)
self.reactor = ThreadedReactor(
self._main_loop,
PORT, self._on_datagram_received)
self.reactor.start()
def _get_ping_datagram(self):
try:
line = self._file.next()
except (StopIteration):
with self._lock:
self._is_done = True
return
print '>>>>', line
ip, str_port = line.split()
if ip in self._pinged_ips:
#duplicated IP, ignore
return
addr = (ip, int(str_port))
msg = self.msg_f.outgoing_ping_query(Node(addr))
return Datagram(msg.stamp(TID), addr)
def _main_loop(self):
datagrams_to_send = []
datagram = self._get_ping_datagram()
if datagram:
self._pinged_ips.add(datagram.addr[0])
self._pinged_addrs.add(datagram.addr)
datagrams_to_send.append(datagram)
return TIMEOUT, datagrams_to_send
def _on_datagram_received(self, datagram):
addr = datagram.addr
if addr in self._pinged_addrs:
self._pinged_addrs.remove(addr)
self._ok_addrs.add(addr)
return TIMEOUT, []
def is_done(self):
with self._lock:
done = self._is_done
return done
def stop_and_get_result(self):
self.reactor.stop()
return sorted(list(self._ok_addrs))
class BootstrapChecker(object):
def __init__(self, filename):
self.msg_f = MsgFactory(PYMDHT_VERSION, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_addrs = set()
self._file = open(filename)
self.reactor = ThreadedReactor(
self._main_loop,
PORT, self._on_datagram_received)
self.reactor.start()
def _get_ping_datagram(self):
try:
line = self._file.next()
except (StopIteration):
with self._lock:
self._is_done = True
return
print '>>>>', line
ip, str_port = line.split()
if ip in self._pinged_ips:
#duplicated IP, ignore
return
addr = (ip, int(str_port))
msg = self.msg_f.outgoing_ping_query(Node(addr))
return Datagram(msg.stamp(TID), addr)
def _main_loop(self):
datagrams_to_send = []
datagram = self._get_ping_datagram()
if datagram:
self._pinged_ips.add(datagram.addr[0])
self._pinged_addrs.add(datagram.addr)
datagrams_to_send.append(datagram)
return TIMEOUT, datagrams_to_send
def _on_datagram_received(self, datagram):
addr = datagram.addr
if addr in self._pinged_addrs:
self._pinged_addrs.remove(addr)
self._ok_addrs.add(addr)
return TIMEOUT, []
def is_done(self):
with self._lock:
done = self._is_done
return done
def stop_and_get_result(self):
self.reactor.stop()
return sorted(list(self._ok_addrs))
def __init__(self, filename):
self.msg_f = MsgFactory(PYMDHT_VERSION, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_addrs = set()
self._file = open(filename)
self.reactor = ThreadedReactor(self._main_loop, PORT, self._on_datagram_received)
self.reactor.start()
def __init__(self, filename):
self.msg_f = MsgFactory(VERSION_LABEL, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_subnet_addrs = {}
self._found_nodes = []
self._file = open(filename)
self.reactor = ThreadedReactor(
self._main_loop,
PORT, self._on_datagram_received)
self.reactor.start()
class NodeCrawler(object):
def __init__(self, filename):
self.msg_f = MsgFactory(VERSION_LABEL, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_subnet_addrs = {}
self._found_nodes = []
self._file = open(filename)
self.reactor = ThreadedReactor(
self._main_loop,
PORT, self._on_datagram_received)
self.reactor.start()
def _get_node_from_file(self):
try:
line = self._file.next()
except (StopIteration):
return
ip, str_port = line.split()
return Node((ip, int(str_port)))
def _get_found_node(self):
if len(self._ok_subnet_addrs) < MAX_NODES and self._found_nodes:
return self._found_nodes.pop(0)
def _get_ping_datagram(self):
datagram = None
node_ = self._get_node_from_file()
if not node_:
node_ = self._get_found_node()
if node_:
if node_.ip in self._pinged_ips:
#duplicated IP, ignore
return
print '>>>>', node_, len(self._ok_subnet_addrs), len(self._found_nodes)
msg = self.msg_f.outgoing_find_node_query(node_,
RandomId())
datagram = Datagram(msg.stamp(TID), node_.addr)
else:
with self._lock:
self._is_done = True
return datagram
def _main_loop(self):
datagrams_to_send = []
datagram = self._get_ping_datagram()
if datagram:
self._pinged_ips.add(datagram.addr[0])
self._pinged_addrs.add(datagram.addr)
datagrams_to_send.append(datagram)
return TIMEOUT, datagrams_to_send
def _on_datagram_received(self, datagram):
#TODO: do not add to UNSTABLE if node is alredy in STABLE
addr = datagram.addr
subnet = utils.get_subnet(addr)
if addr in self._pinged_addrs:
self._pinged_addrs.remove(addr)
self._ok_subnet_addrs[subnet] = addr
if len(self._found_nodes) < MAX_NODES:
msg = IncomingMsg(None, datagram)
for node_ in msg.all_nodes or []:
if utils.get_subnet(node_.addr) not in self._ok_subnet_addrs:
self._found_nodes.append(node_)
return TIMEOUT, []
def is_done(self):
with self._lock:
done = self._is_done
return done
def stop_and_get_result(self):
self.reactor.stop()
return sorted(self._ok_subnet_addrs.values())
class NodeCrawler(object):
def __init__(self, filename):
self.msg_f = MsgFactory(VERSION_LABEL, MY_ID)
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_subnet_addrs = {}
self._found_nodes = []
self._file = open(filename)
self.reactor = ThreadedReactor(self._main_loop, PORT,
self._on_datagram_received)
self.reactor.start()
def _get_node_from_file(self):
try:
line = self._file.next()
except (StopIteration):
return
ip, str_port = line.split()
return Node((ip, int(str_port)))
def _get_found_node(self):
if len(self._ok_subnet_addrs) < MAX_NODES and self._found_nodes:
return self._found_nodes.pop(0)
def _get_ping_datagram(self):
datagram = None
node_ = self._get_node_from_file()
if not node_:
node_ = self._get_found_node()
if node_:
if node_.ip in self._pinged_ips:
#duplicated IP, ignore
return
print '>>>>', node_, len(self._ok_subnet_addrs), len(
self._found_nodes)
msg = self.msg_f.outgoing_find_node_query(node_, RandomId())
datagram = Datagram(msg.stamp(TID), node_.addr)
else:
with self._lock:
self._is_done = True
return datagram
def _main_loop(self):
datagrams_to_send = []
datagram = self._get_ping_datagram()
if datagram:
self._pinged_ips.add(datagram.addr[0])
self._pinged_addrs.add(datagram.addr)
datagrams_to_send.append(datagram)
return TIMEOUT, datagrams_to_send
def _on_datagram_received(self, datagram):
#TODO: do not add to UNSTABLE if node is alredy in STABLE
addr = datagram.addr
subnet = utils.get_subnet(addr)
if addr in self._pinged_addrs:
self._pinged_addrs.remove(addr)
self._ok_subnet_addrs[subnet] = addr
if len(self._found_nodes) < MAX_NODES:
msg = IncomingMsg(None, datagram)
for node_ in msg.all_nodes or []:
if utils.get_subnet(node_.addr) not in self._ok_subnet_addrs:
self._found_nodes.append(node_)
return TIMEOUT, []
def is_done(self):
with self._lock:
done = self._is_done
return done
def stop_and_get_result(self):
self.reactor.stop()
return sorted(self._ok_subnet_addrs.values())
