Exit gracefully if any servers exited, bump version to v1.7.0-alpha.12

Author: zonyitoo

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "shadowsocks-rust"
-version = "1.7.0-alpha.11"
+version = "1.7.0-alpha.12"
 authors = ["Y. T. CHUNG <zonyitoo@gmail.com>"]
 description = "shadowsocks is a fast tunnel proxy that helps you bypass firewalls."
 repository = "https://github.com/zonyitoo/shadowsocks-rust"

Cargo.toml

@@ -19,12 +19,12 @@ use clap::{App, Arg};
 use std::env;
 use std::io::{self, Write};
 use std::net::SocketAddr;
-use std::process;
 
 use env_logger::fmt::Formatter;
 use env_logger::Builder;
 use futures::Future;
 use log::{LevelFilter, Record};
+use tokio::runtime::Runtime;
 
 use shadowsocks::plugin::PluginConfig;
 use shadowsocks::{run_local, Config, ConfigType, ServerAddr, ServerConfig};
@@ -235,16 +235,11 @@ fn main() {
 
     debug!("Config: {:?}", config);
 
-    tokio::run(run_local(config).then(|res| -> Result<(), ()> {
-                                          match res {
-                                              Ok(..) => error!("Server exited without error"),
-                                              Err(err) => error!("Server exited with error: {}", err),
-                                          }
-
-                                          // Kill the whole process
-                                          // Otherwise the users on this crashed server won't be able to connect
-                                          // until manually restart the server.
-                                          // Just crash and restart.
-                                          process::exit(1);
-                                      }));
+    let mut runtime = Runtime::new().expect("Creating runtime");
+
+    let result = runtime.block_on(run_local(config));
+
+    runtime.shutdown_now().wait().unwrap();
+
+    panic!("Server exited unexpectly with result: {:?}", result);
 }

src/bin/local.rs

@@ -18,14 +18,14 @@ extern crate tokio;
 
 use std::env;
 use std::io::{self, Write};
-use std::process;
 
 use clap::{App, Arg};
 
 use env_logger::fmt::Formatter;
 use env_logger::Builder;
 use futures::Future;
 use log::{LevelFilter, Record};
+use tokio::runtime::Runtime;
 
 use shadowsocks::plugin::PluginConfig;
 use shadowsocks::{run_server, Config, ConfigType, ServerAddr, ServerConfig};
@@ -133,18 +133,16 @@ fn main() {
 
     let mut has_provided_config = false;
     let mut config = match matches.value_of("CONFIG") {
-        Some(cpath) => {
-            match Config::load_from_file(cpath, ConfigType::Server) {
-                Ok(cfg) => {
-                    has_provided_config = true;
-                    cfg
-                }
-                Err(err) => {
-                    error!("{:?}", err);
-                    return;
-                }
+        Some(cpath) => match Config::load_from_file(cpath, ConfigType::Server) {
+            Ok(cfg) => {
+                has_provided_config = true;
+                cfg
             }
-        }
+            Err(err) => {
+                error!("{:?}", err);
+                return;
+            }
+        },
         None => Config::new(),
     };
 
@@ -198,16 +196,11 @@ fn main() {
 
     debug!("Config: {:?}", config);
 
-    tokio::run(run_server(config).then(|res| -> Result<(), ()> {
-                                           match res {
-                                               Ok(..) => error!("Server exited without error"),
-                                               Err(err) => error!("Server exited with error: {}", err),
-                                           }
-
-                                           // Kill the whole process
-                                           // Otherwise the users on this crashed server won't be able to connect
-                                           // until manually restart the server.
-                                           // Just crash and restart.
-                                           process::exit(1);
-                                       }));
+    let mut runtime = Runtime::new().expect("Creating runtime");
+
+    let result = runtime.block_on(run_server(config));
+
+    runtime.shutdown_now().wait().unwrap();
+
+    panic!("Server exited unexpectly with result: {:?}", result);
 }

src/bin/server.rs

@@ -14,12 +14,12 @@ use clap::{App, Arg};
 use std::env;
 use std::io::{self, Write};
 use std::net::SocketAddr;
-use std::process;
 
 use env_logger::fmt::Formatter;
 use env_logger::Builder;
 use futures::Future;
 use log::{LevelFilter, Record};
+use tokio::runtime::Runtime;
 
 use shadowsocks::{run_dns, Config, ConfigType, ServerAddr, ServerConfig};
 
@@ -215,16 +215,11 @@ fn main() {
 
     debug!("Config: {:?}", config);
 
-    tokio::run(run_dns(config).then(|res| -> Result<(), ()> {
-                                        match res {
-                                            Ok(..) => error!("Server exited without error"),
-                                            Err(err) => error!("Server exited with error: {}", err),
-                                        }
-
-                                        // Kill the whole process
-                                        // Otherwise the users on this crashed server won't be able to connect
-                                        // until manually restart the server.
-                                        // Just crash and restart.
-                                        process::exit(1);
-                                    }));
+    let mut runtime = Runtime::new().expect("Creating runtime");
+
+    let result = runtime.block_on(run_dns(config));
+
+    runtime.shutdown_now().wait().unwrap();
+
+    panic!("Server exited unexpectly with result: {:?}", result);
 }