lfss 0.8.4__py3-none-any.whl → 0.9.0__py3-none-any.whl

docs/Permission.md

@@ -1,12 +1,25 @@
 
 # Permission System
-There are two user roles in the system: Admin and Normal User ("users" are like "buckets" to some extent).
+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 can create files under any user's path).
+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
-The `GET` is used to access the file (if path is not ending with `/`), or to list the files under a path (if path is ending with `/`).  
 
 ### 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.   
@@ -20,27 +33,26 @@ Non-admin users can access files based on:
 - 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`.
 
-### Meta-data access
-- Non-login users can't access any file-meta.
-- All users can access the file-meta of files under their own path.
-- For files under other users' path, the file-meta is determined in a way same as file access.
-- Admins can access the path-meta of all users.
-- All users can access the path-meta of their own path.
-
-### Path-listing
-- Non-login users cannot list any files.
-- All users can list the files under their own path 
-- Admins can list the files under other users' path. 
-
-## File creation with `PUT` permission
-The `PUT` is used to create a file. 
-- Non-login user don't have `PUT` permission.  
-- Every user can have `PUT` permission of files under its own `/<user>/` path.  
-- The admin can have `PUT` permission of files of all users.
-
-## `DELETE` and moving permissions
+## 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`/move permission that they own.
-- The admin can have `DELETE` permission of files of all users
-(The admin can't move files of other users, because move does not change the owner of the file. 
-If move is allowed, then its equivalent to create file on behalf of other users.)
+- 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.

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/api/connector.py

@@ -17,14 +17,20 @@ _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/cli/cli.py

@@ -6,14 +6,9 @@ from lfss.src.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/cli/user.py

@@ -2,9 +2,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.datatype import AccessLevel
 from ..src.database import Database, FileReadPermission, transaction, UserConn, unique_cursor, FileConn
 from ..src.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():
     parser = argparse.ArgumentParser()
@@ -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/sql/init.sql

@@ -27,6 +27,15 @@ CREATE TABLE IF NOT EXISTS usize (
     size INTEGER DEFAULT 0
 );
 
+CREATE TABLE IF NOT EXISTS upeer (
+    src_user_id INTEGER NOT NULL,
+    dst_user_id INTEGER NOT NULL,
+    access_level INTEGER DEFAULT 0,
+    PRIMARY KEY(src_user_id, dst_user_id),
+    FOREIGN KEY(src_user_id) REFERENCES user(id),
+    FOREIGN KEY(dst_user_id) REFERENCES user(id)
+); 
+
 CREATE INDEX IF NOT EXISTS idx_fmeta_url ON fmeta(url);
 
 CREATE INDEX IF NOT EXISTS idx_user_username ON user(username);

lfss/src/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:

lfss/src/database.py

@@ -1,5 +1,6 @@
 
-from typing import Optional, Literal, AsyncIterable
+from typing import Optional, Literal, AsyncIterable, overload
+from contextlib import asynccontextmanager
 from abc import ABC
 
 import urllib.parse
@@ -12,7 +13,8 @@ import mimetypes, mimesniff
 
 from .connection_pool import execute_sql, unique_cursor, transaction
 from .datatype import (
-    UserRecord, FileReadPermission, FileRecord, DirectoryRecord, PathContents, 
+    UserRecord, AccessLevel, 
+    FileReadPermission, FileRecord, DirectoryRecord, PathContents, 
     FileSortKey, DirSortKey, isValidFileSortKey, isValidDirSortKey
     )
 from .config import LARGE_BLOB_DIR, CHUNK_SIZE, LARGE_FILE_BYTES, MAX_MEM_FILE_BYTES
@@ -57,11 +59,16 @@ class UserConn(DBObjectBase):
         if res is None: return None
         return self.parse_record(res)
     
-    async def get_user_by_id(self, user_id: int) -> Optional[UserRecord]:
+    @overload
+    async def get_user_by_id(self, user_id: int, throw: Literal[True]) -> UserRecord: ...
+    @overload
+    async def get_user_by_id(self, user_id: int, throw: Literal[False] = False) -> Optional[UserRecord]: ...
+    async def get_user_by_id(self, user_id: int, throw = False) -> Optional[UserRecord]:
         await self.cur.execute("SELECT * FROM user WHERE id = ?", (user_id, ))
         res = await self.cur.fetchone()
-        
-        if res is None: return None
+        if res is None:
+            if throw: raise ValueError(f"User {user_id} not found")
+            return None
         return self.parse_record(res)
     
     async def get_user_by_credential(self, credential: str) -> Optional[UserRecord]:
@@ -122,8 +129,58 @@ class UserConn(DBObjectBase):
         await self.cur.execute("UPDATE user SET last_active = CURRENT_TIMESTAMP WHERE username = ?", (username, ))
     
     async def delete_user(self, username: str):
+        await self.cur.execute("DELETE FROM upeer WHERE src_user_id = (SELECT id FROM user WHERE username = ?) OR dst_user_id = (SELECT id FROM user WHERE username = ?)", (username, username))
         await self.cur.execute("DELETE FROM user WHERE username = ?", (username, ))
         self.logger.info(f"Delete user {username}")
