Un balanceador de carga: turnos, pesos, menos conexiones, hash de IP y caídas

1import sys
2
3ALGORITMOS = ("turno", "ponderado", "menos-conexiones", "hash-ip")
4
5
6def ip_a_entero(ip):
7    """'10.0.0.5' → 167772165, o None si no es una IPv4 válida."""
8    partes = ip.split(".")
9    if len(partes) != 4 or not all(p.isdigit() and int(p) <= 255 for p in partes):
10        return None
11    n = 0
12    for p in partes:
13        n = n * 256 + int(p)
14    return n
15
16class Balanceador:
17    def __init__(self, algoritmo, servidores):
18        self.algoritmo = algoritmo
19        self.servidores = servidores                 # [(nombre, peso)] en el orden de la configuración
20        self.caidos = set()
21        self.activas = {s: [] for s, _ in servidores}    # fin de cada conexión abierta
22        self.servidas = {s: 0 for s, _ in servidores}
23        self.maximo = {s: 0 for s, _ in servidores}
24        self.turno = 0
25        self.actual = {s: 0 for s, _ in servidores}      # contadores del ponderado suave
26        self.sin_servicio = 0
27
28    def disponibles(self):
29        return [(s, p) for s, p in self.servidores if s not in self.caidos]
30
31    def liberar(self, t):
32        for s in self.activas:
33            self.activas[s] = [f for f in self.activas[s] if f > t]
34
35    def elegir(self, ip):
36        vivos = self.disponibles()
37        if not vivos:
38            return None
39        if self.algoritmo == "turno":
40            nombres = [s for s, _ in self.servidores]
41            for k in range(len(nombres)):
42                s = nombres[(self.turno + k) % len(nombres)]
43                if s not in self.caidos:
44                    self.turno = (nombres.index(s) + 1) % len(nombres)
45                    return s
46        if self.algoritmo == "ponderado":
47            # round robin ponderado suave (el de nginx): reparte sin rachas largas del mismo servidor
48            total = sum(p for _, p in vivos)
49            for s, p in vivos:
50                self.actual[s] += p
51            elegido = max(vivos, key=lambda sp: self.actual[sp[0]])[0]
52            self.actual[elegido] -= total
53            return elegido
54        if self.algoritmo == "menos-conexiones":
55            return min(vivos, key=lambda sp: len(self.activas[sp[0]]))[0]
56        return vivos[ip_a_entero(ip) % len(vivos)][0]
57
58    def estado(self):
59        return " ".join(f"{s}:{'caído' if s in self.caidos else len(self.activas[s])}" for s, _ in self.servidores)
60
61    def peticion(self, t, ip, duracion):
62        s = self.elegir(ip)
63        if s is None:
64            self.sin_servicio += 1
65            return f"t={t} {ip} → 503 Service Unavailable (ningún servidor disponible)"
66        self.activas[s].append(t + duracion)
67        self.servidas[s] += 1
68        self.maximo[s] = max(self.maximo[s], len(self.activas[s]))
69        return f"t={t} {ip} → {s} [{self.estado()}]"
70
71    def cambiar(self, t, nombre, caido):
72        if (nombre in self.caidos) == caido:
73            return f"t={t} {nombre} ya estaba {'caído' if caido else 'disponible'}"
74        if caido:
75            self.caidos.add(nombre)
76        else:
77            self.caidos.discard(nombre)
78        self.actual = {s: 0 for s, _ in self.servidores}    # cambia el reparto: los contadores empiezan de cero
79        return f"t={t} {nombre} {'deja de responder' if caido else 'vuelve a responder'}"
80
81
82def main():
83    lineas = sys.stdin.read().splitlines()
84    algoritmo, servidores, i = None, [], 0
85    while i < len(lineas) and lineas[i].strip() != "---":
86        p = lineas[i].split()
87        if len(p) == 2 and p[0] == "algoritmo" and p[1] in ALGORITMOS:
88            algoritmo = p[1]
89        elif len(p) == 3 and p[0] == "servidor" and p[2].isdigit() and int(p[2]) > 0 and p[1] not in [s for s, _ in servidores]:
90            servidores.append((p[1], int(p[2])))
91        elif p:
92            print(f"Línea {i + 1}: no se entiende «{lineas[i].strip()}»")
93        i += 1
94    if algoritmo is None or not servidores:
95        print("Hace falta un algoritmo y al menos un servidor")
96        return
97    print(f"Algoritmo: {algoritmo} · servidores: " + ", ".join(f"{s} (peso {p})" for s, p in servidores))
98    b = Balanceador(algoritmo, servidores)
99    ultimo = 0
100    for num in range(i + 1, len(lineas)):
101        p = lineas[num].split()
102        if not p:
103            continue
104        valido = len(p) >= 3 and p[0].isdigit()
105        if valido and p[1] == "peticion":
106            valido = len(p) == 4 and ip_a_entero(p[2]) is not None and p[3].isdigit() and int(p[3]) > 0
107        elif valido and p[1] in ("caido", "recuperado"):
108            valido = len(p) == 3
109        else:
110            valido = False
111        if not valido:
112            print(f"Línea {num + 1}: no se entiende «{lineas[num].strip()}»")
113            continue
114        t = int(p[0])
115        if t < ultimo:
116            print(f"Línea {num + 1}: el tiempo no puede ir hacia atrás")
117            continue
118        ultimo = t
119        b.liberar(t)
120        if p[1] == "peticion":
121            print(b.peticion(t, p[2], int(p[3])))
122        elif p[2] not in b.activas:
123            print(f"Línea {num + 1}: servidor desconocido «{p[2]}»")
124        else:
125            print(b.cambiar(t, p[2], p[1] == "caido"))
126    total = sum(b.servidas.values())
127    print("Resumen:")
128    for s, _ in servidores:
129        n = b.servidas[s]
130        print(f"  {s}: {n} {'petición' if n == 1 else 'peticiones'} ({round(n * 100 / total) if total else 0} %), máximo {b.maximo[s]} a la vez")
131    print(f"  Sin servicio (503): {b.sin_servicio}")
132
133
134main()