def sendRequestFile(self, title, destin):
try:
self.file_udp = title
self.client.send(
encodeJSON(messageType['request'], os.path.basename(title),
destin))
except ConnectionError:
self.repair()
def sendFileReqTo(self, filedir, sender, receiver):
aux = filedir + "#" + sender
try:
print("le voy a pedir archivo a: {}".format(receiver))
self.client.send(encodeJSON(messageType['filesend'], aux,
receiver))
except socket.error:
self.repair()
def disconect(self):
try:
self.client.send(encodeJSON(messageType['logout']))
Notitfication(
"Desconeccion de usuario",
"El usuario {} se ha desconectado del servidor".format(
self.user))
except socket.error:
self.repair()
def sendRequestFile(self, title, destin):
try:
self.file_TCP = title
self.client.send(
encodeJSON(messageType['request'], os.path.basename(title),
destin))
print("Envío solicitud")
except socket.error:
self.repair()
def testEnvio(self, dest, mode, accion):
try:
self.client.send(
encodeJSON(messageType['test'], mode, dest,
accion)) #################
print("Solicito a servidor comunicación con: {}".format(dest))
except socket.error:
print("f")
self.repair()
def enviarLista(self, tar):
while (len(self.cola) > 0):
time.sleep(2.0)
instruction = self.cola.pop()
try:
self.client.send(encodeJSON(messageType['test'], "UY", tar))
print("Enviando instruccion")
except:
print("Falla crítica")
def copiar(self):
for connection, user in self.clients.items():
try:
connection.send(
encodeJSON(messageType['test'], "CA",
self.getVecino(self.clients[connection])))
print("{} iniciando copias a: {}".format(
self.clients[connection],
self.getVecino(self.clients[connection])))
except:
print("Falla crítica en copias")
def validUserName(self, user):
self.user = user
self.client.send(encodeJSON(messageType['username'], str(user)))
messageyype = messageType['none']
while messageyype != messageType['username']:
message = self.client.recv(1024)
message = decodeJSON(message)
messageyype = message['type']
self.status = message['content']
if self.status == "OK":
return True
else:
return False
def reciveMessage(self):
try:
while True:
message = self.client.recv(1024)
message = decodeJSON(message)
if message['type'] == messageType['login']:
Notitfication(
"Usuario conectado",
"El usuario {} se ha conectado con el servidor".format(
message['content']))
self.online_clients = message['content']
self.window.actualizarContactos()
if message['type'] == messageType['info']:
self.online_clients = message['content']
if message['type'] == messageType['request']:
print("llego la petición")
if "OK" in message['content']:
_, ip_h, port_h = message['content'].split("-")
senderThread = threading.Thread(
target=self.createUDPSender, args=(ip_h, port_h))
senderThread.start()
senderThread.join()
elif "NO" in message['content']:
pass
#if message['content'] != "OK" or message['content'] != "NO":
else:
Notitfication("Solicitud de tranferencia de archivo",
message['content'])
if self.window.askmsg("Aviso!", message['content']):
port_tcp = 5001
reciverThread = threading.Thread(
target=self.createUDPReciver,
args=(port_tcp, ))
reciverThread.start()
self.client.send(
encodeJSON(messageType['request'],
"OK-{}".format(port_tcp),
message['target']))
reciverThread.join()
else:
Notitfication(
"Solicitud rechazada",
"La solicitud de transferencia de archivos fue rechacahzada"
)
if message['type'] == messageType['back']:
self.backup = message['content'].split()
time.sleep(0.5)
print(self.backup)
except ConnectionError:
pass
def clientThread(self, connection, addr):
while True:
try:
message = connection.recv(8192)
message = decodeJSON(message)
messagetype = message['type']
#Chose or chage username
if messagetype == messageType['username']:
username = message['content']
print("Solicitud de asignacion de usuario <{}>".format(
username))
if self.validName(username):
self.clientsSem.acquire()
if self.getUserFromName(username):
connection.send(
encodeJSON(messageType['username'], "NOT OK"))
print(
"Solicitud para el usuario <{}> denegada, usuario ya registrado"
.format(username))
else:
connection.send(
encodeJSON(messageType['username'], "OK"))
print("Solicitud para el usuario <{}> aprobada".
format(username))
self.clients[connection] = username
self.broadcast(
encodeJSON(messageType['login'],
"{}".format(username)), connection)
time.sleep(1.0)
connection.send(
encodeJSON(messageType['info'],
self.getAllUsers()))
self.broadcast(
encodeJSON(messageType['info'],
self.getAllUsers()), connection)
connection.send(
encodeJSON(messageType['back'],
self.getbackup()))
self.broadcast(
encodeJSON(messageType['back'],
self.getbackup()), connection)
print("Usuario {} registrado".format(username))
self.activeNodes[username] = True
print(self.activeNodes)
if self.pro_mode:
print("KKKKK")
self.myThread = threading.Thread(
target=self.restoreFromFall,
args=(connection, ))
self.myThread.setDaemon = True
self.myThread.start()
self.clientsSem.release()
else:
connection.send(
encodeJSON(messageType['username'], "NOT OK"))
print(
"Solicitud para el usuario <{}> denegada, usuario ya registrado"
.format(username))
#chatroom
elif messagetype == messageType['request']:
#self.backup(encodeJSON(messageType['back'], self.getbackup()))
if "OK" in message['content']:
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
ip_host = addr[0]
port_host = message['content'].split("-")[1]
if reciver:
try:
reciver.send(
encodeJSON(
messageType['request'],
"OK-{}-{}".format(ip_host, port_host)))
print(
"Solicitud de envio de archivo del usuario [{}] al usuario [{}] aceptada\nProcediendo a la creacion del servidor UDP en IP: {} Puerto: {}"
.format(self.clients[connection],
self.clients[reciver], ip_host,
port_host))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send confirmation to {}".
format(message['target'])))
elif "NO" in message['content']:
pass
else:
#if message['content'] != "OK" or message['content'] != "NO":
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(
messageType['request'],
"El usuario {} esta tratando de enviarte un archivo <{}>.\n¿Aceptar la transferencia?"
.format(self.clients[connection],
message['content']),
self.clients[connection]))
print(
"Enviando solicitud de envio de archivo del usuario [{}] al usuario [{}]"
.format(self.clients[connection],
self.clients[reciver]))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".format(
message['target'])))
#Get server info
elif messagetype == messageType['info']:
if message['content'] == "users":
self.clientsSem.acquire()
print(
"El usuario [{}] solicito actualizacion de los clientes conectados al servidor."
.format(self.clients[connection]))
connection.send(
encodeJSON(messageType['info'],
self.getAllUsers()))
self.clientsSem.release()
time.sleep(0.5)
#logout
elif messagetype == messageType['logout']:
self.clientsSem.acquire()
print("Desconexion del usuario [{}]".format(
self.clients[connection]))
self.removeUser(connection)
self.broadcast(
encodeJSON(messageType['logout'],
"{}".format(username)), connection)
self.clientsSem.release()
break
elif messagetype == messageType['update']:
print("Tratando de enviar la actualizacion")
self.broadcast(
encodeJSON(message['type'], message['content'],
message['target']), connection)
elif messagetype == messageType['upsignal']:
reciver = message['content']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
reciver.send(encodeJSON(messageType['upsignal']))
elif messagetype == messageType['filesend']:
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
reciver.send(
encodeJSON(messageType['filesend'],
message['content']))
elif messagetype == messageType['remotedel']:
print("recibo el delete")
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
reciver.send(
encodeJSON(messageType['remotedel'],
message['content']))
elif messagetype == messageType['test']:
if "SY" in message['content']:
print("Nodo activo: {}. Tomando acción necesaria.".
format(self.activeNodes[message['target']]))
if (self.activeNodes[message['target']]):
print("Establecer conexión con: {}".format(
message['target']))
print(self.validUsers.index(message['target']))
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(messageType['test'], "SY",
self.clients[connection]))
print(
"Enviando solicitud de [{}] al usuario [{}]"
.format(self.clients[connection],
self.clients[reciver]))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".
format(message['target'])))
else:
reciver = self.getVecino(message['target'])
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(messageType['test'], "SV",
self.clients[connection]))
print(
"Enviando solicitud de [{}] al usuario [{}]"
.format(self.clients[connection],
self.clients[reciver]))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".
format(message['target'])))
elif "UV" in message['content']:
print("Nodo activo: {}. Tomando acción necesaria.".
format(self.activeNodes[self.getVecino(
self.clients[connection])]))
if (self.activeNodes[self.getVecino(
self.clients[connection])]):
print("Establecer conexión con: {}".format(
self.getVecino(self.clients[connection])))
print(
self.validUsers.index(
self.getVecino(self.clients[connection])))
reciver = self.getVecino(self.clients[connection])
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(messageType['test'], "UV",
self.clients[connection]))
print(
"Enviando solicitud de [{}] al usuario [{}]"
.format(self.clients[connection],
self.clients[reciver]))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".
format(message['target'])))
else:
reciver = self.getVecino(message['target'])
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(messageType['test'], "NS",
self.clients[connection]))
print(
"Enviando solicitud de [{}] al usuario [{}]"
.format(self.clients[connection],
self.clients[reciver]))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".
format(message['target'])))
elif "UY" in message['content']:
print("Establecer conexión con: {}".format(
message['target']))
print(self.validUsers.index(message['target']))
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(messageType['test'], "UY",
self.clients[connection]))
print(
"Enviando solicitud de [{}] al usuario [{}]"
.format(self.clients[connection],
self.clients[reciver]))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".format(
message['target'])))
elif "LP" in message['content']:
reciver = self.getVecino(self.clients[connection])
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(messageType['test'], "LP",
self.clients[connection]))
print(
"Solicitando lista de pendientes de {} a {}"
.format(
self.clients[connection],
self.getVecino(
self.clients[connection])))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".format(
self.clients[connection])))
except:
print("Conexión perdida con: {}".format(username))
self.removeUser(connection)
break
self.activeNodes[username] = False
print(self.activeNodes)
def restoreFromFall(self, tar):
time.sleep(4.0)
tar.send(
encodeJSON(messageType['test'], "RFF",
self.getVecino(self.clients[tar])))
def reciveMessage(self):
while True:
try:
#print("recibiendo mensajes")
message = self.client.recv(8192)
message = decodeJSON(message)
if message['type'] == messageType['login']:
Notitfication(
"Usuario conectado",
"El usuario {} se ha conectado con el servidor".format(
message['content']))
self.online_clients = message['content']
self.updateList(self.online_clients.split(" "))
time.sleep(2)
self.window.actualizarContactos()
if message['type'] == messageType['info']:
self.online_clients = message['content']
self.updateList(self.online_clients.split(" "))
time.sleep(2)
self.window.actualizarContactos()
if message['type'] == messageType['request']:
print("llego la petición")
if "OK" in message['content']:
_, ip_h, port_h = message['content'].split("-")
senderThread = threading.Thread(
target=self.createTCPSender, args=(ip_h, port_h))
senderThread.start()
senderThread.join()
elif "NO" in message['content']:
pass
#if message['content'] != "OK" or message['content'] != "NO":
else:
Notitfication("Solicitud de tranferencia de archivo",
message['content'])
if self.window.askmsg("Aviso!", message['content']):
port_tcp = 5001
reciverThread = threading.Thread(
target=self.createTCPReciver,
args=(port_tcp, ))
reciverThread.start()
self.client.send(
encodeJSON(messageType['request'],
"OK-{}".format(port_tcp),
message['target']))
reciverThread.join()
else:
Notitfication(
"Solicitud rechazada",
"La solicitud de transferencia de archivos fue rechacahzada"
)
if message['type'] == messageType['back']:
self.backup = message['content'].split()
time.sleep(0.5)
print("me llego el backup: {}".format(self.backup))
if message['type'] == messageType['update']:
self.updateDir(message['target'], message['content'])
if message['type'] == messageType['upsignal']:
self.window.sendTree()
if message['type'] == messageType['filesend']:
info = message['content'].split("#")
self.sendRequestFile(self.window.rootPath + "\\" + info[0],
info[1])
if message['type'] == messageType['remotedel']:
print("voy a eliminar" + message['content'])
os.remove(message['content'])
self.window.sendTree()
if message['type'] == messageType['test']:
if "SY" in message['content']:
print("Set en mis datos")
try:
info = message['content'].split("*") #############
self.sendRequestFile(self.window.rootPath + "\\" +
info[0],
info[1]) #################
self.client.send(
encodeJSON(messageType['test'], "UV", ""))
print(
"Enviando solicitud de actualización de respaldo a vecino"
)
except:
print("Falla crítica")
elif "SV" in message['content']:
print(
"Set en los datos del vecino, añadida accion a la cola"
)
self.cola.append(message)
print(self.cola)
elif "UY" in message['content']:
print(
"Actualizando datos con los datos del respaldo de vecino"
)
self.myThread = threading.Thread(
target=self.atenderSolicitudFinal)
self.myThread.setDaemon = True
self.myThread.start()
elif "UV" in message['content']:
print("Actualizando datos de respaldo del vecino")
elif "CA" in message['content']:
print("Mandando datos a vecino: {}".format(
message['target']))
elif "LP" in message['content']:
print("Accediendo a lista de pendientes de: {}".format(
message['target']))
if len(self.cola) > 0:
self.myThread = threading.Thread(
target=self.enviarLista,
args=(message['target'], ))
self.myThread.setDaemon = True
self.myThread.start()
elif "RFF" in message['content']:
print("Restaurando de caída: {}".format(
message['target']))
try:
self.client.send(
encodeJSON(messageType['test'], "LP", ""))
print(
"Enviando solicitud de acceso a respaldo a vecino"
)
except:
print("Falla crítica")
else:
print("simón, ya escuché")
time.sleep(0.5)
except socket.error:
self.repair()
except ValueError:
pass
def sendFileTree(self, tree):
print("Enviando")
test = encodeJSON(messageType['update'], json.dumps(tree), self.user)
print(sys.getsizeof(test))
self.client.send(test)
print("Enviado")
def remoteDelete(self, filedir, client):
try:
self.client.send(
encodeJSON(messageType['remotedel'], filedir, client))
except socket.error:
self.repair()
def sendSignalTo(self, destino):
try:
self.client.send(encodeJSON(messageType['upsignal'], destino))
print("le voy a pedir update a: {}".format(destino))
except socket.error:
self.repair()
def clientThread(self, connection, addr):
while True:
try:
message = connection.recv(1024)
message = decodeJSON(message)
messagetype = message['type']
#Chose or chage username
if messagetype == messageType['username']:
username = message['content']
print("Solicitud de asignacion de usuario <{}>".format(
username))
self.clientsSem.acquire()
if self.getUserFromName(username):
connection.send(
encodeJSON(messageType['username'], "NOT OK"))
print(
"Solicitud para el usuario <{}> denegada, usuario ya registrado"
.format(username))
else:
connection.send(
encodeJSON(messageType['username'], "OK"))
print("Solicitud para el usuario <{}> aprobada".format(
username))
#self.backup(encodeJSON(messageType['back'], self.getbackup()))
self.clients[connection] = username
self.broadcast(
encodeJSON(messageType['login'],
"{}".format(username)), connection)
time.sleep(1.0)
#self.broadcast(encodeJSON(messageType['private'], ">[{}] is online!".format(username)), connection)
connection.send(
encodeJSON(messageType['info'],
self.getAllUsers()))
self.broadcast(
encodeJSON(messageType['info'],
self.getAllUsers()), connection)
print("Usuario {} registrado".format(username))
self.clientsSem.release()
#chatroom
elif messagetype == messageType['request']:
#self.backup(encodeJSON(messageType['back'], self.getbackup()))
if "OK" in message['content']:
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
ip_host = addr[0]
port_host = message['content'].split("-")[1]
if reciver:
try:
reciver.send(
encodeJSON(
messageType['request'],
"OK-{}-{}".format(ip_host, port_host)))
print(
"Solicitud de envio de archivo del usuario [{}] al usuario [{}] aceptada\nProcediendo a la creacion del servidor UDP en IP: {} Puerto: {}"
.format(self.clients[connection],
self.clients[reciver], ip_host,
port_host))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send confirmation to {}".
format(message['target'])))
elif "NO" in message['content']:
pass
else:
#if message['content'] != "OK" or message['content'] != "NO":
reciver = message['target']
self.clientsSem.acquire()
reciver = self.getUserFromName(reciver)
self.clientsSem.release()
if reciver:
try:
reciver.send(
encodeJSON(
messageType['request'],
"El usuario {} esta tratando de enviarte un archivo <{}>.\n¿Aceptar la transferencia?"
.format(self.clients[connection],
message['content']),
self.clients[connection]))
print(
"Enviando solicitud de envio de archivo del usuario [{}] al usuario [{}]"
.format(self.clients[connection],
self.clients[reciver]))
except:
connection.send(
encodeJSON(
messageType['error'],
">Failed to send message to {}".format(
message['target'])))
#Get server info
elif messagetype == messageType['info']:
if message['content'] == "users":
self.clientsSem.acquire()
print(
"El usuario [{}] solicito actualizacion de los clientes conectados al servidor."
.format(self.clients[connection]))
connection.send(
encodeJSON(messageType['info'],
self.getAllUsers()))
self.clientsSem.release()
time.sleep(0.5)
#logout
elif messagetype == messageType['logout']:
self.clientsSem.acquire()
print("Desconexion del usuario [{}]".format(
self.clients[connection]))
self.removeUser(connection)
self.broadcast(
encodeJSON(messageType['logout'],
"{}".format(username)), connection)
self.clientsSem.release()
break
except:
pass
