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)