Sync from GitHub with Git LFS

agents/bootstrap.txt

@@ -1,2 +1,3 @@
-http://node1.mesh.local:8000
-http://node2.mesh.local:8000
+tcp://node1.mesh.local:8000
+udp://node2.mesh.local:8000
+any://node3.mesh.local:8000

agents/peer_sync.py

@@ -2,12 +2,15 @@
 
 """
 peer_sync.py — фоновый процесс синхронизации пиров в сети HMP
+с поддержкой tcp://, udp:// и any:// адресов
 """
 
 import socket
 import threading
 import time
 import json
+import uuid
+import requests
 from tools.storage import Storage
 
 storage = Storage()
@@ -17,7 +20,6 @@ storage = Storage()
 # ======================
 
 def udp_discovery_listener(udp_port: int):
-    """Слушаем UDP-пакеты"""
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     sock.bind(("", udp_port))
@@ -29,13 +31,25 @@ def udp_discovery_listener(udp_port: int):
             peer_id = msg.get("id")
             name = msg.get("name", "unknown")
             addresses = msg.get("addresses", [f"{addr[0]}:{msg.get('tcp_port', udp_port)}"])
-            storage.add_or_update_peer(peer_id, name, addresses, source="discovery", status="online")
+
+            # Обрабатываем все адреса через normalize_address
+            normalized_addresses = []
+            for a in addresses:
+                norm = storage.normalize_address(a)
+                if norm is None:
+                    continue
+                proto, hostport = norm.split("://")
+                # UDP и any учитываются для UDP discovery
+                if proto in ["udp", "any"]:
+                    normalized_addresses.append(norm)
+
+            if normalized_addresses:
+                storage.add_or_update_peer(peer_id, name, normalized_addresses, source="discovery", status="online")
+
         except Exception as e:
             print("[PeerSync] Ошибка при обработке UDP пакета:", e)
 
-
 def udp_discovery_sender(agent_id: str, agent_name: str, udp_port: int, tcp_port: int):
-    """Рассылаем UDP multicast/broadcast пакеты"""
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
     sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
 
@@ -52,42 +66,46 @@ def udp_discovery_sender(agent_id: str, agent_name: str, udp_port: int, tcp_port
 
     while True:
         now = time.time()
-        # Multicast раз в минуту
         if int(now) % DISCOVERY_INTERVAL == 0:
             sock.sendto(json.dumps(msg).encode("utf-8"), ("239.255.0.1", udp_port))
-        # Broadcast раз в 10 минут
         if now - last_broadcast > BROADCAST_INTERVAL:
             sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
             sock.sendto(json.dumps(msg).encode("utf-8"), ("255.255.255.255", udp_port))
             last_broadcast = now
         time.sleep(1)
 
-
 # ======================
 # Peer Exchange (TCP)
 # ======================
 
 def peer_exchange():
-    """Периодический обмен списками пиров"""
     PEER_EXCHANGE_INTERVAL = 120
     while True:
         peers = storage.get_online_peers(limit=50)
         for peer in peers:
             peer_id, addresses = peer["id"], peer["addresses"]
             try:
-                addr = json.loads(addresses)[0]
-                host, port = addr.split(":")
-                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                s.settimeout(2)
-                s.connect((host, int(port)))
-                # пока только "каркас"
-                s.sendall(b"PEER_EXCHANGE_REQUEST")
-                s.close()
+                addr_list = json.loads(addresses)
+                for addr in addr_list:
+                    proto, hostport = addr.split("://") if "://" in addr else ("any", addr)
+                    if proto not in ["tcp", "any"]:
+                        continue  # пропускаем UDP
+
+                    host, port = hostport.split(":")
+                    try:
+                        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                        s.settimeout(2)
+                        s.connect((host, int(port)))
+                        s.sendall(b"PEER_EXCHANGE_REQUEST")
+                        s.close()
+                        print(f"[PeerSync] Успешно подключились к {peer_id} ({addr})")
+                        break  # успешное подключение — можно не пробовать остальные адреса
+                    except Exception as e:
+                        print(f"[PeerSync] Не удалось подключиться к {peer_id} ({addr}): {e}")
             except Exception as e:
-                print(f"[PeerSync] Не удалось подключиться к {peer_id} ({addresses}): {e}")
+                print(f"[PeerSync] Ошибка обработки адресов {peer_id} ({addresses}): {e}")
         time.sleep(PEER_EXCHANGE_INTERVAL)
 
-
 # ======================
 # Основной запуск
 # ======================
@@ -95,22 +113,16 @@ def peer_exchange():
 def start_sync():
     print("[PeerSync] Запуск фоновой синхронизации")
 
-    # 1. Конфиг
     udp_port = int(storage.get_config_value("udp_port", 4000))
     tcp_port = int(storage.get_config_value("tcp_port", 5000))
     agent_id = storage.get_config_value("agent_id", "unknown-agent")
     agent_name = storage.get_config_value("agent_name", "HMP-Agent")
 
-    # 2. Bootstrap загрузка
     storage.load_bootstrap()
 
-    # 3. UDP discovery
     threading.Thread(target=udp_discovery_listener, args=(udp_port,), daemon=True).start()
     threading.Thread(target=udp_discovery_sender, args=(agent_id, agent_name, udp_port, tcp_port), daemon=True).start()
-
-    # 4. Peer exchange (TCP)
     threading.Thread(target=peer_exchange, daemon=True).start()
 
-    # вечный цикл (чтобы поток не завершался)
     while True:
         time.sleep(60)

agents/tools/storage.py

@@ -896,24 +896,92 @@ class Storage:
         c.execute("SELECT id, addresses FROM agent_peers WHERE status='online' LIMIT ?", (limit,))
         return c.fetchall()
 
+    def normalize_address(self, addr: str) -> str:
+        """Нормализует адрес в формате tcp://, udp:// или any://"""
+        addr = addr.strip()
+        if not addr:
+            return None
+
+        if "://" not in addr:
+            # Универсальная запись → считаем, что оба порта используются
+            return f"any://{addr}"
+
+        return addr
+
     def load_bootstrap(self, bootstrap_file="bootstrap.txt"):
-        if not os.path.exists(bootstrap_file):
+        """
+        Загружает узлы из bootstrap.txt.
+        Поддерживаются адреса:
+            tcp://host:port
+            udp://host:port
+            any://host:port
+        TCP-узлы проверяются запросом /identity.
+        UDP/any регистрируются без проверки (any учитывается как TCP+UDP).
+        """
+        import requests
+
+        # Абсолютный путь к bootstrap.txt в корне проекта
+        base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+        bootstrap_path = os.path.join(base_path, bootstrap_file)
+
+        if not os.path.exists(bootstrap_path):
+            print(f"[Bootstrap] Файл {bootstrap_file} не найден по пути {bootstrap_path}")
             return
-        with open(bootstrap_file, "r", encoding="utf-8") as f:
-            for line in f:
-                line = line.strip()
-                if not line or line.startswith("#"):
+
+        for line in open(bootstrap_path, encoding="utf-8"):
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            try:
+                addr = self.normalize_address(line)
+                if addr is None:
                     continue
-                # Пример: http://node1.mesh.local:8000
-                try:
-                    peer_url = line
-                    peer_id = str(uuid.uuid4())  # временно генерим ID, потом можно подтянуть DID
-                    name = peer_url.split("://")[1].split(":")[0]
-                    self.add_or_update_peer(peer_id, name, [peer_url], source="bootstrap")
-                except Exception as e:
-                    print(f"[Storage] Ошибка парсинга bootstrap: {line} -> {e}")
 
-    # Утилиты
+                proto, hostport = addr.split("://")
+
+                # TCP или any → проверяем identity
+                if proto in ["tcp", "any"]:
+                    try:
+                        url = f"http://{hostport}/identity"
+                        r = requests.get(url, timeout=3)
+                        if r.status_code == 200:
+                            info = r.json()
+                            peer_id = info.get("id")
+                            name = info.get("name", "unknown")
+                            pubkey = info.get("pubkey")
+                            capabilities = info.get("capabilities", {})
+
+                            self.add_or_update_peer(
+                                peer_id=peer_id,
+                                name=name,
+                                addresses=[addr],
+                                source="bootstrap",
+                                status="online",
+                                pubkey=pubkey,
+                                capabilities=capabilities,
+                            )
+                            print(f"[Bootstrap] Добавлен узел {peer_id} ({addr})")
+                        else:
+                            print(f"[Bootstrap] {addr} недоступен (HTTP {r.status_code})")
+                    except Exception as e:
+                        print(f"[Bootstrap] Ошибка при подключении к {addr}: {e}")
+
+                # UDP или any → просто регистрируем
+                if proto in ["udp", "any"]:
+                    peer_id = str(uuid.uuid4())
+                    self.add_or_update_peer(
+                        peer_id=peer_id,
+                        name="unknown",
+                        addresses=[addr],
+                        source="bootstrap",
+                        status="unknown"
+                    )
+                    print(f"[Bootstrap] Добавлен адрес (без проверки): {addr}")
+
+            except Exception as e:
+                print(f"[Bootstrap] Ошибка парсинга {line}: {e}")
 
+    # Утилиты
     def close(self):
         self.conn.close()