Implement SGE job status checking support (issue #52)

- Added _check_sge_status method with comprehensive SGE state parsing
- Supports all SGE job states: r (running), qw (queued), Eqw (error), dr (deleting)
- Handles job completion detection via exit_status or job not found
- Added SGE cancellation support to cancel_job method using qdel
- Integrated SGE status checking into main _check_job_status method
- Added comprehensive test suite with 6 new SGE-specific tests:
  - test_check_sge_status_running
  - test_check_sge_status_queued
  - test_check_sge_status_failed
  - test_check_sge_status_completed
  - test_check_sge_status_exit_status
  - test_cancel_job_sge
- All 312 tests passing

This completes SGE support implementation, moving it from "⚡ Nearly Ready"
to "✅ Full Support" status with proper job monitoring and result collection.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jeremymanning

clustrix/executor.py

@@ -684,6 +684,21 @@ def _check_job_status(self, job_id: str) -> str:
                 else:
                     return "completed"
 
+        elif self.config.cluster_type == "sge":
+            sge_status = self._check_sge_status(job_id)
+            if sge_status == "completed":
+                # Job completed but not in queue, check if result exists
+                if job_id in self.active_jobs:
+                    job_info = self.active_jobs[job_id]
+                    result_exists = self._remote_file_exists(
+                        f"{job_info['remote_dir']}/result.pkl"
+                    )
+                    return "completed" if result_exists else "failed"
+                else:
+                    return "completed"
+            else:
+                return sge_status
+
         elif self.config.cluster_type == "ssh":
             # For SSH jobs, check if result file exists
             if job_id in self.active_jobs:
@@ -992,6 +1007,8 @@ def cancel_job(self, job_id: str):
             self._execute_remote_command(f"scancel {job_id}")
         elif self.config.cluster_type == "pbs":
             self._execute_remote_command(f"qdel {job_id}")
+        elif self.config.cluster_type == "sge":
+            self._execute_remote_command(f"qdel {job_id}")
 
         if job_id in self.active_jobs:
             del self.active_jobs[job_id]
@@ -1093,6 +1110,33 @@ def _check_pbs_status(self, job_id: str) -> str:
         except Exception:
             return "unknown"
 
+    def _check_sge_status(self, job_id: str) -> str:
+        """Check SGE job status."""
+        cmd = f"qstat -j {job_id}"
+        try:
+            stdout, stderr = self._execute_remote_command(cmd)
+            if not stdout.strip() or "Following jobs do not exist" in stderr:
+                # Job not in queue, likely completed
+                return "completed"
+            else:
+                # Parse SGE job state from qstat output
+                # Common SGE states: r (running), qw (queued), Eqw (error), dr (deleting)
+                if "job_state                          r" in stdout:
+                    return "running"
+                elif "job_state                          qw" in stdout:
+                    return "queued" 
+                elif "job_state                          Eqw" in stdout:
+                    return "failed"
+                elif "job_state                          dr" in stdout:
+                    return "completed"
+                # Check for exit status indicating completion
+                elif "exit_status" in stdout:
+                    return "completed"
+                else:
+                    return "running"  # Default for unknown running states
+        except Exception:
+            return "unknown"
+
     def _get_k8s_result(self, job_id: str) -> Any:
         """Get result from Kubernetes job logs."""
         try:

tests/test_executor.py

@@ -365,6 +365,91 @@ def test_check_pbs_status(self, executor):
 
         assert status == "running"
 
+    def test_check_sge_status_running(self, executor):
+        """Test SGE job status checking - running state."""
+        executor.ssh_client = Mock()
+
+        # Mock qstat -j output for running job
+        mock_stdout = Mock()
+        mock_stdout.read.return_value = b"job_state                          r"
+        mock_stderr = Mock()
+        mock_stderr.read.return_value = b""
+
+        executor.ssh_client.exec_command.return_value = (None, mock_stdout, mock_stderr)
+
+        status = executor._check_sge_status("12345")
+
+        assert status == "running"
+
+        # Verify qstat command
+        call_args = executor.ssh_client.exec_command.call_args[0][0]
+        assert "qstat -j" in call_args
+        assert "12345" in call_args
+
+    def test_check_sge_status_queued(self, executor):
+        """Test SGE job status checking - queued state."""
+        executor.ssh_client = Mock()
+
+        # Mock qstat -j output for queued job
+        mock_stdout = Mock()
+        mock_stdout.read.return_value = b"job_state                          qw"
+        mock_stderr = Mock()
+        mock_stderr.read.return_value = b""
+
+        executor.ssh_client.exec_command.return_value = (None, mock_stdout, mock_stderr)
+
+        status = executor._check_sge_status("12345")
+
+        assert status == "queued"
+
+    def test_check_sge_status_failed(self, executor):
+        """Test SGE job status checking - error state."""
+        executor.ssh_client = Mock()
+
+        # Mock qstat -j output for error job
+        mock_stdout = Mock()
+        mock_stdout.read.return_value = b"job_state                          Eqw"
+        mock_stderr = Mock()
+        mock_stderr.read.return_value = b""
+
+        executor.ssh_client.exec_command.return_value = (None, mock_stdout, mock_stderr)
+
+        status = executor._check_sge_status("12345")
+
+        assert status == "failed"
+
+    def test_check_sge_status_completed(self, executor):
+        """Test SGE job status checking - completed/not found."""
+        executor.ssh_client = Mock()
+
+        # Mock qstat -j output for job not found
+        mock_stdout = Mock()
+        mock_stdout.read.return_value = b""
+        mock_stderr = Mock()
+        mock_stderr.read.return_value = b"Following jobs do not exist: 12345"
+
+        executor.ssh_client.exec_command.return_value = (None, mock_stdout, mock_stderr)
+
+        status = executor._check_sge_status("12345")
+
+        assert status == "completed"
+
+    def test_check_sge_status_exit_status(self, executor):
+        """Test SGE job status checking - exit status indicates completion."""
+        executor.ssh_client = Mock()
+
+        # Mock qstat -j output with exit status
+        mock_stdout = Mock()
+        mock_stdout.read.return_value = b"exit_status                        0"
+        mock_stderr = Mock()
+        mock_stderr.read.return_value = b""
+
+        executor.ssh_client.exec_command.return_value = (None, mock_stdout, mock_stderr)
+
+        status = executor._check_sge_status("12345")
+
+        assert status == "completed"
+
     def test_get_job_status_completed(self, executor):
         """Test job status when result file exists."""
         executor.ssh_client = Mock()
@@ -485,6 +570,29 @@ def test_cancel_job_slurm(self, executor):
         call_args = executor.ssh_client.exec_command.call_args[0][0]
         assert "scancel 12345" in call_args
 
+    def test_cancel_job_sge(self, executor):
+        """Test canceling SGE job."""
+        executor.ssh_client = Mock()
+        executor.config.cluster_type = "sge"
+
+        mock_stdout = Mock()
+        mock_stdout.read.return_value = b""
+        mock_stdout.channel.recv_exit_status.return_value = 0
+
+        executor.ssh_client.exec_command.return_value = (None, mock_stdout, Mock())
+
+        # Add job to active jobs
+        executor.active_jobs["12345"] = {"remote_dir": "/tmp/test_job"}
+
+        executor.cancel_job("12345")
+
+        # Verify qdel command was called
+        call_args = executor.ssh_client.exec_command.call_args[0][0]
+        assert "qdel 12345" in call_args
+
+        # Verify job was removed from active jobs
+        assert "12345" not in executor.active_jobs
+
     def test_get_error_log(self, executor):
         """Test error log retrieval."""
         executor.active_jobs["failed_job"] = {"remote_dir": "/tmp/failed_job"}