fix(http): create Profile abstraction to allow port choice

Author: niklaslong

http/src/config.rs

@@ -3,8 +3,11 @@
 use parity_multiaddr::Multiaddr;
 use serde::{Deserialize, Serialize};
 use std::fs::{self, File};
+use std::net::SocketAddr;
 use std::num::NonZeroU16;
 use std::path::Path;
+use std::str::FromStr;
+use structopt::StructOpt;
 use thiserror::Error;
 
 /// Temporary module required to de/ser config files base64'd protobuf rsa private key format.
@@ -13,6 +16,24 @@ mod keys_proto {
     include!(concat!(env!("OUT_DIR"), "/keys_proto.rs"));
 }
 
+#[derive(Debug, StructOpt)]
+pub enum Profile {
+    Test,
+    Default,
+}
+
+impl FromStr for Profile {
+    type Err = InitializationError;
+
+    fn from_str(profile: &str) -> Result<Self, Self::Err> {
+        match profile {
+            "test" => Ok(Profile::Test),
+            "default" => Ok(Profile::Default),
+            _ => Err(InitializationError::InvalidProfile(profile.to_string())),
+        }
+    }
+}
+
 /// The way things can go wrong when calling [`initialize`].
 #[derive(Error, Debug)]
 pub enum InitializationError {
@@ -23,7 +44,7 @@ pub enum InitializationError {
     #[error("invalid RSA key length given: {0}")]
     InvalidRsaKeyLength(u16),
     #[error("unsupported profiles selected: {0:?}")]
-    InvalidProfiles(Vec<String>),
+    InvalidProfile(String),
     #[error("key generation failed: {0}")]
     KeyGeneration(Box<dyn std::error::Error + 'static>),
     #[error("key encoding failed: {0}")]
@@ -37,7 +58,7 @@ pub enum InitializationError {
 pub fn initialize(
     ipfs_path: &Path,
     bits: NonZeroU16,
-    profiles: Vec<String>,
+    profile: Profile,
 ) -> Result<(), InitializationError> {
     let config_path = ipfs_path.join("config");
 
@@ -46,14 +67,10 @@ pub fn initialize(
         .and_then(|_| {
             fs::File::create(&config_path).map_err(InitializationError::ConfigCreationFailed)
         })
-        .and_then(|config_file| create(config_file, bits, profiles))
+        .and_then(|config_file| create(config_file, bits, profile))
 }
 
-fn create(
-    config: File,
-    bits: NonZeroU16,
-    profiles: Vec<String>,
-) -> Result<(), InitializationError> {
+fn create(config: File, bits: NonZeroU16, profile: Profile) -> Result<(), InitializationError> {
     use multibase::Base::Base64Pad;
     use prost::Message;
     use std::io::BufWriter;
@@ -65,13 +82,18 @@ fn create(
         return Err(InitializationError::InvalidRsaKeyLength(bits));
     }
 
-    if profiles.len() != 1 || profiles[0] != "test" {
-        // profiles are expected to be (comma separated) "test" as there are no bootstrap peer
-        // handling yet. the conformance test cases seem to init `go-ipfs` in this profile where
-        // it does not have any bootstrap nodes, and multi node tests later call swarm apis to
-        // dial the nodes together.
-        return Err(InitializationError::InvalidProfiles(profiles));
-    }
+    // if profiles.len() != 1 || profiles[0] != "test" || profiles[0] != "default" {
+    //     // profiles are expected to be (comma separated) "test" as there are no bootstrap peer
+    //     // handling yet. the conformance test cases seem to init `go-ipfs` in this profile where
+    //     // it does not have any bootstrap nodes, and multi node tests later call swarm apis to
+    //     // dial the nodes together.
+    //     return Err(InitializationError::InvalidProfile(profiles));
+    // }
+
+    let api_addrs = match profile {
+        Profile::Test => "127.0.0.1:0",
+        Profile::Default => "127.0.0.1:4004",
+    };
 
     let pk = openssl::rsa::Rsa::generate(bits as u32)
         .map_err(|e| InitializationError::KeyGeneration(Box::new(e)))?;
@@ -118,6 +140,7 @@ fn create(
         },
         addresses: Addresses {
             swarm: vec!["/ip4/127.0.0.1/tcp/0".parse().unwrap()],
+            api: api_addrs.parse().unwrap(),
         },
     };
 
@@ -147,7 +170,7 @@ pub enum LoadingError {
 /// Returns only the keypair and listening addresses or [`LoadingError`] but this should be
 /// extended to contain the bootstrap nodes at least later when we need to support those for
 /// testing purposes.
-pub fn load(config: File) -> Result<(ipfs::Keypair, Vec<Multiaddr>), LoadingError> {
+pub fn load(config: File) -> Result<(ipfs::Keypair, Vec<Multiaddr>, SocketAddr), LoadingError> {
     use std::io::BufReader;
 
     let CompatibleConfigFile {
@@ -167,7 +190,7 @@ pub fn load(config: File) -> Result<(ipfs::Keypair, Vec<Multiaddr>), LoadingErro
         });
     }
 
-    Ok((kp, addresses.swarm))
+    Ok((kp, addresses.swarm, addresses.api))
 }
 
 /// Converts a PEM format to DER where PEM is a container for Base64 data with padding, starting on
@@ -245,6 +268,7 @@ struct CompatibleConfigFile {
 #[serde(rename_all = "PascalCase")]
 struct Addresses {
     swarm: Vec<Multiaddr>,
+    api: SocketAddr,
 }
 
 #[derive(Debug, Serialize, Deserialize)]

http/src/main.rs

@@ -17,8 +17,8 @@ enum Options {
         #[structopt(long)]
         bits: NonZeroU16,
         /// List of configuration profiles to apply
-        #[structopt(long, use_delimiter = true)]
-        profile: Vec<String>,
+        #[structopt(long)]
+        profile: config::Profile,
     },
     /// Start the IPFS node in the foreground (not detaching from parent process).
     Daemon,
@@ -59,7 +59,7 @@ fn main() {
 
     let config_path = home.join("config");
 
-    let (keypair, listening_addrs) = match opts {
+    let (keypair, listening_addrs, api_listening_addrs) = match opts {
         Options::Init { bits, profile } => {
             println!("initializing IPFS node at {:?}", home);
 
@@ -73,7 +73,7 @@ fn main() {
 
             match result {
                 Ok(_) => {
-                    let (kp, _) = std::fs::File::open(config_path)
+                    let (kp, _, _) = std::fs::File::open(config_path)
                         .map_err(config::LoadingError::ConfigurationFileOpening)
                         .and_then(config::load)
                         .unwrap();
@@ -101,8 +101,8 @@ fn main() {
                     eprintln!("This is a fake version of ipfs cli which does not support much");
                     std::process::exit(1);
                 }
-                Err(config::InitializationError::InvalidProfiles(profiles)) => {
-                    eprintln!("Error: unsupported profile selection: {:?}", profiles);
+                Err(config::InitializationError::InvalidProfile(profile)) => {
+                    eprintln!("Error: unsupported profile selection: {:?}", profile);
                     eprintln!("This is a fake version of ipfs cli which does not support much");
                     std::process::exit(1);
                 }
@@ -153,7 +153,13 @@ fn main() {
         tokio::spawn(task);
 
         let api_link_file = home.join("api");
-        let (addr, server) = serve(&ipfs);
+
+        // If the port is specified, use that to start the server, if it isn't use ephemeral ports,
+        // i.e.:
+        //
+        // port => port
+        // none => 0
+        let (addr, server) = serve(&ipfs, api_listening_addrs);
 
         // shutdown future will handle signalling the exit
         drop(ipfs);
@@ -185,6 +191,7 @@ fn main() {
 
 fn serve<Types: IpfsTypes>(
     ipfs: &Ipfs<Types>,
+    listening_addrs: std::net::SocketAddr,
 ) -> (std::net::SocketAddr, impl std::future::Future<Output = ()>) {
     use tokio::stream::StreamExt;
     use warp::Filter;
@@ -195,7 +202,9 @@ fn serve<Types: IpfsTypes>(
 
     let ipfs = ipfs.clone();
 
-    warp::serve(routes).bind_with_graceful_shutdown(([127, 0, 0, 1], 0), async move {
+    println!("SOCKET_ADDR: {:?}", listening_addrs);
+
+    warp::serve(routes).bind_with_graceful_shutdown(listening_addrs, async move {
         shutdown_rx.next().await;
         info!("Shutdown trigger received; starting shutdown");
         ipfs.exit_daemon().await;