Begin sync framework

lighthouse/client/mod.rs

@@ -8,7 +8,7 @@ use super::futures::sync::mpsc::{
 use super::network_libp2p::service::listen as network_listen;
 use super::network_libp2p::state::NetworkState;
 use super::slog::Logger;
-use super::sync::start_sync;
+use super::sync::run_sync_future;
 
 /// Represents the co-ordination of the
 /// networking, syncing and RPC (not-yet-implemented) threads.
@@ -59,7 +59,7 @@ impl Client {
             let sync_log = log.new(o!());
             let sync_db = Arc::clone(&db);
             let thread = thread::spawn(move || {
-                start_sync(
+                run_sync_future(
                     sync_db,
                     network_tx.clone(),
                     network_rx,

lighthouse/sync/messages.rs

@@ -0,0 +1,12 @@
+pub enum SyncEventType {
+    Invalid,
+    PeerConnect,
+    PeerDrop,
+    ReceiveBlocks,
+    ReceiveAttestationRecords,
+}
+
+pub struct SyncEvent {
+    event: SyncEventType,
+    data: Option<Vec<u8>>
+}

lighthouse/sync/mod.rs

@@ -1,50 +1,12 @@
 extern crate futures;
 extern crate slog;
 extern crate tokio;
+extern crate network_libp2p;
 
-use self::futures::sync::mpsc::{
+pub mod messages;
-    UnboundedReceiver,
+pub mod network;
-    UnboundedSender,
+pub mod sync_future;
-};
-use self::tokio::prelude::*;
-use std::sync::{ RwLock, Arc };
-use super::network_libp2p::message::{
-    NetworkEvent,
-    OutgoingMessage,
-};
-use super::db::DB;
-use slog::Logger;
 
-type NetworkSender = UnboundedSender<OutgoingMessage>;
+pub use self::sync_future::run_sync_future;
-type NetworkReceiver = UnboundedReceiver<NetworkEvent>;
 
-type SyncSender = UnboundedSender<Vec<u8>>;
+use super::db;
-type SyncReceiver = UnboundedReceiver<Vec<u8>>;
-
-/// Start a syncing tokio future.
-///
-/// This is effectively a stub function being
-/// used to test network functionality.
-///
-/// Expect a full re-write.
-pub fn start_sync(
-    _db: Arc<RwLock<DB>>,
-    _network_tx: NetworkSender,
-    network_rx: NetworkReceiver,
-    _sync_tx: SyncSender,
-    _sync_rx: SyncReceiver,
-    log: Logger) {
-    let rx_future = network_rx
-        .for_each(move |event| {
-            debug!(&log, "Sync receive";
-                   "msg" => format!("{:?}", event));
-            Ok(())
-        })
-        .map_err(|_| panic!("rx failed"));
-
-    /*
-     * This is an unfinished stub function.
-     */
-
-    tokio::run(rx_future);
-}

lighthouse/sync/network.rs

@@ -0,0 +1,44 @@
+use std::sync::{ RwLock, Arc };
+use super::db::DB;
+use slog::Logger;
+
+use super::network_libp2p::message::{
+    NetworkEvent,
+    OutgoingMessage,
+    NetworkEventType,
+};
+
+use super::futures::sync::mpsc::{
+    UnboundedSender,
+};
+
+pub fn handle_network_event(
+    event: NetworkEvent,
+    db: Arc<RwLock<DB>>,
+    network_tx: UnboundedSender<OutgoingMessage>,
+    log: Logger)
+    -> Result<(), ()>
+{
+        match event.event {
+            NetworkEventType::PeerConnect => Ok(()),
+            NetworkEventType::PeerDrop => Ok(()),
+            NetworkEventType::Message => handle_network_message(
+                event.data,
+                db,
+                network_tx,
+                log
+            )
+        }
+}
+
+fn handle_network_message(
+    message: Option<Vec<u8>>,
+    _db: Arc<RwLock<DB>>,
+    _network_tx: UnboundedSender<OutgoingMessage>,
+    log: Logger)
+    -> Result<(), ()>
+{
+    debug!(&log, "";
+           "network_msg" => format!("{:?}", message));
+    Ok(())
+}

lighthouse/sync/sync_future.rs

@@ -0,0 +1,52 @@
+use super::tokio;
+use super::futures::{ Future, Stream };
+use super::futures::sync::mpsc::{
+    UnboundedReceiver,
+    UnboundedSender,
+};
+use super::network_libp2p::message::{
+    NetworkEvent,
+    OutgoingMessage,
+};
+use super::network::handle_network_event;
+use std::sync::{ RwLock, Arc };
+use super::db::DB;
+use slog::Logger;
+
+type NetworkSender = UnboundedSender<OutgoingMessage>;
+type NetworkReceiver = UnboundedReceiver<NetworkEvent>;
+
+type SyncSender = UnboundedSender<Vec<u8>>;
+type SyncReceiver = UnboundedReceiver<Vec<u8>>;
+
+/// Start a syncing tokio future.
+///
+/// This is effectively a stub function being
+/// used to test network functionality.
+///
+/// Expect a full re-write.
+pub fn run_sync_future(
+    db: Arc<RwLock<DB>>,
+    network_tx: NetworkSender,
+    network_rx: NetworkReceiver,
+    _sync_tx: SyncSender,
+    _sync_rx: SyncReceiver,
+    log: Logger) {
+    let network_future = {
+        network_rx
+            .for_each(move |event| {
+                handle_network_event(
+                    event,
+                    db.clone(),
+                    network_tx.clone(),
+                    log.clone())
+            })
+            .map_err(|_| panic!("rx failed"))
+    };
+
+    /*
+     * This is an unfinished stub function.
+     */
+
+    tokio::run(network_future);
+}