107 lines
3.8 KiB
Markdown
107 lines
3.8 KiB
Markdown
# Phase 2: Storage Service
|
|
|
|
## Objective
|
|
Implement the backend service layer that handles all disk operations: uploading files to hashed paths, resolving file metadata, and serving content. This module is `backend/src/drive_service.py`.
|
|
|
|
## Concepts
|
|
|
|
### Database-First Metadata
|
|
Files are database records pointing to disk locations. Access paths are constructed lazily via a resolve function so internal path formats can change without breaking external references.
|
|
|
|
### Minimal Backend Layers
|
|
Access flows through three strict stages:
|
|
1. **Auth**: Bearer token validation.
|
|
2. **DB Lookup**: Verify ownership (`user_id`) and Drive existence.
|
|
3. **Serve**: If requesting raw content, pass the resolved disk path to Quart's send functions.
|
|
|
|
The router stays thin; the database handles all authorization before any file system calls.
|
|
|
|
## Tasks
|
|
|
|
### 2.1 Implement `drive_service.py`
|
|
|
|
Create `backend/src/drive_service.py` with the following core functions:
|
|
|
|
```python
|
|
import os
|
|
from pathlib import Path
|
|
import secrets
|
|
from datetime import timezone
|
|
import database as db
|
|
|
|
DRIVES_ROOT = None
|
|
|
|
async def init_drives(data_directory):
|
|
"""Initialize DRIVES_ROOT global from app startup."""
|
|
global DRIVES_ROOT
|
|
DRIVES_ROOT = os.path.join(data_directory, "drives")
|
|
os.makedirs(DRIVES_ROOT, exist_ok=True)
|
|
|
|
def _generate_disk_hash():
|
|
"""Generate a random hex string for filesystem-level filenames."""
|
|
return secrets.token_hex(8)
|
|
|
|
async def upload_file(user_id, drive_name, readable_filename, stream, mime_type=None):
|
|
"""Write an incoming stream to disk and register it in the DB. Returns file ID."""
|
|
# 1. Locate or create Drive
|
|
drive = await db.Drive.get_or_none(user_id=user_id, name=drive_name)
|
|
if not drive:
|
|
drive = await db.Drive.create(user_id=user_id, name=drive_name)
|
|
|
|
# 2. Prepare disk path
|
|
disk_hash = _generate_disk_hash()
|
|
drive_dir = os.path.join(DRIVES_ROOT, str(user_id), drive_name)
|
|
os.makedirs(drive_dir, exist_ok=True)
|
|
file_path = os.path.join(drive_dir, disk_hash)
|
|
|
|
# 3. Write stream and calculate size
|
|
size = 0
|
|
with open(file_path, "wb") as f:
|
|
while chunk := stream.read(8192):
|
|
f.write(chunk)
|
|
size += len(chunk)
|
|
|
|
# 4. Register in database
|
|
record = await db.DriveFile.create(
|
|
drive_id=drive.id,
|
|
filename=readable_filename,
|
|
disk_hash=disk_hash,
|
|
mime_type=mime_type or "application/octet-stream",
|
|
size_bytes=size,
|
|
)
|
|
return record.id
|
|
|
|
async def get_drive_file_metadata(file_id):
|
|
"""Return JSON metadata for frontend display."""
|
|
file = await db.DriveFile.get_or_none(id=file_id)
|
|
if not file:
|
|
raise Exception("File not found")
|
|
return {
|
|
"id": file.id,
|
|
"name": file.filename,
|
|
"size": file.size_bytes,
|
|
"mime": file.mime_type,
|
|
"created": file.created_at.isoformat(),
|
|
"accessed": file.accessed_at.isoformat() if file.accessed_at else None
|
|
}
|
|
|
|
async def resolve_drive_file_for_serving(file_id, current_user_id):
|
|
"""Resolve file to absolute disk path after permission check. Returns (path, mime)."""
|
|
# Eager load drive and verify ownership
|
|
file = await db.DriveFile.filter(id=file_id).select_related("drive__user").get_or_none()
|
|
if not file:
|
|
raise FileNotFoundError("File not found")
|
|
if file.drive.user_id != current_user_id:
|
|
raise PermissionError("Access denied")
|
|
|
|
# Update access time asynchronously
|
|
from asyncio import create_task
|
|
create_task(db.DriveFile.filter(id=file_id).update(accessed_at=timezone.now()))
|
|
|
|
abs_path = os.path.join(DRIVES_ROOT, str(file.drive.user_id), file.drive.name, file.disk_hash)
|
|
if not os.path.exists(abs_path):
|
|
raise FileNotFoundError("File missing on disk")
|
|
|
|
return abs_path, file.mime_type
|
|
```
|