Upload 65 files

DeviceManager.py

@@ -1,82 +1,82 @@
-import subprocess
-import GPUtil
-import psutil
-import logging
-from peer_discovery import PORT, PORT
-
-logging.getLogger().setLevel(logging.CRITICAL)  # صامت
-
-class DeviceManager:
-    def __init__(self):
-        self.devices = {
-            "GPU": self._detect_gpus(),
-            "DSP": self._detect_dsps(),
-            "NIC": self._detect_nics(),
-            "STORAGE": self._detect_storage(),
-            "CAPTURE": self._detect_capture(),
-            "ACCELERATOR": self._detect_accelerators()
-        }
-
-    # ────────────── اكتشاف الكروت ──────────────
-    def _detect_gpus(self):
-        try:
-            return GPUtil.getGPUs()
-        except:
-            return []
-
-    def _detect_dsps(self):
-        try:
-            output = subprocess.check_output(["aplay", "-l"], stderr=subprocess.DEVNULL).decode()
-            return ["DSP_Audio"] if "card" in output.lower() else []
-        except:
-            return []
-
-    def _detect_nics(self):
-        try:
-            return list(psutil.net_if_addrs().keys())
-        except:
-            return []
-
-    def _detect_storage(self):
-        try:
-            output = subprocess.check_output(["lsblk", "-o", "NAME"], stderr=subprocess.DEVNULL).decode()
-            return output.split() if output else []
-        except:
-            return []
-
-    def _detect_capture(self):
-        try:
-            output = subprocess.check_output(["v4l2-ctl", "--list-devices"], stderr=subprocess.DEVNULL).decode()
-            return output.split(":")[0::2] if output else []
-        except:
-            return []
-
-    def _detect_accelerators(self):
-        # افتراض: في المستقبل يمكن إضافة اكتشاف حقيقي لـ FPGA/TPU
-        return []
-
-    # ────────────── فحص الحمل ──────────────
-    def get_device_load(self, device_type, index=0):
-        try:
-            if device_type == "GPU" and self.devices["GPU"]:
-                return self.devices["GPU"][index].load * 100
-            elif device_type == "DSP" and self.devices["DSP"]:
-                return 10  # افتراضي: ما في API للحمل
-            elif device_type == "NIC" and self.devices["NIC"]:
-                return psutil.net_io_counters().bytes_sent / (1024 * 1024)  # مثال بسيط
-            elif device_type == "STORAGE" and self.devices["STORAGE"]:
-                return psutil.disk_usage('/').percent
-            elif device_type == "CAPTURE" and self.devices["CAPTURE"]:
-                return 20  # افتراضي: حمل منخفض
-            elif device_type == "ACCELERATOR" and self.devices["ACCELERATOR"]:
-                return 15  # افتراضي
-            return 0
-        except:
-            return 0
-
-    # ────────────── منطق 30% / 70% ──────────────
-    def can_receive(self, device_type, index=0):
-        return self.get_device_load(device_type, index) <= 30
-
-    def should_offload(self, device_type, index=0):
-        return self.get_device_load(device_type, index) >= 70
+import subprocess
+import GPUtil
+import psutil
+import logging
+from peer_discovery import PORT
+
+logging.getLogger().setLevel(logging.CRITICAL)  # صامت
+
+class DeviceManager:
+    def __init__(self):
+        self.devices = {
+            "GPU": self._detect_gpus(),
+            "DSP": self._detect_dsps(),
+            "NIC": self._detect_nics(),
+            "STORAGE": self._detect_storage(),
+            "CAPTURE": self._detect_capture(),
+            "ACCELERATOR": self._detect_accelerators()
+        }
+
+    # ────────────── اكتشاف الكروت ──────────────
+    def _detect_gpus(self):
+        try:
+            return GPUtil.getGPUs()
+        except:
+            return []
+
+    def _detect_dsps(self):
+        try:
+            output = subprocess.check_output(["aplay", "-l"], stderr=subprocess.DEVNULL).decode()
+            return ["DSP_Audio"] if "card" in output.lower() else []
+        except:
+            return []
+
+    def _detect_nics(self):
+        try:
+            return list(psutil.net_if_addrs().keys())
+        except:
+            return []
+
+    def _detect_storage(self):
+        try:
+            output = subprocess.check_output(["lsblk", "-o", "NAME"], stderr=subprocess.DEVNULL).decode()
+            return output.split() if output else []
+        except:
+            return []
+
+    def _detect_capture(self):
+        try:
+            output = subprocess.check_output(["v4l2-ctl", "--list-devices"], stderr=subprocess.DEVNULL).decode()
+            return output.split(":")[0::2] if output else []
+        except:
+            return []
+
+    def _detect_accelerators(self):
+        # افتراض: في المستقبل يمكن إضافة اكتشاف ��قيقي لـ FPGA/TPU
+        return []
+
+    # ────────────── فحص الحمل ──────────────
+    def get_device_load(self, device_type, index=0):
+        try:
+            if device_type == "GPU" and self.devices["GPU"]:
+                return self.devices["GPU"][index].load * 100
+            elif device_type == "DSP" and self.devices["DSP"]:
+                return 10  # افتراضي: ما في API للحمل
+            elif device_type == "NIC" and self.devices["NIC"]:
+                return psutil.net_io_counters().bytes_sent / (1024 * 1024)  # مثال بسيط
+            elif device_type == "STORAGE" and self.devices["STORAGE"]:
+                return psutil.disk_usage('/').percent
+            elif device_type == "CAPTURE" and self.devices["CAPTURE"]:
+                return 20  # افتراضي: حمل منخفض
+            elif device_type == "ACCELERATOR" and self.devices["ACCELERATOR"]:
+                return 15  # افتراضي
+            return 0
+        except:
+            return 0
+
+    # ────────────── منطق 30% / 70% ──────────────
+    def can_receive(self, device_type, index=0):
+        return self.get_device_load(device_type, index) <= 30
+
+    def should_offload(self, device_type, index=0):
+        return self.get_device_load(device_type, index) >= 70

README_FIXES.md

@@ -0,0 +1,61 @@
+    # AmalOffload v6 — Fix Pack
+
+    تم إنشاء نسخة مُرقّعة من المشروع مع إصلاحات أساسية تمنع الأعطال الفورية وتسهّل التشغيل.
+
+    ## ما الذي تم إصلاحه؟
+    - autostart_config.py: dedup import of PORT
+- background_service.py: dedup import of PORT
+- central_manager.py: dedup import of PORT
+- control.py: dedup import of PORT
+- dashboard.py: dedup import of PORT
+- DeviceManager.py: dedup import of PORT
+- distributed_executor.py: dedup import of PORT
+- dts_cli.py: dedup import of PORT
+- enhanced_assistant.py: dedup import of PORT
+- external_server.py: dedup import of PORT
+- internet_scanner.py: dedup import of PORT
+- launcher.py: dedup import of PORT
+- live_streaming.py: dedup import of PORT
+- load_balancer.py: dedup import of PORT
+- peer_registry.py: dedup import of PORT
+- peer_server.py: dedup import of PORT
+- remote_executor.py: dedup import of PORT
+- rpc_server.py: dedup import of PORT
+- security_layer.py: dedup import of PORT
+- server.py: dedup import of PORT
+- smart_tasks.py: dedup import of PORT
+- system_check.py: dedup import of PORT
+- system_tray.py: dedup import of PORT
+- task_splitter.py: dedup import of PORT
+- test_distributed_system.py: dedup import of PORT
+- test_monitor.py: dedup import of PORT
+- video_processing.py: dedup import of PORT
+- your_tasks.py: dedup import of PORT
+- control.py: fixed broken import line
+- dts_cli.py: rewritten to a minimal, valid CLI
+- ram_manager.py: removed BOM
+- templates/dashboard.html: created from index.html
+- config.py: added as a single source of truth for PORT
+
+    ## توصيات إضافية (يدويّة)
+    - أضِف `fastapi` و`uvicorn` إلى `requirements.txt` إذا أردت تشغيل `central_manager.py` (يستخدم FastAPI).
+    - وحّد استيراد المنفذ عبر:
+      ```python
+      from config import PORT
+      ```
+      واستبدل أي استخدام لـ `from peer_discovery import PORT, PORT` أو `CPU_PORT` حسب الحاجة.
+    - إن ظهرت مشكلة `TemplateNotFound: dashboard.html` فقد تم إنشاء `templates/dashboard.html` تلقائياً.
+    - يُفضّل تنظيف `requirements.txt` من التكرارات (انظر التوصيات في تقرير التدقيق).
+    - اختر نقطة دخول واحدة للمشروع (مثلاً: `launcher.py` أو `startup.py`) وتجنّب تشغيل أكثر من خادم في نفس العملية.
+
+    ## التشغيل السريع المقترح
+    1) ثبّت المتطلبات (الأساسية فقط):
+       ```bash
+       pip install flask flask_cors flask_socketio requests psutil zeroconf cryptography numpy networkx GPUtil python-dotenv
+       ```
+    2) شغّل الـ Dashboard وخادم RPC معاً:
+       ```bash
+       python dts_cli.py start
+       ```
+
+    بالتوفيق!

