feat: Add the command to schedule the celery task for populating the index.

Signed-off-by: Farhaan Bukhsh <farhaan@opencraft.com>

Author: farhaanbukhsh

openedx/core/djangoapps/content/search/management/commands/reindex_studio.py

@@ -1,43 +1,83 @@
 """
-Command to build or re-build the search index for courses (in Studio, i.e. Draft
-mode), in Meilisearch.
+Command to queue incremental population of the Studio Meilisearch search index.
+
+Index creation, configuration, and schema reconciliation are handled
+automatically via the post_migrate signal. This command is solely
+responsible for enqueuing the population task in Celery.
 
 See also cms/djangoapps/contentstore/management/commands/reindex_course.py which
 indexes LMS (published) courses in ElasticSearch.
 """
+
 from django.core.management import BaseCommand, CommandError
 
 from ... import api
+from ...tasks import rebuild_index_incremental
 
 
 class Command(BaseCommand):
     """
-    Build or re-build the Meilisearch search index for courses and libraries in Studio.
+    Queue incremental population of the Meilisearch search index for Studio.
 
-    This is separate from LMS search features like courseware search or forum search.
+    This enqueues a Celery task that incrementally indexes all courses and
+    libraries. Progress is tracked via IncrementalIndexCompleted, so the task
+    can safely resume if interrupted.
+
+    Index creation and configuration are handled by post_migrate reconciliation
+    (runs automatically on ./manage.py cms migrate).
     """
 
-    # TODO: improve this - see https://github.com/openedx/edx-platform/issues/36868
+    help = "Queue incremental population of the Studio Meilisearch search index via Celery."
 
     def add_arguments(self, parser):
-        parser.add_argument("--experimental", action="store_true")  # kept for compatibility but ignored.
-        parser.add_argument("--reset", action="store_true")
-        parser.add_argument("--init", action="store_true")
-        parser.add_argument("--incremental", action="store_true")
-        parser.set_defaults(experimental=False, reset=False, init=False, incremental=False)
+        # Removed flags — provide clear error messages for operators with old automation.
+        parser.add_argument(
+            "--reset",
+            action="store_true",
+            default=False,
+            help="(Removed) Index reset is now handled by post_migrate reconciliation.",
+        )
+        parser.add_argument(
+            "--init",
+            action="store_true",
+            default=False,
+            help="(Removed) Index initialization is now handled by post_migrate reconciliation.",
+        )
+        parser.add_argument(
+            "--incremental",
+            action="store_true",
+            default=False,
+            help="(Removed) Incremental is now the default and only population mode.",
+        )
 
     def handle(self, *args, **options):
-        """
-        Build a new search index for Studio, containing content from courses and libraries
-        """
         if not api.is_meilisearch_enabled():
             raise CommandError("Meilisearch is not enabled. Please set MEILISEARCH_ENABLED to True in your settings.")
 
         if options["reset"]:
-            api.reset_index(self.stdout.write)
-        elif options["init"]:
-            api.init_index(self.stdout.write, self.stderr.write)
-        elif options["incremental"]:
-            api.rebuild_index(self.stdout.write, incremental=True)
-        else:
-            api.rebuild_index(self.stdout.write)
+            raise CommandError(
+                "The --reset flag has been removed. "
+                "Index reset is now handled automatically by post_migrate reconciliation. "
+                "Run: ./manage.py cms migrate"
+            )
+
+        if options["init"]:
+            raise CommandError(
+                "The --init flag has been removed. "
+                "Index initialization is now handled automatically by post_migrate reconciliation. "
+                "Run: ./manage.py cms migrate"
+            )
+
+        if options["incremental"]:
+            raise CommandError(
+                "The --incremental flag has been removed. "
+                "Incremental population is now the default behavior of this command."
+            )
+
+        result = rebuild_index_incremental.delay()
+
+        self.stdout.write(
+            f"Studio search index population has been queued (task_id={result.id}). "
+            "Population will run incrementally in a Celery worker. "
+            "Monitor progress in Celery worker logs."
+        )

openedx/core/djangoapps/content/search/tasks.py

@@ -184,3 +184,37 @@ def delete_course_index_docs(course_key_str: str) -> None:
 
     # Delete children index data for course blocks.
     api.delete_docs_with_context_key(course_key)
