Sync from GitHub with Git LFS

agents/peer_sync.py

@@ -1,29 +1,64 @@
 # agents/peer_sync.py
 
-"""
-peer_sync.py — фоновый процесс синхронизации пиров в сети HMP
-с поддержкой tcp://, udp:// и any:// адресов
-"""
-
 import socket
 import threading
 import time
 import json
 import uuid
-import requests
+import ipaddress
 from tools.storage import Storage
 
 storage = Storage()
+my_id = storage.get_config_value("agent_id", "")
 
 # ======================
-# UDP Discovery
+# LAN Discovery
 # ======================
+def lan_discovery(udp_port: int):
+    """
+    Периодический поиск локальных агентов в сети.
+    """
+    DISCOVERY_INTERVAL = 300  # каждые 5 минут
 
+    while True:
+        local_ip = get_local_ip()
+        if not local_ip:
+            time.sleep(DISCOVERY_INTERVAL)
+            continue
+
+        net = ipaddress.ip_network(local_ip + '/24', strict=False)  # /24 по умолчанию
+        for ip in net.hosts():
+            if str(ip) == local_ip:
+                continue  # пропускаем себя
+            try:
+                sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+                sock.settimeout(0.5)
+                msg = json.dumps({"ping": "HMP"}).encode("utf-8")
+                sock.sendto(msg, (str(ip), udp_port))
+                sock.close()
+            except:
+                continue
+
+        time.sleep(DISCOVERY_INTERVAL)
+
+def get_local_ip():
+    """Возвращает локальный IP хоста."""
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.connect(("8.8.8.8", 80))
+        ip = s.getsockname()[0]
+        s.close()
+        return ip
+    except:
+        return None
+
+# ======================
+# UDP Discovery
+# ======================
 def udp_discovery_listener(udp_port: int):
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     sock.bind(("", udp_port))
-
     while True:
         data, addr = sock.recvfrom(1024)
         try:
@@ -31,39 +66,26 @@ 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)}"])
-
-            # Обрабатываем все адреса через 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")
-
+                storage.add_or_update_peer(peer_id, name, normalized_addresses, "discovery", "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):
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
     sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
-
-    msg = {
-        "id": agent_id,
-        "name": agent_name,
-        "tcp_port": tcp_port,
-        "addresses": [f"127.0.0.1:{tcp_port}"]
-    }
-
+    msg = {"id": agent_id, "name": agent_name, "tcp_port": tcp_port, "addresses": [f"127.0.0.1:{tcp_port}"]}
     last_broadcast = 0
     DISCOVERY_INTERVAL = 60
     BROADCAST_INTERVAL = 600
-
     while True:
         now = time.time()
         if int(now) % DISCOVERY_INTERVAL == 0:
@@ -77,27 +99,25 @@ def udp_discovery_sender(agent_id: str, agent_name: str, udp_port: int, tcp_port
 # ======================
 # 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"]
+
+            if peer_id == my_id:
+                continue  # пропускаем собственный агент
+
             try:
                 addr_list = json.loads(addresses)
                 for addr in addr_list:
-                    # Нормализация адреса через storage
                     norm = storage.normalize_address(addr)
                     if norm is None:
                         continue
-
                     proto, hostport = norm.split("://")
-
-                    # TCP и any обрабатываются как TCP
                     if proto not in ["tcp", "any"]:
-                        continue  # пропускаем UDP
-
+                        continue
                     try:
                         host, port = hostport.split(":")
                         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -106,25 +126,21 @@ def peer_exchange():
                         s.sendall(b"PEER_EXCHANGE_REQUEST")
                         s.close()
                         print(f"[PeerSync] Успешно подключились к {peer_id} ({norm})")
-                        break  # успешное подключение — остальные адреса не пробуем
+                        break
                     except Exception as e:
                         print(f"[PeerSync] Не удалось подключиться к {peer_id} ({norm}): {e}")
-
             except Exception as e:
                 print(f"[PeerSync] Ошибка обработки адресов {peer_id} ({addresses}): {e}")
-
         time.sleep(PEER_EXCHANGE_INTERVAL)
 
 # ======================
 # Основной запуск
 # ======================
-
 def start_sync():
     print("[PeerSync] Запуск фоновой синхронизации")
-
     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_id = storage.get_config_value("agent_id", str(uuid.uuid4()))
     agent_name = storage.get_config_value("agent_name", "HMP-Agent")
 
     storage.load_bootstrap()
@@ -132,6 +148,7 @@ def start_sync():
     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()
     threading.Thread(target=peer_exchange, daemon=True).start()
+    threading.Thread(target=lan_discovery, args=(udp_port,), daemon=True).start()  # новый поток
 
     while True:
         time.sleep(60)

agents/tools/storage.py

@@ -7,11 +7,13 @@ import json
 import uuid
 import time
 
-from datetime import datetime, timedelta, UTC
+from datetime import datetime, timedelta, UTC, timezone
 from werkzeug.security import generate_password_hash, check_password_hash
 from tools.identity import generate_did
 from tools.crypto import generate_keypair
 
+UTC = timezone.utc
+
 SCRIPTS_BASE_PATH = "scripts"
 
 class Storage:
@@ -724,6 +726,14 @@ class Storage:
 
         return value
 
+    def set_config_value(self, key, value):
+        c = self.conn.cursor()
+        c.execute("""
+            INSERT INTO config(key, value) VALUES (?, ?)
+            ON CONFLICT(key) DO UPDATE SET value=excluded.value
+        """, (key, value))
+        self.conn.commit()
+
     # Web-интерфейс и API
     def write_note(self, content, user_did="anon", source="user", hidden=0):
         timestamp = datetime.now(UTC).isoformat()
@@ -896,18 +906,16 @@ 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
 
+    # Bootstrap
     def load_bootstrap(self, bootstrap_file="bootstrap.txt"):
         """
         Загружает узлы из bootstrap.txt.