Update VC and BN APIs for naive aggregation (#950)

* Refactor `Attestation` production

* Add constant

* Start refactor for aggregation

* Return early when no attesting validators

* Refactor into individual functions

* Tidy, add comments

* Add first draft of NaiveAggregationPool

* Further progress on naive aggregation pool

* Fix compile errors in VC

* Change locking logic for naive pool

* Introduce AttesationType

* Add pruning, comments

* Add MAX_ATTESTATIONS_PER_SLOT restriction

* Add pruning based on slot

* Update BN for new aggregation fns

* Fix test compile errors

* Fix failing rest_api test

* Move SignedAggregateAndProof into own file

* Update docs, fix warning

* Tidy some formatting in validator API

* Remove T::default_spec from signing

* Fix failing rest test

* Tidy

* Add test, fix bug

* Improve naive pool tests

* Add max attestations test

* Revert changes to the op_pool

* Refactor timer

beacon_node/timer/src/lib.rs

@@ -3,59 +3,13 @@
 //! This service allows task execution on the beacon node for various functionality.
 
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-use futures::prelude::*;
-use slog::warn;
+use futures::{future, prelude::*};
+use slog::error;
 use slot_clock::SlotClock;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::runtime::TaskExecutor;
 use tokio::timer::Interval;
-use types::EthSpec;
-
-/// A collection of timers that can execute actions on the beacon node.
-///
-/// This currently only has a per-slot timer, although others may be added in the future
-struct Timer<T: BeaconChainTypes> {
-    /// Beacon chain associated.
-    beacon_chain: Arc<BeaconChain<T>>,
-    /// A timer that fires every slot.
-    per_slot_timer: Interval,
-    /// The logger for the timer.
-    log: slog::Logger,
-}
-
-impl<T: BeaconChainTypes> Timer<T> {
-    pub fn new(
-        beacon_chain: Arc<BeaconChain<T>>,
-        milliseconds_per_slot: u64,
-        log: slog::Logger,
-    ) -> Result<Self, &'static str> {
-        let duration_to_next_slot = beacon_chain
-            .slot_clock
-            .duration_to_next_slot()
-            .ok_or_else(|| "slot_notifier unable to determine time to next slot")?;
-
-        let slot_duration = Duration::from_millis(milliseconds_per_slot);
-        // A per-slot timer
-        let start_instant = Instant::now() + duration_to_next_slot;
-        let per_slot_timer = Interval::new(start_instant, slot_duration);
-
-        Ok(Timer {
-            beacon_chain,
-            per_slot_timer,
-            log,
-        })
-    }
-
-    /// Tasks that occur on a per-slot basis.
-    pub fn per_slot_task(&self) {
-        self.beacon_chain.per_slot_task();
-    }
-
-    pub fn per_epoch_task(&self) {
-        self.beacon_chain.per_epoch_task();
-    }
-}
 
 /// Spawns a timer service which periodically executes tasks for the beacon chain
 pub fn spawn<T: BeaconChainTypes>(
@@ -64,34 +18,33 @@ pub fn spawn<T: BeaconChainTypes>(
     milliseconds_per_slot: u64,
     log: slog::Logger,
 ) -> Result<tokio::sync::oneshot::Sender<()>, &'static str> {
-    //let thread_log = log.clone();
-    let mut timer = Timer::new(beacon_chain, milliseconds_per_slot, log)?;
-    let (exit_signal, mut exit) = tokio::sync::oneshot::channel();
+    let (exit_signal, exit) = tokio::sync::oneshot::channel();
 
-    executor.spawn(futures::future::poll_fn(move || -> Result<_, ()> {
-        if let Ok(Async::Ready(_)) | Err(_) = exit.poll() {
-            // notifier is terminating, end the process
-            return Ok(Async::Ready(()));
-        }
+    let start_instant = Instant::now()
+        + beacon_chain
+            .slot_clock
+            .duration_to_next_slot()
+            .ok_or_else(|| "slot_notifier unable to determine time to next slot")?;
 
-        while let Async::Ready(_) = timer
-            .per_slot_timer
-            .poll()
-            .map_err(|e| warn!(timer.log, "Per slot timer error"; "error" => format!("{:?}", e)))?
-        {
-            timer.per_slot_task();
-            match timer
-                .beacon_chain
-                .slot_clock
-                .now()
-                .map(|slot| (slot % T::EthSpec::slots_per_epoch()).as_u64())
-            {
-                Some(0) => timer.per_epoch_task(),
-                _ => {}
-            }
-        }
-        Ok(Async::NotReady)
-    }));
+    let timer_future = Interval::new(start_instant, Duration::from_millis(milliseconds_per_slot))
+        .map_err(move |e| {
+            error!(
+                log,
+                "Beacon chain timer failed";
+                "error" => format!("{:?}", e)
+            )
+        })
+        .for_each(move |_| {
+            beacon_chain.per_slot_task();
+            future::ok(())
+        });
+
+    executor.spawn(
+        exit.map_err(|_| ())
+            .select(timer_future)
+            .map(|_| ())
+            .map_err(|_| ()),
+    );
 
     Ok(exit_signal)
 }