quantum-framework 0.18.0__py3-none-any.whl

quantum_admin/backend/database.py

@@ -0,0 +1,226 @@
+"""
+Database configuration and session management
+"""
+import os
+from datetime import datetime
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from .models import Base
+
+# SQLite database file location - use absolute path relative to quantum_admin folder
+_QUANTUM_ADMIN_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_DB_PATH = os.path.join(_QUANTUM_ADMIN_DIR, "quantum_admin.db")
+
+# QUANTUM_ADMIN_DATABASE_URL overrides the location. The path used to be fixed,
+# so the admin test suite created and deleted rows in the same database the
+# admin serves — every `pytest` run wrote into the developer's real data.
+DATABASE_URL = os.environ.get("QUANTUM_ADMIN_DATABASE_URL") or f"sqlite:///{_DB_PATH}"
+
+# Create engine with SQLite-specific settings
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {},
+    echo=False  # Set to True for SQL query logging during development
+)
+
+# Create session factory
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def init_db():
+    """
+    Initialize database - create all tables
+    Call this on application startup
+    """
+    Base.metadata.create_all(bind=engine)
+    print("[OK] Database initialized successfully")
+
+
+def seed_db():
+    """
+    Seed database with sample data if empty
+    """
+    from . import models
+    import uuid
+
+    db = SessionLocal()
+    try:
+        # Check if we already have data
+        existing_projects = db.query(models.Project).first()
+        if existing_projects:
+            print("[OK] Database already has data, skipping seed")
+            return
+
+        print("[INFO] Seeding database with sample data...")
+
+        # Create sample projects
+        projects = [
+            models.Project(
+                name="Blog Application",
+                description="A full-featured blog with posts, comments, and user authentication",
+                status="active"
+            ),
+            models.Project(
+                name="E-Commerce API",
+                description="REST API for an e-commerce platform with products, orders, and payments",
+                status="active"
+            ),
+            models.Project(
+                name="Dashboard App",
+                description="Real-time analytics dashboard with charts and data visualization",
+                status="inactive"
+            ),
+        ]
+        for p in projects:
+            db.add(p)
+        db.flush()
+
+        # Create sample connectors (id is String, required)
+        connectors = [
+            models.Connector(
+                id="postgres-prod",
+                name="PostgreSQL Production",
+                type="database",
+                provider="postgres",
+                host="db.example.com",
+                port=5432,
+                database="production",
+                status="connected"
+            ),
+            models.Connector(
+                id="redis-cache",
+                name="Redis Cache",
+                type="cache",
+                provider="redis",
+                host="redis.example.com",
+                port=6379,
+                status="connected"
+            ),
+            models.Connector(
+                id="s3-storage",
+                name="AWS S3 Storage",
+                type="storage",
+                provider="s3",
+                database="my-app-files",
+                status="disconnected"
+            ),
+        ]
+        for c in connectors:
+            db.add(c)
+
+        # Create sample environments for first project
+        environments = [
+            models.Environment(
+                name="dev",
+                display_name="Development",
+                project_id=1,
+                order=1,
+                branch="develop",
+                is_active=True
+            ),
+            models.Environment(
+                name="staging",
+                display_name="Staging",
+                project_id=1,
+                order=2,
+                branch="staging",
+                is_active=True
+            ),
+            models.Environment(
+                name="production",
+                display_name="Production",
+                project_id=1,
+                order=3,
+                branch="main",
+                requires_approval=True,
+                is_active=True
+            ),
+        ]
+        for e in environments:
+            db.add(e)
+
+        # Create sample application logs
+        from datetime import timedelta
+        sample_logs = [
+            models.ApplicationLog(
+                project_id=1,
+                timestamp=datetime.utcnow() - timedelta(minutes=5),
+                level="INFO",
+                source="app",
+                message="Application started successfully",
+                component_name="main"
+            ),
+            models.ApplicationLog(
+                project_id=1,
+                timestamp=datetime.utcnow() - timedelta(minutes=4),
+                level="INFO",
+                source="database",
+                message="Database connection established",
+                response_time_ms=45
+            ),
+            models.ApplicationLog(
+                project_id=1,
+                timestamp=datetime.utcnow() - timedelta(minutes=3),
+                level="INFO",
+                source="access",
+                message="GET /api/posts 200",
+                request_method="GET",
+                request_path="/api/posts",
+                response_status=200,
+                response_time_ms=120
+            ),
+            models.ApplicationLog(
+                project_id=1,
+                timestamp=datetime.utcnow() - timedelta(minutes=2),
+                level="WARNING",
+                source="api",
+                message="External API rate limit approaching",
+                component_name="oauth_service"
+            ),
+            models.ApplicationLog(
+                project_id=1,
+                timestamp=datetime.utcnow() - timedelta(minutes=1),
+                level="INFO",
+                source="security",
+                message="User login successful: admin@example.com",
+                component_name="auth"
+            ),
+            models.ApplicationLog(
+                project_id=1,
+                timestamp=datetime.utcnow(),
+                level="INFO",
+                source="deploy",
+                message="Deployment completed: v1.2.3",
+                component_name="deployer"
+            ),
+        ]
+        for log in sample_logs:
+            db.add(log)
+
+        db.commit()
+        print("[OK] Database seeded with sample data")
+
+    except Exception as e:
+        db.rollback()
+        print(f"[ERROR] Failed to seed database: {e}")
+        import traceback
+        traceback.print_exc()
+    finally:
+        db.close()
+
+
+def get_db():
+    """
+    Dependency for FastAPI endpoints
+    Provides a database session and ensures cleanup
+
+    Usage:
+        @app.get("/items")
+        def get_items(db: Session = Depends(get_db)):
+            return db.query(Item).all()
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

quantum_admin/backend/db_setup_service.py

@@ -0,0 +1,193 @@
+"""
+Database Setup Service
+Handles initial configuration of database containers
+"""
+import logging
+import time
+import psycopg2
+import pymysql
+from pymongo import MongoClient
+
+logger = logging.getLogger(__name__)
+
+
+class DatabaseSetupService:
+    """Service for setting up databases in containers"""
+
+    @staticmethod
+    def setup_database(datasource) -> tuple[bool, str]:
+        """
+        Setup database based on type
+
+        Returns:
+            tuple: (success: bool, message: str)
+        """
+        try:
+            db_type = datasource.type.lower()
+
+            if db_type == 'postgres':
+                return DatabaseSetupService._setup_postgres(datasource)
+            elif db_type in ['mysql', 'mariadb']:
+                return DatabaseSetupService._setup_mysql(datasource)
+            elif db_type == 'mongodb':
+                return DatabaseSetupService._setup_mongodb(datasource)
+            elif db_type == 'redis':
+                # Redis doesn't need setup
+                return True, "Redis is ready to use"
+            else:
+                return False, f"Unsupported database type: {db_type}"
+
+        except Exception as e:
+            logger.error(f"Database setup failed: {e}")
+            return False, str(e)
+
+    @staticmethod
+    def _setup_postgres(datasource) -> tuple[bool, str]:
+        """Setup PostgreSQL database"""
+        max_retries = 30
+        retry_delay = 2
+
+        for attempt in range(max_retries):
+            try:
+                # Connect to default postgres database
+                conn = psycopg2.connect(
+                    host=datasource.host,
+                    port=datasource.port,
+                    database='postgres',
+                    user=datasource.username,
+                    password=datasource.password_encrypted,
+                    connect_timeout=5
+                )
+                conn.autocommit = True
+                cursor = conn.cursor()
+
+                # Check if database exists
+                cursor.execute(
+                    "SELECT 1 FROM pg_database WHERE datname = %s",
+                    (datasource.database_name,)
+                )
+
+                if not cursor.fetchone():
+                    # Create database
+                    cursor.execute(
+                        f'CREATE DATABASE "{datasource.database_name}" '
+                        f'OWNER "{datasource.username}"'
+                    )
+                    logger.info(f"Created database: {datasource.database_name}")
+
+                cursor.close()
+                conn.close()
+
+                # Test connection to new database
+                test_conn = psycopg2.connect(
+                    host=datasource.host,
+                    port=datasource.port,
+                    database=datasource.database_name,
+                    user=datasource.username,
+                    password=datasource.password_encrypted,
+                    connect_timeout=5
+                )
+                test_conn.close()
+
+                return True, f"PostgreSQL database '{datasource.database_name}' is ready"
+
+            except psycopg2.OperationalError as e:
+                if attempt < max_retries - 1:
+                    logger.info(f"Waiting for PostgreSQL to be ready... (attempt {attempt + 1}/{max_retries})")
+                    time.sleep(retry_delay)
+                else:
+                    return False, f"PostgreSQL failed to start: {str(e)}"
+            except Exception as e:
+                return False, f"PostgreSQL setup error: {str(e)}"
+
+    @staticmethod
+    def _setup_mysql(datasource) -> tuple[bool, str]:
+        """Setup MySQL/MariaDB database"""
+        max_retries = 30
+        retry_delay = 2
+
+        for attempt in range(max_retries):
+            try:
+                # Connect to MySQL server
+                conn = pymysql.connect(
+                    host=datasource.host,
+                    port=datasource.port,
+                    user=datasource.username,
+                    password=datasource.password_encrypted,
+                    connect_timeout=5
+                )
+                cursor = conn.cursor()
+
+                # Create database if not exists
+                cursor.execute(f"CREATE DATABASE IF NOT EXISTS `{datasource.database_name}`")
+
+                # Grant privileges
+                cursor.execute(
+                    f"GRANT ALL PRIVILEGES ON `{datasource.database_name}`.* "
+                    f"TO '{datasource.username}'@'%'"
+                )
+                cursor.execute("FLUSH PRIVILEGES")
+
+                cursor.close()
+                conn.close()
+
+                # Test connection to new database
+                test_conn = pymysql.connect(
+                    host=datasource.host,
+                    port=datasource.port,
+                    database=datasource.database_name,
+                    user=datasource.username,
+                    password=datasource.password_encrypted,
+                    connect_timeout=5
+                )
+                test_conn.close()
+
+                db_type = 'MariaDB' if datasource.type == 'mariadb' else 'MySQL'
+                return True, f"{db_type} database '{datasource.database_name}' is ready"
+
+            except pymysql.OperationalError as e:
+                if attempt < max_retries - 1:
+                    logger.info(f"Waiting for MySQL/MariaDB to be ready... (attempt {attempt + 1}/{max_retries})")
+                    time.sleep(retry_delay)
+                else:
+                    return False, f"MySQL/MariaDB failed to start: {str(e)}"
+            except Exception as e:
+                return False, f"MySQL/MariaDB setup error: {str(e)}"
+
+    @staticmethod
+    def _setup_mongodb(datasource) -> tuple[bool, str]:
+        """Setup MongoDB database"""
+        max_retries = 30
+        retry_delay = 2
+
+        for attempt in range(max_retries):
+            try:
+                # Connect to MongoDB
+                client = MongoClient(
+                    host=datasource.host,
+                    port=datasource.port,
+                    username=datasource.username,
+                    password=datasource.password_encrypted,
+                    serverSelectionTimeoutMS=5000
+                )
+
+                # Test connection
+                client.server_info()
+
+                # Create database (MongoDB creates it on first write)
+                db = client[datasource.database_name]
+
+                # Create a test collection to initialize the database
+                db.create_collection('_quantum_init')
+                db['_quantum_init'].insert_one({'initialized': True})
+
+                client.close()
+
+                return True, f"MongoDB database '{datasource.database_name}' is ready"
+
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    logger.info(f"Waiting for MongoDB to be ready... (attempt {attempt + 1}/{max_retries})")
+                    time.sleep(retry_delay)
+                else:
+                    return False, f"MongoDB failed to start: {str(e)}"