+    
+    async def set_peer_level(self, src_user: int | str, dst_user: int | str, level: AccessLevel):
+        """ src_user can do [AccessLevel] to dst_user """
+        assert int(level) >= AccessLevel.NONE, f"Cannot set alias level to {level}"
+        match (src_user, dst_user):
+            case (int(), int()):
+                await self.cur.execute("INSERT OR REPLACE INTO upeer (src_user_id, dst_user_id, access_level) VALUES (?, ?, ?)", (src_user, dst_user, int(level)))
+            case (str(), str()):
+                await self.cur.execute("INSERT OR REPLACE INTO upeer (src_user_id, dst_user_id, access_level) VALUES ((SELECT id FROM user WHERE username = ?), (SELECT id FROM user WHERE username = ?), ?)", (src_user, dst_user, int(level)))
+            case (str(), int()):
+                await self.cur.execute("INSERT OR REPLACE INTO upeer (src_user_id, dst_user_id, access_level) VALUES ((SELECT id FROM user WHERE username = ?), ?, ?)", (src_user, dst_user, int(level)))
+            case (int(), str()):
+                await self.cur.execute("INSERT OR REPLACE INTO upeer (src_user_id, dst_user_id, access_level) VALUES (?, (SELECT id FROM user WHERE username = ?), ?)", (src_user, dst_user, int(level)))
+            case (_, _):
+                raise ValueError("Invalid arguments")
+    
+    async def query_peer_level(self, src_user_id: int, dst_user_id: int) -> AccessLevel:
+        """ src_user can do [AliasLevel] to dst_user """
+        if src_user_id == dst_user_id:
+            return AccessLevel.ALL
+        await self.cur.execute("SELECT access_level FROM upeer WHERE src_user_id = ? AND dst_user_id = ?", (src_user_id, dst_user_id))
+        res = await self.cur.fetchone()
+        if res is None:
+            return AccessLevel.NONE
+        return AccessLevel(res[0])
+    
+    async def list_peer_users(self, src_user: int | str, level: AccessLevel) -> list[UserRecord]:
+        """
+        List all users that src_user can do [AliasLevel] to, with level >= level, 
+        Note: the returned list does not include src_user and admin users
+        """
+        assert int(level) > AccessLevel.NONE, f"Invalid level, {level}"
+        match src_user:
+            case int():
+                await self.cur.execute("""
+                    SELECT * FROM user WHERE id IN (
+                        SELECT dst_user_id FROM upeer WHERE src_user_id = ? AND access_level >= ?
+                    )
+                """, (src_user, int(level)))
+            case str():
+                await self.cur.execute("""
+                    SELECT * FROM user WHERE id IN (
+                        SELECT dst_user_id FROM upeer WHERE src_user_id = (SELECT id FROM user WHERE username = ?) AND access_level >= ?
+                    )
+                """, (src_user, int(level)))
+            case _:
+                raise ValueError("Invalid arguments")
+        res = await self.cur.fetchall()
+        return [self.parse_record(r) for r in res]
 
 class FileConn(DBObjectBase):
 
@@ -135,10 +192,15 @@ class FileConn(DBObjectBase):
     def parse_record(record) -> FileRecord:
         return FileRecord(*record)
     
-    async def get_file_record(self, url: str) -> Optional[FileRecord]:
+    @overload
+    async def get_file_record(self, url: str, throw: Literal[True]) -> FileRecord: ...
+    @overload
+    async def get_file_record(self, url: str, throw: Literal[False] = False) -> Optional[FileRecord]: ...
+    async def get_file_record(self, url: str, throw = False):
         cursor = await self.cur.execute("SELECT * FROM fmeta WHERE url = ?", (url, ))
         res = await cursor.fetchone()
         if res is None:
+            if throw: raise FileNotFoundError(f"File {url} not found")
             return None
         return self.parse_record(res)
     
@@ -552,7 +614,7 @@ class Database:
             if r is None:
                 raise PathNotFoundError(f"File {url} not found")
             if op_user is not None:
-                if r.owner_id != op_user.id and not op_user.is_admin:
+                if await check_path_permission(url, op_user) < AccessLevel.WRITE:
                     raise PermissionDeniedError(f"Permission denied: {op_user.username} cannot update file {url}")
             await fconn.update_file_record(url, permission=permission)
     
@@ -576,60 +638,70 @@ class Database:
             user_size_used = await fconn_r.user_size(user.id)
 
             f_id = uuid.uuid4().hex
-            async with aiofiles.tempfile.SpooledTemporaryFile(max_size=MAX_MEM_FILE_BYTES) as f:
-                async for chunk in blob_stream:
-                    await f.write(chunk)
-                file_size = await f.tell()
-                if user_size_used + file_size > user.max_storage:
-                    raise StorageExceededError(f"Unable to save file, user {user.username} has storage limit of {user.max_storage}, used {user_size_used}, requested {file_size}")
-                
-                # check mime type
-                if mime_type is None:
-                    mime_type, _ = mimetypes.guess_type(url)
-                if mime_type is None:
-                    await f.seek(0)
-                    mime_type = mimesniff.what(await f.read(1024))
-                if mime_type is None:
-                    mime_type = 'application/octet-stream'
+
+        async with aiofiles.tempfile.SpooledTemporaryFile(max_size=MAX_MEM_FILE_BYTES) as f:
+            async for chunk in blob_stream:
+                await f.write(chunk)
+            file_size = await f.tell()
+            if user_size_used + file_size > user.max_storage:
+                raise StorageExceededError(f"Unable to save file, user {user.username} has storage limit of {user.max_storage}, used {user_size_used}, requested {file_size}")
+            
+            # check mime type
+            if mime_type is None:
+                mime_type, _ = mimetypes.guess_type(url)
+            if mime_type is None:
                 await f.seek(0)
