lfss 0.9.1__py3-none-any.whl → 0.9.4__py3-none-any.whl

lfss/svc/app_dav.py

@@ -3,16 +3,17 @@
 from fastapi import Request, Response, Depends, HTTPException
 import time, uuid, os
 import aiosqlite
+import asyncio
 from typing import Literal, Optional
 import xml.etree.ElementTree as ET
 from ..eng.connection_pool import unique_cursor
 from ..eng.error import *
-from ..eng.config import DATA_HOME
-from ..eng.datatype import UserRecord, FileRecord, DirectoryRecord
-from ..eng.database import FileConn
-from ..eng.utils import ensure_uri_compnents, decode_uri_compnents, format_last_modified
+from ..eng.config import DATA_HOME, DEBUG_MODE
+from ..eng.datatype import UserRecord, FileRecord, DirectoryRecord, AccessLevel
+from ..eng.database import FileConn, UserConn, check_path_permission
+from ..eng.utils import ensure_uri_compnents, decode_uri_compnents, format_last_modified, static_vars
 from .app_base import *
-from .common_impl import get_file_impl, put_file_impl, delete_file_impl
+from .common_impl import copy_impl
 
 LOCK_DB_PATH = DATA_HOME / "lock.db"
 MKDIR_PLACEHOLDER = ".lfss_keep"
