0.0.2.5 V Beta fix

LoadBalancer.py

@@ -12,14 +12,13 @@ import logging
 from threading import Thread, Event, Timer
 from api import InstancesAPI
 
-
 CACHE_DIR = os.getenv("CACHE_DIR")
 
 download_progress = {}
 
 class LoadBalancer:
     def __init__(self, cache_dir, index_file, token, repo, polling_interval=10, max_retries=3, initial_delay=1):
-        self.version = "0.0.2.4 V Beta"
+        self.version = "0.0.2.5 V Beta"
         self.instances = []
         self.instances_health = {}
         self.polling_interval = polling_interval
@@ -33,13 +32,15 @@ class LoadBalancer:
         self.REPO = repo
         self.FILM_STORE_JSON_PATH = os.path.join(cache_dir, "film_store.json")
         self.TV_STORE_JSON_PATH = os.path.join(cache_dir, "tv_store.json")
+        self.TEMP_FILM_STORE_JSON_PATH = os.path.join(cache_dir, "temp_film_store.json")
+        self.TEMP_TV_STORE_JSON_PATH = os.path.join(cache_dir, "temp_tv_store.json")
         self.file_structure = None
 
         # Ensure CACHE_DIR exists
         if not os.path.exists(self.CACHE_DIR):
             os.makedirs(self.CACHE_DIR)
 
-        for path in [self.FILM_STORE_JSON_PATH, self.TV_STORE_JSON_PATH]:
+        for path in [self.FILM_STORE_JSON_PATH, self.TV_STORE_JSON_PATH, self.TEMP_FILM_STORE_JSON_PATH, self.TEMP_TV_STORE_JSON_PATH]:
             if not os.path.exists(path):
                 with open(path, 'w') as json_file:
                     json.dump({}, json_file)
@@ -93,36 +94,40 @@ class LoadBalancer:
         cache_size = report.get('cache_size')
 
         logging.info(f"Processing report from {instance_url}")
-        # logging.info(f"Film Store: {film_store}")
-        # logging.info(f"TV Store: {tv_store}")
-        # logging.info(f"Cache Size: {cache_size}")
+
+        # Clear temporary JSON files before processing
+        self.clear_json_file(self.TEMP_FILM_STORE_JSON_PATH)
+        self.clear_json_file(self.TEMP_TV_STORE_JSON_PATH)
 
         # Process films
         for title, path in film_store.items():
             url = f"{instance_url}/api/film/{title.replace(' ', '%20')}"
-            self.update_film_store_json(title, url)
+            self.update_temp_film_store_json(title, url)
 
- 
         # Process TV shows
         for title, seasons in tv_store.items():
             for season, episodes in seasons.items():
                 for episode, path in episodes.items():
                     url = f"{instance_url}/api/tv/{title.replace(' ', '%20')}/{season.replace(' ', '%20')}/{episode.replace(' ', '%20')}"
-                    self.update_tv_store_json(title, season, episode, url)
+                    self.update_temp_tv_store_json(title, season, episode, url)
 
         logging.info("Film and TV Stores processed successfully.")
+        self.replace_store_jsons()
         self.update_instances_health(instance=instance_url, cache_size=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 replace_store_jsons(self):
+        """Replace the actual JSON contents with the temporary JSON contents."""
+        self.replace_json_content(self.TEMP_FILM_STORE_JSON_PATH, self.FILM_STORE_JSON_PATH)
+        self.replace_json_content(self.TEMP_TV_STORE_JSON_PATH, self.TV_STORE_JSON_PATH)
+
+    @staticmethod
+    def replace_json_content(temp_file_path, actual_file_path):
+        """Replace the content of the actual JSON file with the content of the temporary JSON file."""
+        with open(temp_file_path, 'r') as temp_file:
+            temp_data = json.load(temp_file)
 
-    def stop_polling(self):
-        logging.info("Stopping polling.")
-        self.stop_event.set()
+        with open(actual_file_path, 'w') as actual_file:
+            json.dump(temp_data, actual_file, indent=2)
 
 ######################################################################
 
@@ -152,37 +157,26 @@ class LoadBalancer:
             print(f"Error getting system proxies: {e}")
             return {}
 
-    def update_film_store_json(self,title, url):
+    def update_temp_film_store_json(self, title, url):
         """
-        Updates the film store JSON with the new file.
+        Updates the temporary film store JSON with the new file.
 
         Args:
             title (str): The title of the film.
             url (str): The url.
         """
-        FILM_STORE_JSON_PATH = self.FILM_STORE_JSON_PATH
-
-        film_store_data = {}
-        if os.path.exists(FILM_STORE_JSON_PATH):
-            with open(FILM_STORE_JSON_PATH, 'r') as json_file:
-                film_store_data = json.load(json_file)
-
+        film_store_data = self.read_json(self.TEMP_FILM_STORE_JSON_PATH)
         film_store_data[title] = url
 
-        with open(FILM_STORE_JSON_PATH, 'w') as json_file:
+        with open(self.TEMP_FILM_STORE_JSON_PATH, 'w') as json_file:
             json.dump(film_store_data, json_file, indent=2)
-        print(f'Film store updated with {title}.')
+        print(f'Temporary film store updated with {title}.')
 
-    def update_tv_store_json(self, title, season, episode, url):
+    def update_temp_tv_store_json(self, title, season, episode, url):
         """
-        Updates the TV store JSON with the new file, organizing by title, season, and episode.
+        Updates the temporary TV store JSON with the new file, organizing by title, season, and episode.
         """
-        TV_STORE_JSON_PATH = self.TV_STORE_JSON_PATH
-
-        tv_store_data = {}
-        if os.path.exists(TV_STORE_JSON_PATH):
-            with open(TV_STORE_JSON_PATH, 'r') as json_file:
-                tv_store_data = json.load(json_file)
+        tv_store_data = self.read_json(self.TEMP_TV_STORE_JSON_PATH)
 
         if title not in tv_store_data:
             tv_store_data[title] = {}
@@ -192,10 +186,10 @@ class LoadBalancer:
 
         tv_store_data[title][season][episode] = url
 
-        with open(TV_STORE_JSON_PATH, 'w') as json_file:
+        with open(self.TEMP_TV_STORE_JSON_PATH, 'w') as json_file:
             json.dump(tv_store_data, json_file, indent=2)
 
-        print(f'TV store updated with {title}, {season}, {episode}.')
+        print(f'Temporary TV store updated with {title}, {season}, {episode}.')
 
     @staticmethod
     def clear_json_file(file_path):
@@ -204,22 +198,17 @@ class LoadBalancer:
 
         :param file_path: Path to the JSON file to be cleared
         """
-        # Create an empty dictionary to replace the existing data
         empty_data = {}
 
         try:
-            # Open the file in write mode
             with open(file_path, 'w') as json_file:
-                # Write the empty dictionary to the file
                 json.dump(empty_data, json_file)
             print(f"Successfully cleared the data in {file_path}")
         except Exception as e:
             print(f"An error occurred while clearing the data in {file_path}: {e}")
 
-
     @staticmethod
     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...