Merge #393

393: Remove config file handling r=koivunej a=koivunej

This PR wipes out the config handling from `ipfs`, IpfsOptions::new, and UninitializedIpfs::default.

Co-authored-by: Joonas Koivunen <joonas@equilibrium.co>

Author: bors[bot]

src/config.rs

@@ -1,225 +1,4 @@
-use libp2p::identity::Keypair;
-use libp2p::multiaddr::Protocol;
-use libp2p::{Multiaddr, PeerId};
-use rand::{rngs::OsRng, Rng};
-use serde::{Deserialize, Serialize};
-use std::fs;
-use std::path::Path;
-use thiserror::Error;
+//! Static configuration (the bootstrap node(s)).
 
 pub const BOOTSTRAP_NODES: &[&str] =
     &["/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ"];
-
-/// See test cases for examples how to write such file.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ConfigFile {
-    #[serde(flatten)]
-    key: KeyMaterial,
-    bootstrap: Vec<Multiaddr>,
-}
-
-/// KeyMaterial is an additional abstraction as the identity::Keypair does not support Clone or
-/// Debug nor is there a clearcut way to serialize and deserialize such yet at least.
-#[derive(Clone, Serialize, Deserialize)]
-#[serde(untagged)]
-enum KeyMaterial {
-    Ed25519 {
-        private_key: [u8; 32],
-        #[serde(skip)]
-        keypair: Option<Box<libp2p::identity::ed25519::Keypair>>,
-    },
-    RsaPkcs8File {
-        #[serde(rename = "rsa_pkcs8_filename")]
-        filename: String,
-        #[serde(skip)]
-        keypair: Option<Box<libp2p::identity::rsa::Keypair>>,
-    },
-}
-
-use std::fmt;
-
-impl fmt::Debug for KeyMaterial {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            KeyMaterial::Ed25519 { ref keypair, .. } => {
-                if let Some(kp) = keypair.as_ref() {
-                    write!(fmt, "{:?}", kp)
-                } else {
-                    write!(fmt, "Ed25519(not loaded)")
-                }
-            }
-            KeyMaterial::RsaPkcs8File {
-                ref keypair,
-                ref filename,
-            } => {
-                if let Some(kp) = keypair.as_ref() {
-                    write!(fmt, "{:?}", kp.public())
-                } else {
-                    write!(fmt, "Rsa(not loaded: {:?})", filename)
-                }
-            }
-        }
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum KeyMaterialLoadingFailure {
-    #[error("{0}")]
-    Io(#[from] std::io::Error),
-    #[error("{0}")]
-    RsaDecoding(#[from] libp2p::identity::error::DecodingError),
-    #[error("{0}")]
-    Config(#[from] serde_json::error::Error),
-}
-
-impl KeyMaterial {
-    fn clone_keypair(&self) -> Keypair {
-        match *self {
-            KeyMaterial::Ed25519 { ref keypair, .. } => keypair
-                .as_ref()
-                .map(|kp| Keypair::Ed25519(kp.as_ref().clone())),
-            KeyMaterial::RsaPkcs8File { ref keypair, .. } => {
-                keypair.as_ref().map(|kp| Keypair::Rsa(kp.as_ref().clone()))
-            }
-        }
-        .expect("KeyMaterial needs to be loaded before accessing the keypair")
-    }
-
-    fn load(&mut self) -> Result<(), KeyMaterialLoadingFailure> {
-        match *self {
-            KeyMaterial::Ed25519 {
-                ref private_key,
-                ref mut keypair,
-            } if keypair.is_none() => {
-                let mut cloned = *private_key;
-                let sk = libp2p::identity::ed25519::SecretKey::from_bytes(&mut cloned)
-                    .expect("Failed to extract ed25519::SecretKey");
-
-                let kp = libp2p::identity::ed25519::Keypair::from(sk);
-
-                *keypair = Some(Box::new(kp));
-            }
-            KeyMaterial::RsaPkcs8File {
-                ref filename,
-                ref mut keypair,
-            } if keypair.is_none() => {
-                let mut bytes = std::fs::read(filename).map_err(KeyMaterialLoadingFailure::Io)?;
-                let kp = libp2p::identity::rsa::Keypair::from_pkcs8(&mut bytes)
-                    .map_err(KeyMaterialLoadingFailure::RsaDecoding)?;
-                *keypair = Some(Box::new(kp));
-            }
-            _ => { /* all set */ }
-        }
-
-        Ok(())
-    }
-
-    fn into_loaded(mut self) -> Result<Self, KeyMaterialLoadingFailure> {
-        self.load()?;
-        Ok(self)
-    }
-}
-
-impl ConfigFile {
-    pub fn new<P: AsRef<Path>>(path: P) -> Result<Self, KeyMaterialLoadingFailure> {
-        if path.as_ref().exists() {
-            let content = fs::read_to_string(&path)?;
-            let config = Self::parse(&content)?;
-            config.into_loaded()
-        } else {
-            let config = ConfigFile::default();
-            config.store_at(path)?;
-            config.into_loaded()
-        }
-    }
-
-    fn load(&mut self) -> Result<(), KeyMaterialLoadingFailure> {
-        self.key.load()
-    }
-
-    fn into_loaded(mut self) -> Result<Self, KeyMaterialLoadingFailure> {
-        self.load()?;
-        Ok(self)
-    }
-
-    fn parse(s: &str) -> Result<Self, KeyMaterialLoadingFailure> {
-        Ok(serde_json::from_str(s)?)
-    }
-
-    pub fn store_at<P: AsRef<Path>>(&self, path: P) -> std::io::Result<()> {
-        fs::create_dir_all(path.as_ref().parent().unwrap())?;
-        let string = serde_json::to_string_pretty(self).unwrap();
-        fs::write(path, string)
-    }
-
-    pub fn identity_key_pair(&self) -> Keypair {
-        self.key.clone_keypair()
-    }
-
-    pub fn bootstrap(&self) -> Vec<(Multiaddr, PeerId)> {
-        let mut bootstrap = Vec::new();
-        for addr in &self.bootstrap {
-            let mut addr = addr.to_owned();
-            let peer_id = match addr.pop() {
-                Some(Protocol::P2p(hash)) => PeerId::from_multihash(hash).unwrap(),
-                _ => panic!("No peer id for addr"),
-            };
-            bootstrap.push((addr, peer_id));
-        }
-        bootstrap
-    }
-}
-
-impl Default for ConfigFile {
-    fn default() -> Self {
-        // the ed25519 has no chance of working with go-ipfs as of now because of
-        // https://github.com/libp2p/specs/issues/138 and
-        // https://github.com/libp2p/go-libp2p-core/blob/dc718fa4dab1866476fd9f379718fdd619455a4f/peer/peer.go#L23-L34
-        //
-        // and on the other hand:
-        // https://github.com/libp2p/rust-libp2p/blob/eb7b7bd919b93e6acf00847c19d1a76c09016120/core/src/peer_id.rs#L62-L74
-        let private_key: [u8; 32] = OsRng.gen();
-
-        let bootstrap = BOOTSTRAP_NODES
-            .iter()
-            .map(|node| node.parse().unwrap())
-            .collect();
-        ConfigFile {
-            key: KeyMaterial::Ed25519 {
-                private_key,
-                keypair: None,
-            }
-            .into_loaded()
-            .unwrap(),
-            bootstrap,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use super::ConfigFile;
-
-    #[test]
-    fn supports_older_v1_and_ed25519_v2() {
-        let input = r#"{"private_key":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"bootstrap":[]}"#;
-
-        let actual = ConfigFile::parse(input).unwrap();
-
-        let roundtrip = serde_json::to_string(&actual).unwrap();
-
-        assert_eq!(input, roundtrip);
-    }
-
-    #[test]
-    fn supports_v2() {
-        let input = r#"{"rsa_pkcs8_filename":"foobar.pk8","bootstrap":[]}"#;
-
-        let actual = ConfigFile::parse(input).unwrap();
-
-        let roundtrip = serde_json::to_string(&actual).unwrap();
-
-        assert_eq!(input, roundtrip);
-    }
-}

src/lib.rs

@@ -208,79 +208,6 @@ impl<I: Borrow<Keypair>> DebuggableKeypair<I> {
     }
 }
 
-impl IpfsOptions {
-    pub fn new(
-        ipfs_path: PathBuf,
-        keypair: Keypair,
-        bootstrap: Vec<(Multiaddr, PeerId)>,
-        mdns: bool,
-        kad_protocol: Option<String>,
-        listening_addrs: Vec<Multiaddr>,
-        span: Option<Span>,
-    ) -> Self {
-        Self {
-            ipfs_path,
-            keypair,
-            bootstrap,
-            mdns,
-            kad_protocol,
-            listening_addrs,
-            span,
-        }
-    }
-}
-
-impl Default for IpfsOptions {
-    /// Create `IpfsOptions` from environment.
-    ///
-    /// # Panics
-    ///
-    /// Can panic if two threads call this method at the same time due to race condition on
-    /// creating a configuration file under `IPFS_PATH` and other thread failing to read the just
-    /// created empty file. Because of this, the implementation has been disabled in tests.
-    fn default() -> Self {
-        use self::config::ConfigFile;
-
-        if cfg!(test) {
-            // making this implementation conditional on `not(test)` results in multiple dead_code
-            // lints on config.rs but for rustc 1.42.0 at least having this `cfg!(test)` branch
-            // does not result in the same.
-            panic!(
-                "This implementation must not be invoked when testing as it cannot be safely
-                used from multiple threads"
-            );
-        }
-
-        let ipfs_path = if let Ok(path) = env::var("IPFS_PATH") {
-            PathBuf::from(path)
-        } else {
-            let root = if let Some(home) = dirs::home_dir() {
-                home
-            } else {
-                env::current_dir().unwrap()
-            };
-            root.join(".rust-ipfs")
-        };
-        let config_path = dirs::config_dir()
-            .unwrap()
-            .join("rust-ipfs")
-            .join("config.json");
-        let config = ConfigFile::new(config_path).unwrap();
-        let keypair = config.identity_key_pair();
-        let bootstrap = config.bootstrap();
-
-        IpfsOptions {
-            ipfs_path,
-            keypair,
-            bootstrap,
-            mdns: true,
-            kad_protocol: None,
-            listening_addrs: Vec::new(),
-            span: None,
-        }
-    }
-}
-
 /// The facade for the Ipfs node.
 ///
 /// The facade has most of the functionality either directly as a method or the functionality can
@@ -395,10 +322,6 @@ impl<Types: IpfsTypes> UninitializedIpfs<Types> {
         }
     }
 
-    pub fn default() -> Self {
-        Self::new(IpfsOptions::default())
-    }
-
     /// Initialize the ipfs node. The returned `Ipfs` value is cloneable, send and sync, and the
     /// future should be spawned on a executor as soon as possible.
     pub async fn start(self) -> Result<(Ipfs<Types>, impl Future<Output = ()>), Error> {
@@ -1822,10 +1745,4 @@ mod tests {
         ipfs.remove_pin(&cid, false).await.unwrap();
         assert!(!ipfs.is_pinned(&cid).await.unwrap());
     }
-
-    #[test]
-    #[should_panic]
-    fn default_ipfs_options_disabled_when_testing() {
-        IpfsOptions::default();
-    }
 }