feat: dfx start now starts an http server frontend

Hans Larsen · Hans Larsen · commit 8c44b174255d · 2019-09-26T17:05:30.000-07:00
It will respect address and port from the config (which it did not
previously), and will proxy calls to /api/ to the port 8080 locally
which is always reserved by the client.

Also added tests for (some parts of) the config.

Also now waits and blocks the process. When the user Ctrl-C or kill
dfx it will kill the nodemanager and the http server.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/dfx/Cargo.toml b/dfx/Cargo.toml
@@ -14,7 +14,9 @@ tar = "0.4.26"
 flate2 = "1.0.11"
 
 [dependencies]
+actix = "0.8.3"
 actix-web = "1.0.8"
+actix-files = "0.1.4"
 clap = "2.33.0"
 console = "0.7.7"
 flate2 = "1.0.11"
diff --git a/dfx/assets/new_project_files/dfinity.json b/dfx/assets/new_project_files/dfinity.json
@@ -12,8 +12,9 @@
       "output": "build/"
     },
     "start": {
-      "port": 8080,
-      "address": "127.0.0.1"
+      "port": 8000,
+      "address": "127.0.0.1",
+      "serve_root": "app/"
     }
   }
 }
diff --git a/dfx/src/commands/start.rs b/dfx/src/commands/start.rs
@@ -1,5 +1,5 @@
 use crate::lib::api_client::{ping, Client, ClientConfig};
-use crate::lib::env::BinaryResolverEnv;
+use crate::lib::env::{BinaryResolverEnv, ProjectConfigEnv};
 use crate::lib::error::{DfxError, DfxResult};
 use crate::lib::webserver::webserver;
 use clap::{App, Arg, ArgMatches, SubCommand};
@@ -9,21 +9,22 @@ use tokio::prelude::FutureExt;
 use tokio::runtime::Runtime;
 
 const TIMEOUT_IN_SECS: u64 = 5;
