buggy config patch

client/src/views/Home.vue

@@ -33,6 +33,8 @@ import Graph from '@/components/Graph.vue';
 import AnalyticStatus from '@/components/AnlyticsStatus.vue';
 import { AnalyticUnitType } from '@/types/analytic_units';
 
+import * as _ from 'lodash';
+
 
 export default defineComponent({
   name: 'Home',
@@ -45,13 +47,17 @@ export default defineComponent({
       this.$refs.graph.deleteAllSegments();
     },
     changeAnalyticUnitType(e) {
-      this.$store.dispatch('patchConfig', { [e.target.value]: true } );
+      this.$store.dispatch('patchConfig', { [e.target.value]: null } );
     },
     correlationScoreChange(e) {
-      this.$store.dispatch('patchConfig', { Pattern: { correlation_score: e.target.value } });
+      let cfg = _.clone(this.analyticUnitConfig);
+      cfg.correlation_score = parseFloat(e.target.value);
+      this.$store.dispatch('patchConfig',  { Pattern: cfg });
     },
     modelScoreChange(e) {
-      this.$store.dispatch('patchConfig', { Pattern: { model_score: e.target.value } });
+      let cfg = _.clone(this.analyticUnitConfig);
+      cfg.model_score = parseFloat(e.target.value);
+      this.$store.dispatch('patchConfig', { Pattern: cfg });
     }
   },
   data: function () {
@@ -59,7 +65,7 @@ export default defineComponent({
       analyticUnitTypes: [
         AnalyticUnitType.THRESHOLD,
         AnalyticUnitType.PATTERN,
-        AnalyticUnitType.ANOMALY, 
+        AnalyticUnitType.ANOMALY,
       ]
     }
   },

server/src/api/analytics.rs

@@ -120,7 +120,7 @@ mod handlers {
 
     pub async fn patch_config(client: Client, patch: PatchConfig) -> Result<impl warp::Reply, warp::Rejection> {
 
-        println!("{:?}", patch);
+        // println!("{:?}", patch);
         match client.patch_config(patch).await {
             Ok(cf) => Ok(API::json(&cf)),
             Err(e) => {

server/src/services/analytic_service/analytic_service.rs

@@ -219,9 +219,12 @@ impl AnalyticService {
         }
     }
 
-    fn patch_config(&mut self, mut patch: PatchConfig) {
-        // let r = patch.take();
-        println!("{:?}", patch);
+    fn patch_config(&mut self, patch: PatchConfig) {
+        let (new_conf, need_learning) = self.analytic_unit_config.patch(patch);
+        self.analytic_unit_config = new_conf;
+        if need_learning {
+            self.consume_request(RequestType::RunLearning);
+        }
     }
 
     pub async fn serve(&mut self) {

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

@@ -3,14 +3,12 @@ pub mod threshold_analytic_unit;
 pub mod anomaly_analytic_unit;
 pub mod types;
 
-use self::{
-    pattern_analytic_unit::PatternAnalyticUnit, threshold_analytic_unit::ThresholdAnalyticUnit,
-    types::AnalyticUnitConfig,
-};
+use self::{anomaly_analytic_unit::AnomalyAnalyticUnit, pattern_analytic_unit::PatternAnalyticUnit, threshold_analytic_unit::ThresholdAnalyticUnit, types::AnalyticUnitConfig};
 
 pub fn resolve(cfg: AnalyticUnitConfig) -> Box<dyn types::AnalyticUnit + Send + Sync> {
     match cfg {
-        AnalyticUnitConfig::Pattern(c) => Box::new(PatternAnalyticUnit::new(c.clone())),
         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_service/analytic_unit/types.rs

@@ -1,12 +1,12 @@
+use fastrand::bool;
 use serde::{Deserialize, Serialize};
 
 use async_trait::async_trait;
 
 use crate::services::{
-    analytic_service::types, metric_service::MetricService, segments_service::SegmentsService,
+    metric_service::MetricService, segments_service::SegmentsService,
 };
 
-use super::threshold_analytic_unit::ThresholdAnalyticUnit;
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct PatternConfig {
@@ -14,20 +14,112 @@ pub struct PatternConfig {
     pub model_score: f32,
 }
 
+impl Default for PatternConfig {
+    fn default() -> Self {
+        PatternConfig {
+            correlation_score: 0.95,
+            model_score: 0.95,
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct AnomalyConfig {
     pub sesonality: bool,
 }
 
+impl Default for AnomalyConfig {
+    fn default() -> Self {
+        AnomalyConfig {
+            sesonality: false
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ThresholdConfig {
     pub threashold: f64,
 }
 
+impl Default for ThresholdConfig {
+    fn default() -> Self {
+        ThresholdConfig {
+            threashold: 0.5
+        }
+    }
+}
+
+
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub enum AnalyticUnitConfig {
     Pattern(PatternConfig),
     Threshold(ThresholdConfig),
+    Anomaly(AnomalyConfig)
+}
+
+impl AnalyticUnitConfig {
+    // return tru if patch is different type
+    pub fn patch(&self, patch: PatchConfig) -> (AnalyticUnitConfig, bool) {
+        match patch {
+            PatchConfig::Pattern(tcfg) => {
+                match self.clone() {
+                    AnalyticUnitConfig::Pattern(_) => {
+                        if tcfg.is_some() {
+                            return (AnalyticUnitConfig::Pattern(tcfg.unwrap()), false)
+                        } else {
+                            return (AnalyticUnitConfig::Pattern(Default::default()), false)
+                        }
+                    },
+                    _ => {
+                        if tcfg.is_some() {
+                            return (AnalyticUnitConfig::Pattern(tcfg.unwrap()), true)
+                        } else {
+                            return (AnalyticUnitConfig::Pattern(Default::default()), true)
+                        }
+                    },
+                }
+            }
+
+            PatchConfig::Anomaly(tcfg) => {
+                match self.clone() {
+                    AnalyticUnitConfig::Anomaly(_) => {
+                        if tcfg.is_some() {
+                            return (AnalyticUnitConfig::Anomaly(tcfg.unwrap()), false)
+                        } else {
+                            return (AnalyticUnitConfig::Anomaly(Default::default()), false)
+                        }
+                    },
+                    _ => {
+                        if tcfg.is_some() {
+                            return (AnalyticUnitConfig::Anomaly(tcfg.unwrap()), true)
+                        } else {
+                            return (AnalyticUnitConfig::Anomaly(Default::default()), true)
+                        }
+                    },
+                }
+            }
+
+            PatchConfig::Threshold(tcfg) => {
+                match self.clone() {
+                    AnalyticUnitConfig::Threshold(_) => {
+                        if tcfg.is_some() {
+                            return (AnalyticUnitConfig::Threshold(tcfg.unwrap()), false)
+                        } else {
+                            return (AnalyticUnitConfig::Threshold(Default::default()), false)
+                        }
+                    },
+                    _ => {
+                        if tcfg.is_some() {
+                            return (AnalyticUnitConfig::Threshold(tcfg.unwrap()), true)
+                        } else {
+                            return (AnalyticUnitConfig::Threshold(Default::default()), true)
+                        }
+                    },
+                }
+            }
+        }
+    }
 }
 
 pub enum LearningResult {
@@ -49,7 +141,7 @@ pub trait AnalyticUnit {
 
 #[derive(Deserialize, Serialize, Debug)]
 pub enum PatchConfig {
-    Pattern(bool),
-    Threshold(bool),
-    Anomaly(bool)
+    Pattern(Option<PatternConfig>),
+    Threshold(Option<ThresholdConfig>),
+    Anomaly(Option<AnomalyConfig>)
 }