Rename get_cpu_arch to get_target_cpu_arch

src/clusterfuzz/_internal/bot/tasks/commands.py

@@ -102,7 +102,7 @@ def cleanup_task_state():
 
 def is_supported_cpu_arch_for_job():
   """Return true if the current cpu architecture can run this job."""
-  cpu_arch = environment.get_cpu_arch()
+  cpu_arch = environment.get_target_cpu_arch()
   if not cpu_arch:
     # No cpu architecture check is defined for this platform, bail out.
     return True

src/clusterfuzz/_internal/platforms/android/settings.py

@@ -72,8 +72,10 @@ def get_build_version():
   return match.group(1)
 
 
-def get_cpu_arch():
-  """Return cpu architecture."""
+def get_target_cpu_arch():
+  """Return target cpu architecture,
+  i.e. the cpu architecture where the fuzzer will run.
+  """
   return adb.get_property('ro.product.cpu.abi')
 
 

src/clusterfuzz/_internal/system/environment.py

@@ -221,13 +221,18 @@ def get_asan_options(redzone_size, malloc_context_size, quarantine_size_mb,
   return asan_options
 
 
-def get_cpu_arch():
+def get_target_cpu_arch():
   """Return cpu architecture."""
   if is_android():
     # FIXME: Handle this import in a cleaner way.
     from clusterfuzz._internal.platforms import android
-    return android.settings.get_cpu_arch()
+    return android.settings.get_target_cpu_arch()
 
+  return get_host_cpu_arch()
+
+
+def get_host_cpu_arch():
+  """Returns cpu architecture of the current host."""
   machine = platform_util.machine().lower()
   if machine in ('arm64', 'aarch64'):
     return 'arm64'

src/clusterfuzz/_internal/tests/core/bot/tasks/commands_test.py

@@ -303,41 +303,41 @@ class IsSupportedCpuArchForJobTest(unittest.TestCase):
   def setUp(self):
     helpers.patch_environ(self)
     helpers.patch(self, [
-        'clusterfuzz._internal.system.environment.get_cpu_arch',
+        'clusterfuzz._internal.system.environment.get_target_cpu_arch',
     ])
 
   def test_no_bot_cpu_arch(self):
     """Test when no cpu arch is defined on bot."""
-    self.mock.get_cpu_arch.return_value = None
+    self.mock.get_target_cpu_arch.return_value = None
     environment.set_value('CPU_ARCH', 'arm64')
     self.assertTrue(commands.is_supported_cpu_arch_for_job())
 
   def test_no_job_cpu_arch_requirement(self):
     """Test when job specifies no CPU_ARCH requirement."""
-    self.mock.get_cpu_arch.return_value = 'arm64'
+    self.mock.get_target_cpu_arch.return_value = 'arm64'
     environment.set_value('CPU_ARCH', None)
     self.assertTrue(commands.is_supported_cpu_arch_for_job())
 
   def test_matching_single_string(self):
     """Test when job specifies matching single string CPU_ARCH."""
-    self.mock.get_cpu_arch.return_value = 'arm64'
+    self.mock.get_target_cpu_arch.return_value = 'arm64'
     environment.set_value('CPU_ARCH', 'arm64')
     self.assertTrue(commands.is_supported_cpu_arch_for_job())
 
   def test_non_matching_single_string(self):
     """Test when job specifies non-matching single string CPU_ARCH."""
-    self.mock.get_cpu_arch.return_value = 'arm64'
+    self.mock.get_target_cpu_arch.return_value = 'arm64'
     environment.set_value('CPU_ARCH', 'x86_64')
     self.assertFalse(commands.is_supported_cpu_arch_for_job())
 
   def test_matching_comma_separated_string(self):
     """Test when job specifies comma-separated CPU_ARCH."""
-    self.mock.get_cpu_arch.return_value = 'arm64'
+    self.mock.get_target_cpu_arch.return_value = 'arm64'
     environment.set_value('CPU_ARCH', 'x86_64, arm64')
     self.assertTrue(commands.is_supported_cpu_arch_for_job())
 
   def test_matching_list(self):
     """Test when job specifies a list of supported architectures."""
-    self.mock.get_cpu_arch.return_value = 'arm64'
+    self.mock.get_target_cpu_arch.return_value = 'arm64'
     environment.set_value('CPU_ARCH', ['x86_64', 'arm64'])
     self.assertTrue(commands.is_supported_cpu_arch_for_job())

src/clusterfuzz/_internal/tests/core/system/environment_test.py

@@ -481,42 +481,42 @@ def test_function():
 
 
 class GetCpuArchTest(unittest.TestCase):
-  """Tests for get_cpu_arch."""
+  """Tests for get_target_cpu_arch."""
 
   def setUp(self):
     test_helpers.patch_environ(self)
     test_helpers.patch(self, [
         'clusterfuzz._internal.system.environment.is_android',
         'platform.machine',
-        'clusterfuzz._internal.platforms.android.settings.get_cpu_arch',
+        'clusterfuzz._internal.platforms.android.settings.get_target_cpu_arch',
     ])
     self.mock.is_android.return_value = False
 
   def test_android(self):
     """Test Android architecture delegation."""
     self.mock.is_android.return_value = True
-    self.mock.get_cpu_arch.return_value = 'arm64_v8a'
-    self.assertEqual('arm64_v8a', environment.get_cpu_arch())
+    self.mock.get_target_cpu_arch.return_value = 'arm64_v8a'
+    self.assertEqual('arm64_v8a', environment.get_target_cpu_arch())
 
   def test_arm64(self):
     """Test ARM64 architecture detection."""
     self.mock.machine.return_value = 'arm64'
-    self.assertEqual('arm64', environment.get_cpu_arch())
+    self.assertEqual('arm64', environment.get_target_cpu_arch())
 
   def test_aarch64(self):
     """Test aarch64 normalized to arm64."""
     self.mock.machine.return_value = 'aarch64'
-    self.assertEqual('arm64', environment.get_cpu_arch())
+    self.assertEqual('arm64', environment.get_target_cpu_arch())
 
   def test_x86_64(self):
     """Test x86_64 architecture detection."""
     self.mock.machine.return_value = 'x86_64'
-    self.assertEqual('x86_64', environment.get_cpu_arch())
+    self.assertEqual('x86_64', environment.get_target_cpu_arch())
 
   def test_amd64(self):
     """Test amd64 normalized to x86_64."""
     self.mock.machine.return_value = 'AMD64'
-    self.assertEqual('x86_64', environment.get_cpu_arch())
+    self.assertEqual('x86_64', environment.get_target_cpu_arch())
 
 
 class GetDefaultToolPathTest(unittest.TestCase):