Stable futures (#879)

* Port eth1 lib to use stable futures * Port eth1_test_rig to stable futures * Port eth1 tests to stable futures * Port genesis service to stable futures * Port genesis tests to stable futures * Port beacon_chain to stable futures * Port lcli to stable futures * Fix eth1_test_rig (#1014) * Fix lcli * Port timer to stable futures * Fix timer * Port websocket_server to stable futures * Port notifier to stable futures * Add TODOS * Update hashmap hashset to stable futures * Adds panic test to hashset delay * Port remote_beacon_node to stable futures * Fix lcli merge conflicts * Non rpc stuff compiles * protocol.rs compiles * Port websockets, timer and notifier to stable futures (#1035) * Fix lcli * Port timer to stable futures * Fix timer * Port websocket_server to stable futures * Port notifier to stable futures * Add TODOS * Port remote_beacon_node to stable futures * Partial eth2-libp2p stable future upgrade * Finished first round of fighting RPC types * Further progress towards porting eth2-libp2p adds caching to discovery * Update behaviour * RPC handler to stable futures * Update RPC to master libp2p * Network service additions * Fix the fallback transport construction (#1102) * Correct warning * Remove hashmap delay * Compiling version of eth2-libp2p * Update all crates versions * Fix conversion function and add tests (#1113) * Port validator_client to stable futures (#1114) * Add PH & MS slot clock changes * Account for genesis time * Add progress on duties refactor * Add simple is_aggregator bool to val subscription * Start work on attestation_verification.rs * Add progress on ObservedAttestations * Progress with ObservedAttestations * Fix tests * Add observed attestations to the beacon chain * Add attestation observation to processing code * Add progress on attestation verification * Add first draft of ObservedAttesters * Add more tests * Add observed attesters to beacon chain * Add observers to attestation processing * Add more attestation verification * Create ObservedAggregators map * Remove commented-out code * Add observed aggregators into chain * Add progress * Finish adding features to attestation verification * Ensure beacon chain compiles * Link attn verification into chain * Integrate new attn verification in chain * Remove old attestation processing code * Start trying to fix beacon_chain tests * Split adding into pools into two functions * Add aggregation to harness * Get test harness working again * Adjust the number of aggregators for test harness * Fix edge-case in harness * Integrate new attn processing in network * Fix compile bug in validator_client * Update validator API endpoints * Fix aggreagation in test harness * Fix enum thing * Fix attestation observation bug: * Patch failing API tests * Start adding comments to attestation verification * Remove unused attestation field * Unify "is block known" logic * Update comments * Supress fork choice errors for network processing * Add todos * Tidy * Add gossip attn tests * Disallow test harness to produce old attns * Comment out in-progress tests * Partially address pruning tests * Fix failing store test * Add aggregate tests * Add comments about which spec conditions we check * Dont re-aggregate * Split apart test harness attn production * Fix compile error in network * Make progress on commented-out test * Fix skipping attestation test * Add fork choice verification tests * Tidy attn tests, remove dead code * Remove some accidentally added code * Fix clippy lint * Rename test file * Add block tests, add cheap block proposer check * Rename block testing file * Add observed_block_producers * Tidy * Switch around block signature verification * Finish block testing * Remove gossip from signature tests * First pass of self review * Fix deviation in spec * Update test spec tags * Start moving over to hashset * Finish moving observed attesters to hashmap * Move aggregation pool over to hashmap * Make fc attn borrow again * Fix rest_api compile error * Fix missing comments * Fix monster test * Uncomment increasing slots test * Address remaining comments * Remove unsafe, use cfg test * Remove cfg test flag * Fix dodgy comment * Revert "Update hashmap hashset to stable futures" This reverts commit d432378a3c. * Revert "Adds panic test to hashset delay" This reverts commit 281502396f. * Ported attestation_service * Ported duties_service * Ported fork_service * More ports * Port block_service * Minor fixes * VC compiles * Update TODOS * Borrow self where possible * Ignore aggregates that are already known. * Unify aggregator modulo logic * Fix typo in logs * Refactor validator subscription logic * Avoid reproducing selection proof * Skip HTTP call if no subscriptions * Rename DutyAndState -> DutyAndProof * Tidy logs * Print root as dbg * Fix compile errors in tests * Fix compile error in test * Re-Fix attestation and duties service * Minor fixes Co-authored-by: Paul Hauner <paul@paulhauner.com> * Network crate update to stable futures * Port account_manager to stable futures (#1121) * Port account_manager to stable futures * Run async fns in tokio environment * Port rest_api crate to stable futures (#1118) * Port rest_api lib to stable futures * Reduce tokio features * Update notifier to stable futures * Builder update * Further updates * Convert self referential async functions * stable futures fixes (#1124) * Fix eth1 update functions * Fix genesis and client * Fix beacon node lib * Return appropriate runtimes from environment * Fix test rig * Refactor eth1 service update * Upgrade simulator to stable futures * Lighthouse compiles on stable futures * Remove println debugging statement * Update libp2p service, start rpc test upgrade * Update network crate for new libp2p * Update tokio::codec to futures_codec (#1128) * Further work towards RPC corrections * Correct http timeout and network service select * Use tokio runtime for libp2p * Revert "Update tokio::codec to futures_codec (#1128)" This reverts commit e57aea924a. * Upgrade RPC libp2p tests * Upgrade secio fallback test * Upgrade gossipsub examples * Clean up RPC protocol * Test fixes (#1133) * Correct websocket timeout and run on os thread * Fix network test * Clean up PR * Correct tokio tcp move attestation service tests * Upgrade attestation service tests * Correct network test * Correct genesis test * Test corrections * Log info when block is received * Modify logs and update attester service events * Stable futures: fixes to vc, eth1 and account manager (#1142) * Add local testnet scripts * Remove whiteblock script * Rename local testnet script * Move spawns onto handle * Fix VC panic * Initial fix to block production issue * Tidy block producer fix * Tidy further * Add local testnet clean script * Run cargo fmt * Tidy duties service * Tidy fork service * Tidy ForkService * Tidy AttestationService * Tidy notifier * Ensure await is not suppressed in eth1 * Ensure await is not suppressed in account_manager * Use .ok() instead of .unwrap_or(()) * RPC decoding test for proto * Update discv5 and eth2-libp2p deps * Fix lcli double runtime issue (#1144) * Handle stream termination and dialing peer errors * Correct peer_info variant types * Remove unnecessary warnings * Handle subnet unsubscription removal and improve logigng * Add logs around ping * Upgrade discv5 and improve logging * Handle peer connection status for multiple connections * Improve network service logging * Improve logging around peer manager * Upgrade swarm poll centralise peer management * Identify clients on error * Fix `remove_peer` in sync (#1150) * remove_peer removes from all chains * Remove logs * Fix early return from loop * Improved logging, fix panic * Partially correct tests * Stable futures: Vc sync (#1149) * Improve syncing heuristic * Add comments * Use safer method for tolerance * Fix tests * Stable futures: Fix VC bug, update agg pool, add more metrics (#1151) * Expose epoch processing summary * Expose participation metrics to prometheus * Switch to f64 * Reduce precision * Change precision * Expose observed attesters metrics * Add metrics for agg/unagg attn counts * Add metrics for gossip rx * Add metrics for gossip tx * Adds ignored attns to prom * Add attestation timing * Add timer for aggregation pool sig agg * Add write lock timer for agg pool * Add more metrics to agg pool * Change map lock code * Add extra metric to agg pool * Change lock handling in agg pool * Change .write() to .read() * Add another agg pool timer * Fix for is_aggregator * Fix pruning bug Co-authored-by: pawan <pawandhananjay@gmail.com> Co-authored-by: Paul Hauner <paul@paulhauner.com>
2026-03-14 10:22:38 +00:00 · 2020-05-17 21:16:48 +10:00
parent 21901b1615
commit b6408805a2
165 changed files with 7924 additions and 7733 deletions
--- a/eth2/utils/hashset_delay/Cargo.toml
+++ b/eth2/utils/hashset_delay/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "hashset_delay"
+version = "0.2.0"
+authors = ["Age Manning <Age@AgeManning.com>"]
+edition = "2018"
+
+[dependencies]
+futures = "0.3.5"
+tokio = { version = "0.2.20", features = ["time"] }
+
+[dev-dependencies]
+tokio = { version = "0.2.20", features = ["time", "rt-threaded", "macros"] }
--- a/eth2/utils/hashset_delay/src/hashset_delay.rs
+++ b/eth2/utils/hashset_delay/src/hashset_delay.rs
@@ -0,0 +1,192 @@
+//NOTE: This is just a specific case of a HashMapDelay.
+// The code has been copied to make unique `insert` and `insert_at` functions.
+
+/// The default delay for entries, in seconds. This is only used when `insert()` is used to add
+/// entries.
+const DEFAULT_DELAY: u64 = 30;
+
+use futures::prelude::*;
+use std::{
+    collections::HashMap,
+    pin::Pin,
+    task::{Context, Poll},
+    time::{Duration, Instant},
+};
+use tokio::time::delay_queue::{self, DelayQueue};
+
+pub struct HashSetDelay<K>
+where
+    K: std::cmp::Eq + std::hash::Hash + std::clone::Clone + Unpin,
+{
+    /// The given entries.
+    entries: HashMap<K, MapEntry>,
+    /// A queue holding the timeouts of each entry.
+    expirations: DelayQueue<K>,
+    /// The default expiration timeout of an entry.
+    default_entry_timeout: Duration,
+}
+
+/// A wrapping around entries that adds the link to the entry's expiration, via a `delay_queue` key.
+struct MapEntry {
+    /// The expiration key for the entry.
+    key: delay_queue::Key,
+    /// The actual entry.
+    value: Instant,
+}
+
+impl<K> Default for HashSetDelay<K>
+where
+    K: std::cmp::Eq + std::hash::Hash + std::clone::Clone + Unpin,
+{
+    fn default() -> Self {
+        HashSetDelay::new(Duration::from_secs(DEFAULT_DELAY))
+    }
+}
+
+impl<K> HashSetDelay<K>
+where
+    K: std::cmp::Eq + std::hash::Hash + std::clone::Clone + Unpin,
+{
+    /// Creates a new instance of `HashSetDelay`.
+    pub fn new(default_entry_timeout: Duration) -> Self {
+        HashSetDelay {
+            entries: HashMap::new(),
+            expirations: DelayQueue::new(),
+            default_entry_timeout,
+        }
+    }
+
+    /// Insert an entry into the mapping. Entries will expire after the `default_entry_timeout`.
+    pub fn insert(&mut self, key: K) {
+        self.insert_at(key, self.default_entry_timeout);
+    }
+
+    /// Inserts an entry that will expire at a given instant. If the entry already exists, the
+    /// timeout is updated.
+    pub fn insert_at(&mut self, key: K, entry_duration: Duration) {
+        if self.contains(&key) {
+            // update the timeout
+            self.update_timeout(&key, entry_duration);
+        } else {
+            let delay_key = self.expirations.insert(key.clone(), entry_duration.clone());
+            let entry = MapEntry {
+                key: delay_key,
+                value: Instant::now() + entry_duration,
+            };
+            self.entries.insert(key, entry);
+        }
+    }
+
+    /// Gets a reference to an entry if it exists.
+    ///
+    /// Returns None if the entry does not exist.
+    pub fn get(&self, key: &K) -> Option<&Instant> {
+        self.entries.get(key).map(|entry| &entry.value)
+    }
+
+    /// Returns true if the key exists, false otherwise.
+    pub fn contains(&self, key: &K) -> bool {
+        self.entries.contains_key(key)
+    }
+
+    /// Returns the length of the mapping.
+    pub fn len(&self) -> usize {
+        self.entries.len()
+    }
+
+    /// Updates the timeout for a given key. Returns true if the key existed, false otherwise.
+    ///
+    /// Panics if the duration is too far in the future.
+    pub fn update_timeout(&mut self, key: &K, timeout: Duration) -> bool {
+        if let Some(entry) = self.entries.get(key) {
+            self.expirations.reset(&entry.key, timeout);
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Removes a key from the map returning the value associated with the key that was in the map.
+    ///
+    /// Return false if the key was not in the map.
+    pub fn remove(&mut self, key: &K) -> bool {
+        if let Some(entry) = self.entries.remove(key) {
+            self.expirations.remove(&entry.key);
+            return true;
+        }
+        return false;
+    }
+
+    /// Retains only the elements specified by the predicate.
+    ///
+    /// In other words, remove all pairs `(k, v)` such that `f(&k,&mut v)` returns false.
+    pub fn retain<F: FnMut(&K) -> bool>(&mut self, mut f: F) {
+        let expiration = &mut self.expirations;
+        self.entries.retain(|key, entry| {
+            let result = f(key);
+            if !result {
+                expiration.remove(&entry.key);
+            }
+            result
+        })
+    }
+
+    /// Removes all entries from the map.
+    pub fn clear(&mut self) {
+        self.entries.clear();
+        self.expirations.clear();
+    }
+
+    /// Returns a vector of referencing all keys in the map.
+    pub fn keys(&self) -> impl Iterator<Item = &K> {
+        self.entries.keys()
+    }
+}
+
+impl<K> Stream for HashSetDelay<K>
+where
+    K: std::cmp::Eq + std::hash::Hash + std::clone::Clone + Unpin,
+{
+    type Item = Result<K, String>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        match self.expirations.poll_expired(cx) {
+            Poll::Ready(Some(Ok(key))) => match self.entries.remove(key.get_ref()) {
+                Some(_) => Poll::Ready(Some(Ok(key.into_inner()))),
+                None => Poll::Ready(Some(Err("Value no longer exists in expirations".into()))),
+            },
+            Poll::Ready(Some(Err(e))) => {
+                Poll::Ready(Some(Err(format!("delay queue error: {:?}", e))))
+            }
+            Poll::Ready(None) => Poll::Ready(None),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+#[cfg(test)]
+
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn should_not_panic() {
+        let key = 2u8;
+
+        let mut map = HashSetDelay::default();
+
+        map.insert(key);
+        map.update_timeout(&key, Duration::from_secs(100));
+
+        let fut = |cx: &mut Context| {
+            let _ = map.poll_next_unpin(cx);
+            let _ = map.poll_next_unpin(cx);
+            Poll::Ready(())
+        };
+
+        future::poll_fn(fut).await;
+
+        map.insert(key);
+        map.update_timeout(&key, Duration::from_secs(100));
+    }
+}
--- a/eth2/utils/hashset_delay/src/lib.rs
+++ b/eth2/utils/hashset_delay/src/lib.rs
@@ -0,0 +1,12 @@
+//! This crate provides a single type (its counter-part HashMapDelay has been removed as it
+//! currently is not in use in lighthouse):
+//! - `HashSetDelay`
+//!
+//! # HashSetDelay
+//!
+//! This is similar to a `HashMapDelay` except the mapping maps to the expiry time. This
+//! allows users to add objects and check their expiry deadlines before the `Stream`
+//! consumes them.
+
+mod hashset_delay;
+pub use crate::hashset_delay::HashSetDelay;