485 lines
17 KiB
Rust
485 lines
17 KiB
Rust
use diesel::prelude::*;
|
|
use diesel::sql_types::Text;
|
|
use log::{info, warn};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
#[derive(Clone)]
|
|
pub struct AppConfig {
|
|
pub minio: DriveConfig,
|
|
pub server: ServerConfig,
|
|
pub database: DatabaseConfig,
|
|
pub database_custom: DatabaseConfig,
|
|
pub email: EmailConfig,
|
|
pub ai: AIConfig,
|
|
pub site_path: String,
|
|
pub s3_bucket: String,
|
|
pub stack_path: PathBuf,
|
|
pub db_conn: Option<Arc<Mutex<PgConnection>>>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct DatabaseConfig {
|
|
pub username: String,
|
|
pub password: String,
|
|
pub server: String,
|
|
pub port: u32,
|
|
pub database: String,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct DriveConfig {
|
|
pub server: String,
|
|
pub access_key: String,
|
|
pub secret_key: String,
|
|
pub use_ssl: bool,
|
|
pub org_prefix: String,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct ServerConfig {
|
|
pub host: String,
|
|
pub port: u16,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct EmailConfig {
|
|
pub from: String,
|
|
pub server: String,
|
|
pub port: u16,
|
|
pub username: String,
|
|
pub password: String,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct AIConfig {
|
|
pub instance: String,
|
|
pub key: String,
|
|
pub version: String,
|
|
pub endpoint: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, QueryableByName)]
|
|
pub struct ServerConfigRow {
|
|
#[diesel(sql_type = Text)]
|
|
pub id: String,
|
|
#[diesel(sql_type = Text)]
|
|
pub config_key: String,
|
|
#[diesel(sql_type = Text)]
|
|
pub config_value: String,
|
|
#[diesel(sql_type = Text)]
|
|
pub config_type: String,
|
|
#[diesel(sql_type = diesel::sql_types::Bool)]
|
|
pub is_encrypted: bool,
|
|
}
|
|
|
|
impl AppConfig {
|
|
pub fn database_url(&self) -> String {
|
|
format!(
|
|
"postgres://{}:{}@{}:{}/{}",
|
|
self.database.username,
|
|
self.database.password,
|
|
self.database.server,
|
|
self.database.port,
|
|
self.database.database
|
|
)
|
|
}
|
|
|
|
pub fn database_custom_url(&self) -> String {
|
|
format!(
|
|
"postgres://{}:{}@{}:{}/{}",
|
|
self.database_custom.username,
|
|
self.database_custom.password,
|
|
self.database_custom.server,
|
|
self.database_custom.port,
|
|
self.database_custom.database
|
|
)
|
|
}
|
|
|
|
pub fn component_path(&self, component: &str) -> PathBuf {
|
|
self.stack_path.join(component)
|
|
}
|
|
|
|
pub fn bin_path(&self, component: &str) -> PathBuf {
|
|
self.stack_path.join("bin").join(component)
|
|
}
|
|
|
|
pub fn data_path(&self, component: &str) -> PathBuf {
|
|
self.stack_path.join("data").join(component)
|
|
}
|
|
|
|
pub fn config_path(&self, component: &str) -> PathBuf {
|
|
self.stack_path.join("conf").join(component)
|
|
}
|
|
|
|
pub fn log_path(&self, component: &str) -> PathBuf {
|
|
self.stack_path.join("logs").join(component)
|
|
}
|
|
|
|
pub fn from_database(conn: &mut PgConnection) -> Self {
|
|
info!("Loading configuration from database");
|
|
|
|
let config_map = match Self::load_config_from_db(conn) {
|
|
Ok(map) => {
|
|
info!("Loaded {} config values from database", map.len());
|
|
map
|
|
}
|
|
Err(e) => {
|
|
warn!("Failed to load config from database: {}. Using defaults", e);
|
|
HashMap::new()
|
|
}
|
|
};
|
|
|
|
let get_str = |key: &str, default: &str| -> String {
|
|
config_map
|
|
.get(key)
|
|
.map(|v| v.config_value.clone())
|
|
.unwrap_or_else(|| default.to_string())
|
|
};
|
|
|
|
let get_u32 = |key: &str, default: u32| -> u32 {
|
|
config_map
|
|
.get(key)
|
|
.and_then(|v| v.config_value.parse().ok())
|
|
.unwrap_or(default)
|
|
};
|
|
|
|
let get_u16 = |key: &str, default: u16| -> u16 {
|
|
config_map
|
|
.get(key)
|
|
.and_then(|v| v.config_value.parse().ok())
|
|
.unwrap_or(default)
|
|
};
|
|
|
|
let get_bool = |key: &str, default: bool| -> bool {
|
|
config_map
|
|
.get(key)
|
|
.map(|v| v.config_value.to_lowercase() == "true")
|
|
.unwrap_or(default)
|
|
};
|
|
|
|
let stack_path = PathBuf::from(get_str("STACK_PATH", "./botserver-stack"));
|
|
|
|
// For database credentials, prioritize environment variables over database values
|
|
// because we need the correct credentials to connect to the database in the first place
|
|
let database = DatabaseConfig {
|
|
username: std::env::var("TABLES_USERNAME")
|
|
.unwrap_or_else(|_| get_str("TABLES_USERNAME", "gbuser")),
|
|
password: std::env::var("TABLES_PASSWORD")
|
|
.unwrap_or_else(|_| get_str("TABLES_PASSWORD", "")),
|
|
server: std::env::var("TABLES_SERVER")
|
|
.unwrap_or_else(|_| get_str("TABLES_SERVER", "localhost")),
|
|
port: std::env::var("TABLES_PORT")
|
|
.ok()
|
|
.and_then(|p| p.parse().ok())
|
|
.unwrap_or_else(|| get_u32("TABLES_PORT", 5432)),
|
|
database: std::env::var("TABLES_DATABASE")
|
|
.unwrap_or_else(|_| get_str("TABLES_DATABASE", "botserver")),
|
|
};
|
|
|
|
let database_custom = DatabaseConfig {
|
|
username: std::env::var("CUSTOM_USERNAME")
|
|
.unwrap_or_else(|_| get_str("CUSTOM_USERNAME", "gbuser")),
|
|
password: std::env::var("CUSTOM_PASSWORD")
|
|
.unwrap_or_else(|_| get_str("CUSTOM_PASSWORD", "")),
|
|
server: std::env::var("CUSTOM_SERVER")
|
|
.unwrap_or_else(|_| get_str("CUSTOM_SERVER", "localhost")),
|
|
port: std::env::var("CUSTOM_PORT")
|
|
.ok()
|
|
.and_then(|p| p.parse().ok())
|
|
.unwrap_or_else(|| get_u32("CUSTOM_PORT", 5432)),
|
|
database: std::env::var("CUSTOM_DATABASE")
|
|
.unwrap_or_else(|_| get_str("CUSTOM_DATABASE", "botserver")),
|
|
};
|
|
|
|
let minio = DriveConfig {
|
|
server: get_str("DRIVE_SERVER", "http://localhost:9000"),
|
|
access_key: get_str("DRIVE_ACCESSKEY", "minioadmin"),
|
|
secret_key: get_str("DRIVE_SECRET", "minioadmin"),
|
|
use_ssl: get_bool("DRIVE_USE_SSL", false),
|
|
org_prefix: get_str("DRIVE_ORG_PREFIX", "botserver"),
|
|
};
|
|
|
|
let email = EmailConfig {
|
|
from: get_str("EMAIL_FROM", "noreply@example.com"),
|
|
server: get_str("EMAIL_SERVER", "smtp.example.com"),
|
|
port: get_u16("EMAIL_PORT", 587),
|
|
username: get_str("EMAIL_USER", "user"),
|
|
password: get_str("EMAIL_PASS", "pass"),
|
|
};
|
|
|
|
let ai = AIConfig {
|
|
instance: get_str("AI_INSTANCE", "gpt-4"),
|
|
key: get_str("AI_KEY", ""),
|
|
version: get_str("AI_VERSION", "2023-12-01-preview"),
|
|
endpoint: get_str("AI_ENDPOINT", "https://api.openai.com"),
|
|
};
|
|
|
|
AppConfig {
|
|
minio,
|
|
server: ServerConfig {
|
|
host: get_str("SERVER_HOST", "127.0.0.1"),
|
|
port: get_u16("SERVER_PORT", 8080),
|
|
},
|
|
database,
|
|
database_custom,
|
|
email,
|
|
ai,
|
|
s3_bucket: get_str("DRIVE_BUCKET", "default"),
|
|
site_path: get_str("SITES_ROOT", "./botserver-stack/sites"),
|
|
stack_path,
|
|
db_conn: None,
|
|
}
|
|
}
|
|
|
|
pub fn from_env() -> Self {
|
|
warn!("Loading configuration from environment variables");
|
|
|
|
let stack_path =
|
|
std::env::var("STACK_PATH").unwrap_or_else(|_| "./botserver-stack".to_string());
|
|
|
|
let database_url = std::env::var("DATABASE_URL")
|
|
.unwrap_or_else(|_| "postgres://gbuser:@localhost:5432/botserver".to_string());
|
|
let (db_username, db_password, db_server, db_port, db_name) =
|
|
parse_database_url(&database_url);
|
|
|
|
let database = DatabaseConfig {
|
|
username: db_username,
|
|
password: db_password,
|
|
server: db_server,
|
|
port: db_port,
|
|
database: db_name,
|
|
};
|
|
|
|
let database_custom = DatabaseConfig {
|
|
username: std::env::var("CUSTOM_USERNAME").unwrap_or_else(|_| "gbuser".to_string()),
|
|
password: std::env::var("CUSTOM_PASSWORD").unwrap_or_else(|_| "".to_string()),
|
|
server: std::env::var("CUSTOM_SERVER").unwrap_or_else(|_| "localhost".to_string()),
|
|
port: std::env::var("CUSTOM_PORT")
|
|
.ok()
|
|
.and_then(|p| p.parse().ok())
|
|
.unwrap_or(5432),
|
|
database: std::env::var("CUSTOM_DATABASE").unwrap_or_else(|_| "botserver".to_string()),
|
|
};
|
|
|
|
let minio = DriveConfig {
|
|
server: std::env::var("DRIVE_SERVER")
|
|
.unwrap_or_else(|_| "http://localhost:9000".to_string()),
|
|
access_key: std::env::var("DRIVE_ACCESSKEY")
|
|
.unwrap_or_else(|_| "minioadmin".to_string()),
|
|
secret_key: std::env::var("DRIVE_SECRET").unwrap_or_else(|_| "minioadmin".to_string()),
|
|
use_ssl: std::env::var("DRIVE_USE_SSL")
|
|
.unwrap_or_else(|_| "false".to_string())
|
|
.parse()
|
|
.unwrap_or(false),
|
|
org_prefix: std::env::var("DRIVE_ORG_PREFIX")
|
|
.unwrap_or_else(|_| "botserver".to_string()),
|
|
};
|
|
|
|
let email = EmailConfig {
|
|
from: std::env::var("EMAIL_FROM").unwrap_or_else(|_| "noreply@example.com".to_string()),
|
|
server: std::env::var("EMAIL_SERVER")
|
|
.unwrap_or_else(|_| "smtp.example.com".to_string()),
|
|
port: std::env::var("EMAIL_PORT")
|
|
.unwrap_or_else(|_| "587".to_string())
|
|
.parse()
|
|
.unwrap_or(587),
|
|
username: std::env::var("EMAIL_USER").unwrap_or_else(|_| "user".to_string()),
|
|
password: std::env::var("EMAIL_PASS").unwrap_or_else(|_| "pass".to_string()),
|
|
};
|
|
|
|
let ai = AIConfig {
|
|
instance: std::env::var("AI_INSTANCE").unwrap_or_else(|_| "gpt-4".to_string()),
|
|
key: std::env::var("AI_KEY").unwrap_or_else(|_| "".to_string()),
|
|
version: std::env::var("AI_VERSION")
|
|
.unwrap_or_else(|_| "2023-12-01-preview".to_string()),
|
|
endpoint: std::env::var("AI_ENDPOINT")
|
|
.unwrap_or_else(|_| "https://api.openai.com".to_string()),
|
|
};
|
|
|
|
AppConfig {
|
|
minio,
|
|
server: ServerConfig {
|
|
host: std::env::var("SERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
|
|
port: std::env::var("SERVER_PORT")
|
|
.ok()
|
|
.and_then(|p| p.parse().ok())
|
|
.unwrap_or(8080),
|
|
},
|
|
database,
|
|
database_custom,
|
|
email,
|
|
ai,
|
|
s3_bucket: std::env::var("DRIVE_BUCKET").unwrap_or_else(|_| "default".to_string()),
|
|
site_path: std::env::var("SITES_ROOT")
|
|
.unwrap_or_else(|_| "./botserver-stack/sites".to_string()),
|
|
stack_path: PathBuf::from(stack_path),
|
|
db_conn: None,
|
|
}
|
|
}
|
|
|
|
fn load_config_from_db(
|
|
conn: &mut PgConnection,
|
|
) -> Result<HashMap<String, ServerConfigRow>, diesel::result::Error> {
|
|
let results = diesel::sql_query("SELECT id, config_key, config_value, config_type, is_encrypted FROM server_configuration").load::<ServerConfigRow>(conn)?;
|
|
|
|
let mut map = HashMap::new();
|
|
for row in results {
|
|
map.insert(row.config_key.clone(), row);
|
|
}
|
|
|
|
Ok(map)
|
|
}
|
|
|
|
pub fn set_config(
|
|
&self,
|
|
conn: &mut PgConnection,
|
|
key: &str,
|
|
value: &str,
|
|
) -> Result<(), diesel::result::Error> {
|
|
diesel::sql_query("SELECT set_config($1, $2)")
|
|
.bind::<Text, _>(key)
|
|
.bind::<Text, _>(value)
|
|
.execute(conn)?;
|
|
info!("Updated configuration: {} = {}", key, value);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn get_config(
|
|
&self,
|
|
conn: &mut PgConnection,
|
|
key: &str,
|
|
fallback: Option<&str>,
|
|
) -> Result<String, diesel::result::Error> {
|
|
let fallback_str = fallback.unwrap_or("");
|
|
|
|
#[derive(Debug, QueryableByName)]
|
|
struct ConfigValue {
|
|
#[diesel(sql_type = Text)]
|
|
value: String,
|
|
}
|
|
|
|
let result = diesel::sql_query("SELECT get_config($1, $2) as value")
|
|
.bind::<Text, _>(key)
|
|
.bind::<Text, _>(fallback_str)
|
|
.get_result::<ConfigValue>(conn)
|
|
.map(|row| row.value)?;
|
|
Ok(result)
|
|
}
|
|
}
|
|
|
|
fn parse_database_url(url: &str) -> (String, String, String, u32, String) {
|
|
if let Some(stripped) = url.strip_prefix("postgres://") {
|
|
let parts: Vec<&str> = stripped.split('@').collect();
|
|
if parts.len() == 2 {
|
|
let user_pass: Vec<&str> = parts[0].split(':').collect();
|
|
let host_db: Vec<&str> = parts[1].split('/').collect();
|
|
|
|
if user_pass.len() >= 2 && host_db.len() >= 2 {
|
|
let username = user_pass[0].to_string();
|
|
let password = user_pass[1].to_string();
|
|
|
|
let host_port: Vec<&str> = host_db[0].split(':').collect();
|
|
let server = host_port[0].to_string();
|
|
let port = host_port
|
|
.get(1)
|
|
.and_then(|p| p.parse().ok())
|
|
.unwrap_or(5432);
|
|
let database = host_db[1].to_string();
|
|
|
|
return (username, password, server, port, database);
|
|
}
|
|
}
|
|
}
|
|
|
|
(
|
|
"gbuser".to_string(),
|
|
"".to_string(),
|
|
"localhost".to_string(),
|
|
5432,
|
|
"botserver".to_string(),
|
|
)
|
|
}
|
|
|
|
pub struct ConfigManager {
|
|
conn: Arc<Mutex<PgConnection>>,
|
|
}
|
|
|
|
impl ConfigManager {
|
|
pub fn new(conn: Arc<Mutex<PgConnection>>) -> Self {
|
|
Self { conn }
|
|
}
|
|
|
|
pub fn sync_gbot_config(
|
|
&self,
|
|
bot_id: &uuid::Uuid,
|
|
config_path: &str,
|
|
) -> Result<usize, String> {
|
|
use sha2::{Digest, Sha256};
|
|
use std::fs;
|
|
|
|
let content = fs::read_to_string(config_path)
|
|
.map_err(|e| format!("Failed to read config file: {}", e))?;
|
|
|
|
let mut hasher = Sha256::new();
|
|
hasher.update(content.as_bytes());
|
|
let file_hash = format!("{:x}", hasher.finalize());
|
|
|
|
let mut conn = self
|
|
.conn
|
|
.lock()
|
|
.map_err(|e| format!("Failed to acquire lock: {}", e))?;
|
|
|
|
#[derive(QueryableByName)]
|
|
struct SyncHash {
|
|
#[diesel(sql_type = Text)]
|
|
file_hash: String,
|
|
}
|
|
|
|
let last_hash: Option<String> =
|
|
diesel::sql_query("SELECT file_hash FROM gbot_config_sync WHERE bot_id = $1")
|
|
.bind::<diesel::sql_types::Uuid, _>(bot_id)
|
|
.get_result::<SyncHash>(&mut *conn)
|
|
.optional()
|
|
.map_err(|e| format!("Database error: {}", e))?
|
|
.map(|row| row.file_hash);
|
|
|
|
if last_hash.as_ref() == Some(&file_hash) {
|
|
info!("Config file unchanged for bot {}", bot_id);
|
|
return Ok(0);
|
|
}
|
|
|
|
let mut updated = 0;
|
|
for line in content.lines().skip(1) {
|
|
let parts: Vec<&str> = line.split(',').collect();
|
|
if parts.len() >= 2 {
|
|
let key = parts[0].trim();
|
|
let value = parts[1].trim();
|
|
|
|
diesel::sql_query("INSERT INTO bot_configuration (id, bot_id, config_key, config_value, config_type) VALUES (gen_random_uuid()::text, $1, $2, $3, 'string') ON CONFLICT (bot_id, config_key) DO UPDATE SET config_value = EXCLUDED.config_value, updated_at = NOW()")
|
|
.bind::<diesel::sql_types::Uuid, _>(bot_id)
|
|
.bind::<diesel::sql_types::Text, _>(key)
|
|
.bind::<diesel::sql_types::Text, _>(value)
|
|
.execute(&mut *conn)
|
|
.map_err(|e| format!("Failed to update config: {}", e))?;
|
|
|
|
updated += 1;
|
|
}
|
|
}
|
|
|
|
diesel::sql_query("INSERT INTO gbot_config_sync (id, bot_id, config_file_path, file_hash, sync_count) VALUES (gen_random_uuid()::text, $1, $2, $3, 1) ON CONFLICT (bot_id) DO UPDATE SET last_sync_at = NOW(), file_hash = EXCLUDED.file_hash, sync_count = gbot_config_sync.sync_count + 1")
|
|
.bind::<diesel::sql_types::Uuid, _>(bot_id)
|
|
.bind::<diesel::sql_types::Text, _>(config_path)
|
|
.bind::<diesel::sql_types::Text, _>(&file_hash)
|
|
.execute(&mut *conn)
|
|
.map_err(|e| format!("Failed to update sync record: {}", e))?;
|
|
|
|
info!(
|
|
"Synced {} config values for bot {} from {}",
|
|
updated, bot_id, config_path
|
|
);
|
|
Ok(updated)
|
|
}
|
|
}
|