Merge branch 'master' into swarming-service-remote-task

Author: jardondiego

src/appengine/handlers/fuzzers.py

@@ -34,6 +34,10 @@
 from libs import helpers
 
 ARCHIVE_READ_SIZE_LIMIT = 16 * 1024 * 1024
+FUZZER_FIELDS_EXCLUDED_FROM_LOG = [
+    'result', 'result_timestamp', 'console_output', 'return_code',
+    'sample_testcase', 'stats_columns', 'stats_column_descriptions'
+]
 
 
 class Handler(base_handler.Handler):
@@ -139,6 +143,10 @@ def _get_integer_value(self, key):
 
     return value
 
+  def _get_fuzzer_state_str(self, fuzzer: data_types.Fuzzer) -> str:
+    fuzzer_dict = fuzzer.to_dict(exclude=FUZZER_FIELDS_EXCLUDED_FROM_LOG)
+    return '\n'.join(f"{key}: {val}" for key, val in fuzzer_dict.items())
+
   def apply_fuzzer_changes(self, fuzzer, upload_info):
     """Apply changes to a fuzzer."""
     if upload_info and not archive.is_archive(upload_info.filename):
@@ -160,6 +168,8 @@ def apply_fuzzer_changes(self, fuzzer, upload_info):
             'uploaded is less than 16MB, ensure that the executable file has '
             '"run" in its name.', 400)
 
+    existing_fuzzer_info = self._get_fuzzer_state_str(fuzzer)
+
     jobs = request.get('jobs', [])
     timeout = self._get_integer_value('timeout')
     max_testcases = self._get_integer_value('max_testcases')
@@ -201,7 +211,14 @@ def apply_fuzzer_changes(self, fuzzer, upload_info):
 
     fuzzer_selection.update_mappings_for_fuzzer(fuzzer)
 
-    helpers.log('Uploaded fuzzer %s.' % fuzzer.name, helpers.MODIFY_OPERATION)
+    new_fuzzer_info = self._get_fuzzer_state_str(fuzzer)
+    fuzzer_diff = helpers.diff(existing_fuzzer_info, new_fuzzer_info)
+    fuzzer_update_message = (f"\n--- Updated fuzzer {fuzzer.name} ---\n"
+                             f"{new_fuzzer_info}\n"
+                             f"--- Changes (Diff) ---\n"
+                             f"{fuzzer_diff}")
+    helpers.log(fuzzer_update_message, helpers.MODIFY_OPERATION)
+
     return self.redirect('/fuzzers')
 
 

src/appengine/libs/helpers.py

@@ -14,6 +14,7 @@
 """helper.py is a kitchen sink. It contains static methods that are used by
    multiple handlers."""
 
+import difflib
 import logging
 import sys
 import traceback
@@ -165,3 +166,17 @@ def log(message, operation_type):
   """Logs operation being carried by current logged-in user."""
   logging.info('ClusterFuzz: %s (%s): %s.', operation_type, get_user_email(),
                message)
+
+
+def diff(old_str: str, new_str: str) -> str:
+  """Generates the diff between the two provided strings."""
+  old_lines = old_str.splitlines(keepends=True)
+  new_lines = new_str.splitlines(keepends=True)
+
+  diff_generator = difflib.ndiff(old_lines, new_lines)
+  clean_diff = [
+      line for line in diff_generator
+      if line.startswith('- ') or line.startswith('+ ')
+  ]
+
+  return "".join(clean_diff)

src/clusterfuzz/_internal/remote_task/remote_task_adapters.py

@@ -20,6 +20,7 @@
 from clusterfuzz._internal.k8s import service as k8s_service
 from clusterfuzz._internal.swarming.remote_task_service import RemoteTaskSwarmingService as SwarmingService
 
+
 class RemoteTaskAdapters(Enum):
   """Defines the supported remote task execution backends.
 
@@ -37,7 +38,8 @@ class RemoteTaskAdapters(Enum):
                 feature_flags.FeatureFlags.K8S_JOBS_FREQUENCY, 0.0)
   GCP_BATCH = ('gcp_batch', batch_service.GcpBatchService,
                feature_flags.FeatureFlags.GCP_BATCH_JOBS_FREQUENCY, 1.0)
-  SWARMING = ('swarming', SwarmingService, feature_flags.FeatureFlags.SWARMING_REMOTE_EXECUTION, 0.0)
+  SWARMING = ('swarming', SwarmingService,
+              feature_flags.FeatureFlags.SWARMING_REMOTE_EXECUTION, 0.0)
 
   def __init__(self, adapter_id, service, feature_flag, default_weight):
     self.id = adapter_id

src/clusterfuzz/_internal/swarming/__init__.py

@@ -25,6 +25,7 @@
 from clusterfuzz._internal.google_cloud_utils import credentials
 from clusterfuzz._internal.protos import swarming_pb2
 
+
 def is_swarming_task(command: str, job_name: str):
   """Returns True if the task is supposed to run on swarming."""
   if not FeatureFlags.SWARMING_REMOTE_EXECUTION.enabled:

src/clusterfuzz/_internal/swarming/remote_task_service.py

@@ -17,25 +17,37 @@
 import clusterfuzz._internal.swarming as swarming
 from clusterfuzz._internal.base.tasks import task_utils
 
+
 class RemoteTaskSwarmingService(remote_task_types.RemoteTaskInterface):
+
   def create_utask_main_job(self, module: str, job_type: str,
                             input_download_url: str):
     """Creates a single swarming task for a uworker main task."""
     command = task_utils.get_command_from_module(module)
-    if not swarming.is_swarming_task(command, job_type):
-      return
-    
-    swarming.push_swarming_task(command, input_download_url, job_type)
-  
-  def create_utask_main_jobs(
-      self, remote_tasks: list[remote_task_types.RemoteTask]) -> list[remote_task_types.RemoteTask]:
+    swarming_task = remote_task_types.RemoteTask(command, job_type,
+                                                 input_download_url)
+    result = self.create_utask_main_jobs([swarming_task])
+
+    if not result:
+      return None
+
+    return result[0]
+
+  def create_utask_main_jobs(self,
+                             remote_tasks: list[remote_task_types.RemoteTask]
+                            ) -> list[remote_task_types.RemoteTask]:
     """Creates many remote tasks for uworker main tasks.
        Returns the tasks that couldn't be created.
     """
     unscheduled_tasks = []
     for task in remote_tasks:
       try:
-        self.create_utask_main_job(task.command, task.job_type, task.input_download_url)
+        if not swarming.is_swarming_task(task.command, task.job_type):
+          unscheduled_tasks.append(task)
+          continue
+
+        swarming.push_swarming_task(task.command, task.input_download_url,
+                                    task.job_type)
       except Exception:  # pylint: disable=broad-except
         unscheduled_tasks.append(task)
-    return unscheduled_tasks
+    return unscheduled_tasks

src/clusterfuzz/_internal/tests/appengine/handlers/fuzzers_test.py

@@ -0,0 +1,58 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for fuzzers handler."""
+# pylint: disable=protected-access
+
+import datetime
+import unittest
+
+from clusterfuzz._internal.datastore import data_types
+from handlers import fuzzers
+
+
+class BaseEditHandlerTest(unittest.TestCase):
+  """Test BaseEditHandler."""
+
+  def setUp(self):
+    self.handler = fuzzers.BaseEditHandler()
+
+  def test_get_fuzzer_state_str(self):
+    """Test that fuzzer state str excludes specific fields."""
+    fuzzer = data_types.Fuzzer(
+        name='test_fuzzer',
+        revision=1,
+        timeout=10,
+        result='bad',
+        console_output='some output',
+        result_timestamp=datetime.datetime(2021, 1, 1),
+        return_code=1,
+        sample_testcase='testcase',
+        stats_columns='cols',
+        stats_column_descriptions='desc',
+    )
+
+    state_str = self.handler._get_fuzzer_state_str(fuzzer)
+
+    self.assertIn('name: test_fuzzer', state_str)
+    self.assertIn('revision: 1', state_str)
+    self.assertIn('timeout: 10', state_str)
+
+    # Explicitly excluded fields
+    self.assertNotIn('result:', state_str)
+    self.assertNotIn('result_timestamp', state_str)
+    self.assertNotIn('console_output:', state_str)
+    self.assertNotIn('return_code:', state_str)
+    self.assertNotIn('sample_testcase:', state_str)
+    self.assertNotIn('stats_columns:', state_str)
+    self.assertNotIn('stats_column_descriptions:', state_str)

src/clusterfuzz/_internal/tests/appengine/libs/helpers_test.py

@@ -159,3 +159,27 @@ def test_view(self):
     helpers.log('message', helpers.VIEW_OPERATION)
     self.mock.info.assert_called_once_with(
         'ClusterFuzz: %s (%s): %s.', helpers.VIEW_OPERATION, 'email', 'message')
+
+
+class DiffTest(unittest.TestCase):
+  """Test diff."""
+
+  def test_diff_empty(self):
+    """Test diff with empty strings."""
+    self.assertEqual(helpers.diff('', ''), '')
+
+  def test_diff_no_change(self):
+    """Test diff with no changes."""
+    self.assertEqual(helpers.diff('a\nb\n', 'a\nb\n'), '')
+
+  def test_diff_addition(self):
+    """Test diff with addition."""
+    self.assertEqual(helpers.diff('a\nb\n', 'a\nb\nc\n'), '+ c\n')
+
+  def test_diff_deletion(self):
+    """Test diff with deletion."""
+    self.assertEqual(helpers.diff('a\nb\nc\n', 'a\nc\n'), '- b\n')
+
+  def test_diff_modification(self):
+    """Test diff with modification."""
+    self.assertEqual(helpers.diff('a\nb\nc\n', 'a\nd\nc\n'), '- b\n+ d\n')

src/clusterfuzz/_internal/tests/core/swarming/remote_task_service_test.py

