simplify

Author: valentijnscholten

dojo/decorators.py

@@ -94,11 +94,12 @@ def __wrapper__(*args, **kwargs):
                 kwargs=kwargs,
             )
 
+            if signature:
+                return func.si(*args, **kwargs)
+
             countdown = kwargs.pop("countdown", 0)
             if we_want_async(*args, func=func, **kwargs):
                 # Return a signature for use in chord/group if requested
-                if signature:
-                    return func.si(*args, **kwargs)
                 # Execute the task
                 return func.apply_async(args=args, kwargs=kwargs, countdown=countdown)
             return func(*args, **kwargs)

dojo/importers/default_importer.py

@@ -15,6 +15,7 @@
     Test_Import,
 )
 from dojo.notifications.helper import create_notification
+from dojo.decorators import we_want_async
 from dojo.validators import clean_tags
 
 logger = logging.getLogger(__name__)
@@ -159,7 +160,7 @@ def process_findings(
         from dojo.finding import helper as finding_helper
         from dojo.models import Dojo_User
         from dojo.utils import calculate_grade, calculate_grade_signature
-        task_signatures = []
+        post_processing_task_signatures = []
 
         """
         Saves findings in memory that were parsed from the scan report into the database.
@@ -233,29 +234,17 @@ def process_findings(
 
             # Collect finding for parallel processing - we'll process them all at once after the loop
             push_to_jira = self.push_to_jira and (not self.findings_groups_enabled or not self.group_by)
-            # Process finding - either sync or async based on block_execution
-            if Dojo_User.wants_block_execution(self.user):
-                # This will run synchronously, but we still call the dojo_async decorated function to count the task
-                finding_helper.post_process_finding_save(
+            # Always create signatures - we'll execute them sync or async later
+            post_processing_task_signatures.append(
+                finding_helper.post_process_finding_save_signature(
                     finding,
                     dedupe_option=True,
                     rules_option=True,
                     product_grading_option=False,
                     issue_updater_option=True,
                     push_to_jira=push_to_jira,
-                )
-            else:
-                # Add to task signatures for async execution
-                task_signatures.append(
-                    finding_helper.post_process_finding_save_signature(
-                        finding,
-                        dedupe_option=True,
-                        rules_option=True,
-                        product_grading_option=False,
-                        issue_updater_option=True,
-                        push_to_jira=push_to_jira,
-                    ),
-                )
+                ),
+            )
 
         for (group_name, findings) in group_names_to_findings_dict.items():
             finding_helper.add_findings_to_auto_group(
@@ -273,19 +262,18 @@ def process_findings(
 
         # Calculate product grade after all findings are processed
         product = self.test.engagement.product
-        if task_signatures:
+        if post_processing_task_signatures:
             # If we have async tasks, use chord to wait for them before calculating grade
-            if Dojo_User.wants_block_execution(self.user):
-                # Run the chord synchronously by passing sync=True to each task
-                for task_sig in task_signatures:
-                    task_sig.apply_async(sync=True).get()
-                calculate_grade(product, sync=True)
+            if we_want_async(async_user=self.user):
+                # Run the chord asynchronously and after completing post processing tasks, calculate grade ONCE
+                chord(post_processing_task_signatures)(calculate_grade_signature(product))
             else:
-                # Run the chord asynchronously
-                chord(task_signatures)(calculate_grade_signature(product))
-        else:
-            # If everything was sync, calculate grade now as post processing is done
-            calculate_grade(product)
+                # Execute each task synchronously
+                for task_sig in post_processing_task_signatures:
+                    task_sig()
+
+        # Calculate grade, which can be prelimary calculated before the async tasks have finished
+        calculate_grade(product)
 
         sync = kwargs.get("sync", True)
         if not sync:

unittests/test_importers_performance.py

@@ -177,7 +177,7 @@ def import_reimport_performance(self, expected_num_queries1, expected_num_async_
     def test_import_reimport_reimport_performance_async(self):
         self.import_reimport_performance(
             expected_num_queries1=684,
-            expected_num_async_tasks1=11,
+            expected_num_async_tasks1=12,
             expected_num_queries2=610,
             expected_num_async_tasks2=22,
             expected_num_queries3=292,