+const IC_CLIENT_BIND_ADDR: &str = "http://localhost:8080/api";
 
 pub fn construct() -> App<'static, 'static> {
     SubCommand::with_name("start")
         .about("Start a local network in the background.")
         .arg(
             Arg::with_name("host")
-                .help("The host (with port) to send the query to.")
+                .help("The host (with port) to bind the frontend to.")
                 .long("host")
                 .takes_value(true),
         )
 }
 
 pub fn exec<T>(env: &T, args: &ArgMatches<'_>) -> DfxResult
 where
-    T: BinaryResolverEnv,
+    T: ProjectConfigEnv + BinaryResolverEnv,
 {
     let b = ProgressBar::new_spinner();
     b.set_draw_target(ProgressDrawTarget::stderr());
@@ -33,6 +34,22 @@ where
 
     let client_pathbuf = env.get_binary_command_path("client").unwrap();
     let nodemanager_pathbuf = env.get_binary_command_path("nodemanager").unwrap();
+
+    let config = env.get_config().unwrap();
+    let address_and_port = args
+        .value_of("host")
+        .and_then(|host| Option::from(host.parse()))
+        .unwrap_or_else(|| {
+            Ok(config
+                .get_config()
+                .get_defaults()
+                .get_start()
+                .get_binding_socket_addr("localhost:8000")
+                .unwrap())
+        })?;
+    let frontend_url = format!("{}:{}", address_and_port.ip(), address_and_port.port());
+    let project_root = config.get_path().parent().unwrap();
+
     let client_watchdog = std::thread::spawn(move || {
         let client = client_pathbuf.as_path();
         let nodemanager = nodemanager_pathbuf.as_path();
@@ -44,26 +61,39 @@ where
 
             // If the nodemanager itself fails, we are probably deeper into troubles than
             // we can solve at this point and the user is better rerunning the server.
-            cmd.output().unwrap();
+            let mut child = cmd.spawn().unwrap();
+            if child.wait().is_err() {
+                break;
+            }
         }
     });
     let frontend_watchdog = webserver(
-        "localhost:8000",
-        url::Url::parse("http://localhost:8080/api"),
+        address_and_port,
+        url::Url::parse(IC_CLIENT_BIND_ADDR).unwrap(),
+        project_root
+            .join(
+                config
+                    .get_config()
+                    .get_defaults()
+                    .get_start()
+                    .get_serve_root(".")
+                    .as_path(),
+            )
+            .as_path(),
     );
 
     b.set_message("Pinging the DFINITY client...");
 
     std::thread::sleep(Duration::from_millis(500));
 
-    let url = String::from(args.value_of("host").unwrap_or("http://localhost:8080"));
-
     let mut runtime = Runtime::new().expect("Unable to create a runtime");
 
     // Try to ping for 1 second, then timeout after 5 seconds if ping hasn't succeeded.
     let start = Instant::now();
     while {
-        let client = Client::new(ClientConfig { url: url.clone() });
+        let client = Client::new(ClientConfig {
+            url: frontend_url.clone(),
+        });
 
         runtime
             .block_on(ping(client).timeout(Duration::from_millis(TIMEOUT_IN_SECS * 1000 / 4)))
diff --git a/dfx/src/config/dfinity.rs b/dfx/src/config/dfinity.rs
@@ -3,6 +3,7 @@
 use crate::lib::error::DfxResult;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
+use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::{Path, PathBuf};
 
 pub const CONFIG_FILE_NAME: &str = "dfinity.json";
@@ -15,6 +16,7 @@ const EMPTY_CONFIG_DEFAULTS_START: ConfigDefaultsStart = ConfigDefaultsStart {
     address: None,
     port: None,
     nodes: None,
+    serve_root: None,
 };
 const EMPTY_CONFIG_DEFAULTS_BUILD: ConfigDefaultsBuild = ConfigDefaultsBuild { output: None };
 
@@ -28,6 +30,7 @@ pub struct ConfigDefaultsStart {
     pub address: Option<String>,
     pub nodes: Option<u64>,
     pub port: Option<u16>,
+    pub serve_root: Option<String>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -61,6 +64,28 @@ impl ConfigDefaultsStart {
             .to_owned()
             .unwrap_or_else(|| default.to_string())
     }
+    pub fn get_binding_socket_addr(&self, default: &str) -> Option<SocketAddr> {
+        default
+            .to_socket_addrs()
+            .ok()
+            .and_then(|mut x| x.next())
+            .and_then(|default_addr| {
+                let addr = self.get_address(default_addr.ip().to_string().as_str());
+                let port = self.get_port(default_addr.port());
+
+                format!("{}:{}", addr, port)
+                    .to_socket_addrs()
+                    .ok()
+                    .and_then(|mut x| x.next())
+            })
+    }
+    pub fn get_serve_root(&self, default: &str) -> PathBuf {
+        PathBuf::from(
+            self.serve_root
+                .to_owned()
+                .unwrap_or_else(|| default.to_string()),
+        )
+    }
     pub fn get_nodes(&self, default: u64) -> u64 {
         self.nodes.unwrap_or(default)
     }
@@ -136,16 +161,25 @@ impl Config {
         ))
     }
 
-    pub fn load_from(working_dir: &PathBuf) -> std::io::Result<Config> {
+    pub fn from_file(working_dir: &PathBuf) -> std::io::Result<Config> {
         let path = Config::resolve_config_path(working_dir)?;
         let content = std::fs::read(&path)?;
+        Config::from_slice(path, &content)
+    }
+
+    pub fn from_current_dir() -> std::io::Result<Config> {
+        Config::from_file(&std::env::current_dir()?)
+    }
+
+    fn from_slice(path: PathBuf, content: &[u8]) -> std::io::Result<Config> {
         let config = serde_json::from_slice(&content)?;
         let json = serde_json::from_slice(&content)?;
         Ok(Config { path, json, config })
     }
 
-    pub fn from_current_dir() -> std::io::Result<Config> {
-        Config::load_from(&std::env::current_dir()?)
+    /// Create a configuration from a string.
+    pub fn from_str(content: &str) -> std::io::Result<Config> {
+        Config::from_slice(PathBuf::from("-"), content.as_bytes())
     }
 
     pub fn get_path(&self) -> &PathBuf {
@@ -218,4 +252,77 @@ mod tests {
             Config::resolve_config_path(subdir_path.as_path()).unwrap(),
         );
     }
+
+    #[test]
+    fn config_defaults_start_addr() {
+        let config = Config::from_str(
+            r#"{
+            "defaults": {
+                "start": {
+                    "address": "localhost",
+                    "port": 8000
+                }
+            }
+        }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            config
+                .get_config()
+                .get_defaults()
+                .get_start()
+                .get_binding_socket_addr("1.2.3.4:123")
+                .unwrap(),
+            "localhost:8000".to_socket_addrs().unwrap().next().unwrap()
+        );
+    }
+
+    #[test]
+    fn config_defaults_start_addr_no_address() {
+        let config = Config::from_str(
+            r#"{
+            "defaults": {
+                "start": {
+                    "port": 8000
+                }
+            }
+        }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            config
+                .get_config()
+                .get_defaults()
+                .get_start()
+                .get_binding_socket_addr("1.2.3.4:123")
+                .unwrap(),
+            "1.2.3.4:8000".to_socket_addrs().unwrap().next().unwrap()
+        );
+    }
+
+    #[test]
+    fn config_defaults_start_addr_no_port() {
+        let config = Config::from_str(
+            r#"{
+            "defaults": {
+                "start": {
+                    "address": "localhost"
+                }
+            }
+        }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            config
+                .get_config()
+                .get_defaults()
+                .get_start()
+                .get_binding_socket_addr("1.2.3.4:123")
+                .unwrap(),
+            "localhost:123".to_socket_addrs().unwrap().next().unwrap()
+        );
+    }
 }
