feat(auto-update): enhance logging and version handling for updates; support prerelease and nightly checks

Author: I-am-PUID-0

utils/auto_update.py

@@ -32,7 +32,9 @@ def update_schedule(self, process_name, config, key, instance_name):
                 self.scheduled_update_check, process_name, config, key, instance_name
             )
             Update._jobs[process_name] = True
-            self.logger.debug(f"Scheduled automatic update check for {process_name}")
+            self.logger.debug(
+                f"Scheduled automatic update check for {process_name}, w/ key: {key}, and job ID: {id(self.scheduler.jobs[-1])}"
+            )
 
         while not self.process_handler.shutting_down:
             self.scheduler.run_pending()
@@ -74,32 +76,46 @@ def auto_update(self, process_name, enable_update):
 
     def initial_update_check(self, process_name, config, key, instance_name):
         with self.updating:
+            self.logger.info(f"Performing initial update check for {process_name}")
             success, error = self.update_check(process_name, config, key, instance_name)
             if not success:
                 if "No updates available" in error:
                     self.logger.info(error)
+                    from utils.setup import setup_project
+
+                    success, error = setup_project(self.process_handler, process_name)
+                    if not success:
+                        return False, f"Failed to set up {process_name}: {error}"
+
                     self.start_process(process_name, config, key, instance_name)
                 else:
                     raise RuntimeError(error)
 
     def scheduled_update_check(self, process_name, config, key, instance_name):
         with self.updating:
+            self.logger.info(f"Performing scheduled update check for {process_name}")
             success, error = self.update_check(process_name, config, key, instance_name)
             if not success:
                 if "No updates available" in error:
                     self.logger.info(error)
-                    self.start_process(process_name, config, key, instance_name)
+                    # self.start_process(process_name, config, key, instance_name)
                 else:
                     raise RuntimeError(error)
 
     def update_check(self, process_name, config, key, instance_name):
-        if (
-            not key == "plex_debrid"
-            and config.get("release_version").lower() == "nightly"
-        ):
+        if "nightly" in config["release_version"].lower():
             nightly = True
+            prerelease = False
+            self.logger.info(f"Checking for nightly updates for {process_name}.")
+        elif config.get("release_version").lower() == "prerelease":
+            nightly = False
+            prerelease = True
+            self.logger.info(f"Checking for prerelease updates for {process_name}.")
         else:
             nightly = False
+            prerelease = False
+            self.logger.info(f"Checking for stable updates for {process_name}.")
+
         versions = Versions()
         try:
             repo_owner = config["repo_owner"]
@@ -111,6 +127,7 @@ def update_check(self, process_name, config, key, instance_name):
                 instance_name,
                 key,
                 nightly=nightly,
+                prerelease=prerelease,
             )
 
             if not update_needed:

utils/dmb_config_schema.json

