lfss 0.8.4__tar.gz → 0.9.1__tar.gz

{lfss-0.8.4 → lfss-0.9.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.8.4
+Version: 0.9.1
 Summary: Lightweight file storage service
 Home-page: https://github.com/MenxLi/lfss
-Author: li, mengxun
-Author-email: limengxun45@outlook.com
+Author: li_mengxun
+Author-email: limengxun45@outlookc.com
 Requires-Python: >=3.10
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -32,6 +32,7 @@ My experiment on a lightweight and high-performance file/object storage service.
 - Pagination and sorted file listing for vast number of files.  
 - High performance: high concurrency, near-native speed on stress tests.
 - Support range requests, so you can stream large files / resume download.
+- WebDAV compatible ([NOTE](./docs/Webdav.md)).
 
 It stores small files and metadata in sqlite, large files in the filesystem.  
 Tested on 2 million files, and it is still fast.
@@ -53,7 +54,11 @@ lfss-panel --open
 Or, you can start a web server at `/frontend` and open `index.html` in your browser. 
 
 The API usage is simple, just `GET`, `PUT`, `DELETE` to the `/<username>/file/url` path.  
-Authentication via `Authorization` header with the value `Bearer <token>`, or through the `token` query parameter.  
+The authentication can be acheived through one of the following methods:
+1. `Authorization` header with the value `Bearer sha256(<username><password>)`.
+2. `token` query parameter with the value `sha256(<username><password>)`.
+3. HTTP Basic Authentication with the username and password. 
+
 You can refer to `frontend` as an application example, `lfss/api/connector.py` for more APIs. 
 
 By default, the service exposes all files to the public for `GET` requests, 

{lfss-0.8.4 → lfss-0.9.1}/Readme.md

@@ -9,6 +9,7 @@ My experiment on a lightweight and high-performance file/object storage service.
 - Pagination and sorted file listing for vast number of files.  
 - High performance: high concurrency, near-native speed on stress tests.
 - Support range requests, so you can stream large files / resume download.
+- WebDAV compatible ([NOTE](./docs/Webdav.md)).
 
 It stores small files and metadata in sqlite, large files in the filesystem.  
 Tested on 2 million files, and it is still fast.
@@ -30,7 +31,11 @@ lfss-panel --open
 Or, you can start a web server at `/frontend` and open `index.html` in your browser. 
 
 The API usage is simple, just `GET`, `PUT`, `DELETE` to the `/<username>/file/url` path.  
-Authentication via `Authorization` header with the value `Bearer <token>`, or through the `token` query parameter.  
+The authentication can be acheived through one of the following methods:
+1. `Authorization` header with the value `Bearer sha256(<username><password>)`.
+2. `token` query parameter with the value `sha256(<username><password>)`.
+3. HTTP Basic Authentication with the username and password. 
+
 You can refer to `frontend` as an application example, `lfss/api/connector.py` for more APIs. 
 
 By default, the service exposes all files to the public for `GET` requests, 

lfss-0.9.1/docs/Permission.md

@@ -0,0 +1,58 @@
+
+# Permission System
+There are two user roles in the system: Admin and Normal User ("users" are like "buckets" to some extent).  
+A user have all permissions of the files and subpaths under its path (starting with `/<user>/`).  
+Admins have all permissions of all files and paths.
+
+> **path** ends with `/` and **file** does not end with `/`.
+
+## Peers
+The user can have multiple peer users. The peer user can have read or write access to the user's path, depending on the access level set when adding the peer user.  
+The peer user can list the files under the user's path.  
+If the peer user only has read access (peer-r), then the peer user can only `GET` files under the user's path.  
+If the peer user has write access (peer-w), then the peer user can `GET`/`PUT`/`POST`/`DELETE` files under the user's path.  
+
+## Ownership
+A file is owned by the user who created it, may not necessarily be the user under whose path the file is stored (admin/write-peer can create files under any user's path).
+
+# Non-peer and public access
+
+**NOTE:** below discussion is based on the assumption that the user is not a peer of the path owner, or is guest user (public access).
+
+## File access with `GET` permission
+
+### File access
+For accessing file content, the user must have `GET` permission of the file, which is determined by the `permission` field of both the owner and the file.   
+
+There are four types of permissions: `unset`, `public`, `protected`, `private`.
+Non-admin users can access files based on:   
+
+- If the file is `public`, then all users can access it.
+- If the file is `protected`, then only the logged-in user can access it.  
+- If the file is `private`, then only the owner can access it.
+- If the file is `unset`, then the file's permission is inherited from the owner's permission.
+- If both the owner and the file have `unset` permission, then the file is `public`.
+
+## File creation with `PUT`/`POST` permission
+`PUT`/`POST` permission is not allowed for non-peer users.
+
+## File `DELETE` and moving permissions
+- Non-login user don't have `DELETE`/move permission.
+- Every user can have `DELETE` permission that they own.
+- User can move files if they have write access to the destination path.
+
+## Path-listing
+Path-listing is not allowed for these users.
+
+# Summary
+
+| Permission | Admin | User | Peer-r | Peer-w | Owner (not the user) | Non-peer user / Guest  |
+|------------|-------|------|--------|--------|----------------------|------------------------|
+| GET        | Yes   | Yes  | Yes    | Yes    | Yes                  | Depends on file        |
+| PUT/POST   | Yes   | Yes  | No     | Yes    | Yes                  | No                     |
+| DELETE file| Yes   | Yes  | No     | Yes    | Yes                  | No                     | 
+| DELETE path| Yes   | Yes  | No     | Yes    | N/A                  | No                     | 
+| move       | Yes   | Yes  | No     | Yes    | Dep. on destination  | No                     |
+| list       | Yes   | Yes  | Yes    | Yes    | No if not peer       | No                     |
+
+> Capitilized methods are HTTP methods, N/A means not applicable.

lfss-0.9.1/docs/Webdav.md

@@ -0,0 +1,22 @@
+# WebDAV
+
+It is convinient to make LFSS WebDAV compatible, because they both use HTTP `GET`, `PUT`, `DELETE` methods to interact with files.
+
+However, WebDAV utilize more HTTP methods, 
+which are disabled by default in LFSS, because they may not be supported by many middlewares or clients.   
+
+The WebDAV support can be enabled by setting the `LFSS_WEBDAV` environment variable to `1`. 
+i.e. 
+```sh
+LFSS_WEBDAV=1 lfss-serve
+```
+Please note:
+1. **WebDAV support is experimental, and is currently not well-tested.**
+2. LFSS not allow creating files in the root directory, however some client such as [Finder](https://sabre.io/dav/clients/finder/) will try to create files in the root directory. Thus, it is safer to mount the user directory only, e.g. `http://localhost:8000/<username>/`.
+3. LFSS not allow directory creation, instead it creates directoy implicitly when a file is uploaded to a non-exist directory. 
+   i.e. `PUT http://localhost:8000/<username>/dir/file.txt` will create the `dir` directory if it does not exist. 
+   However, the WebDAV `MKCOL` method requires the directory to be created explicitly, so WebDAV `MKCOL` method instead create a decoy file on the path (`.lfss-keep`), and hide the file from the file listing by `PROPFIND` method. 
+   This leads to: 
+   1) You may see a `.lfss-keep` file in the directory with native file listing (e.g. `/_api/list-files`), but it is hidden in WebDAV clients.
+   2) The directory may be deleted if there is no file in it and the `.lfss-keep` file is not created by WebDAV client.  
+

{lfss-0.8.4 → lfss-0.9.1}/frontend/api.js

@@ -45,6 +45,17 @@ export const permMap = {
     3: 'private'
 }
 
+async function fmtFailedResponse(res){
+    const raw = await res.text();
+    const json = raw ? JSON.parse(raw) : {};
+    const txt = JSON.stringify(json.detail || json || "No message");
+    const maxWords = 32;
+    if (txt.length > maxWords){
+        return txt.slice(0, maxWords) + '...';
+    }
+    return txt;
+}
+
 export default class Connector {
 
     constructor(){
@@ -79,7 +90,7 @@ export default class Connector {
             body: fileBytes
         });
         if (res.status != 200 && res.status != 201){
-            throw new Error(`Failed to upload file, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to upload file, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
         return (await res.json()).url;
     }
@@ -111,7 +122,7 @@ export default class Connector {
         });
                 
         if (res.status != 200 && res.status != 201){
-            throw new Error(`Failed to upload file, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to upload file, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
         return (await res.json()).url;
     }
@@ -133,7 +144,7 @@ export default class Connector {
             body: JSON.stringify(data)
         });
         if (res.status != 200 && res.status != 201){
-            throw new Error(`Failed to upload object, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to upload object, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
         return (await res.json()).url;
     }
@@ -147,7 +158,7 @@ export default class Connector {
             }, 
         });
         if (res.status == 200) return;
-        throw new Error(`Failed to delete file, status code: ${res.status}, message: ${await res.json()}`);
+        throw new Error(`Failed to delete file, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
     }
 
     /**
@@ -211,7 +222,7 @@ export default class Connector {
             },
         });
         if (res.status != 200){
-            throw new Error(`Failed to count files, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to count files, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
         return (await res.json()).count;
     }
@@ -250,7 +261,7 @@ export default class Connector {
             },
         });
         if (res.status != 200){
-            throw new Error(`Failed to list files, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to list files, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
         return await res.json();
     }
@@ -270,7 +281,7 @@ export default class Connector {
             },
         });
         if (res.status != 200){
-            throw new Error(`Failed to count directories, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to count directories, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
         return (await res.json()).count;
     }
@@ -309,7 +320,7 @@ export default class Connector {
             },
         });
         if (res.status != 200){
-            throw new Error(`Failed to list directories, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to list directories, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
         return await res.json();
     }
@@ -347,7 +358,7 @@ export default class Connector {
             },
         });
         if (res.status != 200){
-            throw new Error(`Failed to set permission, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to set permission, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
     }
 
@@ -369,7 +380,7 @@ export default class Connector {
             },
         });
         if (res.status != 200){
-            throw new Error(`Failed to move file, status code: ${res.status}, message: ${await res.json()}`);
+            throw new Error(`Failed to move file, status code: ${res.status}, message: ${await fmtFailedResponse(res)}`);
         }
     }
 

{lfss-0.8.4 → lfss-0.9.1}/lfss/api/__init__.py

@@ -1,9 +1,9 @@
 import os, time, pathlib
 from threading import Lock
 from .connector import Connector
-from ..src.datatype import FileRecord
-from ..src.utils import decode_uri_compnents
-from ..src.bounded_pool import BoundedThreadPoolExecutor
+from ..eng.datatype import FileRecord
+from ..eng.utils import decode_uri_compnents
+from ..eng.bounded_pool import BoundedThreadPoolExecutor
 
 def upload_file(
     connector: Connector, 

{lfss-0.8.4 → lfss-0.9.1}/lfss/api/connector.py

@@ -5,26 +5,32 @@ import requests
 import requests.adapters
 import urllib.parse
 from tempfile import SpooledTemporaryFile
-from lfss.src.error import PathNotFoundError
-from lfss.src.datatype import (
+from lfss.eng.error import PathNotFoundError
+from lfss.eng.datatype import (
     FileReadPermission, FileRecord, DirectoryRecord, UserRecord, PathContents, 
     FileSortKey, DirSortKey
     )
-from lfss.src.utils import ensure_uri_compnents
+from lfss.eng.utils import ensure_uri_compnents
 
 _default_endpoint = os.environ.get('LFSS_ENDPOINT', 'http://localhost:8000')
 _default_token = os.environ.get('LFSS_TOKEN', '')
 
 class Connector:
     class Session:
-        def __init__(self, connector: Connector, pool_size: int = 10):
+        def __init__(
+            self, connector: Connector, pool_size: int = 10, 
+            retry: int = 1, backoff_factor: float = 0.5, status_forcelist: list[int] = [503]
+            ):
             self.connector = connector
             self.pool_size = pool_size
+            self.retry_adapter = requests.adapters.Retry(
+                total=retry, backoff_factor=backoff_factor, status_forcelist=status_forcelist, 
+            )
         def open(self):
             self.close()
             if self.connector._session is None:
                 s = requests.Session()
-                adapter = requests.adapters.HTTPAdapter(pool_connections=self.pool_size, pool_maxsize=self.pool_size)
+                adapter = requests.adapters.HTTPAdapter(pool_connections=self.pool_size, pool_maxsize=self.pool_size, max_retries=self.retry_adapter)
                 s.mount('http://', adapter)
                 s.mount('https://', adapter)
                 self.connector._session = s
@@ -48,9 +54,9 @@ class Connector:
         }
         self._session: Optional[requests.Session] = None
     
-    def session(self, pool_size: int = 10):
+    def session( self, pool_size: int = 10, **kwargs):
         """ avoid creating a new session for each request.  """
-        return self.Session(self, pool_size)
+        return self.Session(self, pool_size, **kwargs)
     
     def _fetch_factory(
         self, method: Literal['GET', 'POST', 'PUT', 'DELETE'], 

{lfss-0.8.4 → lfss-0.9.1}/lfss/cli/balance.py

@@ -2,14 +2,14 @@
 Balance the storage by ensuring that large file thresholds are met.
 """
 
-from lfss.src.config import LARGE_BLOB_DIR, LARGE_FILE_BYTES
+from lfss.eng.config import LARGE_BLOB_DIR, LARGE_FILE_BYTES
 import argparse, time, itertools
 from functools import wraps
 from asyncio import Semaphore
 import aiofiles, asyncio
 import aiofiles.os
-from lfss.src.database import transaction, unique_cursor
-from lfss.src.connection_pool import global_entrance
+from lfss.eng.database import transaction, unique_cursor
+from lfss.eng.connection_pool import global_entrance
 
 sem: Semaphore
 

{lfss-0.8.4 → lfss-0.9.1}/lfss/cli/cli.py

@@ -1,19 +1,14 @@
 from pathlib import Path
 import argparse, typing
 from lfss.api import Connector, upload_directory, upload_file, download_file, download_directory
-from lfss.src.datatype import FileReadPermission, FileSortKey, DirSortKey
-from lfss.src.utils import decode_uri_compnents
+from lfss.eng.datatype import FileReadPermission, FileSortKey, DirSortKey
+from lfss.eng.utils import decode_uri_compnents
 from . import catch_request_error, line_sep
 
 def parse_permission(s: str) -> FileReadPermission:
-    if s.lower() == "public":
-        return FileReadPermission.PUBLIC
-    if s.lower() == "protected":
-        return FileReadPermission.PROTECTED
-    if s.lower() == "private":
-        return FileReadPermission.PRIVATE
-    if s.lower() == "unset":
-        return FileReadPermission.UNSET
+    for p in FileReadPermission:
+        if p.name.lower() == s.lower():
+            return p
     raise ValueError(f"Invalid permission {s}")
 
 def parse_arguments():

{lfss-0.8.4 → lfss-0.9.1}/lfss/cli/panel.py

@@ -2,6 +2,7 @@
 import uvicorn
 from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
 
 import argparse
 from contextlib import asynccontextmanager
@@ -27,6 +28,13 @@ assert (__frontend_dir / "index.html").exists(), "Frontend panel not found"
 
 app = FastAPI(lifespan=app_lifespan)
 app.mount("/", StaticFiles(directory=__frontend_dir, html=True), name="static")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
 def main():
     parser = argparse.ArgumentParser(description="Serve frontend panel")

{lfss-0.8.4 → lfss-0.9.1}/lfss/cli/serve.py

@@ -1,7 +1,9 @@
 import argparse
 from uvicorn import Config, Server
 from uvicorn.config import LOGGING_CONFIG
-from ..src.server import *
+from ..eng.config import DEBUG_MODE
+from ..svc.app_base import logger
+from ..svc.app import app
 
 def main():
     parser = argparse.ArgumentParser()
@@ -19,7 +21,7 @@ def main():
         app=app,
         host=args.host,
         port=args.port,
-        access_log=False,
+        access_log=True if DEBUG_MODE else False,
         workers=args.workers,
         log_config=default_logging_config
     )

{lfss-0.8.4 → lfss-0.9.1}/lfss/cli/user.py

@@ -1,9 +1,16 @@
 import argparse, asyncio, os
 from contextlib import asynccontextmanager
 from .cli import parse_permission, FileReadPermission
-from ..src.utils import parse_storage_size, fmt_storage_size
-from ..src.database import Database, FileReadPermission, transaction, UserConn, unique_cursor, FileConn
-from ..src.connection_pool import global_entrance
+from ..eng.utils import parse_storage_size, fmt_storage_size
+from ..eng.datatype import AccessLevel
+from ..eng.database import Database, FileReadPermission, transaction, UserConn, unique_cursor, FileConn
+from ..eng.connection_pool import global_entrance
+
+def parse_access_level(s: str) -> AccessLevel:
+    for p in AccessLevel:
+        if p.name.lower() == s.lower():
+            return p
+    raise ValueError(f"Invalid access level {s}")
 
 @global_entrance(1)
 async def _main():
@@ -31,11 +38,16 @@ async def _main():
     sp_set.add_argument('-a', '--admin', type=parse_bool, default=None)
     sp_set.add_argument('--permission', type=parse_permission, default=None)
     sp_set.add_argument('--max-storage', type=parse_storage_size, default=None)
-    
+
     sp_list = sp.add_parser('list')
     sp_list.add_argument("username", nargs='*', type=str, default=None)
     sp_list.add_argument("-l", "--long", action="store_true")
     
+    sp_peer = sp.add_parser('set-peer')
+    sp_peer.add_argument('src_username', type=str)
+    sp_peer.add_argument('dst_username', type=str)
+    sp_peer.add_argument('--level', type=parse_access_level, default=AccessLevel.READ, help="Access level")
+    
     args = parser.parse_args()
     db = await Database().init()
 
@@ -72,6 +84,16 @@ async def _main():
             assert user is not None
             print('User updated, credential:', user.credential)
     
+    if args.subparser_name == 'set-peer':
+        async with get_uconn() as uconn:
+            src_user = await uconn.get_user(args.src_username)
+            dst_user = await uconn.get_user(args.dst_username)
+            if src_user is None or dst_user is None:
+                print('User not found')
+                exit(1)
+            await uconn.set_peer_level(src_user.id, dst_user.id, args.level)
+            print(f"Peer set: [{src_user.username}] now have [{args.level.name}] access to [{dst_user.username}]")
+    
     if args.subparser_name == 'list':
         async with get_uconn() as uconn:
             term_width = os.get_terminal_size().columns
@@ -86,6 +108,11 @@ async def _main():
                         user_size_used = await fconn.user_size(user.id)
                     print('- Credential: ', user.credential)
                     print(f'- Storage: {fmt_storage_size(user_size_used)} / {fmt_storage_size(user.max_storage)}')
+                    for p in AccessLevel:
+                        if p > AccessLevel.NONE:
+                            usernames = [x.username for x in await uconn.list_peer_users(user.id, p)]
+                            if usernames:
+                                print(f'- Peers [{p.name}]: {", ".join(usernames)}')
         
 def main():
     asyncio.run(_main())

{lfss-0.8.4 → lfss-0.9.1}/lfss/cli/vacuum.py

@@ -2,17 +2,17 @@
 Vacuum the database and external storage to ensure that the storage is consistent and minimal.
 """
 
-from lfss.src.config import LARGE_BLOB_DIR
+from lfss.eng.config import LARGE_BLOB_DIR
 import argparse, time
 from functools import wraps
 from asyncio import Semaphore
 import aiofiles, asyncio
 import aiofiles.os
 from contextlib import contextmanager
-from lfss.src.database import transaction, unique_cursor
-from lfss.src.stat import RequestDB
-from lfss.src.utils import now_stamp
-from lfss.src.connection_pool import global_entrance
+from lfss.eng.database import transaction, unique_cursor
+from lfss.svc.request_log import RequestDB
+from lfss.eng.utils import now_stamp
+from lfss.eng.connection_pool import global_entrance
 
 sem: Semaphore
 

{lfss-0.8.4/lfss/src → lfss-0.9.1/lfss/eng}/config.py

@@ -21,6 +21,7 @@ else:
 MAX_MEM_FILE_BYTES = 128 * 1024 * 1024   # 128MB
 MAX_BUNDLE_BYTES = 512 * 1024 * 1024   # 512MB
 CHUNK_SIZE = 1024 * 1024   # 1MB chunks for streaming (on large files)
+DEBUG_MODE = os.environ.get('LFSS_DEBUG', '0') == '1'
 
 THUMB_DB = DATA_HOME / 'thumbs.db'
 THUMB_SIZE = (48, 48)

{lfss-0.8.4/lfss/src → lfss-0.9.1/lfss/eng}/connection_pool.py

@@ -8,6 +8,7 @@ from functools import wraps
 from typing import Callable, Awaitable
 
 from .log import get_logger
+from .error import DatabaseLockedError
 from .config import DATA_HOME
 
 async def execute_sql(conn: aiosqlite.Connection | aiosqlite.Cursor, name: str):
@@ -28,7 +29,7 @@ async def get_connection(read_only: bool = False) -> aiosqlite.Connection:
 
     conn = await aiosqlite.connect(
         get_db_uri(DATA_HOME / 'index.db', read_only=read_only), 
-        timeout = 60, uri = True
+        timeout = 20, uri = True
         )
     async with conn.cursor() as c:
         await c.execute(
@@ -46,7 +47,7 @@ class SqlConnection:
 
 class SqlConnectionPool:
     _r_sem: Semaphore
-    _w_sem: Lock | Semaphore
+    _w_sem: Lock
     def __init__(self):
         self._readers: list[SqlConnection] = []
         self._writer: None | SqlConnection = None
@@ -65,6 +66,17 @@ class SqlConnectionPool:
             self._readers.append(SqlConnection(conn))
         self._r_sem = Semaphore(n_read)
     
+    def status(self):   # debug
+        assert self._writer
+        assert len(self._readers) == self.n_read
+        n_free_readers = sum([1 for c in self._readers if c.is_available])
+        n_free_writers = 1 if self._writer.is_available else 0
+        n_free_r_sem = self._r_sem._value
+        n_free_w_sem = 1 - self._w_sem.locked()
+        assert n_free_readers == n_free_r_sem, f"{n_free_readers} != {n_free_r_sem}"
+        assert n_free_writers == n_free_w_sem, f"{n_free_writers} != {n_free_w_sem}"
+        return f"Readers: {n_free_readers}/{self.n_read}, Writers: {n_free_writers}/{1}"
+    
     @property
     def n_read(self):
         return len(self._readers)
@@ -142,6 +154,10 @@ async def unique_cursor(is_write: bool = False):
             connection_obj = await g_pool.get()
             try:
                 yield await connection_obj.conn.cursor()
+            except Exception as e:
+                if 'database is locked' in str(e):
+                    raise DatabaseLockedError from e
+                raise e
             finally:
                 await g_pool.release(connection_obj)
     else:
@@ -149,10 +165,13 @@ async def unique_cursor(is_write: bool = False):
             connection_obj = await g_pool.get(w=True)
             try:
                 yield await connection_obj.conn.cursor()
+            except Exception as e:
+                if 'database is locked' in str(e):
+                    raise DatabaseLockedError from e
+                raise e
             finally:
                 await g_pool.release(connection_obj)
 
-# todo: add exclusive transaction option
 @asynccontextmanager
 async def transaction():
     async with unique_cursor(is_write=True) as cur: