feat: Implement Java validation and download

Author: CalaKuad1

minecraft_server_gui.py

@@ -17,8 +17,8 @@
 
 from gui.widgets import CollapsiblePane
 from utils.constants import *
-from utils.helpers import format_size, get_folder_size, get_local_ip, get_server_port
-from utils.api_client import fetch_player_avatar_image, fetch_player_uuid, download_server_jar, get_server_versions, fetch_username_from_uuid, get_forge_versions
+from utils.helpers import format_size, get_folder_size, get_local_ip, get_server_port, get_java_version, get_required_java_version
+from utils.api_client import fetch_player_avatar_image, fetch_player_uuid, download_server_jar, get_server_versions, fetch_username_from_uuid, get_forge_versions, download_jre
 from server.server_handler import ServerHandler
 from server.config_manager import ConfigManager
 
@@ -328,7 +328,7 @@ def _create_setup_wizard(self):
         self.vanilla_version_frame = ctk.CTkFrame(self.version_options_container, fg_color="transparent")
         ctk.CTkLabel(self.vanilla_version_frame, text="2. Select Minecraft Version", font=ctk.CTkFont(weight="bold")).pack(anchor='w', pady=(10,5))
         self.server_version_var = tk.StringVar()
-        self.version_menu = ctk.CTkComboBox(self.vanilla_version_frame, variable=self.server_version_var, values=["Loading..."], state="disabled")
+        self.version_menu = ctk.CTkComboBox(self.vanilla_version_frame, variable=self.server_version_var, values=["Loading..."], state="disabled", command=self._check_java_compatibility)
         self.version_menu.pack(fill=tk.X, pady=5)
 
         # Steps 2 & 3 (Forge): Forge-specific widgets
@@ -356,9 +356,20 @@ def _create_setup_wizard(self):
         self.server_name_var = tk.StringVar()
         self.server_name_entry = ctk.CTkEntry(self.install_frame, textvariable=self.server_name_var)
         self.server_name_entry.pack(fill=tk.X, pady=5)
+
+        # --- Java Validation ---
+        self.java_status_frame = ctk.CTkFrame(self.install_frame, fg_color="gray20")
+        self.java_status_frame.pack(fill=tk.X, pady=10, ipady=5)
+        self.java_status_label = ctk.CTkLabel(self.java_status_frame, text="Java Status: Checking...", anchor="w")
+        self.java_status_label.pack(side=tk.LEFT, padx=10)
 
+        self.download_jre_var = tk.BooleanVar(value=False)
+        self.download_jre_checkbox = ctk.CTkCheckBox(self.install_frame, text="Automatically download a compatible Java runtime", variable=self.download_jre_var)
+        # Will be packed later if needed
+
         self.eula_accepted_var = tk.BooleanVar(value=False)
-        ctk.CTkCheckBox(self.install_frame, text="I agree to the Minecraft EULA (minecraft.net/eula)", variable=self.eula_accepted_var).pack(fill=tk.X, pady=10)
+        self.eula_checkbox = ctk.CTkCheckBox(self.install_frame, text="I agree to the Minecraft EULA (minecraft.net/eula)", variable=self.eula_accepted_var)
+        self.eula_checkbox.pack(fill=tk.X, pady=10)
 
         # --- Widgets for "Use Existing Server" ---
         ctk.CTkLabel(self.existing_frame, text="1. Choose Existing Server Location", font=ctk.CTkFont(weight="bold")).pack(anchor='w', pady=(10,5))
@@ -370,7 +381,7 @@ def _create_setup_wizard(self):
 
         # --- Action Button & Progress ---
         self.action_button = ctk.CTkButton(setup_frame, text="Download and Install Server", command=self._start_setup_action)
-        self.action_button.pack(pady=(30, 10), ipady=10, fill=tk.X)
+        self.action_button.pack(pady=(20, 10), ipady=10, fill=tk.X)
         self.progress_bar = ctk.CTkProgressBar(setup_frame)
         self.progress_bar.set(0)
         self.progress_bar.pack(fill=tk.X, pady=5)
