unstable fix

LoadBalancer.py

@@ -4,6 +4,7 @@ import re
 import urllib.parse
 from tvdb import fetch_and_cache_json
 from threading import Event, Thread
+from fastapi import BackgroundTasks
 import asyncio
 import time
 import logging
@@ -14,7 +15,7 @@ CACHE_DIR = os.getenv("CACHE_DIR")
 
 class LoadBalancer:
     def __init__(self, cache_dir, token, repo, polling_interval=4, max_retries=3, initial_delay=1):
-        self.version = "0.0.0.2 Alpha"
+        self.version = "0.0.0.1 Alpha"
         self.instances = []
         self.instances_health = {}
         self.polling_interval = polling_interval
@@ -35,7 +36,7 @@ class LoadBalancer:
             os.makedirs(self.CACHE_DIR)
 
         # Initialize file structure and prefetching
-        self.file_structure = indexer()
+        self.file_structure = self.indexer()
         self.start_prefetching()
 
         # Start polling and file checking in separate threads
@@ -49,8 +50,12 @@ class LoadBalancer:
         content_check_thread.start()
 
     def start_prefetching(self):
-        """Start the metadata prefetching in the FastAPI event loop."""
-        asyncio.create_task(self.prefetch_metadata())
+        """Start the metadata prefetching using FastAPI background tasks."""
+        # Create a FastAPI BackgroundTasks instance
+        background_tasks = BackgroundTasks()
+        # Add the prefetch_metadata coroutine to the background tasks
+        background_tasks.add_task(self.prefetch_metadata)
+        return background_tasks
 
     async def prefetch_metadata(self):
         """Prefetch metadata for all items in the file structure."""
@@ -88,9 +93,12 @@ class LoadBalancer:
         """Periodically check for updates and trigger prefetching if new content is detected."""
         while not self.stop_event.is_set():
             time.sleep(120)  # Wait for 2 minutes
-            current_file_structure = indexer()
+            current_file_structure = self.indexer()
             if current_file_structure != self.previous_file_structure:
-                self.start_prefetching()
+                # Trigger prefetching using FastAPI background tasks
+                background_tasks = self.start_prefetching()
+                # Here you need to integrate background_tasks with FastAPI
+                # For example, you might need to pass it to your FastAPI route handler or another component
                 self.previous_file_structure = current_file_structure
             else:
                 logging.info("No new content detected.")

TODO.md

@@ -0,0 +1,4 @@
+create endpoints for
+* /api/get/film/{title} `Endpoint to get the movie by title.`
+
+* /api/get/tv/{title}/{season}/{episode} `Endpoint to get the episode by title, season and episode.`

app.py

@@ -1,9 +1,10 @@
-from fastapi import FastAPI,HTTPException
+from fastapi import FastAPI,HTTPException, Request
 from fastapi.responses import JSONResponse
 from LoadBalancer import LoadBalancer
+import logging
 import os
 import urllib.parse
-from utils import read_json_file
+from utils import read_json_file, is_valid_url
 
 CACHE_DIR = os.getenv("CACHE_DIR")
 TOKEN = os.getenv("TOKEN")
@@ -21,9 +22,25 @@ def greet_json():
     return {"Version": load_balancer.version}
 
 @app.post("/api/post/register")
-async def register_instance():
-    #register the instance to Instance Register
-    pass
+async def register_instance(request: Request):
+    try:
+        data = await request.json()
+        if not data or "url" not in data:
+            return JSONResponse(content={"error": "No URL provided"}, status_code=400)
+        
+        url = data["url"]
+        if not is_valid_url(url):
+            return JSONResponse(content={"error": "Invalid URL"}, status_code=400)
+
+        # Register the instance
+        load_balancer.register_instance(url)
+        logging.info(f"Instance registered: {url}")
+
+        return JSONResponse(content={"message": f"Instance {url} registered successfully"}, status_code=200)
+
+    except Exception as e:
+        logging.error(f"Error registering instance: {e}")
+        return JSONResponse(content={"error": "Failed to register instance"}, status_code=500)
 
 @app.get("/api/get/file_structure")
 async def get_file_structure():
@@ -94,4 +111,12 @@ async def get_season_metadata_api(series_id: int, season: str):
         data = await read_json_file(json_cache_path)
         return JSONResponse(content=data)
     
-    raise HTTPException(status_code=404, detail="Metadata not found")
+    raise HTTPException(status_code=404, detail="Metadata not found")
+
+@app.get('/api/get/instances')
+def get_instances():
+    return load_balancer.instances
+
+@app.get('/api/get/instances/health')
+def get_instances_health():
+    return load_balancer.instances_health