Python Function.roll_the_dice方法代码示例

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def logout(ip, sessionID, SN, SN_host):
	print ("\n>>> LOGOUT")
	pk = pack.request_logout(sessionID)
	s = func.create_socket_client(func.roll_the_dice(SN_host[0]), SN_host[1]);
	if s is None:
		func.error("Errore nel logout dal super nodo, vabbè")
	else:
		s.sendall(pk)
		ricevutoByte = s.recv(const.LENGTH_PACK)
		nDelete = ricevutoByte[4:]
		func.success("Logout eseguito con successo dal super nodo, eliminati " + str(nDelete, "ascii") + " elementi")
		s.close()

	pk = pack.close()
	s = func.create_socket_client(func.roll_the_dice(ip), const.PORT);
	if s is None:
		func.error("Errore nella chiusura del demone")
	else:
		s.sendall(pk)
		s.close()
		print ("Chiusura del peer eseguito con successo, arrivederci.\n\n")

	if SN:
		s = func.create_socket_client(func.roll_the_dice(ip), const.PORT_SN);
		if s is None:
			func.error("Errore nella chiusura del demone super nodo")
		else:
			s.sendall(pk)
			s.close()
			print ("Chiusura del supernodo eseguita con successo, arrivederci.\n\n")

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def logout(ip55, t_host, sessionID):
	tfunc.warning("\n>>> LOGOUT")
	result = -1
	pk = pack.request_logout(sessionID)
	s = sFunc.create_socket_client(func.roll_the_dice(t_host[0]), t_host[1]);
	if s is None:
		tfunc.error("Errore nella creazione della socket per il logout.")
	else:
		try:
			s.sendall(pk)
			ricevutoByte = s.recv(const.LENGTH_PACK)
			if str(ricevutoByte[:4], "ascii") == pack.CODE_LOGOUT_DENIED:
				tfunc.error("Siamo spiacenti ma il logout risulta impossibile poichè si è in possesso di parti di file uniche.\n" + \
					"Sono state scaricate " + str(int(ricevutoByte[4:])) + " parti del file, fatevi il conto di quante ne mancano.")
			elif str(ricevutoByte[:4], "ascii") == pack.CODE_ANSWER_LOGOUT:	
				tfunc.success("Logout eseguito con successo.\nAvevi " + str(int(ricevutoByte[4:])) + " parti, peccato tu te ne vada, addio.\nAttendi " + str(const.TIME_TO_UPDATE) + " secondi e potrai scomparire.")
				time.sleep(const.TIME_TO_UPDATE)
				pk = pack.close()
				sD = sFunc.create_socket_client(func.roll_the_dice(ip55), const.PORT);
				if sD is None:
					pass
					#tfunc.error("Errore nella chiusura del demone")
				else:
					sD.sendall(pk)
					sD.close()
				tfunc.success("Chiusura del peer eseguito con successo, arrivederci.\n\n")
				result = 1
			else:
				tfunc.error("Errore nel codice di logout.")
			s.close()
		except:
			tfunc.error("Errore nel logout a causa del tracker.")
			s.close()

	return result

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def search(sessionID, query, SN, SN_host, host, listPkt):
	ricevutoByteRam = b''
	ricevutoByte = b''
	pk = pack.request_search(sessionID, query)
	s = func.create_socket_client(func.roll_the_dice(SN_host[0]), SN_host[1]);
	if s is None:
		func.error("Super nodo non attivo.")
		update_network(host, SN, listPkt)
	else:
		s.sendall(pk)

		ricevutoByte = s.recv(4 * const.LENGTH_PACK)

		if str(ricevutoByte[0:4],"ascii") == const.CODE_ANSWER_SEARCH:
			print(ricevutoByte)
			nIdmd5 = int(ricevutoByte[4:7])
			if(nIdmd5 != 0):
				func.success("Ricerca completata.")
				pointer = 7
				id = 0
				listFile = []
				for j in range(0, nIdmd5):
					md5 = ricevutoByte[pointer:pointer + 32]
					nomeFile = ricevutoByte[pointer + 32:pointer + 132]
					nCopy = int(ricevutoByte[pointer + 132:pointer + 135])

					pointer = pointer + 135

					for i in range(0, nCopy):
						ip = ricevutoByte[pointer:pointer + 55]
						port = ricevutoByte[pointer + 55:pointer + 60]
						id = id + 1
						pointer = pointer + 60
						fixList = [id, md5, nomeFile, ip, port]
						listFile.append(fixList)
						
				print("\nScegli file da quelli disponibili (0 per uscire): \n")
				print("FILE    \t\tID\tIP\n")
				lastFileName = b''
				for row in listFile:
					if lastFileName != row[2]:
						nomeFile = func.reverse_format_string((str(row[2], "ascii").strip() + ":"), const.LENGTH_FORMAT, " ")
						print(nomeFile + str(row[0]) + "\t" + str(row[3], "ascii"))
					else:
						print("\t\t\t" + str(row[0]) + "\t" + str(row[3], "ascii"))
					lastFileName = row[2]
				
				selectId = input("\nInserire il numero di file che vuoi scaricare (0 per uscire): ")
				
				if(selectId != "0"):
					for i in range (0, id):
						if listFile[i][0] == int(selectId):
							selectFile = listFile[i]
							break

					func.download(selectFile)

			else:
				func.error("Non sono presenti file con questa query nel nome: " + query)
		s.close()

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def add(ip55, sessionID, t_host, listPartOwned):
	tfunc.warning("\n>>> ADD FILE")
	fileName = input("Quale file vuoi inserire?\n")
	if fileName != "0":
		if os.path.exists(const.FILE_COND + fileName):
			
			fileToRead = open((const.FILE_COND + fileName),'rb')
			lenFile = os.stat(const.FILE_COND + fileName).st_size
			m = hashlib.md5()

			for x in range(0, pfunc.calculate_part(lenFile, const.LENGTH_PART)):
				m.update(fileToRead.read(const.LENGTH_PART))

			m.update(bytes(ip55, "ascii"))
			md5File = m.hexdigest()
			fileToRead.close()

			pk = pack.request_add_file(sessionID, lenFile, md5File, tfunc.format_string(fileName, const.LENGTH_FILENAME, " "))
			s = sfunc.create_socket_client(func.roll_the_dice(t_host[0]), t_host[1]);
			if s is None:
				tfunc.error("Errore, tracker non attivo.")
			else:
				s.sendall(pk)
				ricevutoByte = s.recv(const.LENGTH_PACK)
				if(ricevutoByte[:4].decode("ascii") == pack.CODE_ANSWER_ADDFILE):
					tfunc.success("Il file " + fileName + " è stato aggiunto con successo.\nÈ stato diviso in " + str(int(ricevutoByte[4:])) + " parti.")
					pfunc.add_to_list_owner(md5File, lenFile, const.LENGTH_PART, listPartOwned, fileName)
				else:
					tfunc.error("Errore nella ricezione del codice di aggiunta file.")
				s.close()
		else:
			tfunc.error("Errore: file non esistente.")

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
	def run(self):

		global mutex
		
		sP = sfunc.create_socket_client(func.roll_the_dice(self.peer[0]), self.peer[1])
		if sP is None:
		    #tfunc.error('Error: could not open socket in download')
		    var = "" # giusto per fargli fare qualcosa
		else:
			try:
				if mutex.acquire(timeout = const.TIME_TO_UPDATE):
					dnl.update_own_memory(self.md5, self.partN, self.listPartOwned, "2")
					mutex.release()

					#tfunc.gtext("Start download della parte " + str(self.partN) + " da " + str(self.peer[0], "ascii"))

					pk = pack.request_download(self.md5, self.partN)
					sP.sendall(pk)
					ricevutoByte = sP.recv(const.LENGTH_HEADER)
					if str(ricevutoByte[0:4], "ascii") == pack.CODE_ANSWER_DOWNLOAD:
						nChunk = int(ricevutoByte[4:10])
						ricevutoByte = b''
						i = 0
						
						while i != nChunk:
							ricevutoLen = sP.recv(const.LENGTH_NCHUNK)
							while (len(ricevutoLen) < const.LENGTH_NCHUNK):
								ricevutoLen = ricevutoLen + sP.recv(const.LENGTH_NCHUNK - len(ricevutoLen))
							buff = sP.recv(int(ricevutoLen))
							while(len(buff) < int(ricevutoLen)):
								buff = buff + sP.recv(int(ricevutoLen) - len(buff))
							ricevutoByte = ricevutoByte + buff
							i = i + 1

						sP.close()

						# Modifico nel file la parte che ho appena scaricato, se il file non esiste lo creo (es b'00000')
						dnl.create_part(ricevutoByte, self.fileName, self.partN, self.lenFile, self.lenPart)

						if mutex.acquire(timeout = const.TIME_TO_UPDATE):
							# Aggiorno la mia memoria
							dnl.update_own_memory(self.md5, self.partN, self.listPartOwned, "1")
							mutex.release()

							pfunc.part_all(self.listPartOwned[self.md5][0])

							# Invio l'update al tracker
							send_update(self.t_host, self.sessionID, self.md5, self.partN, self.listPartOwned, self.peer)
						else:
							raise Exception("Error Download Code")
					else:
						raise Exception("Error Download Code")

				else:
					raise Exception("Error Download Code")

			except Exception as e:
				#tfunc.write_daemon_error(self.name, str(self.peer[0], "ascii"), "ERRORE DOWNLOAD: {0}".format(e))
				dnl.update_own_memory(self.md5, self.partN, self.listPartOwned, "0")

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def try_connection(host):
	s = sfunc.create_socket_client(func.roll_the_dice(host), const.TPORT)
	pk = pack.confirm()
	if s is None:
		sys.exit(-1)
	else:
		s.sendall(pk)
		s.close()

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def forward(pk, addr, listNeighbor):
	if pk != bytes(const.ERROR_PKT, "ascii"):
		if not [pk[20:75], pk[75:80]] in listNeighbor:
			for x in listNeighbor:
				if addr != x[0]:
					s = func.create_socket_client(func.roll_the_dice(x[0]), x[1])
					if not(s is None):
						s.sendall(pk)
						s.close()

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def forward(pk, addr, l): # Non andrebbe fatto generico?
	if pk != bytes(const.ERROR_PKT, "ascii"):
		for x in l:
			if addr != x[0]:
				s = func.create_socket_client(func.roll_the_dice(x[0]), x[1])
				if not(s is None):
					s.sendall(pk)
					#write_daemon_success("Daemon", "-", "Forward da " + addr + " a " + x[0])
					s.close()

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def quit(ip55):
	tfunc.warning("\n>>> QUIT")
	pk = pack.close()
	s = sFunc.create_socket_client(func.roll_the_dice(ip55), const.TPORT);
	if s is None:
		tfunc.error("Errore nella chiusura del demone tracker")
	else:
		s.sendall(pk)
		s.close()
		tfunc.success("Chiusura del demone tracker eseguito con successo, arrivederci.\n\n")

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def request_memory_of_hitpeer(t_host, sessionID, md5):
	s = sfunc.create_socket_client(func.roll_the_dice(t_host[0]), t_host[1]);
	if s is None:
		#tfunc.error("Tracker non attivo.")
		return bytes(const.ERROR_PKT, "ascii")
	else:
		pk = pack.request_hitpeer(sessionID, md5)
		s.sendall(pk)

		return s.recv(4 * const.LENGTH_PACK)

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def send_update(t_host, sessionID, md5, partN, listPartOwned, peer):
	s = sfunc.create_socket_client(func.roll_the_dice(t_host[0]), t_host[1])
	if s is None:
	    tfunc.error('Error: could not open socket to update Tracker')
	else:
		pk = pack.request_update_tracker(sessionID, md5, partN)
		s.sendall(pk)
		ricevutoByte = s.recv(const.LENGTH_PACK)
		if str(ricevutoByte[0:4], "ascii") == pack.CODE_ANSWER_UPDATE_PART:
			tfunc.dnl_success("Download eseguito della parte " + str(partN) + " da " + str(peer[0], "ascii") + "\nAttualmente in possesso di " + str(int(ricevutoByte[4:])) + "/" + str(len(listPartOwned[md5][0])) + " parti del file.")
		s.close()

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def login(host, SN, SN_host, listPkt):
	s = func.create_socket_client(func.roll_the_dice(SN_host[0]), SN_host[1])
	pk = pack.request_login(host)
	if s is None:
		func.error("Errore nell'apertura della socket per il login")
		update_network(host, SN, listPkt)
	else:
		s.sendall(pk)
		ricevutoByte = s.recv(const.LENGTH_PACK)
		sessionID = ricevutoByte[4:20]
		s.close()
		return sessionID

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def updateNeighbor(myHost, listNeighbor):
	del listNeighbor[:]
	pk = pack.neighbor(myHost)
	# Se avevo già dei vicini vado a testare se sono ancora attivi
	"""if len(listNeighbor) != 0:
		for neighbor in listNeighbor:
			s = func.create_socket_client(func.roll_the_dice(neighbor[0]), neighbor[1]);
			# Se non sono più attivi lo segnalo e li cancello dalla lista
			if s is None:
				func.error(str(neighbor[0], "ascii") + " non è più attivo.")
				del neighbor
			else:
				func.success(str(neighbor[0], "ascii") + " ancora attivo.")
				s.close()
		# Se prima ero al completo e sono ancora tutti attivi lo segnalo e esco
		if len(listNeighbor) == const.NUM_NEIGHBOR:
			func.success("Lista vicini completa!")
		# Se invece dopo il controllo ho meno vicini del numero massimo mando a ogni vicino una richiesta di vicinato
		elif len(listNeighbor) > 0:
			for neighbor in listNeighbor:
				s = func.create_socket_client(func.roll_the_dice(neighbor[0]), neighbor[1]);
				if s is None:
					func.error("Mamma che sfiga, sto vicino è andato giù proprio ora.")
				else:
					s.sendall(pk)
					s.close()	
	
	# Alla fine gestisco la possibilità che tutti i vicini che avevo siano andati giù e quindi passo all'inserimento manuale.
	if len(listNeighbor) == 0: 		"""
	while True:
		print ("\n>>> SCELTA PEER VICINO")
		nGroup = input("Numero del gruppo: ")
		if nGroup is 0:
			break
		nElement = input("Numero dell'elemento del gruppo: ")
		if nElement is 0:
			break
		nPort = input("Inserire la porta su cui il vicino è in ascolto: ")
		if nPort is 0:
			break
		hostN = func.roll_the_dice("172.030." + func.format_string(nGroup, const.LENGTH_SECTION_IPV4, "0") + 
																"." + func.format_string(nElement, const.LENGTH_SECTION_IPV4, "0") + 
																"|fc00:0000:0000:0000:0000:0000:" + func.format_string(nGroup, const.LENGTH_SECTION_IPV6, "0") + 
																":" + func.format_string(nElement, const.LENGTH_SECTION_IPV6, "0"))
		s = func.create_socket_client(hostN, nPort);
		if s is None:
			func.error("Errore nella scelta del primo peer vicino, scegline un altro.")
			break
		else:
			s.sendall(pk)
			s.close()
			break

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def remove_file(fileName, sessionID, SN, SN_host, host, listPkt):
	if os.path.exists("FileCondivisi/" + fileName):
		md5File = hashlib.md5(open(("FileCondivisi/" + fileName),'rb').read()).hexdigest()
		pk = pack.request_remove_file(sessionID, md5File)
		s = func.create_socket_client(func.roll_the_dice(SN_host[0]), SN_host[1]);
		if s is None:
			func.error("Errore, super nodo non attivo.")
			update_network(host, SN, listPkt)
		else:
			s.sendall(pk)
			s.close()
	else:
		func.error("Errore: file non esistente.")

