refactor indexer

Author: frisitano

crates/indexer/src/action.rs

@@ -0,0 +1,44 @@
+use super::{IndexerError, IndexerEvent};
+use std::{
+    fmt,
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// A future that resolves to a tuple of the block info and the block import outcome.
+type PendingIndexerFuture =
+    Pin<Box<dyn Future<Output = Result<IndexerEvent, IndexerError>> + Send>>;
+
+pub(super) enum IndexerAction {
+    HandleReorg(PendingIndexerFuture),
+    HandleBatchCommit(PendingIndexerFuture),
+    HandleBatchFinalization(PendingIndexerFuture),
+    HandleL1Message(PendingIndexerFuture),
+}
+
+impl IndexerAction {
+    /// Polls the future to completion.
+    pub(super) fn poll(
+        &mut self,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<IndexerEvent, IndexerError>> {
+        match self {
+            Self::HandleReorg(fut) |
+            Self::HandleBatchCommit(fut) |
+            Self::HandleBatchFinalization(fut) |
+            Self::HandleL1Message(fut) => fut.as_mut().poll(cx),
+        }
+    }
+}
+
+impl fmt::Debug for IndexerAction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::HandleReorg(_) => write!(f, "HandleReorg"),
+            Self::HandleBatchCommit(_) => write!(f, "HandleBatchCommit"),
+            Self::HandleBatchFinalization(_) => write!(f, "HandleBatchFinalization"),
+            Self::HandleL1Message(_) => write!(f, "HandleL1Message"),
+        }
+    }
+}

crates/indexer/src/lib.rs

@@ -6,49 +6,29 @@ use rollup_node_watcher::L1Notification;
 use scroll_db::{Database, DatabaseOperations};
 use std::{
     collections::VecDeque,
-    fmt,
-    future::Future,
     pin::Pin,
     sync::Arc,
     task::{Context, Poll},
 };
 
+mod action;
+use action::IndexerAction;
+
 mod event;
 pub use event::IndexerEvent;
 
 mod error;
 use error::IndexerError;
 
-/// A future that resolves to a tuple of the block info and the block import outcome.
-type PendingIndexerFuture =
-    Pin<Box<dyn Future<Output = Result<IndexerEvent, IndexerError>> + Send>>;
-
-enum IndexerAction {
-    HandleReorg(PendingIndexerFuture),
-    HandleBatchCommit(PendingIndexerFuture),
-    HandleBatchFinalization(PendingIndexerFuture),
-    HandleL1Message(PendingIndexerFuture),
-}
-
 /// The indexer is responsible for indexing data relevant to the L1.
+#[derive(Debug)]
 pub struct Indexer {
     /// A reference to the database used to persist the indexed data.
     database: Arc<Database>,
     /// A queue of pending futures.
     pending_futures: VecDeque<IndexerAction>,
 }
 
-impl IndexerAction {
-    fn poll(&mut self, cx: &mut Context<'_>) -> Poll<Result<IndexerEvent, IndexerError>> {
-        match self {
-            Self::HandleReorg(fut) |
-            Self::HandleBatchCommit(fut) |
-            Self::HandleBatchFinalization(fut) |
-            Self::HandleL1Message(fut) => fut.as_mut().poll(cx),
-        }
-    }
-}
-
 impl Indexer {
     /// Creates a new indexer with the given [`Database`].
     pub fn new(database: Arc<Database>) -> Self {
@@ -149,16 +129,6 @@ impl Stream for Indexer {
     }
 }
 
-impl fmt::Debug for Indexer {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Indexer")
-            .field("database", &"Arc<Database>") // Hide actual DB details
-            .field("cmd_rx", &"mpsc::UnboundedReceiver<IndexerCommand>") // Hide channel details
-            .field("pending_futures_len", &self.pending_futures.len()) // Only print the queue length
-            .finish()
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;