Debug - Database

Dockerfile

@@ -20,7 +20,7 @@ EXPOSE 7860
 
 # Explicitly create the /data directory where the SQLite DB will live
 # Running as root by default, so permissions should be okay initially
-RUN mkdir -p /data
+# RUN mkdir -p /data
 
 # Command to run the application using uvicorn
 # It will run the FastAPI app instance created in app/main.py

app/database.py

@@ -4,40 +4,32 @@ from databases import Database
 from dotenv import load_dotenv
 from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, text
 import logging
-from urllib.parse import urlparse, urlunparse, parse_qs, urlencode # For URL manipulation
+from urllib.parse import urlparse, urlunparse, parse_qs, urlencode
 
 load_dotenv()
 logger = logging.getLogger(__name__)
 
 # --- Database URL Configuration ---
-DEFAULT_DB_PATH = "/data/app.db"
-# Start with the base URL from env or default
+# --- CHANGE THIS LINE: Use path relative to WORKDIR (/code) ---
+# Using an absolute path inside /code is also fine: '/code/app.db'
+DEFAULT_DB_PATH = "/code/app.db" # Store DB in the main workdir
+
 raw_db_url = os.getenv("DATABASE_URL", f"sqlite+aiosqlite:///{DEFAULT_DB_PATH}")
 
-# Ensure 'check_same_thread=False' is in the URL for SQLite async connection
 final_database_url = raw_db_url
 if raw_db_url.startswith("sqlite+aiosqlite"):
-    # Parse the URL
     parsed_url = urlparse(raw_db_url)
-    # Parse existing query parameters into a dictionary
     query_params = parse_qs(parsed_url.query)
-    # Add check_same_thread=False ONLY if it's not already there
-    # (in case it's set via DATABASE_URL env var)
     if 'check_same_thread' not in query_params:
-        query_params['check_same_thread'] = ['False'] # Needs to be a list for urlencode
-        # Rebuild the query string
+        query_params['check_same_thread'] = ['False']
         new_query = urlencode(query_params, doseq=True)
-        # Rebuild the URL using _replace method of the named tuple
         final_database_url = urlunparse(parsed_url._replace(query=new_query))
     logger.info(f"Using final async DB URL: {final_database_url}")
 else:
     logger.info(f"Using non-SQLite async DB URL: {final_database_url}")
 
-
-# --- Async Database Instance (using 'databases' library) ---
-# Pass the *modified* URL. DO NOT pass connect_args separately here.
+# --- Async Database Instance ---
 database = Database(final_database_url)
-
 metadata = MetaData()
 users = Table(
     "users",
@@ -47,82 +39,66 @@ users = Table(
     Column("hashed_password", String, nullable=False),
 )
 
-# --- Synchronous Engine for Initial Table Creation (using SQLAlchemy Core) ---
-# Derive the sync URL (remove +aiosqlite). The query param should remain.
+# --- Synchronous Engine for Initial Table Creation ---
 sync_db_url = final_database_url.replace("+aiosqlite", "")
-
-# SQLAlchemy's create_engine *can* take connect_args, but for check_same_thread,
-# it also understands it from the URL query string. Let's rely on the URL for simplicity.
-# sync_connect_args = {"check_same_thread": False} if sync_db_url.startswith("sqlite") else {} # Keep for reference if other args are needed
-
 logger.info(f"Using synchronous DB URL for initial check/create: {sync_db_url}")
-# Create the engine using the URL which now includes ?check_same_thread=False
-engine = create_engine(sync_db_url) # No connect_args needed here if only using check_same_thread
+engine = create_engine(sync_db_url)
 
 # --- Directory and Table Creation Logic ---
-# Extract path correctly, ignoring query parameters for os.path operations
 db_file_path = ""
 if sync_db_url.startswith("sqlite"):
-    # Get the path part after 'sqlite:///' and before '?'
     path_part = sync_db_url.split("sqlite:///")[-1].split("?")[0]
-    # Ensure it's an absolute path if it starts with /
-    if path_part.startswith('/'):
-        db_file_path = path_part
-    else:
-        # Handle relative paths if they were somehow configured (though /data should be absolute)
-        # This case is less likely with our default /data/app.db
-        db_file_path = os.path.abspath(path_part)
-
+    # Use os.path.abspath to resolve relative paths based on WORKDIR
+    db_file_path = os.path.abspath(path_part) # Should resolve to /code/app.db
 
 if db_file_path:
-    db_dir = os.path.dirname(db_file_path)
+    # --- CHANGE THIS LINE: Check writability of the target directory ---
+    db_dir = os.path.dirname(db_file_path) # Should be /code
     logger.info(f"Ensuring database directory exists: {db_dir}")
     try:
-        if db_dir and not os.path.exists(db_dir):
-            os.makedirs(db_dir, exist_ok=True)
-            logger.info(f"Created database directory: {db_dir}")
-        # Add a check for writability after ensuring directory exists
-        if db_dir and not os.access(db_dir, os.W_OK):
-             logger.error(f"Database directory {db_dir} is not writable!")
-        # Also check if the file itself can be created/opened (might fail here if dir is writable but file isn't)
-        # This check is implicitly done by engine.connect() below
+        # Directory /code should exist because it's the WORKDIR
+        # We mainly need to check if it's writable
+        if not os.path.exists(db_dir):
+             logger.warning(f"Database directory {db_dir} does not exist! Attempting creation (may fail).")
+             # This shouldn't really happen for /code unless WORKDIR is wrong
+             os.makedirs(db_dir, exist_ok=True)
+
+        if not os.access(db_dir, os.W_OK):
+            # If /code isn't writable, we have a bigger problem
+            logger.error(f"Database directory {db_dir} is not writable! Database creation will likely fail.")
+        else:
+            logger.info(f"Database directory {db_dir} appears writable.")
 
     except OSError as e:
-        logger.error(f"Error creating or accessing database directory {db_dir}: {e}")
+        logger.error(f"Error accessing database directory {db_dir}: {e}")
     except Exception as e:
-        logger.error(f"Unexpected error checking/creating DB directory {db_dir}: {e}")
-
+        logger.error(f"Unexpected error checking directory {db_dir}: {e}")
 
 # Now try connecting and creating the table with the sync engine
 try:
     logger.info("Attempting to connect with sync engine to check/create table...")
     with engine.connect() as connection:
         try:
-            # Use text() for literal SQL
             connection.execute(text("SELECT 1 FROM users LIMIT 1"))
             logger.info("Users table already exists.")
-        except Exception as table_check_exc: # Catch specific DB errors if possible
+        except Exception as table_check_exc:
             logger.warning(f"Users table check failed ({type(table_check_exc).__name__}), attempting creation...")
-            # Pass the engine explicitly to create_all
             metadata.create_all(bind=engine)
             logger.info("Users table created (or creation attempted).")
 
 except Exception as e:
-    # This OperationalError "unable to open database file" might still indicate
-    # a fundamental permission issue with /data/app.db in the HF environment.
+    # Hopefully, this won't happen now if /code is writable
     logger.exception(f"CRITICAL: Failed to connect/create database tables using sync engine: {e}")
 
 
 # --- Async connect/disconnect functions ---
 async def connect_db():
     try:
-        # The 'database' instance now uses the URL with the query param
         await database.connect()
         logger.info(f"Database connection established (async): {final_database_url}")
     except Exception as e:
         logger.exception(f"Failed to establish async database connection: {e}")
-        # If the sync engine failed earlier due to permissions, this might fail too.
-        raise # Reraise critical error during startup lifespan
+        raise
 
 async def disconnect_db():
     try: