nucliadb 4.0.0.post542__py3-none-any.whl → 6.2.1.post2777__py3-none-any.whl

nucliadb/writer/api/v1/upload.py

@@ -18,7 +18,6 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import base64
-import mimetypes
 import pickle
 import uuid
 from datetime import datetime
@@ -30,9 +29,7 @@ from fastapi import HTTPException
 from fastapi.params import Header
 from fastapi.requests import Request
 from fastapi.responses import Response
-from fastapi_versioning import version  # type: ignore
-from nucliadb_protos.resources_pb2 import FieldFile, Metadata
-from nucliadb_protos.writer_pb2 import BrokerMessage
+from fastapi_versioning import version
 from starlette.requests import Request as StarletteRequest
 
 from nucliadb.common import datamanagers
@@ -40,13 +37,15 @@ from nucliadb.ingest.orm.utils import set_title
 from nucliadb.ingest.processing import PushPayload, Source
 from nucliadb.models.responses import HTTPClientError
 from nucliadb.writer import SERVICE_NAME
+from nucliadb.writer.api.v1 import transaction
 from nucliadb.writer.api.v1.resource import (
     get_rid_from_slug_or_raise_error,
     validate_rid_exists_or_raise_error,
 )
+from nucliadb.writer.api.v1.slug import ensure_slug_uniqueness, noop_context_manager
 from nucliadb.writer.back_pressure import maybe_back_pressure
 from nucliadb.writer.resource.audit import parse_audit
-from nucliadb.writer.resource.basic import parse_basic
+from nucliadb.writer.resource.basic import parse_basic_creation
 from nucliadb.writer.resource.field import parse_fields
 from nucliadb.writer.resource.origin import parse_extra, parse_origin
 from nucliadb.writer.tus import TUSUPLOAD, UPLOAD, get_dm, get_storage_manager
@@ -58,20 +57,21 @@ from nucliadb.writer.tus.exceptions import (
     InvalidTUSMetadata,
     ResumableURINotAvailable,
 )
-from nucliadb.writer.tus.storage import FileStorageManager  # type: ignore
+from nucliadb.writer.tus.storage import FileStorageManager
 from nucliadb.writer.tus.utils import parse_tus_metadata
 from nucliadb.writer.utilities import get_processing
+from nucliadb_models import content_types
 from nucliadb_models.resource import NucliaDBRoles
 from nucliadb_models.utils import FieldIdString
 from nucliadb_models.writer import CreateResourcePayload, ResourceFileUploaded
+from nucliadb_protos.resources_pb2 import CloudFile, FieldFile, Metadata
+from nucliadb_protos.writer_pb2 import BrokerMessage
 from nucliadb_utils.authentication import requires_one
 from nucliadb_utils.exceptions import LimitsExceededError, SendToProcessError
 from nucliadb_utils.storages.storage import KB_RESOURCE_FIELD
-from nucliadb_utils.transaction import TransactionCommitTimeoutError
 from nucliadb_utils.utilities import (
     get_partitioning,
     get_storage,
-    get_transaction_utility,
 )
 
 from .router import KB_PREFIX, RESOURCE_PREFIX, RSLUG_PREFIX, api