@@ -383,6 +394,36 @@ def _create_setup_wizard(self):
         self._toggle_setup_view()
         self._on_server_type_change()
 
+    def _check_java_compatibility(self, *args):
+        mc_version_str = self.server_version_var.get()
+        if self.server_type_var.get().lower() == 'forge':
+            mc_version_str = self.forge_mc_version_var.get()
+
+        if not mc_version_str or "Loading" in mc_version_str or "Error" in mc_version_str:
+            self.java_status_label.configure(text="Java Status: Select a Minecraft version first")
+            return
+
+        required_version = get_required_java_version(mc_version_str)
+        installed_version = get_java_version()
+
+        if installed_version is None:
+            status_text = f"❌ Java Not Found (Required: Java {required_version}+)"
+            status_color = "red"
+            self.download_jre_var.set(True)
+            self.download_jre_checkbox.pack(fill=tk.X, pady=5, before=self.eula_checkbox)
+        elif installed_version < required_version:
+            status_text = f"⚠️ Wrong Version: Java {installed_version} found (Required: Java {required_version}+)"
+            status_color = "orange"
+            self.download_jre_var.set(True)
+            self.download_jre_checkbox.pack(fill=tk.X, pady=5, before=self.eula_checkbox)
+        else:
+            status_text = f"✅ Java {installed_version} Found (Compatible)"
+            status_color = "green"
+            self.download_jre_var.set(False)
+            self.download_jre_checkbox.pack_forget()
+
+        self.java_status_label.configure(text=status_text, text_color=status_color)
+
     def _on_server_type_change(self, *args):
         server_type = self.server_type_var.get().lower()
 
@@ -400,6 +441,8 @@ def _on_server_type_change(self, *args):
             self.location_step_label.configure(text="3. Choose Parent Directory")
             self.name_step_label.configure(text="4. Name Server Folder")
             self._update_server_versions()
+        
+        self._check_java_compatibility()
 
     def _update_forge_versions(self):
         self.forge_mc_version_var.set("Loading...")
@@ -420,6 +463,7 @@ def update_ui():
             else:
                 self.forge_mc_version_var.set("Error")
                 self.forge_version_var.set("Error")
+            self._check_java_compatibility()
 
         if hasattr(self, 'master'):
             self.master.after(0, update_ui)
@@ -435,11 +479,13 @@ def _on_forge_mc_version_selected(self, mc_version):
         else:
             self.forge_version_menu.configure(values=[], state="disabled")
             self.forge_version_var.set("N/A")
+        self._check_java_compatibility()
 
     def _update_server_versions(self, *args):
         server_type = self.server_type_var.get()
         if server_type.lower() == "forge":
-            return # No need to fetch versions for Forge this way
+            self._check_java_compatibility()
+            return
 
         self.server_version_var.set("Loading...")
         self.version_menu.configure(state=tk.DISABLED)
@@ -455,6 +501,7 @@ def update_ui():
                 self.server_version_var.set(versions[0])
             else:
                 self.server_version_var.set("Error fetching versions")
+            self._check_java_compatibility()
 
         if hasattr(self, 'master'):
             self.master.after(0, update_ui)
@@ -580,6 +627,32 @@ def _detect_server_version(self, server_path):
 
     def _perform_server_installation(self):
         try:
+            # --- Java Handling ---
+            if self.download_jre_var.get():
+                mc_version_str = self.server_version_var.get()
+                if self.server_type_var.get().lower() == 'forge':
+                    mc_version_str = self.forge_mc_version_var.get()
+                
+                required_java = get_required_java_version(mc_version_str)
+                self.master.after(0, self.status_label.configure, {'text': f"Downloading compatible Java JRE (Version {required_java})..."})
+                
+                def progress_callback(p):
+                    self.master.after(0, self.progress_bar.set, p / 100)
+
+                jre_path = download_jre(java_version=required_java, progress_callback=progress_callback)
+
+                if not jre_path:
+                    raise Exception(f"Failed to download the required Java JRE. Please install Java {required_java} manually and try again.")
+                
+                # On Windows, the executable is in /bin/java.exe
+                java_exe_path = os.path.join(jre_path, 'bin', 'java.exe')
+                if not os.path.exists(java_exe_path):
+                    raise Exception(f"Could not find java.exe in the downloaded JRE folder.")
+                
+                self.java_path_var.set(java_exe_path)
+                self.master.after(0, self.status_label.configure, {'text': "Java JRE downloaded successfully."})
+                self.master.after(0, self.progress_bar.set, 0)
+
             server_type = self.server_type_var.get().lower()
             parent_dir = self.install_location_var.get()
             server_folder_name = self.server_name_var.get()
