Cover an index with no read pointer, and stop sending operators to repair one

A missing read alias is a state advance_read_pointer handles on purpose: an
index serving no reads is not already current, so a completed pass publishes
it. test_update_read_pointer was what covered that, and it went with the task,
so give SearchMigrationFixture a way to drop the alias and pin the behaviour
where the rest of the pointer logic is tested.

The startup message for a read pointer behind the write pointer sent operators
to repair the index by hand. That was right when nothing advanced the pointer
on its own; now the first reindex to complete a full pass publishes it, so say
that instead.

Author: jonathangreen

src/palace/manager/scripts/initialization.py

@@ -154,9 +154,9 @@ def initialize_search(self) -> None:
             self.migrate_search(service, revision)
         elif read_pointer.version < revision.version:
             self.log.info(
-                f"Search read pointer is out-of-date (v{read_pointer.version}). Latest is v{revision.version}."
-                f"This likely means that the reindexing task is in progress. If there is no reindexing task "
-                f"running, you may need to repair the search index."
+                f"Search read pointer is out-of-date (v{read_pointer.version}). Latest is v{revision.version}. "
+                f"This likely means that the reindexing task is in progress. The first run to complete a "
+                f"full pass over the new index will publish it for reads."
             )
         elif (
             read_pointer.version > revision.version

tests/manager/celery/tasks/test_search.py

@@ -363,6 +363,22 @@ def __init__(
             self.service, self.new_revision
         )
 
+    def remove_read_pointer(self) -> None:
+        """Leave the index with no read pointer at all, serving no reads."""
+        self.client.indices.update_aliases(
+            body={
+                "actions": [
+                    {
+                        "remove": {
+                            "index": "*",
+                            "alias": self.service.read_pointer_name(),
+                        }
+                    }
+                ]
+            }
+        )
+        assert self.service.read_pointer() is None
+
     def assert_pointers(self, read: str, write: str) -> None:
         read_pointer = self.service.read_pointer()
         write_pointer = self.service.write_pointer()
@@ -404,6 +420,22 @@ def test_search_reindex_advances_read_pointer(
     end_to_end_search_fixture.expect_results(fixture.works, "", ordered=False)
 
 
+def test_search_reindex_advances_read_pointer_when_there_is_none(
+    celery_fixture: CeleryFixture,
+    redis_fixture: RedisFixture,
+    search_migration_fixture: SearchMigrationFixture,
+):
+    fixture = search_migration_fixture
+
+    # An index serving no reads at all is not "already current", so a completed pass
+    # publishes it rather than leaving search with nothing to read from.
+    fixture.remove_read_pointer()
+
+    search_reindex.delay().wait()
+
+    fixture.assert_pointers(read=fixture.new_index, write=fixture.new_index)
+
+
 @patch("palace.manager.celery.tasks.search.random.uniform")
 @patch("palace.manager.celery.tasks.search.exponential_backoff")
 def test_search_reindex_advances_read_pointer_after_a_retried_batch(