def send_receive(self, data): """ Envia os dados contidos em data para a socket da ligação, e retorna a resposta recebida pela mesma socket. """ try: data_obj = pickle.dumps(data, -1) self.socket.sendall(struct.pack("!i", len(data_obj))) self.socket.sendall(data_obj) ret_size = struct.unpack("!i", receive_all(self.socket, 4, 4)) return pickle.loads(receive_all(self.socket, ret_size)) except s.error: print "Erro ao enviar/receber dados, o canal ou outra parte morreu" self.close()
def send_receive(self, data): """ It sends the data through the connection socket, and returns the answer received by the endpoint. """ mens = p.dumps(data, -1) size_mens = struct.pack("!i", len(mens)) self._sock.sendall(size_mens) self._sock.sendall(mens) size_bytes = su.receive_all(self._sock, 4) size = struct.unpack("!i", size_bytes)[0] msg = su.receive_all(self._sock, size) obj = p.loads(msg) return list(obj)
def send_receive(self, data): """ Envia os dados contidos em data para a socket da ligação, e retorna a resposta recebida pela mesma socket. """ self.client_sock.sendall(pickle.dumps(data)) temp = s.receive_all(self.client_sock, 1024) return pickle.loads(temp)
def client(host, port): cont = True while cont: sock = sock_utils.create_tcp_client_socket(host, port) send_msg = raw_input("Qual a mensagem") if send_msg == "EXIT": cont = False else: sock.sendall(send_msg) resposta = sock_utils.receive_all(sock, 5000) print 'Recebi {}'.format(resposta)
def cliente(): try: IP_Server = sys.argv[1] PORT = int(sys.argv[2]) IP_Client = sys.argv[3] except: raise ValueError("Argumentos inválidos!") Cliente = net_client.server(IP_Server, PORT) while True: msg = raw_input("comando > ") if msg == "EXIT": exit() else: msg = msg.split(" ") lista = verify(msg, IP_Client) if lista != []: msg_bytes = pickle.dumps(lista, -2) send_bytes = struct.pack("!i",len(msg_bytes)) Cliente.connect() conn_sock.sendall(send_bytes) conn_sock.sendall(msg_bytes) resp_bytes = sock_utils.receive_all(Cliente, 4) resp = sock_utils.receive_all(Cliente, int(struct.unpack("!i",resp_bytes)[0])) resposta_final = pickle.loads(resp) Cliente.close() print 'Recebi: %s' % resposta:final else: print "UNKNOWN COMMAND"
def send_receive(self, data): """ Envia os dados contidos em data para a socket da ligação, e retorna a resposta recebida pela mesma socket. """ try: self.socket.sendall(data) msg = receive_all(self.socket, 1024) return msg except: print "erro no send receive" self.close()
def handle(self): """ Handling das mensagens. """ global skeleton continue_flag = True global server_up while continue_flag and server_up: r, w, x = sel.select([self.request], [], []) for sock in r: size = sock_utils.receive_all(sock, 4, 4) if size: skeleton.clear_expired_locks() skeleton.clear_maxed_locks() rcv_message_size = struct.unpack("!i", size)[0] rcv_message = pickle.loads( sock_utils.receive_all(sock, rcv_message_size)) self.client_message_handler(sock, rcv_message) else: addr, port = sock.getpeername() print "Cliente com IP {} e porto {} fechou a ligação".format( addr, port) sock.close() continue_flag = False
class server: """ Classe para abstrair uma ligação a um servidor TCP. Implementa métodos para estabelecer a ligação, para envio de um comando e receção da resposta, e para terminar a ligação """ def __init__(self, address, port): """ Inicializa a classe com parâmetros para funcionamento futuro. """ self.sock = 0 self.adr = address self.port = port def connect(self): """ Estabelece a ligação ao servidor especificado na inicialização do objeto. """ self.sock = util.create_tcp_client_socket(self.adr, self.port) def send_receive(self, (data, datasize)): # type: (object) -> object """ Envia os dados contidos em data para a socket da ligação, e retorna a resposta recebida pela mesma socket. :rtype: object """ #Send a request to server self.sock.sendall(datasize) self.sock.sendall(data) #Get answer from server and interpret it sizebytes = self.sock.recv(4) size = util.size_unpack(sizebytes) message_recv = util.receive_all(self.sock, size) message = util.deserialize(message_recv) return message size = struct.unpack('!i', sizebytes)[0] recbytes = receive_all38(self.sock, size) rec = pickle.loads(recbytes) return rec
def send_receive(self, data): """ Envia os dados contidos em data para a socket da ligação, e retorna a resposta recebida pela mesma socket. """ try: data_bytes = pickle.dumps(data, -1) data_size_bytes = struct.pack('!i', len(data_bytes)) self.socket.sendall(data_size_bytes) self.socket.sendall(data_bytes) response = "" response_size_bytes = self.socket.recv(4) response_bytes = sock_utils.receive_all( self.socket, struct.unpack('!i', response_size_bytes)[0]) response = pickle.loads(response_bytes) except: print("Connection lost, server disconnected") self.socket.close() exit() return response
for sckt in R: if sckt is socket: conn_sock, addr = socket.accept() addr, port = conn_sock.getpeername() print("<" + time.ctime() + "> " + ' Nova Ligação: %s:%d' % (addr, port)) SocketList.append(conn_sock) else: locks.locks.clear_expired_locks() for recurso in locks.locks.recursosArray: if locks.locks.recursosArray[recurso].stat() >= int( locks.locks.numMaxBloqueios): locks.locks.recursosArray[recurso].disable() size_bytes2 = sckt.recv(4) if size_bytes2: mensagem = sock_utils.receive_all(sckt, size_bytes2) if mensagem: print("\n-#-") print("Recebi: ", mensagem) resposta = locks.handleMessage(mensagem) print("Vou Enviar: ", resposta) print("-#-\n") msg_bytes3 = pickle.dumps(resposta, -1) size_bytes3 = struct.pack('!i', len(msg_bytes3)) sckt.sendall(size_bytes3) sckt.sendall(msg_bytes3) print("Data Actual: " + time.ctime() + "\n") print(locks.locks) print('----------#########----------\n')
HOST = '' PORT = 9999 resource_number=10 resource_time=10 print "A utiizar os parametros padrão" print "Porta: " + str(PORT) print "Recursos: " + str(resource_number) + " Tempo: " + str(resource_time) lp = lock_pool(resource_number) msgcliente = [] ret = [] sock=sock_utils.create_tcp_server_socket(HOST,PORT,1) while True: (conn_sock, addr) = sock.accept() print 'ligado a %s', addr try: msg = sock_utils.receive_all(conn_sock,1024) msg_unp = pickle.loads(msg) print 'recebi %s' % msg_unp msg_unp[1]=int(msg_unp[1]) if(len(msg_unp)>2): msg_unp[2]=int(msg_unp[2]) msg_unp[1]=int(msg_unp[1]) if msg_unp[1] > len(lp.lock_pool_array): msg_pronta_enviar = 'UNKNOWN RESOURCE' else: lp.clear_expired_locks() if(msg_unp[0] == 'LOCK'): if lp.lock(msg_unp[1], msg_unp[2], t.time() + resource_time): msg_pronta_enviar = 'OK' else:
R, W, X = select.select(SocketList, [], []) for socket in R: if socket is listener_socket: (conn_sock, addr) = listener_socket.accept() try: (addr, port) = conn_sock.getpeername() print "New client connected: ", addr[0], ":", addr[1] SocketList.append(conn_sock) except: print "Socket Closed! ------ End Connection" SocketList.remove(conn_sock) conn_sock.close() else: try: pool.clear_expired_locks() message_bytes = util.receive_all(socket, 4) if message_bytes != "None": #Get Client request bytesize = util.size_unpack(message_bytes) getmessage = util.receive_all(socket, bytesize) print util.deserialize(getmessage) #Launch server skeleton & process message skeleton = skel.LockSkel() answer = skeleton.ServerHelper(getmessage, pool, args) # Answer must be serialized and sent # answer = util.serialize(answer) # answer_size = util.msg_length(answer) # socket.sendall(answer_size) # socket.sendall(answer) util.serial_send(socket, answer)
sock = su.create_tcp_server_socket("", PORT, 1) SocketList = [sock] while True: try: R, W, X = sel.select(SocketList, [], []) for sckt in R: if sckt is sock: (conn_sock, addr) = sock.accept() print("### CONNECTED TO: ###") print("ADDRESS: ", addr[0]) print("PORT: ", str(addr[1])) SocketList.append(conn_sock) else: size_bytes = su.receive_all(sckt, 4) if size_bytes: skel.pool.clear_expired_locks() skel.pool.disable_expired_resources() size = struct.unpack("!i", size_bytes)[0] #receber mensagem em bytes resp, pool = skel.processMessage(su.receive_all( sckt, size)) #enviar resposta size_mens = struct.pack("!i", len(resp)) sckt.sendall(size_mens)
try: if soquete is sock: (conn_sock, addr) = sock.accept() print "Cliente" + str(conn_sock.getpeername()) SocketInput.append(conn_sock) else: resp = [] recvv = soquete.recv(50) if recvv == '': print 'Client Close' + str(soquete.getpeername()) soquete.close() SocketInput.remove(soquete) else: tamanho = int(p.loads(recvv)) soquete.sendall(p.dumps("SIZEOK", -1)) comando = sock_utils.receive_all(soquete, tamanho) if tamanho == sys.getsizeof(comando): msg_unp = p.loads(comando) print 'Pedido Recebido: ' + str(msg_unp) print "" msg_unp[1] = int(msg_unp[1]) if len(msg_unp) > 2: msg_unp[2] = int(msg_unp[2]) msg_unp[1] = int(msg_unp[1]) resp = lskel.handle(msg_unp) soquete.sendall(resp) else: print 'Erro: Mensagem recebida nao tem o mesmo tamanho da original' soquete.close() SocketInput.remove(soquete)
try: if soquete is sock: (conn_sock, addr) = sock.accept() print "Cliente" + str(conn_sock.getpeername()) SocketInput.append(conn_sock) else: resp = [] recvv = soquete.recv(50) if recvv == '': print 'Client Close' + str(soquete.getpeername()) soquete.close() SocketInput.remove(soquete) else: tamanho = int(p.loads(recvv)) soquete.sendall(p.dumps("SIZEOK", -1)) comando = sock_utils.receive_all(soquete, tamanho) if tamanho == sys.getsizeof(comando): msg_unp = p.loads(comando) print 'Pedido Recebido: ' + str(msg_unp) print "" msg_unp[1] = int(msg_unp[1]) if len(msg_unp) > 2: msg_unp[2] = int(msg_unp[2]) msg_unp[1] = int(msg_unp[1]) resp = lskel.handle(msg_unp) soquete.sendall(resp) else: print 'Erro: Mensagem recebida nao tem o mesmo tamanho da original' soquete.close() SocketInput.remove(soquete)
def servidor(): """ Função usada para iniciar o programa, processando a linha de comandos, aceitando ligações de clientes, processando o pedido, gerindo os recursos definidos e enviando a devida resposta ao pedido. """ # python lock_server.py <PORT> <n recursos> <maximo de bloqueios k> <maximo de bloqueios y> <tempo limite de ligacao(segundos) try: PORT = int(sys.argv[1]) N = int(sys.argv[2]) K = int(sys.argv[3]) Y = int(sys.argv[4]) T = int(sys.argv[5]) global pool pool = lock_pool(N, K, Y, T) global dicionario dicionario = dictionary_create(pool) except: raise ValueError("Argumentos inválidos!") HOST = '' Servidor = create_tcp_server_socket(HOST, PORT, 1) # Criaçao do listening socket do servidor semaforo = Semaphore(1) # Semaforo usado para garantir exclusao mutua keep = True # variavel que mantem o servidor ligado while keep: try: (conn_sock, addr) = Servidor.accept() except s.error as err: print "Erro na criacao do socket de conecao: ", err exit() resp = "" pool.clear_expired_locks() pool.check_K() msg_nbytes = receive_all(Servidor, 4) msg_bytes = receive_all(Servidor, int(struct.unpack("!i",msg_nbytes)[0])) msg = pickle.loads(resp) if msg[0] == 10: resp = pool.lock(msg[-1], msg[1], T) elif msg[0] == 20: resp = pool.release(msg[-1],msg[1]) elif msg[0] == 30: resp = pool.test(msg[1]) elif msg[0] == 40: resp = pool.stat(msg[1]) elif msg[0] == 50: resp = pool.stat_y() elif msg[0] == 60: resp = pool.stat_n() else: resp = "UNKNOWN COMMAND" msg_bytes = pickle.dumps(resp, -2) size_bytes = struct.pack("!i",len(msg_bytes)) conn_sock.sendall(size_bytes) conn_sock.sendall(msg_bytes) conn_sock.close() sock.close()
SocketList = [ListenSocket, sys.stdin] while True: R, W, X = select.select(SocketList, [], []) for socket in R: if socket is ListenSocket: conn_sock, addr = ListenSocket.accept() addr, port = conn_sock.getpeername() print('Novo cliente conectado -> %s:%d' % (addr, port)) SocketList.append(conn_sock) else: #limpar recursos skel.clear_locks() size_bytes = receive_all(socket, 4) if not size_bytes: socket.close() SocketList.remove(socket) print('Client closed connection.') else: size = struct.unpack("!i", size_bytes)[0] msg_bytes = receive_all(socket, size) if not msg_bytes: socket.close() SocketList.remove(socket) print('Client closed connection.') else: msg = pickle.loads(msg_bytes)