def client(server_addr):
"""Client - with shutdown and receiving more"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
sent_bytes = []
recv_bytes = []
for message in msg.msgs(20, max_length=2000): # generate 20 msgs
n_sent = sock.send(message) # send message to server
sent_bytes.append(n_sent)
data = sock.recv(1024) # receive response from server
if not data: # check if server terminates abormally
print('Server closing')
break
recv_bytes.append(len(data))
else: #for문 정상적으로 끝났을떄
# Now all the messages sent. Terminate outgoing TCP connection.
sock.shutdown(socket.SHUT_WR) # send eof mark (FIN)
# Receive the remaining messages
while True:
data = sock.recv(1024)
if not data: break
recv_bytes.append(len(data))
sock.close() # for 문 break으로 나오게될떄
print('sent {} times: {}'.format(len(sent_bytes), sum(sent_bytes)))
print(sent_bytes)
print('received {} times: {}'.format(len(recv_bytes), sum(recv_bytes)))
print(recv_bytes)
def client(server_addr):
"""Client - using file-like object instead of socket obj"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
in_file = sock.makefile('rb') # file-like obj
out_file = sock.makefile('wb')
sent_bytes = []
recv_bytes = []
# for message in msg.msgs(20, max_length=2000):
# n_sent = out_file.write(message)
# out_file.flush() # flush-out buffer to send immediately
# sent_bytes.append(n_sent)
# data = in_file.readline() # receive response
# if not data: break
# recv_bytes.append(len(data))
for line in msg.msgs(20, max_length=2000):
message = line.encode()
n_sent = sock.send(message)
sent_bytes.append(n_sent)
data = in_file.readline()
if not data: break
recv_bytes.append(len(data))
sock.close()
print('sent {} times: {}'.format(len(sent_bytes), sum(sent_bytes)))
print(sent_bytes)
print('received {} times: {}'.format(len(recv_bytes), sum(recv_bytes)))
print(recv_bytes)
def client(server_addr):
"""Client - read more date after shut-down
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
sent_bytes = []
recv_bytes = []
for message in msg.msgs(20, length=2000): # generate 20 msgs
n_sent = sock.send(message) # send message to server
sent_bytes.append(n_sent)
data = sock.recv(2048) # receive response from server
if not data: # check if server terminates abnormally
print('Server abnormally terminated')
break
recv_bytes.append(len(data))
else:
# Now all the messages sent. Terminate outgoing TCP connection.
sock.shutdown(socket.SHUT_WR) # send eof mark (FIN)
# Receive more for the remaining messages
while True:
data = sock.recv(2048)
if not data:
break
recv_bytes.append(len(data))
sock.close()
msg.report(sent_bytes, recv_bytes)
def client(server_addr):
"""Client - converting to file-like object to allow buffered I/O
Assumption: request/response messages ending with LF
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
# file-like obj in read/write binary mode
# Note: binary mode preserve the data (not convert encodings and line ending)
rfile = sock.makefile('rb') # incoming stream
wfile = sock.makefile('wb') # outgoing stream
sent_bytes = []
recv_bytes = []
for message in msg.msgs(20, length=2000):
n_sent = wfile.write(message)
wfile.flush() # flush-out user buffer to send immediately
sent_bytes.append(n_sent)
data = rfile.readline() # incoming line message
if not data: # check if server terminates abnormally
print('Server abnormally terminated')
break
recv_bytes.append(len(data))
sock.close()
msg.report(sent_bytes, recv_bytes)
def client(server_addr):
"""Client - read more date after shut-down
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
sock.setblocking(False) # non-blocking socket
sel = selectors.DefaultSelector()
sel.register(sock, selectors.EVENT_READ | selectors.EVENT_WRITE)
it = msg.msgs(100, length=2000) # generator is iterable
sent_bytes = []
recv_bytes = []
keep_running = True
while keep_running:
events = sel.select(
timeout=1) # wake up every 1 sec even though no events
if not events: # timeout event occurs
print('timeout')
continue
for key, mask in events:
conn = key.fileobj
# recv if socket becomes readable
if mask & selectors.EVENT_READ:
data = conn.recv(4096)
if not data:
print('Server closing')
sel.unregister(conn)
keep_running = False
break
recv_bytes.append(len(data))
print('recv:', len(data))
# sendall if socket becomes writable
if mask & selectors.EVENT_WRITE:
try:
message = next(it)
except StopIteration: # no more messages
# Do not check writable.
sel.modify(conn, selectors.EVENT_READ)
conn.shutdown(socket.SHUT_WR)
break
conn.sendall(
message
) # send the entire message even though non-blocking mode
sent_bytes.append(len(message))
print('send:', len(message))
# end for
# end while
sock.close()
msg.report(sent_bytes, recv_bytes)
def run(self):
print('%s started' % self.getName())
for message in msg.msgs(20, length=2000):
n_sent = self.sock.send(message)
self.sent_bytes.append(n_sent)
data = self.in_file.readline() # receive response
if not data:
print('Server closing')
break
self.recv_bytes.append(len(data))
self.sock.close() # to send eof to server
def run(self):
print(f'{self.getName()} starts')
for message in msg.msgs(n_mesg, length=2000):
n_sent = self.sock.send(message)
print(f'send {n_sent} bytes')
data = self.rfile.readline() # receive response
if not data:
print('Server closing')
break
print(f'recv {len(data)} bytes')
self.sock.close() # to send eof to server
def run(self):
for message in msg.msgs(20, length=2000, delay=0.5):
n_sent = self.sock.send(message)
self.sent_bytes.append(n_sent)
data = self.in_file.readline() # receive response
if not data:
print('Server closing')
break
self.recv_bytes.append(len(data))
self.sock.close() # to send eof to server
msg.report(self.sent_bytes, self.recv_bytes)
def menuOpt():
localizarDados()
while True:
msgs().getMenu()
opt = input("OPÇÃO DESEJADA: ").upper()
if opt == 'Q':
break
elif opt == 'A': # COPIAR E COLAR LINHA DE UMA PLANILHA PRA OUTRA
insertPlanList(orig[0], orig[1], dest[0], dest[1])
elif opt == 'B': # PROCURAR
procPlanPrint(orig[0], orig[1], dest[0], dest[1])
elif opt == 'C': # INSERIR LOOPBACK
pass
elif opt == 'D':
testesopt()
elif opt == 'E':
localizarDados()
elif opt == 'F':
pass
else:
msgs().getMsg1()
def doit(self):
sent_bytes = []
recv_bytes = []
for message in msg.msgs(20, max_length=2000):
self.sock.sendall(message)
sent_bytes.append(len(message))
data = self.in_file.readline() # receive response
if not data:
print('Server closing')
break
recv_bytes.append(len(data))
self.sock.close() # to send eof to server
print('sent {} times: {}'.format(len(sent_bytes), sum(sent_bytes)))
print(sent_bytes)
print('received {} times: {}'.format(len(recv_bytes), sum(recv_bytes)))
print(recv_bytes)
def client(server_addr):
"""Incorrect client
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
sent_bytes = []
recv_bytes = []
for message in msg.msgs(100, length=1400): # generate 100 msgs
n_sent = sock.send(message) # send message to server
sent_bytes.append(n_sent)
data = sock.recv(2048) # receive response from server
recv_bytes.append(len(data))
sock.close() # send eof mark (FIN)
msg.report(sent_bytes, recv_bytes)
def client(server_addr):
"""Client - sending and receiving threads
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
receiver = threading.Thread(target=recv_loop, args=(sock, ))
receiver.start() # start recv_loop thread
# main thread continues hereafter
for message in msg.msgs(20, length=2000):
n_sent = sock.send(message)
sent_bytes.append(n_sent)
sock.shutdown(socket.SHUT_WR) # send FIN. This will stop receiver thread
receiver.join() # wait for receiver exit
sock.close()
print('Client terminated')
msg.report(sent_bytes, recv_bytes)
def client(server_addr):
"""Client implemented with threads"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
in_file = sock.makefile('rb') # file-like obj
out_file = sock.makefile('wb') # file-like obj
receiver = threading.Thread(target=recv_loop, args=(in_file, ))
receiver.start() # start recv_loop thread
# main thread continues hereafter
sent_bytes = []
for message in msg.msgs(20, max_length=2000):
out_file.write(message) # buffered
sent_bytes.append(len(message))
out_file.flush() # flush-out buffer to send immediately
sock.shutdown(socket.SHUT_WR) # send FIN. This will stop receiver thread
print('sent: {}'.format(sum(sent_bytes)))
receiver.join() # wait for receiver exit
sock.close()
print('Client terminated')
def client(server_addr):
"""Client - converting to file-like object to allow buffered I/O
Assumption: request/response messages ending with LF
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(server_addr) # connect to server process
# Note: binary mode preserve the data
# does not convert encodings and line ending as in text mode.
file = sock.makefile('rwb') # file-like obj in read/write binary mode
sent_bytes = []
recv_bytes = []
for message in msg.msgs(20, length=2000):
n_sent = file.write(message)
file.flush() # flush-out buffer to send immediately
sent_bytes.append(n_sent)
data = file.readline() # receive response
if not data:
break
recv_bytes.append(len(data))
file.close()
sock.close()
msg.report(sent_bytes, recv_bytes)
