burncloud_database_client/
burncloud_manager.rs

1// BurnCloud数据库管理器 - 统一的数据库操作接口
2
3use crate::migration::MigrationManager as DatabaseMigrationManager;
4use crate::*;
5use burncloud_database_core::error::{DatabaseResult, DatabaseError};
6use burncloud_database_core::{DatabaseConfig, QueryContext};
7use std::sync::Arc;
8
9/// BurnCloud数据库管理器
10/// 提供统一的数据库操作接口，包含所有业务相关的Repository
11pub struct BurnCloudDatabase {
12    // 基础组件
13    pub client: Arc<DatabaseClient>,
14    pub pool: Arc<DatabasePool>,
15    pub migration_manager: Arc<DatabaseMigrationManager>,
16
17    // 业务Repository
18    pub ai_models: Arc<AiModelRepository>,
19    pub deployments: Arc<ModelDeploymentRepository>,
20    pub system_metrics: Arc<SystemMetricsRepository>,
21    pub model_metrics: Arc<ModelMetricsRepository>,
22    pub request_logs: Arc<RequestLogRepository>,
23    pub user_settings: Arc<UserSettingsRepository>,
24    pub security_config: Arc<SecurityConfigRepository>,
25}
26
27impl BurnCloudDatabase {
28    /// 创建新的BurnCloud数据库管理器
29    pub async fn new(config: DatabaseConfig) -> DatabaseResult<Self> {
30        // 创建数据库连接和执行器
31        let connection = DatabaseClientFactory::create_connection(&config)?;
32        let query_executor1 = DatabaseClientFactory::create_query_executor(&config)?;
33
34        // 为每个组件创建独立的执行器
35        let query_executor2 = DatabaseClientFactory::create_query_executor(&config)?;
36        let query_executor3 = DatabaseClientFactory::create_query_executor(&config)?;
37        let query_executor4 = DatabaseClientFactory::create_query_executor(&config)?;
38        let query_executor5 = DatabaseClientFactory::create_query_executor(&config)?;
39        let query_executor6 = DatabaseClientFactory::create_query_executor(&config)?;
40        let query_executor7 = DatabaseClientFactory::create_query_executor(&config)?;
41        let query_executor8 = DatabaseClientFactory::create_query_executor(&config)?;
42
43        // 创建客户端和连接池
44        let client = Arc::new(DatabaseClient::new(connection, query_executor1));
45        let pool = Arc::new(DatabasePool::new(config.clone(), config.pool_size.unwrap_or(10) as usize));
46
47        // 连接数据库
48        client.connect().await?;
49
50        // 创建迁移管理器
51        let migration_manager = Arc::new(DatabaseMigrationManager::new(query_executor2));
52
53        // 创建所有Repository
54        let ai_models = Arc::new(AiModelRepository::new(query_executor3));
55        let deployments = Arc::new(ModelDeploymentRepository::new(query_executor4));
56        let system_metrics = Arc::new(SystemMetricsRepository::new(query_executor5));
57        let model_metrics = Arc::new(ModelMetricsRepository::new(query_executor6));
58        let request_logs = Arc::new(RequestLogRepository::new(query_executor7));
59        let user_settings = Arc::new(UserSettingsRepository::new(query_executor8));
60        let security_config = Arc::new(SecurityConfigRepository::new(DatabaseClientFactory::create_query_executor(&config)?));
61
62        Ok(Self {
63            client,
64            pool,
65            migration_manager,
66            ai_models,
67            deployments,
68            system_metrics,
69            model_metrics,
70            request_logs,
71            user_settings,
72            security_config,
73        })
74    }
75
76    /// 初始化数据库（运行迁移）
77    pub async fn initialize(&self) -> DatabaseResult<()> {
78        let context = QueryContext::default();
79        self.migration_manager.run_migrations(&context).await?;
80        println!("✅ Database initialized successfully");
81        Ok(())
82    }
83
84    /// 检查数据库连接状态
85    pub async fn health_check(&self) -> DatabaseResult<()> {
86        self.client.ping().await?;
87        println!("✅ Database connection healthy");
88        Ok(())
89    }
90
91    /// 获取数据库统计信息
92    pub async fn get_database_stats(&self) -> DatabaseResult<DatabaseStats> {
93        let context = QueryContext::default();
94
95        // 获取各表的记录数
96        let models_count = self.count_table_rows("ai_models", &context).await?;
97        let deployments_count = self.count_table_rows("model_deployments", &context).await?;
98        let metrics_count = self.count_table_rows("system_metrics", &context).await?;
99        let logs_count = self.count_table_rows("request_logs", &context).await?;
100
101        // 获取最新的系统指标
102        let latest_system_metrics = self.system_metrics.get_latest(&context).await?;
103
104        Ok(DatabaseStats {
105            models_count,
106            deployments_count,
107            metrics_count,
108            logs_count,
109            latest_system_metrics,
110            pool_size: self.pool.get_pool_size().await,
111        })
112    }
113
114    /// 清理旧数据
115    pub async fn cleanup_old_data(&self, retention_days: u32) -> DatabaseResult<CleanupStats> {
116        let context = QueryContext::default();
117        let cutoff_time = chrono::Utc::now() - chrono::Duration::days(retention_days as i64);
118
119        // 清理旧的系统指标
120        let metrics_deleted = self.system_metrics.cleanup_old_metrics(cutoff_time, &context).await?;
121
122        // 清理旧的请求日志
123        let logs_deleted = self.cleanup_old_logs(cutoff_time, &context).await?;
124
125        Ok(CleanupStats {
126            metrics_deleted,
127            logs_deleted,
128            cutoff_time,
129        })
130    }
131
132    /// 备份数据库配置
133    pub async fn backup_config(&self) -> DatabaseResult<BurnCloudConfig> {
134        let context = QueryContext::default();
135
136        // 获取所有模型
137        let models = self.ai_models.base.find_all(&QueryOptions::default(), &context).await?;
138
139        // 获取所有部署
140        let deployments = self.deployments.base.find_all(&QueryOptions::default(), &context).await?;
141
142        // 获取用户设置
143        let user_settings = self.user_settings.base.find_all(&QueryOptions::default(), &context).await?;
144
145        // 获取安全配置
146        let security_config = self.security_config.get_current(&context).await?;
147
148        Ok(BurnCloudConfig {
149            models,
150            deployments,
151            user_settings,
152            security_config,
153            backup_time: chrono::Utc::now(),
154        })
155    }
156
157    /// 恢复数据库配置
158    pub async fn restore_config(&self, config: &BurnCloudConfig) -> DatabaseResult<()> {
159        let context = QueryContext::default();
160
161        // 注意：这是一个简化的恢复实现
162        // 实际应用中需要更复杂的事务处理和冲突解决
163
164        for model in &config.models {
165            let _ = self.ai_models.base.create(model, &context).await;
166        }
167
168        for deployment in &config.deployments {
169            let _ = self.deployments.base.create(deployment, &context).await;
170        }
171
172        for settings in &config.user_settings {
173            let _ = self.user_settings.base.create(settings, &context).await;
174        }
175
176        if let Some(security) = &config.security_config {
177            let _ = self.security_config.base.create(security, &context).await;
178        }
179
180        println!("✅ Configuration restored successfully");
181        Ok(())
182    }
183
184    // 辅助方法
185    async fn count_table_rows(&self, table_name: &str, context: &QueryContext) -> DatabaseResult<u64> {
186        let query = format!("SELECT COUNT(*) as count FROM {}", table_name);
187        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![];
188
189        let result = self.client.execute_query(&query, &params, context).await?;
190
191        if let Some(row) = result.rows.first() {
192            if let Some(count_value) = row.get("count") {
193                if let Some(count) = count_value.as_u64() {
194                    return Ok(count);
195                }
196            }
197        }
198
199        Ok(0)
200    }
201
202    async fn cleanup_old_logs(&self, cutoff_time: chrono::DateTime<chrono::Utc>, context: &QueryContext) -> DatabaseResult<u64> {
203        let query = "DELETE FROM request_logs WHERE timestamp < $1";
204        let time_param = burncloud_database_impl::StringParam(cutoff_time.to_rfc3339());
205        let params: Vec<&dyn burncloud_database_core::QueryParam> = vec![&time_param];
206
207        let result = self.client.execute_query(query, &params, context).await?;
208        Ok(result.rows_affected)
209    }
210}
211
212/// 数据库统计信息
213#[derive(Debug, serde::Serialize, serde::Deserialize)]
214pub struct DatabaseStats {
215    pub models_count: u64,
216    pub deployments_count: u64,
217    pub metrics_count: u64,
218    pub logs_count: u64,
219    pub latest_system_metrics: Option<SystemMetrics>,
220    pub pool_size: usize,
221}
222
223/// 清理统计信息
224#[derive(Debug, serde::Serialize, serde::Deserialize)]
225pub struct CleanupStats {
226    pub metrics_deleted: u64,
227    pub logs_deleted: u64,
228    pub cutoff_time: chrono::DateTime<chrono::Utc>,
229}
230
231/// BurnCloud配置备份
232#[derive(Debug, serde::Serialize, serde::Deserialize)]
233pub struct BurnCloudConfig {
234    pub models: Vec<AiModel>,
235    pub deployments: Vec<ModelDeployment>,
236    pub user_settings: Vec<UserSettings>,
237    pub security_config: Option<SecurityConfig>,
238    pub backup_time: chrono::DateTime<chrono::Utc>,
239}
240
241/// BurnCloud数据库构建器
242pub struct BurnCloudDatabaseBuilder {
243    config: DatabaseConfig,
244}
245
246impl BurnCloudDatabaseBuilder {
247    pub fn new() -> Self {
248        Self {
249            config: DatabaseConfig {
250                database_type: burncloud_database_core::DatabaseType::Postgres,
251                host: "localhost".to_string(),
252                port: 5432,
253                database: "burncloud".to_string(),
254                username: "burncloud".to_string(),
255                password: "password".to_string(),
256                pool_size: Some(10),
257                timeout: Some(30),
258                ssl: Some(false),
259            },
260        }
261    }
262
263    pub fn with_postgres(mut self, host: &str, port: u16, database: &str, username: &str, password: &str) -> Self {
264        self.config.database_type = burncloud_database_core::DatabaseType::Postgres;
265        self.config.host = host.to_string();
266        self.config.port = port;
267        self.config.database = database.to_string();
268        self.config.username = username.to_string();
269        self.config.password = password.to_string();
270        self
271    }
272
273    pub fn with_sqlite(mut self, database_path: &str) -> Self {
274        self.config.database_type = burncloud_database_core::DatabaseType::SQLite;
275        self.config.database = database_path.to_string();
276        self
277    }
278
279    pub fn with_pool_size(mut self, size: u32) -> Self {
280        self.config.pool_size = Some(size);
281        self
282    }
283
284    pub fn with_timeout(mut self, timeout_seconds: u64) -> Self {
285        self.config.timeout = Some(timeout_seconds);
286        self
287    }
288
289    pub async fn build(self) -> DatabaseResult<BurnCloudDatabase> {
290        BurnCloudDatabase::new(self.config).await
291    }
292
293    pub async fn build_and_initialize(self) -> DatabaseResult<BurnCloudDatabase> {
294        let db = self.build().await?;
295        db.initialize().await?;
296        Ok(db)
297    }
298}
299
300impl Default for BurnCloudDatabaseBuilder {
301    fn default() -> Self {
302        Self::new()
303    }
304}
burncloud_database_client/burncloud_manager.rs

burncloud_database_client/
burncloud_manager.rs
