HeartBeat.da

"""
Created on Sat Dec  1 18:17:36 2018

@author: risabh
"""
import time
config(channel is fifo, clock is lamport)

class HeartBeat(process):
    
    def setup(master:Master):
        output('Setting up HeartBeat')
        #Stores the set of heartBeats recieved in each call
        self.heartBeatFromChunks = set()    
        
        #Stores the list of available chunkServers to which HeartBeat needs to poll
        self.availableChunkServers = set()
        
        #Map which stores the list of files send from chunkServer in a call  
        self.filesList = {}
        
        self.master = master
        
        self.counter=0
        
        # Number of cycles in which we want garbage collection to happen
        self.timeForGarbage =1

        
    def sendHeartBeat():
        '''
        Helper method to send HeartBeat message to all chunkServers and await their 
        replies and then send it to master for updates.
        '''
        
        output('Inside Send Heart Beat')
        self.heartBeatFromChunks = set()
        nonAvailableChunkServers =set()
        
        counter+=1
        #Obatain the list of chunkServers from master
        if len(self.availableChunkServers)==0:
            send(('GET_AVAILABLE_CHUNK_SERVERS',), to = master)
            await(len(self.availableChunkServers)!=0)
            for chunkServer in self.availableChunkServers:
                self.filesList[chunkServer] = []        
        
        # Send heartbeat message to all the chunkServers and await their replies    
        for chunkServer in self.availableChunkServers:
            send(('HEARTBEAT',), to = chunkServer)
        if await(len(self.availableChunkServers) == len(self.heartBeatFromChunks)):
            output('All chunk servers are responding')
        elif timeout(20):
            output('Chunk Servers available', self.heartBeatFromChunks)
            nonAvailableChunkServers = self.availableChunkServers - self.heartBeatFromChunks
            output("Chunk servers not available", nonAvailableChunkServers)
            for chunkServer in nonAvailableChunkServers:
                self.filesList[chunkServer] = []
        
        #Updates master with list of chunkServers which are not available
        send(('UPDATE_AVAILABLE_CHUNK_SERVERS', nonAvailableChunkServers), to = master)
        
        if counter% self.timeForGarbage==0:
            #Send the list of file obtained from chunkServers to master to be checked for garbage collection
            send(('DELETE_ORPHANED_CHUNKS', self.filesList), to=master)
            for chunkServer in self.availableChunkServers:
                self.filesList[chunkServer] = []
     
    def receive(msg=('AVAILABLE_CHUNK_SERVERS', availableChunkServers), from_=master):
        '''
        Receive handler to get the availableChunkServers from master
        '''
        
        self.availableChunkServers = availableChunkServers
        
    def receive(msg=('HEARTBEAT_ACKNOWLEDGED',files), from_=chunkServer):
        '''
        Receive handler for Heartbeat acknowledgement from the chunkServers and
        adding the list of files sent from ChunkServer to be checked for existence
        '''
        
        output("Heart beat received from", chunkServer)
        self.heartBeatFromChunks.add(chunkServer)
        localFileList = []
        for file in files:
            localFileList.append(file[:-4]) 
        self.filesList[chunkServer].extend(localFileList)
        self.filesList[chunkServer] = list(set(self.filesList[chunkServer])) 

    def run():
        while True:
            sendHeartBeat()
            time.sleep(10)            #Running heartbeat process every 10 seconds