0.0.2.6 V Beta Patch

LoadBalancer.py

@@ -19,7 +19,7 @@ download_progress = {}
 
 class LoadBalancer:
     def __init__(self, cache_dir, index_file, token, repo, polling_interval=4, max_retries=3, initial_delay=1):
-        self.version = "0.0.2.5 V Beta"
+        self.version = "0.0.2.6 V Beta"
         self.instances = []
         self.instances_health = {}
         self.polling_interval = polling_interval
@@ -31,19 +31,14 @@ class LoadBalancer:
         self.INDEX_FILE = index_file
         self.TOKEN = token
         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.FILM_STORE = {}
+        self.TV_STORE = {}
         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]:
-            if not os.path.exists(path):
-                with open(path, 'w') as json_file:
-                    json.dump({}, json_file)
-
         # Index the file structure
         indexer()
 
@@ -58,7 +53,6 @@ class LoadBalancer:
         prefetch_thread.daemon = True
         prefetch_thread.start()
 
-
     def register_instance(self, instance_url):
         if instance_url not in self.instances:
             self.instances.append(instance_url)
@@ -70,8 +64,6 @@ class LoadBalancer:
         if instance_url in self.instances:
             self.instances.remove(instance_url)
             self.instances_health.pop(instance_url, None)
-            self.clear_json_file(self.FILM_STORE_JSON_PATH)
-            self.clear_json_file(self.TV_STORE_JSON_PATH)
             logging.info(f"Removed instance {instance_url}")
         else:
             logging.info(f"Instance {instance_url} not found for removal.")
@@ -92,10 +84,8 @@ class LoadBalancer:
                 logging.error(f"Failed to get report from {instance_url}. Removing instance.")
                 self.remove_instance(instance_url)
 
-        # Use concurrent.futures to update JSON files in separate threads without waiting
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            executor.submit(self.update_film_store_json, temp_film_store)
-            executor.submit(self.update_tv_store_json, temp_tv_store)
+        self.FILM_STORE = temp_film_store
+        self.TV_STORE = temp_tv_store
 
     def process_report(self, instance_url, report, temp_film_store, temp_tv_store):
         film_store = report.get('film_store', {})
@@ -134,65 +124,7 @@ class LoadBalancer:
         logging.info("Stopping polling.")
         self.stop_event.set()
 
-    def update_film_store_json(self, temp_film_store, ):
-        # Load current data
-        film_store_data = self.read_json(self.FILM_STORE_JSON_PATH)
-        
-
-        # Compare and update film store
-        for title in list(film_store_data.keys()):
-            if title not in temp_film_store:
-                del film_store_data[title]
-        
-        for title, url in temp_film_store.items():
-            film_store_data[title] = url
-
-        with open(self.FILM_STORE_JSON_PATH, 'w') as json_file:
-            json.dump(film_store_data, json_file, indent=2)
-
-        print(f'Film store updated.')
-
-    def update_tv_store_json(self, temp_tv_store):
-        """
-        Updates the TV store JSON with the new file, organizing by title, season, and episode.
-        """
-        tv_store_data = self.read_json(self.TV_STORE_JSON_PATH)
-        # Compare and update TV store
-        for title in list(tv_store_data.keys()):
-            if title not in temp_tv_store:
-                del tv_store_data[title]
-            else:
-                for season in list(tv_store_data[title].keys()):
-                    if season not in temp_tv_store[title]:
-                        del tv_store_data[title][season]
-                    else:
-                        for episode in list(tv_store_data[title][season].keys()):
-                            if episode not in temp_tv_store[title][season]:
-                                del tv_store_data[title][season][episode]
-
-        for title, seasons in temp_tv_store.items():
-            if title not in tv_store_data:
-                tv_store_data[title] = {}
-            for season, episodes in seasons.items():
-                if season not in tv_store_data[title]:
-                    tv_store_data[title][season] = {}
-                for episode, url in episodes.items():
-                    tv_store_data[title][season][episode] = url
-
-        with open(self.TV_STORE_JSON_PATH, 'w') as json_file:
-            json.dump(tv_store_data, json_file, indent=2)
-
-        print(f'TV store updated.')
-
 ######################################################################
