nucliadb 6.2.1.post2971__py3-none-any.whl → 6.2.1.post2972__py3-none-any.whl

nucliadb/common/cluster/manager.py

@@ -27,31 +27,25 @@ import backoff
 from nucliadb.common import datamanagers
 from nucliadb.common.cluster.base import AbstractIndexNode
 from nucliadb.common.cluster.exceptions import (
-    ExhaustedNodesError,
     NodeClusterSmall,
     NodeError,
     NodesUnsync,
-    NoHealthyNodeAvailable,
     ShardNotFound,
     ShardsNotFound,
 )
 from nucliadb.common.maindb.driver import Transaction
-from nucliadb.common.nidx import NIDX_ENABLED, get_nidx, get_nidx_api_client, get_nidx_fake_node
+from nucliadb.common.nidx import get_nidx, get_nidx_api_client, get_nidx_fake_node
 from nucliadb_protos import (
     knowledgebox_pb2,
-    nodereader_pb2,
     noderesources_pb2,
     nodewriter_pb2,
     writer_pb2,
 )
 from nucliadb_protos.nodewriter_pb2 import IndexMessage, IndexMessageSource, NewShardRequest, TypeMessage
 from nucliadb_telemetry import errors
-from nucliadb_utils.utilities import get_indexing, get_storage
+from nucliadb_utils.utilities import get_storage
 
-from .index_node import IndexNode
 from .settings import settings
-from .standalone.index_node import ProxyStandaloneIndexNode
-from .standalone.utils import get_self, get_standalone_node_id, is_index_node
 
 logger = logging.getLogger(__name__)
 
@@ -60,67 +54,11 @@ READ_REPLICA_INDEX_NODES: dict[str, set[str]] = {}
 
 
 def get_index_nodes(include_secondary: bool = False) -> list[AbstractIndexNode]:
-    all_nodes = [inode for inode in INDEX_NODES.values()]
-    if not include_secondary:
-        return [inode for inode in all_nodes if inode.primary_id is None]
-    return all_nodes
+    return [get_nidx_fake_node()]
 
 
 def get_index_node(node_id: str) -> Optional[AbstractIndexNode]:
-    return INDEX_NODES.get(node_id)
-
-
-def clear_index_nodes():
-    INDEX_NODES.clear()
-    READ_REPLICA_INDEX_NODES.clear()
-
-
-def get_read_replica_node_ids(node_id: str) -> list[str]:
-    return list(READ_REPLICA_INDEX_NODES.get(node_id, set()))
-
-
-def add_index_node(
-    *,
-    id: str,
-    address: str,
-    shard_count: int,
-    available_disk: int,
-    dummy: bool = False,
-    primary_id: Optional[str] = None,
-) -> AbstractIndexNode:
-    if settings.standalone_mode:
-        if is_index_node() and id == get_standalone_node_id():
-            node = get_self()
-        else:
-            node = ProxyStandaloneIndexNode(
-                id=id,
-                address=address,
-                shard_count=shard_count,
-                available_disk=available_disk,
-                dummy=dummy,
-            )
-    else:
-        node = IndexNode(  # type: ignore
-            id=id,
-            address=address,
-            shard_count=shard_count,
-            available_disk=available_disk,
-            dummy=dummy,
-            primary_id=primary_id,
-        )
-    INDEX_NODES[id] = node
-    if primary_id is not None:
-        if primary_id not in READ_REPLICA_INDEX_NODES:
-            READ_REPLICA_INDEX_NODES[primary_id] = set()
-        READ_REPLICA_INDEX_NODES[primary_id].add(id)
-    return node
-
-
-def remove_index_node(node_id: str, primary_id: Optional[str] = None) -> None:
-    INDEX_NODES.pop(node_id, None)
-    if primary_id is not None and primary_id in READ_REPLICA_INDEX_NODES:
-        if node_id in READ_REPLICA_INDEX_NODES[primary_id]:
-            READ_REPLICA_INDEX_NODES[primary_id].remove(node_id)
+    return get_nidx_fake_node()
 
 
 class KBShardManager:
@@ -145,16 +83,13 @@ class KBShardManager:
         aw: Callable[[AbstractIndexNode, str], Awaitable[Any]],
         timeout: float,
         *,
-        use_nidx: bool,
         use_read_replica_nodes: bool = False,
     ) -> list[Any]:
         shards = await self.get_shards_by_kbid(kbid)
         ops = []
 
         for shard_obj in shards:
