0.0.1 V Beta

LoadBalancer.py

@@ -0,0 +1,73 @@
+import time
+import logging
+from threading import Thread, Event, Timer
+from api import InstancesAPI
+
+class LoadBalancer:
+    def __init__(self, polling_interval=60, max_retries=3, initial_delay=1):
+        self.version = "0.0.1 V Beta"
+        self.instances = []
+        self.polling_interval = polling_interval
+        self.max_retries = max_retries
+        self.initial_delay = initial_delay
+        self.stop_event = Event()
+        self.instances_api = InstancesAPI(self.instances)
+
+    def register_instance(self, instance_url):
+        if instance_url not in self.instances:
+            self.instances.append(instance_url)
+            logging.info(f"Registered instance {instance_url}")
+        else:
+            logging.info(f"Instance {instance_url} is already registered.")
+
+    def remove_instance(self, instance_url):
+        if instance_url in self.instances:
+            self.instances.remove(instance_url)
+            logging.info(f"Removed instance {instance_url}")
+        else:
+            logging.info(f"Instance {instance_url} not found for removal.")
+        
+    def get_reports(self):
+        reports = self.instances_api.fetch_reports()
+        for instance_url in self.instances[:]:  # Copy list to avoid modification during iteration
+            if instance_url in reports:
+                report = reports[instance_url]
+                logging.info(f"Report from {instance_url}: {report}")
+                self.process_report(instance_url, report)
+            else:
+                logging.error(f"Failed to get report from {instance_url}. Removing instance.")
+                self.remove_instance(instance_url)
+
+    def process_report(self, instance_url, report):
+        # Process the report (film_store, tv_store, cache_size) here
+        logging.info(f"Processing report from {instance_url}")
+        # Example: Print the film_store and tv_store
+        logging.info(f"Film Store: {report.get('film_store')}")
+        logging.info(f"TV Store: {report.get('tv_store')}")
+        logging.info(f"Cache Size: {report.get('cache_size')}")
+
+    def start_polling(self):
+        logging.info("Starting polling.")
+        while not self.stop_event.is_set():
+            self.get_reports()
+            time.sleep(self.polling_interval)
+        logging.info("Polling stopped.")
+
+    def stop_polling(self):
+        logging.info("Stopping polling.")
+        self.stop_event.set()
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+
+    load_balancer = LoadBalancer()
+
+    # Example registration (in real use, handle this via an API endpoint)
+    load_balancer.register_instance("http://localhost:5000")
+
+    # Start polling in a separate thread
+    polling_thread = Thread(target=load_balancer.start_polling)
+    polling_thread.start()
+
+    # Stop polling after some time for demonstration purposes
+    Timer(300, load_balancer.stop_polling).start()  # Stop after 5 minutes

api.py

@@ -0,0 +1,17 @@
+import requests
+import logging
+
+class InstancesAPI:
+    def __init__(self, instances):
+        self.instances = instances
+
+    def fetch_reports(self):
+        reports = {}
+        for instance_url in self.instances:
+            try:
+                response = requests.get(f"{instance_url}/api/get/report")
+                response.raise_for_status()
+                reports[instance_url] = response.json()
+            except requests.exceptions.RequestException as e:
+                logging.error(f"Error contacting instance {instance_url}: {e}")
+        return reports

app.py

@@ -8,6 +8,15 @@ from hf_scrapper import download_film, download_episode, get_system_proxies, get
 from indexer import indexer
 from tvdb import fetch_and_cache_json
 import re
+import logging
+from LoadBalancer import LoadBalancer
+
+logging.basicConfig(level=logging.INFO)
+load_balancer = LoadBalancer()
+
+# Start polling in a separate thread
+polling_thread = threading.Thread(target=load_balancer.start_polling)
+polling_thread.start()
 
 app = Flask(__name__)
 CORS(app)
@@ -18,6 +27,7 @@ INDEX_FILE = os.getenv("INDEX_FILE")
 TOKEN = os.getenv("TOKEN")
 FILM_STORE_JSON_PATH = os.path.join(CACHE_DIR, "film_store.json")
 TV_STORE_JSON_PATH = os.path.join(CACHE_DIR, "tv_store.json")
+INSTANCE_REGISTER_JSON_PATH = os.path.join(CACHE_DIR, "instance_register.json")
 REPO = os.getenv("REPO")
 download_threads = {}
 
@@ -41,7 +51,6 @@ with open(INDEX_FILE, 'r') as f:
     file_structure = json.load(f)
 
 # Function Definitions
-
 def load_json(file_path):
     """Load JSON data from a file."""
     with open(file_path, 'r') as file:
@@ -115,6 +124,18 @@ def bytes_to_human_readable(num, suffix="B"):
 def encode_episodeid(title,season,episode):
     return f"{title}_{season}_{episode}"
 
+def is_valid_url(url):
+    # Simple URL validation (could be more complex if needed)
+    regex = re.compile(
+        r'^(?:http|ftp)s?://' # http:// or https://
+        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
+        r'localhost|' # localhost...
+        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
+        r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
+        r'(?::\d+)?' # optional port
+        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
+    return re.match(regex, url) is not None
+
 def get_all_tv_shows(indexed_cache):
     """Get all TV shows from the indexed cache structure JSON file."""
     tv_shows = {}
@@ -283,7 +304,7 @@ def get_tv_store_api():
 
 @app.route('/api/film/store', methods=['GET'])
 def get_film_store_api():
-    """Endpoint to get the TV store JSON."""
+    """Endpoint to get the film store JSON."""
     if os.path.exists(FILM_STORE_JSON_PATH):
         with open(FILM_STORE_JSON_PATH, 'r') as json_file:
             tv_store_data = json.load(json_file)
@@ -362,15 +383,35 @@ def get_all_tvshows_api():
 
 #############################################################
 # unique api's
-@app.route('/api/register/<instanceid>',methods=['POST'])
-def register_instance(instanceid):
-    # need to add instance registration logic
-    return jsonify({f'{instanceid} registered'}), 200
+@app.route('/api/register', methods=['POST'])
+def register_instance():
+    try:
+        data = request.json
+        if not data or "url" not in data:
+            return jsonify({"error": "No URL provided"}), 400
+        
+        url = data["url"]
+        if not is_valid_url(url):
+            return jsonify({"error": "Invalid URL"}), 400
+
+        # Register the instance
+        load_balancer.register_instance(url)
+        logging.info(f"Instance registered: {url}")
+
+        return jsonify({"message": f"Instance {url} registered successfully"}), 200
 
+    except Exception as e:
+        logging.error(f"Error registering instance: {e}")
+        return jsonify({"error": "Failed to register instance"}), 500
+#############################################################
 # Routes
 @app.route('/')
 def index():
-    return "Load Balancer is Running ..."
+    return f"Load Balancer is Running {load_balancer.version}"
+
+@app.route('/instances',method=["GET"])
+def get_instances():
+    return load_balancer.instances
 
 # Main entry point
 if __name__ == "__main__":