autostart_config.py

@@ -2,7 +2,7 @@ import json
 import os
 import platform
 from pathlib import Path
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 class AutoStartManager:
     def __init__(self, app_name="DistributedTaskSystem"):

background_service.py

@@ -16,7 +16,7 @@ from pathlib import Path
 from flask import Flask, jsonify, request
 import json
 from datetime import datetime
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 class BackgroundService:
     def __init__(self):

central_manager.py

@@ -8,7 +8,7 @@ from typing import Dict, List
 import requests
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 # ---- إعداد FastAPI ----------------------------------------------------------
 app = FastAPI(title="Central Task Manager")

config.py

@@ -1,10 +1,7 @@
-# config.py
+# config.py — نقطة مركزية لإعدادات المشروع
+import os, random
 
-OPENAI_API_KEY = "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"
-
-DEFAULT_LANGUAGE = "ar"
-DEFAULT_MODEL = "gpt-4"
-SYSTEM_PROMPT = """
-أنت مساعد ذكاء اصطناعي يتحكم به المستخدم عبر أوامر صوتية وكتابية، 
-يجب أن تستجيب بسرعة، وبدقة، وتتعلم من التعليمات الجديدة.
-"""
+# مصدر الحقيقة الوحيد لمنفذ الخدمة
+PORT = int(os.getenv("CPU_PORT", os.getenv("PORT", "0")))
+if PORT == 0:
+    PORT = random.randint(5000, 9999)

control.py

@@ -1,6 +1,4 @@
-import argparsefrom peer_discovery import PORT, PORT
-
-
+import argparse
 from autostart_config import AutoStartManager
 
 def main():

dashboard.py

@@ -1,59 +1,60 @@
-import logging
-import socket
-import threading
-import psutil
-import GPUtil
-from flask import Flask, render_template
-from flask_socketio import SocketIO, emit
-from peer_discovery import PEERS
-from peer_discovery import PORT, PORT
-
-logging.basicConfig(level=logging.INFO)
-
-app = Flask(__name__)
-socketio = SocketIO(app, cors_allowed_origins="*")
-
-node_id = socket.gethostname()
-connected_peers_data = {}
-
-# ─────────────── جمع بيانات الحمل ───────────────
-def get_system_status():
-    cpu = psutil.cpu_percent()
-    ram = psutil.virtual_memory().percent
-    gpu_load = 0
-    try:
-        gpus = GPUtil.getGPUs()
-        if gpus:
-            gpu_load = gpus[0].load * 100
-    except:
-        pass
-    return {"cpu": cpu, "ram": ram, "gpu": gpu_load}
-
-# ─────────────── إرسال التحديثات ───────────────
-def broadcast_status():
-    while True:
-        status = get_system_status()
-        socketio.emit("status_update", {node_id: status}, broadcast=True)
-        socketio.sleep(5)
-
-# ─────────────── صفحة الواجهة ───────────────
-@app.route("/")
-def index():
-    return render_template("dashboard.html", peers=connected_peers_data)
-
-# ─────────────── استقبال تحديثات الحالة ───────────────
-@socketio.on("status_update")
-def handle_status_update(data):
-    connected_peers_data.update(data)
-    emit("update_peers", connected_peers_data, broadcast=True)
-
-# ─────────────── دردشة ───────────────
-@socketio.on("send_message")
-def handle_message(data):
-    emit("receive_message", data, broadcast=True)
-
-# ─────────────── تشغيل ───────────────
-if __name__ == "__main__":
-    threading.Thread(target=broadcast_status).start()
-    logging.info(f"🚀 تشغيل Dashboard على {node_id}")
-    socketio.run(app, host="0.0.0.0", port=7000)
+import logging
+import socket
+import threading
+import psutil
+import GPUtil
+from flask import Flask, render_template
+from flask_socketio import SocketIO, emit
+from peer_discovery import PEERS
+from peer_discovery import PORT
+
+
+logging.basicConfig(level=logging.INFO)
+
+app = Flask(__name__)
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+node_id = socket.gethostname()
+connected_peers_data = {}
+
+# ─────────────── جمع بيانات الحمل ───────────────
+def get_system_status():
+    cpu = psutil.cpu_percent()
+    ram = psutil.virtual_memory().percent
+    gpu_load = 0
+    try:
+        gpus = GPUtil.getGPUs()
+        if gpus:
+            gpu_load = gpus[0].load * 100
+    except:
+        pass
+    return {"cpu": cpu, "ram": ram, "gpu": gpu_load}
+
+# ─────────────── إرسال التحديثات ───────────────
+def broadcast_status():
+    while True:
+        status = get_system_status()
+        socketio.emit("status_update", {node_id: status}, broadcast=True)
+        socketio.sleep(5)
+
+# ─────────────── صفحة الواجهة ───────────────
+@app.route("/")
+def index():
+    return render_template("dashboard.html", peers=connected_peers_data)
+
+# ─────────────── استقبال تحديثات الحالة ───────────────
+@socketio.on("status_update")
+def handle_status_update(data):
+    connected_peers_data.update(data)
+    emit("update_peers", connected_peers_data, broadcast=True)
+
+# ─────────────── دردشة ───────────────
+@socketio.on("send_message")
+def handle_message(data):
+    emit("receive_message", data, broadcast=True)
+
+# ─────────────── تشغيل ───────────────
+if __name__ == "__main__":
+    threading.Thread(target=broadcast_status).start()
+    logging.info(f"🚀 تشغيل Dashboard على {node_id}")
+    socketio.run(app, host="0.0.0.0", port=7000)

distributed_executor.py

@@ -10,7 +10,7 @@ import subprocess
 import psutil
 import GPUtil
 from processor_manager import ResourceMonitor
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 
 logging.basicConfig(level=logging.INFO)

dts_cli.py

@@ -1,65 +1,27 @@
-# dts_cli.py
+# dts_cli.py — أوامر CLI لتشغيل النظام الموزع
 import click
-from dashboard import app
-from rpc_server import app as rpc_app
 import threading
-from peer_discovery import PORT, PORT
+from peer_discovery import PEERS, PORT
+import dashboard
+import rpc_server
+
 @click.group()
 def cli():
     pass
 
 @cli.command()
 def start():