@@ -595,7 +668,7 @@ def _perform_server_installation(self):
             os.makedirs(install_path, exist_ok=True)
 
             # Initialize ServerHandler here to use its methods
-            temp_server_handler = ServerHandler(install_path, server_type, "1", "2", "G", lambda msg, level: self.master.after(0, self.log_to_console, msg, level))
+            temp_server_handler = ServerHandler(install_path, server_type, "1", "2", "G", lambda msg, level: self.master.after(0, self.log_to_console, msg, level), java_path=self.java_path_var.get())
 
             if server_type == 'forge':
                 forge_version = self.forge_version_var.get()
@@ -627,7 +700,7 @@ def install_logic():
                 self.master.after(0, self.status_label.configure, {'text': "First-time server run to generate files..."})
                 self.master.after(0, self.progress_bar.set, 0)
 
-                initial_run_command = ['java', '-jar', jar_name, '--nogui']
+                initial_run_command = [self.java_path_var.get(), '-jar', jar_name, '--nogui']
                 process = subprocess.Popen(initial_run_command, cwd=install_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0)
                 try:
                     stdout, stderr = process.communicate(timeout=600)

server/server_handler.py

@@ -9,13 +9,14 @@
 from utils.api_client import download_file_from_url, download_and_extract_zip
 
 class ServerHandler:
-    def __init__(self, server_path, server_type, ram_min, ram_max, ram_unit, output_callback):
+    def __init__(self, server_path, server_type, ram_min, ram_max, ram_unit, output_callback, java_path="java"):
         self.server_path = server_path
         self.server_type = server_type
         self.ram_min = ram_min
         self.ram_max = ram_max
         self.ram_unit = ram_unit
         self.output_callback = output_callback
+        self.java_path = java_path
         self.server_process = None
         self.tunnel_process = None
         self.public_url = None
