Tidy up p2p code somewhat

src/main.rs

@@ -10,14 +10,11 @@ pub mod pubkeystore;
 pub mod state;
 pub mod utils;
 
-use p2p::keys;
-use p2p::floodsub;
 use slog::Drain;
 use clap::{ App, SubCommand};
-use std::sync::Arc;
+use p2p::config::NetworkConfig;
-use std::time::Duration;
+use p2p::floodsub;
-use libp2p_peerstore::{ PeerAccess, Peerstore };
+use p2p::state::NetworkState;
-use libp2p_peerstore::memory_peerstore::MemoryPeerstore;
 
 fn main() {
     let decorator = slog_term::TermDecorator::new().build();
@@ -33,22 +30,12 @@ fn main() {
             .about("Generates a new set of random keys for p2p dev.")
         .get_matches();
 
+    let config = NetworkConfig::default();
     if let Some(_) = matches.subcommand_matches("generate-keys") {
-        keys::generate_keys(&log).expect("Failed to generate keys");
+        // keys::generate_keys(&log).expect("Failed to generate keys");
     } else {
-        let (s256k1_public, _s256k1_secret) = keys::load_local_keys(&log);
+        let state = NetworkState::new(&config).expect("setup failed");
-        let peer_id = keys::peer_id_from_pub_key(&s256k1_public);
+        floodsub::listen(state, &log);
-        let bootstrap_peer_id = 
-            keys::peer_id_from_pub_key(&keys::load_bootstrap_pk(&log));
-        
-       let peer_store = Arc::new(MemoryPeerstore::empty());
-
-       peer_store.peer_or_create(&bootstrap_peer_id).add_addr(
-           "/ip4/127.0.0.1/tcp/10101/ws".parse().unwrap(),
-           Duration::from_secs(3600 * 24 * 356)
-        );
-        
-        floodsub::listen(peer_id, peer_store, &log);
     }
     info!(log, "Exiting.");
 }

src/p2p/config.rs

@@ -0,0 +1,17 @@
+use super::libp2p_core::Multiaddr;
+
+pub struct NetworkConfig {
+    pub config_dir: String,
+    pub listen_multiaddr: Multiaddr,
+}
+
+impl NetworkConfig {
+    pub fn default() -> Self{
+        Self {
+            config_dir: ".lighthouse".to_string(),
+            listen_multiaddr: "/ip4/0.0.0.0/tcp/0"
+                .parse::<Multiaddr>().unwrap()
+
+        }
+    }
+}

src/p2p/floodsub.rs

@@ -1,6 +1,7 @@
 extern crate bigint;
 extern crate bytes;
 extern crate futures;
+extern crate hex;
 extern crate libp2p_peerstore;
 extern crate libp2p_identify;
 extern crate libp2p_core;
@@ -14,9 +15,9 @@ extern crate tokio_io;
 extern crate tokio_timer;
 extern crate tokio_stdin;
 
+use super::state::NetworkState;
 use self::bigint::U512;
 use self::futures::{ Future, Stream };
-use self::libp2p_peerstore::PeerId;
 use self::libp2p_core::{ AddrComponent, Endpoint, Multiaddr, Transport, ConnectionUpgrade };
 use self::libp2p_floodsub::{ FloodSubUpgrade, FloodSubFuture };
 use self::libp2p_kad::{ KademliaUpgrade, KademliaProcessingFuture};
@@ -26,16 +27,14 @@ use std::sync::{ Arc, RwLock };
 use std::time::{ Duration, Instant };
 use std::ops::Deref;
 use std::io::Error as IoError;
-use libp2p_peerstore::memory_peerstore::MemoryPeerstore;
 use self::tokio_io::{ AsyncRead, AsyncWrite };
 use self::bytes::Bytes;
 
-pub fn listen(peer_id: PeerId, 
+pub fn listen(state: NetworkState, log: &Logger) 
-               peer_store: Arc<MemoryPeerstore>,
-               log: &Logger) 
 {
-    let listen_multiaddr: Multiaddr = "/ip4/0.0.0.0/tcp/0"
+    let peer_store = state.peer_store;
-        .parse::<Multiaddr>().expect("Failed to parse listen multiaddr.");
+    let peer_id = state.peer_id;
+    let listen_multiaddr = state.listen_multiaddr;
 
     info!(log, "Local PeerId: {:?}", peer_id);
     

src/p2p/keys.rs

@@ -8,6 +8,9 @@ use std::io::prelude::*;
 use std::fs::File;
 use slog::Logger;
 
+use std::io::Error as IoError;
+use std::path::Path;
+use super::config::NetworkConfig;
 use self::secp256k1::key::{ SecretKey, PublicKey };
 use self::libp2p_peerstore::PeerId;
 
@@ -15,16 +18,13 @@ const LOCAL_PK_FILE: &str = "local.pk";
 const LOCAL_SK_FILE: &str = "local.sk";
 const BOOTSTRAP_PK_FILE: &str = "bootstrap.pk";
 
-pub fn peer_id_from_pub_key(pk: &PublicKey) -> PeerId {
-    let curve = get_curve();
-    PeerId::from_public_key(&pk.serialize_vec(&curve, false))
-}
-
 fn get_curve() -> secp256k1::Secp256k1 { secp256k1::Secp256k1::new() }
 
 /// Generates a new public and secret key pair and writes them to 
 /// individual files.
-pub fn generate_keys(log: &Logger) -> std::io::Result<()> {
+pub fn generate_keys(config: NetworkConfig, log: &Logger)
+    -> Result<(), IoError>
+{
     info!(log, "Generating keys...");
     let mut rng = rand::thread_rng();
     let curve = get_curve();
@@ -42,32 +42,3 @@ pub fn generate_keys(log: &Logger) -> std::io::Result<()> {
     s_file.write(s_string.as_bytes())?;
     Ok(())
 }
-
-pub fn load_bootstrap_pk(log: &Logger) -> PublicKey {
-    info!(log, "Loading boostrap public key from filesystem...");
-    load_pk_from_file(BOOTSTRAP_PK_FILE)
-}
-
-pub fn load_local_keys(log: &Logger) -> (PublicKey, SecretKey) {
-    info!(log, "Loading local keys from filesystem...");
-    (load_pk_from_file(LOCAL_PK_FILE), load_sk_from_file(LOCAL_SK_FILE))
-}
-
-fn load_sk_from_file(file: &str) -> SecretKey {
-    let vec = load_vec_from_hex_file(file);
-    let curve = get_curve();
-    SecretKey::from_slice(&curve, &vec).expect("secret key invalid")
-}
-
-fn load_pk_from_file(file: &str) -> PublicKey {
-    let vec = load_vec_from_hex_file(file);
-    let curve = get_curve();
-    PublicKey::from_slice(&curve, &vec).expect("public key invalid")
-}
-
-fn load_vec_from_hex_file(file: &str) -> Vec<u8> {
-    let mut contents = String::new();
-    let mut file = File::open(file).expect("key not found");
-    file.read_to_string(&mut contents).expect("error reading from file");
-    hex::decode(contents).expect("public key corrupt")
-}

src/p2p/mod.rs

@@ -1,2 +1,9 @@
+extern crate hex;
+extern crate libp2p_core;
+extern crate libp2p_peerstore;
+extern crate secp256k1;
+
 pub mod floodsub;
-pub mod keys;
+pub mod state;
+// pub mod keys;
+pub mod config;

src/p2p/state.rs

@@ -0,0 +1,55 @@
+use std::io::Read;
+use std::error::Error;
+use std::path::Path;
+use std::fs::File;
+use std::sync::Arc;
+
+use super::hex;
+use super::secp256k1::Secp256k1;
+use super::secp256k1::key::{ SecretKey, PublicKey };
+use super::libp2p_core::Multiaddr;
+use super::libp2p_peerstore::PeerId;
+use super::libp2p_peerstore::json_peerstore::JsonPeerstore;
+use super::config::NetworkConfig;
+
+
+const PEERS_FILE: &str = "peerstore.json";
+const LOCAL_SK_FILE: &str = "local.sk";
+
+pub struct NetworkState {
+    pub pubkey: PublicKey,
+    pub seckey: SecretKey,
+    pub peer_id: PeerId,
+    pub listen_multiaddr: Multiaddr,
+    pub peer_store: Arc<JsonPeerstore>,
+}
+
+impl NetworkState {
+    pub fn new(config: &NetworkConfig) -> Result <Self, Box<Error>> {
+        let curve = Secp256k1::new();
+        let seckey = {
+            let path = Path::new(&config.config_dir).join(LOCAL_SK_FILE);
+            let mut contents = String::new();
+            let mut file = File::open(path)?;
+            file.read_to_string(&mut contents)?;
+            let vec = hex::decode(contents)?;
+            SecretKey::from_slice(&curve, &vec)?
+        };
+        let pubkey = PublicKey::from_secret_key(&curve, &seckey)?;
+        let peer_id = PeerId::from_public_key(
+            &pubkey.serialize_vec(&curve, false));
+        let peer_store =  {
+            let path = Path::new(&config.config_dir).join(PEERS_FILE);
+            let base = JsonPeerstore::new(path)?;
+            Arc::new(base)
+        };
+        let listen_multiaddr = "/ip4/0.0.0.0/tcp/0".parse::<Multiaddr>()?;
+        Ok(Self {
+            seckey,
+            pubkey,
+            peer_id,
+            listen_multiaddr,
+            peer_store,
+        })
+    }
+}