def close_connection(self):
"""
Close the connection with the indexing server and the peers.
:return: None
"""
self.idx_server_proxy.close_connection(self.id)
for peer_id, sock in self.peers_sock.iteritems():
if sock:
try:
exch = MessageExchanger(sock)
peer_action = dict(type='exit', id=peer_id)
exch.pkl_send(peer_action)
sock.shutdown(1)
sock.close()
except error:
pass
def _register(self, f_path, regex=False):
"""
Register a given file to the indexing server.
:param f_path: path to the file to register.
:param regex: if not False, then f_path is processed as a regular expression.
:return: False, True if replication has been done or False otherwise.
"""
if regex != False:
files = glob.glob(f_path)
results = []
for f in files:
term, ret = self._register(f)
results.append(ret)
return False, Counter(results)
if not os.path.isfile(f_path):
self.logger.error("%s does not exist or is not a file." % f_path)
return False, False
# Register to the indexing server
name = os.path.basename(f_path)
replicate_to = self.idx_server_proxy.register(self.id, name)
if replicate_to == False:
self.logger.debug("Main node and replica are done for metadata.")
return False, False
# Register locally
local_files = self.parent.local_files
local_files[name] = os.path.abspath(f_path)
self.parent.local_files = local_files
# Replicate files
if replicate_to:
self.logger.debug("Replicate to %s", replicate_to)
for peer_id in replicate_to:
peer_sock = self._get_peer_sock(peer_id)
if peer_sock:
peer_exch = MessageExchanger(peer_sock)
peer_action = dict(type='replicate', name=name)
peer_exch.pkl_send(peer_action)
peer_exch.file_send(f_path)
return False, True
def _peer_message_handler(self, peer_sock, peer_addr):
"""
Handle messages sent by another peer.
:param peer_sock: socket to communicate with the other peer.
:param peer_addr: address of the other peer.
:return: None
"""
self.logger.debug("Accepted connection from %s", peer_addr)
peer_exch = MessageExchanger(peer_sock)
open_conn = True
while open_conn != False:
self.logger.debug("%s: %s", repr(peer_sock), open_conn)
action = peer_exch.pkl_recv()
if action is None:
break
self.logger.debug(repr(action))
action['exch'] = peer_exch
open_conn = self._generic_action(action)
peer_sock.shutdown(1)
peer_sock.close()
self.parent.client.peers_sock[peer_addr] = None
self.parent.client.peers_check[peer_addr] = time.time()
def _lookup(self, name):
"""
Search for peers where a given file is stored and then request these peers for the file until the file
is entirely stored locally.
:param name: name of the file to obtain.
:return: False, True if the file has been downloaded or False if not.
"""
_, available_peers = self._search(name, pprint=False)
file_obtained = False
while not file_obtained and available_peers:
peer_id = available_peers.pop(0)
# Establish connection to the peer to obtain file
peer_sock = self._get_peer_sock(peer_id)
self.logger.debug('peer_sock in lookup: %s', repr(peer_sock))
if peer_sock:
peer_exch = MessageExchanger(peer_sock)
peer_action = dict(type='obtain', name=name)
peer_exch.pkl_send(peer_action)
f_path = os.path.join(self.download_dir, name)
file_exists = peer_exch.pkl_recv()
if file_exists:
peer_exch.file_recv(f_path, show_progress=False)
file_obtained = True
return False, file_obtained
