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()