tuspyserver 4.2.1__tar.gz → 4.2.2__tar.gz

{tuspyserver-4.2.1 → tuspyserver-4.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tuspyserver
-Version: 4.2.1
+Version: 4.2.2
 Summary: A Python tus server implementation as a FastAPI router
 Author: Edi Hasaj
 Author-email: Edi Hasaj <edi.hasaj@applifyer.com>

{tuspyserver-4.2.1 → tuspyserver-4.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tuspyserver"
-version = "4.2.1"
+version = "4.2.2"
 description ="A Python tus server implementation as a FastAPI router"
 readme = "README.md"
 authors = [

{tuspyserver-4.2.1 → tuspyserver-4.2.2}/src/tuspyserver/file.py

@@ -26,6 +26,31 @@ class TusUploadFile:
         params: Optional[TusUploadParams] = None,
     ):
         self._options = options
+        
+        # Ensure files_dir is a valid directory path
+        # Normalize the path and ensure parent directories exist
+        files_dir = os.path.abspath(os.path.expanduser(self._options.files_dir))
+        
+        # Check if path exists and is actually a directory
+        if os.path.exists(files_dir):
+            if not os.path.isdir(files_dir):
+                raise OSError(
+                    f"Upload directory path '{files_dir}' exists but is not a directory. "
+                    f"Please ensure the path points to a valid directory."
+                )
+        else:
+            # create the files dir if necessary (must be done before creating files)
+            try:
+                os.makedirs(files_dir, exist_ok=True)
+            except OSError as e:
+                raise OSError(
+                    f"Failed to create upload directory '{files_dir}': {e}. "
+                    f"Please ensure the path is valid and writable."
+                ) from e
+        
+        # Update options with normalized path
+        self._options.files_dir = files_dir
+        
         # init
         if uid is None:
             # creating new file
@@ -34,7 +59,9 @@ class TusUploadFile:
         else:
             # reading existing file
             self.uid = uid
-            if not self.exists:
+            # Only create the file if we're explicitly creating a new upload with params
+            # This happens when creating a partial or final upload with a specific uid
+            if params is not None and not self.exists:
                 self.create()
         # create the files dir if necessary
         if not os.path.exists(self._options.files_dir):

{tuspyserver-4.2.1 → tuspyserver-4.2.2}/src/tuspyserver/info.py

@@ -14,23 +14,30 @@ from tuspyserver.params import TusUploadParams
 
 class TusUploadInfo:
     _params: Optional[TusUploadParams]
+    _loaded: bool
     file: TusUploadFile
 
     def __init__(self, file: TusUploadFile, params: Optional[TusUploadParams] = None):
         self.file = file
         self._params = params
+        self._loaded = params is not None  # If params provided, consider them loaded
         # create if doesn't exist
         if params and not self.exists:
             self.serialize()
 
     @property
     def params(self):
-        self.deserialize()
+        # Only deserialize if we haven't loaded params yet
+        # This prevents overwriting in-memory params on every access
+        if not self._loaded:
+            self.deserialize()
+            self._loaded = True
         return self._params
 
     @params.setter
     def params(self, value):
         self._params = value
+        self._loaded = True  # Mark as loaded since we're explicitly setting params
         self.serialize()
 
     @property
@@ -42,11 +49,34 @@ class TusUploadInfo:
         return os.path.exists(self.path)
 
     def serialize(self) -> None:
-        with open(self.path, "w") as f:
-            json_string = json.dumps(
-                self._params, indent=4, default=lambda k: k.__dict__
-            )
-            f.write(json_string)
+        """
+        Atomically serialize params to info file.
+        
+        Uses a temporary file and atomic rename to prevent corruption
+        from concurrent writes.
+        """
+        # Write to temporary file first
+        temp_path = f"{self.path}.tmp"
+        try:
+            with open(temp_path, "w") as f:
+                json_string = json.dumps(
+                    self._params, indent=4, default=lambda k: k.__dict__
+                )
+                f.write(json_string)
+                f.flush()
+                # Ensure data is written to disk
+                os.fsync(f.fileno())
+            
+            # Atomic rename - this is atomic on Unix systems
+            os.rename(temp_path, self.path)
+        except Exception:
+            # Clean up temp file if rename fails
+            try:
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+            except Exception:
+                pass
+            raise
 
     def deserialize(self) -> Optional[TusUploadParams]:
         if self.exists:

tuspyserver-4.2.2/src/tuspyserver/lock.py

@@ -0,0 +1,185 @@
+"""
+File locking utilities for tus uploads.
+
+Provides advisory file locking using fcntl (Unix) to prevent race conditions
+during concurrent upload operations. This implementation matches tusd's approach
+by using separate lock files stored in a .locks directory, where each lock file
+contains the PID of the process holding the lock.
+"""
+import fcntl
+import logging
+import os
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class FileLock:
+    """
+    Advisory file lock using fcntl (Unix) with separate lock files.
+    
+    Matches tusd's filelocker approach by creating separate .lock files
+    in a .locks directory. Each lock file contains the PID of the process
+    holding the lock, allowing for lock cleanup if a process crashes.
+    """
+    
+    def __init__(self, file_path: str, locks_dir: Optional[str] = None):
+        """
+        Initialize a file lock.
+        
+        Args:
+            file_path: Path to the upload file to lock
+            locks_dir: Directory to store lock files (defaults to {files_dir}/.locks)
+        """
+        self.file_path = file_path
+        self.locks_dir = locks_dir
+        
+        # Derive lock file path from upload file path
+        if locks_dir:
+            # Ensure locks directory exists
+            os.makedirs(locks_dir, exist_ok=True)
+            lock_filename = os.path.basename(file_path) + ".lock"
+            self.lock_file_path = os.path.join(locks_dir, lock_filename)
+        else:
+            # Default: create .locks directory next to upload file
+            upload_dir = os.path.dirname(file_path)
+            locks_dir = os.path.join(upload_dir, ".locks")
+            os.makedirs(locks_dir, exist_ok=True)
+            lock_filename = os.path.basename(file_path) + ".lock"
+            self.lock_file_path = os.path.join(locks_dir, lock_filename)
+        
+        self._lock_fd: Optional[int] = None
+    
+    def acquire(self, blocking: bool = True) -> bool:
+        """
+        Acquire an exclusive lock on the upload file.
+        
+        Creates a separate lock file and applies an exclusive lock on it.
+        The lock file contains the PID of the process holding the lock.
+        This matches tusd's filelocker approach.
+        
+        Args:
+            blocking: If True, block until lock is acquired. If False, return immediately.
+            
+        Returns:
+            True if lock was acquired, False otherwise (only when blocking=False)
+        """
+        try:
+            # Ensure locks directory exists
+            os.makedirs(os.path.dirname(self.lock_file_path), exist_ok=True)
+            
+            # Open the lock file for read-write, create if it doesn't exist
+            # Use O_RDWR to allow both reading and writing
+            # Use O_CREAT to create the file if it doesn't exist
+            self._lock_fd = os.open(self.lock_file_path, os.O_RDWR | os.O_CREAT, 0o644)
+            
+            # Ensure the lock file contains only the current PID before writing
+            try:
+                os.ftruncate(self._lock_fd, 0)
+                os.lseek(self._lock_fd, 0, os.SEEK_SET)
+            except OSError as e:
+                logger.warning(f"Failed to truncate lock file {self.lock_file_path}: {e}")
+
+            # Write PID to lock file (like tusd does)
+            try:
+                pid_str = str(os.getpid()).encode('utf-8')
+                os.write(self._lock_fd, pid_str)
+                os.fsync(self._lock_fd)  # Ensure PID is written to disk
+                # Seek back to beginning for reading
+                os.lseek(self._lock_fd, 0, os.SEEK_SET)
+            except (IOError, OSError) as e:
+                # If writing PID fails, continue anyway - lock is still valid
+                logger.warning(f"Failed to write PID to lock file {self.lock_file_path}: {e}")
+            
+            # Try to acquire exclusive lock (LOCK_EX) on the lock file
+            # If blocking=False, use LOCK_NB (non-blocking)
+            flags = fcntl.LOCK_EX
+            if not blocking:
+                flags |= fcntl.LOCK_NB
+            
+            fcntl.flock(self._lock_fd, flags)
+            return True
+        except (IOError, OSError) as e:
+            # Lock acquisition failed
+            if self._lock_fd is not None:
+                try:
+                    os.close(self._lock_fd)
+                except Exception:
+                    pass
+                self._lock_fd = None
+            
+            if not blocking and e.errno in (11, 35):  # EAGAIN/EWOULDBLOCK
+                return False
+            raise
+    
+    def release(self) -> None:
+        """Release the lock and close the file descriptor."""
+        if self._lock_fd is not None:
+            try:
+                fcntl.flock(self._lock_fd, fcntl.LOCK_UN)
+                os.close(self._lock_fd)
+            except Exception as e:
+                logger.warning(f"Error releasing lock file descriptor: {e}")
+            finally:
+                self._lock_fd = None
+            
+            # Remove the lock file (tusd does this)
+            # Note: We remove the lock file but keep the .locks directory
+            try:
+                if os.path.exists(self.lock_file_path):
+                    os.remove(self.lock_file_path)
+            except Exception as e:
+                logger.warning(f"Error removing lock file {self.lock_file_path}: {e}")
+    
+    def get_fd(self) -> Optional[int]:
+        """
+        Get the file descriptor for the lock file.
+        
+        Returns:
+            File descriptor if lock is acquired, None otherwise
+        """
+        return self._lock_fd
+    
+    def __enter__(self):
+        """Context manager entry."""
+        self.acquire(blocking=True)
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.release()
+
+
+@contextmanager
+def acquire_upload_lock(upload_path: str, locks_dir: Optional[str] = None, blocking: bool = True):
+    """
+    Context manager for acquiring an upload lock.
+    
+    This matches tusd's filelocker pattern by creating separate lock files
+    in a .locks directory. Each lock file contains the PID of the process
+    holding the lock.
+    
+    Args:
+        upload_path: Path to the upload file to lock
+        locks_dir: Directory to store lock files (defaults to {upload_dir}/.locks)
+        blocking: If True, block until lock is acquired
+        
+    Yields:
+        FileLock instance with the locked file descriptor
+        
+    Example:
+        with acquire_upload_lock("/path/to/upload") as lock:
+            # Lock is held via lock file in .locks directory
+            # Lock file contains PID of this process
+            pass
+    """
+    lock = FileLock(upload_path, locks_dir=locks_dir)
+    try:
+        acquired = lock.acquire(blocking=blocking)
+        if not acquired:
+            raise IOError("Could not acquire lock")
+        yield lock
+    finally:
+        lock.release()

tuspyserver-4.2.2/src/tuspyserver/request.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+from copy import deepcopy
+import datetime
+import os
+import typing
+from typing import Callable, Optional
+
+import inspect
+
+if typing.TYPE_CHECKING:
+    from tuspyserver.router import TusRouterOptions
+
+from fastapi import Depends, HTTPException, Path, Request
+from starlette.requests import ClientDisconnect
+
+from tuspyserver.file import TusUploadFile
+from tuspyserver.lock import acquire_upload_lock
+
+
+def make_request_chunks_dep(options: TusRouterOptions):
+    async def request_chunks_dep(
+        request: Request,
+        uuid: str = Path(...),
+        post_request: bool = False,
+        file_dep: Callable[[dict], None] = Depends(options.file_dep),
+    ) -> Optional[bool]:
+        # Create a copy of options to avoid mutating the original
+        file_options = deepcopy(options)
+        # call file_dep to possibly update the files_dir
+        result = file_dep({})
+        # if the callback returned a coroutine, await it
+        if inspect.isawaitable(result):
+            result = await result
+        if isinstance(result, dict):
+            file_options.files_dir = result.get("files_dir", file_options.files_dir)
+
+        # init file handle
+        file = TusUploadFile(uid=uuid, options=file_options)
+        # check if valid file exists BEFORE acquiring lock
+        if not file.exists or not file.info:
+            raise HTTPException(status_code=404, detail="Upload not found")
+        
+        # Ensure uploads directory exists before locking
+        uploads_dir = file_options.files_dir
+        os.makedirs(uploads_dir, exist_ok=True)
+        
+        # Create locks directory path (matches tusd's .locks directory)
+        locks_dir = os.path.join(uploads_dir, ".locks")
+        
+        # Acquire lock BEFORE any validation or reading to prevent race conditions
+        # This ensures we have exclusive access during the entire write operation
+        upload_path = file.path
+        try:
+            with acquire_upload_lock(upload_path, locks_dir=locks_dir, blocking=True):
+                # Re-read info file while holding lock to get latest offset
+                # This prevents TOCTOU race condition
+                file._info._loaded = False  # Force reload
+                current_info = file.info
+                
+                if current_info is None:
+                    raise HTTPException(status_code=404, detail="Upload not found")
+                
+                # Check if upload has expired (distinguish from non-existent uploads)
+                if current_info.expires:
+                    expires_dt = None
+                    if isinstance(current_info.expires, str):
+                        try:
+                            # Try RFC 7231 format first (e.g., "Mon, 02 Jan 2006 15:04:05 GMT")
+                            from email.utils import parsedate_to_datetime
+                            expires_dt = parsedate_to_datetime(current_info.expires)
+                        except (ValueError, TypeError):
+                            # Fallback to ISO format
+                            try:
+                                expires_dt = datetime.datetime.fromisoformat(current_info.expires.replace('Z', '+00:00'))
+                            except (ValueError, AttributeError):
+                                pass
+                    elif isinstance(current_info.expires, (int, float)):
+                        expires_dt = datetime.datetime.fromtimestamp(current_info.expires)
+                    
+                    if expires_dt:
+                        now = datetime.datetime.now(expires_dt.tzinfo) if expires_dt.tzinfo else datetime.datetime.now()
+                        if expires_dt < now:
+                            raise HTTPException(status_code=410, detail="Upload expired")
+
+                # Validate Upload-Offset header matches current file offset (required for PATCH)
+                # Use the offset we just read while holding the lock
+                upload_offset = request.headers.get("upload-offset")
+                if upload_offset is not None:
+                    try:
+                        upload_offset = int(upload_offset)
+                        if current_info.offset != upload_offset:
+                            raise HTTPException(status_code=409, detail="Offset mismatch")
+                    except (ValueError, TypeError):
+                        raise HTTPException(status_code=400, detail="Invalid Upload-Offset header")
+                else:
+                    # Upload-Offset is required for PATCH
+                    raise HTTPException(status_code=400, detail="Upload-Offset header is required")
+
+                # Use the validated offset directly - don't re-read from file.info
+                # This prevents stale offset issues
+                new_params = current_info
+                validated_offset = current_info.offset
+
+                # init variables
+                has_chunks = False
+                total_bytes_written = 0
+
+                # process chunk stream - lock is held during entire operation
+                with open(upload_path, "ab") as f:
+                    try:
+                        async for chunk in request.stream():
+                            has_chunks = True
+                            # skip empty chunks but continue processing
+                            if len(chunk) == 0:
+                                continue
+                            
+                            # Calculate new offset based on validated offset + bytes written so far
+                            new_offset = validated_offset + total_bytes_written
+                            
+                            # Check if upload would exceed declared size
+                            if (
+                                new_params.size is not None
+                                and new_offset + len(chunk) > new_params.size
+                            ):
+                                raise HTTPException(
+                                    status_code=400,
+                                    detail="Upload would exceed declared Upload-Length",
+                                )
+                            # throw if max size exceeded
+                            if new_offset + len(chunk) > options.max_size:
+                                raise HTTPException(
+                                    status_code=413,
+                                    detail="Upload exceeds maximum allowed size",
+                                )
+                            # write chunk otherwise
+                            f.write(chunk)
+                            f.flush()  # Ensure data is written to disk immediately
+                            total_bytes_written += len(chunk)
+                        
+                        # After all chunks are written, update params atomically
+                        # Lock is still held here, so this is safe
+                        new_params.offset = validated_offset + total_bytes_written
+                        new_params.upload_chunk_size = total_bytes_written if total_bytes_written > 0 else 0
+                        new_params.upload_part += 1
+                        # Save updated params (atomic write while lock is held)
+                        file.info = new_params
+                        
+                    except HTTPException:
+                        # HTTPExceptions should propagate - don't catch them here
+                        # The lock will be released by the context manager
+                        raise
+                    except ClientDisconnect:
+                        # Save the current offset before returning, so resume works correctly
+                        # Lock is still held, so this is safe
+                        new_params.offset = validated_offset + total_bytes_written
+                        new_params.upload_chunk_size = total_bytes_written if total_bytes_written > 0 else 0
+                        new_params.upload_part += 1
+                        file.info = new_params
+                        return False
+                    except Exception as e:
+                        # save the error
+                        new_params.error = str(e)
+                        new_params.offset = validated_offset + total_bytes_written
+                        # save updated params
+                        file.info = new_params
+                        return False
+                    finally:
+                        f.close()
+
+                # For empty files in a POST request, we still want to return True
+                # to ensure the file gets created properly
+                # Lock is still held here
+                if post_request and not has_chunks:
+                    # update params for empty file
+                    new_params.offset = validated_offset
+                    new_params.upload_chunk_size = 0
+                    new_params.upload_part += 1
+                    # save updated params
+                    file.info = new_params
+        except (IOError, OSError) as e:
+            # Lock acquisition or file operation failed
+            raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+        return True
+
+    return request_chunks_dep
+
+
+def get_request_headers(request: Request, uuid: str, prefix: str = "files") -> dict:
+    proto = "http"
+    host = request.headers.get("host")
+
+    # Check for forwarded headers first (for proxy setups)
+    if request.headers.get("X-Forwarded-Proto") is not None:
+        proto = request.headers.get("X-Forwarded-Proto")
+    if request.headers.get("X-Forwarded-Host") is not None:
+        host = request.headers.get("X-Forwarded-Host")
+
+    # If no forwarded protocol, try to detect scheme from request URL
+    # This handles direct HTTPS connections (e.g., Uvicorn with SSL)
+    if proto == "http" and not request.headers.get("X-Forwarded-Proto"):
+        try:
+            # Use request.url.scheme to detect the actual protocol
+            if hasattr(request, 'url') and request.url.scheme:
+                proto = request.url.scheme
+        except Exception:
+            # Fallback to default if URL parsing fails
+            pass
+
+    # Ensure we have a host
+    if not host:
+        host = "localhost:8000"  # fallback host
+
+    # Build the full path including root_path and router prefixes
+    # FastAPI includes the full mount path in request.url.path
+    # We need to construct the base path from the current request path
+    current_path = request.url.path.rstrip("/")
+
+    # The current path should end with our prefix (e.g., "/api/files")
+    # We want to extract everything before our prefix to build the location header
+    clean_prefix = prefix.lstrip("/").rstrip("/")
+
+    # Find where our prefix appears in the current path
+    if current_path == f"/{clean_prefix}":
+        # Handle case where current_path is exactly our prefix (e.g., "/files")
+        # This means there's no parent path in the URL, check for root_path
+        root_path = request.scope.get("root_path", "")
+        base_path = root_path.rstrip("/") if root_path else ""
+    elif current_path.endswith(f"/{clean_prefix}"):
+        # Extract the base path (everything before our prefix)
+        base_path = current_path[:-len(f"/{clean_prefix}")]
+    elif current_path.endswith(clean_prefix) and current_path != clean_prefix:
+        # Handle case where current_path doesn't have leading slash
+        base_path = current_path[:-len(clean_prefix)].rstrip("/")
+    else:
+        # Fallback: check for root_path in request scope
+        # This handles FastAPI root_path that might not be included in request.url.path
+        root_path = request.scope.get("root_path", "")
+        if root_path:
+            base_path = root_path.rstrip("/")
+        else:
+            base_path = ""
+
+    # Construct the full path
+    if base_path:
+        full_path = f"{base_path.rstrip('/')}/{clean_prefix}"
+    else:
+        full_path = clean_prefix
+
+    # Ensure path starts with /
+    if not full_path.startswith("/"):
+        full_path = "/" + full_path
+
+    return {
+        "location": f"{proto}://{host}{full_path}/{uuid}",
+        "proto": proto,
+        "host": host,
+    }