fix: trigger error and termination from resource validation failure

Signed-off-by: tkqdldk <samia.20.bouchaal@gmail.com>

Author: tkqdldk

oss_crs/src/crs_compose.py

@@ -5,7 +5,7 @@
 import os
 import hashlib
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Optional
 from .config.crs_compose import CRSComposeConfig, CRSComposeEnv, RunEnv
 from .env_policy import OSS_FUZZ_TARGET_ENV, build_target_builder_env
 from .llm import LLM
@@ -22,6 +22,7 @@
     rm_with_docker,
     get_host_memory,
     log_success,
+    log_error,
     log_warning,
     log_dim,
 )
@@ -650,6 +651,9 @@ def build_target(
         if target_base_image is None:
             return False
 
+        if not self._validate_machine_resources():
+            return False
+
         # Resolve target source path: user-provided repo or extracted WORKDIR
         if target._has_repo:
             resolved_source_path = target.repo_path.resolve()
@@ -661,12 +665,7 @@ def build_target(
                 return False
             resolved_source_path = source_dir
 
-        tasks: list[tuple[str, Callable[[MultiTaskProgress], TaskResult]]] = [
-            (
-                "Validate machine resources",
-                lambda _: self._validate_machine_resources(),
-            ),
-        ]
+        tasks = []
 
         if bug_candidate is not None and bug_candidate_dir is not None:
             print(
@@ -931,7 +930,7 @@ def _validate_required_inputs(
             return TaskResult(success=False, error="\n".join(errors))
         return TaskResult(success=True)
 
-    def _validate_machine_resources(self) -> TaskResult:
+    def _validate_machine_resources(self) -> bool:
         """Validate that machine resources and resource config do not conflict."""
         # Get machine CPU count and memory (in Bytes)
         machine_cpu_count = os.cpu_count()
@@ -941,7 +940,7 @@ def _validate_machine_resources(self) -> TaskResult:
             log_warning(
                 "Could not determine machine resources. Skipping resource check."
             )
-            return TaskResult(success=True)
+            return True
 
         # Collect entries for shared infra and all crs
         entries = [("oss_crs_infra", self.config.oss_crs_infra)]
@@ -969,12 +968,13 @@ def _validate_machine_resources(self) -> TaskResult:
         memory_check = total_memory_required <= machine_memory
 
         if not cpu_check or not memory_check:
-            log_warning(
+            log_error(
                 f"Machine does not have adequate resources. "
                 f"Only {machine_cpu_count} CPUs and {machine_memory // (1024**3)}G memory available. "
                 f"Please edit the compose file. "
             )
-        return TaskResult(success=True)
+            return False
+        return True
 
     def __validate_before_run(
         self,
@@ -999,10 +999,6 @@ def __validate_before_run(
                     bug_candidate_dir=bug_candidate_dir,
                 ),
             ),
-            (
-                "Validate machine resources",
-                lambda _: self._validate_machine_resources(),
-            ),
         ]
 
         if self.llm.exists():

oss_crs/tests/unit/test_validate_machine_resources.py

@@ -43,72 +43,84 @@ def _make_compose(
 def patched_resources(monkeypatch):
     """Patch machine resource detection with standard mock values.
 
-    Returns a list that captures all log_warning calls.
+    Returns a tuple of (warnings, errors) lists.
     """
     warnings = []
+    errors = []
     monkeypatch.setattr("oss_crs.src.crs_compose.os.cpu_count", lambda: MOCK_CPU_COUNT)
     monkeypatch.setattr("oss_crs.src.crs_compose.get_host_memory", lambda: MOCK_MEMORY)
     monkeypatch.setattr(
         "oss_crs.src.crs_compose.log_warning", lambda msg: warnings.append(msg)
     )
-    return warnings
+    monkeypatch.setattr(
+        "oss_crs.src.crs_compose.log_error", lambda msg: errors.append(msg)
+    )
+    return warnings, errors
 
 
 ## CPU and memory checks
 
 
 def test_cpu_within_bounds_no_warning(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose(f"0-{MOCK_CPU_COUNT - 2}")
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 0
+    assert compose._validate_machine_resources() is True
+    assert len(errors) == 0
 
 
 def test_cpu_at_max_valid_id_no_warning(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose(f"0-{MOCK_CPU_COUNT - 1}")
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 0
+    assert compose._validate_machine_resources() is True
+    assert len(errors) == 0
 
 
-def test_cpu_equals_machine_count_warns(patched_resources):
+def test_cpu_equals_machine_count_errors(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose(f"0-{MOCK_CPU_COUNT}")
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 1
-    assert "does not have adequate resources" in patched_resources[0]
+    assert compose._validate_machine_resources() is False
+    assert len(errors) == 1
+    assert "does not have adequate resources" in errors[0]
 
 
-def test_cpu_exceeds_machine_count_warns(patched_resources):
+def test_cpu_exceeds_machine_count_errors(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose(f"0-{MOCK_CPU_COUNT + 1}")
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 1
-    assert "does not have adequate resources" in patched_resources[0]
+    assert compose._validate_machine_resources() is False
+    assert len(errors) == 1
+    assert "does not have adequate resources" in errors[0]
 
 
 def test_memory_at_exact_limit_no_warning(patched_resources):
+    warnings, errors = patched_resources
     exact_memory = f"{MOCK_MEMORY // (1024**3)}G"
     compose = _make_compose("0-3", exact_memory)
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 0
+    assert compose._validate_machine_resources() is True
+    assert len(errors) == 0
 
 
-def test_memory_over_limit_warns(patched_resources):
+def test_memory_over_limit_errors(patched_resources):
+    warnings, errors = patched_resources
     over_memory = f"{(MOCK_MEMORY // (1024**3)) + 1}G"
     compose = _make_compose("0-3", over_memory)
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 1
-    assert "does not have adequate resources" in patched_resources[0]
+    assert compose._validate_machine_resources() is False
+    assert len(errors) == 1
+    assert "does not have adequate resources" in errors[0]
 
 
-def test_crs_entry_exceeds_cpu_count_warns(patched_resources):
+def test_crs_entry_exceeds_cpu_count_errors(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose(
         "0-3",
         crs_entries={"crs-a": _FakeResource(f"0-{MOCK_CPU_COUNT}", "4G")},
     )
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 1
-    assert "does not have adequate resources" in patched_resources[0]
+    assert compose._validate_machine_resources() is False
+    assert len(errors) == 1
+    assert "does not have adequate resources" in errors[0]
 
 
-def test_combined_memory_across_entries_warns(patched_resources):
+def test_combined_memory_across_entries_errors(patched_resources):
+    warnings, errors = patched_resources
     half_memory = f"{MOCK_MEMORY // (1024**3) // 2 + 1}G"
     compose = _make_compose(
         "0-3",
@@ -117,58 +129,71 @@ def test_combined_memory_across_entries_warns(patched_resources):
             "crs-a": _FakeResource("0-3", half_memory),
         },
     )
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 1
-    assert "does not have adequate resources" in patched_resources[0]
+    assert compose._validate_machine_resources() is False
+    assert len(errors) == 1
+    assert "does not have adequate resources" in errors[0]
 
 
 def test_both_adequate_no_warning(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose("0-3", "4G")
-    compose._validate_machine_resources()
-    assert len(patched_resources) == 0
+    assert compose._validate_machine_resources() is True
+    assert len(errors) == 0
 
 
 ## undetectable machine resources checks
 
 
 def test_undetectable_cpu_skips_check(monkeypatch):
     warnings = []
+    errors = []
     monkeypatch.setattr("oss_crs.src.crs_compose.os.cpu_count", lambda: None)
     monkeypatch.setattr("oss_crs.src.crs_compose.get_host_memory", lambda: MOCK_MEMORY)
     monkeypatch.setattr(
         "oss_crs.src.crs_compose.log_warning", lambda msg: warnings.append(msg)
     )
+    monkeypatch.setattr(
+        "oss_crs.src.crs_compose.log_error", lambda msg: errors.append(msg)
+    )
 
     compose = _make_compose("0-3")
-    compose._validate_machine_resources()
+    assert compose._validate_machine_resources() is True
     assert len(warnings) == 1
     assert "Could not determine machine resources" in warnings[0]
+    assert len(errors) == 0
 
 
 def test_undetectable_memory_skips_check(monkeypatch):
     warnings = []
+    errors = []
     monkeypatch.setattr("oss_crs.src.crs_compose.os.cpu_count", lambda: MOCK_CPU_COUNT)
     monkeypatch.setattr("oss_crs.src.crs_compose.get_host_memory", lambda: None)
     monkeypatch.setattr(
         "oss_crs.src.crs_compose.log_warning", lambda msg: warnings.append(msg)
     )
+    monkeypatch.setattr(
+        "oss_crs.src.crs_compose.log_error", lambda msg: errors.append(msg)
+    )
 
     compose = _make_compose("0-3")
-    compose._validate_machine_resources()
+    assert compose._validate_machine_resources() is True
     assert len(warnings) == 1
     assert "Could not determine machine resources" in warnings[0]
+    assert len(errors) == 0
 
 
 # parsing error checks
 
 
 def test_invalid_cpuset_warns(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose("not-a-cpuset", "4G")
     compose._validate_machine_resources()
-    assert any("Failed to validate cpuset" in w for w in patched_resources)
+    assert any("Failed to validate cpuset" in w for w in warnings)
 
 
 def test_invalid_memory_string_warns(patched_resources):
+    warnings, errors = patched_resources
     compose = _make_compose("0-3", "notmemory")
     compose._validate_machine_resources()
-    assert any("Failed to parse memory" in w for w in patched_resources)
+    assert any("Failed to parse memory" in w for w in warnings)