def make_client(address, file_path, chunk_size):
logger.info('client running')
tcp = TCP()
tcp.start()
conn = dial(address)
logger.info('client connected to server')
data = []
while True:
chunk = recv(conn, chunk_size)
if len(chunk) == 0:
break
logger.info(f'chunk received. length: {len(chunk)}')
data.append(chunk)
data = b''.join(data)
with open(file_path, 'wb') as fp:
fp.write(data)
logger.info(f'data saved. length: {len(data)}')
def make_server(address, file_path, chunk_size):
logger.info('server running')
tcp = TCP()
tcp.start()
executor = ThreadPoolExecutor()
connections = []
server = listen(address)
while True:
try:
conn = accept(server)
future = executor.submit(handle, conn, file_path, chunk_size)
connections.append((conn, future))
except KeyboardInterrupt:
logger.info('closing server')
break
except Exception as e:
logger.exception(e)
logger.info('releasing resources')
executor.shutdown(True)
import argparse
from trapy.tcp.tcp import TCP
parser = argparse.ArgumentParser()
parser.add_argument("-listen",
required=False,
type=str,
default="",
help="Listening host of transport layer")
args = parser.parse_args()
tcp = TCP(args.listen)
tcp.start()
tcp.wait()
def listen(address: str) -> Conn:
"""
prepara una conexión que acepta los paquetes enviados a `address`.
"""
return TCP.start_server(address)
def close(conn: Conn):
"""
termina la conexión.
"""
TCP.close_connection(conn)
def recv(conn: Conn, length: int) -> bytes:
"""
bytes recibe a lo sumo `length` bytes almacenados en el buffer de la conexión.
"""
return TCP.recv(conn, length)
def send(conn: Conn, data: bytes) -> int:
"""
envía los datos por la conexión y devuelve la cantidad de bytes enviados.
"""
return TCP.send(conn, data)
def dial(address: str) -> Conn:
"""
establece conexión con el otro extremo indicado en `address` y devuelve la conexión.
"""
return TCP.start_connection(address)
def accept(conn: Conn) -> Conn:
"""
espera por alguna petición de conexión utilizando un `conn` creado previamente con `listen`.
"""
return TCP.accept(conn)