@@ -119,7 +119,7 @@
               "type": "boolean"
             },
             "auto_update_interval": {
-              "type": "integer"
+              "type": "number"
             },
             "clear_on_update": {
               "type": "boolean"
@@ -228,7 +228,7 @@
           "type": "boolean"
         },
         "auto_update_interval": {
-          "type": "integer"
+          "type": "number"
         },
         "clear_on_update": {
           "type": "boolean"
@@ -385,7 +385,7 @@
           "type": "boolean"
         },
         "auto_update_interval": {
-          "type": "integer"
+          "type": "number"
         },
         "clear_on_update": {
           "type": "boolean"
@@ -468,7 +468,7 @@
           "type": "boolean"
         },
         "auto_update_interval": {
-          "type": "integer"
+          "type": "number"
         },
         "clear_on_update": {
           "type": "boolean"
@@ -791,7 +791,7 @@
           "type": "boolean"
         },
         "auto_update_interval": {
-          "type": "integer"
+          "type": "number"
         },
         "symlink_library_path": {
           "type": "string"
@@ -915,7 +915,7 @@
           "type": "boolean"
         },
         "auto_update_interval": {
-          "type": "integer"
+          "type": "number"
         },
         "clear_on_update": {
           "type": "boolean"
@@ -1011,7 +1011,7 @@
           "type": "boolean"
         },
         "auto_update_interval": {
-          "type": "integer"
+          "type": "number"
         },
         "clear_on_update": {
           "type": "boolean"
@@ -1165,7 +1165,7 @@
                   "type": "boolean"
                 },
                 "auto_update_interval": {
-                  "type": "integer"
+                  "type": "number"
                 },
                 "clear_on_update": {
                   "type": "boolean"

utils/download.py

@@ -85,14 +85,24 @@ def download_release_version(
                 if CONFIG_MANAGER.get("dmb").get("github_token"):
                     logger.debug("Using GitHub token for downloading zurg.")
                     # repo_name = "zurg"
-                    if release_version == "nightly":
+                    if "nightly" in release_version:
                         release_version, error = self.get_latest_release(
                             repo_owner, repo_name, nightly=True
                         )
                         if error:
                             logger.error(error)
                             return False, error
 
+            elif key == "cli_debrid":
+                architecture = None
+                if release_version == "prerelease":
+                    release_version, error = self.get_latest_release(
+                        repo_owner, repo_name, nightly=False, prerelease=True
+                    )
+                    if error:
+                        logger.error(error)
+                        return False, error
+
             elif key == "plex_debrid":
                 branch = "main"
                 branch_url, zip_folder_name = self.get_branch(
@@ -154,15 +164,15 @@ def download_release_version(
                     f"Failed to download the {release_version} for {process_name}: {error}"
                 )
                 return False, error
-            logger.info(
-                f"Successfully downloaded the {release_version} for {process_name}"
-            )
+            logger.info(f"Successfully downloaded {release_version} for {process_name}")
             return True, None
         except Exception as e:
             logger.error(f"Error in download release version: {e}")
             return False, str(e)
 
-    def get_latest_release(self, repo_owner, repo_name, nightly=False):
+    def get_latest_release(
+        self, repo_owner, repo_name, nightly=False, prerelease=False
+    ):
         self.logger.debug(f"Fetching latest {repo_name} release.")
         headers = self.get_headers()
         if repo_name == "plex_debrid":
@@ -185,7 +195,7 @@ def get_latest_release(self, repo_owner, repo_name, nightly=False):
                 )
             except Exception as e:
                 return None, f"Exception while fetching version for {repo_name}: {e}"
-        if nightly:
+        if nightly or prerelease:
             api_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases"
         else:
             api_url = (
@@ -203,6 +213,17 @@ def get_latest_release(self, repo_owner, repo_name, nightly=False):
                     return latest_nightly["tag_name"], None
                 return None, "No nightly releases found."
 
+            elif prerelease:
+                prerelease_releases = [
+                    release for release in releases if release["prerelease"]
+                ]
+                if prerelease_releases:
+                    latest_prerelease = max(
+                        prerelease_releases, key=lambda x: x["tag_name"]
+                    )
+                    return latest_prerelease["tag_name"], None
+                return None, "No prerelease versions found."
+
             else:
                 latest_release = response.json()
                 version_tag = latest_release["tag_name"]
@@ -241,23 +262,24 @@ def fetch_github_release_info(
 
     def find_asset_download_url(self, release_info, architecture=None):
         assets = release_info.get("assets", [])
-        for asset in assets:
-            if architecture and architecture in asset["name"]:
-                self.logger.debug(
-                    f"Assets ID found: {asset['id']} for architecture: {architecture}"
-                )
-                self.logger.debug(
-                    f"Browser Download URL: {asset['browser_download_url']}"
-                )
-                return asset["browser_download_url"], asset["id"]
+        if architecture:
+            for asset in assets:
+                if architecture and architecture in asset["name"]:
+                    self.logger.debug(
+                        f"Assets ID found: {asset['id']} for architecture: {architecture}"
+                    )
+                    self.logger.debug(
+                        f"Browser Download URL: {asset['browser_download_url']}"
+                    )
+                    return asset["browser_download_url"], asset["id"]
 
-        if assets:
-            self.logger.warning(
-                "No matching asset found for architecture: %s. Falling back to the first available asset.",
-                architecture,
-            )
-            self.logger.debug(f"Download URL: {asset['browser_download_url']}")
-            return assets[0]["browser_download_url"], assets[0]["id"]
+            if assets:
+                self.logger.warning(
+                    "No matching asset found for architecture: %s. Falling back to the first available asset.",
+                    architecture,
+                )
+                self.logger.debug(f"Download URL: {asset['browser_download_url']}")
+                return assets[0]["browser_download_url"], assets[0]["id"]
 
         zipball_url = release_info.get("zipball_url")
         tarball_url = release_info.get("tarball_url")

utils/setup.py

@@ -161,12 +161,34 @@ def setup_project(process_handler, process_name):
 
     logger.info(f"Setting up {process_name}...")
     try:
-        if config.get("release_version_enabled"):
-            success, error = setup_release_version(
-                process_handler, config, process_name, key
+        if config.get("release_version_enabled") and not config.get("auto_update"):
+            repo_owner = config.get("repo_owner")
+            repo_name = config.get("repo_name")
+            nightly = "nightly" in config["release_version"].lower()
+            prerelease = config.get("release_version").lower() == "prerelease"
+            update_needed, update_info = versions.compare_versions(
+                process_name,
+                repo_owner,
+                repo_name,
+                instance_name,
+                key,
+                nightly=nightly,
+                prerelease=prerelease,
             )
-            if not success:
-                return False, error
+
+            if update_needed:
+                logger.info(
+                    f"Update needed for {process_name}: {update_info['latest_version']}, but using the requested version: {config['release_version']}"
+                )
+                success, error = setup_release_version(
+                    process_handler, config, process_name, key
+                )
+                if not success:
+                    return False, error
+            else:
+                logger.info(
+                    f"No update needed for {process_name}: current version is {update_info['current_version']}, and requested version is: {config['release_version']}"
+                )
 
         elif config.get("branch_enabled"):
             success, error = setup_branch_version(
@@ -525,12 +547,16 @@ def setup_zurg_instance(instance, key_type):
                 )
 
                 if not os.path.exists(instance_zurg_binaries):
+                    if instance.get("release_version_enabled"):
+                        release_version = instance.get("release_version")
+                    else:
+                        release_version = "latest"
                     success, error = downloader.download_release_version(
                         process_name=instance["process_name"],
                         key="zurg",
                         repo_owner=instance["repo_owner"],
                         repo_name=instance["repo_name"],
-                        release_version="latest",
+                        release_version=release_version,
                         target_dir=instance_config_dir,
                         zip_folder_name=None,
                         exclude_dirs=instance.get("exclude_dirs", []),

utils/versions.py

@@ -124,6 +124,8 @@ def version_check(
                                     )
                                     match = re.search(r"v?\d+(\.\d+)*", version_raw)
                                     version = match.group(0) if match else ""
+                                    if key == "riven_backend":
+                                        version = f"v{version}"
                                     break
                             else:
                                 version = None
@@ -199,11 +201,18 @@ def version_write(self, process_name, key=None, version_path=None, version=None)
             return False, str(e)
 
     def compare_versions(
-        self, process_name, repo_owner, repo_name, instance_name, key, nightly=False
+        self,
+        process_name,
+        repo_owner,
+        repo_name,
+        instance_name,
+        key,
+        nightly=False,
+        prerelease=False,
     ):
         try:
             latest_release_version, error = self.downloader.get_latest_release(
-                repo_owner, repo_name, nightly=nightly
+                repo_owner, repo_name, nightly=nightly, prerelease=prerelease
             )
             if not latest_release_version:
                 self.logger.error(
@@ -217,7 +226,19 @@ def compare_versions(
                 self.logger.error(
                     f"Failed to get the current version for {process_name}: {error}"
                 )
-                raise Exception(error)
+                current_version = "0.0.0"
+                self.logger.error(
+                    f"Setting current version to 0.0.0 for {process_name}"
+                )
+                # raise Exception(error)
+            if nightly:
+                current_date = ".".join(current_version.split(".")[0:3])
+                latest_date = ".".join(latest_release_version.split(".")[0:3])
+                if current_date == latest_date:
+                    return False, {
+                        "message": "No updates available (same nightly date)",
+                        "current_version": current_version,
+                    }
             if current_version == latest_release_version:
                 return False, {
                     "message": "No updates available",