update: 💾 minio support added

Author: jiisanda

Dockerfile api.DockerfileDockerfile renamed to api.Dockerfile

@@ -3,11 +3,11 @@ LABEL authors="jiisanda"
 
 WORKDIR /usr/src/app
 
-COPY requirements.txt ./
+COPY requirements/api.txt ./
 
 RUN pip install --upgrade pip
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir -r api.txt  # Fix the path here too
 
 COPY . .
 
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/api/dependencies/repositories.py

@@ -1,5 +1,7 @@
 import os.path
 import re
+from typing import Optional
+
 import ulid
 
 from fastapi import Depends
@@ -35,20 +37,30 @@ def _get_repository(session: AsyncSession = Depends(get_db)):
 
 
 async def get_s3_url(key: str) -> str:
+    if settings.s3_endpoint_url:
+        # minio URL format
+        return f"{settings.s3_endpoint_url}/{settings.s3_bucket}/{key}"
     return f"https://{settings.s3_bucket}.s3.{settings.aws_region}.amazonaws.com/{key}"
 
 
-async def get_key(s3_url: str) -> str:
-
-    pattern = (
-        f"https://{settings.s3_bucket}"
-        + r"\.s3\."
-        + settings.aws_region
-        + r"\.amazonaws\.com/"
-        + r"(.+)"
-    )
-    if match := re.search(pattern, s3_url):
-        return match[1]
+async def get_key(s3_url: str) -> Optional[str]:
+    if settings.s3_endpoint_url:
+        # minio url format: http://host:9000/bucket/key
+        # remove the endpoint and bucket form the URL
+        url_without_endpoint = s3_url.replace(settings.s3_endpoint_url, "")
+        url_without_bucket = url_without_endpoint.replace(f"/{settings.s3_bucket}/", "")
+        return url_without_bucket.lstrip("/")
+    else:
+        pattern = (
+            f"https://{settings.s3_bucket}"
+            + r"\.s3\."
+            + settings.aws_region
+            + r"\.amazonaws\.com/"
+            + r"(.+)"
+        )
+        if match := re.search(pattern, s3_url):
+            return match[1]
+        return None
 
 
 def get_ulid():

app/core/config.py

@@ -26,9 +26,11 @@ class GlobalConfig(BaseSettings):
     postgres_port: int = int(os.environ.get("POSTGRES_PORT"))
     postgres_db: str = os.environ.get("POSTGRES_DB")
     db_echo_log: bool = str(os.environ.get("DEBUG", "False")).lower() == "true"
+    # s3 / minio configurations
     aws_access_key_id: str = os.environ.get("AWS_ACCESS_KEY_ID")
     aws_secret_key: str = os.environ.get("AWS_SECRET_ACCESS_KEY")
-    aws_region: str = os.environ.get("AWS_REGION")
+    aws_region: str = os.environ.get("AWS_REGION", "us-east-1")     # minio doesn't care about a region
+    s3_endpoint_url: str = os.environ.get("S3_ENDPOINT_URL")
     s3_bucket: str = os.environ.get("S3_BUCKET")
     s3_test_bucket: str = os.environ.get("S3_TEST_BUCKET")
     # user config

app/db/repositories/documents/documents.py