@@ -196,6 +196,13 @@ async def _tus_post(
     if path_rid is not None:
         await validate_rid_exists_or_raise_error(kbid, path_rid)
 
+    kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
+    if item and item.hidden and not (kb_config and kb_config.hidden_resources_enabled):
+        raise HTTPException(
+            status_code=422,
+            detail="Cannot hide a resource: the KB does not have hidden resources enabled",
+        )
+
     await maybe_back_pressure(request, kbid, resource_uuid=path_rid)
 
     dm = get_dm()
@@ -221,15 +228,11 @@ async def _tus_post(
         try:
             metadata = parse_tus_metadata(request.headers["upload-metadata"])
         except InvalidTUSMetadata as exc:
-            raise HTTPBadRequest(
-                detail=f"Upload-Metadata header contains errors: {str(exc)}"
-            )
+            raise HTTPBadRequest(detail=f"Upload-Metadata header contains errors: {str(exc)}")
     else:
         metadata = {}
 
-    path, rid, field = await validate_field_upload(
-        kbid, path_rid, field_id, metadata.get("md5")
-    )
+    path, rid, field = await validate_field_upload(kbid, path_rid, field_id, metadata.get("md5"))
 
     if implies_resource_creation:
         # When uploading a file to a new kb resource, we want to allow multiple
@@ -255,8 +258,15 @@ async def _tus_post(
     request_content_type = None
     if item is None:
         request_content_type = request.headers.get("content-type")
-    if not request_content_type:
-        request_content_type = guess_content_type(metadata["filename"])
+    if request_content_type is None:
+        request_content_type = content_types.guess(metadata["filename"]) or "application/octet-stream"
+
+    if request_content_type is not None and not content_types.valid(request_content_type):
+        raise HTTPException(
+            status_code=415,
+            detail=f"Unsupported content type: {request_content_type}",
+        )
+
     metadata.setdefault("content_type", request_content_type)
 
     metadata["implies_resource_creation"] = implies_resource_creation
@@ -286,9 +296,7 @@ async def _tus_post(
     await dm.save()
 
     # Find the URL for upload, with the same parameter as this call
-    location = api.url_path_for(
-        "Upload information", upload_id=upload_id, **request.path_params
-    )
+    location = api.url_path_for("Upload information", upload_id=upload_id, **request.path_params)
     return Response(
         status_code=201,
         headers={
@@ -465,7 +473,7 @@ async def _tus_patch(
     field: Optional[str] = None,
 ) -> Response:
     """
-    Upload all bytes in the requests and append them in the specifyied offset
+    Upload all bytes in the requests and append them in the specified offset
     """
     if rid is not None:
         await validate_rid_exists_or_raise_error(kbid, rid)
@@ -494,8 +502,7 @@ async def _tus_patch(
 
     if offset != dm.offset:
         raise HTTPConflict(
-            detail=f"Current upload offset({offset}) does not match "
-            f"object offset {dm.offset}"
+            detail=f"Current upload offset({offset}) does not match " f"object offset {dm.offset}"
         )
 
     storage_manager = get_storage_manager()
@@ -507,9 +514,7 @@ async def _tus_patch(
 
     if to_upload and read_bytes != to_upload:  # pragma: no cover
         # check length matches if provided
-        raise HTTPPreconditionFailed(
-            detail="Upload size does not match what was provided"
-        )
+        raise HTTPPreconditionFailed(detail="Upload size does not match what was provided")
     await dm.update(offset=offset + read_bytes)
 
     headers = {
@@ -521,7 +526,6 @@ async def _tus_patch(
     }
 
     upload_finished = dm.get("size") is not None and dm.offset >= dm.get("size")
-
     if upload_finished:
         rid = dm.get("rid", rid)
         if rid is None:
@@ -540,13 +544,19 @@ async def _tus_patch(
             if isinstance(item_payload, str):
                 item_payload = item_payload.encode()
             creation_payload = pickle.loads(base64.b64decode(item_payload))
+
+        content_type = dm.get("metadata", {}).get("content_type")
+        if content_type is not None and not content_types.valid(content_type):
+            return HTTPClientError(
+                status_code=415,
+                detail=f"Unsupported content type: {content_type}",
+            )
+
         try:
             seqid = await store_file_on_nuclia_db(
                 size=dm.get("size"),
-                content_type=dm.get("metadata", {}).get("content_type"),
-                override_resource_title=dm.get("metadata", {}).get(
-                    "implies_resource_creation", False
-                ),
+                content_type=content_type,
+                override_resource_title=dm.get("metadata", {}).get("implies_resource_creation", False),
                 filename=dm.get("metadata", {}).get("filename"),
                 password=dm.get("metadata", {}).get("password"),
                 language=dm.get("metadata", {}).get("language"),
@@ -565,20 +575,17 @@ async def _tus_patch(
 
         headers["NDB-Seq"] = f"{seqid}"
     else:
-        check_uploaded_chunk_size(read_bytes, storage_manager)
+        validate_intermediate_tus_chunk(read_bytes, storage_manager)
         await dm.save()
 
     return Response(headers=headers)
 
 
-def check_uploaded_chunk_size(read_bytes: int, storage_manager: FileStorageManager):
-    if (
-        storage_manager.min_upload_size is not None
-        and read_bytes < storage_manager.min_upload_size
-    ):
-        raise HTTPPreconditionFailed(
-            detail=f"Intermediate chunks cannot be smaller than {storage_manager.min_upload_size} bytes"
-        )
+def validate_intermediate_tus_chunk(read_bytes: int, storage_manager: FileStorageManager):
+    try:
+        storage_manager.validate_intermediate_chunk(read_bytes)
+    except ValueError as err:
+        raise HTTPPreconditionFailed(detail=str(err))
 
 
 @api.post(
@@ -688,9 +695,7 @@ async def _upload(
     await maybe_back_pressure(request, kbid, resource_uuid=path_rid)
 
     md5_user = x_md5[0] if x_md5 is not None and len(x_md5) > 0 else None
-    path, rid, valid_field = await validate_field_upload(
-        kbid, path_rid, field, md5_user
-    )
+    path, rid, valid_field = await validate_field_upload(kbid, path_rid, field, md5_user)
     dm = get_dm()
     storage_manager = get_storage_manager()
 
@@ -719,8 +724,14 @@ async def _upload(
     # - content-type set by the user in the upload request header takes precedence.
     # - if not set, we will try to guess it from the filename and default to a generic binary content type otherwise
     content_type = request.headers.get("content-type")
-    if not content_type:
-        content_type = guess_content_type(filename)
+    if content_type is None:
+        content_type = content_types.guess(filename) or "application/octet-stream"
+
+    if not content_types.valid(content_type):
+        raise HTTPException(
+            status_code=415,
+            detail=f"Unsupported content type: {content_type}",
+        )
 
     metadata = {"content_type": content_type, "filename": filename}
 
@@ -791,13 +802,9 @@ async def validate_field_upload(
     if rid is None:
         # we are going to create a new resource and a field
         if md5 is not None:
-            exists = await datamanagers.atomic.resources.resource_exists(
-                kbid=kbid, rid=md5
-            )
+            exists = await datamanagers.atomic.resources.resource_exists(kbid=kbid, rid=md5)
             if exists:
-                raise HTTPConflict(
-                    "A resource with the same uploaded file already exists"
-                )
+                raise HTTPConflict("A resource with the same uploaded file already exists")
             rid = md5
         else:
             rid = uuid.uuid4().hex
@@ -823,7 +830,7 @@ async def store_file_on_nuclia_db(
     path: str,
     request: Request,
     bucket: str,
-    source: Source,
+    source: CloudFile.Source.ValueType,
     rid: str,
     field: str,
     content_type: str = "application/octet-stream",
@@ -835,9 +842,7 @@ async def store_file_on_nuclia_db(
     item: Optional[CreateResourcePayload] = None,
 ) -> Optional[int]:
     # File is on NucliaDB Storage at path
-
     partitioning = get_partitioning()
-    transaction = get_transaction_utility()
     processing = get_processing()
     storage = await get_storage(service_name=SERVICE_NAME)
 
@@ -859,14 +864,17 @@ async def store_file_on_nuclia_db(
 
     parse_audit(writer.audit, request)
 
+    unique_slug_context_manager = noop_context_manager()
     if item is not None:
         if item.slug:
+            unique_slug_context_manager = ensure_slug_uniqueness(kbid, item.slug)
             writer.slug = item.slug
             toprocess.slug = item.slug
 
         toprocess.processing_options = item.processing_options
 
-        parse_basic(writer, item, toprocess)
+        kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
+        parse_basic_creation(writer, item, toprocess, kb_config)
         if item.origin is not None:
             parse_origin(writer.origin, item.origin)
         if item.extra is not None:
@@ -882,62 +890,61 @@ async def store_file_on_nuclia_db(
             uuid=rid,
             x_skip_store=False,
         )
-
-    if override_resource_title and filename is not None:
-        set_title(writer, toprocess, filename)
-
-    writer.basic.icon = content_type
-    writer.basic.created.FromDatetime(datetime.now())
-
-    # Update resource with file
-    file_field = FieldFile()
-    file_field.added.FromDatetime(datetime.now())
-    file_field.file.bucket_name = bucket
-    file_field.file.content_type = content_type
-    if filename is not None:
-        file_field.file.filename = filename
-    file_field.file.uri = path
-    file_field.file.source = source
-
-    if md5:
-        file_field.file.md5 = md5
-    if size:
-        file_field.file.size = size
-    if language:
-        file_field.language = language
-    if password:
-        file_field.password = password
-
-    writer.files[field].CopyFrom(file_field)
-    # Do not store passwords on maindb
-    writer.files[field].ClearField("password")
-
-    toprocess.filefield[field] = await processing.convert_internal_filefield_to_str(
-        file_field, storage=storage
-    )
-
-    writer.source = BrokerMessage.MessageSource.WRITER
-    writer.basic.metadata.status = Metadata.Status.PENDING
-    writer.basic.metadata.useful = True
-    try:
-        await transaction.commit(writer, partition, wait=True)
-    except TransactionCommitTimeoutError:
-        raise HTTPException(
-            status_code=501,
-            detail="Inconsistent write. This resource will not be processed and may not be stored.",
+    else:
+        # Use defaults for everything, but don't forget hidden which depends on KB config
+        kb_config = await datamanagers.atomic.kb.get_config(kbid=kbid)
+        if kb_config and kb_config.hidden_resources_hide_on_creation:
+            writer.basic.hidden = True
+
+    async with unique_slug_context_manager:
+        if override_resource_title and filename is not None:
+            set_title(writer, toprocess, filename)
+
+        writer.basic.icon = content_type
+        writer.basic.created.FromDatetime(datetime.now())
+
+        # Update resource with file
+        file_field = FieldFile()
+        file_field.added.FromDatetime(datetime.now())
+        file_field.file.bucket_name = bucket
+        file_field.file.content_type = content_type
+        if filename is not None:
+            file_field.file.filename = filename
+        file_field.file.uri = path
+        file_field.file.source = source
+
+        if md5:
+            file_field.file.md5 = md5
+        if size:
+            file_field.file.size = size
+        if language:
+            file_field.language = language
+        if password:
+            file_field.password = password
+
+        writer.files[field].CopyFrom(file_field)
+        # Do not store passwords on maindb
+        writer.files[field].ClearField("password")
+
+        toprocess.filefield[field] = await processing.convert_internal_filefield_to_str(
+            file_field, storage=storage
         )
 
-    try:
-        processing_info = await processing.send_to_process(toprocess, partition)
-    except LimitsExceededError as exc:
-        raise HTTPException(status_code=exc.status_code, detail=exc.detail)
-    except SendToProcessError:
-        raise HTTPException(
-            status_code=500,
-            detail="Error while sending to process. Try calling /reprocess",
-        )
+        writer.source = BrokerMessage.MessageSource.WRITER
+        writer.basic.metadata.status = Metadata.Status.PENDING
+        writer.basic.metadata.useful = True
+        await transaction.commit(writer, partition)
+        try:
+            processing_info = await processing.send_to_process(toprocess, partition)
+        except LimitsExceededError as exc:
+            raise HTTPException(status_code=exc.status_code, detail=exc.detail)
+        except SendToProcessError:
+            raise HTTPException(
+                status_code=500,
+                detail="Error while sending to process. Try calling /reprocess",
+            )
 
-    return processing_info.seqid
+        return processing_info.seqid
 
 
 def maybe_b64decode(some_string: str) -> str:
@@ -946,9 +953,3 @@ def maybe_b64decode(some_string: str) -> str:
     except ValueError:
         # not b64encoded
         return some_string
-
-
-def guess_content_type(filename: str) -> str:
-    default = "application/octet-stream"
-    guessed, _ = mimetypes.guess_type(filename)
-    return guessed or default

nucliadb/writer/app.py

@@ -18,61 +18,38 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 
-import functools
+import importlib.metadata
 
-import pkg_resources
 from fastapi import FastAPI
 from starlette.middleware import Middleware
 from starlette.middleware.authentication import AuthenticationMiddleware
-from starlette.middleware.cors import CORSMiddleware
 from starlette.requests import ClientDisconnect
 from starlette.responses import HTMLResponse
 
-from nucliadb.common.context.fastapi import get_app_context, set_app_context
 from nucliadb.writer import API_PREFIX
 from nucliadb.writer.api.v1.router import api as api_v1
-from nucliadb.writer.lifecycle import finalize, initialize
+from nucliadb.writer.lifecycle import lifespan
 from nucliadb_telemetry import errors
 from nucliadb_telemetry.fastapi.utils import (
     client_disconnect_handler,
     global_exception_handler,
 )
-from nucliadb_utils import const
 from nucliadb_utils.authentication import NucliaCloudAuthenticationBackend
 from nucliadb_utils.fastapi.openapi import extend_openapi
 from nucliadb_utils.fastapi.versioning import VersionedFastAPI
-from nucliadb_utils.settings import http_settings, running_settings
-from nucliadb_utils.utilities import has_feature
+from nucliadb_utils.settings import running_settings
 
 middleware = []
 
-if has_feature(const.Features.CORS_MIDDLEWARE, default=False):
-    middleware.append(
-        Middleware(
-            CORSMiddleware,
-            allow_origins=http_settings.cors_origins,
-            allow_methods=["*"],
-            # Authorization will be exluded from * in the future, (CORS non-wildcard request-header).
-            # Browsers already showing deprecation notices, so it needs to be specified explicitly
-            allow_headers=["*", "Authorization"],
-        )
-    )
-
-middleware.extend(
-    [Middleware(AuthenticationMiddleware, backend=NucliaCloudAuthenticationBackend())]
-)
-
+middleware.extend([Middleware(AuthenticationMiddleware, backend=NucliaCloudAuthenticationBackend())])
 
-errors.setup_error_handling(pkg_resources.get_distribution("nucliadb").version)
 
-on_startup = [initialize]
-on_shutdown = [finalize]
+errors.setup_error_handling(importlib.metadata.distribution("nucliadb").version)
 
 fastapi_settings = dict(
     debug=running_settings.debug,
     middleware=middleware,
-    on_startup=on_startup,
-    on_shutdown=on_shutdown,
+    lifespan=lifespan,
     exception_handlers={
         Exception: global_exception_handler,
         ClientDisconnect: client_disconnect_handler,
@@ -102,18 +79,4 @@ def create_application() -> FastAPI:
     # Use raw starlette routes to avoid unnecessary overhead
     application.add_route("/", homepage)
 
-    set_app_context(application)
-    maybe_configure_back_pressure(application)
     return application
-
-
-def maybe_configure_back_pressure(application: FastAPI):
-    from nucliadb.writer.back_pressure import start_materializer, stop_materializer
-    from nucliadb.writer.settings import back_pressure_settings
-    from nucliadb_utils.settings import is_onprem_nucliadb
-
-    if back_pressure_settings.enabled and not is_onprem_nucliadb():
-        context = get_app_context(application)
-        start_materializer_with_context = functools.partial(start_materializer, context)
-        application.add_event_handler("startup", start_materializer_with_context)
-        application.add_event_handler("shutdown", stop_materializer)

nucliadb/writer/back_pressure.py

@@ -28,7 +28,6 @@ from typing import Optional
 from async_lru import alru_cache
 from cachetools import TTLCache
 from fastapi import HTTPException, Request
-from nucliadb_protos.writer_pb2 import ShardObject
 
 from nucliadb.common import datamanagers
 from nucliadb.common.cluster.manager import get_index_nodes
@@ -37,6 +36,7 @@ from nucliadb.common.context.fastapi import get_app_context
 from nucliadb.common.http_clients.processing import ProcessingHTTPClient
 from nucliadb.writer import logger
 from nucliadb.writer.settings import back_pressure_settings as settings
+from nucliadb_protos.writer_pb2 import ShardObject
 from nucliadb_telemetry import metrics
 from nucliadb_utils import const
 from nucliadb_utils.nats import NatsConnectionManager
@@ -112,9 +112,7 @@ def cached_back_pressure(kbid: str, resource_uuid: Optional[str] = None):
     if data is not None:
         try_after = data.try_after
         back_pressure_type = data.type
-        RATE_LIMITED_REQUESTS_COUNTER.inc(
-            {"type": back_pressure_type, "cached": "true"}
-        )
+        RATE_LIMITED_REQUESTS_COUNTER.inc({"type": back_pressure_type, "cached": "true"})
         logger.info(
             "Back pressure applied from cache",
             extra={
@@ -137,9 +135,7 @@ def cached_back_pressure(kbid: str, resource_uuid: Optional[str] = None):
     except BackPressureException as exc:
         try_after = exc.data.try_after
         back_pressure_type = exc.data.type
-        RATE_LIMITED_REQUESTS_COUNTER.inc(
-            {"type": back_pressure_type, "cached": "false"}
-        )
+        RATE_LIMITED_REQUESTS_COUNTER.inc({"type": back_pressure_type, "cached": "false"})
         _cache.set(cache_key, exc.data)
         raise HTTPException(
             status_code=429,
@@ -248,14 +244,10 @@ class Materializer:
                 for node in get_index_nodes():
                     try:
                         with back_pressure_observer({"type": "get_indexing_pending"}):
-                            self.indexing_pending[node.id] = (
-                                await get_nats_consumer_pending_messages(
-                                    self.nats_manager,
-                                    stream=const.Streams.INDEX.name,
-                                    consumer=const.Streams.INDEX.group.format(
-                                        node=node.id
-                                    ),
-                                )
+                            self.indexing_pending[node.id] = await get_nats_consumer_pending_messages(
+                                self.nats_manager,
+                                stream=const.Streams.INDEX.name,
+                                consumer=const.Streams.INDEX.group.format(node=node.id),
                             )
                     except Exception:
                         logger.exception(
@@ -336,9 +328,7 @@ def get_materializer() -> Materializer:
     return MATERIALIZER
 
 
-async def maybe_back_pressure(
-    request: Request, kbid: str, resource_uuid: Optional[str] = None
-) -> None:
+async def maybe_back_pressure(request: Request, kbid: str, resource_uuid: Optional[str] = None) -> None:
     """
     This function does system checks to see if we need to put back pressure on writes.
     In that case, a HTTP 429 will be raised with the estimated time to try again.
@@ -348,9 +338,7 @@ async def maybe_back_pressure(
     await back_pressure_checks(request, kbid, resource_uuid)
 
 
-async def back_pressure_checks(
-    request: Request, kbid: str, resource_uuid: Optional[str] = None
-):
+async def back_pressure_checks(request: Request, kbid: str, resource_uuid: Optional[str] = None):
     """
     Will raise a 429 if back pressure is needed:
     - If the processing engine is behind.
@@ -361,9 +349,7 @@ async def back_pressure_checks(
     materializer = get_materializer()
     with cached_back_pressure(kbid, resource_uuid):
         check_ingest_behind(materializer.get_ingest_pending())
-        await check_indexing_behind(
-            context, kbid, resource_uuid, materializer.get_indexing_pending()
-        )
+        await check_indexing_behind(context, kbid, resource_uuid, materializer.get_indexing_pending())
         await check_processing_behind(materializer, kbid)
 
 
@@ -418,9 +404,7 @@ async def check_indexing_behind(
 
     # Get nodes that are involved in the indexing of the request
     if resource_uuid is not None:
-        nodes_to_check = await get_nodes_for_resource_shard(
-            context, kbid, resource_uuid
-        )
+        nodes_to_check = await get_nodes_for_resource_shard(context, kbid, resource_uuid)
     else:
         nodes_to_check = await get_nodes_for_kb_active_shards(context, kbid)
 
@@ -488,9 +472,7 @@ def estimate_try_after(rate: float, pending: int, max_wait: int) -> datetime:
 
 
 @alru_cache(maxsize=1024, ttl=60 * 15)
-async def get_nodes_for_kb_active_shards(
-    context: ApplicationContext, kbid: str
-) -> list[str]:
+async def get_nodes_for_kb_active_shards(context: ApplicationContext, kbid: str) -> list[str]:
     with back_pressure_observer({"type": "get_kb_active_shard"}):
         active_shard = await get_kb_active_shard(context, kbid)
     if active_shard is None:
@@ -521,20 +503,16 @@ async def get_nats_consumer_pending_messages(
     return consumer_info.num_pending
 
 
-async def get_kb_active_shard(
-    context: ApplicationContext, kbid: str
-) -> Optional[ShardObject]:
-    async with context.kv_driver.transaction() as txn:
+async def get_kb_active_shard(context: ApplicationContext, kbid: str) -> Optional[ShardObject]:
+    async with context.kv_driver.transaction(read_only=True) as txn:
         return await context.shard_manager.get_current_active_shard(txn, kbid)
 
 
 async def get_resource_shard(
     context: ApplicationContext, kbid: str, resource_uuid: str
 ) -> Optional[ShardObject]:
-    async with datamanagers.with_transaction(read_only=True) as txn:
-        shard_id = await datamanagers.resources.get_resource_shard_id(
-            txn, kbid=kbid, rid=resource_uuid
-        )
+    async with datamanagers.with_ro_transaction() as txn:
+        shard_id = await datamanagers.resources.get_resource_shard_id(txn, kbid=kbid, rid=resource_uuid)
         if shard_id is None:
             # Resource does not exist
             logger.debug(

nucliadb/writer/exceptions.py

@@ -19,10 +19,6 @@
 #
 
 
-class ConflictError(Exception):
-    pass
-
-
 class ResourceNotFound(Exception):
     pass