-
-    @staticmethod
-    def read_json(file_path):
-        if os.path.exists(file_path):
-            with open(file_path, 'r') as json_file:
-                return json.load(json_file)
-        return {}
-
     @staticmethod
     def get_system_proxies():
         """
@@ -212,27 +144,6 @@ class LoadBalancer:
             print(f"Error getting system proxies: {e}")
             return {}
 
-
-    @staticmethod
-    def clear_json_file(file_path):
-        """
-        Clears the data in a JSON file by replacing its contents with an empty JSON object.
-
-        :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)
@@ -347,11 +258,6 @@ class LoadBalancer:
         return float(space_str.split()[0])
 
 #################################################################
-    def load_json(self, file_path):
-        """Load JSON data from a file."""
-        with open(file_path, 'r') as file:
-            return json.load(file)
-
     def find_movie_path(self, title):
         """Find the path of the movie in the JSON data based on the title."""
         for directory in self.file_structure:

TODO.md

@@ -0,0 +1 @@
+# implement a better way to collect store jsons

app.py

@@ -31,13 +31,9 @@ def get_movie_api(title):
     if not title:
         return jsonify({"error": "Title parameter is required"}), 400
     
-    # Load the film store JSON
-    with open(load_balancer.FILM_STORE_JSON_PATH, 'r') as json_file:
-        film_store_data = json.load(json_file)
-
     # Check if the film is already cached
-    if title in film_store_data:
-        url = film_store_data[title]
+    if title in load_balancer.FILM_STORE:
+        url = load_balancer.FILM_STORE[title]
         return jsonify({"url":url})
 
     movie_path = load_balancer.find_movie_path(title)
@@ -56,15 +52,11 @@ def get_tv_show_api(title, season, episode):
     if not title or not season or not episode:
         return jsonify({"error": "Title, season, and episode parameters are required"}), 400
 
-    # Load the TV store JSON
-    with open(load_balancer.TV_STORE_JSON_PATH, 'r') as json_file:
-        tv_store_data = json.load(json_file)
-
     # Check if the episode is already cached
-    if title in tv_store_data and season in tv_store_data[title]:
-        for ep in tv_store_data[title][season]:
+    if title in load_balancer.TV_STORE and season in load_balancer.TV_STORE[title]:
+        for ep in load_balancer.TV_STORE[title][season]:
             if episode in ep:
-                url = tv_store_data[title][season][ep]
+                url = load_balancer.TV_STORE[title][season][ep]
                 return jsonify({"url":url})
 
     tv_path = load_balancer.find_tv_path(title)
@@ -129,20 +121,14 @@ def clear_cache_api():
 @app.route('/api/tv/store', methods=['GET'])
 def get_tv_store_api():
     """Endpoint to get the TV store JSON."""
-    if os.path.exists(load_balancer.TV_STORE_JSON_PATH):
-        with open(load_balancer.TV_STORE_JSON_PATH, 'r') as json_file:
-            tv_store_data = json.load(json_file)
-        return jsonify(tv_store_data)
-    return jsonify({}), 404
+    return jsonify(load_balancer.TV_STORE)
+
 
 @app.route('/api/film/store', methods=['GET'])
 def get_film_store_api():
     """Endpoint to get the film store JSON."""
-    if os.path.exists(load_balancer.FILM_STORE_JSON_PATH):
-        with open(load_balancer.FILM_STORE_JSON_PATH, 'r') as json_file:
-            tv_store_data = json.load(json_file)
-        return jsonify(tv_store_data)
-    return jsonify({}), 404
+    return jsonify(load_balancer.FILM_STORE)
+
 
 @app.route('/api/film/metadata/<title>', methods=['GET'])
 def get_film_metadata_api(title):