-    """بدء النظام الموزع"""
-    print("جارِ تشغيل النظام الموزع...")
-    
-    # تشغيل واجهة التحكم في خيط منفصل
-    dashboard_thread = threading.Thread(
-        target=lambda: app.run(host="0.0.0.0", port=5000)
-    )
-    dashboard_thread.daemon = True
-    dashboard_thread.start()
-    
-    # تشغيل خادم RPC
-    rpc_app.run(host="0.0.0.0", port=PORT)
+    """بدء Dashboard وخادم RPC معاً"""
+    # شغّل الـ Dashboard في خيط منفصل
+    t = threading.Thread(target=lambda: dashboard.socketio.run(dashboard.app, host="0.0.0.0", port=7000), daemon=True)
+    t.start()
+    # شغّل خادم RPC في الخيط الرئيسي
+    rpc_server.app.run(host="0.0.0.0", port=PORT)
 
 @cli.command()
-from flask import Flask, render_template, request
-
-# ... (الكود الحالي)
-
-@flask_app.route("/")
-def home():
-    tasks = {
-        "1": ("ضرب المصفوفات", "matrix"),
-        "2": ("حساب الأعداد الأولية", "prime"),
-        "3": ("معالجة البيانات", "data"),
-    }
-    return render_template("index.html", tasks=tasks)
-
-@flask_app.route("/run_task", methods=["POST"])
-def run_task():
-    task_id = request.form.get("task_id")
-    result = None
-    
-    if task_id == "1":
-        result = matrix_multiply(500)  # استبدل بمعاملاتك الفعلية
-    elif task_id == "2":
-        result = prime_calculation(100_000)
-    elif task_id == "3":
-        result = data_processing(10_000)
-    
-    return render_template("index.html", tasks={
-        "1": ("ضرب المصفوفات", "matrix"),
-        "2": ("حساب الأعداد الأولية", "prime"),
-        "3": ("معالجة البيانات", "data"),
-    }, result=result)
 def discover():
-    """عرض الأجهزة المتصلة"""
-    from peer_discovery import discover_peers
-    peers = discover_peers()
-    print("الأجهزة المتصلة:")
-    for i, peer in enumerate(peers, 1):
+    """طباعة قائمة الأقران المكتشفة"""
+    for i, peer in enumerate(sorted(PEERS), 1):
         print(f"{i}. {peer}")
 
 if __name__ == "__main__":

enhanced_assistant.py

@@ -9,7 +9,7 @@ from PIL import Image
 from io import BytesIO
 import re
 from datetime import datetime
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 class EnhancedNoraAssistant:
     def __init__(self):

external_server.py

@@ -1,98 +1,98 @@
-#!/usr/bin/env python3
-"""
-external_server.py — سيرفر مركزي لتوزيع المهام + Dashboard تفاعلي
-"""
-import logging
-import requests
-from flask import Flask, request, jsonify, render_template
-from flask_cors import CORS
-from flask_socketio import SocketIO, emit
-from peer_discovery import PEERS
-from peer_discovery import PORT, PORT
-
-logging.basicConfig(level=logging.INFO)
-
-app = Flask(__name__)
-CORS(app, resources={r"/*": {"origins": "*"}})
-socketio = SocketIO(app, cors_allowed_origins="*")
-
-connected_peers = {}  # {node_id: {"cpu":%, "ram":%, "gpu":%}}
-
-# ─────────────── اختيار أفضل Peer ───────────────
-def select_best_peer():
-    peers_list = list(PEERS)
-    if not peers_list:
-        logging.warning("⚠️ لا توجد أجهزة مسجلة حالياً.")
-        return None
-    
-    try:
-        peer_loads = []
-        for peer_url in peers_list:
-            try:
-                resp = requests.get(f"{peer_url.replace('/run_task','')}/status", timeout=2)
-                if resp.ok:
-                    data = resp.json()
-                    peer_loads.append((peer_url, data.get("cpu_load", 100)))
-            except:
-                continue
-        
-        if not peer_loads:
-            return None
-        
-        peer_loads.sort(key=lambda x: x[1])
-        return peer_loads[0][0]
-    except Exception as e:
-        logging.error(f"❌ خطأ في اختيار الـ Peer: {e}")
-        return None
-
-# ─────────────── API توزيع المهام ───────────────
-@app.route("/submit_task", methods=["POST"])
-def submit_task():
-    data = request.get_json()
-    if not data or "task_id" not in data:
-        return jsonify({"error": "يجب تحديد task_id"}), 400
-
-    peer = select_best_peer()
-    if not peer:
-        return jsonify({"error": "لا توجد أجهزة متاحة حالياً"}), 503
-    
-    try:
-        resp = requests.post(peer, json=data, timeout=10)
-        if resp.ok:
-            return jsonify({"status": "success", "result": resp.json()})
-        else:
-            return jsonify({"error": "فشل إرسال المهمة"}), 500
-    except Exception as e:
-        logging.error(f"❌ خطأ في إرسال المهمة: {e}")
-        return jsonify({"error": str(e)}), 500
-
-# ─────────────── API تحديث حالة الأجهزة ───────────────
-@app.route("/update_status", methods=["POST"])
-def update_status():
-    data = request.json
-    node_id = data.get("node_id")
-    if not node_id:
-        return jsonify({"error": "node_id مطلوب"}), 400
-    
-    connected_peers[node_id] = {
-        "cpu": data.get("cpu"),
-        "ram": data.get("ram"),
-        "gpu": data.get("gpu")
-    }
-    socketio.emit("update_peers", connected_peers, broadcast=True)
-    return jsonify({"status": "ok"})
-
-# ─────────────── صفحة Dashboard ───────────────
-@app.route("/")
-def index():
-    return render_template("dashboard.html")
-
-# ─────────────── دردشة ───────────────
-@socketio.on("send_message")
-def handle_message(data):
-    socketio.emit("receive_message", data, broadcast=True)
-
-# ─────────────── تشغيل السيرفر ───────────────
-if __name__ == "__main__":
-    logging.info("🚀 بدء السيرفر المركزي مع Dashboard ودردشة")
-    socketio.run(app, host="0.0.0.0", port =5005)
+#!/usr/bin/env python3
+"""
+external_server.py — سيرفر مركزي لتوزيع المهام + Dashboard تفاعلي
+"""
+import logging
+import requests
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS
+from flask_socketio import SocketIO, emit
+from peer_discovery import PEERS
+from peer_discovery import PORT
+
+logging.basicConfig(level=logging.INFO)
+
+app = Flask(__name__)
+CORS(app, resources={r"/*": {"origins": "*"}})
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+connected_peers = {}  # {node_id: {"cpu":%, "ram":%, "gpu":%}}
+
+# ─────────────── اختيار أفضل Peer ───────────────
+def select_best_peer():
+    peers_list = list(PEERS)
+    if not peers_list:
+        logging.warning("⚠️ لا توجد أجهزة مسجلة حالياً.")
+        return None
+    
+    try:
+        peer_loads = []
+        for peer_url in peers_list:
+            try:
+                resp = requests.get(f"{peer_url.replace('/run_task','')}/status", timeout=2)
+                if resp.ok:
+                    data = resp.json()
+                    peer_loads.append((peer_url, data.get("cpu_load", 100)))
+            except:
+                continue
+        
+        if not peer_loads:
+            return None
+        
+        peer_loads.sort(key=lambda x: x[1])
+        return peer_loads[0][0]
+    except Exception as e:
+        logging.error(f"❌ خطأ في اختيار الـ Peer: {e}")
+        return None
+
+# ─────────────── API توزيع المهام ───────────────
+@app.route("/submit_task", methods=["POST"])
+def submit_task():
+    data = request.get_json()
+    if not data or "task_id" not in data:
+        return jsonify({"error": "يجب تحديد task_id"}), 400
+
+    peer = select_best_peer()
+    if not peer:
+        return jsonify({"error": "لا توجد أجهزة متاحة حالياً"}), 503
+    
+    try:
+        resp = requests.post(peer, json=data, timeout=10)
+        if resp.ok:
+            return jsonify({"status": "success", "result": resp.json()})
+        else:
+            return jsonify({"error": "فشل إرسال المهمة"}), 500
+    except Exception as e:
+        logging.error(f"❌ خطأ في إرسال المهمة: {e}")
+        return jsonify({"error": str(e)}), 500
+
+# ─────────────── API تحديث حالة الأجهزة ───────────────
+@app.route("/update_status", methods=["POST"])
+def update_status():
+    data = request.json
+    node_id = data.get("node_id")
+    if not node_id:
+        return jsonify({"error": "node_id مطلوب"}), 400
+    
+    connected_peers[node_id] = {
+        "cpu": data.get("cpu"),
+        "ram": data.get("ram"),
+        "gpu": data.get("gpu")
+    }
+    socketio.emit("update_peers", connected_peers, broadcast=True)
+    return jsonify({"status": "ok"})
+
+# ─────────────── صفحة Dashboard ───────────────
+@app.route("/")
+def index():
+    return render_template("dashboard.html")
+
+# ─────────────── دردشة ───────────────
+@socketio.on("send_message")
+def handle_message(data):
+    socketio.emit("receive_message", data, broadcast=True)
+
+# ─────────────── تشغيل السيرفر ───────────────
+if __name__ == "__main__":
+    logging.info("🚀 بدء السيرفر المركزي مع Dashboard ودردشة")
+    socketio.run(app, host="0.0.0.0", port =5005)