# 需要导入模块: import Function [as 别名]
# 或者: from Function import roll_the_dice [as 别名]
def download(selectFile):	
	print ("\n>>> DOWNLOAD")

	md5 = selectFile[1]
	nomeFile = selectFile[2].decode("ascii").strip()
	ip = selectFile[3]
	port = selectFile[4]

	# Con probabilità 0.5 invio su IPv4, else IPv6
	ip = func.roll_the_dice(ip.decode("ascii"))
	print("Connessione con:", ip)

	# Mi connetto al peer

	sP = func.create_socket_client(ip, port)
	if sP is None:
	    print ('Error: could not open socket in download')
	else:
		pk = pack.request_download(md5)
		sP.sendall(pk)

		nChunk = int(sP.recv(const.LENGTH_HEADER)[4:10])
					
		ricevutoByte = b''

		i = 0
		
		while i != nChunk:
			ricevutoLen = sP.recv(const.LENGTH_NCHUNK)
			while (len(ricevutoLen) < const.LENGTH_NCHUNK):
				ricevutoLen = ricevutoLen + sP.recv(const.LENGTH_NCHUNK - len(ricevutoLen))
			buff = sP.recv(int(ricevutoLen))
			while(len(buff) < int(ricevutoLen)):
				buff = buff + sP.recv(int(ricevutoLen) - len(buff))
			ricevutoByte = ricevutoByte + buff
			i = i + 1

		sP.close()
		
		# Salvare il file data
		open((const.FILE_COND + nomeFile),'wb').write(ricevutoByte)
		print("File scaricato correttamente, apertura in corso...")
		try:
			os.system("open " + const.FILE_COND + nomeFile)
		except:
			try:
				os.system("start " + const.FILE_COND + nomeFile)
			except:
				print("Apertura non riuscita")