Hastic standalone
https://hastic.io
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
129 lines
3.1 KiB
129 lines
3.1 KiB
use std::{fmt, sync::Arc}; |
|
|
|
use crate::services::segments_service::Segment; |
|
|
|
use super::analytic_unit::{ |
|
pattern_analytic_unit::{self}, |
|
types::AnalyticUnitConfig, |
|
}; |
|
|
|
use super::analytic_unit::types::PatchConfig; |
|
|
|
use anyhow::Result; |
|
use serde::Serialize; |
|
use tokio::sync::{oneshot, RwLock}; |
|
|
|
use crate::services::analytic_service::analytic_unit::types::AnalyticUnit; |
|
|
|
pub type AnalyticUnitRF = Arc<RwLock<Box<dyn AnalyticUnit + Send + Sync>>>; |
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize)] |
|
pub enum LearningStatus { |
|
Initialization, |
|
Starting, |
|
Learning, |
|
Error(String), |
|
Ready, |
|
} |
|
|
|
// TODO: move to analytic_unit config of pattern detector |
|
#[derive(Clone, Serialize, Debug)] |
|
pub struct LearningTrain { |
|
pub features: Vec<pattern_analytic_unit::Features>, |
|
pub target: Vec<bool>, |
|
} |
|
|
|
impl Default for LearningTrain { |
|
fn default() -> Self { |
|
return LearningTrain { |
|
features: Vec::new(), |
|
target: Vec::new(), |
|
}; |
|
} |
|
} |
|
|
|
pub enum ResponseType { |
|
DetectionRunnerStarted(u64), |
|
DetectionRunnerUpdate(String, u64), // analytic_unit id and timestamp |
|
DetectionRunnerDetection(u64, u64), // TODO: add more into about analytic unit and more |
|
LearningStarted, |
|
LearningFinished(Box<dyn AnalyticUnit + Send + Sync>), |
|
LearningFinishedEmpty, |
|
} |
|
|
|
impl fmt::Debug for ResponseType { |
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
|
// TODO: implement |
|
f.debug_tuple("foo").finish() |
|
} |
|
} |
|
|
|
#[derive(Debug)] |
|
pub struct DetectionTask { |
|
pub sender: oneshot::Sender<Result<Vec<Segment>>>, |
|
pub from: u64, |
|
pub to: u64, |
|
} |
|
|
|
#[derive(Debug)] |
|
pub struct DetectionRunnerTask { |
|
pub from: u64, |
|
} |
|
|
|
#[derive(Debug, Serialize)] |
|
pub struct AnomalyHSRConfig { |
|
pub timestamp: u64, |
|
pub seasonality: u64, |
|
pub ts: Vec<(u64, f64, (f64, f64))>, |
|
} |
|
// HSR Stands for Hastic Signal Representation, |
|
// varies for different analytic units |
|
#[derive(Debug, Serialize)] |
|
pub enum HSR { |
|
TimeSerie(Vec<(u64, f64)>), |
|
AnomalyHSR(AnomalyHSRConfig), |
|
} |
|
|
|
#[derive(Debug)] |
|
pub struct HSRTask { |
|
// TODO: make enum for HSR which is different for different Analytic Types |
|
pub sender: oneshot::Sender<Result<HSR>>, |
|
pub from: u64, |
|
pub to: u64, |
|
} |
|
|
|
#[derive(Debug)] |
|
pub enum LearningWaiter { |
|
Detection(DetectionTask), |
|
DetectionRunner(DetectionRunnerTask), |
|
HSR(HSRTask), |
|
} |
|
|
|
// TODO: review if it's needed |
|
#[derive(Debug, Clone)] |
|
pub struct DetectionRunnerConfig { |
|
// pub sender: mpsc::Sender<Result<Vec<Segment>>>, |
|
pub endpoint: String, |
|
// pub from: u64, |
|
pub interval: u64, |
|
} |
|
|
|
#[derive(Debug)] |
|
pub enum RequestType { |
|
// TODO: convert to result RunLearning(anyhow::Result<()>) |
|
RunLearning, |
|
GetHSR(HSRTask), |
|
RunDetection(DetectionTask), |
|
GetStatus(oneshot::Sender<LearningStatus>), |
|
// TODO: make type of Value |
|
PatchConfig(PatchConfig, oneshot::Sender<()>), |
|
GetConfig(oneshot::Sender<AnalyticUnitConfig>), |
|
// GetLearningTrain(oneshot::Sender<LearningTrain>), |
|
} |
|
|
|
#[derive(Debug)] |
|
pub enum AnalyticServiceMessage { |
|
// Status, |
|
Request(RequestType), |
|
Response(anyhow::Result<ResponseType>), // Detect { from: u64, to: u64 }, |
|
}
|
|
|