def __init__(self, bootstrap_nodes):
self.target = RandomId()
self.extracting_queue = ExtractingQueue(self.target)
for node_ in bootstrap_nodes:
is_new_node = self.extracting_queue.add_node(node_)
self.my_id = self._my_id = RandomId()
self.msg_f = message.MsgFactory(PYMDHT_VERSION, self.my_id,
None)
self.querier = Querier()
self.last_extraction_ts = time.time()
self.num_msgs = 0
self.nodes_inrange_w_response = set()
def __init__(self, node_to_extract):
self.node_to_extract = node_to_extract
self.my_id = self._my_id = RandomId()
self.msg_f = message.MsgFactory(PYMDHT_VERSION, self.my_id, None)
self.querier = Querier()
self.next_level = 159
self.last_extraction_ts = 0
def next_bootstrap_msg(self):
dst_node = None
target = None
if self.leaf:
return dst_node, target
self.bootstrap_done = (self.rcrawlers[0].bootstrap_done
and self.rcrawlers[1].bootstrap_done)
if self.bootstrap_done:
return dst_node, target
for i, j in ((0, 1), (1, 0)):
rcrawler0 = self.rcrawlers[i]
rcrawler1 = self.rcrawlers[j]
#print self.target_prefix, 'rc0 ok', len(rcrawler0.ok_nodes),
#print 'rc1 pending', len(rcrawler1.pending_nodes),
if (rcrawler0.ok_nodes and not rcrawler1.bootstrap_done
and not rcrawler1.pending_nodes):
# Try bootrapping rcrawler1 from nodes from rcrawler0
rcrawler1.num_bootstrap_attempts += 1
rcrawler1.bootstrap_done = rcrawler1.num_bootstrap_attempts > 2
dst_node = random.sample(rcrawler0.ok_nodes, 1)[0]
target = RandomId(rcrawler1.target_prefix)
print rcrawler1.target_prefix
break
if not target:
dst_node, target = self.rcrawlers[
self.next_rcrawler].next_bootstrap_msg()
self.next_rcrawler = self.next_rcrawler ^ 1 #round-robin
if not target:
dst_node, target = self.rcrawlers[
self.next_rcrawler].next_bootstrap_msg()
self.bootstrap_done = (self.rcrawlers[0].bootstrap_done
and self.rcrawlers[1].bootstrap_done)
return dst_node, target
def __init__(self, bootstrap_nodes):
self.rcrawler = RCrawler(set(), set(), START_PREFIX_LEN,
bootstrap_nodes[0].id)
self.rcrawler.got_nodes_handler(None, bootstrap_nodes)
self.my_id = self._my_id = RandomId()
self.msg_f = message.MsgFactory(PYMDHT_VERSION, self.my_id, None)
self.querier = Querier()
self.next_main_loop_ts = 0
self.num_msgs = 0
self.ok_nodes = set()
self.dead_nodes = set()
def __init__(self, bootstrap_nodes):
self.target = bootstrap_nodes[0].id
target_prefix = self.target.get_prefix(START_PREFIX_LEN)
print target_prefix
self.rcrawler = RCrawler(target_prefix)
for n in bootstrap_nodes:
self.rcrawler.found_node_handler(n)
self.pending_nodes = bootstrap_nodes
self.my_id = self._my_id = RandomId()
self.msg_f = message.MsgFactory(PYMDHT_VERSION, self.my_id, None)
self.querier = Querier()
self.next_main_loop_ts = 0
self.num_msgs = 0
self.known_nodes = set(bootstrap_nodes)
self.ok_nodes = set()
self.dead_nodes = set()
self.last_msg_ts = time.time()
def main(options, args):
ip, port_str = args
port = int(port_str)
bootstrap_node = Node((ip, port), RandomId())
mcrawler = MultiCrawler(bootstrap_node)
logs_path = '.'# os.path.join(os.path.expanduser('~'), '.pymdht')
logging_conf.setup(logs_path, logging.DEBUG)
reactor = minitwisted.ThreadedReactor(
mcrawler.main_loop, 7005,
mcrawler.on_datagram_received,
task_interval=.005)
reactor.start()
try:
time.sleep(20000)
except:
pass
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 __init__(self, swift_port, dht_port, path):
# Raul, 2012-03-09: Do not create a thread
# threading.Thread.__init__(self)
my_node = Node(('127.0.0.1', dht_port), RandomId())
self.dht = Pymdht(my_node, path, routing_m_mod, lookup_m_mod,
experimental_m_mod, None, logging.ERROR, False)
self.rand_num = random.randint(0, 999)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.settimeout(
TOAST_EACH) # This is to show that the thread is running
try:
self.socket.bind(('', swift_port))
except (socket.error):
droid.log('EXCEP: swift_port in use')
raise
self.channel_m = ChannelManager()
import threading
import sys
sys.path.append('..')
import logging
from core.pymdht import PYMDHT_VERSION
import core.logging_conf as logging_conf
from core.node import Node
from core.message import MsgFactory, Datagram
from core.identifier import RandomId
from core.minitwisted import ThreadedReactor
import core.ptime as time
from core.pymdht import PYMDHT_VERSION
MY_ID = RandomId()
TID = '11'
INPUT_FILE = '../core/bootstrap.backup'
PORT = 7667
TIMEOUT = .25 # seconds
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()