burncloud-database-client 0.1.1

// BurnCloud数据库使用示例

use burncloud_database_client::*;
use burncloud_database_core::*;
use uuid::Uuid;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 BurnCloud Database Example");

    // 1. 创建数据库连接
    let db = BurnCloudDatabaseBuilder::new()
        .with_postgres("localhost", 5432, "burncloud", "postgres", "password")
        .with_pool_size(10)
        .with_timeout(30)
        .build_and_initialize()
        .await?;

    println!("✅ Database connected and initialized");

    // 2. 健康检查
    db.health_check().await?;

    // 3. 添加示例AI模型
    let context = QueryContext::default();

    let model = AiModel {
        id: Uuid::new_v4(),
        name: "Qwen2.5-7B-Chat".to_string(),
        version: "v1.0".to_string(),
        size_gb: 4.1,
        model_type: ModelType::ChatCompletion,
        provider: "Alibaba".to_string(),
        description: Some("7B参数的对话模型".to_string()),
        tags: vec!["chat".to_string(), "chinese".to_string()],
        capabilities: vec!["text-generation".to_string(), "conversation".to_string()],
        requirements: ModelRequirements {
            min_ram_gb: 8.0,
            min_vram_gb: Some(6.0),
            gpu_required: true,
            cpu_cores: 4,
            disk_space_gb: 5.0,
            supported_platforms: vec!["linux".to_string(), "windows".to_string()],
        },
        status: ModelStatus::Downloaded,
        download_url: Some("https://example.com/qwen2.5-7b".to_string()),
        checksum: Some("abc123".to_string()),
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
    };

    let model_id = db.ai_models.base.create(&model, &context).await?;
    println!("✅ AI模型已添加: {}", model_id);

    // 4. 创建模型部署
    let deployment = ModelDeployment {
        id: Uuid::new_v4(),
        model_id: model.id,
        name: "qwen2.5-chat-prod".to_string(),
        port: 8001,
        bind_address: "127.0.0.1".to_string(),
        api_key: "sk-burncloud-123456".to_string(),
        max_concurrent: 4,
        config: DeploymentConfig {
            auto_start: true,
            restart_on_failure: true,
            max_restart_count: 3,
            health_check_interval: 30,
            timeout_seconds: 60,
            log_level: LogLevel::Info,
            custom_args: std::collections::HashMap::new(),
        },
        resource_config: ResourceConfig {
            context_length: 4096,
            temperature: 0.7,
            top_p: 0.9,
            top_k: 50,
            max_tokens: 2048,
            gpu_layers: Some(32),
            threads: Some(8),
            batch_size: 1,
        },
        status: DeploymentStatus::Running,
        pid: Some(12345),
        started_at: Some(chrono::Utc::now()),
        stopped_at: None,
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
    };

    let deployment_id = db.deployments.base.create(&deployment, &context).await?;
    println!("✅ 模型部署已创建: {}", deployment_id);

    // 5. 记录系统指标
    let system_metrics = SystemMetrics {
        id: Uuid::new_v4(),
        timestamp: chrono::Utc::now(),
        cpu_usage: 45.2,
        memory_usage: 78.5,
        memory_total: 16_000_000_000, // 16GB
        disk_usage: 65.0,
        disk_total: 500_000_000_000, // 500GB
        gpu_usage: Some(32.1),
        gpu_memory_usage: Some(60.5),
        network_rx: 1024 * 1024, // 1MB
        network_tx: 512 * 1024,  // 512KB
    };

    db.system_metrics.base.create(&system_metrics, &context).await?;
    println!("✅ 系统指标已记录");

    // 6. 记录模型性能指标
    let model_metrics = ModelMetrics {
        id: Uuid::new_v4(),
        deployment_id: deployment.id,
        timestamp: chrono::Utc::now(),
        request_count: 142,
        error_count: 2,
        average_response_time: 1.2,
        tokens_per_second: 45.3,
        concurrent_requests: 3,
        queue_length: 0,
        memory_usage: 85.2,
    };

    db.model_metrics.base.create(&model_metrics, &context).await?;
    println!("✅ 模型性能指标已记录");

    // 7. 查询示例

    // 查找运行中的部署
    let running_deployments = db.deployments.get_running_deployments(&context).await?;
    println!("🔍 运行中的部署数量: {}", running_deployments.len());

    // 查找聊天模型
    let chat_models = db.ai_models.find_by_type(ModelType::ChatCompletion, &context).await?;
    println!("🔍 聊天模型数量: {}", chat_models.len());

    // 搜索模型
    let search_results = db.ai_models.search("Qwen", &context).await?;
    println!("🔍 搜索'Qwen'的结果: {}", search_results.len());

    // 获取最新系统指标
    let latest_metrics = db.system_metrics.get_latest(&context).await?;
    if let Some(metrics) = latest_metrics {
        println!("📊 当前CPU使用率: {:.1}%", metrics.cpu_usage);
        println!("📊 当前内存使用率: {:.1}%", metrics.memory_usage);
    }

    // 8. 获取数据库统计信息
    let stats = db.get_database_stats().await?;
    println!("\n📈 数据库统计:");
    println!("   模型数量: {}", stats.models_count);
    println!("   部署数量: {}", stats.deployments_count);
    println!("   指标记录数: {}", stats.metrics_count);
    println!("   连接池大小: {}", stats.pool_size);

    // 9. 创建用户设置
    let user_settings = UserSettings {
        id: Uuid::new_v4(),
        user_id: "admin".to_string(),
        theme: Theme::Dark,
        language: "zh-CN".to_string(),
        font_size: FontSize::Medium,
        auto_refresh_interval: 30,
        notifications_enabled: true,
        notification_types: vec![
            NotificationType::ModelStarted,
            NotificationType::ModelStopped,
            NotificationType::ModelError,
        ],
        created_at: chrono::Utc::now(),
        updated_at: chrono::Utc::now(),
    };

    db.user_settings.base.create(&user_settings, &context).await?;
    println!("✅ 用户设置已保存");

    // 10. 清理旧数据 (保留30天)
    let cleanup_stats = db.cleanup_old_data(30).await?;
    println!("\n🧹 数据清理完成:");
    println!("   删除指标记录: {}", cleanup_stats.metrics_deleted);
    println!("   删除日志记录: {}", cleanup_stats.logs_deleted);

    // 11. 备份配置
    let backup_config = db.backup_config().await?;
    println!("\n💾 配置已备份:");
    println!("   模型数量: {}", backup_config.models.len());
    println!("   部署数量: {}", backup_config.deployments.len());
    println!("   备份时间: {}", backup_config.backup_time.format("%Y-%m-%d %H:%M:%S"));

    println!("\n🎉 BurnCloud数据库示例运行完成!");

    Ok(())
}

