def lfd_ping(lfd_id, lfd_addr): sudp_ping = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sudp_ping.settimeout(1) while True: msg = messager.encodeMsg(20, 0, "") sudp_ping.sendto(msg.encode('utf-8'), lfd_addr) try: sudp_ping.recvfrom(buffSize) logging.info("lfd %d login", lfd_id) break except socket.timeout: continue while True: while True: time.sleep(interval) sudp_ping.sendto(msg.encode('utf-8'), lfd_addr) tried = 0 while tried < retry: try: sudp_ping.recvfrom(buffSize) logging.info("lfd %d beating freq: %d retry: %d", lfd_id, interval, retry) break except socket.timeout: logging.info("No response, try %d times", tried) tried += 1 # Should never goes here except socket.error: logging.error("Critical error") if tried == 3: logging.error("NO Heartbeating") print("lfd %d down", lfd_id) break
def ping(sock): global ACTIVE global INIT_LOGIN addr = ((host, port)) while True: time.sleep(interval) ping_str = messager.encodeHeartbeat(sid) msg = messager.encodeMsg(messager.MSG_PING, len(ping_str) + 1, ping_str) sock.sendto(bytes(msg, 'utf-8'), addr) tried = 0 while tried < retry: try: data, addr = sock.recvfrom(buffSize) logging.info("beating freq: %d retry: %d", interval, retry) if (not ACTIVE): c = messager.encodeInit(messager.MSG_ROLE_SERVER, sid) if INIT_LOGIN: msg = messager.encodeMsg(messager.MSG_INIT, len(c) + 1, c) else: msg = messager.encodeMsg(messager.MSG_RECOVERY, len(c) + 1, c) sudp_handle.sendto(bytes(msg, "utf-8"), ((ip_gfd, port_gfd))) logging.info("server %d active", sid) ACTIVE = True break except socket.timeout: logging.info("No response, try %d times", tried) tried += 1 # Should never goes here except socket.error: logging.error("Critical error") if tried == 3: logging.error("NO Heartbeating") if ACTIVE: c = messager.encodeInit(messager.MSG_ROLE_LFD, sid) msg = messager.encodeMsg(messager.MSG_FAULT, len(c) + 1, c) sudp.sendto(bytes(msg, "utf-8"), ((ip_gfd, port_gfd))) ACTIVE = False INIT_LOGIN = False break
def handleUDP(data): global ACTIVE global BLOCK_FLAG global log global state global quiet_lock global num_client global num_blocked sock = data tdata = threading.local() while True: try: tdata.data, tdata.addr = sock.recvfrom(buffSize) except socket.timeout: exit(0) tdata.t, tdata.s, tdata.c = messager.decodeMsg( tdata.data.decode('utf-8')) if tdata.t == messager.MSG_CHECKPOINT: with __lock: if tdata.s == 1: tdata.data = messager.encodeMsg(messager.MSG_CHECKPOINT, 2, state) sock.sendto(bytes(tdata.data, 'utf-8'), (tdata.c[0], tdata.c[1])) elif tdata.s == 2: print("after checkpoint state is : ", tdata.c) else: tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state = messager.decodeUpdateState( tdata.c) print("checkpoint state is : ", tdata.state) state = tdata.state for i in range(len(log)): if log[i][0] == tdata.cid and log[i][2] == tdata.seq: break log = log[i:] print("obtain useful log:") for i in log: print(i) for i in log: state = i[4] logging.info( "client: %i ,server: %i, seq: %i, time: %s,state: %s", i[0], i[1], i[2], i[3], i[4]) log = [] quiet_lock = False if tdata.t == messager.MSG_LFD_SERVER_INIT: print('recv lfd init') sudp.sendto(tdata.data, tdata.addr) # Heartbeating if tdata.t == messager.MSG_PING: if sid == messager.decodeHeartbeat(tdata.c): tdata.data = messager.encodeMsg(messager.MSG_BEATING, tdata.s, tdata.c) sock.sendto(bytes(tdata.data, 'utf-8'), tdata.addr) # Should Never happen, but just in case else: tdata.data = messager.encodeMsg(messager.MSG_ERROR, tdata.s, tdata.c) sock.sendto(bytes(tdata.data, 'utf-8'), tdata.addr) elif tdata.t == messager.MSG_ACTIVE: with __lock: ACTIVE = True logging.info("Become active") elif tdata.t == messager.MSG_QUIET: with __lock: quiet_lock = True logging.info("Become quiet") elif tdata.t == messager.MSG_CHECK_REMIND: with __lock: tosid = int(tdata.c) print("sid:", tosid) if tosid == 1: sendToCheck = 10087 if tosid == 2: sendToCheck = 10088 if tosid == 3: sendToCheck = 10089 BLOCK_FLAG = True check_state = state print("checkpointing") print("send checkpoint. state:", check_state) #logging.info("%d %d", num_blocked, num_client) while num_blocked < num_client: continue #logging.info("%d %d", num_blocked, num_client) with __lock: tdata.c = messager.encodeUpdateState(log[0][0], log[0][1], log[0][2], log[0][3], check_state) msg = messager.encodeMsg(messager.MSG_CHECKPOINT, 0, tdata.c) sock.sendto(msg.encode('utf-8'), ("localhost", sendToCheck)) BLOCK_FLAG = False log = [] num_client = 0
def handleTCP(data): global state global log global num_client global num_blocked sock = data[0] tdata = threading.local() tdata.cid = 0 recovered = False with __lock: num_client += 1 while True: tdata.data = sock.recv(buffSize) if not tdata.data: # logging.info("CID: %i exit (0 is UNKNOWN)", tdata.cid) with __lock: num_client -= 1 sock.close() return tdata.t, tdata.s, tdata.c = messager.decodeMsg( tdata.data.decode('utf-8')) # Update state, may be better to have a dedicate function if tdata.t == messager.MSG_UPDATESTATE: # cid, seq, state tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state = messager.decodeUpdateState( tdata.c) item = [tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state] with __lock: if ACTIVE == False: logging.error("NOT ACTIVE") log.append([ tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state ]) print("log:") for i in log: print(i) tdata.c = "SERVER NOT ACTIVE" tdata.data = messager.encodeMsg(messager.MSG_ERROR, len(tdata.c), tdata.c) sock.send(bytes(tdata.data, 'utf-8')) #with __lock: #num_client -= 1 #sock.close() continue with __lock: # Send if quiet_lock: logging.info("NOT ACTIVE") log.append([ tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state ]) print("log:") for i in log: print(i) tdata.data = messager.encodeMsg(messager.MSG_UPDATESTATE, 0, tdata.c) sock.send(bytes(tdata.data, 'utf-8')) continue __lock.acquire() # Racing Condition state = tdata.state logging.info("client: %i ,server: %i, seq: %i, time: %s,state: %s", tdata.cid, tdata.sid, tdata.seq, tdata.ts, state) if BLOCK_FLAG: num_blocked += 1 log.append( [tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state]) recovered = True __lock.release() while BLOCK_FLAG: # Busy wait for very short period continue with __lock: tdata.data = messager.encodeMsg(messager.MSG_UPDATESTATE, 0, tdata.c) sock.send(tdata.data.encode('utf-8')) if recovered: time.sleep(0.2) recovered = False
def handleUDP(sock): while True: data, addr = sock.recvfrom(buffSize) sock.sendto(data, (ip_repmgn, port_repmgn)) t, s, c = messager.decodeMsg(data.decode('utf-8')) if (t == messager.MSG_INIT): role, ID = messager.decodeInit(c) factive = False idaddr = {"id": ID, "addr": addr} if online(idaddr): logging.error("Already login") continue if (role == messager.MSG_ROLE_SERVER): if _primary: if ID == 1: msg = messager.encodeMsg(messager.MSG_CHECKPOINT, 1, ("localhost", 10087)) elif ID == 2: msg = messager.encodeMsg(messager.MSG_CHECKPOINT, 1, ("localhost", 10088)) elif ID == 3: msg = messager.encodeMsg(messager.MSG_CHECKPOINT, 1, ("localhost", 10089)) if int(_primary[0]['id']) == 1: sock.sendto(bytes(msg, 'utf-8'), ('localhost', 10087)) elif int(_primary[0]['id']) == 2: sock.sendto(bytes(msg, 'utf-8'), ('localhost', 10088)) elif int(_primary[0]['id']) == 3: sock.sendto(bytes(msg, 'utf-8'), ('localhost', 10089)) _backup.append(idaddr) else: _primary.append(idaddr) factive = True elif (role == messager.MSG_ROLE_LFD): _lfd.append(idaddr) msg = messager.encodeMsg(messager.MSG_SUCCESS, 1, "") sock.sendto(bytes(msg, 'utf-8'), addr) logging.info('id: %d login', ID) print("membership:") print("Current primary:") for p in _primary: print(p) print("Current backup:") for b in _backup: print(b) if factive: msg = messager.encodeMsg(messager.MSG_ACTIVE, 1, "") sock.sendto(bytes(msg, 'utf-8'), addr) logging.info('id: %d activing', ID) if _primary: firstPrimaryMessage = messager.encodeMsg( messager.MSG_INIT_PRIMARY, 1, "") if int(_primary[0]['id']) == 1: sock.sendto(bytes(firstPrimaryMessage, 'utf-8'), ('localhost', 10087)) if int(_primary[0]['id']) == 2: sock.sendto(bytes(firstPrimaryMessage, 'utf-8'), ('localhost', 10088)) if int(_primary[0]['id']) == 3: sock.sendto(bytes(firstPrimaryMessage, 'utf-8'), ('localhost', 10089)) #server down with lfd message if (t == messager.MSG_FAULT): role, ID = messager.decodeInit(c) if (role == messager.MSG_ROLE_LFD): for s in _primary: if s["id"] == ID: _primary.remove(s) # primary done if _backup: # if there is still backup alive _primary.append( _backup[0] ) #wake up one of the backup and make it primary _backup.pop(0) msg = messager.encodeMsg(messager.MSG_WAKE, 1, '') if int(_primary[0]['id']) == 1: sock.sendto(msg.encode("utf-8"), ("localhost", 10087)) elif int(_primary[0]['id']) == 2: sock.sendto(msg.encode("utf-8"), ("localhost", 10088)) elif int(_primary[0]['id']) == 3: sock.sendto(msg.encode("utf-8"), ("localhost", 10089)) break for b in _backup: if b["id"] == ID: _backup.remove(b) break ### ## c = messager.encodeInit(messager.MSG_ROLE_REPMGN, ID) ### print("server down. ID:", ID) print("membership:") print("Current primary:") for p in _primary: print(p) print("Current backup:") for b in _backup: print(b)
def handleUDP(data): global ACTIVE global primaryFlag global state global Checkpoint_turn global Log global state sock = data tdata = threading.local() while True: try: tdata.data, tdata.addr = sock.recvfrom(buffSize) except socket.timeout: exit(0) tdata.t, tdata.s, tdata.c = messager.decodeMsg( tdata.data.decode('utf-8')) # intial primary if tdata.t == messager.MSG_INIT_PRIMARY: primaryFlag = True print("I am primary!") # checkpointing sent if it is primary # wake up to be primary and recover if tdata.t == messager.MSG_WAKE: # recover with __lock: print("i am waking up") primaryFlag = True print( "Recovery start. Prune log and process unreplied requests") if Log == []: print("Recovery done. Current state:", state) #initial checkpoint if tdata.t == messager.MSG_CHECKPOINT and primaryFlag == True: with __lock: msg = messager.encodeMsg(messager.MSG_CHECKPOINT, len(state) + 1, state) sock.sendto(bytes(msg, 'utf-8'), (tdata.c[0], tdata.c[1])) # recv checkpoint it is a backup if tdata.t == messager.MSG_CHECKPOINT and primaryFlag == False: with __lock: state = tdata.c Log = [] print('After checkpointing, current state is: ', state) if tdata.t == messager.MSG_LFD_SERVER_INIT: print('recv lfd init') sudp.sendto(tdata.data, tdata.addr) # Heartbeating if tdata.t == messager.MSG_PING: if sid == messager.decodeHeartbeat(tdata.c): tdata.data = messager.encodeMsg(messager.MSG_BEATING, tdata.s, tdata.c) sock.sendto(bytes(tdata.data, 'utf-8'), tdata.addr) # Should Never happen, but just in case else: tdata.data = messager.encodeMsg(messager.MSG_ERROR, tdata.s, tdata.c) sock.sendto(bytes(tdata.data, 'utf-8'), tdata.addr) elif tdata.t == messager.MSG_ACTIVE: with __lock: ACTIVE = True logging.info("Become active") exit(0)
def handleTCP(data, udp): global state global Checkpoint_turn global Log sock = data[0] tdata = threading.local() tdata.cid = 0 checkpoint_count = 0 while True: tdata.data = sock.recv(buffSize) if not tdata.data: logging.info("CID: %i exit (0 is UNKNOWN)", tdata.cid) sock.close() return tdata.t, tdata.s, tdata.c = messager.decodeMsg( tdata.data.decode('utf-8')) # Update state, may be better to have a dedicate function if tdata.t == messager.MSG_UPDATESTATE: # Client side do not have a way to handle this at this point if ACTIVE == False: logging.error("NOT ACTIVE") tdata.c = "SERVER NOT ACTIVE" tdata.data = messager.encodeMsg(messager.MSG_ERROR, len(tdata.c), tdata.c) # sock.send(bytes(tdata.data, 'utf-8')) sock.close() exit(0) # cid, seq, state tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state = messager.decodeUpdateState( tdata.c) __lock.acquire() # Racing Condition # state = tdata.state # logging.info("client: %i ,server: %i, seq: %i, state: %s", tdata.cid, tdata.sid,tdata.seq, state) # sock.send(tdata.c.encode('utf-8')) # Checkpoint_turn = True ##checkpoint_count += 1 if primaryFlag == True: state = tdata.state logging.info( "client: %i ,server: %i, seq: %i, time: %s, state: %s", tdata.cid, tdata.sid, tdata.seq, tdata.ts, state) tdata.data = messager.encodeMsg(messager.MSG_UPDATESTATE, 0, tdata.c) sock.send(tdata.data.encode('utf-8')) Checkpoint_turn += 1 else: logging.info("backup is sleeping") tdata.c = messager.encodeUpdateState(tdata.cid, tdata.sid, tdata.seq, tdata.ts, "backup is sleeping") tdata.data = messager.encodeMsg(messager.MSG_UPDATESTATE, 0, tdata.c) sock.send(tdata.data.encode('utf-8')) Log.append([ tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state, 0 ]) print("log:") for i in Log: print(i[:5]) __lock.release() # recovery request elif tdata.t == messager.MSG_RECOVERY: #print("recovering") # cid, seq, state tdata.cid, tdata.sid, tdata.seq, tdata.ts, tdata.state = messager.decodeUpdateState( tdata.c) if primaryFlag == True: while True: #process log flag = False for i in range(len(Log)): if Log[i][0] == tdata.cid and Log[i][2] == tdata.seq: #current first if i == 0 or Log[i - 1][5] == 0 or Log[i - 1][5] == 2: flag = True break else: break if flag: break time.sleep(0.2) with __lock: #process log for i in range(len(Log)): if Log[i][0] == tdata.cid and Log[i][2] == tdata.seq: state = Log[i][4] Log[i][5] = 2 logging.info( "client: %i ,server: %i, seq: %i, time: %s, state: %s", Log[i][0], Log[i][1], Log[i][2], Log[i][3], state) tdata.c = messager.encodeUpdateState( Log[i][0], Log[i][1], Log[i][2], Log[i][3], state) tdata.data = messager.encodeMsg( messager.MSG_UPDATESTATE, 0, tdata.c) sock.send(tdata.data.encode('utf-8')) Checkpoint_turn += 1 #prune log if i == (len(Log) - 1): Log = [] print("Recovery done. Current state:", state) break elif Log[i][5] == 0: state = Log[i][4] Log[i][5] = 2 else: with __lock: tdata.c = messager.encodeUpdateState( tdata.cid, tdata.sid, tdata.seq, tdata.ts, "backup is sleeping") tdata.data = messager.encodeMsg(messager.MSG_UPDATESTATE, 0, tdata.c) sock.send(tdata.data.encode('utf-8')) #mark as unreplied for i in range(len(Log)): if Log[i][0] == tdata.cid and Log[i][2] == tdata.seq: Log[i][5] = 1 # send checkpoint out if it is the primary and meets the frequency if primaryFlag and (Checkpoint_turn >= checkpoint_frequency): with __lock: checkpoint = messager.encodeMsg(messager.MSG_CHECKPOINT, len(state) + 1, state) sendCheck(udp, checkpoint) Checkpoint_turn = 0
def handleUDP(sock): while True: data, addr = sock.recvfrom(buffSize) t, s, c = messager.decodeMsg(data.decode('utf-8')) if (t == messager.MSG_INIT): role, ID = messager.decodeInit(c) factive = False idaddr = {"id": ID, "addr": addr} if online(idaddr): logging.error("Already login") continue if (role == messager.MSG_ROLE_SERVER): if _primary: _backup.append(idaddr) else: _primary.append(idaddr) factive = True elif (role == messager.MSG_ROLE_LFD): _lfd.append(idaddr) msg = messager.encodeMsg(messager.MSG_SUCCESS, 1, "") logging.info('id: %d login', ID) print("membership:") print("Current primary:") for p in _primary: print(p) print("Current backup:") for b in _backup: print(b) if factive: msg = messager.encodeMsg(messager.MSG_ACTIVE, 1, "") logging.info('id: %d activing', ID) # server down with lfd message if (t == messager.MSG_FAULT): role, ID = messager.decodeInit(c) if (role == messager.MSG_ROLE_LFD): for s in _primary: if s["id"] == ID: _primary.remove(s) # primary done if _backup: # if there is still backup alive _primary.append( _backup[0] ) # wake up one of the backup and make it primary _backup.pop(0) msg = messager.encodeMsg(messager.MSG_WAKE, 1, '') break for b in _backup: if b["id"] == ID: _backup.remove(b) break ### ## c = messager.encodeInit(messager.MSG_ROLE_REPMGN, ID) ### print("server down. ID:", ID) print("membership:") print("Current primary:") for p in _primary: print(p) print("Current backup:") for b in _backup: print(b)
def stateUpdate(stcp): global seq global recovering global resend # Currently for easy debug -- Later will be feeded by script if recovering: state = resend print("send recover", state) else: state = messager.inputState() # send msg for i in stcp: # check connection if i[2]: timestamp = str(datetime.now()) update_str = messager.encodeUpdateState(cid, i[0], seq, timestamp, state) if recovering: msg = messager.encodeMsg(messager.MSG_RECOVERY, len(update_str) + 1, update_str) else: msg = messager.encodeMsg(messager.MSG_UPDATESTATE, len(update_str) + 1, update_str) i[1].send(bytes(msg, 'utf-8')) if not recovering: print("msg send to server id:", i[0], state) else: # reconnect try: i[1] = socket.socket(socket.AF_INET, socket.SOCK_STREAM) i[1].connect(server_address[i[0] - 1]) i[2] = True timestamp = str(datetime.now()) update_str = messager.encodeUpdateState( cid, i[0], seq, timestamp, state) if recovering: msg = messager.encodeMsg(messager.MSG_RECOVERY, len(update_str) + 1, update_str) else: msg = messager.encodeMsg(messager.MSG_UPDATESTATE, len(update_str) + 1, update_str) i[1].send(bytes(msg, 'utf-8')) if not recovering: print("msg send to server id:", i[0], state) except socket.error: continue # duplicate detector recovering = True for i in range(len(stcp)): if stcp[i][2]: try: data = stcp[i][1].recv(buffSize) # error if not data: stcp[i][1].close() stcp[i][2] = False if stcp[i][3] == 'p': recovering = True stcp[i][3] = 'b' continue i_type, i_len, i_c = messager.decodeMsg(data.decode('utf-8')) if i_type == messager.MSG_UPDATESTATE: i_cid, i_sid, i_seq, i_timestamp, i_state = messager.decodeUpdateState( i_c) # only implementaiton on reply if i_state == "backup is sleeping": continue if i_seq >= seq: print(messager.decodeUpdateState(i_c)) stcp[i][3] = 'p' recovering = False seq += 1 else: print("duplicate reply detected:") print(messager.decodeUpdateState(i_c)) # error except socket.error: stcp[i][1].close() stcp[i][2] = False if stcp[i][3] == 'p': recovering = True stcp[i][3] = 'b' continue if recovering: resend = state time.sleep(1) return
def handle_gfd_ping(): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.bind(('localhost', port_lfd)) tdata = threading.local() while True: tdata.data, tdata.addr = sock.recvfrom(buffSize) sock.sendto(tdata.data, tdata.addr) if __name__ == "__main__": sudp = init() logging.info("timeout: %d, interval: %d", timeout, interval) tudp2 = threading.Thread(target=handle_gfd_ping, args=(), daemon=True) tudp2.start() ## keep sending message to server until get responses, then break while True: msg = messager.encodeMsg(messager.MSG_LFD_SERVER_INIT, 0, "") sudp.sendto(msg.encode('utf-8'), ((host, port))) try: data, addr = sudp.recvfrom(buffSize) break except socket.timeout: continue while True: ping(sudp)
def stateUpdate(stcp): global seq # Currently for easy debug -- Later will be feeded by script state = messager.inputState() # send msg for i in stcp: # check connection if i[2]: timestamp = str(datetime.now()) update_str = messager.encodeUpdateState(cid, i[0], seq, timestamp, state) msg = messager.encodeMsg(messager.MSG_UPDATESTATE, len(update_str) + 1, update_str) i[1].send(bytes(msg, 'utf-8')) print("msg send to server id:", i[0], "msg:", state) else: # reconnect try: i[1] = socket.socket(socket.AF_INET, socket.SOCK_STREAM) i[1].connect(server_address[i[0] - 1]) i[2] = True timestamp = str(datetime.now()) update_str = messager.encodeUpdateState( cid, i[0], seq, timestamp, state) msg = messager.encodeMsg(messager.MSG_UPDATESTATE, len(update_str) + 1, update_str) i[1].send(bytes(msg, 'utf-8')) print("msg send to server id:", i[0], "msg:", state) except socket.error: print("not add ", server_address[i[0] - 1]) continue # duplicate detector for i in range(len(stcp)): if stcp[i][2]: try: data = stcp[i][1].recv(buffSize) # error if not data: stcp[i][1].close() stcp[i][2] = False continue i_type, i_len, i_c = messager.decodeMsg(data.decode('utf-8')) if i_type == messager.MSG_UPDATESTATE: i_cid, i_sid, i_seq, i_timestamp, i_state = messager.decodeUpdateState( i_c) # only implementaiton on reply if i_state == "backup is sleeping": continue if i_seq >= seq: print("Reply:", messager.decodeUpdateState(i_c)) seq += 1 else: print("Duplicate reply detected:") print(messager.decodeUpdateState(i_c)) elif i_type == messager.MSG_ERROR: if i_c == "SERVER NOT ACTIVE": continue elif i_c == "SERVER QUIESCENCE": print("quiet") continue # error except socket.error: stcp[i][1].close() stcp[i][2] = False continue return
def handleUdp(sock): while True: data, addr = sock.recvfrom(buffSize) print("msg recv") t, s, c = messager.decodeMsg(data.decode('utf-8')) if (t == messager.MSG_INIT): role, ID = messager.decodeInit(c) factive = False idaddr = {"id": ID, "addr": addr} if online(idaddr): logging.error("Already login") continue if (role == messager.MSG_ROLE_SERVER): if (len(_active) > 3): _replica.append(idaddr) else: _active.append(idaddr) factive = True elif (role == messager.MSG_ROLE_LFD): _lfd.append(idaddr) msg = messager.encodeMsg(messager.MSG_SUCCESS, 1, "") logging.info('id: %d login', ID) print("membership:") for s in _active: print("server id:", s["id"]) if factive: msg = messager.encodeMsg(messager.MSG_ACTIVE, 1, "") logging.info('id: %d activing', ID) print() ## recovery if (t == messager.MSG_RECOVERY): role, ID = messager.decodeInit(c) factive = False idaddr = {"id": ID, "addr": addr} if online(idaddr): logging.error("Already login") continue if (role == messager.MSG_ROLE_SERVER): if (len(_active) > 3): _replica.append(idaddr) else: _active.append(idaddr) factive = True elif (role == messager.MSG_ROLE_LFD): _lfd.append(idaddr) msg = messager.encodeMsg(messager.MSG_SUCCESS, 1, "") logging.info('id: %d login', ID) print("membership:") for s in _active: print("server id:", s["id"]) if factive: msg = messager.encodeMsg(messager.MSG_ACTIVE, 1, "") logging.info('id: %d activing', ID) print() if _active[0]['id'] == 1: checkSendFromPort = 10087 if _active[0]['id'] == 2: checkSendFromPort = 10088 if _active[0]['id'] == 3: checkSendFromPort = 10089 print("when recovery rempn active list:", _active) msg = messager.encodeMsg(messager.MSG_CHECK_REMIND, 1, _active[-1]['id']) # server down with lfd message if (t == messager.MSG_FAULT): role, ID = messager.decodeInit(c) if (role == messager.MSG_ROLE_LFD): for s in _active: if s["id"] == ID: _active.remove(s) break print("server down. ID:", ID) print("membership:") for s in _active: print("server id:", s["id"]) print()
def handleUDP(sock): while True: data, addr = sock.recvfrom(buffSize) sock.sendto(data, ((ip_repmgn, port_repmgn))) t, s, c = messager.decodeMsg(data.decode('utf-8')) if (t == messager.MSG_INIT): role, ID = messager.decodeInit(c) factive = False idaddr = {"id": ID, "addr": addr} if online(idaddr): logging.error("Already login") continue if (role == messager.MSG_ROLE_SERVER): if (len(_active) > 3): _replica.append(idaddr) #initial checkpoint elif _active != []: if ID == 1: msg = messager.encodeMsg(messager.MSG_CHECKPOINT, 1, ("localhost", 10087)) elif ID == 2: msg = messager.encodeMsg(messager.MSG_CHECKPOINT, 1, ("localhost", 10088)) elif ID == 3: msg = messager.encodeMsg(messager.MSG_CHECKPOINT, 1, ("localhost", 10089)) sock.sendto(bytes(msg, 'utf-8'), _active[0]["addr"]) _active.append(idaddr) factive = True else: _active.append(idaddr) factive = True elif (role == messager.MSG_ROLE_LFD): _lfd.append(idaddr) msg = messager.encodeMsg(messager.MSG_SUCCESS, 1, "") sock.sendto(bytes(msg, 'utf-8'), addr) logging.info('id: %d login', ID) print("membership:") for s in _active: print("server id:", s["id"]) if factive: msg = messager.encodeMsg(messager.MSG_ACTIVE, 1, "") sock.sendto(bytes(msg, 'utf-8'), addr) logging.info('id: %d activing', ID) print() ## recovery if (t == messager.MSG_RECOVERY): role, ID = messager.decodeInit(c) factive = False idaddr = {"id": ID, "addr": addr} print("recoveryhhhhhhhhhhhhhh:", idaddr) if online(idaddr): logging.error("Already login") continue if (role == messager.MSG_ROLE_SERVER): if (len(_active) > 3): _replica.append(idaddr) else: _active.append(idaddr) factive = True elif (role == messager.MSG_ROLE_LFD): _lfd.append(idaddr) # msg = messager.encodeMsg(messager.MSG_SUCCESS, 1, "") # sock.sendto(bytes(msg, 'utf-8'), addr) msg_lock = messager.encodeMsg(messager.MSG_QUIET, 1, "") sock.sendto(msg_lock.encode('utf-8'), addr) logging.info('id: %d login', ID) print("membership:") for s in _active: print("server id:", s["id"]) if factive: msg = messager.encodeMsg(messager.MSG_ACTIVE, 1, "") sock.sendto(bytes(msg, 'utf-8'), addr) logging.info('id: %d activing', ID) print() if _active[0]['id'] == 1: checkSendFromPort = 10087 if _active[0]['id'] == 2: checkSendFromPort = 10088 if _active[0]['id'] == 3: checkSendFromPort = 10089 print("when recovery rempn active list:", _active) msg = messager.encodeMsg(messager.MSG_CHECK_REMIND, 1, _active[-1]['id']) sock.sendto(msg.encode('utf-8'), ("localhost", checkSendFromPort)) #server down with lfd message if (t == messager.MSG_FAULT): role, ID = messager.decodeInit(c) if (role == messager.MSG_ROLE_LFD): for s in _active: if s["id"] == ID: _active.remove(s) break print("server down. ID:", ID) print("membership:") for s in _active: print("server id:", s["id"]) print()