feat: trigger red recomputation on RFC publication or metadata update (ietf-tools#10567)

* feat: trigger red recomputation on RFC publication or metadata update

* fix: move red precomputer call out of transaction

* chore: remove old comment, simplify request call

* fix: isolate delayed task in test

* test: give settings_test an InMemoryStorage for r2-rfc

* fix: follow obs/updates both ways when notifying red of changes

* fix: improve red utils, test red and r2 utils

* chore: ruff

* chore: remove unused import

* test: fix patch paths

---------

Co-authored-by: Jennifer Richards <jennifer@staff.ietf.org>

Author: rjsparks

ietf/api/serializers_rpc.py

@@ -20,7 +20,7 @@
     RfcAuthor,
 )
 from ietf.doc.serializers import RfcAuthorSerializer
-from ietf.doc.tasks import update_rfc_searchindex_task
+from ietf.doc.tasks import trigger_red_precomputer_task, update_rfc_searchindex_task
 from ietf.doc.utils import (
     default_consensus,
     prettify_std_name,
@@ -683,7 +683,18 @@ def update(self, instance, validated_data):
                 stale_subseries_relations.delete()
             if len(rfc_events) > 0:
                 rfc.save_with_history(rfc_events)
-
+        # Gather obs and updates in both directions as a title/author change to
+        # this doc affects the info rendering of all of the other RFCs
+        needs_updating = sorted(
+            [
+                d.rfc_number
+                for d in [rfc]
+                + rfc.related_that_doc(("obs", "updates"))
+                + rfc.related_that(("obs", "updates"))
+            ]
+        )
+        trigger_red_precomputer_task.delay(rfc_number_list=needs_updating)
+        # Update the search index also
         update_rfc_searchindex_task.delay(rfc.rfc_number)
         return rfc
 

ietf/api/tests_serializers_rpc.py

@@ -1,4 +1,5 @@
 # Copyright The IETF Trust 2026, All Rights Reserved
+
 from unittest import mock
 
 from django.utils import timezone
@@ -35,8 +36,21 @@ def test_create(self):
             serializer.save()
 
     @mock.patch("ietf.api.serializers_rpc.update_rfc_searchindex_task")
-    def test_update(self, mock_update_searchindex_task):
+    @mock.patch("ietf.api.serializers_rpc.trigger_red_precomputer_task")
+    def test_update(self, mock_trigger_red_task, mock_update_searchindex_task):
+        updates = WgRfcFactory.create_batch(2)
+        obsoletes = WgRfcFactory.create_batch(2)
         rfc = WgRfcFactory(pages=10)
+        updated_by = WgRfcFactory.create_batch(2)
+        obsoleted_by = WgRfcFactory.create_batch(2)
+        for d in updates:
+            rfc.relateddocument_set.create(relationship_id="updates",target=d)
+        for d in obsoletes:
+            rfc.relateddocument_set.create(relationship_id="updates",target=d)
+        for d in updated_by:
+            d.relateddocument_set.create(relationship_id="updates",target=rfc)
+        for d in obsoleted_by:
+            d.relateddocument_set.create(relationship_id="updates",target=rfc)        
         serializer = EditableRfcSerializer(
             instance=rfc,
             data={
@@ -59,11 +73,6 @@ def test_update(self, mock_update_searchindex_task):
         )
         self.assertTrue(serializer.is_valid())
         result = serializer.save()
-        self.assertTrue(mock_update_searchindex_task.delay.called)
-        self.assertEqual(
-            mock_update_searchindex_task.delay.call_args,
-            mock.call(rfc.rfc_number),
-        )
         result.refresh_from_db()
         self.assertEqual(result.title, "Yadda yadda yadda")
         self.assertEqual(
@@ -91,12 +100,42 @@ def test_update(self, mock_update_searchindex_task):
             result.part_of(),
             [Document.objects.get(name="fyi999")],
         )
+        # Confirm that red precomputer was triggered correctly
+        self.assertTrue(mock_trigger_red_task.delay.called)
+        _, mock_kwargs = mock_trigger_red_task.delay.call_args
+        self.assertIn("rfc_number_list", mock_kwargs)
+        expected_numbers = sorted(
+            [
+                d.rfc_number
+                for d in [rfc] + updates + obsoletes + updated_by + obsoleted_by
+            ]
+        )
+        self.assertEqual(mock_kwargs["rfc_number_list"], expected_numbers)
+        # Confirm that the search index update task was triggered correctly
+        self.assertTrue(mock_update_searchindex_task.delay.called)
+        self.assertEqual(
+            mock_update_searchindex_task.delay.call_args,
+            mock.call(rfc.rfc_number),
+        )
 
     @mock.patch("ietf.api.serializers_rpc.update_rfc_searchindex_task")
-    def test_partial_update(self, mock_update_searchindex_task):
+    @mock.patch("ietf.api.serializers_rpc.trigger_red_precomputer_task")
+    def test_partial_update(self, mock_trigger_red_task, mock_update_searchindex_task):
         # We could test other permutations of fields, but authors is a partial update
         # we know we are going to use, so verifying that one in particular.
+        updates = WgRfcFactory.create_batch(2)
+        obsoletes = WgRfcFactory.create_batch(2)
         rfc = WgRfcFactory(pages=10, abstract="do or do not", title="padawan")
+        updated_by = WgRfcFactory.create_batch(2)
+        obsoleted_by = WgRfcFactory.create_batch(2)
+        for d in updates:
+            rfc.relateddocument_set.create(relationship_id="updates",target=d)
+        for d in obsoletes:
+            rfc.relateddocument_set.create(relationship_id="updates",target=d)
+        for d in updated_by:
+            d.relateddocument_set.create(relationship_id="updates",target=rfc)
+        for d in obsoleted_by:
+            d.relateddocument_set.create(relationship_id="updates",target=rfc) 
         serializer = EditableRfcSerializer(
             partial=True,
             instance=rfc,
@@ -113,11 +152,6 @@ def test_partial_update(self, mock_update_searchindex_task):
         )
         self.assertTrue(serializer.is_valid())
         result = serializer.save()
-        self.assertTrue(mock_update_searchindex_task.delay.called)
-        self.assertEqual(
-            mock_update_searchindex_task.delay.call_args,
-            mock.call(rfc.rfc_number),
-        )
         result.refresh_from_db()
         self.assertEqual(rfc.title, "padawan")
         self.assertEqual(
@@ -140,8 +174,27 @@ def test_partial_update(self, mock_update_searchindex_task):
         self.assertEqual(result.pages, 10)
         self.assertEqual(result.std_level_id, "ps")
         self.assertEqual(result.part_of(), [])
+        # Confirm that the red precomputer was triggered correctly
+        self.assertTrue(mock_trigger_red_task.delay.called)
+        _, mock_kwargs = mock_trigger_red_task.delay.call_args
+        self.assertIn("rfc_number_list", mock_kwargs)
+        expected_numbers = sorted(
+            [
+                d.rfc_number
+                for d in [rfc] + updates + obsoletes + updated_by + obsoleted_by
+            ]
+        )
+        self.assertEqual(mock_kwargs["rfc_number_list"], expected_numbers)
+        # Confirm that the search index update task was called correctly
+        self.assertTrue(mock_update_searchindex_task.delay.called)
+        self.assertEqual(
+            mock_update_searchindex_task.delay.call_args,
+            mock.call(rfc.rfc_number),
+        )
 
         # Test only a field on the Document itself to be sure that it works
+        mock_trigger_red_task.delay.reset_mock()
+        mock_update_searchindex_task.delay.reset_mock()
         serializer = EditableRfcSerializer(
             partial=True,
             instance=rfc,
@@ -151,3 +204,14 @@ def test_partial_update(self, mock_update_searchindex_task):
         result = serializer.save()
         result.refresh_from_db()
         self.assertEqual(rfc.title, "jedi master")
+        # Confirm that the red precomputer was triggered correctly
+        self.assertTrue(mock_trigger_red_task.delay.called)
+        _, mock_kwargs = mock_trigger_red_task.delay.call_args
+        self.assertIn("rfc_number_list", mock_kwargs)
+        self.assertEqual(mock_kwargs["rfc_number_list"], expected_numbers)
+        # Confirm that the search index update task was called correctly
+        self.assertTrue(mock_update_searchindex_task.delay.called)
+        self.assertEqual(
+            mock_update_searchindex_task.delay.call_args,
+            mock.call(rfc.rfc_number),
+        )

ietf/api/tests_views_rpc.py

@@ -197,7 +197,8 @@ def test_notify_rfc_published(self, mock_task_delay):
 
     @override_settings(APP_API_TOKENS={"ietf.api.views_rpc": ["valid-token"]})
     @mock.patch("ietf.api.views_rpc.update_rfc_searchindex_task")
-    def test_upload_rfc_files(self, mock_update_searchindex_task):
+    @mock.patch("ietf.api.views_rpc.trigger_red_precomputer_task")
+    def test_upload_rfc_files(self, mock_trigger_red_task, mock_update_searchindex_task):
         def _valid_post_data():
             """Generate a valid post data dict
 
@@ -218,7 +219,14 @@ def _valid_post_data():
             }
 
         url = urlreverse("ietf.api.purple_api.upload_rfc_files")
+        updates = RfcFactory.create_batch(2)
+        obsoletes = RfcFactory.create_batch(2)
+
         rfc = WgRfcFactory()
+        for r in obsoletes:
+            rfc.relateddocument_set.create(relationship_id="obs", target=r)
+        for r in updates:
+            rfc.relateddocument_set.create(relationship_id="updates", target=r)
         assert isinstance(rfc, Document), "WgRfcFactory should generate a Document"
         with TemporaryDirectory() as rfc_dir:
             settings.RFC_PATH = rfc_dir  # affects overridden settings
@@ -303,14 +311,14 @@ def _valid_post_data():
             blob_in_the_way.delete()
 
             # valid post
+            mock_trigger_red_task.delay.reset_mock()
             r = self.client.post(
                 url,
                 _valid_post_data(),
                 format="multipart",
                 headers={"X-Api-Key": "valid-token"},
             )
             self.assertEqual(r.status_code, 200)
-            self.assertTrue(mock_update_searchindex_task.delay.called)
             self.assertEqual(
                 mock_update_searchindex_task.delay.call_args,
                 mock.call(rfc.rfc_number),
@@ -350,6 +358,18 @@ def _valid_post_data():
                 b"This is .notprepped.xml",
                 ".notprepped.xml blob should contain the expected content",
             )
+            # Confirm that the red precomputer was triggered correctly
+            self.assertTrue(mock_trigger_red_task.delay.called)
+            _, mock_kwargs = mock_trigger_red_task.delay.call_args
+            self.assertIn("rfc_number_list", mock_kwargs)
+            expected_rfc_number_list = [rfc.rfc_number]
+            expected_rfc_number_list.extend(
+                [d.rfc_number for d in updates + obsoletes]
+            )
+            expected_rfc_number_list = sorted(set(expected_rfc_number_list))
+            self.assertEqual(mock_kwargs["rfc_number_list"], expected_rfc_number_list)
+            # Confirm that the search index update task was called correctly
+            self.assertTrue(mock_update_searchindex_task.delay.called)
 
             # re-post with replace = False should now fail
             mock_update_searchindex_task.reset_mock()

ietf/api/views_rpc.py

@@ -38,7 +38,11 @@
 from ietf.doc.models import Document, DocHistory, RfcAuthor, DocEvent
 from ietf.doc.serializers import RfcAuthorSerializer
 from ietf.doc.storage_utils import remove_from_storage, store_file, exists_in_storage
-from ietf.doc.tasks import signal_update_rfc_metadata_task, update_rfc_searchindex_task
+from ietf.doc.tasks import (
+    signal_update_rfc_metadata_task,
+    trigger_red_precomputer_task,
+    update_rfc_searchindex_task,
+)
 from ietf.person.models import Email, Person
 from ietf.sync.tasks import create_rfc_index_task
 
@@ -516,6 +520,12 @@ def post(self, request):
                     destination.parent.mkdir()
                 shutil.move(ftm, destination)
 
+        # Trigger red precomputer
+        needs_updating = [rfc.rfc_number]
+        for rel in rfc.relateddocument_set.filter(relationship_id__in=["obs","updates"]):
+            needs_updating.append(rel.target.rfc_number)
+        trigger_red_precomputer_task.delay(rfc_number_list=sorted(needs_updating))
+        # Trigger search index update
         update_rfc_searchindex_task.delay(rfc.rfc_number)
         return Response(NotificationAckSerializer().data)
 

ietf/doc/tasks.py

@@ -7,11 +7,14 @@
 import debug  # pyflakes:ignore
 
 from celery import shared_task
+from celery.exceptions import MaxRetriesExceededError
 from pathlib import Path
 
 from django.conf import settings
 from django.utils import timezone
 
+from ietf.doc.utils_r2 import rfcs_are_in_r2
+from ietf.doc.utils_red import trigger_red_precomputer
 from ietf.utils import log, searchindex
 from ietf.utils.timezone import datetime_today
 
@@ -169,6 +172,20 @@ def signal_update_rfc_metadata_task(rfc_number_list=()):
     signal_update_rfc_metadata(rfc_number_list)
 
 
+@shared_task(bind=True)
+def trigger_red_precomputer_task(self, rfc_number_list=()):
+    if not rfcs_are_in_r2(rfc_number_list):
+        log.log(f"Objects are not yet in R2 for RFCs {rfc_number_list}")
+        try:
+            countdown = getattr(settings, "RED_PRECOMPUTER_TRIGGER_RETRY_DELAY", 10)
+            max_retries = getattr(settings, "RED_PRECOMPUTER_TRIGGER_MAX_RETRIES", 12)
+            self.retry(countdown=countdown, max_retries=max_retries)
+        except MaxRetriesExceededError:
+            log.log(f"Gave up waiting for objects in R2 for RFCs {rfc_number_list}")
+    else:
+        trigger_red_precomputer(rfc_number_list)
+
+
 @shared_task(bind=True)
 def update_rfc_searchindex_task(self, rfc_number: int):
     """Update the search index for one RFC"""