Resolve RayJob E2E test failures and add entrypoint validation

Author: kryanbeane

src/codeflare_sdk/ray/rayjobs/rayjob.py

@@ -457,81 +457,93 @@ def _validate_cluster_config_image(self):
 
     def _validate_working_dir_entrypoint(self):
         """
-        Validate that entrypoint doesn't redundantly reference the working_dir.
+        Validate entrypoint file configuration.
 
-        This prevents a common mistake where users specify both working_dir and
-        reference the same directory in their entrypoint, causing the job to fail.
+        Checks:
+        1. Entrypoint doesn't redundantly reference working_dir
+        2. Local files exist before submission
 
-        Example problem:
-            working_dir = "./mydir"
-            entrypoint = "python ./mydir/script.py"  # Wrong! Will look for ./mydir/mydir/script.py
-
-        Should be:
-            entrypoint = "python script.py"  # Correct! Runs from within working_dir
-
-        Raises:
-            ValueError: If a redundant directory reference is detected
+        Raises ValueError if validation fails.
         """
-        # Get working_dir from runtime_env if it exists
-        if not self.runtime_env:
+        # Skip validation for inline commands (python -c, etc.)
+        if re.search(r"\s+-c\s+", self.entrypoint):
             return
 
-        runtime_env_dict = (
-            self.runtime_env.to_dict()
-            if hasattr(self.runtime_env, "to_dict")
-            else self.runtime_env
-        )
-        if not runtime_env_dict or "working_dir" not in runtime_env_dict:
+        # Match Python file references only
+        file_pattern = r"(?:python\d?\s+)?([./\w/-]+\.py)"
+        matches = re.findall(file_pattern, self.entrypoint)
+
+        if not matches:
             return
 
-        working_dir = runtime_env_dict["working_dir"]
+        entrypoint_path = matches[0]
 
-        # Only validate local working_dir (not remote URLs)
-        if not os.path.isdir(working_dir):
-            return
+        # Get working_dir from runtime_env
+        runtime_env_dict = None
+        working_dir = None
 
-        # Extract Python file path from entrypoint using the same pattern as runtime_env.py
-        # Pattern matches: test.py, ./test.py, dir/test.py, my-dir/test.py
-        python_file_pattern = r"(?:python\s+)?([./\w/-]+\.py)"
-        matches = re.findall(python_file_pattern, self.entrypoint)
+        if self.runtime_env:
+            runtime_env_dict = (
+                self.runtime_env.to_dict()
+                if hasattr(self.runtime_env, "to_dict")
+                else self.runtime_env
+            )
+            if runtime_env_dict and "working_dir" in runtime_env_dict:
+                working_dir = runtime_env_dict["working_dir"]
 
-        if not matches:
-            return  # No Python file found in entrypoint
+        # Skip all validation for remote working_dir
+        if working_dir and not os.path.isdir(working_dir):
+            return
 
-        entrypoint_path = matches[0]  # Get first Python file reference
+        # Case 1: Local working_dir - check redundancy and file existence
+        if working_dir:
+            normalized_working_dir = os.path.normpath(working_dir)
+            normalized_entrypoint = os.path.normpath(entrypoint_path)
 
-        # Normalize paths for comparison (remove ./, trailing /, etc.)
-        normalized_working_dir = os.path.normpath(working_dir)
-        normalized_entrypoint = os.path.normpath(entrypoint_path)
+            # Check for redundant directory reference
+            if normalized_entrypoint.startswith(normalized_working_dir + os.sep):
+                relative_to_working_dir = os.path.relpath(
+                    normalized_entrypoint, normalized_working_dir
+                )
+                working_dir_basename = os.path.basename(normalized_working_dir)
+                redundant_nested_path = os.path.join(
+                    normalized_working_dir,
+                    working_dir_basename,
+                    relative_to_working_dir,
+                )
 
-        # Check if entrypoint path starts with working_dir path
-        # This indicates potential redundant directory reference
-        if normalized_entrypoint.startswith(normalized_working_dir + os.sep):
-            # Extract the path that would be searched for (the redundant nested path)
-            relative_to_working_dir = os.path.relpath(
-                normalized_entrypoint, normalized_working_dir
-            )
-            # The redundant path would be: working_dir / basename(working_dir) / relative_path
-            working_dir_basename = os.path.basename(normalized_working_dir)
-            redundant_nested_path = os.path.join(
-                normalized_working_dir, working_dir_basename, relative_to_working_dir
-            )
+                if not os.path.exists(redundant_nested_path):
+                    raise ValueError(
+                        f"❌ Working directory conflict detected:\n"
+                        f"   working_dir: '{working_dir}'\n"
+                        f"   entrypoint references: '{entrypoint_path}'\n"
+                        f"\n"
+                        f"This will fail because the entrypoint runs from within working_dir.\n"
+                        f"It would look for: '{redundant_nested_path}' (which doesn't exist)\n"
+                        f"\n"
+                        f"Fix: Remove the directory prefix from your entrypoint:\n"
+                        f'   entrypoint = "python {relative_to_working_dir}"'
+                    )
 
-            # Check if the redundant nested path actually exists on disk
-            # If it doesn't exist, this is likely a user error
-            # If it does exist, it's a legitimate nested directory structure
-            if not os.path.exists(redundant_nested_path):
-                # This is a user error - block it with helpful message
+            # Check file exists within working_dir
+            if not normalized_entrypoint.startswith(normalized_working_dir + os.sep):
+                full_entrypoint_path = os.path.join(working_dir, entrypoint_path)
+                if not os.path.isfile(full_entrypoint_path):
+                    raise ValueError(
+                        f"❌ Entrypoint file not found:\n"
+                        f"   Looking for: '{full_entrypoint_path}'\n"
+                        f"   (working_dir: '{working_dir}', entrypoint file: '{entrypoint_path}')\n"
+                        f"\n"
+                        f"Please ensure the file exists at the expected location."
+                    )
+
+        # Case 2: No working_dir - validate local file exists
+        else:
+            if not os.path.isfile(entrypoint_path):
                 raise ValueError(
-                    f"❌ Working directory conflict detected:\n"
-                    f"   working_dir: '{working_dir}'\n"
-                    f"   entrypoint references: '{entrypoint_path}'\n"
-                    f"\n"
-                    f"This will fail because the entrypoint runs from within working_dir.\n"
-                    f"It would look for: '{redundant_nested_path}' (which doesn't exist)\n"
+                    f"❌ Entrypoint file not found: '{entrypoint_path}'\n"
                     f"\n"
-                    f"Fix: Remove the directory prefix from your entrypoint:\n"
-                    f'   entrypoint = "python {relative_to_working_dir}"'
+                    f"Please ensure the file exists at the specified path."
                 )
 
     def status(