Remove civet server option

Author: Turbo87

Cargo.lock

@@ -34,7 +34,6 @@ anyhow = "1.0"
 base64 = "0.13"
 cargo-registry-s3 = { path = "src/s3", version = "0.2.0" }
 chrono = { version = "0.4.0", features = ["serde"] }
-civet = "0.12.0-alpha.5"
 clap = "=3.0.0-beta.2"
 comrak = { version = "0.9", default-features = false }
 

Cargo.toml

@@ -12,11 +12,10 @@ The server does the following things:
 3. Reads values from environment variables to configure a new instance of `cargo_registry::App`
 4. Adds middleware to the app by calling `cargo_registry::middleware`
 5. Syncs the categories defined in *src/categories.toml* with the categories in the database
-6. Starts either a [conduit] or a [hyper] server that uses the `cargo_registry::App` instance
+6. Starts a [hyper] server that uses the `cargo_registry::App` instance
 7. Tells Nginx on Heroku that the application is ready to receive requests, if running on Heroku
 8. Blocks forever (or until the process is killed)
 
-[civet]: https://crates.io/crates/civet
 [hyper]: https://crates.io/crates/hyper
 
 ## Routes

docs/BACKEND.md

@@ -2,30 +2,17 @@
 #![allow(unknown_lints)]
 
 use cargo_registry::{boot, App, Env};
-use std::{
-    borrow::Cow,
-    fs::File,
-    process::Command,
-    sync::{mpsc::channel, Arc, Mutex},
-    time::Duration,
-};
-
-use civet::Server as CivetServer;
+use std::{borrow::Cow, fs::File, process::Command, sync::Arc, time::Duration};
+
 use conduit_hyper::Service;
 use futures_util::future::FutureExt;
 use reqwest::blocking::Client;
 use sentry::{ClientOptions, IntoDsn};
+use tokio::io::AsyncWriteExt;
+use tokio::signal::unix::{signal, SignalKind};
 
 const CORE_THREADS: usize = 4;
 
-#[allow(clippy::large_enum_variant)]
-enum Server {
-    Civet(CivetServer),
-    Hyper(tokio::runtime::Runtime, tokio::task::JoinHandle<()>),
-}
-
-use Server::*;
-
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let _sentry = dotenv::var("SENTRY_DSN_API")
         .ok()
@@ -90,52 +77,41 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             }
         });
 
-    let server = if dotenv::var("WEB_USE_CIVET").is_err() {
-        use tokio::io::AsyncWriteExt;
-        use tokio::signal::unix::{signal, SignalKind};
-
-        println!("Booting with a hyper based server");
-
-        let rt = tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .worker_threads(CORE_THREADS)
-            .max_blocking_threads(threads as usize)
-            .build()
-            .unwrap();
-
-        let handler = Arc::new(conduit_hyper::BlockingHandler::new(handler));
-        let make_service =
-            hyper::service::make_service_fn(move |socket: &hyper::server::conn::AddrStream| {
-                let addr = socket.remote_addr();
-                let handler = handler.clone();
-                async move { Service::from_blocking(handler, addr) }
-            });
-
-        let addr = (ip, port).into();
-        #[allow(clippy::async_yields_async)]
-        let server = rt.block_on(async { hyper::Server::bind(&addr).serve(make_service) });
-
-        let mut sig_int = rt.block_on(async { signal(SignalKind::interrupt()) })?;
-        let mut sig_term = rt.block_on(async { signal(SignalKind::terminate()) })?;
-
-        let server = server.with_graceful_shutdown(async move {
-            // Wait for either signal
-            futures_util::select! {
-                _ = sig_int.recv().fuse() => {},
-                _ = sig_term.recv().fuse() => {},
-            };
-            let mut stdout = tokio::io::stdout();
-            stdout.write_all(b"Starting graceful shutdown\n").await.ok();
+    println!("Booting with a hyper based server");
+
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .worker_threads(CORE_THREADS)
+        .max_blocking_threads(threads as usize)
+        .build()
+        .unwrap();
+
+    let handler = Arc::new(conduit_hyper::BlockingHandler::new(handler));
+    let make_service =
+        hyper::service::make_service_fn(move |socket: &hyper::server::conn::AddrStream| {
+            let addr = socket.remote_addr();
+            let handler = handler.clone();
+            async move { Service::from_blocking(handler, addr) }
         });
 
-        let server = rt.spawn(async { server.await.unwrap() });
-        Hyper(rt, server)
-    } else {
-        println!("Booting with a civet based server");
-        let mut cfg = civet::Config::new();
-        cfg.port(port).threads(threads).keep_alive(true);
-        Civet(CivetServer::start(cfg, handler).unwrap())
-    };
+    let addr = (ip, port).into();
+    #[allow(clippy::async_yields_async)]
+    let server = rt.block_on(async { hyper::Server::bind(&addr).serve(make_service) });
+
+    let mut sig_int = rt.block_on(async { signal(SignalKind::interrupt()) })?;
+    let mut sig_term = rt.block_on(async { signal(SignalKind::terminate()) })?;
+
+    let server = server.with_graceful_shutdown(async move {
+        // Wait for either signal
+        futures_util::select! {
+            _ = sig_int.recv().fuse() => {},
+            _ = sig_term.recv().fuse() => {},
+        };
+        let mut stdout = tokio::io::stdout();
+        stdout.write_all(b"Starting graceful shutdown\n").await.ok();
+    });
+
+    let server = rt.spawn(async { server.await.unwrap() });
 
     println!("listening on port {}", port);
 
@@ -159,17 +135,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     // Block the main thread until the server has shutdown
-    match server {
-        Hyper(rt, server) => {
-            rt.block_on(async { server.await.unwrap() });
-        }
-        Civet(server) => {
-            let (tx, rx) = channel::<()>();
-            ctrlc_handler(move || tx.send(()).unwrap_or(()));
-            rx.recv().unwrap();
-            drop(server);
-        }
-    }
+    rt.block_on(async { server.await.unwrap() });
 
     println!("Persisting remaining downloads counters");
     if let Err(err) = app.downloads_counter.persist_all_shards(&app) {
@@ -180,23 +146,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
-fn ctrlc_handler<F>(f: F)
-where
-    F: FnOnce() + Send + 'static,
-{
-    let call_once = Mutex::new(Some(f));
-
-    ctrlc::set_handler(move || {
-        if let Some(f) = call_once.lock().unwrap().take() {
-            println!("Starting graceful shutdown");
-            f();
-        } else {
-            println!("Already sent signal to start graceful shutdown");
-        }
-    })
-    .unwrap();
-}
-
 fn downloads_counter_thread(app: Arc<App>) {
     let interval = Duration::from_millis(
         (app.config.downloads_persist_interval_ms / app.downloads_counter.shards_count()) as u64,