-                
-                if file_size < LARGE_FILE_BYTES:
-                    blob = await f.read()
-                    async with transaction() as w_cur:
-                        fconn_w = FileConn(w_cur)
-                        await fconn_w.set_file_blob(f_id, blob)
-                        await fconn_w.set_file_record(
-                            url, owner_id=user.id, file_id=f_id, file_size=file_size, 
-                            permission=permission, external=False, mime_type=mime_type)
-                
-                else:
-                    async def blob_stream_tempfile():
-                        nonlocal f
-                        while True:
-                            chunk = await f.read(CHUNK_SIZE)
-                            if not chunk: break
-                            yield chunk
-                    await FileConn.set_file_blob_external(f_id, blob_stream_tempfile())
-                    async with transaction() as w_cur:
-                        await FileConn(w_cur).set_file_record(
-                            url, owner_id=user.id, file_id=f_id, file_size=file_size, 
-                            permission=permission, external=True, mime_type=mime_type)
+                mime_type = mimesniff.what(await f.read(1024))
+            if mime_type is None:
+                mime_type = 'application/octet-stream'
+            await f.seek(0)
+            
+            if file_size < LARGE_FILE_BYTES:
+                blob = await f.read()
+                async with transaction() as w_cur:
+                    fconn_w = FileConn(w_cur)
+                    await fconn_w.set_file_blob(f_id, blob)
+                    await fconn_w.set_file_record(
+                        url, owner_id=user.id, file_id=f_id, file_size=file_size, 
+                        permission=permission, external=False, mime_type=mime_type)
+            
+            else:
+                async def blob_stream_tempfile():
+                    nonlocal f
+                    while True:
+                        chunk = await f.read(CHUNK_SIZE)
+                        if not chunk: break
+                        yield chunk
+                await FileConn.set_file_blob_external(f_id, blob_stream_tempfile())
+                async with transaction() as w_cur:
+                    await FileConn(w_cur).set_file_record(
+                        url, owner_id=user.id, file_id=f_id, file_size=file_size, 
+                        permission=permission, external=True, mime_type=mime_type)
         return file_size
 
     async def read_file(self, url: str, start_byte = -1, end_byte = -1) -> AsyncIterable[bytes]:
-        # end byte is exclusive: [start_byte, end_byte)
+        """
+        Read a file from the database.
+        end byte is exclusive: [start_byte, end_byte)
+        """
+        # The implementation is tricky, should not keep the cursor open for too long
         validate_url(url)
         async with unique_cursor() as cur:
             fconn = FileConn(cur)
             r = await fconn.get_file_record(url)
             if r is None:
                 raise FileNotFoundError(f"File {url} not found")
+
             if r.external:
-                ret = fconn.get_file_blob_external(r.file_id, start_byte=start_byte, end_byte=end_byte)
+                _blob_stream = fconn.get_file_blob_external(r.file_id, start_byte=start_byte, end_byte=end_byte)
+                async def blob_stream():
+                    async for chunk in _blob_stream:
+                        yield chunk
             else:
+                blob = await fconn.get_file_blob(r.file_id, start_byte=start_byte, end_byte=end_byte)
                 async def blob_stream():
-                    yield await fconn.get_file_blob(r.file_id, start_byte=start_byte, end_byte=end_byte)
-                ret = blob_stream()
+                    yield blob
+        ret = blob_stream()
         return ret
 
     async def delete_file(self, url: str, op_user: Optional[UserRecord] = None) -> Optional[FileRecord]:
@@ -641,7 +713,8 @@ class Database:
             if r is None:
                 return None
             if op_user is not None:
-                if r.owner_id != op_user.id and not op_user.is_admin:
+                if  r.owner_id != op_user.id and \
+                    await check_path_permission(r.url, op_user, cursor=cur) < AccessLevel.WRITE:
                     # will rollback
                     raise PermissionDeniedError(f"Permission denied: {op_user.username} cannot delete file {url}")
             f_id = r.file_id
@@ -661,7 +734,7 @@ class Database:
             if r is None:
                 raise FileNotFoundError(f"File {old_url} not found")
             if op_user is not None:
-                if r.owner_id != op_user.id:
+                if await check_path_permission(old_url, op_user) < AccessLevel.WRITE:
                     raise PermissionDeniedError(f"Permission denied: {op_user.username} cannot move file {old_url}")
             await fconn.move_file(old_url, new_url)
 
@@ -681,20 +754,14 @@ class Database:
         assert old_url.endswith('/'), "Old path must end with /"
         assert new_url.endswith('/'), "New path must end with /"
 
