def _broadcast_ledger(self, add_secret=False, just_sharing=False):
ledger = self.book.peers
if add_secret:
# We add secret when we are sending the ledger to a new peer, so
# that the peer can ping the leader and expect the secret value
# print 'THE SECRET VALUE {0}'.format(self.secret_value)
self.log.msg('Secret value sending:{0}'.format(self.secret_value))
msg = bake(BCAST_LEDGER,
leader_id=self.book.leader,
ledger=ledger,
secret_value=self.secret_value)
self.send(msg, MCAST_ADDR)
elif just_sharing is True:
# This is necessary when the wrong winner is announced for the
# election. We then just exchange ledger with each other and
# organize a fresh new re-election
self.log.msg('Wrong winner announced: Exchange ledger')
msg = bake(BCAST_LEDGER,
ledger=ledger,
leader_id=None,
secret_value=None)
self.send(msg, MCAST_ADDR)
else:
# When split brain occurs, we exchange ledger and perform re-election
# We cant really let all the peers to announce re-election. Lets
# make only the leaders of different clusters announce the
# re-election
self.log.msg('Split Brain: Leaders only exchange ledger')
msg = bake(BCAST_LEDGER,
leader_id=self.book.leader,
ledger=ledger,
secret_value=None)
self.send(msg, MCAST_ADDR)
def _send_face_off(self, addr, with_leader=False, without_leader=False):
'''
Send a face off message: same election id but different winners
'''
if with_leader:
self.log.msg('FACE OFF: WITH LEADER')
msg = bake(FACE_OFF, with_leader=WITH_LEADER)
self.send(msg, addr)
else:
self.log.msg('FACE OFF: WITHOUT LEADER')
msg = bake(FACE_OFF, with_leader=WITHOUT_LEADER)
self.send(msg, addr)
def _change_download_folder(self, data):
new_download_folder = data['download_folder']
msg = bake(NEW_DOWNLOAD_FOLDER_RES,
download_folder_response=new_download_folder)
if not os.path.isdir(new_download_folder):
msg = bake(
NEW_DOWNLOAD_FOLDER_RES,
download_folder_response='Invalid download path provided')
else:
print_log(
'changed download folder to {0}'.format(new_download_folder))
self.factory.download_folder = new_download_folder
self.sendLine(msg)
self.transport.loseConnection()
def connectionMade(self):
if self.factory.key == LOOKUP:
update_msg = bake(LOOKUP, search_query=self.factory.dump)
elif self.factory.key == HASH_DUMP:
update_msg = bake(HASH_DUMP,
identity=self.factory.identity,
operation=self.factory.dump)
elif self.factory.key == SEND_PEER_DETAILS:
update_msg = bake(SEND_PEER_DETAILS,
filehash=self.factory.dump)
# self.transport.write(str(update_msg))
self.sendLine(update_msg)
if not persist:
self.transport.loseConnection()
def connectionMade(self):
# print 'Connection Established ... \n'
if self.factory.query == SEARCH_REQ:
reqMessage = bake(SEARCH_REQ, search_query=self.factory.arguments)
elif self.factory.query == IWANT_PEER_FILE:
reqMessage = bake(IWANT_PEER_FILE, filehash=self.factory.arguments)
elif self.factory.query == SHARE:
shared_folder = self.factory.arguments
update_config(shared_folder=shared_folder)
reqMessage = bake(SHARE, shared_folder=shared_folder)
elif self.factory.query == CHANGE:
download_folder = self.factory.arguments
update_config(download_folder=download_folder)
reqMessage = bake(CHANGE, download_folder=self.factory.arguments)
self.sendLine(reqMessage)
def _send_pong_to(self, addr):
'''
Prove that leader is alive
'''
# self.log.msg('send pong to {0}'.format(addr))
msg = bake(HANDLE_PONG, secret_value=self.secret_value)
self.send(msg, addr)
def _leader_lookup(self, data):
# TODO: there is absolutely no use of sending uuid of the message initiator
# uuid, text_search = data
text_search = data['search_query']
filtered_response = []
for uuid in self.factory.data_from_peers.keys():
for filename in self.factory.data_from_peers[uuid]['filenames']:
if fuzz.partial_ratio(text_search.lower(),
filename.lower()) >= 55:
file_hash = self.factory.data_from_peers[uuid][
'filenames'][filename]
try:
filtered_response.append(
self.factory.data_from_peers[uuid]['hashes']
[file_hash])
except Exception as e:
print e
print_log('BIGGEST MESS UP {0}'.format(filename),
WARNING_LOG)
if len(self.factory.data_from_peers.keys()) == 0:
filtered_response = []
# update_msg = Basemessage(key=SEARCH_RES, data=filtered_response)
update_msg = bake(SEARCH_RES, search_query_response=filtered_response)
self.sendLine(update_msg) # this we are sending it back to the server
# leader will loseConnection with the requesting server
self.transport.loseConnection()
def _filesystem_modified(self, data):
# print 'got updates from watchdog daemon {0}'.format(data)
if self.factory.state == READY and self.leaderThere():
self.factory._notify_leader(HASH_DUMP, data)
else: # dont think this part is required at all
if self.factory.state == NOT_READY:
# resMessage = Basemessage(key=ERROR_LIST_ALL_FILES, data='File hashing incomplete')
resMessage = bake(key=ERROR_LIST_ALL_FILES,
data='File hashing incomplete')
self.sendLine(resMessage)
else:
# msg = Basemessage(key=LEADER_NOT_READY, data=None)
msg = bake(key=LEADER_NOT_READY,
reason='Tracker is not available')
self.sendLine(msg)
self.transport.loseConnection()
def _share_new_folder(self, data):
new_shared_folder = data['shared_folder']
msg = bake(NEW_SHARED_FOLDER_RES,
shared_folder_response=new_shared_folder)
if not os.path.isdir(new_shared_folder):
msg = bake(
NEW_SHARED_FOLDER_RES,
shared_folder_response='Invalid shared folder path provided')
elif new_shared_folder != self.factory.shared_folder:
self.factory.shared_folder = new_shared_folder
file_meta_data = yield fileHashUtils.bootstrap(
self.factory.shared_folder, self.factory.dbpool)
ScanFolder(self.factory.shared_folder, filechangeCB,
self.factory.dbpool)
self.fileindexing_complete(file_meta_data)
self.sendLine(msg)
self.transport.loseConnection()
def _send_folder_structure(self, data):
requested_hash = data['checksum']
file_structure_response = yield fileHashUtils.get_structure(
requested_hash, self.factory.dbpool)
hash_identity_response_msg = bake(
key=HASH_IDENTITY_RESPONSE,
file_structure_response=file_structure_response)
self.sendLine(hash_identity_response_msg)
def _dead(self):
'''
Announce dead message
'''
self.log.msg('Announce: Dead peer')
msg = bake(DEAD,
dead_uuid=self.book.uuidObj,
secret_value=self.secret_value)
self.send(msg, MCAST_ADDR)
def _send_id_to(self, addr):
'''
Sending peer id to new peer
'''
self.log.msg('send id to {0}'.format(addr))
msg = bake(NEW_PEER,
identity=self.book.uuidObj,
leader_id=self.book.leader)
self.send(msg, addr)
def _handshake(self, data):
filehash = data['filehash']
if self.factory.state == READY:
piece_hashes = yield fileHashUtils.get_piecehashes_of(
filehash, self.factory.dbpool)
ack_msg = bake(FILE_CONFIRMATION_MESSAGE, piecehashes=piece_hashes)
self.sendLine(ack_msg)
else:
print_log('not ready yet', WARNING_LOG)
def _leader_looksup_peer(self, data):
'''
The leader looks up the peer who has the file
The leader sends a list of peers with the following data
1.piece hashes of the file
2.file size
3.file name
'''
uuids = []
sending_data = []
peers_list = []
filehash = data['filehash']
for key, val in self.factory.data_from_peers.iteritems():
value = val['hashes']
if filehash in value:
file_name, file_size, file_hash, file_root_hash = value[
filehash]
uuids.append(key)
for uuid in uuids:
sending_data.append(self.factory.book.peers[uuid])
peers_list.append(self.factory.book.peers[uuid])
try:
sending_data.append(file_root_hash) # appending hash of pieces
sending_data.append(file_size) # appending filesize
sending_data.append(file_name) # appending filename
# msg = Basemessage(key=PEER_LOOKUP_RESPONSE, data=sending_data)
response = {}
response['peers'] = peers_list
response['file_root_hash'] = file_root_hash
response['file_size'] = file_size
response['file_name'] = file_name
# response['file_hash'] = filehash
msg = bake(PEER_LOOKUP_RESPONSE, peer_lookup_response=response)
self.sendLine(msg)
self.transport.loseConnection()
except:
msg = bake(key=HASH_NOT_PRESENT, reason='No such file exists')
self.sendLine(msg)
self.transport.loseConnection()
def _broadcast_winner(self, eid):
'''
broadcasting winner message
'''
# # print 'Sending SECRET {0}'.format(self.secret_value)
self.log.msg('Broadcasting winner for election id: {0} '.format(eid))
msg = bake(NEW_LEADER,
leader_id=self.book.leader,
election_id=eid,
secret_value=self.secret_value)
self.send(msg, MCAST_ADDR)
def _broadcast_leader_dead(self):
if self.book.leader:
self.log.msg('broadcast leader is dead: {0}'.format(
self.book.leader))
msg = bake(REMOVE_LEADER, leader_id=self.book.leader)
if self.book.leader in self.book.peers:
del self.book.peers[self.book.leader]
self.book.leader = None
self.send(msg, MCAST_ADDR)
# print 'Leader dead: Broadcast re-election'
self.log.msg('Leader dead: Broadcast re-election')
self._broadcast_re_election()
def _leader_send_list(self, data):
if self.leaderThere():
print_log('lookup request sent to leader')
search_query = data['search_query']
self.factory._notify_leader(key=LOOKUP,
data=search_query,
persist=True,
clientConn=self)
else:
# msg = Basemessage(key=LEADER_NOT_READY, data=None)
msg = bake(key=LEADER_NOT_READY, reason='Tracker is not available')
self.sendLine(msg)
self.transport.loseConnection()
def _ask_leader_for_peers(self, data):
if self.leaderThere():
print_log('asking leaders for peers')
#print_log( data)
filehash = data['filehash']
self.factory._notify_leader(key=SEND_PEER_DETAILS,
data=filehash,
persist=True,
clientConn=self)
else:
# msg = Basemessage(key=LEADER_NOT_READY, data=None)
msg = bake(key=LEADER_NOT_READY, reason='Tracker is not available')
self.sendLine(msg)
self.transport.loseConnection()
def _load_file(self, data):
fhash = data['filehash']
if self.factory.state == READY:
self.fileObj = yield fileHashUtils.get_file(
fhash, self.factory.dbpool)
self.chunk_size = piece_size(
fileHashUtils.get_file_size(self.fileObj.name))
# unchoke_msg = Basemessage(key=UNCHOKE, data=None)
unchoke_msg = bake(key=UNCHOKE, unchoke=True)
self.sendLine(unchoke_msg)
else:
print_log(
'need to handle this part where files are not indexed yet',
ERROR_LOG)
def _send_alive_msg_to(self, addr, eid):
msg = bake(HANDLE_ALIVE, election_id=eid)
self.send(msg, addr)
def _ping(self, addr):
# self.log.msg('sending ping to leader {0}'.format(addr))
msg = bake(HANDLE_PING, ping=PING)
self.send(msg, addr) # might be a problem
def _send_election_msg_to(self, peer_id, eid):
self.log.msg('sending election message to {0}'.format(peer_id))
addr = self.book.peers[peer_id]
msg = bake(ALIVE, election_id=eid)
self.send(msg, addr)
def election_timeout_callback():
eid = self.generate_election_id()
self.log.msg('broadcast re-election id {0}'.format(eid))
msg = bake(RE_ELECTION, election_id=eid)
self.send(msg, MCAST_ADDR)
def _broadcast_identity(self):
self.log.msg('broadcast identity')
msg = bake(NEW_PEER,
identity=self.book.uuidObj,
leader_id=self.book.leader)
self.send(msg, MCAST_ADDR)
def send_file_search_response(self, data):
update_msg = bake(
SEARCH_RES,
search_query_response=data['search_query_response'])
clientConn.sendLine(update_msg)
clientConn.transport.loseConnection()
def invalid_file_response(self, data):
reason = data['reason']
msg = bake(HASH_NOT_PRESENT, reason=reason)
clientConn.sendLine(msg)
clientConn.transport.loseConnection()