From 27640a5b6f67003edbcd55214cd70c0503332731 Mon Sep 17 00:00:00 2001 From: Alexey Velikiy Date: Tue, 9 Nov 2021 12:48:11 +0300 Subject: [PATCH] buggy config patch --- client/src/views/Home.vue | 14 ++- server/src/api/analytics.rs | 2 +- .../analytic_service/analytic_service.rs | 9 +- .../analytic_service/analytic_unit/mod.rs | 8 +- .../analytic_service/analytic_unit/types.rs | 102 +++++++++++++++++- 5 files changed, 117 insertions(+), 18 deletions(-) diff --git a/client/src/views/Home.vue b/client/src/views/Home.vue index 330534b..1bdb770 100644 --- a/client/src/views/Home.vue +++ b/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, ] } }, diff --git a/server/src/api/analytics.rs b/server/src/api/analytics.rs index c6e8600..e73a47b 100644 --- a/server/src/api/analytics.rs +++ b/server/src/api/analytics.rs @@ -120,7 +120,7 @@ mod handlers { pub async fn patch_config(client: Client, patch: PatchConfig) -> Result { - println!("{:?}", patch); + // println!("{:?}", patch); match client.patch_config(patch).await { Ok(cf) => Ok(API::json(&cf)), Err(e) => { diff --git a/server/src/services/analytic_service/analytic_service.rs b/server/src/services/analytic_service/analytic_service.rs index 2813329..403ec1d 100644 --- a/server/src/services/analytic_service/analytic_service.rs +++ b/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) { diff --git a/server/src/services/analytic_service/analytic_unit/mod.rs b/server/src/services/analytic_service/analytic_unit/mod.rs index 5ab7d2e..6b84890 100644 --- a/server/src/services/analytic_service/analytic_unit/mod.rs +++ b/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 { 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())) } } diff --git a/server/src/services/analytic_service/analytic_unit/types.rs b/server/src/services/analytic_service/analytic_unit/types.rs index d165d61..845b651 100644 --- a/server/src/services/analytic_service/analytic_unit/types.rs +++ b/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), + Threshold(Option), + Anomaly(Option) }