+
+
+@shared_task(
+    base=LoggedTask,
+    autoretry_for=(MeilisearchError, ConnectionError),
+    max_retries=3,
+    retry_backoff=True,
+)
+@set_code_owner_attribute
+def rebuild_index_incremental() -> None:
+    """
+    Celery task to incrementally populate the Studio Meilisearch index.
+
+    Uses IncrementalIndexCompleted to track progress and resume from where
+    it left off if interrupted. Safe to call multiple times — already-indexed
+    contexts are skipped.
+
+    If a rebuild is already in progress (lock held), the task exits gracefully.
+    """
+    log.info("Starting incremental Studio search index population...")
+
+    try:
+        api.rebuild_index(status_cb=log.info, incremental=True)
+    except RuntimeError as exc:
+        # rebuild_index -> _using_temp_index or lock contention
+        if "already in progress" in str(exc).lower():
+            log.warning(
+                "Studio index population skipped: a rebuild is already in progress. "
+                "Will retry later if re-enqueued."
+            )
+            return
+        raise
+
+    log.info("Incremental Studio search index population complete.")

openedx/core/djangoapps/content/search/tests/test_reindex_cmd.py

@@ -0,0 +1,100 @@
+"""
+Tests for the reindex_studio management command and the rebuild_index_incremental Celery task.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
+from django.core.management import CommandError, call_command
+from django.test import TestCase, override_settings
+
+from openedx.core.djangolib.testing.utils import skip_unless_cms
+
+try:
+    from .. import api
+    from ..tasks import rebuild_index_incremental
+except RuntimeError:
+    pass
+
+
+@skip_unless_cms
+@override_settings(MEILISEARCH_ENABLED=True)
+class TestReindexStudioCommand(TestCase):
+    """Tests for the reindex_studio management command."""
+
+    @patch("openedx.core.djangoapps.content.search.tasks.rebuild_index_incremental.delay")
+    def test_enqueues_task(self, mock_delay):
+        """Command enqueues the incremental rebuild task."""
+        mock_delay.return_value = Mock(id="fake-task-id")
+
+        call_command("reindex_studio")
+
+        mock_delay.assert_called_once_with()
+
+    @override_settings(MEILISEARCH_ENABLED=False)
+    def test_disabled(self):
+        """Command raises error when Meilisearch is disabled."""
+        with pytest.raises(CommandError, match="not enabled"):
+            call_command("reindex_studio")
+
+    def test_reset_flag_removed(self):
+        """Passing --reset raises a clear error."""
+        with pytest.raises(CommandError, match="--reset flag has been removed"):
+            call_command("reindex_studio", "--reset")
+
+    def test_init_flag_removed(self):
+        """Passing --init raises a clear error."""
+        with pytest.raises(CommandError, match="--init flag has been removed"):
+            call_command("reindex_studio", "--init")
+
+    def test_incremental_flag_removed(self):
+        """Passing --incremental raises a clear error."""
+        with pytest.raises(CommandError, match="--incremental flag has been removed"):
+            call_command("reindex_studio", "--incremental")
+
+
+@skip_unless_cms
+@override_settings(MEILISEARCH_ENABLED=True)
+@patch("openedx.core.djangoapps.content.search.api._wait_for_meili_task", new=MagicMock(return_value=None))
+@patch("openedx.core.djangoapps.content.search.api.MeilisearchClient")
+class TestRebuildIndexIncrementalTask(TestCase):
+    """Tests for the rebuild_index_incremental Celery task."""
+
+    def setUp(self):
+        super().setUp()
+        api.clear_meilisearch_client()
+
+    @patch("openedx.core.djangoapps.content.search.api.rebuild_index")
+    def test_calls_rebuild_incremental(self, mock_rebuild, mock_meilisearch):
+        """Task calls api.rebuild_index with incremental=True."""
+        rebuild_index_incremental()
+
+        mock_rebuild.assert_called_once()
+        _, kwargs = mock_rebuild.call_args
+        assert kwargs["incremental"] is True
+
+    @patch("openedx.core.djangoapps.content.search.api.rebuild_index")
+    def test_rebuild_already_in_progress(self, mock_rebuild, mock_meilisearch):
+        """Task exits gracefully if rebuild lock is already held."""
+        mock_rebuild.side_effect = RuntimeError("Rebuild already in progress")
+
+        # Should not raise
+        rebuild_index_incremental()
+
+    @patch("openedx.core.djangoapps.content.search.api.rebuild_index")
+    def test_other_runtime_error_raised(self, mock_rebuild, mock_meilisearch):
+        """Task re-raises RuntimeError if it's not about lock contention."""
+        mock_rebuild.side_effect = RuntimeError("Something else went wrong")
+
+        with pytest.raises(RuntimeError, match="Something else went wrong"):
+            rebuild_index_incremental()
+
+    @patch("openedx.core.djangoapps.content.search.api.rebuild_index")
+    def test_idempotent(self, mock_rebuild, mock_meilisearch):
+        """Task can be called multiple times safely."""
+        rebuild_index_incremental()
+        rebuild_index_incremental()
+
+        assert mock_rebuild.call_count == 2