Ejercicio resuelto: protocolo de texto sobre TCP con buffer en Python

La solución separa dos responsabilidades, igual que se haría en un servidor real. La capa de framing (función simular) solo sabe acumular segmentos y cortar mensajes completos. La capa de aplicación (función atender) recibe un mensaje ya completo y decide la respuesta. Así cada parte se puede razonar y probar por separado, y cambiar el delimitador no obliga a tocar la lógica de las órdenes.

import sys

TERMINADOR = "|"


def atender(mensaje, almacen):
    """Procesa un mensaje completo y no vacio. Devuelve (respuesta, cerrar)."""
    partes = mensaje.split(None, 2)
    orden = partes[0].upper()
    args = partes[1:]
    if orden == "SET":
        if len(args) != 2:
            return "ERR 400 argumentos", False
        almacen[args[0]] = args[1]
        return "OK", False
    if orden in ("GET", "DEL"):
        if len(args) != 1:
            return "ERR 400 argumentos", False
        clave = args[0]
        if clave not in almacen:
            return "ERR 404", False
        if orden == "GET":
            return "VAL " + almacen[clave], False
        del almacen[clave]
        return "OK", False
    if orden == "COUNT":
        if args:
            return "ERR 400 argumentos", False
        return "VAL " + str(len(almacen)), False
    if orden == "QUIT":
        if args:
            return "ERR 400 argumentos", False
        return "BYE", True
    return "ERR 400 comando desconocido", False


def simular(segmentos):
    """Reensambla el flujo TCP y devuelve (respuestas, procesados, pendientes)."""
    almacen = {}
    buffer = ""
    respuestas = []
    procesados = 0
    for i, segmento in enumerate(segmentos):
        buffer += segmento
        while TERMINADOR in buffer:
            mensaje, buffer = buffer.split(TERMINADOR, 1)
            mensaje = mensaje.strip()
            if not mensaje:
                continue
            respuesta, cerrar = atender(mensaje, almacen)
            respuestas.append(respuesta)
            procesados += 1
            if cerrar:
                descartados = sum(len(s) for s in segmentos[i + 1:])
                return respuestas, procesados, len(buffer) + descartados
    return respuestas, procesados, len(buffer)


def main():
    lineas = sys.stdin.read().split("\n")
    n = int(lineas[0]) if lineas[0].strip() else 0
    segmentos = [linea.rstrip("\r") for linea in lineas[1:1 + n]]
    respuestas, procesados, pendientes = simular(segmentos)
    for respuesta in respuestas:
        print(respuesta)
    print(f"RESUMEN procesados={procesados} pendientes={pendientes}")


if __name__ == "__main__":
    main()

Lectura. En main se lee toda la entrada con sys.stdin.read() y se divide por saltos de línea. Es deliberado no usar strip() sobre los segmentos: solo se quita un posible \r final. En el ejemplo, el cuarto segmento empieza por un espacio que separa la clave talla del valor M; si se recortara, el buffer contendría SET tallaM y el servidor respondería ERR 400 argumentos en lugar de OK. Si la primera línea está vacía, n vale 0, y así funciona el caso de entrada vacía.

Framing. En simular, la variable buffer es el estado de la conexión. Cada segmento se concatena y, mientras haya un TERMINADOR, buffer.split(TERMINADOR, 1) separa el primer mensaje completo del resto. En el ejemplo, tras el primer segmento el buffer queda en SET color az y no se responde nada; con el segundo se completa SET color azul, se responde OK y queda GET col esperando. El tercer segmento cierra ese GET y trae tres órdenes más, que el bucle while atiende sin salir del mismo segmento.

Mensajes vacíos. El strip() sí se aplica aquí, al mensaje ya cortado, porque el enunciado lo exige. Un || o un mensaje formado solo por espacios produce una cadena vacía y el continue lo salta sin incrementar procesados. El test de órdenes mixtas incluye ambos casos y por eso cuenta 9 mensajes atendidos, aunque el flujo contenga 11 delimitadores.

Capa de aplicación. En atender, mensaje.split(None, 2) divide por cualquier secuencia de espacios en, como mucho, tres piezas. Para set saludo hola mundo produce la orden, la clave y hola mundo con sus dos espacios internos, que es justo lo que devuelve el GET posterior. Solo la orden pasa por upper(); la clave se usa tal cual, porque distingue mayúsculas. La lista args sirve para validar: GET a b deja dos argumentos y se rechaza, igual que Count extra o quit now.

Cierre y resumen. atender devuelve una tupla cuyo segundo elemento indica si hay que cerrar. Cuando QUIT devuelve True, simular calcula los pendientes como lo que queda en buffer más la longitud de todos los segmentos posteriores (segmentos[i + 1:]). En el ejemplo queda GET color| en el buffer, 10 caracteres, y no hay más segmentos. En el test de QUIT temprano quedan SET a (5) y dos segmentos de 3 y 6 caracteres: 14. Si no hay QUIT, como en el test de fragmento final, se devuelve la longitud del buffer: SET k3, 6.