-            node, shard_id = choose_node(
-                shard_obj, use_nidx=use_nidx, use_read_replica_nodes=use_read_replica_nodes
-            )
+            node, shard_id = choose_node(shard_obj, use_read_replica_nodes=use_read_replica_nodes)
             if shard_id is None:
                 raise ShardNotFound("Found a node but not a shard")
 
@@ -190,27 +125,12 @@ class KBShardManager:
         txn: Transaction,
         kbid: str,
     ) -> writer_pb2.ShardObject:
-        try:
-            check_enough_nodes()
-        except NodeClusterSmall as err:
-            errors.capture_exception(err)
-            logger.error(
-                f"Shard creation for kbid={kbid} failed: Replication requirements could not be met."
-            )
-            raise
-
         kb_shards = await datamanagers.cluster.get_kb_shards(txn, kbid=kbid, for_update=True)
         if kb_shards is None:
             msg = ("Attempting to create a shard for a KB when it has no stored shards in maindb",)
             logger.error(msg, extra={"kbid": kbid})
             raise ShardsNotFound(msg)
 
-        existing_kb_nodes = [replica.node for shard in kb_shards.shards for replica in shard.replicas]
-        nodes = sorted_primary_nodes(
-            avoid_nodes=existing_kb_nodes,
-            ignore_nodes=settings.drain_nodes,
-        )
-
         vectorsets = {
             vectorset_id: vectorset_config.vectorset_index_config
             async for vectorset_id, vectorset_config in datamanagers.vectorsets.iter(txn, kbid=kbid)
@@ -220,64 +140,14 @@ class KBShardManager:
 
         shard = writer_pb2.ShardObject(shard=shard_uuid, read_only=False)
         try:
-            # Attempt to create configured number of replicas
-            replicas_created = 0
-            while replicas_created < settings.node_replicas:
-                try:
-                    node_id = nodes.pop(0)
-                except IndexError:
-                    # It was not possible to find enough nodes
-                    # available/responsive to create the required replicas
-                    raise ExhaustedNodesError()
-
-                node = get_index_node(node_id)
-                if node is None:
-                    logger.error(f"Node {node_id} is not found or not available")
-                    continue
-
-                try:
-                    if not vectorsets:
-                        # bw/c KBs without vectorsets
-                        is_matryoshka = len(kb_shards.model.matryoshka_dimensions) > 0
-                        vector_index_config = nodewriter_pb2.VectorIndexConfig(
-                            similarity=kb_shards.similarity,
-                            vector_type=nodewriter_pb2.VectorType.DENSE_F32,
-                            vector_dimension=kb_shards.model.vector_dimension,
-                            normalize_vectors=is_matryoshka,
-                        )
-
-                        shard_created = await node.new_shard(
-                            kbid,
-                            vector_index_config=vector_index_config,
-                        )
-
-                    else:
-                        shard_created = await node.new_shard_with_vectorsets(
-                            kbid,
-                            vectorsets_configs=vectorsets,
-                        )
-
-                except Exception as exc:
-                    errors.capture_exception(exc)
-                    logger.exception(
-                        f"Error creating new shard for KB", extra={"kbid": kbid, "node_id": node}
-                    )
-                    continue
-
-                replica = writer_pb2.ShardReplica(node=str(node_id))
-                replica.shard.CopyFrom(shard_created)
-                shard.replicas.append(replica)
-                replicas_created += 1
-
-                nidx_api = get_nidx_api_client()
-                if nidx_api:
-                    req = NewShardRequest(
-                        kbid=kbid,
-                        vectorsets_configs=vectorsets,
-                    )
-
-                    resp = await nidx_api.NewShard(req)  # type: ignore
-                    shard.nidx_shard_id = resp.id
+            nidx_api = get_nidx_api_client()
+            req = NewShardRequest(
+                kbid=kbid,
+                vectorsets_configs=vectorsets,
+            )
+
+            resp = await nidx_api.NewShard(req)  # type: ignore
+            shard.nidx_shard_id = resp.id
 
         except Exception as exc:
             errors.capture_exception(exc)
@@ -300,43 +170,15 @@ class KBShardManager:
         return shard
 
     async def rollback_shard(self, shard: writer_pb2.ShardObject):
-        for shard_replica in shard.replicas:
-            node_id = shard_replica.node
-            replica_id = shard_replica.shard.id
-            node = get_index_node(node_id)
-            if node is not None:
-                try:
-                    logger.info(
-                        "Deleting shard replica",
-                        extra={"shard": replica_id, "node": node_id},
-                    )
-                    await node.delete_shard(replica_id)
-                except Exception as rollback_error:
-                    errors.capture_exception(rollback_error)
-                    logger.error(
-                        f"New shard rollback error. Node: {node_id} Shard: {replica_id}",
-                        exc_info=True,
-                    )
-
         nidx_api = get_nidx_api_client()
-        if nidx_api and shard.nidx_shard_id:
-            try:
-                await nidx_api.DeleteShard(noderesources_pb2.ShardId(id=shard.nidx_shard_id))
-            except Exception as rollback_error:
-                errors.capture_exception(rollback_error)
-                logger.error(
-                    f"New shard rollback error. Nidx Shard: {shard.nidx_shard_id}",
-                    exc_info=True,
-                )
-
-    def indexing_replicas(self, shard: writer_pb2.ShardObject) -> list[tuple[str, str]]:
-        """
-        Returns the replica ids and nodes for the shard replicas
-        """
-        result = []
-        for replica in shard.replicas:
-            result.append((replica.shard.id, replica.node))
-        return result
+        try:
+            await nidx_api.DeleteShard(noderesources_pb2.ShardId(id=shard.nidx_shard_id))
+        except Exception as rollback_error:
+            errors.capture_exception(rollback_error)
+            logger.error(
+                f"New shard rollback error. Nidx Shard: {shard.nidx_shard_id}",
+                exc_info=True,
+            )
 
     async def delete_resource(
         self,
@@ -346,29 +188,16 @@ class KBShardManager:
         partition: str,
         kb: str,
     ) -> None:
-        indexing = get_indexing()
         storage = await get_storage()
         nidx = get_nidx()
 
         await storage.delete_indexing(resource_uid=uuid, txid=txid, kb=kb, logical_shard=shard.shard)
 
-        for replica_id, node_id in self.indexing_replicas(shard):
-            indexpb: nodewriter_pb2.IndexMessage = nodewriter_pb2.IndexMessage()
-            indexpb.node = node_id
-            indexpb.shard = replica_id
-            indexpb.txid = txid
-            indexpb.resource = uuid
-            indexpb.typemessage = nodewriter_pb2.TypeMessage.DELETION
-            indexpb.partition = partition
-            indexpb.kbid = kb
-            await indexing.index(indexpb, node_id)
-
-        if nidx is not None and shard.nidx_shard_id:
-            nidxpb: nodewriter_pb2.IndexMessage = nodewriter_pb2.IndexMessage()
-            nidxpb.shard = shard.nidx_shard_id
-            nidxpb.resource = uuid
-            nidxpb.typemessage = nodewriter_pb2.TypeMessage.DELETION
-            await nidx.index(nidxpb)
+        nidxpb: nodewriter_pb2.IndexMessage = nodewriter_pb2.IndexMessage()
+        nidxpb.shard = shard.nidx_shard_id
+        nidxpb.resource = uuid
+        nidxpb.typemessage = nodewriter_pb2.TypeMessage.DELETION
+        await nidx.index(nidxpb)
 
     async def add_resource(
         self,
@@ -389,7 +218,6 @@ class KBShardManager:
             reindex_id = uuid.uuid4().hex
 
         storage = await get_storage()
-        indexing = get_indexing()
         nidx = get_nidx()
         indexpb = IndexMessage()
 
@@ -412,14 +240,8 @@ class KBShardManager:
         indexpb.source = source
         indexpb.resource = resource.resource.uuid
 
-        for replica_id, node_id in self.indexing_replicas(shard):
-            indexpb.node = node_id
-            indexpb.shard = replica_id
-            await indexing.index(indexpb, node_id)
-
-        if nidx is not None and shard.nidx_shard_id:
-            indexpb.shard = shard.nidx_shard_id
-            await nidx.index(indexpb)
+        indexpb.shard = shard.nidx_shard_id
+        await nidx.index(indexpb)
 
     def should_create_new_shard(self, num_paragraphs: int) -> bool:
         return num_paragraphs > settings.max_shard_paragraphs
@@ -451,12 +273,8 @@ class KBShardManager:
                 )
 
         await self.apply_for_all_shards(
-            kbid, _create_vectorset, timeout=10, use_nidx=False, use_read_replica_nodes=False
+            kbid, _create_vectorset, timeout=10, use_read_replica_nodes=False
         )
-        if NIDX_ENABLED:
-            await self.apply_for_all_shards(
-                kbid, _create_vectorset, timeout=10, use_nidx=True, use_read_replica_nodes=False
-            )
 
     async def delete_vectorset(self, kbid: str, vectorset_id: str):
         """Delete a vectorset from all KB shards"""
@@ -469,12 +287,8 @@ class KBShardManager:
                 )
 
         await self.apply_for_all_shards(
-            kbid, _delete_vectorset, timeout=10, use_nidx=False, use_read_replica_nodes=False
+            kbid, _delete_vectorset, timeout=10, use_read_replica_nodes=False
         )
