get rids of meilisearch-lib

meilisearch-http/src/main.rs

@@ -2,13 +2,16 @@ use std::env;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use actix_cors::Cors;
 use actix_web::http::KeepAlive;
-use actix_web::HttpServer;
+use actix_web::web::Data;
+use actix_web::{middleware, HttpServer};
+use clap::Parser;
+use index_scheduler::IndexScheduler;
 use meilisearch_auth::AuthController;
-use meilisearch_http::analytics;
 use meilisearch_http::analytics::Analytics;
-use meilisearch_http::{create_app, setup_meilisearch, Opt};
-use meilisearch_lib::MeiliSearch;
+use meilisearch_http::{analytics, configure_data, create_app, dashboard, routes};
+use meilisearch_http::{setup_meilisearch, Opt};
 
 #[global_allocator]
 static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;
@@ -45,9 +48,7 @@ async fn main() -> anyhow::Result<()> {
         _ => unreachable!(),
     }
 
-    let meilisearch = setup_meilisearch(&opt)?;
-    let m = meilisearch.clone();
-    tokio::task::spawn_blocking(move || m.run());
+    let index_scheduler = setup_meilisearch(&opt)?;
 
     let auth_controller = AuthController::new(&opt.db_path, &opt.master_key)?;
 
@@ -62,39 +63,81 @@ async fn main() -> anyhow::Result<()> {
 
     print_launch_resume(&opt, &user, config_read_from);
 
-    run_http(meilisearch, auth_controller, opt, analytics).await?;
+    run_http(index_scheduler, auth_controller, opt, analytics).await?;
 
     Ok(())
 }
 
 async fn run_http(
-    data: MeiliSearch,
+    index_scheduler: IndexScheduler,
     auth_controller: AuthController,
     opt: Opt,
     analytics: Arc<dyn Analytics>,
 ) -> anyhow::Result<()> {
-    let _enable_dashboard = &opt.env == "development";
+    let enable_dashboard = &opt.env == "development";
     let opt_clone = opt.clone();
+    let index_scheduler = Data::new(index_scheduler);
+
     let http_server = HttpServer::new(move || {
+        let app = actix_web::App::new()
+            .configure(|s| {
+                configure_data(
+                    s,
+                    index_scheduler.clone(),
+                    auth_controller.clone(),
+                    &opt,
+                    analytics.clone(),
+                )
+            })
+            .configure(routes::configure)
+            .configure(|s| dashboard(s, enable_dashboard));
+
+        #[cfg(feature = "metrics")]
+        let app = app.configure(|s| configure_metrics_route(s, opt.enable_metrics_route));
+
+        let app = app
+            .wrap(
+                Cors::default()
+                    .send_wildcard()
+                    .allow_any_header()
+                    .allow_any_origin()
+                    .allow_any_method()
+                    .max_age(86_400), // 24h
+            )
+            .wrap(middleware::Logger::default())
+            .wrap(middleware::Compress::default())
+            .wrap(middleware::NormalizePath::new(
+                middleware::TrailingSlash::Trim,
+            ));
+
+        #[cfg(feature = "metrics")]
+        let app = app.wrap(Condition::new(
+            opt.enable_metrics_route,
+            route_metrics::RouteMetrics,
+        ));
+
+        app
+        /*
         create_app!(
-            data,
-            auth_controller,
-            _enable_dashboard,
-            opt_clone,
+            index_scheduler.clone(),
+            auth_controller.clone(),
+            enable_dashboard,
+            opt,
             analytics.clone()
         )
+        */
     })
     // Disable signals allows the server to terminate immediately when a user enter CTRL-C
     .disable_signals()
     .keep_alive(KeepAlive::Os);
 
-    if let Some(config) = opt.get_ssl_config()? {
+    if let Some(config) = opt_clone.get_ssl_config()? {
         http_server
-            .bind_rustls(opt.http_addr, config)?
+            .bind_rustls(opt_clone.http_addr, config)?
             .run()
             .await?;
     } else {
-        http_server.bind(&opt.http_addr)?.run().await?;
+        http_server.bind(&opt_clone.http_addr)?.run().await?;
     }
     Ok(())
 }