@@ -44,7 +45,7 @@ def install_forge_server(self, forge_version, minecraft_version, progress_callba
 
         # Run the installer
         try:
-            install_command = ["java", "-jar", installer_path, "--installServer"]
+            install_command = [self.java_path, "-jar", installer_path, "--installServer"]
             process = subprocess.Popen(install_command, cwd=self.server_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0)
 
             # Log stdout and stderr from the installer
@@ -100,7 +101,7 @@ def start(self):
         threading.Thread(target=self._run_server, args=(command, env), daemon=True).start()
 
     def _get_start_command(self):
-        java_path = "java"
+        java_path = self.java_path
         run_script = None
 
         # Universal check for startup scripts

utils/api_client.py

@@ -139,8 +139,11 @@ def download_file_from_url(download_url, save_path, progress_callback):
         logging.error(f"Failed to download file: {e}")
         return False
 
-def download_and_extract_zip(url, extract_to_dir, progress_callback):
-    """Downloads a zip file and extracts its contents."""
+def download_and_extract_zip(url, extract_to_dir, progress_callback, contains_single_folder=True):
+    """
+    Downloads a zip file and extracts its contents.
+    If contains_single_folder is True, it moves the contents of the single top-level folder up one level.
+    """
     os.makedirs(extract_to_dir, exist_ok=True)
     zip_path = os.path.join(extract_to_dir, 'temp.zip')
 
@@ -152,17 +155,99 @@ def download_and_extract_zip(url, extract_to_dir, progress_callback):
     logging.info(f"Extracting {zip_path} to {extract_to_dir}")
     try:
         with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-            zip_ref.extractall(extract_to_dir)
+            if contains_single_folder:
+                # Extract to a temporary subdirectory to handle the nested folder structure
+                temp_extract_dir = os.path.join(extract_to_dir, "temp_extract")
+                os.makedirs(temp_extract_dir, exist_ok=True)
+                zip_ref.extractall(temp_extract_dir)
+                
+                # Identify the single folder inside the temp directory
+                extracted_items = os.listdir(temp_extract_dir)
+                if len(extracted_items) == 1 and os.path.isdir(os.path.join(temp_extract_dir, extracted_items[0])):
+                    single_folder_path = os.path.join(temp_extract_dir, extracted_items[0])
+                    # Move each item from the single folder to the final destination
+                    for item_name in os.listdir(single_folder_path):
+                        source_item = os.path.join(single_folder_path, item_name)
+                        dest_item = os.path.join(extract_to_dir, item_name)
+                        os.rename(source_item, dest_item)
+                    # Clean up the temporary extraction directory
+                    os.rmdir(single_folder_path)
+                    os.rmdir(temp_extract_dir)
+                else:
+                    # If it's not a single folder, move items directly
+                    for item_name in extracted_items:
+                        source_item = os.path.join(temp_extract_dir, item_name)
+                        dest_item = os.path.join(extract_to_dir, item_name)
+                        os.rename(source_item, dest_item)
+                    os.rmdir(temp_extract_dir)
+
+            else: # Original behavior
+                zip_ref.extractall(extract_to_dir)
+
         logging.info("Extraction complete.")
-    except zipfile.BadZipFile:
-        logging.error("Failed to extract: The file is not a valid zip file.")
+    except (zipfile.BadZipFile, IOError) as e:
+        logging.error(f"Failed to extract: {e}")
         return False
     finally:
         if os.path.exists(zip_path):
             os.remove(zip_path)
 
     return True
 
+def download_jre(java_version, os_type="windows", arch="x64", progress_callback=None):
+    """
+    Downloads a portable JRE from Adoptium API.
+    Returns the path to the extracted JRE folder or None on failure.
+    """
+    if progress_callback is None:
+        progress_callback = lambda p: None
+
+    try:
+        api_url = f"https://api.adoptium.net/v3/assets/latest/{java_version}/hotspot?vendor=eclipse"
+        response = requests.get(api_url, timeout=15)
+        response.raise_for_status()
+        releases = response.json()
+
+        binary_info = None
+        for release in releases:
+            if release['binary']['os'] == os_type and release['binary']['architecture'] == arch and release['binary']['image_type'] == 'jre':
+                binary_info = release['binary']
+                break
+        
+        if not binary_info:
+            logging.error(f"Could not find a matching JRE for Java {java_version}, OS: {os_type}, Arch: {arch}")
+            return None
+
+        download_url = binary_info['package']['link']
+        jre_name = f"jre-{java_version}"
+        extract_path = os.path.join(os.getcwd(), "jre_temp") # Temp extraction folder
+        final_path = os.path.join(os.getcwd(), jre_name) # Final destination
+
+        if os.path.exists(final_path):
+            logging.info(f"JRE for Java {java_version} already exists. Skipping download.")
+            return final_path
+
+        logging.info(f"Downloading JRE from: {download_url}")
+        
+        # The JRE zip from Adoptium contains a single top-level folder, so we need to handle that.
+        if download_and_extract_zip(download_url, extract_path, progress_callback, contains_single_folder=True):
+            os.rename(extract_path, final_path)
+            logging.info(f"JRE successfully downloaded and extracted to {final_path}")
+            return final_path
+        else:
+            logging.error("Failed to download and extract JRE.")
+            # Clean up failed extraction
+            if os.path.exists(extract_path):
+                import shutil
+                shutil.rmtree(extract_path)
+            return None
+
+    except requests.RequestException as e:
+        logging.error(f"API Error fetching JRE data: {e}")
+        return None
+    except Exception as e:
+        logging.error(f"An unexpected error occurred during JRE download: {e}")
+        return None
 
 if __name__ == '__main__':
     print("Fetching Forge versions...")