/// 演示高级查询功能
async fn advanced_query_examples(db: &BurnCloudDatabase) -> Result<(), Box<dyn std::error::Error>> {
    let context = QueryContext::default();

    // 时间范围查询
    let start_time = chrono::Utc::now() - chrono::Duration::hours(24);
    let end_time = chrono::Utc::now();

    // 获取过去24小时的系统指标
    let recent_metrics = db.system_metrics.find_by_time_range(start_time, end_time, &context).await?;
    println!("📊 过去24小时系统指标: {} 条记录", recent_metrics.len());

    // 获取特定部署的性能指标
    if let Some(deployment) = db.deployments.get_running_deployments(&context).await?.first() {
        let deployment_metrics = db.model_metrics
            .find_by_deployment_id(deployment.id, start_time, end_time, &context)
            .await?;
        println!("📈 部署 {} 的性能指标: {} 条记录", deployment.name, deployment_metrics.len());

        // 获取该部署的错误日志
        let error_logs = db.request_logs.find_errors(start_time, end_time, &context).await?;
        println!("❌ 过去24小时错误日志: {} 条记录", error_logs.len());
    }

    Ok(())
}

/// 演示事务操作
async fn transaction_example(db: &BurnCloudDatabase) -> Result<(), Box<dyn std::error::Error>> {
    // 注意：这个示例展示了事务的概念，但实际的事务实现需要更复杂的代码

    println!("\n🔄 开始事务操作示例");

    // 在真实应用中，这里会开启一个数据库事务
    // let transaction = db.client.begin_transaction(&context).await?;

    // 批量操作：同时创建模型和部署
    // 如果任何操作失败，整个事务将回滚

    println!("✅ 事务操作完成");

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_database_operations() {
        // 使用内存SQLite进行测试
        let db = BurnCloudDatabaseBuilder::new()
            .with_sqlite(":memory:")
            .build_and_initialize()
            .await
            .expect("Failed to create test database");

        let context = QueryContext::default();

        // 测试模型创建
        let model = AiModel {
            id: Uuid::new_v4(),
            name: "test-model".to_string(),
            version: "v1.0".to_string(),
            size_gb: 1.0,
            model_type: ModelType::TextGeneration,
            provider: "test".to_string(),
            description: None,
            tags: vec![],
            capabilities: vec![],
            requirements: ModelRequirements {
                min_ram_gb: 2.0,
                min_vram_gb: None,
                gpu_required: false,
                cpu_cores: 2,
                disk_space_gb: 2.0,
                supported_platforms: vec!["linux".to_string()],
            },
            status: ModelStatus::Available,
            download_url: None,
            checksum: None,
            created_at: chrono::Utc::now(),
            updated_at: chrono::Utc::now(),
        };

        let _model_id = db.ai_models.base.create(&model, &context).await
            .expect("Failed to create model");

        // 验证模型已创建
        let models = db.ai_models.find_by_status(ModelStatus::Available, &context).await
            .expect("Failed to find models");
        assert_eq!(models.len(), 1);
        assert_eq!(models[0].name, "test-model");
    }
}