def setup(self):
self.lock = threading.Lock()
self.datagrams_received = []
self.callback_order = []
self.client_r = ThreadedReactor(task_interval=tc.TASK_INTERVAL)
self.server_r = ThreadedReactor(task_interval=tc.TASK_INTERVAL)
self.client_r.listen_udp(tc.CLIENT_ADDR[1], self.on_datagram_received)
self.server_r.listen_udp(tc.SERVER_ADDR[1], self.on_datagram_received)
self.client_r.start()
self.server_r.start()
def __init__(self, dht_addr, state_path, routing_m_mod, lookup_m_mod):
self.state_filename = os.path.join(state_path, STATE_FILENAME)
self.load_state()
if not self._my_id:
self._my_id = identifier.RandomId()
self._my_node = Node(dht_addr, self._my_id)
self._tracker = tracker.Tracker()
self._token_m = token_manager.TokenManager()
self._reactor = ThreadedReactor()
self._reactor.listen_udp(self._my_node.addr[1],
self._on_datagram_received)
#self._rpc_m = RPCManager(self._reactor)
self._querier = Querier(self._my_id)
bootstrap_nodes = self.loaded_nodes or BOOTSTRAP_NODES
del self.loaded_nodes
self._routing_m = routing_m_mod.RoutingManager(self._my_node,
bootstrap_nodes)
# self._responder = Responder(self._my_id, self._routing_m,
# self._tracker, self._token_m)
self._lookup_m = lookup_m_mod.LookupManager(self._my_id)
current_time = time.time()
self._next_maintenance_ts = current_time
self._next_save_state_ts = current_time + SAVE_STATE_DELAY
self._running = False
def __init__(self, dht_addr):
self.my_addr = dht_addr
self.my_id = identifier.RandomId()
self.my_node = Node(self.my_addr, self.my_id)
self.tracker = tracker.Tracker()
self.token_m = token_manager.TokenManager()
self.reactor = ThreadedReactor()
self.rpc_m = RPCManager(self.reactor, self.my_addr[1])
self.querier = Querier(self.rpc_m, self.my_id)
self.routing_m = RoutingManager(self.my_node, self.querier,
bootstrap_nodes)
self.responder = Responder(self.my_id, self.routing_m,
self.tracker, self.token_m)
self.responder.set_on_query_received_callback(
self.routing_m.on_query_received)
self.querier.set_on_response_received_callback(
self.routing_m.on_response_received)
self.querier.set_on_error_received_callback(
self.routing_m.on_error_received)
self.querier.set_on_timeout_callback(self.routing_m.on_timeout)
self.querier.set_on_nodes_found_callback(self.routing_m.on_nodes_found)
self.routing_m.do_bootstrap()
self.rpc_m.add_msg_callback(QUERY,
self.responder.on_query_received)
self.lookup_m = LookupManager(self.my_id, self.querier,
self.routing_m)
def __init__(self, dht_addr):
my_addr = dht_addr
my_id = identifier.RandomId()
my_node = Node(my_addr, my_id)
tracker_ = tracker.Tracker()
token_m = token_manager.TokenManager()
self.reactor = ThreadedReactor()
rpc_m = RPCManager(self.reactor, my_addr[1])
querier_ = Querier(rpc_m, my_id)
routing_m = RoutingManager(my_node, querier_, bootstrap_nodes)
responder_ = Responder(my_id, routing_m, tracker_, token_m)
responder_.set_on_query_received_callback(routing_m.on_query_received)
querier_.set_on_response_received_callback(
routing_m.on_response_received)
querier_.set_on_error_received_callback(routing_m.on_error_received)
querier_.set_on_timeout_callback(routing_m.on_timeout)
querier_.set_on_nodes_found_callback(routing_m.on_nodes_found)
routing_m.do_bootstrap()
rpc_m.add_msg_callback(QUERY, responder_.on_query_received)
self.lookup_m = LookupManager(my_id, querier_, routing_m)
self._routing_m = routing_m
def setup(self):
global time
#TODO: mock time and socket
#time = minitwisted.time = MockTime()
#minitwisted.socket = MockSocket()
self.lock = threading.Lock()
self.datagrams_received = []
self.callback_order = []
self.client_r = ThreadedReactor(task_interval=tc.TASK_INTERVAL)
self.server_r = ThreadedReactor(task_interval=tc.TASK_INTERVAL)
self.client_s = self.client_r.listen_udp(tc.CLIENT_ADDR[1],
self.on_datagram_received)
self.server_s = self.server_r.listen_udp(tc.SERVER_ADDR[1],
self.on_datagram_received)
self.client_r.start()
self.server_r.start()
def test_recvfrom(self):
self.r.start()
r2 = ThreadedReactor()
r2.listen_udp(tc.SERVER_ADDR[1], lambda x, y: None)
logger.critical('TESTING: IGNORE CRITICAL MESSAGE')
r2.sendto('z', tc.CLIENT_ADDR)
# self.r will call recvfrom (which raises socket.error)
time.sleep(tc.TASK_INTERVAL)
ok_(not self.callback_fired)
self.r.stop()
def setup(self):
self.main_loop_call_counter = 0
self.callback_values = []
self.datagrams_received = []
self.reactor = ThreadedReactor(self._main_loop,
tc.CLIENT_PORT,
self._on_datagram_received,
task_interval=tc.TASK_INTERVAL)
self.reactor.s = _SocketMock()
def test_failed_join(self):
self.lock = threading.RLock()
self.reactor = ThreadedReactor(self._main_loop,
tc.CLIENT_PORT,
self._on_datagram_received,
task_interval=tc.TASK_INTERVAL)
self.reactor.s = _SocketMock(tc.TASK_INTERVAL)
# self.reactor.start()
self.reactor.call_asap(self._very_long_callback)
time.sleep(tc.TASK_INTERVAL*2)
assert_raises(Exception, self.reactor.stop)
def _test_recvfrom(self):
#self.r.start()
r2 = ThreadedReactor(self._main_loop, tc.CLIENT_PORT,
self._on_datagram_received,
task_interval=tc.TASK_INTERVAL)
r2.s = _SocketErrorMock()
assert not r2.running
# r2.start()
assert r2.running
logger.critical('TESTING: IGNORE CRITICAL MESSAGE')
# self.r will call recvfrom (which raises socket.error)
while not r2.s.error_raised:
time.sleep(tc.TASK_INTERVAL)
assert r2.running # the error is ignored
ok_(not self.callback_fired)
def test_start_and_stop(self):
'''
NOTE:
This is the only test using real threading
'''
self.reactor = ThreadedReactor(self._main_loop,
tc.CLIENT_PORT,
self._on_datagram_received,
task_interval=tc.TASK_INTERVAL)
ok_(not self.reactor.running)
self.reactor.start()
time.sleep(.1)
ok_(self.reactor.running)
self.reactor.stop()
ok_(not self.reactor.running)
def test_listen_upd(self):
r = ThreadedReactor()
r.start()
logger.warning(''.join(('TESTING LOGS ** IGNORE EXPECTED WARNING ** ',
'(udp_listen has not been called)')))
self.client_r.sendto(DATA, tc.SERVER_ADDR)
while 1: #waiting for data
with self.lock:
if self.datagrams_received:
break
time.sleep(tc.TASK_INTERVAL)
with self.lock:
first_datagram = self.datagrams_received.pop(0)
logger.debug('first_datagram: %s, %s' % (first_datagram,
(DATA, tc.CLIENT_ADDR)))
assert first_datagram, (DATA, tc.CLIENT_ADDR)
r.stop()
def test_mock_threaded_reactor(self):
'''
Just making sure that the interface is the same
'''
r = ThreadedReactor(task_interval=.1)
rm = ThreadedReactorMock(task_interval=.1)
r.listen_udp(tc.CLIENT_ADDR[1], lambda x, y: None)
rm.listen_udp(tc.CLIENT_ADDR[1], lambda x, y: None)
r.start()
rm.start()
r.sendto(DATA, tc.CLIENT_ADDR)
rm.sendto(DATA, tc.CLIENT_ADDR)
r.call_later(.1, self._callback)
rm.call_later(.1, self._callback)
# time.sleep(.002)
r.stop()
rm.stop()
def setup(self):
self.main_loop_send_called = False
self.callback_fired = False
self.r = ThreadedReactor(self._main_loop_send, tc.CLIENT_PORT,
self._on_datagram_received)
self.r.s = _SocketErrorMock()