@@ -52,11 +53,27 @@ async def eval_path(path: str) -> tuple[ptype, str, Optional[FileRecord | Direct
     # path now is url-safe and without leading slash
     if path.endswith("/"):
         lfss_path = path
-        async with unique_cursor() as c:
-            fconn = FileConn(c)
-            if await fconn.count_path_files(path, flat=True) == 0:
-                return None, lfss_path, None
-            return "dir", lfss_path, await fconn.get_path_record(path)
+        dir_path_sp = path.split("/")
+        if len(dir_path_sp) > 2:
+            async with unique_cursor() as c:
+                fconn = FileConn(c)
+                if await fconn.count_path_files(path, flat=True) == 0:
+                    return None, lfss_path, None
+                return "dir", lfss_path, await fconn.get_path_record(path)
+        else:
+            # test if its a user's root directory
+            assert len(dir_path_sp) == 2
+            username = path.split("/")[0]
+            async with unique_cursor() as c:
+                uconn = UserConn(c)
+                u = await uconn.get_user(username)
+                if u is None: 
+                    return None, lfss_path, None
+                return "dir", lfss_path, DirectoryRecord(lfss_path)
+
+    # may be root directory
+    if path == "": 
+        return "dir", "", DirectoryRecord("")
 
     # not end with /, check if it is a file
     async with unique_cursor() as c:
@@ -65,11 +82,10 @@ async def eval_path(path: str) -> tuple[ptype, str, Optional[FileRecord | Direct
             lfss_path = path
             return "file", lfss_path, res
     
-    if path == "": return "dir", "", DirectoryRecord("")
     async with unique_cursor() as c:
+        lfss_path = path + "/"
         fconn = FileConn(c)
-        if await fconn.count_path_files(path + "/") > 0:
-            lfss_path = path + "/"
+        if await fconn.count_path_files(lfss_path) > 0:
             return "dir", lfss_path, await fconn.get_path_record(lfss_path)
     
     return None, path, None
@@ -79,12 +95,14 @@ CREATE TABLE IF NOT EXISTS locks (
     path TEXT PRIMARY KEY,
     user TEXT,
     token TEXT,
+    depth TEXT,
     timeout float,
     lock_time float
 );
 """
-async def lock_path(user: UserRecord, p: str, token: str, timeout: int = 600):
+async def lock_path(user: UserRecord, p: str, token: str, depth: str, timeout: int = 1800):
     async with aiosqlite.connect(LOCK_DB_PATH) as conn:
+        await conn.execute("BEGIN EXCLUSIVE")
         await conn.execute(lock_table_create_sql)
         async with conn.execute("SELECT user, timeout, lock_time FROM locks WHERE path=?", (p,)) as cur:
             row = await cur.fetchone()
@@ -93,10 +111,11 @@ async def lock_path(user: UserRecord, p: str, token: str, timeout: int = 600):
                 curr_time = time.time()
                 if timeout > 0 and curr_time - lock_time_ < timeout_:
                     raise FileLockedError(f"File is locked (by {user_}) [{p}]")
-            await cur.execute("INSERT OR REPLACE INTO locks VALUES (?, ?, ?, ?, ?)", (p, user.username, token, timeout, time.time()))
+            await cur.execute("INSERT OR REPLACE INTO locks VALUES (?, ?, ?, ?, ?, ?)", (p, user.username, token, depth, timeout, time.time()))
             await conn.commit()
 async def unlock_path(user: UserRecord, p: str, token: str):
     async with aiosqlite.connect(LOCK_DB_PATH) as conn:
+        await conn.execute("BEGIN EXCLUSIVE")
         await conn.execute(lock_table_create_sql)
         async with conn.execute("SELECT user, token FROM locks WHERE path=?", (p,)) as cur:
             row = await cur.fetchone()
@@ -106,31 +125,34 @@ async def unlock_path(user: UserRecord, p: str, token: str):
                 raise FileLockedError(f"Failed to unlock file [{p}] with token {token}")
             await cur.execute("DELETE FROM locks WHERE path=?", (p,))
             await conn.commit()
-async def query_lock_el(p: str, top_el_name: str = f"{{{DAV_NS}}}lockinfo") -> Optional[ET.Element]:
+async def query_lock_element(p: str, top_el_name: str = f"{{{DAV_NS}}}lockinfo") -> Optional[ET.Element]:
     async with aiosqlite.connect(LOCK_DB_PATH) as conn:
+        await conn.execute("BEGIN EXCLUSIVE")
         await conn.execute(lock_table_create_sql)
-        async with conn.execute("SELECT user, token, timeout, lock_time FROM locks WHERE path=?", (p,)) as cur:
+        async with conn.execute("SELECT user, token, depth, timeout, lock_time FROM locks WHERE path=?", (p,)) as cur:
             row = await cur.fetchone()
             if not row: return None
             curr_time = time.time()
-            user_, token, timeout, lock_time = row
+            username, token, depth, timeout, lock_time = row
             if timeout > 0 and curr_time - lock_time > timeout:
                 await cur.execute("DELETE FROM locks WHERE path=?", (p,))
                 await conn.commit()
                 return None
-            lock_info = ET.Element(top_el_name)
-            locktype = ET.SubElement(lock_info, f"{{{DAV_NS}}}locktype")
-            ET.SubElement(locktype, f"{{{DAV_NS}}}write")
-            lockscope = ET.SubElement(lock_info, f"{{{DAV_NS}}}lockscope")
-            ET.SubElement(lockscope, f"{{{DAV_NS}}}exclusive")
-            owner = ET.SubElement(lock_info, f"{{{DAV_NS}}}owner")
-            owner.text = user_
-            timeout = ET.SubElement(lock_info, f"{{{DAV_NS}}}timeout")
-            timeout.text = f"Second-{timeout}"
-            locktoken = ET.SubElement(lock_info, f"{{{DAV_NS}}}locktoken")
-            href = ET.SubElement(locktoken, f"{{{DAV_NS}}}href")
-            href.text = f"{token}"
-            return lock_info
+        lock_info = ET.Element(top_el_name)
+        locktype = ET.SubElement(lock_info, f"{{{DAV_NS}}}locktype")
+        ET.SubElement(locktype, f"{{{DAV_NS}}}write")
+        lockscope = ET.SubElement(lock_info, f"{{{DAV_NS}}}lockscope")
+        ET.SubElement(lockscope, f"{{{DAV_NS}}}exclusive")
+        owner = ET.SubElement(lock_info, f"{{{DAV_NS}}}owner")
+        owner.text = username
+        depth_el = ET.SubElement(lock_info, f"{{{DAV_NS}}}depth")
+        depth_el.text = depth
+        timeout = ET.SubElement(lock_info, f"{{{DAV_NS}}}timeout")
+        timeout.text = f"Second-{timeout}"
+        locktoken = ET.SubElement(lock_info, f"{{{DAV_NS}}}locktoken")
+        href = ET.SubElement(locktoken, f"{{{DAV_NS}}}href")
+        href.text = f"{token}"
+        return lock_info
 
 async def create_file_xml_element(frecord: FileRecord) -> ET.Element:
     file_el = ET.Element(f"{{{DAV_NS}}}response")
@@ -138,15 +160,16 @@ async def create_file_xml_element(frecord: FileRecord) -> ET.Element:
     href.text = f"/{frecord.url}"
     propstat = ET.SubElement(file_el, f"{{{DAV_NS}}}propstat")
     prop = ET.SubElement(propstat, f"{{{DAV_NS}}}prop")
-    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = frecord.url.split("/")[-1]
+    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = decode_uri_compnents(frecord.url.split("/")[-1])
     ET.SubElement(prop, f"{{{DAV_NS}}}resourcetype")
     ET.SubElement(prop, f"{{{DAV_NS}}}getcontentlength").text = str(frecord.file_size)
     ET.SubElement(prop, f"{{{DAV_NS}}}getlastmodified").text = format_last_modified(frecord.create_time)
     ET.SubElement(prop, f"{{{DAV_NS}}}getcontenttype").text = frecord.mime_type
-    lock_discovery = ET.SubElement(prop, f"{{{DAV_NS}}}lockdiscovery")
-    lock_el = await query_lock_el(frecord.url, top_el_name=f"{{{DAV_NS}}}activelock")
+    lock_el = await query_lock_element(frecord.url, top_el_name=f"{{{DAV_NS}}}activelock")
     if lock_el is not None:
+        lock_discovery = ET.SubElement(prop, f"{{{DAV_NS}}}lockdiscovery")
         lock_discovery.append(lock_el)
+    ET.SubElement(propstat, f"{{{DAV_NS}}}status").text = "HTTP/1.1 200 OK"
     return file_el
 
 async def create_dir_xml_element(drecord: DirectoryRecord) -> ET.Element:
@@ -155,15 +178,16 @@ async def create_dir_xml_element(drecord: DirectoryRecord) -> ET.Element:
     href.text = f"/{drecord.url}"
     propstat = ET.SubElement(dir_el, f"{{{DAV_NS}}}propstat")
     prop = ET.SubElement(propstat, f"{{{DAV_NS}}}prop")
-    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = drecord.url.split("/")[-2]
+    ET.SubElement(prop, f"{{{DAV_NS}}}displayname").text = decode_uri_compnents(drecord.url.split("/")[-2])
     ET.SubElement(prop, f"{{{DAV_NS}}}resourcetype").append(ET.Element(f"{{{DAV_NS}}}collection"))
     if drecord.size >= 0:
         ET.SubElement(prop, f"{{{DAV_NS}}}getlastmodified").text = format_last_modified(drecord.create_time)
         ET.SubElement(prop, f"{{{DAV_NS}}}getcontentlength").text = str(drecord.size)
-    lock_discovery = ET.SubElement(prop, f"{{{DAV_NS}}}lockdiscovery")
-    lock_el = await query_lock_el(drecord.url, top_el_name=f"{{{DAV_NS}}}activelock")
+    lock_el = await query_lock_element(drecord.url, top_el_name=f"{{{DAV_NS}}}activelock")
     if lock_el is not None:
+        lock_discovery = ET.SubElement(prop, f"{{{DAV_NS}}}lockdiscovery")
         lock_discovery.append(lock_el)
+    ET.SubElement(propstat, f"{{{DAV_NS}}}status").text = "HTTP/1.1 200 OK"
     return dir_el
 
 async def xml_request_body(request: Request) -> Optional[ET.Element]:
@@ -179,64 +203,59 @@ async def dav_options(request: Request, path: str):
     return Response(headers={
         "DAV": "1,2",
         "MS-Author-Via": "DAV",
-        "Allow": "OPTIONS, GET, HEAD, POST, DELETE, TRACE, PROPFIND, PROPPATCH, COPY, MOVE, LOCK, UNLOCK",
+        "Allow": "OPTIONS, GET, HEAD, POST, DELETE, TRACE, PROPFIND, PROPPATCH, COPY, MOVE, LOCK, UNLOCK, MKCOL",
         "Content-Length": "0"
     })
 
-@router_dav.get("/{path:path}")
-@handle_exception
-async def dav_get(request: Request, path: str, user: UserRecord = Depends(registered_user)):
-    ptype, path, _ = await eval_path(path)
-    if ptype is None: raise PathNotFoundError(path)
-    elif ptype == "dir": raise InvalidOptionsError("Directory should not be fetched")
-    else: return await get_file_impl(request, user=user, path=path)
-
-@router_dav.head("/{path:path}")
-@handle_exception
-async def dav_head(request: Request, path: str, user: UserRecord = Depends(registered_user)):
-    ptype, path, _ = await eval_path(path)
-    # some clients may send HEAD request to check if the file exists
-    if ptype is None: raise PathNotFoundError(path)
-    elif ptype == "dir": return Response(status_code=200)
-    else: return await get_file_impl(request, user=user, path=path, is_head=True)
-
-@router_dav.put("/{path:path}")
-@handle_exception
-async def dav_put(request: Request, path: str, user: UserRecord = Depends(registered_user)):
-    _, path, _ = await eval_path(path)
-    return await put_file_impl(request, user=user, path=path, conflict='overwrite')
-
-@router_dav.delete("/{path:path}")
-@handle_exception
-async def dav_delete(path: str, user: UserRecord = Depends(registered_user)):
-    _, path, _ = await eval_path(path)
-    return await delete_file_impl(user=user, path=path)
-
 @router_dav.api_route("/{path:path}", methods=["PROPFIND"])
 @handle_exception
-async def dav_propfind(request: Request, path: str, user: UserRecord = Depends(registered_user)):
+async def dav_propfind(request: Request, path: str, user: UserRecord = Depends(registered_user), body: Optional[ET.Element] = Depends(xml_request_body)):
     if path.startswith("/"): path = path[1:]
     path = ensure_uri_compnents(path)
 
-    depth = request.headers.get("Depth", "1")
+    if body and DEBUG_MODE:
+        print("Propfind-body:", ET.tostring(body, encoding="utf-8", method="xml"))
+
+    depth = request.headers.get("Depth", "0")
     # Generate XML response
     multistatus = ET.Element(f"{{{DAV_NS}}}multistatus")
     path_type, lfss_path, record = await eval_path(path)
-    logger.info(f"PROPFIND {lfss_path} (depth: {depth})")
-    return_status = 200
+    logger.info(f"PROPFIND {lfss_path} (depth: {depth}), type: {path_type}, record: {record}")
+
+    if lfss_path and await check_path_permission(lfss_path, user) < AccessLevel.READ:
+        raise PermissionDeniedError(lfss_path)
+
     if path_type == "dir" and depth == "0":
         # query the directory itself
-        return_status = 200
         assert isinstance(record, DirectoryRecord)
         dir_el = await create_dir_xml_element(record)
         multistatus.append(dir_el)
 
+    elif path_type == "dir" and lfss_path == "":
+        # query root directory content
+        async def user_path_record(user_name: str, cur) -> DirectoryRecord:
+            try:
+                return await FileConn(cur).get_path_record(user_name + "/")
+            except PathNotFoundError:
+                return DirectoryRecord(user_name + "/", size=0, n_files=0, create_time="1970-01-01 00:00:00", update_time="1970-01-01 00:00:00", access_time="1970-01-01 00:00:00")
+
+        async with unique_cursor() as c:
+            uconn = UserConn(c)
+            if not user.is_admin:
+                for u in [user] + await uconn.list_peer_users(user.id, AccessLevel.READ):
+                    dir_el = await create_dir_xml_element(await user_path_record(u.username, c))
+                    multistatus.append(dir_el)
+            else:
+                async for u in uconn.all():
+                    dir_el = await create_dir_xml_element(await user_path_record(u.username, c))
+                    multistatus.append(dir_el)
+
     elif path_type == "dir":
-        return_status = 207
+        # query directory content
         async with unique_cursor() as c:
             flist = await FileConn(c).list_path_files(lfss_path, flat = True if depth == "infinity" else False)
         for frecord in flist:
-            if frecord.url.split("/")[-1] == MKDIR_PLACEHOLDER: continue
+            if frecord.url.endswith(f"/{MKDIR_PLACEHOLDER}"): continue
             file_el = await create_file_xml_element(frecord)
             multistatus.append(file_el)
 
@@ -247,6 +266,7 @@ async def dav_propfind(request: Request, path: str, user: UserRecord = Depends(r
             multistatus.append(dir_el)
 
     elif path_type == "file": 
+        # query file
         assert isinstance(record, FileRecord)
         file_el = await create_file_xml_element(record)
         multistatus.append(file_el)
@@ -255,7 +275,7 @@ async def dav_propfind(request: Request, path: str, user: UserRecord = Depends(r
         raise PathNotFoundError(path)
 
     xml_response = ET.tostring(multistatus, encoding="utf-8", method="xml")
-    return Response(content=xml_response, media_type="application/xml", status_code=return_status)
+    return Response(content=xml_response, media_type="application/xml", status_code=207)
 
 @router_dav.api_route("/{path:path}", methods=["MKCOL"])
 @handle_exception
@@ -282,7 +302,7 @@ async def dav_move(request: Request, path: str, user: UserRecord = Depends(regis
     ptype, lfss_path, _ = await eval_path(path)
     if ptype is None:
         raise PathNotFoundError(path)
-    dptype, dlfss_path, ddav_path = await eval_path(destination)
+    dptype, dlfss_path, _ = await eval_path(destination)
     if dptype is not None:
         raise HTTPException(status_code=409, detail="Conflict")
 
@@ -308,25 +328,17 @@ async def dav_copy(request: Request, path: str, user: UserRecord = Depends(regis
     ptype, lfss_path, _ = await eval_path(path)
     if ptype is None:
         raise PathNotFoundError(path)
-    dptype, dlfss_path, ddav_path = await eval_path(destination)
+    dptype, dlfss_path, _ = await eval_path(destination)
     if dptype is not None:
         raise HTTPException(status_code=409, detail="Conflict")
     
     logger.info(f"COPY {path} -> {destination}")
-    if ptype == "file":
-        assert not lfss_path.endswith("/"), "File path should not end with /"
-        assert not dlfss_path.endswith("/"), "File path should not end with /"
-        await db.copy_file(lfss_path, dlfss_path, user)
-    else:
-        assert ptype == "dir", "Directory path should end with /"
-        assert lfss_path.endswith("/"), "Directory path should end with /"
-        assert dlfss_path.endswith("/"), "Directory path should end with /"
-        await db.copy_path(lfss_path, dlfss_path, user)
-    return Response(status_code=201)
+    return await copy_impl(op_user=user, src_path=lfss_path, dst_path=dlfss_path)
 
 @router_dav.api_route("/{path:path}", methods=["LOCK"])
 @handle_exception
-async def dav_lock(request: Request, path: str, user: UserRecord = Depends(registered_user)):
+@static_vars(lock = asyncio.Lock())
+async def dav_lock(request: Request, path: str, user: UserRecord = Depends(registered_user), body: ET.Element = Depends(xml_request_body)):
     raw_timeout = request.headers.get("Timeout", "Second-3600")
     if raw_timeout == "Infinite": timeout = -1
     else:
@@ -334,16 +346,20 @@ async def dav_lock(request: Request, path: str, user: UserRecord = Depends(regis
             raise HTTPException(status_code=400, detail="Bad Request, invalid timeout: " + raw_timeout + ", expected Second-<seconds> or Infinite")
         _, timeout_str = raw_timeout.split("-")
         timeout = int(timeout_str)
-
+    
+    lock_depth = request.headers.get("Depth", "0")
     _, path, _ = await eval_path(path)
     # lock_token = f"opaquelocktoken:{uuid.uuid4().hex}"
     lock_token = f"urn:uuid:{uuid.uuid4()}"
-    logger.info(f"LOCK {path} (timeout: {timeout}), token: {lock_token}")
-    await lock_path(user, path, lock_token, timeout=timeout)
-    response_elem = ET.Element(f"{{{DAV_NS}}}prop")
-    lockdiscovery = ET.SubElement(response_elem, f"{{{DAV_NS}}}lockdiscovery")
-    activelock = await query_lock_el(path, top_el_name=f"{{{DAV_NS}}}activelock")
-    assert activelock is not None, "Lock info should not be None"
+    logger.info(f"LOCK {path} (timeout: {timeout}), token: {lock_token}, depth: {lock_depth}")
+    if DEBUG_MODE and body:
+        print("Lock-body:", ET.tostring(body, encoding="utf-8", method="xml"))
+    async with dav_lock.lock:
+        await lock_path(user, path, lock_token, lock_depth, timeout=timeout)
+        response_elem = ET.Element(f"{{{DAV_NS}}}prop")
+        lockdiscovery = ET.SubElement(response_elem, f"{{{DAV_NS}}}lockdiscovery")
+        activelock = await query_lock_element(path, top_el_name=f"{{{DAV_NS}}}activelock")
+        assert activelock is not None
     lockdiscovery.append(activelock)
     lock_response = ET.tostring(response_elem, encoding="utf-8", method="xml")
     return Response(content=lock_response, media_type="application/xml", status_code=201, headers={
@@ -352,13 +368,15 @@ async def dav_lock(request: Request, path: str, user: UserRecord = Depends(regis
 
 @router_dav.api_route("/{path:path}", methods=["UNLOCK"])
 @handle_exception
-async def dav_unlock(request: Request, path: str, user: UserRecord = Depends(registered_user)):
+async def dav_unlock(request: Request, path: str, user: UserRecord = Depends(registered_user), body: ET.Element = Depends(xml_request_body)):
     lock_token = request.headers.get("Lock-Token")
     if not lock_token:
         raise HTTPException(status_code=400, detail="Lock-Token header is required")
     if lock_token.startswith("<") and lock_token.endswith(">"):
         lock_token = lock_token[1:-1]
     logger.info(f"UNLOCK {path}, token: {lock_token}")
+    if DEBUG_MODE and body:
+        print("Unlock-body:", ET.tostring(body, encoding="utf-8", method="xml"))
     _, path, _ = await eval_path(path)
     await unlock_path(user, path, lock_token)
     return Response(status_code=204)

lfss/svc/app_native.py

@@ -13,7 +13,7 @@ from ..eng.datatype import (
 )
 
 from .app_base import *
-from .common_impl import get_file_impl, put_file_impl, post_file_impl, delete_file_impl
+from .common_impl import get_impl, put_file_impl, post_file_impl, delete_impl, copy_impl
 
 @router_fs.get("/{path:path}")
 @handle_exception
@@ -23,7 +23,7 @@ async def get_file(
     download: bool = False, thumb: bool = False,
     user: UserRecord = Depends(get_current_user)
     ):
-    return await get_file_impl(
+    return await get_impl(
         request = request,
         user = user, path = path, download = download, thumb = thumb
         )
@@ -38,9 +38,7 @@ async def head_file(
     ):
     if path.startswith("_api/"):
         raise HTTPException(status_code=405, detail="HEAD not supported for API")
-    if path.endswith("/"):
-        raise HTTPException(status_code=405, detail="HEAD not supported for directory")
-    return await get_file_impl(
+    return await get_impl(
         request = request,
         user = user, path = path, download = download, thumb = thumb, is_head = True
         )
@@ -50,7 +48,7 @@ async def head_file(
 async def put_file(
     request: Request, 
     path: str, 
-    conflict: Literal["overwrite", "skip", "abort"] = "abort",
+    conflict: Literal["overwrite", "skip", "abort"] = "overwrite",
     permission: int = 0,
     user: UserRecord = Depends(registered_user)
     ):
@@ -64,7 +62,7 @@ async def put_file(
 async def post_file(
     path: str, 
     file: UploadFile,
-    conflict: Literal["overwrite", "skip", "abort"] = "abort",
+    conflict: Literal["overwrite", "skip", "abort"] = "overwrite",
     permission: int = 0,
     user: UserRecord = Depends(registered_user)
     ):
@@ -75,7 +73,7 @@ async def post_file(
 @router_fs.delete("/{path:path}")
 @handle_exception
 async def delete_file(path: str, user: UserRecord = Depends(registered_user)):
-    return await delete_file_impl(path, user)
+    return await delete_impl(path, user)
 
 
 @router_api.get("/bundle")
@@ -181,11 +179,19 @@ async def update_file_meta(
         if new_path is not None:
             new_path = ensure_uri_compnents(new_path)
             logger.info(f"Update path of {path} to {new_path}")
-            # currently only move own file, with overwrite
+            # will raise duplicate path error if same name path exists in the new path
             await db.move_path(path, new_path, user)
 
     return Response(status_code=200, content="OK")
 
+@router_api.post("/copy")
+@handle_exception
+async def copy_file(
+    src: str, dst: str, 
+    user: UserRecord = Depends(registered_user)
+    ):
+    return await copy_impl(src_path = src, dst_path = dst, op_user = user)
+
 async def validate_path_read_permission(path: str, user: UserRecord):
     if not path.endswith("/"):
         raise HTTPException(status_code=400, detail="Path must end with /")