-        async with transaction() as cur:
-            first_component = new_url.split('/')[0]
-            if not (first_component == op_user.username or op_user.is_admin):
-                raise PermissionDeniedError(f"Permission denied: path must start with {op_user.username}")
-            elif op_user.is_admin:
-                uconn = UserConn(cur)
-                _is_user = await uconn.get_user(first_component)
-                if not _is_user:
-                    raise PermissionDeniedError(f"Invalid path: {first_component} is not a valid username")
-            
-            # check if old path is under user's directory (non-admin)
-            if not old_url.startswith(op_user.username + '/') and not op_user.is_admin:
-                raise PermissionDeniedError(f"Permission denied: {op_user.username} cannot move path {old_url}")
+        async with unique_cursor() as cur:
+            if not (
+                await check_path_permission(old_url, op_user) >= AccessLevel.WRITE and
+                await check_path_permission(new_url, op_user) >= AccessLevel.WRITE
+                ):
+                raise PermissionDeniedError(f"Permission denied: {op_user.username} cannot move path {old_url} to {new_url}")
 
+        async with transaction() as cur:
             fconn = FileConn(cur)
             await fconn.move_path(old_url, new_url, 'overwrite', op_user.id)
 
@@ -718,7 +785,7 @@ class Database:
 
     async def delete_path(self, url: str, op_user: Optional[UserRecord] = None) -> Optional[list[FileRecord]]:
         validate_url(url, is_file=False)
-        from_owner_id = op_user.id if op_user is not None and not op_user.is_admin else None
+        from_owner_id = op_user.id if op_user is not None and not (op_user.is_admin or await check_path_permission(url, op_user) >= AccessLevel.WRITE) else None
 
         async with transaction() as cur:
             fconn = FileConn(cur)
@@ -786,7 +853,15 @@ class Database:
         buffer.seek(0)
         return buffer
 
-def check_user_permission(user: UserRecord, owner: UserRecord, file: FileRecord) -> tuple[bool, str]:
+def check_file_read_permission(user: UserRecord, owner: UserRecord, file: FileRecord) -> tuple[bool, str]:
+    """
+    This does not consider alias level permission,
+    use check_path_permission for alias level permission check first:
+    ```
+    if await check_path_permission(path, user) < AccessLevel.READ:
+        read_allowed, reason = check_file_read_permission(user, owner, file)
+    ```
+    """
     if user.is_admin:
         return True, ""
     
@@ -812,4 +887,47 @@ def check_user_permission(user: UserRecord, owner: UserRecord, file: FileRecord)
     else:
         assert owner.permission == FileReadPermission.PUBLIC or owner.permission == FileReadPermission.UNSET
 
-    return True, ""
+    return True, ""
+
+async def check_path_permission(path: str, user: UserRecord, cursor: Optional[aiosqlite.Cursor] = None) -> AccessLevel:
+    """
+    Check if the user has access to the path. 
+    If the user is admin, the user will have all access.
+    If the path is a file, the user will have all access if the user is the owner.
+    Otherwise, the user will have alias level access w.r.t. the path user.
+    """
+    if user.id == 0:
+        return AccessLevel.GUEST
+    
+    @asynccontextmanager
+    async def this_cur():
+        if cursor is None:
+            async with unique_cursor() as _cur:
+                yield _cur
+        else:
+            yield cursor
+
+    # check if path user exists
+    path_username = path.split('/')[0]
+    async with this_cur() as cur:
+        uconn = UserConn(cur)
+        path_user = await uconn.get_user(path_username)
+    if path_user is None:
+        raise PathNotFoundError(f"Invalid path: {path_username} is not a valid username")
+
+    # check if user is admin
+    if user.is_admin or user.username == path_username:
+        return AccessLevel.ALL
+    
+    # if the path is a file, check if the user is the owner
+    if not path.endswith('/'):
+        async with this_cur() as cur:
+            fconn = FileConn(cur)
+            file = await fconn.get_file_record(path)
+        if file and file.owner_id == user.id:
+            return AccessLevel.ALL
+    
+    # check alias level
+    async with this_cur() as cur:
+        uconn = UserConn(cur)
+        return await uconn.query_peer_level(user.id, path_user.id)

lfss/src/datatype.py

@@ -8,6 +8,13 @@ class FileReadPermission(IntEnum):
     PROTECTED = 2       # accessible by any user
     PRIVATE = 3         # accessible by owner only (including admin)
 
+class AccessLevel(IntEnum):
+    GUEST = -1          # guest, no permission
+    NONE  = 0           # no permission
+    READ  = 1           # read permission
+    WRITE = 2           # write/delete permission
+    ALL   = 10          # all permission, currently same as WRITE
+
 @dataclasses.dataclass
 class UserRecord:
     id: int

lfss/src/error.py

@@ -1,6 +1,9 @@
+import sqlite3
 
 class LFSSExceptionBase(Exception):...
 
+class DatabaseLockedError(LFSSExceptionBase, sqlite3.DatabaseError):...
+
 class PathNotFoundError(LFSSExceptionBase, FileNotFoundError):...
 
 class PermissionDeniedError(LFSSExceptionBase, PermissionError):...

lfss/src/server.py