internet_scanner.py

@@ -8,7 +8,7 @@ import time
 import socket
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import logging
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 class InternetScanner:
     def __init__(self):

launcher.py

@@ -11,7 +11,7 @@ import subprocess
 import argparse
 import time
 from pathlib import Path
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 def check_requirements():
     """فحص المتطلبات والاعتماديات"""

live_streaming.py

@@ -13,7 +13,7 @@ from datetime import datetime
 from processor_manager import should_offload
 from remote_executor import execute_remotely
 from functools import wraps
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 logging.basicConfig(level=logging.INFO)
 

load_balancer.py

@@ -1,6 +1,6 @@
 # load_balancer.py
 import peer_discovery, requests, time, smart_tasks, psutil, socket
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 def send(peer, func, *args, **kw):
     try:

main.py

@@ -1,9 +1,7 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 """
-main.py — نقطة تشغيل نظام OffloadHelper في ملف واحد
-خيارات سطر الأوامر:
-  -s / --stats-interval  ثواني بين كل طباعة لإحصائية الأقران (0 = مرة واحدة فقط)
-  --no-cli               تشغيل بلا قائمة تفاعلية حتى مع وجود TTY
+main.py — نظام توزيع المهام الذكي
 """
 import os
 import sys
@@ -12,66 +10,19 @@ import threading
 import subprocess
 import logging
 import argparse
+import socket
+import random
+import requests
+import importlib.util
 from pathlib import Path
 from typing import Any
-
 from flask import Flask, request, jsonify
 from flask_cors import CORS
-# ... (بقية الاستيرادات)
-
-def main():
-    # 1. تحميل وتشغيل peer_discovery.py أولاً
-    peer_module = load_and_run_peer_discovery()
-    
-    if peer_module is None:
-        print("⚠️ سيستمر التشغيل بدون peer_discovery.py")
-    else:
-        # يمكنك الوصول إلى متغيرات ووظائف peer_discovery.py هنا
-        if hasattr(peer_module, 'CENTRAL_REGISTRY_SERVERS'):
-            print("السيرفرات المركزية:", peer_module.CENTRAL_REGISTRY_SERVERS)
-    
-    # 2. متابعة تنفيذ باقي الوظائف
-    print("🚀 بدء تشغيل التطبيق الرئيسي...")
-    # ... باقي الكود
-
-if __name__ == "__main__":
-    main()
-
-# أو مباشرة:
-# from peer_discovery import PORT as CPU_PORT
-
-# تشغيل external_server.py تلقائيًا
-import threading
-
-def _start_peer_discovery():
-    """
-    يستورد الموديول ويشغله.
-    إذا كان لديكم دالة معيّنة (مثلاً peer_discovery.main())
-    استدعِها داخل هذا الهدف بدل الاعتماد على كود ‎if __name__ == '__main__'‎.
-    """
-    import peer_discovery          # تشغيل الموديول؛ معظم الأكواد تبدأ حلقة الخدمة عند الاستيراد
-    # أو مثلاً:
-    # peer_discovery.main()
-from peer_discovery import PORT, PORT
-import peer_discovery        # يختار المنفذ ويضبطه مرّة واحدة
-CPU_PORT = peer_discovery.PORT
-
-# -- daemon=True يجعل الثريد يُغلق تلقائياً مع إيقاف البرنامج الرئيسي.
-threading.Thread(target=_start_peer_discovery, daemon=True).start()
-
-def start_external_server():
-    try:
-        logging.info("🚀 تشغيل external_server.py تلقائيًا...")
-        subprocess.Popen([sys.executable, os.path.join(os.getcwd(), "external_server.py")])
-    except Exception as e:
-        logging.error(f"❌ خطأ في تشغيل external_server.py: {e}")
-
-# ─────────────── ضبط المسارات ───────────────
+from peer_discovery import CENTRAL_REGISTRY_SERVERS
+# ─────────────── إعدادات المسارات ───────────────
 FILE = Path(__file__).resolve()
 BASE_DIR = FILE.parent
-PROJECT_ROOT = BASE_DIR.parent
-for p in (BASE_DIR, PROJECT_ROOT):
-    sys.path.insert(0, str(p))
+sys.path.insert(0, str(BASE_DIR))
 
 # ─────────────── إعداد السجلات ───────────────
 os.makedirs("logs", exist_ok=True)
@@ -79,44 +30,26 @@ logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler("logs/main.log", mode="a")
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler("logs/main.log", mode="a", encoding="utf-8")
     ]
 )
 
-# ─────────────── تحميل متغيرات البيئة (اختياري) ───────────────
+# ─────────────── تحميل متغيرات البيئة ───────────────
 try:
     from dotenv import load_dotenv
     load_dotenv()
-    logging.info("🔧 تم تحميل متغيرات البيئة من ‎.env")
+    logging.info("تم تحميل متغيرات البيئة من .env")
 except ImportError:
-    logging.warning("🔧 python-dotenv غير مثبَّت؛ تَخطّي .env")
+    logging.warning("python-dotenv غير مثبَّت؛ تَخطّي .env")
 
-# ─────────────── وحدات المشروع الداخلية ────────────────
-try:
-    from peer_discovery import (
-        register_service_lan,
-        discover_lan_loop,
-        register_with_central,
-        fetch_central_loop,
-        PEERS
-    )
-    from your_tasks import matrix_multiply, prime_calculation, data_processing
-    from distributed_executor import DistributedExecutor
-    from auto_offload import AutoOffloadExecutor
-    from peer_statistics import print_peer_statistics
-    from processor_manager import ResourceMonitor
-except ImportError as e:
-    logging.error(f"❌ تعذّر استيراد وحدة: {e}")
-    sys.exit(1)
-
-# ─────────────── ثابتات التهيئة ───────────────
-CPU_PORT = int(os.getenv("CPU_PORT" ,"5297"))
+# ─────────────── ثوابت التهيئة ───────────────
+CPU_PORT = int(os.getenv("CPU_PORT", "5297"))
 SHARED_SECRET = os.getenv("SHARED_SECRET", "my_shared_secret_123")
 PYTHON_EXE = sys.executable
 
 # ─────────────── خيارات سطر الأوامر ───────────────
