somnytoo 1.1.2

Binary protocol server for secure communications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use serde::{Deserialize, Serialize};
use tokio::sync::RwLock;
use std::sync::Arc;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AutoScalingConfig {
    pub enable_auto_scaling: bool,
    pub max_replicas: usize,
    pub scale_up_cpu_threshold: f64,
    pub scale_down_cpu_threshold: f64,
    pub scale_up_connections_threshold: usize,
    pub check_interval_seconds: u64,
}

impl Default for AutoScalingConfig {
    fn default() -> Self {
        Self {
            enable_auto_scaling: true,
            max_replicas: 10,
            scale_up_cpu_threshold: 80.0,
            scale_down_cpu_threshold: 30.0,
            scale_up_connections_threshold: 1000,
            check_interval_seconds: 60,
        }
    }
}

#[derive(Debug, Clone)]
pub struct SystemMetrics {
    pub cpu_usage: f64,
    pub memory_usage: f64,
    pub active_connections: usize,
    pub queries_per_second: f64,
}

pub struct AutoScaler {
    config: AutoScalingConfig,
    current_replicas: Arc<RwLock<usize>>,
    metrics_history: Arc<RwLock<Vec<SystemMetrics>>>,
}

impl AutoScaler {
    pub fn new(config: AutoScalingConfig) -> Self {
        Self {
            config,
            current_replicas: Arc::new(RwLock::new(1)),
            metrics_history: Arc::new(RwLock::new(Vec::new())),
        }
    }

    // ✅ ДОБАВЛЕНО: Основной метод автоскейлинга
    pub async fn check_and_scale(&self, current_metrics: SystemMetrics) -> ScalingDecision {
        if !self.config.enable_auto_scaling {
            return ScalingDecision::NoAction;
        }

        // Сохраняем метрики для анализа тренда
        {
            let mut history = self.metrics_history.write().await;
            history.push(current_metrics.clone());
            // Сохраняем только последние 10 метрик
            if history.len() > 10 {
                history.remove(0);
            }
        }

        let current_replicas = *self.current_replicas.read().await;

        // Проверяем условия для масштабирования вверх
        if self.should_scale_up(&current_metrics, current_replicas).await {
            let new_replicas = (current_replicas + 1).min(self.config.max_replicas);
            *self.current_replicas.write().await = new_replicas;
            return ScalingDecision::ScaleUp(new_replicas);
        }

        // Проверяем условия для масштабирования вниз
        if self.should_scale_down(&current_metrics, current_replicas).await {
            let new_replicas = current_replicas.saturating_sub(1).max(1);
            *self.current_replicas.write().await = new_replicas;
            return ScalingDecision::ScaleDown(new_replicas);
        }

        ScalingDecision::NoAction
    }

    async fn should_scale_up(&self, metrics: &SystemMetrics, current_replicas: usize) -> bool {
        if current_replicas >= self.config.max_replicas {
            return false;
        }

        // Условия для масштабирования вверх
        metrics.cpu_usage > self.config.scale_up_cpu_threshold ||
            metrics.active_connections > self.config.scale_up_connections_threshold ||
            metrics.queries_per_second > 1000.0 // Дополнительное условие
    }

    async fn should_scale_down(&self, metrics: &SystemMetrics, current_replicas: usize) -> bool {
        if current_replicas <= 1 {
            return false;
        }

        // Условия для масштабирования вниз
        metrics.cpu_usage < self.config.scale_down_cpu_threshold &&
            metrics.active_connections < (self.config.scale_up_connections_threshold / 2) &&
            metrics.queries_per_second < 100.0
    }

    // ✅ ДОБАВЛЕНО: Метод для получения текущего состояния
    pub async fn get_status(&self) -> AutoScalerStatus {
        let current_replicas = *self.current_replicas.read().await;
        let history = self.metrics_history.read().await;

        AutoScalerStatus {
            enabled: self.config.enable_auto_scaling,
            current_replicas,
            max_replicas: self.config.max_replicas,
            metrics_history_count: history.len(),
        }
    }

    // ✅ ДОБАВЛЕНО: Метод для ручного управления репликами
    pub async fn set_replica_count(&self, count: usize) -> Result<(), String> {
        if count > self.config.max_replicas {
            return Err(format!("Replica count cannot exceed {}", self.config.max_replicas));
        }

        *self.current_replicas.write().await = count;
        Ok(())
    }
}

#[derive(Debug, Clone)]
pub enum ScalingDecision {
    NoAction,
    ScaleUp(usize),
    ScaleDown(usize),
}

pub struct AutoScalerStatus {
    pub enabled: bool,
    pub current_replicas: usize,
    pub max_replicas: usize,
    pub metrics_history_count: usize,
}