@@ -34,12 +34,25 @@ async def perm_delete(
 class DocumentRepository:
 
     def __init__(self):
-        self.s3_client = boto3.resource("s3")
-        self.client = boto3.client("s3")
+        boto3_config = {
+            "aws_access_key_id": settings.aws_access_key_id,
+            "aws_secret_access_key": settings.aws_secret_key,
+            "region_name": settings.aws_region,
+        }
+        
+        if settings.s3_endpoint_url:
+            boto3_config["endpoint_url"] = settings.s3_endpoint_url
+
+        self.s3_client = boto3.resource("s3", **boto3_config)
+        self.client = boto3.client("s3", **boto3_config)
         self.s3_bucket = self.s3_client.Bucket(settings.s3_bucket)
-        self.client.put_bucket_versioning(
-            Bucket=settings.s3_bucket, VersioningConfiguration={"Status": "Enabled"}
-        )
+        try:
+            self.client.put_bucket_versioning(
+                Bucket=settings.s3_bucket, VersioningConfiguration={"Status": "Enabled"}
+            )
+        except Exception as e:
+            # Minio does not support versioning in all configurations
+            ...
 
     @staticmethod
     async def _calculate_file_hash(file: File) -> str:
@@ -72,7 +85,7 @@ async def _upload_new_file(
         else:
             key = f"{user.id}/{folder}/{str(ULID())}.{SUPPORTED_FILE_TYPES[file_type]}"
 
-        self.s3_bucket.put_object(Bucket=settings.s3_bucket, Key=key, Body=contents)
+        self.s3_bucket.put_object(Key=key, Body=contents)
 
         return {
             "response": "file_added",
@@ -98,7 +111,7 @@ async def _upload_new_version(
 
         key = await get_key(s3_url=doc["s3_url"])
 
-        self.s3_bucket.put_object(Bucket=settings.s3_bucket, Key=key, Body=contents)
+        self.s3_bucket.put_object(Key=key, Body=contents)
 
         return {
             "response": "file_updated",

app/logs/logger.py

@@ -1,63 +1,142 @@
-from os.path import join, abspath, dirname
+import os
 import logging
 import logging.config
-
+from pathlib import Path
 
 LOGGER_NAME: str = "docflow"
 LOG_FORMAT: str = (
     "%(asctime)s [%(levelname)s] | %(name)s | %(filename)s | %(funcName)s | %(lineno)d | %(message)s"
 )
 LOG_LEVEL: int = logging.DEBUG
 
-BASE_DIR = abspath(dirname(__file__))
 
-LOG_FILE: str = join(BASE_DIR, "docflow.log")
+def get_log_file_path():
+    """
+    Get a writable log file path, trying multiple locations.
+    Returns None if no writable location is found.
+    """
+    possible_locations = [
+        "/usr/src/app/logs/docflow.log",
+        "/app/logs/docflow.log",
+        "/tmp/docflow.log",
+        "docflow.log",
+    ]
+
+    for log_path in possible_locations:
+        try:
+            log_file = Path(log_path)
+            log_file.parent.mkdir(parents=True, exist_ok=True)
+
+            test_write = log_file.parent / f"test_write_{os.getpid()}.tmp"
+            test_write.touch()
+            test_write.unlink()
+
+            return str(log_file)
+        except (OSError, PermissionError):
+            continue
+
+    return None
+
+
+LOG_FILE = get_log_file_path()
 
 LOGGING = {
     "version": 1,
-    "disable_existing_logger": False,
+    "disable_existing_loggers": False,
     "formatters": {
         "standard": {
             "format": LOG_FORMAT,
             "datefmt": "%Y-%m-%d %H:%M:%S",
         },
+        "console": {
+            "format": "%(asctime)s [%(levelname)s] | %(name)s | %(message)s",
+            "datefmt": "%Y-%m-%d %H:%M:%S",
+        },
     },
     "handlers": {
-        "default": {
+        "console": {
             "level": "INFO",
-            "formatter": "standard",
+            "formatter": "console",
             "class": "logging.StreamHandler",
-            "stream": "ext://sys.stderr",
+            "stream": "ext://sys.stdout",
         },
-        "file": {
-            "class": "logging.handlers.RotatingFileHandler",
+        "error_console": {
+            "level": "ERROR",
             "formatter": "standard",
-            "level": "DEBUG",
-            "filename": "docflow.log",
-            "mode": "a",
-            "encoding": "utf-8",
-            "maxBytes": 500000,
-            "backupCount": 4,
+            "class": "logging.StreamHandler",
+            "stream": "ext://sys.stderr",
         },
     },
     "loggers": {
-        "": {"handlers": ["default"], "level": "INFO", "propagate": True},
+        "": {
+            "handlers": ["console"],
+            "level": "INFO",
+            "propagate": False
+        },
         LOGGER_NAME: {
-            "handlers": ["default", "file"],
+            "handlers": ["console", "error_console"],
             "level": LOG_LEVEL,
             "propagate": False,
         },
-        "sqlalchemy": {"handlers": ["file"], "level": "WARNING"},
-        "s3": {"handlers": ["file"], "level": "WARNING"},
-        "uvicorn.error": {"level": "INFO", "handlers": ["default"], "propagate": False},
-        "uvicorn.access": {"level": "INFO", "handlers": ["default"], "propagate": True},
-        "uvicorn.asgi": {"level": "INFO", "handlers": ["default"], "propagate": True},
+        "sqlalchemy": {
+            "handlers": ["console"],
+            "level": "WARNING",
+            "propagate": False,
+        },
+        "s3": {
+            "handlers": ["console"],
+            "level": "WARNING",
+            "propagate": False,
+        },
+        "uvicorn.error": {
+            "level": "INFO",
+            "handlers": ["console"],
+            "propagate": False
+        },
+        "uvicorn.access": {
+            "level": "INFO",
+            "handlers": ["console"],
+            "propagate": False
+        },
+        "uvicorn.asgi": {
+            "level": "INFO",
+            "handlers": ["console"],
+            "propagate": False
+        },
     },
 }
 
-logging.config.dictConfig(LOGGING)
+if LOG_FILE:
+    LOGGING["handlers"]["file"] = {
+        "class": "logging.handlers.RotatingFileHandler",
+        "formatter": "standard",
+        "level": "DEBUG",
+        "filename": LOG_FILE,
+        "mode": "a",
+        "encoding": "utf-8",
+        "maxBytes": 500000,
+        "backupCount": 4,
+    }
 
-# loggers
-docflow_logger = logging.getLogger("docflow")
+    LOGGING["loggers"][LOGGER_NAME]["handlers"].append("file")
+    LOGGING["loggers"]["sqlalchemy"]["handlers"].append("file")
+    LOGGING["loggers"]["s3"]["handlers"].append("file")
+
+try:
+    logging.config.dictConfig(LOGGING)
+except Exception as e:
+    logging.basicConfig(
+        level=LOG_LEVEL,
+        format=LOG_FORMAT,
+        handlers=[logging.StreamHandler()]
+    )
+    print(f"Warning: Failed to configure logging: {e}")
+
+docflow_logger = logging.getLogger(LOGGER_NAME)
 s3_logger = logging.getLogger("s3")
 sqlalchemy_logger = logging.getLogger("sqlalchemy")
+
+if LOG_FILE:
+    docflow_logger.info(f"File logging enabled: {LOG_FILE}")
+else:
+    docflow_logger.warning("File logging disabled - no writable location found")

app/main.py

@@ -1,17 +1,36 @@
+from contextlib import asynccontextmanager
+
 from fastapi import FastAPI
 from fastapi.responses import FileResponse
 
 from app.api.router import router
 from app.core.config import settings
 from app.db.models import check_tables
+from app.logs.logger import docflow_logger
+from app.scripts.init_bucket import create_bucket_if_not_exists
+
 
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    docflow_logger.info("Starting DocFlow...")
+    
+    try:
+        docflow_logger.info("Initializing Tables and Storage buckets...")
+        await check_tables()
+        await create_bucket_if_not_exists()
+        docflow_logger.info("Tables and Storage buckets successfully created.")
+    except Exception as e:
+        docflow_logger.error(f"Error during startup: {e}")
+        raise
+    yield 
 
 app = FastAPI(
     title=settings.title,
     version=settings.version,
     description=settings.description,
     docs_url=settings.docs_url,
     openapi_url=settings.openapi_url,
+    lifespan=lifespan,
 )
 
 app.include_router(router=router, prefix=settings.api_prefix)
@@ -28,10 +47,18 @@ async def favicon():
 @app.get("/", tags=["Default"])
 async def root():
     return {
-        "API": "Document Management API... Docker's up!!! is it? or not... Yes it is!!!"
+        "API": "DocFlow - Document Management API is running! 🚀",
+        "version": settings.version,
+        "docs": f"{settings.host_url}{settings.docs_url}",
+        "storage": "MinIO" if settings.s3_endpoint_url else "AWS S3"
     }
 
 
-@app.on_event("startup")
-async def app_startup() -> None:
-    return await check_tables()
+@app.get("/health", tags=["Default"])
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "service": "DocFlow API",
+        "version": settings.version
+    }