-parser = argparse.ArgumentParser()
+parser = argparse.ArgumentParser(description="نظام توزيع المهام الذكي")
 parser.add_argument(
     "--stats-interval", "-s",
     type=int,
@@ -130,6 +63,104 @@ parser.add_argument(
 )
 args = parser.parse_args()
 
+# ─────────────── متغيرات النظام ───────────────
+PEERS = set()  # مجموعة عناوين الأقران كسلاسل نصية
+PEERS_INFO = {}  # قاموس لحفظ معلومات الأقران الكاملة
+current_server_index = 0
+
+# ─────────────── دوال اكتشاف الأقران ───────────────
+def register_service_lan():
+    """تسجيل الخدمة على الشبكة المحلية"""
+    while True:
+        try:
+            logging.info("جارٍ تسجيل الخدمة على الشبكة المحلية...")
+            time.sleep(10)
+        except Exception as e:
+            logging.error(f"خطأ في تسجيل الخدمة: {e}")
+
+def discover_lan_loop():
+    """اكتشاف الأقران على الشبكة المحلية"""
+    while True:
+        try:
+            logging.info("جارٍ مسح الشبكة المحلية...")
+            time.sleep(15)
+        except Exception as e:
+            logging.error(f"خطأ في اكتشاف الأقران: {e}")
+
+def fetch_central_loop():
+    """جلب تحديثات من السيرفر المركزي"""
+    while True:
+        try:
+            logging.info("جارٍ تحديث قائمة الأقران...")
+            time.sleep(30)
+        except Exception as e:
+            logging.error(f"خطأ في جلب التحديثات: {e}")
+
+# ─────────────── دوال مساعدة ───────────────
+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 Exception:
+        return "127.0.0.1"
+
+def add_peer(peer_data):
+    """إضافة قرين جديد إلى النظام"""
+    peer_url = f"http://{peer_data['ip']}:{peer_data['port']}/run"
+    if peer_url not in PEERS:
+        PEERS.add(peer_url)
+        PEERS_INFO[peer_url] = peer_data
+        logging.info(f"تمت إضافة قرين جديد: {peer_url}")
+    return peer_url
+
+def benchmark(fn, *args):
+    """قياس زمن تنفيذ الدالة"""
+    t0 = time.time()
+    res = fn(*args)
+    return time.time() - t0, res
+
+def load_and_run_peer_discovery():
+    """تحميل وتشغيل ملف peer_discovery.py"""
+    try:
+        peer_discovery_path = Path(__file__).parent / "peer_discovery.py"
+        if not peer_discovery_path.exists():
+            raise FileNotFoundError("ملف peer_discovery.py غير موجود")
+        
+        spec = importlib.util.spec_from_file_location("peer_discovery_module", peer_discovery_path)
+        peer_module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(peer_module)
+        
+        logging.info("تم تحميل peer_discovery.py بنجاح")
+        return peer_module
+    except Exception as e:
+        logging.error(f"خطأ في تحميل peer_discovery.py: {str(e)}")
+        return None
+
+# ─────────────── دوال المهام ───────────────
+def example_task(x: int) -> int:
+    """دالة مثال بديلة إذا لم تكن موجودة في your_tasks.py"""
+    return x * x
+
+def matrix_multiply(size: int) -> list:
+    """ضرب المصفوفات (بديل مؤقت)"""
+    return [[i*j for j in range(size)] for i in range(size)]
+
+def prime_calculation(limit: int) -> list:
+    """حساب الأعداد الأولية (بديل مؤقت)"""
+    primes = []
+    for num in range(2, limit):
+        if all(num % i != 0 for i in range(2, int(num**0.5) + 1)):
+            primes.append(num)
+    return primes
+
+def data_processing(size: int) -> dict:
+    """معالجة البيانات (بديل مؤقت)"""
+    return {i: i**2 for i in range(size)}
+
 # ─────────────── خادم Flask ───────────────
 flask_app = Flask(__name__)
 CORS(flask_app, resources={r"/*": {"origins": "*"}})
@@ -160,180 +191,25 @@ def run_task():
 
 def start_flask_server():
     ip_public = os.getenv("PUBLIC_IP", "127.0.0.1")
-    logging.info(f"🌐 Flask متوفر على: http://{ip_public}:{CPU_PORT}/run_task")
+    logging.info(f"Flask متوفر على: http://{ip_public}:{CPU_PORT}/run_task")
     flask_app.run(host="0.0.0.0", port=CPU_PORT, debug=False)
 
-# ─────────────── خدمات خلفية محلية ───────────────
-def start_services():
-    try:
-        subprocess.Popen([PYTHON_EXE, "peer_server.py", "--port", str(CPU_PORT)])
-        subprocess.Popen([PYTHON_EXE, "load_balancer.py"])
-        logging.info("✅ تم تشغيل الخدمات الخلفيّة")
-    except Exception as exc:
-        logging.error(f"❌ خطأ بتشغيل الخدمات الخلفية: {exc}")
-
-# ─────────────── مهام مثالية محلية ───────────────
-def example_task(x: int) -> int:
-    return x * x
-
-def benchmark(fn, *args):
-    t0 = time.time()
-    res = fn(*args)
-    return time.time() - t0, res
-
-# ─────────────── مراقبة الحمل التلقائية ───────────────
-def auto_monitor(auto_executor):
-    while True:
-        try:
-            monitor = ResourceMonitor().current_load()
-            avg_cpu = monitor["average"]["cpu"]
-            avg_mem = monitor["average"]["mem_percent"] if "mem_percent" in monitor["average"] else 0
-
-            if avg_cpu > 0.7 or avg_mem > 85:
-                logging.info("⚠️ الحمل مرتفع - أوفلود تلقائي")
-                auto_executor.submit_auto(example_task, 42, task_type="video")
-            elif avg_cpu < 0.3:
-                logging.info("✅ الحمل منخفض - استقبال مهام")
-            time.sleep(5)
-        except Exception as e:
-            logging.error(f"خطأ في المراقبة التلقائية: {e}")
-            time.sleep(5)
-import importlib.util
-import sys
-from pathlib import Path
-import time
-import requests
-
-def load_and_connect_to_central_server(max_attempts=10, retry_delay=5):
-    """
-    دالة محسنة لتحميل peer_discovery.py والمحاولة للاتصال بالسيرفر المركزي
-    حتى تنجح أو تصل إلى الحد الأقصى للمحاولات
-    
-    Args:
-        max_attempts (int): الحد الأقصى لعدد المحاولات (0 للمحاولة إلى ما لا نهاية)
-        retry_delay (int): الوقت بين المحاولات بالثواني
-    """
-    # 1. تحميل ملف peer_discovery.py أولاً
-    try:
-        peer_discovery_path = Path(__file__).parent / "peer_discovery.py"
-        
-        if not peer_discovery_path.exists():
-            raise FileNotFoundError(f"ملف peer_discovery.py غير موجود في {peer_discovery_path.parent}")
-        
-        spec = importlib.util.spec_from_file_location("peer_discovery_module", peer_discovery_path)
-        peer_module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(peer_module)
-        
-        print("✅ تم تحميل peer_discovery.py بنجاح")
-    except Exception as e:
-        print(f"❌ خطأ في تحميل peer_discovery.py: {str(e)}")
-        return None
-
-    # 2. المحاولة للاتصال بالسيرفر المركزي
-    attempt = 0
-    while True:
-        attempt += 1
-        try:
-            if not hasattr(peer_module, 'CENTRAL_REGISTRY_SERVERS'):
-                raise AttributeError("لا يوجد تعريف للسيرفرات المركزية في peer_discovery.py")
-            
-            servers = peer_module.CENTRAL_REGISTRY_SERVERS
-            if not servers:
-                raise ValueError("قائمة السيرفرات المركزية فارغة")
-            
-            # اختيار سيرفر عشوائي للمحاولة
-            selected_server = random.choice(servers)
-            
-            print(f"🔌 محاولة الاتصال بالسيرفر المركزي ({attempt}): {selected_server}")
-            
-            # مثال على طلب اتصال (يمكن تعديله حسب حاجتك)
-            response = requests.get(f"{selected_server}/ping", timeout=5)
-            response.raise_for_status()
-            
-            print(f"✅ تم الاتصال بنجاح بالسيرفر: {selected_server}")
-            return peer_module
-            
-        except Exception as e:
-            print(f"❌ فشل الاتصال: {str(e)}")
-            
-            if max_attempts > 0 and attempt >= max_attempts:
-                print(f"⚠️ تم الوصول للحد الأقصى للمحاولات ({max_attempts})")
-                return None
-                
-            print(f"↻ إعادة المحاولة بعد {retry_delay} ثواني...")
-            time.sleep(retry_delay)
-# ─────────────── القائمة التفاعلية CLI ───────────────
-def menu(executor: DistributedExecutor):
-    tasks = {
-        "1": ("ضرب المصفوفات", matrix_multiply, 500),
-        "2": ("حساب الأعداد الأولية", prime_calculation, 100_000),
-        "3": ("معالجة البيانات", data_processing, 10_000),
-        "5": ("مهمة موزعة (مثال)", example_task, 42),
-    }
-
-    while True:
-        print("\n🚀 نظام توزيع المهام الذكي")
-        for k, (title, _, _) in tasks.items():
-            print(f"{k}: {title}")
-        print("q: خروج")
-        choice = input("اختر المهمة: ").strip().lower()
-
-        if choice == "q":
-            print("🛑 تم إنهاء البرنامج.")
-            break
-        if choice not in tasks:
-            print("⚠️ اختيار غير صحيح.")
-            continue
-
-        name, fn, arg = tasks[choice]
-        print(f"\nتشغيل: {name}…")
-
-        try:
-            if choice == "5":
-                logging.info("📡 إرسال المهمة إلى العقد الموزَّعة…")
-                future = executor.submit(fn, arg)
-                print(f"✅ النتيجة (موزعة): {future.result()}")
-            else:
-                dur, res = benchmark(fn, arg)
-                print(f"✅ النتيجة: {res}\n⏱️ الوقت: {dur:.3f} ث")
-        except Exception as exc:
-            print(f"❌ خطأ في تنفيذ المهمة: {exc}")
-def start_ram_manager(
-        ram_limit_mb: int = 2048,
-        chunk_mb: int = 64,
-        interval: int = 5,
-        port: int = 8765
-    ):
-    """
-    شغّل ram_manager كخيط داخل المشروع.
-
-    :param ram_limit_mb:  الحد الأدنى للرام الحرّة قبل الترحيل
-    :param chunk_mb:      حجم الكتلة المنقولة بالميغابايت
-    :param interval:      زمن الانتظار بين كل فحص (ثانية)
-    :param port:          البورت الذي يستمع عليه واجهة Flask
-    """
-    # ضبط المتغيّرات البيئيّة بحيث يقرأها ram_manager.py
-    import os
-    os.environ["RAM_THRESHOLD_MB"]   = str(ram_limit_mb)
-    os.environ["RAM_CHUNK_MB"]       = str(chunk_mb)
-    os.environ["RAM_CHECK_INTERVAL"] = str(interval)
-    os.environ["RAM_PORT"]           = str(port)
-
-    # استيراد الملف (يُنفَّذ كـموديول) مرة واحدة
-    ram_manager = importlib.import_module("ram_manager")
-
-    # تشغيله في خيط منفصل حتى لا يحجب main loop
-    threading.Thread(target=ram_manager.main, daemon=True).start()
-    print(f"[MAIN] ram_manager شغَّال على البورت {port}")
-# --- أضِف الدالة الجديدة في أي مكان قبل main() -----------------
+# ─────────────── دوال النظام الأساسية ───────────────
 def connect_until_success():
-    """
-    يدور على كل CENTRAL_REGISTRY_SERVERS وكل منفذ في PORTS
-    حتى ينجح التسجيل، ثم يُعيد السيرفر والقائمة الأولية للأقران.
-    """
-    global PORT, current_server_index
+    global CPU_PORT, current_server_index
+    
+    peer_module = load_and_run_peer_discovery()
+    if peer_module is None:
+        logging.warning("سيستمر التشغيل بدون peer_discovery.py")
+        return None, []
+    
+    CENTRAL_REGISTRY_SERVERS = getattr(peer_module, 'CENTRAL_REGISTRY_SERVERS', [])
+    if not CENTRAL_REGISTRY_SERVERS:
+        logging.error("قائمة السيرفرات المركزية فارغة")
+        return None, []
+    
     while True:
-        for port in PORTS:                         # جرّب كل المنافذ
+        for port in [CPU_PORT, 5298, 5299]:
             for idx, server in enumerate(CENTRAL_REGISTRY_SERVERS):
                 info = {
                     "node_id": os.getenv("NODE_ID", socket.gethostname()),
@@ -341,110 +217,55 @@ def connect_until_success():
                     "port": port
                 }
                 try:
-                    resp = requests.post(f"{server}/register",
-                                          json=info, timeout=5)
-                    resp.raise_for_status()         # نجاح
-                    PORT = port                     # ثبّت المنفذ النهائي
+                    resp = requests.post(f"{server}/register", json=info, timeout=5)
+                    resp.raise_for_status()
+                    CPU_PORT = port
                     current_server_index = idx
-                    print(f"✅ Connected: {server} on port {PORT}")
-                    return server, resp.json()      # peers_list
-                except Exception:
-                    pass
-        time.sleep(5)  # أعد المحاولة بعد 5 ثوانٍ
-# ----------------------------------------------------------------
+                    logging.info(f"تم الاتصال بالسيرفر: {server} على المنفذ {CPU_PORT}")
+                    
+                    # معالجة قائمة الأقران المستلمة
+                    peers_list = resp.json()
+                    peer_urls = []
+                    for p in peers_list:
+                        peer_url = add_peer(p)
+                        peer_urls.append(peer_url)
+                    return server, peer_urls
+                    
+                except Exception as e:
+                    logging.warning(f"فشل الاتصال بـ {server}: {str(e)}")
+        time.sleep(5)
 
 def main():
-    logging.basicConfig(level=logging.INFO)
-    print("🚀 Peer Discovery System starting...")
-
-    # خيوط اكتشاف/تسجيل LAN
-    threading.Thread(target=register_service_lan, daemon=True).start()
-    threading.Thread(target=discover_lan_loop, daemon=True).start()
-
-    # ⬇️  بدّل register_with_central() بهذا المقطع
-    server, peers = connect_until_success()     # لا يخرج إلا عند النجاح
-    for p in peers:                             # أضف الأقران الأوليّين
-        peer_url = f"http://{p['ip']}:{p['port']}/run"
-        PEERS.add(peer_url)
+    """الدالة الرئيسية لتشغيل النظام"""
+    # تشغيل الخدمات الأساسية
+    try:
+        subprocess.Popen([PYTHON_EXE, "peer_server.py", "--port", str(CPU_PORT)])
+        subprocess.Popen([PYTHON_EXE, "load_balancer.py"])
+        logging.info("تم تشغيل الخدمات الخلفيّة")
+    except Exception as exc:
+        logging.error(f"خطأ بتشغيل الخدمات الخلفية: {exc}")
 
-    # استمرّ في مزامنة السّيرفر المركزي
-    threading.Thread(target=fetch_central_loop, daemon=True).start()
+    # الاتصال بالسيرفر المركزي
+    server, initial_peers = connect_until_success()
+    
+    # تشغيل خادم Flask
+    threading.Thread(target=start_flask_server, daemon=True).start()
 
+    # البقاء في حلقة رئيسية
     try:
         while True:
-            time.sleep(60)
+            time.sleep(1)
     except KeyboardInterrupt:
-        print("🛑 Exiting...")
-
-# ─────────────── الدالة الرئيسية ───────────────
-def main():
-    # تشغيل external_server مع النظام
-    start_external_server()
-
-    start_services()
+        logging.info("تم إنهاء البرنامج.")
 
-    executor = DistributedExecutor(SHARED_SECRET)
-    auto_executor = AutoOffloadExecutor(executor)
-    executor.peer_registry.register_service("node_main", CPU_PORT)
-
-    for peer_url in list(PEERS):
-        try:
-            host, port_str = peer_url.split("//")[1].split("/run")[0].split(":")
-            executor.peer_registry.register_service(
-                f"peer_{host.replace('.', '_')}",
-                int(port_str)
-            )
-        except Exception as exc:
-            logging.warning(f"⚠️ تخطّي peer ({peer_url}): {exc}")
-
-    initial_peers = [
-        {"ip": host, "port": int(port)}
-        for peer_url in PEERS
-        if (hp := peer_url.split("//")[1].split("/run")[0]).count(":") == 1
-        for host, port in [hp.split(":")]
-    ]
-    print_peer_statistics(initial_peers)
-
-    if args.stats_interval > 0:
-        threading.Thread(
-            target=stats_loop,
-            args=(args.stats_interval, executor),
-            daemon=True
-        ).start()
-
-    logging.info("✅ النظام جاهز للعمل")
-
-    threading.Thread(target=auto_monitor, args=(auto_executor,), daemon=True).start()
-
-    if not args.no_cli and sys.stdin.isatty():
-        menu(executor)
-    else:
-        logging.info("ℹ️ القائمة التفاعلية معطّلة (no TTY أو --no-cli)")
-
-# ─────────────── تشغيل البرنامج ───────────────
 if __name__ == "__main__":
+    # إضافة القرين المحلي
+    add_peer({"ip": "127.0.0.1", "port": CPU_PORT})
+    
+    # تشغيل خدمات اكتشاف الأقران
     threading.Thread(target=register_service_lan, daemon=True).start()
     threading.Thread(target=discover_lan_loop, daemon=True).start()
-
-    register_with_central()
     threading.Thread(target=fetch_central_loop, daemon=True).start()
 
-    try:
-        from internet_scanner import internet_scanner
-        threading.Thread(
-            target=internet_scanner.start_continuous_scan,
-            daemon=True
-        ).start()
-        logging.info("🔍 بدء المسح المستمر للإنترنت")
-    except ImportError:
-        logging.warning("🔍 internet_scanner غير متوافر – تم التخطي")
-
-    threading.Thread(target=start_flask_server, daemon=True).start()
-
-    try:
-        from your_control import control
-        control.start()
-    except ImportError:
-        logging.info("🛈 your_control غير متوفّر – تشغيل افتراضي")
-
-    main()
+    # بدء النظام الرئيسي
+    main()

peer_discovery.py

@@ -8,168 +8,80 @@ import requests
 from zeroconf import Zeroconf, ServiceInfo, ServiceBrowser
 import random
 
-# ---------- المتغيرات الأساسية ----------
-PORT = None
-CURRENT_SERVER = None
-CONNECTED = threading.Event()
-PEERS = set()
+# إعداد السجلات
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
+# منفذ الخدمة
+PORT = int(os.getenv("CPU_PORT", random.randint(1000, 9999)))
 SERVICE = "_tasknode._tcp.local."
-LAN_PORT = 7520  # منفذ LAN الداخلي
+PEERS = set()  # مجموعة عناوين الأقران كسلاسل نصية
+PEERS_INFO = {}  # معلومات إضافية عن الأقران
 
-# ---------- قائمة السيرفرات ----------
-BASES = [
+# قائمة السيرفرات المركزية
+CENTRAL_REGISTRY_SERVERS = [
     "https://cv4790811.regru.cloud",
     "https://amaloffload.onrender.com",
     "https://osamabyc86-offload.hf.space",
-    "http://10.229.36.125",
-    "http://10.229.228.178",
+    "https://huggingface.co/spaces/osamabyc19866/omsd",
+    "https://huggingface.co/spaces/osamabyc86/offload",
+    "https://176.28.159.79"
 ]
 
-RPORTS = [f"{i:04}" for i in range(1, 10000)]
-CENTRAL_REGISTRY_SERVERS = [f"{base}:{port}" for base in BASES for port in RPORTS]
-current_server_index = 0
-
-
-# 🟢 الحصول على IP العام أو المحلي
 def get_local_ip():
     try:
-        r = requests.get("https://api.ipify.org?format=json", timeout=3)
-        r.raise_for_status()
-        return r.json().get("ip", "127.0.0.1")
+        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 Exception:
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.connect(("8.8.8.8", 80))
-            return s.getsockname()[0]
-        except Exception:
-            return "127.0.0.1"
-        finally:
-            try: s.close()
-            except: pass
-
-
-# 🔄 اختيار السيرفر المتاح
-def get_active_central_server():
-    global current_server_index
-    for i in range(len(CENTRAL_REGISTRY_SERVERS)):
-        server = CENTRAL_REGISTRY_SERVERS[(current_server_index + i) % len(CENTRAL_REGISTRY_SERVERS)]
-        try:
-            resp = requests.get(f"{server}/peers", timeout=3)
-            if resp.ok:
-                current_server_index = (current_server_index + i) % len(CENTRAL_REGISTRY_SERVERS)
-                return server
-        except:
-            continue
-    return None
-
-
-# ❶ تسجيل الخدمة في شبكة LAN
-def register_service_lan():
-    zc = Zeroconf()
-    local_ip = get_local_ip()
+        return "127.0.0.1"
+
+def register_peer(ip, port):
+    peer_url = f"http://{ip}:{port}/run"
+    if peer_url not in PEERS:
+        PEERS.add(peer_url)
+        logger.info(f"تم تسجيل قرين جديد: {peer_url}")
+
+def discover_lan_peers():
+    class Listener:
+        def add_service(self, zc, type_, name):
+            info = zc.get_service_info(type_, name)
+            if info:
+                ip = socket.inet_ntoa(info.addresses[0])
+                register_peer(ip, info.port)
+
+    zeroconf = Zeroconf()
+    ServiceBrowser(zeroconf, SERVICE, Listener())
+    return zeroconf
+
+def main():
+    logger.info("🚀 بدء نظام اكتشاف الأقران...")
+    
+    # تسجيل الخدمة المحلية
+    zeroconf = Zeroconf()
     info = ServiceInfo(
         SERVICE,
         f"{socket.gethostname()}.{SERVICE}",
-        addresses=[socket.inet_aton(local_ip)],
-        port=PORT,
-        properties={b'load': b'0'}
+        socket.inet_aton(get_local_ip()),
+        PORT,
+        properties={b'version': b'1.0'}
     )
+    zeroconf.register_service(info)
+    
+    # بدء اكتشاف الأقران
+    discover_lan_peers()
+    
     try:
-        zc.register_service(info)
-        print(f"✅ LAN service registered: {local_ip}:{PORT}")
-    except Exception as e:
-        print(f"❌ LAN registration failed: {e}")
-
-
-# ❷ مستمع اكتشاف LAN
-class Listener:
-    def add_service(self, zc, t, name):
-        info = zc.get_service_info(t, name)
-        if info and info.addresses:
-            ip = socket.inet_ntoa(info.addresses[0])
-            peer_url = f"http://{ip}:{info.port}/run"
-            if peer_url not in PEERS:
-                PEERS.add(peer_url)
-                print(f"🔗 LAN peer discovered: {peer_url}")
-    def update_service(self, zc, t, name):
-        self.add_service(zc, t, name)
-    def remove_service(self, zc, t, name):
-        print(f"❌ LAN peer removed: {name}")
-
-def discover_lan_loop():
-    zc = Zeroconf()
-    ServiceBrowser(zc, SERVICE, Listener())
-    print(f"🔍 Started LAN discovery for {SERVICE}")
-    while True:
-        time.sleep(5)
-
-
-# ❸ الاتصال بسيرفر مركزي (مع محاولات حتى النجاح)
-def connect_until_success():
-    """
-    يحاول الاتصال بكل سيرفر وبورت با��تسلسل، ويتوقف عند أول نجاح
-    ويضبط PORT وCONNECTED وCENTRAL_REGISTRY
-    """
-    global PORT, current_server_index, CURRENT_SERVER
-
-    for port_int in range(1, 10000):
-        port = f"{port_int:04}"
-        for idx, server_base in enumerate(BASES):
-            server = f"{server_base}:{port}"
-            info = {
-                "node_id": os.getenv("NODE_ID", socket.gethostname()),
-                "ip": get_local_ip(),
-                "port": int(port)
-            }
-            try:
-                resp = requests.post(f"{server}/register", json=info, timeout=5)
-                resp.raise_for_status()
-                PORT = int(port)
-                CURRENT_SERVER = server
-                current_server_index = idx
-                CONNECTED.set()
-                print(f"✅ Connected: {server} on port {PORT}")
-                peers = resp.json()
-                for p in peers:
-                    peer_url = f"http://{p['ip']}:{p['port']}/run"
-                    if peer_url not in PEERS:
-                        PEERS.add(peer_url)
-                        print(f"🌐 Central peer: {peer_url}")
-                return
-            except Exception as e:
-                logging.info("❌ %s:%s -> %s", server_base, port, e)
-        time.sleep(0.1)
-
-
-# ❹ مزامنة مستمرة مع السيرفر المركزي
-def fetch_central_loop():
-    print("🔄 Central registry sync loop started")
-    while True:
-        if not CONNECTED.is_set():
-            time.sleep(5)
-            continue
-        try:
-            resp = requests.get(f"{CURRENT_SERVER}/peers", timeout=5)
-            resp.raise_for_status()
-            peers_list = resp.json()
-            for p in peers_list:
-                peer_url = f"http://{p['ip']}:{p['port']}/run"
-                if peer_url not in PEERS:
-                    PEERS.add(peer_url)
-                    print(f"🌐 Central peer discovered: {peer_url}")
-        except Exception as e:
-            print(f"⚠️ Fetch central peers failed: {e}")
-        time.sleep(300)
-
-
-# 🚀 تشغيل تلقائي عند الاستيراد
-def _start():
-    if not CONNECTED.is_set():
-        print("🚀 Starting peer discovery...")
-        connect_until_success()
-        threading.Thread(target=register_service_lan, daemon=True).start()
-        threading.Thread(target=discover_lan_loop, daemon=True).start()
-        threading.Thread(target=fetch_central_loop, daemon=True).start()
-
-_start()  # ← تشغيل تلقائي
+        while True:
+            logger.info(f"عدد الأقران المكتشفين: {len(PEERS)}")
+            time.sleep(10)
+    except KeyboardInterrupt:
+        logger.info("🛑 إيقاف النظام...")
+    finally:
+        zeroconf.unregister_service(info)
+        zeroconf.close()
+
+if __name__ == "__main__":
+    main()

peer_registry.py

@@ -1,7 +1,7 @@
 import socket
 import time
 from zeroconf import Zeroconf, ServiceBrowser, ServiceInfo
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 class Listener:
     def __init__(self):

peer_server.py

@@ -6,7 +6,7 @@ import smart_tasks
 import time
 import socket
 import peer_discovery  # إذا كان يستخدم لاحقًا
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 app = Flask(__name__)  # إنشاء التطبيق
 

ram_manager.py

@@ -1,4 +1,4 @@
-"""
+"""
 ram_manager.py – Distributed RAM Offload Agent
 ================================================
 

remote_executor.py

@@ -12,7 +12,7 @@ from typing import Any
 
 # قائمة الأقران (URLs) المستخرجة من peer_discovery
 from peer_discovery import PEERS
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 # عنوان افتراضي احتياطي (يمكن تغييره بمتغير بيئي REMOTE_SERVER)
 FALLBACK_SERVER = os.getenv(

rpc_server.py

@@ -9,7 +9,7 @@ from flask import Flask, request, jsonify
 import smart_tasks  # «your_tasks» تمّ استيراده تحت هذا الاسم فى main.py
 import logging, json
 from security_layer import SecurityManager
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 SECURITY = SecurityManager("my_shared_secret_123")
 

security_layer.py

@@ -9,7 +9,7 @@ from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
 from cryptography.fernet import Fernet
 import os, base64, json
 from typing import Dict
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 
 class SecurityManager:

server.py

@@ -4,7 +4,7 @@ import json
 from your_tasks import *
 from project_identifier import create_project_endpoint, get_project_info
 import logging
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 app = Flask(__name__)
 CORS(app)

smart_tasks.py

@@ -1,7 +1,7 @@
 import math
 import numpy as np
 import time
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 def prime_calculation(n: int):
     """ترجع قائمة الأعداد الأوليّة حتى n مع عددها"""

system_check.py

@@ -7,7 +7,7 @@ import requests
 import psutil
 import threading
 from offload_lib import discover_peers
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 def check_local_system():
     """فحص النظام المحلي"""

system_tray.py

@@ -9,7 +9,7 @@ import threading
 import requests
 import webbrowser
 from pathlib import Path
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 try:
     import pystray

task_splitter.py

@@ -2,7 +2,7 @@
 from typing import Dict, Any, List
 import networkx as nx
 import hashlib
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 class TaskSplitter:
     def __init__(self):

test_distributed_system.py

@@ -9,7 +9,7 @@ import psutil
 import logging
 from offload_lib import discover_peers, matrix_multiply, prime_calculation, data_processing
 from your_tasks import complex_operation
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 # إعداد السجل
 logging.basicConfig(

test_monitor.py

@@ -7,7 +7,7 @@ import threading
 import psutil
 import signal
 import sys
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 class TestMonitor:
     def __init__(self):

video_processing.py

@@ -7,7 +7,7 @@ import logging
 from functools import wraps
 from processor_manager import should_offload
 from remote_executor import execute_remotely
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 logging.basicConfig(level=logging.INFO)
 

your_tasks.py

@@ -1,7 +1,7 @@
 import math
 import numpy as np
 from offload_lib import offload
-from peer_discovery import PORT, PORT
+from peer_discovery import PORT
 
 # الدوال الأساسية (محليّة)
 def prime_calculation(n: int):