ssl logic

controller.py

@@ -60,7 +60,7 @@ logging.basicConfig(
 logger = logging.getLogger("API_Controller")
 
 # ==============================================================================
-# ASYNC CONNECTION POOL MANAGER
+# ASYNC CONNECTION POOL MANAGER (UPDATED WITH SSL FALLBACK)
 # ==============================================================================
 class AsyncPoolManager:
     def __init__(self):
@@ -70,21 +70,52 @@ class AsyncPoolManager:
 
     async def get_pg_pool(self, db_url: str) -> asyncpg.Pool:
         async with self._lock:
-            if db_url not in self._pg_pools:
-                logger.info(f"Creating new AsyncPG pool for: {db_url[:25]}...")
-                try:
-                    # asyncpg handles Keepalives and SSL automatically better than psycopg2
-                    pool = await asyncpg.create_pool(
-                        dsn=db_url,
-                        min_size=1,
-                        max_size=20,
-                        max_inactive_connection_lifetime=300,
-                        command_timeout=60
-                    )
-                    self._pg_pools[db_url] = pool
-                except Exception as e:
-                    logger.error(f"Failed to create PG pool: {e}")
+            if db_url in self._pg_pools:
+                return self._pg_pools[db_url]
+
+            logger.info(f"Creating new AsyncPG pool for: {db_url[:25]}...")
+            
+            # Define connection logic
+            async def attempt_connect(force_no_ssl: bool = False):
+                # Common config
+                config = {
+                    "dsn": db_url,
+                    "min_size": 1,
+                    "max_size": 20,
+                    "max_inactive_connection_lifetime": 300,
+                    "command_timeout": 60
+                }
+                
+                # If falling back, explicitly disable SSL (overrides DSN settings in most cases)
+                if force_no_ssl:
+                    config["ssl"] = False
+                    
+                return await asyncpg.create_pool(**config)
+
+            try:
+                # 1. Try Default Connection (uses DSN settings or defaults)
+                pool = await attempt_connect(force_no_ssl=False)
+                logger.info("✅ Connected to Postgres (Standard/SSL)")
+                self._pg_pools[db_url] = pool
+                
+            except Exception as e:
+                err_msg = str(e).lower()
+                # 2. Check for SSL specific errors
+                # "server does not support ssl" is the specific error from Postgres
+                # "sslerror" covers generic python ssl issues
+                if "ssl" in err_msg or "certificate" in err_msg or "connection reset" in err_msg:
+                    logger.warning(f"⚠️ SSL Connection failed ({e}). Retrying with SSL DISABLED...")
+                    try:
+                        pool = await attempt_connect(force_no_ssl=True)
+                        logger.info("✅ Connected to Postgres (No SSL Fallback)")
+                        self._pg_pools[db_url] = pool
+                    except Exception as retry_e:
+                        logger.error(f"❌ Postgres Retry Failed: {retry_e}")
+                        raise retry_e
+                else:
+                    logger.error(f"❌ Failed to create PG pool: {e}")
                     raise e
+                    
         return self._pg_pools[db_url]
 
     async def get_mysql_pool(self, db_url: str) -> asyncmy.Pool:
@@ -94,37 +125,54 @@ class AsyncPoolManager:
 
         async with self._lock:
             # Check again inside lock
-            if db_url not in self._mysql_pools:
-                logger.info(f"Creating new AsyncMy pool for: {db_url[:25]}...")
-                parsed = urlparse(db_url)
-                qs = parse_qs(parsed.query)
-                
-                # Determine SSL settings
-                # asyncmy needs an SSL context or ssl=True/False
-                ssl_ctx = None
-                if 'ssl-mode' in qs:
-                    mode = qs['ssl-mode'][0].upper()
-                    if mode != 'DISABLED':
-                        # Create a default SSL context that allows self-signed certs (common in cloud DBs)
-                        ssl_ctx = ssl.create_default_context()
-                        ssl_ctx.check_hostname = False
-                        ssl_ctx.verify_mode = ssl.CERT_NONE
-                
-                try:
-                    pool = await asyncmy.create_pool(
-                        user=parsed.username,
-                        password=parsed.password,
-                        host=parsed.hostname,
-                        port=parsed.port or 3306,
-                        db=parsed.path.lstrip("/"),
-                        minsize=1,
-                        maxsize=20,
-                        autocommit=True,
-                        pool_recycle=280,
-                        ssl=ssl_ctx # Pass the SSL context explicitly
-                    )
-                    self._mysql_pools[db_url] = pool
-                except Exception as e:
+            if db_url in self._mysql_pools:
+                return self._mysql_pools[db_url]
+
+            logger.info(f"Creating new AsyncMy pool for: {db_url[:25]}...")
+            parsed = urlparse(db_url)
+            qs = parse_qs(parsed.query)
+            
+            # Determine initial SSL settings
+            initial_ssl_ctx = None
+            if 'ssl-mode' in qs:
+                mode = qs['ssl-mode'][0].upper()
+                if mode != 'DISABLED':
+                    initial_ssl_ctx = ssl.create_default_context()
+                    initial_ssl_ctx.check_hostname = False
+                    initial_ssl_ctx.verify_mode = ssl.CERT_NONE
+            
+            # Helper to create pool
+            async def attempt_connect(ssl_context):
+                return await asyncmy.create_pool(
+                    user=parsed.username,
+                    password=parsed.password,
+                    host=parsed.hostname,
+                    port=parsed.port or 3306,
+                    db=parsed.path.lstrip("/"),
+                    minsize=1,
+                    maxsize=20,
+                    autocommit=True,
+                    pool_recycle=280,
+                    ssl=ssl_context 
+                )
+
+            try:
+                # 1. Try with calculated SSL context
+                pool = await attempt_connect(initial_ssl_ctx)
+                logger.info("✅ Connected to MySQL")
+                self._mysql_pools[db_url] = pool
+            except Exception as e:
+                # 2. If it fails and we were trying to use SSL, try disabling it
+                if initial_ssl_ctx is not None:
+                    logger.warning(f"⚠️ MySQL SSL handshake failed ({e}). Retrying without SSL...")
+                    try:
+                        pool = await attempt_connect(None) # Pass None to disable SSL
+                        logger.info("✅ Connected to MySQL (No SSL Fallback)")
+                        self._mysql_pools[db_url] = pool
+                    except Exception as retry_e:
+                        logger.error(f"❌ MySQL Retry Failed: {retry_e}")
+                        raise retry_e
+                else:
                     logger.error(f"Failed to create MySQL pool: {e}")
                     raise e