@@ -16,10 +16,10 @@ from .stat import RequestDB
 from .config import MAX_BUNDLE_BYTES, CHUNK_SIZE
 from .utils import ensure_uri_compnents, format_last_modified, now_stamp, wait_for_debounce_tasks
 from .connection_pool import global_connection_init, global_connection_close, unique_cursor
-from .database import Database, DECOY_USER, check_user_permission, UserConn, FileConn
+from .database import Database, DECOY_USER, check_file_read_permission, check_path_permission, UserConn, FileConn
 from .database import delayed_log_activity, delayed_log_access
 from .datatype import (
-    FileReadPermission, FileRecord, UserRecord, PathContents, 
+    FileReadPermission, FileRecord, UserRecord, PathContents, AccessLevel, 
     FileSortKey, DirSortKey
 )
 from .thumb import get_thumb
@@ -54,6 +54,7 @@ def handle_exception(fn):
             if isinstance(e, FileNotFoundError): raise HTTPException(status_code=404, detail=str(e))
             if isinstance(e, FileExistsError): raise HTTPException(status_code=409, detail=str(e))
             if isinstance(e, TooManyItemsError): raise HTTPException(status_code=400, detail=str(e))
+            if isinstance(e, DatabaseLockedError): raise HTTPException(status_code=503, detail=str(e))
             logger.error(f"Uncaptured error in {fn.__name__}: {e}")
             raise 
     return wrapper
@@ -228,39 +229,37 @@ async def get_file_impl(
     if path == "": path = "/"
     if path.endswith("/"):
         # return file under the path as json
-        async with unique_cursor() as conn:
-            fconn = FileConn(conn)
+        async with unique_cursor() as cur:
+            fconn = FileConn(cur)
             if user.id == 0:
                 raise HTTPException(status_code=401, detail="Permission denied, credential required")
             if thumb:
                 return await emit_thumbnail(path, download, create_time=None)
             
             if path == "/":
+                peer_users = await UserConn(cur).list_peer_users(user.id, AccessLevel.READ)
                 return PathContents(
-                    dirs = await fconn.list_root_dirs(user.username, skim=True) \
+                    dirs = await fconn.list_root_dirs(user.username, *[x.username for x in peer_users], skim=True) \
                         if not user.is_admin else await fconn.list_root_dirs(skim=True),
                     files = []
                 )
 
-            if not path.startswith(f"{user.username}/") and not user.is_admin:
-                raise HTTPException(status_code=403, detail="Permission denied, path must start with username")
+            if not await check_path_permission(path, user, cursor=cur) >= AccessLevel.READ:
+                raise HTTPException(status_code=403, detail="Permission denied")
 
             return await fconn.list_path(path)
     
     # handle file query
-    async with unique_cursor() as conn:
-        fconn = FileConn(conn)
-        file_record = await fconn.get_file_record(path)
-        if not file_record:
-            raise HTTPException(status_code=404, detail="File not found")
-
-        uconn = UserConn(conn)
-        owner = await uconn.get_user_by_id(file_record.owner_id)
-
-    assert owner is not None, "Owner not found"
-    allow_access, reason = check_user_permission(user, owner, file_record)
-    if not allow_access:
-        raise HTTPException(status_code=403, detail=reason)
+    async with unique_cursor() as cur:
+        fconn = FileConn(cur)
+        file_record = await fconn.get_file_record(path, throw=True)
+        uconn = UserConn(cur)
+        owner = await uconn.get_user_by_id(file_record.owner_id, throw=True)
+
+        if not await check_path_permission(path, user, cursor=cur) >= AccessLevel.READ:
+            allow_access, reason = check_file_read_permission(user, owner, file_record)
+            if not allow_access:
+                raise HTTPException(status_code=403 if user.id != 0 else 401, detail=reason)
     
     req_range = request.headers.get("Range", None)
     if not req_range is None:
@@ -326,17 +325,11 @@ async def put_file(
     ):
     path = ensure_uri_compnents(path)
     assert not path.endswith("/"), "Path must not end with /"
-    if not path.startswith(f"{user.username}/"):
-        if not user.is_admin:
-            logger.debug(f"Reject put request from {user.username} to {path}")
-            raise HTTPException(status_code=403, detail="Permission denied")
-        else:
-            first_comp = path.split("/")[0]
-            async with unique_cursor() as c:
-                uconn = UserConn(c)
-                owner = await uconn.get_user(first_comp)
-                if not owner:
-                    raise HTTPException(status_code=404, detail="Owner not found")
+
+    access_level = await check_path_permission(path, user)
+    if access_level < AccessLevel.WRITE:
+        logger.debug(f"Reject put request from {user.username} to {path}")
+        raise HTTPException(status_code=403, detail="Permission denied")
     
     logger.info(f"PUT {path}, user: {user.username}")
     exists_flag = False
@@ -352,7 +345,7 @@ async def put_file(
                 "Content-Type": "application/json",
             }, content=json.dumps({"url": path}))
         exists_flag = True
-        if not user.is_admin and not file_record.owner_id == user.id:
+        if await check_path_permission(path, user) < AccessLevel.WRITE:
             raise HTTPException(status_code=403, detail="Permission denied, cannot overwrite other's file")
         await db.delete_file(path)
     
@@ -386,17 +379,11 @@ async def post_file(
     ):
     path = ensure_uri_compnents(path)
     assert not path.endswith("/"), "Path must not end with /"
-    if not path.startswith(f"{user.username}/"):
-        if not user.is_admin:
-            logger.debug(f"Reject put request from {user.username} to {path}")
-            raise HTTPException(status_code=403, detail="Permission denied")
-        else:
-            first_comp = path.split("/")[0]
-            async with unique_cursor() as conn:
-                uconn = UserConn(conn)
-                owner = await uconn.get_user(first_comp)
-                if not owner:
-                    raise HTTPException(status_code=404, detail="Owner not found")
+
+    access_level = await check_path_permission(path, user)
+    if access_level < AccessLevel.WRITE:
+        logger.debug(f"Reject post request from {user.username} to {path}")
+        raise HTTPException(status_code=403, detail="Permission denied")
 
     logger.info(f"POST {path}, user: {user.username}")
     exists_flag = False
@@ -412,7 +399,7 @@ async def post_file(
                 "Content-Type": "application/json",
             }, content=json.dumps({"url": path}))
         exists_flag = True
-        if not user.is_admin and not file_record.owner_id == user.id:
+        if await check_path_permission(path, user) < AccessLevel.WRITE: 
             raise HTTPException(status_code=403, detail="Permission denied, cannot overwrite other's file")
         await db.delete_file(path)
     
@@ -431,7 +418,7 @@ async def post_file(
 @handle_exception
 async def delete_file(path: str, user: UserRecord = Depends(registered_user)):
     path = ensure_uri_compnents(path)
-    if not path.startswith(f"{user.username}/") and not user.is_admin:
+    if await check_path_permission(path, user) < AccessLevel.WRITE:
         raise HTTPException(status_code=403, detail="Permission denied")
     
     logger.info(f"DELETE {path}, user: {user.username}")
@@ -458,6 +445,7 @@ async def bundle_files(path: str, user: UserRecord = Depends(registered_user)):
     if not path == "" and path[0] == "/":   # adapt to both /path and path
         path = path[1:]
     
+    # TODO: may check peer users here
     owner_records_cache: dict[int, UserRecord] = {}     # cache owner records, ID -> UserRecord
     async def is_access_granted(file_record: FileRecord):
         owner_id = file_record.owner_id
@@ -465,11 +453,10 @@ async def bundle_files(path: str, user: UserRecord = Depends(registered_user)):
         if owner is None:
             async with unique_cursor() as conn:
                 uconn = UserConn(conn)
-                owner = await uconn.get_user_by_id(owner_id)
-                assert owner is not None, "Owner not found"
+                owner = await uconn.get_user_by_id(owner_id, throw=True)
             owner_records_cache[owner_id] = owner
             
-        allow_access, _ = check_user_permission(user, owner, file_record)
+        allow_access, _ = check_file_read_permission(user, owner, file_record)
         return allow_access
     
     async with unique_cursor() as conn:
@@ -502,23 +489,20 @@ async def get_file_meta(path: str, user: UserRecord = Depends(registered_user)):
     logger.info(f"GET meta({path}), user: {user.username}")
     path = ensure_uri_compnents(path)
     is_file = not path.endswith("/")
-    async with unique_cursor() as conn:
-        fconn = FileConn(conn)
+    async with unique_cursor() as cur:
+        fconn = FileConn(cur)
         if is_file:
-            record = await fconn.get_file_record(path)
-            if not record:
-                raise HTTPException(status_code=404, detail="File not found")
-            if not path.startswith(f"{user.username}/") and not user.is_admin:
-                uconn = UserConn(conn)
-                owner = await uconn.get_user_by_id(record.owner_id)
-                assert owner is not None, "Owner not found"
-                is_allowed, reason = check_user_permission(user, owner, record)
+            record = await fconn.get_file_record(path, throw=True)
+            if await check_path_permission(path, user, cursor=cur) < AccessLevel.READ:
+                uconn = UserConn(cur)
+                owner = await uconn.get_user_by_id(record.owner_id, throw=True)
+                is_allowed, reason = check_file_read_permission(user, owner, record)
                 if not is_allowed:
                     raise HTTPException(status_code=403, detail=reason)
         else:
-            record = await fconn.get_path_record(path)
-            if not path.startswith(f"{user.username}/") and not user.is_admin:
+            if await check_path_permission(path, user, cursor=cur) < AccessLevel.READ:
                 raise HTTPException(status_code=403, detail="Permission denied")
+            record = await fconn.get_path_record(path)
     return record
 
 @router_api.post("/meta")
@@ -559,15 +543,14 @@ async def update_file_meta(
 
     return Response(status_code=200, content="OK")
 
-async def validate_path_permission(path: str, user: UserRecord):
+async def validate_path_read_permission(path: str, user: UserRecord):
     if not path.endswith("/"):
         raise HTTPException(status_code=400, detail="Path must end with /")
-    if not path.startswith(f"{user.username}/") and not user.is_admin:
+    if not await check_path_permission(path, user) >= AccessLevel.READ:
         raise HTTPException(status_code=403, detail="Permission denied")
-
 @router_api.get("/count-files")
 async def count_files(path: str, flat: bool = False, user: UserRecord = Depends(registered_user)):
-    await validate_path_permission(path, user)
+    await validate_path_read_permission(path, user)
     path = ensure_uri_compnents(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
@@ -578,7 +561,7 @@ async def list_files(
     order_by: FileSortKey = "", order_desc: bool = False,
     flat: bool = False, user: UserRecord = Depends(registered_user)
     ):
-    await validate_path_permission(path, user)
+    await validate_path_read_permission(path, user)
     path = ensure_uri_compnents(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
@@ -590,7 +573,7 @@ async def list_files(
 
 @router_api.get("/count-dirs")
 async def count_dirs(path: str, user: UserRecord = Depends(registered_user)):
-    await validate_path_permission(path, user)
+    await validate_path_read_permission(path, user)
     path = ensure_uri_compnents(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)
@@ -601,7 +584,7 @@ async def list_dirs(
     order_by: DirSortKey = "", order_desc: bool = False,
     skim: bool = True, user: UserRecord = Depends(registered_user)
     ):
-    await validate_path_permission(path, user)
+    await validate_path_read_permission(path, user)
     path = ensure_uri_compnents(path)
     async with unique_cursor() as conn:
         fconn = FileConn(conn)

lfss/src/utils.py

@@ -47,13 +47,15 @@ def debounce_async(delay: float = 0.1, max_wait: float = 1.):
     """
     def debounce_wrap(func):
         task_record: tuple[str, asyncio.Task] | None = None
+        fn_execution_lock = Lock()
         last_execution_time = 0
 
         async def delayed_func(*args, **kwargs):
             nonlocal last_execution_time
             await asyncio.sleep(delay)
-            await func(*args, **kwargs)
-            last_execution_time = time.monotonic()
+            async with fn_execution_lock:
+                await func(*args, **kwargs)
+                last_execution_time = time.monotonic()
 
         @functools.wraps(func)
         async def wrapper(*args, **kwargs):
@@ -64,10 +66,11 @@ def debounce_async(delay: float = 0.1, max_wait: float = 1.):
                     task_record[1].cancel()
                     g_debounce_tasks.pop(task_record[0], None)
             
-            if time.monotonic() - last_execution_time > max_wait:
-                await func(*args, **kwargs)
-                last_execution_time = time.monotonic()
-                return
+            async with fn_execution_lock:
+                if time.monotonic() - last_execution_time > max_wait:
+                    await func(*args, **kwargs)
+                    last_execution_time = time.monotonic()
+                    return
 
             task = asyncio.create_task(delayed_func(*args, **kwargs))
             task_uid = uuid4().hex

{lfss-0.8.4.dist-info → lfss-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lfss
-Version: 0.8.4
+Version: 0.9.0
 Summary: Lightweight file storage service
 Home-page: https://github.com/MenxLi/lfss
 Author: li, mengxun

{lfss-0.8.4.dist-info → lfss-0.9.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 Readme.md,sha256=J1tGk7B9EyIXT-RN7VGz_229UeKvZHVLpn1FvzNDxL4,1538
 docs/Known_issues.md,sha256=rfdG3j1OJF-59S9E06VPyn0nZKbW-ybPxkoZ7MEZWp8,81
-docs/Permission.md,sha256=9r9nEmhqfz18RTS8FI0fZ9F0a31r86OoAyx3EQxxpk0,2317
-frontend/api.js,sha256=wUJNAkL8QigAiwR_jaMPUhCQEsL-lp0wZ6XeueYgunE,18049
+docs/Permission.md,sha256=mvK8gVBBgoIFJqikcaReU_bUo-mTq_ECqJaDDJoQF7Q,3126
+frontend/api.js,sha256=hMV6Fc1JxkFQgv7BV1Y_Su7pqsWeF_92hPMmDBcXC04,18485
 frontend/index.html,sha256=-k0bJ5FRqdl_H-O441D_H9E-iejgRCaL_z5UeYaS2qc,3384
 frontend/info.css,sha256=Ny0N3GywQ3a9q1_Qph_QFEKB4fEnTe_2DJ1Y5OsLLmQ,595
 frontend/info.js,sha256=xGUJPCSrtDhuSu0ELLQZ77PmVWldg-prU1mwQGbdEoA,5797
@@ -16,29 +16,29 @@ frontend/thumb.css,sha256=rNsx766amYS2DajSQNabhpQ92gdTpNoQKmV69OKvtpI,295
 frontend/thumb.js,sha256=46ViD2TlTTWy0fx6wjoAs_5CQ4ajYB90vVzM7UO2IHw,6182
 frontend/utils.js,sha256=IYUZl77ugiXKcLxSNOWC4NSS0CdD5yRgUsDb665j0xM,2556
 lfss/api/__init__.py,sha256=c_-GokKJ_3REgve16AwgXRfFyl9mwy7__FxCIIVlk1Q,6660
-lfss/api/connector.py,sha256=e2nhqrRGWixSJXRVDBxadq9oeiL0sGWLaL7FFzvLFJ8,11231
+lfss/api/connector.py,sha256=sSYy8gDewOosQiOzn8rvl7NsfFkIuhumHDefAVCgess,11573
 lfss/cli/__init__.py,sha256=lPwPmqpa7EXQ4zlU7E7LOe6X2kw_xATGdwoHphUEirA,827
 lfss/cli/balance.py,sha256=R2rbO2tg9TVnnQIVeU0GJVeMS-5LDhEdk4mbOE9qGq0,4121
-lfss/cli/cli.py,sha256=WVxDtIYCgFkEp9HoVLGi7AAhZJi5BCML7uT5D4yVcuE,8262
+lfss/cli/cli.py,sha256=iQkZm5Ltlhw7EWM4gOv_N0vjxiteGDH_aGhh06YMPYk,8066
 lfss/cli/panel.py,sha256=iGdVmdWYjA_7a78ZzWEB_3ggIOBeUKTzg6F5zLaB25c,1401
 lfss/cli/serve.py,sha256=T-jz_PJcaY9FJRRfyWV9MbjDI73YdOOCn4Nr2PO-s0c,993
-lfss/cli/user.py,sha256=uqHQ7onddTjJAYg3B1DIc8hDl0aCkIMZolLKhQrBd0k,4046
+lfss/cli/user.py,sha256=4ynarVvSybxEQaoAzCn2dN2h6-9A61XDNQ-83-lwK4s,5364
 lfss/cli/vacuum.py,sha256=4TMMYC_5yEt7jeaFTVC3iX0X6aUzYXBiCsrcIYgw_uA,3695
-lfss/sql/init.sql,sha256=C-JtQAlaOjESI8uoF1Y_9dKukEVSw5Ll-7yA3gG-XHU,1210
+lfss/sql/init.sql,sha256=8LjHx0TBCkBD62xFfssSeHDqKYVQQJkZAg4rSm046f4,1496
 lfss/sql/pragma.sql,sha256=uENx7xXjARmro-A3XAK8OM8v5AxDMdCCRj47f86UuXg,206
 lfss/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfss/src/bounded_pool.py,sha256=BI1dU-MBf82TMwJBYbjhEty7w1jIUKc5Bn9SnZ_-hoY,1288
 lfss/src/config.py,sha256=7k_6L_aG7vD-lVcmgpwMIg-ggpMMDNU8IbaB4y1effE,861
-lfss/src/connection_pool.py,sha256=4YULPcmndy33FyBSo9w1fZjAlBX2q-xPP27xJOTA06I,5228
-lfss/src/database.py,sha256=zoiBm7CVHHV4TqwmK6lPnZvK9mzDNtrNvAJCRaIYMU8,36302
-lfss/src/datatype.py,sha256=1xdxSKhpJXoBKumUokL3zQ2VyZ0Wwp8q6PaJf1idVw0,2435
-lfss/src/error.py,sha256=Bh_GUtuNsMSMIKbFreU4CfZzL96TZdNAIcgmDxvGbQ0,333
+lfss/src/connection_pool.py,sha256=-tePasJxiZZ73ymgWf_kFnaKouc4Rrr4K6EXwjb7Mm4,6141
+lfss/src/database.py,sha256=jahoLa3kU6wGovwyfuvaMuGI8rLxcJYSfMkTT8_LI3c,41883
+lfss/src/datatype.py,sha256=27UB7-l9SICy5lAvKjdzpTL_GohZjzstQcr9PtAq7nM,2709
+lfss/src/error.py,sha256=oUQPkXzrlJ6Mtvm26T_3SYW_4j9unfudG3HMa1Q-JF0,421
 lfss/src/log.py,sha256=u6WRZZsE7iOx6_CV2NHh1ugea26p408FI4WstZh896A,5139
-lfss/src/server.py,sha256=YLsp6bab7q0I2hI4uUYIiWc2S0k6d6bbMaweg6VbVV4,23743
+lfss/src/server.py,sha256=TMsZBt-hF4dh_-e_v5odki09S36kJ33Gi_GbtUnGQ-M,23310
 lfss/src/stat.py,sha256=WlRiiAl0rHX9oPi3thi6K4GKn70WHpClSDCt7iZUow4,3197
 lfss/src/thumb.py,sha256=qjCNMpnCozMuzkhm-2uAYy1eAuYTeWG6xqs-13HX-7k,3266
-lfss/src/utils.py,sha256=DxjHabdiISMkrm1WQlpsZFKL3by6YrzBNQaDt_uZlRk,5744
-lfss-0.8.4.dist-info/METADATA,sha256=OUvtod8R5Z7DnNLczVG6FpsHEQ2J1ct8QlbdZhU2fIk,2298
-lfss-0.8.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lfss-0.8.4.dist-info/entry_points.txt,sha256=VJ8svMz7RLtMCgNk99CElx7zo7M-N-z7BWDVw2HA92E,205
-lfss-0.8.4.dist-info/RECORD,,
+lfss/src/utils.py,sha256=XHBDBODU6RPpYywArmMBVnghPk3crPLrSW4cKxqiP5Q,5887
+lfss-0.9.0.dist-info/METADATA,sha256=QNSYV-4VzdS4VCmKtSvjSMurXTb1qvUhvW-Wvpz3dcA,2298
+lfss-0.9.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lfss-0.9.0.dist-info/entry_points.txt,sha256=VJ8svMz7RLtMCgNk99CElx7zo7M-N-z7BWDVw2HA92E,205
+lfss-0.9.0.dist-info/RECORD,,