def logout(self): msg = {"type": "CLIENT_LOGOUT", "username": self.username} s = socket.socket() # s.bind(('', 9090)) ip = MDS_IPs["primary"]["ip"] port = MDS_IPs["primary"]["port"] try: s.connect((ip, port)) _send_msg(s, msg) response = _wait_recv_msg(s, MSG_SIZE) if response["status"] == "SUCCESS": # here check response from mds self.window.destroy() print(response["msg"]) elif response["status"] == "ERROR": print(response["msg"]) except Exception as e: print("[ERROR] login failed") print(e) finally: global LoginPage s.close() LoginPage()
def heartbeat_protocol(soc, live_osd): # Establish connection with client. c, addr = soc.accept() print(f"\nGot connection from {addr}") n = os.fork() if n == 0: print(F"Inside child process {os.getpid()}") msg = _recv_msg(c, MSG_SIZE) print(msg) if msg == None: print(f"Didn't receive data! [Timeout] {addr}") elif msg["type"] == "ALIVE": res = {"type": "ACK"} _send_msg(c, res) elif msg["type"] == "FAIL": res = {"type": "ACK"} _send_msg(c, res) gossip(c, msg, live_osd) c.close() print(f"Exiting from pid {os.getpid()} ..\n") os._exit(1) return
def report_monitor(node_ip, osd_id): flag = 0 #Will call monitor to state about the down node soc = socket.socket() soc.settimeout(5) print ("Socket successfully created for Recovery: Primary") monitor_1 = monitor_ip["primary"] try : soc.connect((monitor_1["ip"], monitor_1["port"])) # soc.timeout(None) print(f"Connecting Primary monitor...") res = {"type": "FAIL", "ip" : node_ip, "osd_id" : osd_id} _send_msg(soc, res) msg = _wait_recv_msg(soc, MSG_SIZE) print(msg) if msg == None: pass elif msg["type"] == "ACK": soc.close() return except Exception as e: print(e) print("Didn't Connect! [Timeout] Primary Monitor is Down") soc.close() soc = socket.socket() soc.settimeout(5) print ("Socket successfully created for Recovery: Backup") monitor_2 = monitor_ip["backup"] try : soc.connect((monitor_2["ip"], monitor_2["port"])) soc.settimeout(None) print(f"Connecting Backup monitor...") res = {"type": "FAIL", "ip" : node_ip, "osd_id" : osd_id} _send_msg(soc, res) msg = _wait_recv_msg(soc, MSG_SIZE) print(msg) if msg == None: pass elif msg["type"] == "ACK": return except: print("MAY GOD HELP US!! WE ARE DOOMED\n\n") soc.close()
def recv_primary_update(): recv_primary_update_socket = socket.socket() print("recv primary update socket successfully created") recv_primary_update_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # reserve a port on your computer port = RECV_PRIMARY_UPDATE_PORT # Next bind to the port # we have not entered any ip in the ip field # instead we have inputted an empty string # this makes the server listen to requests # coming from other computers on the network recv_primary_update_socket.bind(('', port)) print("primary update socket bound to %s" % (port)) # put the socket into listening mode recv_primary_update_socket.listen(5) print("primary update socket is listening") # a forever loop until we interrupt it or # an error occurs while True: # Establish connection with osd c, addr = recv_primary_update_socket.accept() print('Got connection from', addr) # recv the update update = _recv_msg(c, 1024) print(update) if update["update_type"] == "hash_table": for i in range(len(update["pg_or_osd_ids_list"])): hashtable[update["pg_or_osd_ids_list"] [i]] = update["osd_list"][i] else: for i in range(len(update["pg_or_osd_ids_list"])): cluster_topology[update["pg_or_osd_ids_list"] [i]] = update["osd_list"][i] hashtable_file = open('hashtable', 'wb') hashtable_dump = pickle.dumps(hashtable) hashtable_file.write(hashtable_dump) hashtable_file.close() cluster_topology_file = open('cluster_topology', 'wb') cluster_topology_dump = pickle.dumps(cluster_topology) cluster_topology_file.write(cluster_topology_dump) cluster_topology_file.close() msg = {"status": "SUCCESS"} _send_msg(c, msg) # send the acknowledgement c.close() recv_primary_update_socket.close()
def recv_gossip(): while True: time.sleep(10) # Wait for 10 sec to run this protocol i = 0 for i in range(4): curr_osd = "osd_id" + str(i + 1) if curr_osd != STORAGE_ID: node_ip = storage_ip[curr_osd]["ip"] port = storage_ip[curr_osd]["port"] soc = socket.socket() soc.settimeout(5) print( f"\n\nSocket successfully created for Gossip with osd {curr_osd}" ) try: soc.connect((node_ip, port)) soc.settimeout(None) print( f"Connecting {node_ip} storage node number {curr_osd} port {port}" ) msg = {"type": "ALIVE"} _send_msg(soc, msg) rec = _wait_recv_msg(soc, MSG_SIZE) print(msg) if rec == None: print( f"Didn't receive data to Storage {curr_osd} ip {node_ip}! [Timeout] " ) report_monitor(node_ip, curr_osd) elif rec["type"] != "ACK": report_monitor(node_ip, curr_osd) except: print( f"Didn't Connect to Storage {curr_osd} ip {node_ip}! [Timeout]" ) report_monitor(node_ip, curr_osd) soc.close() time.sleep(3)
def login(): global user, passwd, login_screen # send credentials to mds and wait for response client_id = "C200" # received from mds print("username:: ", user.get()) # print("password:: ", passwd.get()) msg = { "type": "CLIENT_LOGIN", "username": user.get(), "password": passwd.get() } s = socket.socket() ip = MDS_IPs["primary"]["ip"] port = MDS_IPs["primary"]["port"] # print(s.gethostname()) # s.bind(('', 9090)) try: s.connect((ip, port)) _send_msg(s, msg) response = _wait_recv_msg(s, MSG_SIZE) s.close() if response["status"] == "SUCCESS": # here check response from mds print(response["msg"]) login_screen.destroy() client = Client(response["tree"]) elif response["status"] == "ERROR": # print(response["msg"]) _popup("Login Failed", response["msg"]) except Exception as e: s.close() print("[ERROR] login failed") print(e) _popup("Login Failed", str(e)) finally: print("Exiting login..")
def dispatch_primary(self): while True: # Establish connection with client. print("waiting for messages..") c, addr = self.mds_socket.accept() print('Got connection from', addr) msg = {} try: msg = _recv_msg(c, MSG_SIZE) except Exception as e: print(e) c.close() continue res = {} print(msg) if msg["type"] == "CLIENT_LOGIN": res = self._login_handle(msg) print(res["msg"]) elif msg["type"] == "CLIENT_LOGOUT": res = self._logout_handle(msg) print(res["msg"]) elif msg["type"] == "WRITE_RESPONSE": res = self.update_handle(msg) print(res["msg"]) elif msg["type"] == "WRITE_QUERY": res = self._client_query_handle(msg) print(res["msg"]) elif msg["type"] == "RECOVERY": res = self._recovery_handle() print(res["msg"]) try: _send_msg(c, res) except Exception as e: print(e) finally: c.close()
def update_backup_monitor(update_type, pg_or_osd_ids_list, osd_list): primary_update_socket = socket.socket() print ("primary update socket successfully created") try: primary_update_socket.connect((MONITOR_IPs["backup"], RECV_PRIMARY_UPDATE_PORT)) msg = {"update_type": update_type, "pg_or_osd_ids_list": pg_or_osd_ids_list, \ "osd_list": osd_list} _send_msg(primary_update_socket, msg) response = _wait_recv_msg(primary_update_socket, MSG_SIZE) primary_update_socket.close() if response["status"] == "SUCCESS": print("written to monitor backup successfully") else: print("write to monitor backup failed") except Exception as e: print(e) primary_update_socket.close()
def _update_primary(self, update_type, update): print("writing to backup..") s = socket.socket() # send backup mds to make data consistent ip = MDS_IPs["backup"]["ip"] port = MDS_IPs["backup"]["port"] try: s.connect((ip, port)) msg = {"type": "UPD", "update_type": update_type, "update": update} # d_msg = pickle.dumps(msg) _send_msg(s, msg) #s.send(d_msg) response = _wait_recv_msg(s, 1024) if response["status"] == "SUCCESS": if update_type == "ADD_LOGIN_USER": self.logged_in.append(update["user"]) self._write_logged_in() elif update_type == "REMOVE_LOGIN_USER": self.logged_in.remove(update["user"]) self._write_logged_in() print("Successfully updated on Backup") return 0 elif response["status"] == "ERROR": print(response["msg"]) print("Couldn't update on Backup") return -1 except Exception as e: print(e) print("Couldn't update on Backup") return -2 finally: s.close() print("writing to backup completed.")
def _read(self, pg_id): s = socket.socket() # send monitor to ask for OSD details ip = MONITOR_IPs["primary"] port = CLIENT_REQ_PORT s.connect((ip, port)) msg = {"type": "READ", "pg_id": pg_id} # d_msg = pickle.dumps(msg) _send_msg(s, msg) #s.send(d_msg) response = _wait_recv_msg(s, 1024) osd_addr = response["addrs"][0] # print(osd_ips) s.close() # print(osd_ips[0][0], osd_ips[0][1]) # write on OSD s = socket.socket() s.connect(osd_addr) data_msg = {"type": "READ", "pg_id": pg_id} _send_msg(s, data_msg) osd_response = _wait_recv_msg(s, 1024) # print(osd_response) # print(osd_response["pg_id"] == pg_id) # print(osd_response["res"] == "SUCCESS") if osd_response["pg_id"] == pg_id and osd_response["res"] == "SUCCESS": s.close() print("PG received from OSD writing on disk") return 0, osd_response["pg"] else: s.close() print("Error - PG not received from OSD") return -2, None
def send_replicate_request(pg_id, master_osd, clone_osd): soc = socket.socket() soc.settimeout(5) print( f"Socket successfully created for replicating {pg_id} from master {master_osd} to clone {clone_osd}" ) # reserve a port on your computer in our ip_add = storage_ip[master_osd]["ip"] port = storage_ip[master_osd]["port"] + 10 flag = -1 try: soc.connect((ip_add, port)) soc.settimeout(None) print(f"Connecting with {master_osd} on port {port}...") res = {"type": "REPLICATE", "pg_id": pg_id, "osd_id": clone_osd} _send_msg(soc, res) print("Message send for replication ") # time.sleep(5) msg = _wait_recv_msg(soc, MSG_SIZE) print(msg) if msg == None: flag = 0 elif msg["type"] == "ACK": flag = 1 except Exception as e: print(e) print( f"Didn't Connect! [Timeout] master {master_osd} is down, port {port}" ) soc.close() return flag
def send_heartbeat(): #This will check for incoming messages #from other nodes and reply s = socket.socket() print("Socket successfully created for Heartbeat") port = storage_ip[STORAGE_ID]["port"] s.bind(('', port)) print("Socket binded to %s" % (port)) # put the socket into listening mode s.listen(5) while True: # Establish connection with client. c, addr = s.accept() print(f"\nGot connection from {addr}") n = os.fork() if n == 0: print(F"Inside child process {os.getpid()}") msg = _recv_msg(c, MSG_SIZE) print(msg) if msg == None: print(f"Didn't receive data from ip {addr}! [Timeout] ") report_monitor(addr, None) elif msg["type"] == "ALIVE": res = {"type": "ACK"} _send_msg(c, res) c.close() print(f"Exiting from pid {os.getpid()} ..\n\n") os._exit(1)
else: ip = MDS_IPs["primary"]["ip"] port = MDS_IPs["primary"]["port"] print("receiving data..") s = socket.socket() try: s.connect((ip, port)) msg = {"type":"RECOVERY"} # d_msg = pickle.dumps(msg) _send_msg(s, msg) #s.send(d_msg) response = _wait_recv_msg(s, 1024) if response["status"] == "SUCCESS": trees = response["trees"] logged_in = response["logged_in"] # user_list = response["user_list"] for tree in trees: file = open("./tree/"+tree["username"], 'wb') obj_b = pickle.dumps(tree) file.write(obj_b) file.close()
def recv_client_reqs(): global cluster_topology, hashtable recv_client_reqs_socket = socket.socket() print ("client req listener socket successfully created") recv_client_reqs_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # reserve a port on your computer port = CLIENT_REQ_PORT # Next bind to the port # we have not entered any ip in the ip field # instead we have inputted an empty string # this makes the server listen to requests # coming from other computers on the network recv_client_reqs_socket.bind(('', port)) print ("client req listener socket bound to %s" %(port)) # put the socket into listening mode recv_client_reqs_socket.listen(5) print ("client req listener socket is listening") # a forever loop until we interrupt it or # an error occurs while True: # Establish connection with client. c, addr = recv_client_reqs_socket.accept() print ('Got connection from', addr) # recv the pg_id, size req = _recv_msg(c, 1024) if(req["type"] == "WRITE"): pg_id = req["pg_id"] size = req["size"] print(size) hashtable[pg_id] = [] i = 0 for osd_id in cluster_topology: if cluster_topology[osd_id]["free_space"] > size and cluster_topology[osd_id]["status"] == 0: hashtable[pg_id].append([osd_id, 0]) i = i+1 if(i>2): break if i < 3: print("less than two osds are free/alive") response = {"status":"ERROR", "msg": "sufficent storage not available"} _send_msg(c, response) c.close() continue osd_ids = [osd[0] for osd in hashtable[pg_id]] addrs = {} for osd_id in osd_ids: addrs[osd_id] = (cluster_topology[osd_id]["ip"], cluster_topology[osd_id]["port"]) osd_dict = {"osd_ids": osd_ids, "addrs": addrs} response = {"osd_dict": osd_dict, "status":"SUCCESS", "msg": "written succefully"} if isPrimary: # updating the backup(only hash_table) update_backup_monitor("hash_table", [pg_id], [hashtable[pg_id]]) hashtable_file = open('hashtable', 'wb') hashtable_dump = pickle.dumps(hashtable) hashtable_file.write(hashtable_dump) hashtable_file.close() _send_msg(c, response) elif req["type"] == "READ": pg_id = req["pg_id"] osd_ids = [hashtable[pg_id][i][0] for i in range(3)] addrs = [(cluster_topology[osd_id]["ip"], cluster_topology[osd_id]["port"]) \ for osd_id in osd_ids] osds_dict = {"osd_ids": osd_ids, "addrs": addrs} _send_msg(c, osds_dict) c.close() recv_client_reqs_socket.close()
def replicate_pg(soc): # This will be always true loop that will run in parallel c, addr = soc.accept() print(f"Got connection from {addr} to do the replication") n = os.fork() if n == 0: msg = _recv_msg(c, MSG_SIZE) print(msg) if msg == None: print(f"Didn't receive data! [Timeout] {addr}") msg = {"type": "SEND AGAIN"} _send_msg(c, msg) elif msg["type"] == "REPLICATE": # Can do one thing here # call the func that act as access this pg_id for the client # then call other function that act as send this pg to osd to do a write pg_id = msg["pg_id"] osd_id = msg["osd_id"] file = open("./data/" + pg_id, 'rb') pg_b = file.read() pg = pickle.loads(pg_b) ## Connect to this osd_id with new socket new_soc = socket.socket() print( f"Socket created to send request to SAVE data at OSD {osd_id}") ip_add = storage_ip[osd_id]["ip"] port = storage_ip[osd_id]["port"] + 10 # Remember replication is on normal port + 10 try: new_soc.connect((ip_add, port)) print(f"Connection made with {ip_add} on {port}") msg = {"type": "SAVE", "pg_id": pg_id, "pg": pg} _send_msg(new_soc, msg) print("Msg send to SAVE the data") msg = _wait_recv_msg(new_soc, MSG_SIZE) print("Msg received !") except Exception as e: print(e) if msg == None: res = {"type": "REPLICATION FAIL"} _send_msg(c, res) print("Fail Msg send to the monitor") elif msg["type"] == "ACK": res = {"type": "ACK"} _send_msg(c, res) print("Success Msg send to the monitor") elif msg["type"] == "SAVE": # This will take request from other osd to save some data # This is basic replication strategy pg_id = msg["pg_id"] pg = msg["pg"] try: file = open("./data/" + pg_id, 'wb') print("Replicated data is saved") pg_dump = pickle.dump(pg) file.write(pg_dump) except Exception as e: print(e) msg = {"type": "ACK"} _send_msg(c, msg) print("Write successful..send back Ack to the master osd") else: print("[ERROR] Check the code in replication") c.close() print(f"Exiting from pid {os.getpid()} ..") os._exit(1)
def recv_write_acks(): global hashtable, cluster_topology, MDS_IP, MDS_flags write_ack_socket = socket.socket() print ("write ack socket successfully created") write_ack_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # reserve a port on your computer port = WRITE_ACK_PORT # Next bind to the port # we have not entered any ip in the ip field # instead we have inputted an empty string # this makes the server listen to requests # coming from other computers on the network write_ack_socket.bind(('', port)) print ("write ack socket bound to %s" %(port)) # put the socket into listening mode write_ack_socket.listen(5) print ("socket is listening") # a forever loop until we interrupt it or # an error occurs while True: # Establish connection with osd c, addr = write_ack_socket.accept() print ('Got connection from', addr) # recv the acknowledgement ack = _recv_msg(c, 1024) print(ack) # extracting the written pd_id, free_space, osd_id of that osd client_id = ack["client_id"] # client_addr = ack["client_addr"] # addr = (ip, port) pg_id = ack["pg_id"] free_space = ack["free_space"] osd_id = ack["osd_id"] # if the osd is down or out, make it up again # [need to check this] if cluster_topology[osd_id]["status"] != 0: cluster_topology[osd_id]["status"] = 0 # updating the write status of the osd to 1 for i in range(len(hashtable[pg_id])): if hashtable[pg_id][i][0] == osd_id: hashtable[pg_id][i][1] = 1 replication_factor = 0 # adding the new friend for osd in hashtable[pg_id]: if osd[0] != osd_id: if osd[1] == 1: replication_factor += 1 cluster_topology[osd_id]["friends"].add(osd[0]) cluster_topology[osd[0]]["friends"].add(osd_id) cluster_topology[osd_id]["free_space"] = free_space if isPrimary: # updating the backup update_backup_monitor("hash_table", [pg_id], [hashtable[pg_id]]) update_backup_monitor("cluster_topology", [osd[0] for osd in hashtable[pg_id]], \ [cluster_topology[osd[0]] for osd in hashtable[pg_id]]) hashtable_file = open('hashtable', 'wb') cluster_topology_file = open('cluster_topology', 'wb') hashtable_dump = pickle.dumps(hashtable) hashtable_file.write(hashtable_dump) hashtable_file.close() cluster_topology_dump = pickle.dumps(cluster_topology) cluster_topology_file.write(cluster_topology_dump) cluster_topology_file.close() if replication_factor > 1: # # sending write update to client # client_update = socket.socket() # print ("client write ack socket successfully created") # client_update.connect(client_addr) # msg = {"type": "WRITE_RESPONSE", "PG_ID": pg_id, \ # "status": "SUCCESS", "message": "write successful",\ # "client_id": client_id} # _send_msg(client_update, msg) # client_update.close() # sending write update to MDS MDS_update_socket = socket.socket() print ("MDS write ack socket successfully created") MDS_update_socket.connect((MDS_IP, MDS_PORT)) msg = {"type": "WRITE_RESPONSE", "PG_ID": pg_id, \ "status": "SUCCESS", "message": "write successful",\ "client_id": client_id} _send_msg(MDS_update_socket, msg) MDS_ack = _wait_recv_msg(MDS_update_socket, 1024) pg_id = MDS_ack["pg_id"] if MDS_ack["status"] == "SUCCESS": print("Write successful") MDS_flags[pg_id] = 0 else: print("Write error from MDS") print(MDS_ack["msg"]) MDS_flags[pg_id] = 1 ## resend pgs in MDS_flags with flag = 1 ## start that loop here MDS_update_socket.close() error = "" status = "SUCCESS" # send success _send_msg(c, {"error":error, "status":status}) c.close() write_ack_socket.close()
def recv_client_reqs(): global MY_OSD_ID recv_client_reqs_socket = socket.socket() print("client reqs socket successfully created") recv_client_reqs_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # reserve a port on your computer port = READ_WRITE_PORT # Next bind to the port # we have not entered any ip in the ip field # instead we have inputted an empty string # this makes the server listen to requests # coming from other computers on the network recv_client_reqs_socket.bind(('', port)) print("write ack socket bound to %s" % (port)) # put the socket into listening mode recv_client_reqs_socket.listen(5) print("socket is listening") # a forever loop until we interrupt it or # an error occurs while True: # Establish connection with client. c, addr = recv_client_reqs_socket.accept() print('Got connection from', addr) # recv the acknowledgement req = _recv_msg(c, 1024) print(req) if (req["type"] == "CLIENT_WRITE"): res = {"status": "RECEIVED", "msg": "data received"} _send_msg(c, res) client_id = req["client_id"] # client_addr = req["client_addr"] osd_dict = req["osd_dict"] for osd_id in osd_dict["osd_ids"]: if osd_id == MY_OSD_ID: continue # sending write update to client write_forward_socket = socket.socket() print("write forward socket successfully created") write_forward_socket.connect(osd_dict["addrs"][osd_id]) req["type"] = "OSD_WRITE" _send_msg(write_forward_socket, req) write_forward_socket.close() pg = req["pg"] file = open("./data/" + pg.pg_id, 'wb') pg_dump = pickle.dumps(pg) file.write(pg_dump) file.close() # sending write ack to monitor write_ack_socket = socket.socket() print("write forward socket successfully created") write_ack_socket.connect((MONITOR_IP, WRITE_ACK_PORT)) ack = {} ack["client_id"] = client_id # ack["client_addr"] = client_addr # addr = (ip, port) ack["pg_id"] = pg.pg_id ack["free_space"] = FREESPACE - req["size"] ack["osd_id"] = MY_OSD_ID _send_msg(write_ack_socket, ack) write_ack_socket.close() # _send_msg(c, [pg.pg_id, "SUCCESS"]) elif req["type"] == "OSD_WRITE": client_id = req["client_id"] # client_addr = req["client_addr"] pg = req["pg"] file = open("./data/" + pg.pg_id, 'wb') pg_dump = pickle.dumps(pg) file.write(pg_dump) file.close() # sending write ack to monitor write_ack_socket = socket.socket() print("write forward socket successfully created") write_ack_socket.connect((MONITOR_IP, WRITE_ACK_PORT)) ack = {} ack["client_id"] = client_id # ack["client_addr"] = client_addr # addr = (ip, port) ack["pg_id"] = pg.pg_id ack["free_space"] = FREESPACE - sys.getsizeof(pg_dump) ack["osd_id"] = MY_OSD_ID _send_msg(write_ack_socket, ack) write_ack_socket.close() elif req["type"] == "READ": pg_id = req["pg_id"] file = open("./data/" + pg_id, 'rb') pg_b = file.read() pg = pickle.loads(pg_b) file.close() # print(pg) print("sending pg to client " + str(pg_id)) msg = {"pg_id": pg.pg_id, "res": "SUCCESS", "pg": pg} _send_msg(c, msg) c.close() # print(msg) recv_client_reqs_socket.close()
def update_handler(self): # if n == 0: print("update handler started..") # if self.start_update_handler == True: while True: if len(self.processing) == 0: self.start_update_handler = False return msg = { "type": "WRITE_QUERY", "username": self.username, "processing": self.processing } s = socket.socket() ip = MDS_IPs["primary"]["ip"] port = MDS_IPs["primary"]["port"] # print(s.gethostname()) # s.bind(('', 9090)) try: s.connect((ip, port)) _send_msg(s, msg) response = _wait_recv_msg(s, MSG_SIZE) s.close() if response[ "status"] == "SUCCESS": # here check response from mds print(response["msg"]) file_written = response["file_written"] for file in file_written: #populate listbox again filename = file[0] file_id = file[1] file_path = file[2] self.file_id_map[filename] = file_id self.listbox.insert(tk.END, file_path) # listbox.insert(END, percent) self.listbox.update_idletasks() tree = response["tree"] self.dir_tree = tree["dir_tree"] self.processing = tree["processing"] print(self.processing) if len(self.processing) == 0: self.start_update_handler = False print("Exiting update handler") for file in file_written: self._popup("Update", str(file[2]) + " UPLOADED SUCCESSFULLY") # return # update on GUI # self._update_gui() # for filename in file_written: #populate listbox again # self.listbox.insert(END, filename) # # listbox.insert(END, percent) # self.listbox.update_idletasks() # tk.mainloop() # self.window.mainloop() elif response["status"] == "NO_UPD": print(response["msg"]) time.sleep(self.update_interval) except Exception as e: s.close() print("Update (write) from MDS failed") print(e) time.sleep(self.update_interval) finally: time.sleep(self.update_interval)
def _write(self, pg, pg_data): s = socket.socket() # send monitor to ask for OSD details ip = MONITOR_IPs["primary"] port = CLIENT_REQ_PORT s.connect((ip, port)) msg = { "type": "WRITE", "pg_id": pg.pg_id, "size": (sys.getsizeof(pg) / float(1 << 20)) } # d_msg = pickle.dumps(msg) _send_msg(s, msg) #s.send(d_msg) res = _wait_recv_msg(s, MSG_SIZE) osd_dict = {} if res["status"] == "SUCCESS": osd_dict = res["osd_dict"] else: print(res["msg"]) s.close() return -2 # osd_dict = response["osd_dict"] # print(osd_ips) s.close() # print(osd_ips[0][0], osd_ips[0][1]) # write on OSD osd_addr = osd_dict["addrs"][osd_dict["osd_ids"][0]] s = socket.socket() s.connect(osd_addr) data_msg = { "type": "CLIENT_WRITE", "pg": pg, "size": (sys.getsizeof(pg) / float(1 << 20)), "client_id": self.username, "client_addr": "", "osd_dict": osd_dict } _send_msg(s, data_msg) print(len(pg.object_list)) self.processing[pg.pg_id] = pg_data threading.Thread(target=self.update_handler()).start() ### Add server to receive response osd_response = _wait_recv_msg(s, 1024) if osd_response["status"] == "RECEIVED": print("file sent to OSD") # self.processing[pg.pg_id] = pg_data # if self.start_update_handler == False: # self.start_update_handler = True # self.update_handler() # threading.Thread(target=self.update_handler()) s.close() return 0 else: s.close() print("Error - File not sent") return -2
def dispatch_backup(self): while True: # Establish connection with client. print("waiting for messages..") c, addr = self.mds_socket.accept() print('Got connection from', addr) msg = {} try: msg = _recv_msg(c, MSG_SIZE) except Exception as e: print(e) c.close() continue res = {"status": "", "msg": ""} print(msg) if msg["type"] == "UPD": if msg["update_type"] == "ADD_LOGIN_USER": self.logged_in.append(msg["update"]["user"]) self._write_logged_in() res["status"] = "SUCCESS" elif msg["update_type"] == "REMOVE_LOGIN_USER": self.logged_in.remove(msg["update"]["user"]) self._write_logged_in() res["status"] = "SUCCESS" elif msg["update_type"] == "WRITE_SUCCESS": username = msg["update"]["user"] tree = self._read_tree(username) pg_id = msg["update"]["pg_id"] direc = tree["processing"][pg_id][0] file_id = tree["processing"][pg_id][1] filename = tree["processing"][pg_id][2] tree["dir_tree"][direc][file_id] = [filename, [pg_id]] tree["processing"][pg_id][3] = 1 self._write_tree(username, tree) res["status"] = "SUCCESS" elif msg["update_type"] == "UPDATE_PROCESSING": username = msg["update"]["username"] pg_written = msg["update"]["pg_written"] pg_wait = msg["update"]["pg_wait"] tree = self._read_tree(username) for pg_id in pg_written: tree["processing"].pop(pg_id) for pg_id in pg_wait.keys(): tree["processing"][pg_id] = pg_wait[pg_id] self._write_tree(username, tree) res["status"] = "SUCCESS" elif msg["type"] == "RECOVERY": res = self._recovery_handle() print(res["msg"]) else: res["status"] = "ERROR" res["msg"] = "msg type not define !" try: _send_msg(c, res) except Exception as e: print(e) finally: c.close()