567 lines
17 KiB
Rust
Executable File
567 lines
17 KiB
Rust
Executable File
// src/common/mod.rs
|
||
//! Общие модули для Futriix
|
||
//!
|
||
//! Содержит общие структуры данных, ошибки, протоколы и конфигурацию,
|
||
//! используемые во всех компонентах системы с wait-free архитектурой.
|
||
|
||
use thiserror::Error;
|
||
use serde::{Deserialize, Serialize};
|
||
use std::fs;
|
||
use std::path::Path;
|
||
|
||
/// Основной тип ошибки для Futriix
|
||
#[derive(Error, Debug)]
|
||
pub enum FutriixError {
|
||
#[error("Configuration error: {0}")]
|
||
ConfigError(String),
|
||
|
||
#[error("Database error: {0}")]
|
||
DatabaseError(String),
|
||
|
||
#[error("Lua error: {0}")]
|
||
LuaError(String),
|
||
|
||
#[error("Network error: {0}")]
|
||
NetworkError(String),
|
||
|
||
#[error("Replication error: {0}")]
|
||
ReplicationError(String),
|
||
|
||
#[error("HTTP error: {0}")]
|
||
HttpError(String),
|
||
|
||
#[error("Serialization error: {0}")]
|
||
SerializationError(String),
|
||
|
||
#[error("IO error: {0}")]
|
||
IoError(#[from] std::io::Error),
|
||
|
||
#[error("CSV error: {0}")]
|
||
CsvError(String),
|
||
|
||
#[error("Unknown error: {0}")]
|
||
Unknown(String),
|
||
}
|
||
|
||
// Реализация преобразования из rlua::Error в FutriixError
|
||
impl From<rlua::Error> for FutriixError {
|
||
fn from(error: rlua::Error) -> Self {
|
||
FutriixError::LuaError(error.to_string())
|
||
}
|
||
}
|
||
|
||
/// Тип результата для Futriix
|
||
pub type Result<T> = std::result::Result<T, FutriixError>;
|
||
|
||
// Модуль конфигурации
|
||
pub mod config {
|
||
use super::*;
|
||
|
||
/// Конфигурация сервера
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct Config {
|
||
#[serde(default = "ServerConfig::default")]
|
||
pub server: ServerConfig,
|
||
#[serde(default = "ReplicationConfig::default")]
|
||
pub replication: ReplicationConfig,
|
||
#[serde(default = "ClusterConfig::default")] // Новая секция кластера
|
||
pub cluster: ClusterConfig,
|
||
#[serde(default = "LuaConfig::default")]
|
||
pub lua: LuaConfig,
|
||
#[serde(default = "AclConfig::default")]
|
||
pub acl: AclConfig,
|
||
#[serde(default = "TlsConfig::default")]
|
||
pub tls: TlsConfig,
|
||
#[serde(default = "CsvConfig::default")]
|
||
pub csv: CsvConfig,
|
||
}
|
||
|
||
/// Конфигурация серверных параметров
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct ServerConfig {
|
||
#[serde(default = "default_host")]
|
||
pub host: String,
|
||
#[serde(default = "default_port")]
|
||
pub port: u16,
|
||
#[serde(default)]
|
||
pub http_port: Option<u16>,
|
||
#[serde(default)]
|
||
pub https_port: Option<u16>,
|
||
#[serde(default)]
|
||
pub http2_enabled: Option<bool>,
|
||
#[serde(default = "default_http_enabled")] // Новая директива
|
||
pub http: bool,
|
||
#[serde(default = "default_https_enabled")] // Новая директива
|
||
pub https: bool,
|
||
}
|
||
|
||
/// Конфигурация репликации
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct ReplicationConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_master_nodes")]
|
||
pub master_nodes: Vec<String>,
|
||
#[serde(default = "default_sync_interval")]
|
||
pub sync_interval: u64,
|
||
}
|
||
|
||
/// Конфигурация кластера
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct ClusterConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_cluster_name")]
|
||
pub name: String,
|
||
}
|
||
|
||
/// Конфигурация Lua
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct LuaConfig {
|
||
#[serde(default = "default_scripts_dir")]
|
||
pub scripts_dir: String,
|
||
#[serde(default)]
|
||
pub auto_execute: Vec<String>,
|
||
}
|
||
|
||
/// Конфигурация ACL
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct AclConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_allowed_ips")]
|
||
pub allowed_ips: Vec<String>,
|
||
#[serde(default)]
|
||
pub denied_ips: Vec<String>,
|
||
}
|
||
|
||
/// Конфигурация TLS
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct TlsConfig {
|
||
#[serde(default)]
|
||
pub enabled: bool,
|
||
#[serde(default = "default_cert_path")]
|
||
pub cert_path: String,
|
||
#[serde(default = "default_key_path")]
|
||
pub key_path: String,
|
||
}
|
||
|
||
/// Конфигурация CSV
|
||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||
pub struct CsvConfig {
|
||
#[serde(default = "default_csv_import_dir")]
|
||
pub import_dir: String,
|
||
#[serde(default = "default_csv_export_dir")]
|
||
pub export_dir: String,
|
||
#[serde(default = "default_max_csv_file_size")]
|
||
pub max_file_size: u64,
|
||
}
|
||
|
||
// Функции для значений по умолчанию
|
||
fn default_host() -> String {
|
||
"127.0.0.1".to_string()
|
||
}
|
||
|
||
fn default_port() -> u16 {
|
||
8081
|
||
}
|
||
|
||
fn default_http_enabled() -> bool {
|
||
true
|
||
}
|
||
|
||
fn default_https_enabled() -> bool {
|
||
false
|
||
}
|
||
|
||
fn default_master_nodes() -> Vec<String> {
|
||
vec!["127.0.0.1:8081".to_string(), "127.0.0.1:8083".to_string()]
|
||
}
|
||
|
||
fn default_sync_interval() -> u64 {
|
||
5000
|
||
}
|
||
|
||
fn default_cluster_name() -> String {
|
||
"futriix-default-cluster".to_string()
|
||
}
|
||
|
||
fn default_scripts_dir() -> String {
|
||
"lua_scripts".to_string()
|
||
}
|
||
|
||
fn default_allowed_ips() -> Vec<String> {
|
||
vec!["127.0.0.1".to_string(), "::1".to_string()]
|
||
}
|
||
|
||
fn default_cert_path() -> String {
|
||
"certs/cert.pem".to_string()
|
||
}
|
||
|
||
fn default_key_path() -> String {
|
||
"certs/key.pem".to_string()
|
||
}
|
||
|
||
fn default_csv_import_dir() -> String {
|
||
"/futriix/csv/import".to_string()
|
||
}
|
||
|
||
fn default_csv_export_dir() -> String {
|
||
"/futriix/csv/export".to_string()
|
||
}
|
||
|
||
fn default_max_csv_file_size() -> u64 {
|
||
104857600 // 100MB
|
||
}
|
||
|
||
impl Default for ServerConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
host: default_host(),
|
||
port: default_port(),
|
||
http_port: Some(8082),
|
||
https_port: None,
|
||
http2_enabled: Some(false),
|
||
http: default_http_enabled(),
|
||
https: default_https_enabled(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for ReplicationConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
master_nodes: default_master_nodes(),
|
||
sync_interval: default_sync_interval(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for ClusterConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
name: default_cluster_name(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for LuaConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
scripts_dir: default_scripts_dir(),
|
||
auto_execute: vec!["init.lua".to_string()],
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for AclConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
allowed_ips: default_allowed_ips(),
|
||
denied_ips: vec![],
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for TlsConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
enabled: false,
|
||
cert_path: default_cert_path(),
|
||
key_path: default_key_path(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for CsvConfig {
|
||
fn default() -> Self {
|
||
Self {
|
||
import_dir: default_csv_import_dir(),
|
||
export_dir: default_csv_export_dir(),
|
||
max_file_size: default_max_csv_file_size(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Default for Config {
|
||
fn default() -> Self {
|
||
Self {
|
||
server: ServerConfig::default(),
|
||
replication: ReplicationConfig::default(),
|
||
cluster: ClusterConfig::default(),
|
||
lua: LuaConfig::default(),
|
||
acl: AclConfig::default(),
|
||
tls: TlsConfig::default(),
|
||
csv: CsvConfig::default(),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Config {
|
||
/// Загрузка конфигурации из файла
|
||
pub fn load(path: &str) -> Result<Self> {
|
||
let path = Path::new(path);
|
||
|
||
if !path.exists() {
|
||
// Создание конфигурации по умолчанию
|
||
let default_config = Config::default();
|
||
let toml_content = toml::to_string_pretty(&default_config)
|
||
.map_err(|e| FutriixError::ConfigError(e.to_string()))?;
|
||
|
||
fs::write(path, toml_content)
|
||
.map_err(|e| FutriixError::ConfigError(e.to_string()))?;
|
||
|
||
println!("Created default configuration file: {}", path.display());
|
||
return Ok(default_config);
|
||
}
|
||
|
||
let content = fs::read_to_string(path)
|
||
.map_err(|e| FutriixError::ConfigError(e.to_string()))?;
|
||
|
||
// Парсим конфигурацию с использованием значений по умолчанию
|
||
let mut config: Config = toml::from_str(&content)
|
||
.map_err(|e| FutriixError::ConfigError(e.to_string()))?;
|
||
|
||
// Убеждаемся, что все поля имеют значения по умолчанию, если они отсутствуют
|
||
if config.server.host.is_empty() {
|
||
config.server.host = default_host();
|
||
}
|
||
if config.server.port == 0 {
|
||
config.server.port = default_port();
|
||
}
|
||
if config.replication.master_nodes.is_empty() {
|
||
config.replication.master_nodes = default_master_nodes();
|
||
}
|
||
if config.replication.sync_interval == 0 {
|
||
config.replication.sync_interval = default_sync_interval();
|
||
}
|
||
if config.cluster.name.is_empty() {
|
||
config.cluster.name = default_cluster_name();
|
||
}
|
||
if config.lua.scripts_dir.is_empty() {
|
||
config.lua.scripts_dir = default_scripts_dir();
|
||
}
|
||
if config.acl.allowed_ips.is_empty() {
|
||
config.acl.allowed_ips = default_allowed_ips();
|
||
}
|
||
if config.tls.cert_path.is_empty() {
|
||
config.tls.cert_path = default_cert_path();
|
||
}
|
||
if config.tls.key_path.is_empty() {
|
||
config.tls.key_path = default_key_path();
|
||
}
|
||
if config.csv.import_dir.is_empty() {
|
||
config.csv.import_dir = default_csv_import_dir();
|
||
}
|
||
if config.csv.export_dir.is_empty() {
|
||
config.csv.export_dir = default_csv_export_dir();
|
||
}
|
||
if config.csv.max_file_size == 0 {
|
||
config.csv.max_file_size = default_max_csv_file_size();
|
||
}
|
||
|
||
Ok(config)
|
||
}
|
||
|
||
/// Сохранение конфигурации в файл
|
||
#[allow(dead_code)]
|
||
pub fn save(&self, path: &str) -> Result<()> {
|
||
let toml_content = toml::to_string_pretty(self)
|
||
.map_err(|e| FutriixError::ConfigError(e.to_string()))?;
|
||
|
||
fs::write(path, toml_content)
|
||
.map_err(|e| FutriixError::ConfigError(e.to_string()))
|
||
}
|
||
}
|
||
}
|
||
|
||
// Модуль протокола
|
||
pub mod protocol {
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
/// Команды для выполнения в базе данных
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub enum Command {
|
||
// Базовые CRUD команды
|
||
Create {
|
||
collection: String,
|
||
document: Vec<u8>,
|
||
},
|
||
Read {
|
||
collection: String,
|
||
id: String,
|
||
},
|
||
Update {
|
||
collection: String,
|
||
id: String,
|
||
document: Vec<u8>,
|
||
},
|
||
Delete {
|
||
collection: String,
|
||
id: String,
|
||
},
|
||
Query {
|
||
collection: String,
|
||
filter: Vec<u8>,
|
||
},
|
||
|
||
// Команды для процедур и транзакций
|
||
CreateProcedure {
|
||
name: String,
|
||
code: Vec<u8>,
|
||
},
|
||
CallProcedure {
|
||
name: String,
|
||
},
|
||
BeginTransaction {
|
||
transaction_id: String,
|
||
},
|
||
CommitTransaction {
|
||
transaction_id: String,
|
||
},
|
||
RollbackTransaction {
|
||
transaction_id: String,
|
||
},
|
||
|
||
// Команды для индексов
|
||
CreateIndex {
|
||
collection: String,
|
||
index: crate::server::database::Index,
|
||
},
|
||
QueryByIndex {
|
||
collection: String,
|
||
index_name: String,
|
||
value: Vec<u8>,
|
||
},
|
||
|
||
// Команды для шардинга с Raft
|
||
AddShardNode {
|
||
node_id: String,
|
||
address: String,
|
||
capacity: u64,
|
||
},
|
||
RemoveShardNode {
|
||
node_id: String,
|
||
},
|
||
MigrateShard {
|
||
collection: String,
|
||
from_node: String,
|
||
to_node: String,
|
||
shard_key: String,
|
||
},
|
||
RebalanceCluster,
|
||
GetClusterStatus,
|
||
StartElection, // Новая команда для Raft выборов
|
||
GetRaftNodes, // Новая команда для получения Raft узлов
|
||
|
||
// Команды для constraints
|
||
AddConstraint {
|
||
collection: String,
|
||
constraint_name: String,
|
||
constraint_type: String,
|
||
field: String,
|
||
value: Vec<u8>,
|
||
},
|
||
RemoveConstraint {
|
||
collection: String,
|
||
constraint_name: String,
|
||
},
|
||
|
||
// Команды для компрессии
|
||
EnableCompression {
|
||
collection: String,
|
||
algorithm: String,
|
||
},
|
||
DisableCompression {
|
||
collection: String,
|
||
},
|
||
|
||
// Команды для глобальных индексов
|
||
CreateGlobalIndex {
|
||
name: String,
|
||
field: String,
|
||
unique: bool,
|
||
},
|
||
QueryGlobalIndex {
|
||
index_name: String,
|
||
value: Vec<u8>,
|
||
},
|
||
|
||
// Новые команды для CSV импорта/экспорта
|
||
ImportCsv {
|
||
collection: String,
|
||
file_path: String,
|
||
},
|
||
ExportCsv {
|
||
collection: String,
|
||
file_path: String,
|
||
},
|
||
ListCsvFiles,
|
||
GetImportProgress {
|
||
collection: String,
|
||
},
|
||
}
|
||
|
||
/// Ответы от базы данных
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub enum Response {
|
||
Success(Vec<u8>),
|
||
Error(String),
|
||
}
|
||
|
||
/// Сообщение для репликации
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct ReplicationMessage {
|
||
pub sequence: u64,
|
||
pub command: Command,
|
||
pub timestamp: i64,
|
||
}
|
||
|
||
/// Структура для информации о шарде
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct ShardInfo {
|
||
pub node_id: String,
|
||
pub address: String,
|
||
pub capacity: u64,
|
||
pub used: u64,
|
||
pub collections: Vec<String>,
|
||
}
|
||
|
||
/// Структура для информации о Raft узле
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct RaftNodeInfo {
|
||
pub node_id: String,
|
||
pub address: String,
|
||
pub state: String, // "leader", "follower", "candidate"
|
||
pub term: u64,
|
||
pub last_heartbeat: i64,
|
||
}
|
||
|
||
/// Структура для статуса кластера
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct ClusterStatus {
|
||
pub nodes: Vec<ShardInfo>,
|
||
pub total_capacity: u64,
|
||
pub total_used: u64,
|
||
pub rebalance_needed: bool,
|
||
pub cluster_formed: bool, // Новое поле: собран ли кластер
|
||
pub leader_exists: bool, // Новое поле: существует ли лидер
|
||
pub raft_nodes: Vec<RaftNodeInfo>, // Новое поле: список Raft узлов
|
||
}
|
||
|
||
/// Wait-Free сериализация сообщений
|
||
pub fn serialize<T: serde::Serialize>(value: &T) -> crate::common::Result<Vec<u8>> {
|
||
rmp_serde::to_vec(value)
|
||
.map_err(|e| crate::common::FutriixError::SerializationError(e.to_string()))
|
||
}
|
||
|
||
/// Wait-Free десериализация сообщений
|
||
pub fn deserialize<'a, T: serde::Deserialize<'a>>(bytes: &'a [u8]) -> crate::common::Result<T> {
|
||
rmp_serde::from_slice(bytes)
|
||
.map_err(|e| crate::common::FutriixError::SerializationError(e.to_string()))
|
||
}
|
||
}
|