re-register if load balancer didnt fetch report for a 1 minute

Instance.py

@@ -10,13 +10,14 @@ from indexer import indexer
 import re
 from tvdb import fetch_and_cache_json
 import logging
+from threading import Event
 
 CACHE_DIR = os.getenv("CACHE_DIR")
 
 download_progress = {}
 
 class Instance:
-    def __init__(self, id, url, cache_dir, index_file, token, repo, load_balancer_api,max_retries=20, initial_delay=1):
+    def __init__(self, id, url, cache_dir, index_file, token, repo, load_balancer_api, max_retries=20, initial_delay=1):
         self.version = "0.2.4 V Alpha"
         self.id = id
         self.url = url
@@ -31,6 +32,8 @@ class Instance:
         self.load_balancer_api = load_balancer_api
         self.max_retries = max_retries
         self.initial_delay = initial_delay
+        self.last_report_time = time.time()  # Initialize the last report time
+        self.re_register_event = Event()
 
         # Ensure CACHE_DIR exists
         if not os.path.exists(self.CACHE_DIR):
@@ -51,19 +54,26 @@ class Instance:
         with open(self.INDEX_FILE, 'r') as f:
             self.file_structure = json.load(f)
 
-        # Start prefetching metadata
-        thread = Thread(target=self.start_prefetching)
+        # Start prefetching metadata and monitoring registration
         self.register_to_load_balancer()
-        thread.daemon = True
-        thread.start()
+        prefetch_thread = Thread(target=self.start_prefetching)
+        registration_thread = Thread(target=self.monitor_registration)
+        
+        prefetch_thread.daemon = True
+        registration_thread.daemon = True
+
+        prefetch_thread.start()
+        registration_thread.start()
 
     def compile_report(self):
-        film_store_path = os.path.join(CACHE_DIR, "film_store.json")
-        tv_store_path = os.path.join(CACHE_DIR, "tv_store.json")
+        self.last_report_time = time.time()  # Update the last report time
+        
+        film_store_path = os.path.join(self.CACHE_DIR, "film_store.json")
+        tv_store_path = os.path.join(self.CACHE_DIR, "tv_store.json")
         cache_size = self.get_cache_size()
 
         report = {
-            "instance_id":self.id,
+            "instance_id": self.id,
             "instance_url": self.url,
             "film_store": self.read_json(film_store_path),
             "tv_store": self.read_json(tv_store_path),
@@ -71,6 +81,21 @@ class Instance:
         }
         return report
 
+    def register_to_load_balancer(self):
+        result = self.load_balancer_api.register_instance(self.id, self.url)
+        if result is not None:
+            logging.info(f'Registered instance {self.id} to load balancer.')
+        else:
+            logging.error(f'Failed to register instance {self.id} to load balancer.')
+
+    def monitor_registration(self):
+        while True:
+            if time.time() - self.last_report_time > 60:  # Check if 1 minute has passed
+                logging.info('1 minute passed since last report. Re-registering...')
+                self.register_to_load_balancer()
+                self.last_report_time = time.time()  # Reset the last report time
+            time.sleep(30)  # Check every 30 seconds
+
     def get_cache_size(self):
         total_size = 0
         for dirpath, dirnames, filenames in os.walk(CACHE_DIR):