@@ -0,0 +1,128 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Tests for RemoteTaskSwarmingService."""
+
+import unittest
+from unittest import mock
+
+from clusterfuzz._internal.remote_task import remote_task_types
+from clusterfuzz._internal.swarming import remote_task_service
+from clusterfuzz._internal.tests.test_libs import helpers
+
+
+class RemoteTaskSwarmingServiceTest(unittest.TestCase):
+  """Tests for RemoteTaskSwarmingService."""
+
+  def setUp(self):
+    helpers.patch(self, [
+        'clusterfuzz._internal.swarming.is_swarming_task',
+        'clusterfuzz._internal.swarming.push_swarming_task',
+        'clusterfuzz._internal.base.tasks.task_utils.get_command_from_module',
+    ])
+    self.service = remote_task_service.RemoteTaskSwarmingService()
+
+  def test_create_utask_main_job_success(self):
+    """Test creating a single task successfully."""
+    self.mock.get_command_from_module.return_value = 'fuzz'
+    self.mock.is_swarming_task.return_value = True
+
+    result = self.service.create_utask_main_job('fuzz_task', 'job_type',
+                                                'http://url')
+
+    # Success returns None in this interface (consistent with GcpBatchService)
+    self.assertIsNone(result)
+
+    self.mock.push_swarming_task.assert_called_once_with(
+        'fuzz', 'http://url', 'job_type')
+
+  def test_create_utask_main_job_failure(self):
+    """Test creating a single task that is not a swarming task."""
+    self.mock.get_command_from_module.return_value = 'fuzz'
+    self.mock.is_swarming_task.return_value = False
+
+    result = self.service.create_utask_main_job('fuzz_task', 'job_type',
+                                                'http://url')
+
+    # Failure returns the task itself
+    self.assertIsInstance(result, remote_task_types.RemoteTask)
+    self.assertEqual(result.command, 'fuzz')
+    self.mock.push_swarming_task.assert_not_called()
+
+  def test_create_utask_main_jobs_mixed_results(self):
+    """Test creating multiple tasks with mixed success/failure."""
+    tasks = [
+        remote_task_types.RemoteTask('fuzz', 'job1', 'url1'),
+        remote_task_types.RemoteTask('fuzz', 'job2', 'url2'),
+        remote_task_types.RemoteTask('fuzz', 'job3', 'url3'),
+    ]
+
+    # job1 succeeds, job2 fails (not a swarming task), job3 succeeds
+    self.mock.is_swarming_task.side_effect = [True, False, True]
+
+    unscheduled = self.service.create_utask_main_jobs(tasks)
+
+    self.assertEqual(len(unscheduled), 1)
+    self.assertEqual(unscheduled[0].job_type, 'job2')
+
+    self.assertEqual(self.mock.push_swarming_task.call_count, 2)
+    self.mock.push_swarming_task.assert_has_calls([
+        mock.call('fuzz', 'url1', 'job1'),
+        mock.call('fuzz', 'url3', 'job3'),
+    ])
+
+  def test_create_utask_main_jobs_all_success(self):
+    """Test creating multiple tasks where all succeed."""
+    tasks = [
+        remote_task_types.RemoteTask('fuzz', 'job1', 'url1'),
+        remote_task_types.RemoteTask('fuzz', 'job2', 'url2'),
+    ]
+    self.mock.is_swarming_task.return_value = True
+
+    unscheduled = self.service.create_utask_main_jobs(tasks)
+
+    self.assertEqual(unscheduled, [])
+    self.assertEqual(self.mock.push_swarming_task.call_count, 2)
+
+  def test_create_utask_main_jobs_all_fail(self):
+    """Test creating multiple tasks where all fail."""
+    tasks = [
+        remote_task_types.RemoteTask('fuzz', 'job1', 'url1'),
+        remote_task_types.RemoteTask('fuzz', 'job2', 'url2'),
+    ]
+    self.mock.is_swarming_task.return_value = False
+
+    unscheduled = self.service.create_utask_main_jobs(tasks)
+
+    self.assertEqual(unscheduled, tasks)
+    self.mock.push_swarming_task.assert_not_called()
+
+  def test_create_utask_main_jobs_empty(self):
+    """Test creating tasks with an empty list."""
+    unscheduled = self.service.create_utask_main_jobs([])
+    self.assertEqual(unscheduled, [])
+    self.mock.push_swarming_task.assert_not_called()
+
+  def test_create_utask_main_jobs_exception(self):
+    """Test creating tasks when push_swarming_task raises an exception."""
+    tasks = [
+        remote_task_types.RemoteTask('fuzz', 'job1', 'url1'),
+    ]
+
+    self.mock.is_swarming_task.return_value = True
+    self.mock.push_swarming_task.side_effect = Exception('error')
+
+    unscheduled = self.service.create_utask_main_jobs(tasks)
+
+    self.assertEqual(len(unscheduled), 1)
+    self.assertEqual(unscheduled[0].job_type, 'job1')