init services in main

3 years ago · 4fa6d81328
4 changed files with 45 additions and 29 deletions
--- a/server/src/api/mod.rs
+++ b/server/src/api/mod.rs
@ -1,5 +1,5 @@
 use hastic::config::Config;
-use hastic::services::analytic_service::AnalyticService;
+use hastic::services::analytic_service::{analytic_client, AnalyticService};
 use hastic::services::{metric_service, segments_service, user_service};
 use warp::http::HeaderValue;
 use warp::hyper::{Body, StatusCode};
@ -32,19 +32,23 @@ pub struct API<'a> {
    user_service: Arc<RwLock<user_service::UserService>>,
    metric_service: metric_service::MetricService,
    segments_service: segments_service::SegmentsService,
+    analytic_client: analytic_client::AnalyticClient,
 }

 impl API<'_> {
-    pub fn new(config: &Config) -> anyhow::Result<API<'_>> {
-        let ss = segments_service::SegmentsService::new()?;
-        let ms = metric_service::MetricService::new(&config.prom_url, &config.query);
-
-        Ok(API {
+    pub fn new(
+        config: &Config,
+        metric_service: metric_service::MetricService,
+        segments_service: segments_service::SegmentsService,
+        analytic_client: analytic_client::AnalyticClient,
+    ) -> API<'_> {
+        API {
            config: config,
            user_service: Arc::new(RwLock::new(user_service::UserService::new())),
-            metric_service: ms.clone(),
-            segments_service: ss.clone(),
-        })
+            metric_service,
+            segments_service,
+            analytic_client,
+        }
    }

    fn json<T: Serialize>(t: &T) -> Response<Body> {
@ -69,9 +73,6 @@ impl API<'_> {
    }

    pub async fn serve(&self) {
-        let mut analytic_service =
-            AnalyticService::new(self.metric_service.clone(), self.segments_service.clone());
-
        let not_found =
            warp::any().map(|| warp::reply::with_status("Not found", StatusCode::NOT_FOUND));
        let options = warp::any().and(options()).map(|| {
@ -81,11 +82,9 @@ impl API<'_> {
        });
        let metrics = metric::get_route(self.metric_service.clone());
        let login = auth::get_route(self.user_service.clone());
-        let segments = segments::filters::filters(
-            self.segments_service.clone(),
-            analytic_service.get_client(),
-        );
-        let analytics = analytics::filters::filters(analytic_service.get_client());
+        let segments =
+            segments::filters::filters(self.segments_service.clone(), self.analytic_client.clone());
+        let analytics = analytics::filters::filters(self.analytic_client.clone());
        let public = warp::fs::dir("public");

        println!("Start server on {} port", self.config.port);
@ -95,9 +94,8 @@ impl API<'_> {
            .or(public)
            .or(not_found);

-        let s1 = analytic_service.serve();
-        let s2 = warp::serve(routes).run(([127, 0, 0, 1], self.config.port));
-
-        futures::future::join(s1, s2).await;
+        warp::serve(routes)
+            .run(([127, 0, 0, 1], self.config.port))
+            .await;
    }
 }
--- a/server/src/config.rs
+++ b/server/src/config.rs
@ -1,6 +1,5 @@
 use std::collections::HashMap;

-
 pub struct Config {
    pub prom_url: String,
    pub query: String,
@ -10,13 +9,14 @@ pub struct Config {
 // TODO: use actual config and env variables
 impl Config {
    pub fn new() -> Config {
-
        let mut config = config::Config::default();

        if std::path::Path::new("config.toml").exists() {
            config.merge(config::File::with_name("config")).unwrap();
        }
-        config.merge(config::Environment::with_prefix("HASTIC")).unwrap();
+        config
+            .merge(config::Environment::with_prefix("HASTIC"))
+            .unwrap();

        if config.get::<u16>("port").is_err() {
            config.set("port", "8000").unwrap();
@ -25,13 +25,15 @@ impl Config {
            config.set("prom_url", "http://localhost:9090").unwrap();
        }
        if config.get::<String>("query").is_err() {
-            config.set("query", "rate(go_memstats_alloc_bytes_total[5m])").unwrap();
+            config
+                .set("query", "rate(go_memstats_alloc_bytes_total[5m])")
+                .unwrap();
        }

        Config {
            port: config.get::<u16>("port").unwrap(),
            prom_url: config.get("prom_url").unwrap(),
-            query: config.get("query").unwrap()
+            query: config.get("query").unwrap(),
        }
    }
 }
--- a/server/src/main.rs
+++ b/server/src/main.rs
@ -1,13 +1,29 @@
 use anyhow;
+use hastic::services::{analytic_service, metric_service, segments_service};

 mod api;

 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
    let config = hastic::config::Config::new();
-    let api = api::API::new(&config)?;

-    api.serve().await;
+    let metric_service = metric_service::MetricService::new(&config.prom_url, &config.query);
+    let segments_service = segments_service::SegmentsService::new()?;
+
+    let mut analytic_service =
+        analytic_service::AnalyticService::new(metric_service.clone(), segments_service.clone());
+
+    let api = api::API::new(
+        &config,
+        metric_service.clone(),
+        segments_service.clone(),
+        analytic_service.get_client(),
+    );
+
+    let s1 = analytic_service.serve();
+    let s2 = api.serve();
+
+    futures::future::join(s1, s2).await;

    Ok(())
 }
--- a/server/src/services/analytic_service/pattern_detector.rs
+++ b/server/src/services/analytic_service/pattern_detector.rs
@ -58,7 +58,7 @@ impl PatternDetector {

        // let model = stat.iter().map(|(c, v)| v / *c as f64).collect();

-        LearningResults { 
+        LearningResults {
            patterns
            //model
        }