diff --git a/dfx/src/lib/error.rs b/dfx/src/lib/error.rs
@@ -17,6 +17,7 @@ pub enum DfxError {
     SerdeJson(serde_json::error::Error),
     Url(reqwest::UrlError),
     WabtError(wabt::Error),
+    AddrParseError(std::net::AddrParseError),
 
     /// An unknown command was used. The argument is the command itself.
     UnknownCommand(String),
@@ -78,3 +79,9 @@ impl From<wabt::Error> for DfxError {
         DfxError::WabtError(err)
     }
 }
+
+impl From<std::net::AddrParseError> for DfxError {
+    fn from(err: std::net::AddrParseError) -> DfxError {
+        DfxError::AddrParseError(err)
+    }
+}
diff --git a/dfx/src/lib/webserver.rs b/dfx/src/lib/webserver.rs
@@ -1,8 +1,8 @@
 use actix_web::client::Client;
 use actix_web::{middleware, web, App, Error, HttpRequest, HttpResponse, HttpServer};
-use clap::{value_t, Arg};
 use futures::Future;
-use std::net::ToSocketAddrs;
+use std::net::SocketAddr;
+use std::path::{Path, PathBuf};
 use url::Url;
 
 fn forward(
@@ -40,21 +40,35 @@ fn forward(
         })
 }
 
-pub fn webserver(bind: &str, client_api_uri: url::Url, serve_dir: Path) -> std::io::Result<()> {
-    let listen_addr = matches.value_of("listen_addr").unwrap();
-    let listen_port = value_t!(matches, "listen_port", u16).unwrap_or_else(|e| e.exit());
-
-    let forwarded_addr = matches.value_of("forward_addr").unwrap();
-    let forwarded_port = value_t!(matches, "forward_port", u16).unwrap_or_else(|e| e.exit());
+/// Run the webserver in the current thread.
+fn run_webserver(
+    bind: SocketAddr,
+    client_api_uri: url::Url,
+    serve_dir: PathBuf,
+) -> Result<(), std::io::Error> {
+    eprintln!("binding to: {:?}", bind);
+    eprintln!("client: {:?}", client_api_uri);
 
     HttpServer::new(move || {
         App::new()
             .data(Client::new())
             .data(client_api_uri.clone())
             .wrap(middleware::Logger::default())
-            .default_service(web::route().to_async(forward))
+            .service(web::scope(client_api_uri.path()).default_service(web::to_async(forward)))
+            .default_service(actix_files::Files::new("/", &serve_dir).index_file("index.html"))
     })
-    .bind((listen_addr, listen_port))?
+    .bind(bind)?
     .system_exit()
-    .run()
+    .start();
+
+    Ok(())
+}
+
+pub fn webserver(
+    bind: SocketAddr,
+    client_api_uri: url::Url,
+    serve_dir: &Path,
+) -> std::thread::JoinHandle<()> {
+    let serve_dir = PathBuf::from(serve_dir);
+    std::thread::spawn(move || run_webserver(bind, client_api_uri, serve_dir).unwrap())
 }

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,9 @@`
`12`	`12`	`"output": "build/"`
`13`	`13`	`},`
`14`	`14`	`"start": {`
`15`		`- "port": 8080,`
`16`		`- "address": "127.0.0.1"`
	`15`	`+ "port": 8000,`
	`16`	`+ "address": "127.0.0.1",`
	`17`	`+ "serve_root": "app/"`
`17`	`18`	`}`
`18`	`19`	`}`
`19`	`20`	`}`