enhanced, renamed shutdown example and modified async_pg readme

Cargo.toml

@@ -27,7 +27,7 @@ members = [
    "redis-session",
    "run-in-thread",
    "rustls",
-   "self-shutdown-route",
+   "shutdown-server",
    "server-sent-events",
    "simple-auth-server",
    "state",

async_pg/Cargo.toml

@@ -3,6 +3,7 @@ name = "async_pg"
 version = "0.1.0"
 authors = ["dowwie <dkcdkg@gmail.com>"]
 edition = "2018"
+workspace = ".."
 
 [dependencies]
 actix-rt = "1.0.0"
@@ -12,6 +13,7 @@ deadpool-postgres = "0.5.0"
 derive_more = "0.99.2"
 dotenv = "0.15.0"
 serde = { version = "1.0.104", features = ["derive"] }
+tokio = { version = "0.2.11", features = ["signal"] }
 tokio-pg-mapper = "0.1.4"
 tokio-pg-mapper-derive = "0.1.4"
 tokio-postgres = "0.5.1"

async_pg/README.md

@@ -43,7 +43,7 @@
     ```ini
     SERVER_ADDR=127.0.0.1:8080
     PG.USER=test_user
-    PG.PASSWD=testing
+    PG.PASSWORD=testing
     PG.HOST=127.0.0.1
     PG.PORT=5432
     PG.DBNAME=testing_db

async_pg/src/main.rs

@@ -49,6 +49,7 @@ mod errors {
         fn error_response(&self) -> HttpResponse {
             match *self {
                 MyError::NotFound => HttpResponse::NotFound().finish(),
+                MyError::PoolError(ref err) => HttpResponse::InternalServerError().body(err.to_string()),
                 _ => HttpResponse::InternalServerError().finish(),
             }
         }
@@ -97,7 +98,7 @@ mod handlers {
 
         let client: Client =
             db_pool.get().await.map_err(|err| MyError::PoolError(err))?;
-
+    
         let new_user = db::add_user(&client, user_info).await?;
 
         Ok(HttpResponse::Ok().json(new_user))
@@ -108,6 +109,8 @@ use actix_web::{web, App, HttpServer};
 use dotenv::dotenv;
 use handlers::add_user;
 use tokio_postgres::NoTls;
+use tokio::signal::unix::{signal, SignalKind};
+
 
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
@@ -125,5 +128,15 @@ async fn main() -> std::io::Result<()> {
     .run();
     println!("Server running at http://{}/", config.server_addr);
 
+    let srv = server.clone();
+    let mut stream = signal(SignalKind::interrupt())?;	
+    actix_rt::spawn(async move {
+        loop {
+            stream.recv().await;
+            println!("\nSIGINT Received.  Stopping server.\n");
+            srv.stop(true).await;
+        }
+	});
+
     server.await
 }

shutdown-server/Cargo.toml

@@ -1,12 +1,13 @@
 [package]
-name = "self-shutdown-route"
+name = "shutdown-server"
 version = "2.0.0"
 authors = ["Rob Ede <robjtede@icloud.com>"]
 edition = "2018"
 description = "Send a request to the server to shut it down"
 
 [dependencies]
-actix-web = "2.0.0"
 actix-rt = "1.0.0"
+actix-web = "2.0.0"
 env_logger = "0.7"
 futures = "0.3"
+tokio = { version = "0.2.11", features = ["signal"] }

shutdown-server/README.md

@@ -1,16 +1,19 @@
-# self-shutdown-route
+# shutdown-server
 
-> Demonstrates how to shutdown the web server using a route hosted by the server itself using channels.
+Demonstrates how to shutdown the web server in a couple of ways:
+
+1. remotely, via http request
+	- Created in response to actix/actix-web#1315
+
+2. sending a SIGINT signal to the server (control-c)
 
-This technique can be easily modified to support shutting down the server using other kinds of external events.
-Created in response to actix/actix-web#1315. 
 
 ## Usage
 
 ### Running The Server
 
 ```bash
-cargo run --bin self-shutdown-route
+cargo run --bin shutdown-server
 
 # Starting 8 workers
 # Starting "actix-web-service-127.0.0.1:8080" service on 127.0.0.1:8080

shutdown-server/src/main.rs

@@ -1,8 +1,8 @@
 use std::{sync::mpsc, thread};
-
-use futures::executor;
-
 use actix_web::{get, middleware, post, web, App, HttpResponse, HttpServer};
+use futures::executor;
+use tokio::signal::unix::{signal, SignalKind};
+
 
 #[get("/hello")]
 async fn hello() -> &'static str {
@@ -24,6 +24,7 @@ async fn main() -> std::io::Result<()> {
 
     // create a channel
     let (tx, rx) = mpsc::channel::<()>();
+    let stopper = tx.clone();
 
     let bind = "127.0.0.1:8080";
 
@@ -51,6 +52,15 @@ async fn main() -> std::io::Result<()> {
         executor::block_on(srv.stop(true))
     });
 
+    let mut stream = signal(SignalKind::interrupt())?;
+    actix_rt::spawn(async move {
+        loop {
+            stream.recv().await;
+            println!("\n*** SIGINT received. Stopping server, gracefully. ***\n");
+            stopper.send(()).unwrap();
+        }
+	});
+
     // run server
     server.await
 }