analytic unit config

server/src/api/analytics.rs

@@ -9,6 +9,7 @@ pub mod filters {
     ) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
         list(client.clone())
             .or(status(client.clone()))
+            .or(get_config(client.clone()))
             .or(list_train(client.clone()))
         // .or(create(db.clone()))
         // // .or(update(db.clone()))
@@ -36,6 +37,16 @@ pub mod filters {
             .and_then(handlers::status)
     }
 
+    /// GET /analytics/config
+    pub fn get_config(
+        client: Client,
+    ) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
+        warp::path!("analytics" / "config")
+            .and(warp::get())
+            .and(with_client(client))
+            .and_then(handlers::config)
+    }
+
     /// GET /analytics/model
     pub fn list_train(
         client: Client,
@@ -82,6 +93,16 @@ mod handlers {
         }
     }
 
+    pub async fn config(client: Client) -> Result<impl warp::Reply, warp::Rejection> {
+        match client.get_config().await {
+            Ok(cf) => Ok(API::json(&cf)),
+            Err(e) => {
+                println!("{:?}", e);
+                Err(warp::reject::custom(BadQuery))
+            }
+        }
+    }
+
     pub async fn list_train(client: Client) -> Result<impl warp::Reply, warp::Rejection> {
         match client.get_train().await {
             Ok(lt) => Ok(API::json(&lt)),

server/src/services/analytic_service/analytic_client.rs

@@ -3,6 +3,7 @@ use tokio::sync::oneshot;
 
 use crate::services::segments_service::Segment;
 
+use super::analytic_unit::types::AnalyticUnitConfig;
 use super::types::DetectionTask;
 use super::types::LearningStatus;
 use super::types::LearningTrain;
@@ -34,6 +35,14 @@ impl AnalyticClient {
         Ok(r)
     }
 
+    pub async fn get_config(&self) -> anyhow::Result<AnalyticUnitConfig> {
+        let (tx, rx) = oneshot::channel();
+        let req = AnalyticServiceMessage::Request(RequestType::GetConfig(tx));
+        self.tx.send(req).await?;
+        let r = rx.await?;
+        Ok(r)
+    }
+
     pub async fn get_train(&self) -> anyhow::Result<LearningTrain> {
         let (tx, rx) = oneshot::channel();
         let req = AnalyticServiceMessage::Request(RequestType::GetLearningTrain(tx));

server/src/services/analytic_service/analytic_service.rs

@@ -1,7 +1,8 @@
+use super::analytic_unit::types::{AnalyticUnitConfig, PatternDetectorConfig};
 use super::types::{self, DetectionRunnerConfig, LearningTrain};
 use super::{
     analytic_client::AnalyticClient,
-    pattern_detector::{self, LearningResults, PatternDetector},
+    analytic_unit::pattern_detector::{self, LearningResults, PatternDetector},
     types::{AnalyticServiceMessage, DetectionTask, LearningStatus, RequestType, ResponseType},
 };
 
@@ -51,6 +52,7 @@ pub struct AnalyticService {
     metric_service: MetricService,
     segments_service: SegmentsService,
     learning_results: Option<LearningResults>,
+    analytic_unit_config: AnalyticUnitConfig,
     learning_status: LearningStatus,
     tx: mpsc::Sender<AnalyticServiceMessage>,
     rx: mpsc::Receiver<AnalyticServiceMessage>,
@@ -78,8 +80,14 @@ impl AnalyticService {
         AnalyticService {
             metric_service,
             segments_service,
+
             // TODO: get it from persistance
             learning_results: None,
+            analytic_unit_config: AnalyticUnitConfig::PatternDetector(PatternDetectorConfig {
+                correlation_score: 0.95,
+                model_score: 0.95
+            }),
+
             learning_status: LearningStatus::Initialization,
             tx,
             rx,
@@ -180,6 +188,9 @@ impl AnalyticService {
                     .unwrap();
                 }
             }
+            RequestType::GetConfig(tx) => {
+                tx.send(self.analytic_unit_config.clone()).unwrap();
+            }
         };
     }
 

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

@@ -1,3 +1,6 @@
-trait AnalyticUnit<C> where C: AnalyticUnitConfig {
+pub mod pattern_detector;
+pub mod types;
+
+trait AnalyticUnit<C> {
     
 }

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

@@ -11,7 +11,9 @@ use linfa_svm::{error::Result, Svm};
 
 use ndarray::{Array, ArrayView, Axis};
 
-use super::types::LearningTrain;
+use crate::services::analytic_service::types::LearningTrain;
+
+
 
 #[derive(Clone)]
 pub struct LearningResults {

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

@@ -1,3 +1,12 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct PatternDetectorConfig {
+    pub correlation_score: f32,
+    pub model_score: f32
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub enum AnalyticUnitConfig {
     PatternDetector(PatternDetectorConfig)
 }

server/src/services/analytic_service/mod.rs

@@ -1,5 +1,5 @@
 mod analytic_service;
-mod pattern_detector;
+mod analytic_unit;
 pub mod types;
 
 pub mod analytic_client;

server/src/services/analytic_service/types.rs

@@ -1,6 +1,6 @@
 use crate::services::segments_service::Segment;
 
-use super::pattern_detector::{self, LearningResults};
+use super::analytic_unit::{pattern_detector::{self, LearningResults}, types::AnalyticUnitConfig};
 
 use anyhow::Result;
 use serde::Serialize;
@@ -15,6 +15,7 @@ pub enum LearningStatus {
     Ready,
 }
 
+// TODO: move to analytic_unit config of pattern detector
 #[derive(Clone, Serialize, Debug)]
 pub struct LearningTrain {
     pub features: Vec<pattern_detector::Features>,
@@ -58,6 +59,7 @@ pub enum RequestType {
     RunLearning,
     RunDetection(DetectionTask),
     GetStatus(oneshot::Sender<LearningStatus>),
+    GetConfig(oneshot::Sender<AnalyticUnitConfig>),
     GetLearningTrain(oneshot::Sender<LearningTrain>),
 }