AnalyticUnitService++

server/src/main.rs

@@ -1,6 +1,6 @@
 mod api;
 
-use hastic::services::{analytic_service, metric_service, segments_service};
+use hastic::services::{analytic_service, metric_service, segments_service, analytic_unit_service};
 
 use anyhow;
 
@@ -9,10 +9,12 @@ async fn main() -> anyhow::Result<()> {
     let config = hastic::config::Config::new()?;
     let cfg_clone = config.clone();
 
+    let analytic_unit_service = analytic_unit_service::AnalyticUnitService::new()?;
     let metric_service = metric_service::MetricService::new(&config.datasource_config);
     let segments_service = segments_service::SegmentsService::new()?;
 
     let mut analytic_service = analytic_service::AnalyticService::new(
+        analytic_unit_service.clone(),
         metric_service.clone(),
         segments_service.clone(),
         config.alerting,

server/src/services/analytic_service/analytic_service.rs

@@ -11,7 +11,8 @@ use super::{
 };
 
 use crate::config::{AlertingConfig, AlertingType};
-use crate::services::analytic_service::analytic_unit::resolve;
+
+use crate::services::analytic_unit_service::AnalyticUnitService;
 use crate::services::{
     metric_service::MetricService,
     segments_service::{self, Segment, SegmentType, SegmentsService, ID_LENGTH},
@@ -30,6 +31,7 @@ use tokio::sync::{mpsc, oneshot};
 pub struct AnalyticService {
     metric_service: MetricService,
     segments_service: SegmentsService,
+    analytic_unit_service: AnalyticUnitService,
 
     alerting: Option<AlertingConfig>,
 
@@ -52,6 +54,7 @@ pub struct AnalyticService {
 
 impl AnalyticService {
     pub fn new(
+        analytic_unit_service: AnalyticUnitService,
         metric_service: MetricService,
         segments_service: segments_service::SegmentsService,
         alerting: Option<AlertingConfig>,
@@ -59,6 +62,7 @@ impl AnalyticService {
         let (tx, rx) = mpsc::channel::<AnalyticServiceMessage>(32);
 
         AnalyticService {
+            analytic_unit_service,
             metric_service,
             segments_service,
 
@@ -161,11 +165,12 @@ impl AnalyticService {
                 self.learning_handler = Some(tokio::spawn({
                     self.analytic_unit_learning_status = LearningStatus::Starting;
                     let tx = self.tx.clone();
+                    let aus = self.analytic_unit_service.clone();
                     let ms = self.metric_service.clone();
                     let ss = self.segments_service.clone();
                     let cfg = self.analytic_unit_config.clone();
                     async move {
-                        AnalyticService::run_learning(tx, cfg, ms, ss).await;
+                        AnalyticService::run_learning(tx, cfg, aus, ms, ss).await;
                     }
                 }));
             }
@@ -321,10 +326,11 @@ impl AnalyticService {
     async fn run_learning(
         tx: mpsc::Sender<AnalyticServiceMessage>,
         aucfg: AnalyticUnitConfig,
+        aus: AnalyticUnitService,
         ms: MetricService,
         ss: SegmentsService,
     ) {
-        let mut au = resolve(aucfg);
+        let mut au = aus.resolve(aucfg);
 
         match tx
             .send(AnalyticServiceMessage::Response(Ok(

server/src/services/analytic_service/analytic_unit/mod.rs

@@ -8,10 +8,4 @@ use self::{
     threshold_analytic_unit::ThresholdAnalyticUnit, types::AnalyticUnitConfig,
 };
 
-pub fn resolve(cfg: AnalyticUnitConfig) -> Box<dyn types::AnalyticUnit + Send + Sync> {
-    match cfg {
-        AnalyticUnitConfig::Threshold(c) => Box::new(ThresholdAnalyticUnit::new(c.clone())),
-        AnalyticUnitConfig::Pattern(c) => Box::new(PatternAnalyticUnit::new(c.clone())),
-        AnalyticUnitConfig::Anomaly(c) => Box::new(AnomalyAnalyticUnit::new(c.clone())),
-    }
-}
+

server/src/services/analytic_unit_service.rs

@@ -1,13 +1,17 @@
+use std::sync::{Arc, Mutex};
+
 use crate::utils::get_random_str;
 
 use rusqlite::{params, Connection, Row};
 
+use super::analytic_service::analytic_unit::{types::{AnalyticUnitConfig, self}, threshold_analytic_unit::ThresholdAnalyticUnit, pattern_analytic_unit::PatternAnalyticUnit, anomaly_analytic_unit::AnomalyAnalyticUnit};
+
+#[derive(Clone)]
 pub struct AnalyticUnitService {
     // TODO: resolve by setting id for 3 types 
     // TODO: create database
     // TODO: update detection
-
-    
+    connection: Arc<Mutex<Connection>>
 }
 
 impl AnalyticUnitService {
@@ -20,7 +24,7 @@ impl AnalyticUnitService {
         conn.execute(
             "CREATE TABLE IF NOT EXISTS analytic_unit (
                       id              TEXT PRIMARY KEY,
-                      last_detection  INTEGER NOT NULL,
+                      last_detection  INTEGER NOT NULL
                  )",
             [],
         )?;
@@ -29,4 +33,12 @@ impl AnalyticUnitService {
             connection: Arc::new(Mutex::new(conn)),
         })
     }
+
+    pub fn resolve(&self, cfg: AnalyticUnitConfig) -> Box<dyn types::AnalyticUnit + Send + Sync> {
+        match cfg {
+            AnalyticUnitConfig::Threshold(c) => Box::new(ThresholdAnalyticUnit::new(c.clone())),
+            AnalyticUnitConfig::Pattern(c) => Box::new(PatternAnalyticUnit::new(c.clone())),
+            AnalyticUnitConfig::Anomaly(c) => Box::new(AnomalyAnalyticUnit::new(c.clone())),
+        }
+    }
 }

server/src/services/mod.rs

@@ -2,3 +2,4 @@ pub mod analytic_service;
 pub mod metric_service;
 pub mod segments_service;
 pub mod user_service;
+pub mod analytic_unit_service;