-        if NIDX_ENABLED:
-            await self.apply_for_all_shards(
-                kbid, _delete_vectorset, timeout=10, use_nidx=True, use_read_replica_nodes=False
-            )
 
 
 class StandaloneKBShardManager(KBShardManager):
@@ -485,27 +299,6 @@ class StandaloneKBShardManager(KBShardManager):
         self._lock = asyncio.Lock()
         self._change_count: dict[tuple[str, str], int] = {}
 
-    async def _resource_change_event(self, kbid: str, node_id: str, shard_id: str) -> None:
-        if (node_id, shard_id) not in self._change_count:
-            self._change_count[(node_id, shard_id)] = 0
-        self._change_count[(node_id, shard_id)] += 1
-        if self._change_count[(node_id, shard_id)] < self.max_ops_before_checks:
-            return
-
-        self._change_count[(node_id, shard_id)] = 0
-        async with self._lock:
-            index_node: Optional[ProxyStandaloneIndexNode] = get_index_node(node_id)  # type: ignore
-            if index_node is None:
-                return
-            shard_info: noderesources_pb2.Shard = await index_node.reader.GetShard(
-                nodereader_pb2.GetShardRequest(shard_id=noderesources_pb2.ShardId(id=shard_id))
-            )
-            await self.maybe_create_new_shard(
-                kbid,
-                shard_info.paragraphs,
-            )
-            await index_node.writer.GC(noderesources_pb2.ShardId(id=shard_id))
-
     @backoff.on_exception(backoff.expo, NodesUnsync, jitter=backoff.random_jitter, max_tries=5)
     async def delete_resource(
         self,
@@ -518,16 +311,6 @@ class StandaloneKBShardManager(KBShardManager):
         req = noderesources_pb2.ResourceID()
         req.uuid = uuid
 
-        for shardreplica in shard.replicas:
-            req.shard_id = shardreplica.shard.id
-            index_node = get_index_node(shardreplica.node)
-            if index_node is None:  # pragma: no cover
-                raise NodesUnsync(f"Node {shardreplica.node} is not found or not available")
-            await index_node.writer.RemoveResource(req)  # type: ignore
-            asyncio.create_task(
-                self._resource_change_event(kb, shardreplica.node, shardreplica.shard.id)
-            )
-
         nidx = get_nidx()
         if nidx is not None and shard.nidx_shard_id:
             indexpb: nodewriter_pb2.IndexMessage = nodewriter_pb2.IndexMessage()
@@ -551,16 +334,6 @@ class StandaloneKBShardManager(KBShardManager):
         Calls the node writer's SetResource method directly to store the resource in the node.
         There is no queuing for standalone nodes at the moment -- indexing is done synchronously.
         """
-        index_node = None
-        for shardreplica in shard.replicas:
-            resource.shard_id = resource.resource.shard_id = shardreplica.shard.id
-            index_node = get_index_node(shardreplica.node)
-            if index_node is None:  # pragma: no cover
-                raise NodesUnsync(f"Node {shardreplica.node} is not found or not available")
-            await index_node.writer.SetResource(resource)  # type: ignore
-            asyncio.create_task(
-                self._resource_change_event(kb, shardreplica.node, shardreplica.shard.id)
-            )
 
         nidx = get_nidx()
         if nidx is not None and shard.nidx_shard_id:
@@ -587,89 +360,18 @@ class StandaloneKBShardManager(KBShardManager):
                 pass
 
 
-def get_all_shard_nodes(
-    shard: writer_pb2.ShardObject,
-    *,
-    use_read_replicas: bool,
-) -> list[tuple[AbstractIndexNode, str]]:
-    """Return a list of all nodes containing `shard` with the shard replica id.
-    If `use_read_replicas`, read replica nodes will be returned too.
-
-    """
-    nodes = []
-    for shard_replica_pb in shard.replicas:
-        node_id = shard_replica_pb.node
-        shard_replica_id = shard_replica_pb.shard.id
-
-        node = get_index_node(node_id)
-        if node is not None:
-            nodes.append((node, shard_replica_id))
-
-        if use_read_replicas:
-            for read_replica_node_id in get_read_replica_node_ids(node_id):
-                read_replica_node = get_index_node(read_replica_node_id)
-                if read_replica_node is not None:
-                    nodes.append((read_replica_node, shard_replica_id))
-
-    return nodes
-
-
 def choose_node(
     shard: writer_pb2.ShardObject,
     *,
-    use_nidx: bool,
     target_shard_replicas: Optional[list[str]] = None,
     use_read_replica_nodes: bool = False,
 ) -> tuple[AbstractIndexNode, str]:
-    """Choose an arbitrary node storing `shard` following these rules:
-    - nodes containing a shard replica from `target_replicas` are the preferred
-    - when enabled, read replica nodes are preferred over primaries
-    - if there's more than one option with the same score, a random choice will
-      be made between them.
-
-    According to these rules and considering we use read replica nodes, a read
-    replica node containing a shard replica from `target_shard_replicas` is the
-    most preferent, while a primary node with a shard not in
-    `target_shard_replicas` is the least preferent.
-
-    """
-
-    # Use nidx if requested and enabled, fallback to node
-    if shard.nidx_shard_id and use_nidx:
-        fake_node = get_nidx_fake_node()
-        if fake_node:
-            return fake_node, shard.nidx_shard_id
-
-    target_shard_replicas = target_shard_replicas or []
-
-    shard_nodes = get_all_shard_nodes(shard, use_read_replicas=use_read_replica_nodes)
-
-    if len(shard_nodes) == 0:
-        raise NoHealthyNodeAvailable("Could not find a node to query")
-
-    # Ranking values
-    IN_TARGET_SHARD_REPLICAS = 0b10
-    IS_READ_REPLICA_NODE = 0b01
-
-    ranked_nodes: dict[int, list[tuple[AbstractIndexNode, str]]] = {}
-    for node, shard_replica_id in shard_nodes:
-        score = 0
-        if shard_replica_id in target_shard_replicas:
-            score |= IN_TARGET_SHARD_REPLICAS
-        if node.is_read_replica():
-            score |= IS_READ_REPLICA_NODE
-
-        ranked_nodes.setdefault(score, []).append((node, shard_replica_id))
-
-    top = ranked_nodes[max(ranked_nodes)]
-    # As shard replica ids are random numbers, we sort by shard replica id and choose its
-    # node to make sure we choose in deterministically but we don't favour any node in particular
-    top.sort(key=lambda x: x[1])
-    selected_node, shard_replica_id = top[0]
-    return selected_node, shard_replica_id
+    fake_node = get_nidx_fake_node()
+    return fake_node, shard.nidx_shard_id
 
 
 def check_enough_nodes():
+    return True
     """
     It raises an exception if it can't find enough nodes for the configured replicas.
     """

nucliadb/common/cluster/rebalance.py

@@ -52,7 +52,7 @@ async def get_shards_paragraphs(kbid: str) -> list[tuple[str, int]]:
     results = {}
     for shard_meta in kb_shards.shards:
         # Rebalance using node as source of truth. But it will rebalance nidx
-        node, shard_id = choose_node(shard_meta, use_nidx=False)
+        node, shard_id = choose_node(shard_meta)
         shard_data: nodereader_pb2.Shard = await node.reader.GetShard(
             nodereader_pb2.GetShardRequest(shard_id=noderesources_pb2.ShardId(id=shard_id))  # type: ignore
         )
@@ -102,7 +102,7 @@ async def move_set_of_kb_resources(
     from_shard = [s for s in kb_shards.shards if s.shard == from_shard_id][0]
     to_shard = [s for s in kb_shards.shards if s.shard == to_shard_id][0]
 
-    from_node, from_shard_replica_id = choose_node(from_shard, use_nidx=False)
+    from_node, from_shard_replica_id = choose_node(from_shard)
     search_response: nodereader_pb2.SearchResponse = await from_node.reader.Search(  # type: ignore
         nodereader_pb2.SearchRequest(
             shard=from_shard_replica_id,

nucliadb/common/cluster/rollover.py

@@ -24,7 +24,6 @@ from datetime import datetime
 from typing import Optional
 
 from nucliadb.common import datamanagers, locking
-from nucliadb.common.cluster import manager as cluster_manager
 from nucliadb.common.context import ApplicationContext
 from nucliadb.common.datamanagers.rollover import RolloverState, RolloverStateNotFoundError
 from nucliadb.common.external_index_providers.base import ExternalIndexManager
@@ -32,11 +31,9 @@ from nucliadb.common.external_index_providers.manager import (
     get_external_index_manager,
 )
 from nucliadb.common.nidx import get_nidx_fake_node
-from nucliadb_protos import nodewriter_pb2, writer_pb2
+from nucliadb_protos import writer_pb2
 from nucliadb_telemetry import errors
 
-from .manager import get_index_node
-from .settings import settings
 from .utils import (
     delete_resource_from_shard,
     get_resource,
@@ -138,63 +135,19 @@ async def create_rollover_shards(
     # create new shards
     created_shards = []
     try:
-        nodes = cluster_manager.sorted_primary_nodes(ignore_nodes=drain_nodes)
         for shard in kb_shards.shards:
             shard.ClearField("replicas")
-            # Attempt to create configured number of replicas
-            replicas_created = 0
-            while replicas_created < settings.node_replicas:
-                if len(nodes) == 0:
-                    # could have multiple shards on single node
-                    nodes = cluster_manager.sorted_primary_nodes(ignore_nodes=drain_nodes)
-                node_id = nodes.pop(0)
-
-                node = get_index_node(node_id)
-                if node is None:
-                    logger.error(f"Node {node_id} is not found or not available")
-                    continue
-
-                vectorsets = {
-                    vectorset_id: vectorset_config.vectorset_index_config
-                    async for vectorset_id, vectorset_config in datamanagers.vectorsets.iter(
-                        txn, kbid=kbid
-                    )
-                }
-                try:
-                    if not vectorsets:
-                        is_matryoshka = len(kb_shards.model.matryoshka_dimensions) > 0
-                        vector_index_config = nodewriter_pb2.VectorIndexConfig(
-                            similarity=kb_shards.similarity,
-                            vector_type=nodewriter_pb2.VectorType.DENSE_F32,
-                            vector_dimension=kb_shards.model.vector_dimension,
-                            normalize_vectors=is_matryoshka,
-                        )
-                        shard_created = await node.new_shard(
-                            kbid,
-                            vector_index_config=vector_index_config,
-                        )
-                    else:
-                        shard_created = await node.new_shard_with_vectorsets(
-                            kbid,
-                            vectorsets_configs=vectorsets,
-                        )
-                except Exception as e:
-                    errors.capture_exception(e)
-                    logger.exception(f"Error creating new shard at {node}")
-                    continue
-
-                replica = writer_pb2.ShardReplica(node=str(node_id))
-                replica.shard.CopyFrom(shard_created)
-                shard.replicas.append(replica)
-                created_shards.append(shard)
-                replicas_created += 1
-
-            if nidx_node:
-                nidx_shard = await nidx_node.new_shard_with_vectorsets(
-                    kbid,
-                    vectorsets_configs=vectorsets,
-                )
-                shard.nidx_shard_id = nidx_shard.id
+            vectorsets = {
+                vectorset_id: vectorset_config.vectorset_index_config
+                async for vectorset_id, vectorset_config in datamanagers.vectorsets.iter(txn, kbid=kbid)
+            }
+
+            nidx_shard = await nidx_node.new_shard_with_vectorsets(
+                kbid,
+                vectorsets_configs=vectorsets,
+            )
+            shard.nidx_shard_id = nidx_shard.id
+            created_shards.append(shard)
 
     except Exception as e:
         errors.capture_exception(e)
@@ -621,16 +574,6 @@ async def clean_rollover_status(app_context: ApplicationContext, kbid: str) -> N
         await txn.commit()
 
 
-async def wait_for_cluster_ready() -> None:
-    node_ready_checks = 0
-    while len(cluster_manager.INDEX_NODES) == 0:
-        if node_ready_checks > 10:
-            raise Exception("No index nodes available")
-        logger.info("Waiting for index nodes to be available")
-        await asyncio.sleep(1)
-        node_ready_checks += 1
-
-
 async def rollover_kb_index(
     app_context: ApplicationContext, kbid: str, drain_nodes: Optional[list[str]] = None
 ) -> None:
@@ -654,8 +597,6 @@ async def rollover_kb_index(
     - Validate that all resources are in the new kb index
     - Clean up indexed data
     """
-    await wait_for_cluster_ready()
-
     extra = {"kbid": kbid, "external_index_provider": None}
     external = await get_external_index_manager(kbid, for_rollover=True)
     if external is not None: