address comments

Author: akaladarshi

src/chain_sync/sync_status.rs

@@ -13,7 +13,7 @@ use std::sync::Arc;
 use tracing::log;
 
 // Node considered synced if the head is within this threshold.
-const SYNCED_EPOCH_THRESHOLD: u64 = 5;
+const SYNCED_EPOCH_THRESHOLD: u64 = 10;
 
 /// Represents the overall synchronization status of the Forest node.
 #[derive(
@@ -41,10 +41,10 @@ pub enum NodeSyncStatus {
     #[strum(to_string = "Synced")]
     Synced,
     /// An error occurred during the sync process.
-    #[strum(to_string = "error")]
+    #[strum(to_string = "Error")]
     Error,
     /// Node is configured to not sync (offline mode).
-    #[strum(to_string = "offline")]
+    #[strum(to_string = "Offline")]
     Offline,
 }
 
@@ -74,7 +74,7 @@ pub enum ForkSyncStage {
     #[strum(to_string = "Stalled")]
     Stalled,
     /// An error occurred processing this specific fork.
-    #[strum(to_string = "error")]
+    #[strum(to_string = "Error")]
     Error,
 }
 
@@ -105,24 +105,24 @@ pub struct ForkSyncInfo {
 #[derive(Serialize, Deserialize, Debug, Clone, Default, PartialEq, JsonSchema)]
 pub struct SyncStatusReport {
     /// Overall status of the node's synchronization.
-    status: NodeSyncStatus,
+    pub(crate) status: NodeSyncStatus,
     /// The epoch of the heaviest validated tipset on the node's main chain.
-    current_head_epoch: ChainEpoch,
+    pub(crate) current_head_epoch: ChainEpoch,
     /// The tipset key of the current heaviest validated tipset.
     #[schemars(with = "crate::lotus_json::LotusJson<TipsetKey>")]
     #[serde(with = "crate::lotus_json")]
-    current_head_key: Option<TipsetKey>,
+    pub(crate) current_head_key: Option<TipsetKey>,
     // Current highest epoch on the network.
-    network_head_epoch: ChainEpoch,
+    pub(crate) network_head_epoch: ChainEpoch,
     /// Estimated number of epochs the node is behind the network head.
     /// Can be negative if the node is slightly ahead, due to estimation variance.
-    epochs_behind: i64,
+    pub(crate) epochs_behind: i64,
     /// List of active fork synchronization tasks the node is currently handling.
-    active_forks: Vec<ForkSyncInfo>,
+    pub(crate) active_forks: Vec<ForkSyncInfo>,
     /// When the node process started.
-    node_start_time: DateTime<Utc>,
+    pub(crate) node_start_time: DateTime<Utc>,
     /// Last time this status report was generated.
-    last_updated: DateTime<Utc>,
+    pub(crate) last_updated: DateTime<Utc>,
 }
 
 lotus_json_with_self!(SyncStatusReport);
@@ -135,58 +135,6 @@ impl SyncStatusReport {
         }
     }
 
-    pub(crate) fn set_current_chain_head_key(&mut self, tipset_key: TipsetKey) {
-        self.current_head_key = Some(tipset_key);
-    }
-
-    pub(crate) fn set_current_chain_head_epoch(&mut self, epoch: ChainEpoch) {
-        self.current_head_epoch = epoch;
-    }
-
-    pub(crate) fn get_current_chain_head_epoch(&self) -> ChainEpoch {
-        self.current_head_epoch
-    }
-
-    pub(crate) fn set_network_head(&mut self, epoch: ChainEpoch) {
-        self.network_head_epoch = epoch;
-    }
-
-    pub(crate) fn get_network_head_epoch(&self) -> ChainEpoch {
-        self.network_head_epoch
-    }
-
-    pub(crate) fn get_current_chain_head_key(&self) -> Option<&TipsetKey> {
-        self.current_head_key.as_ref()
-    }
-
-    pub(crate) fn set_epochs_behind(&mut self, epochs_behind: i64) {
-        self.epochs_behind = epochs_behind;
-    }
-
-    pub(crate) fn get_epochs_behind(&self) -> i64 {
-        self.epochs_behind
-    }
-
-    pub(crate) fn set_status(&mut self, status: NodeSyncStatus) {
-        self.status = status;
-    }
-
-    pub(crate) fn get_status(&self) -> NodeSyncStatus {
-        self.status
-    }
-
-    pub(crate) fn update_active_forks(&mut self, active_forks: Vec<ForkSyncInfo>) {
-        self.active_forks = active_forks;
-    }
-
-    pub(crate) fn get_active_forks(&self) -> &Vec<ForkSyncInfo> {
-        &self.active_forks
-    }
-
-    pub fn get_last_updated(&self) -> &DateTime<Utc> {
-        &self.last_updated
-    }
-
     pub(crate) fn update<DB: Blockstore + Sync + Send + 'static>(
         &mut self,
         state_manager: &Arc<StateManager<DB>>,
@@ -195,8 +143,8 @@ impl SyncStatusReport {
     ) {
         let heaviest = state_manager.chain_store().heaviest_tipset();
         let current_chain_head_epoch = heaviest.epoch();
-        self.set_current_chain_head_key(heaviest.key().clone());
-        self.set_current_chain_head_epoch(current_chain_head_epoch);
+        self.current_head_key = Some(heaviest.key().clone());
+        self.current_head_epoch = current_chain_head_epoch;
 
         let now = Utc::now();
         let now_ts = now.timestamp() as u64;
@@ -207,13 +155,13 @@ impl SyncStatusReport {
             seconds_per_epoch,
         );
 
-        self.set_network_head(network_head_epoch);
-        self.set_epochs_behind(network_head_epoch.saturating_sub(current_chain_head_epoch));
+        self.network_head_epoch = network_head_epoch;
+        self.epochs_behind = network_head_epoch.saturating_sub(current_chain_head_epoch);
         log::trace!(
             "Sync status report: current head epoch: {}, network head epoch: {}, epochs behind: {}",
             current_chain_head_epoch,
             network_head_epoch,
-            self.get_epochs_behind()
+            self.epochs_behind
         );
 
         let time_diff = now_ts.saturating_sub(heaviest.min_timestamp());
@@ -228,8 +176,8 @@ impl SyncStatusReport {
             }
         };
 
-        self.set_status(status);
-        self.update_active_forks(current_active_forks);
+        self.status = status;
+        self.active_forks = current_active_forks;
         self.last_updated = now;
     }
 

src/cli/subcommands/sync_cmd.rs

@@ -55,17 +55,17 @@ impl SyncCommands {
                         .context("Failed to get sync status")?;
 
                     // Skip printing if initializing, since it's not useful to print
-                    if report.get_status() == NodeSyncStatus::Initializing {
+                    if report.status == NodeSyncStatus::Initializing {
                         continue;
                     }
 
                     clear_previous_lines(&mut stdout, lines_printed_last_iteration)?;
 
-                    lines_printed_last_iteration += print_sync_report_details(&report)
+                    lines_printed_last_iteration = print_sync_report_details(&report)
                         .context("Failed to print sync status report")?;
 
                     // Exit if synced and not in watch mode.
-                    if !watch && report.get_status() == NodeSyncStatus::Synced {
+                    if !watch && report.status == NodeSyncStatus::Synced {
                         println!("\nSync complete!");
                         break;
                     }
@@ -76,7 +76,7 @@ impl SyncCommands {
 
             Self::Status => {
                 let sync_status = client.call(SyncStatus::request(())?).await?;
-                if sync_status.get_status() == NodeSyncStatus::Initializing {
+                if sync_status.status == NodeSyncStatus::Initializing {
                     print!("Node initializing, checking snapshot status..\n\n");
                     // If a snapshot is required and not yet complete, return here
                     if !check_snapshot_progress(&client, false)
@@ -117,30 +117,29 @@ fn print_sync_report_details(report: &SyncStatusReport) -> anyhow::Result<usize>
 
     println!(
         "Status: {:?} ({} epochs behind)",
-        report.get_status(),
-        report.get_epochs_behind()
+        report.status, report.epochs_behind
     );
     lines_printed_count += 1;
 
     let head_key_str = report
-        .get_current_chain_head_key()
+        .current_head_key
+        .as_ref()
         .map(tipset_key_to_string)
         .unwrap_or_else(|| "[unknown]".to_string());
     println!(
         "Node Head: Epoch {} ({})",
-        report.get_current_chain_head_epoch(),
-        head_key_str
+        report.current_head_epoch, head_key_str
     );
     lines_printed_count += 1;
 
-    println!("Network Head: Epoch {}", report.get_network_head_epoch());
+    println!("Network Head: Epoch {}", report.network_head_epoch);
     lines_printed_count += 1;
 
-    println!("Last Update: {}", report.get_last_updated().to_rfc3339());
+    println!("Last Update: {}", report.last_updated.to_rfc3339());
     lines_printed_count += 1;
 
     // Print active sync tasks (forks)
-    let active_forks = report.get_active_forks();
+    let active_forks = &report.active_forks;
     if active_forks.is_empty() {
         println!("Active Sync Tasks: None");
         lines_printed_count += 1;
@@ -238,7 +237,7 @@ async fn handle_initial_snapshot_check(client: &rpc::Client) -> anyhow::Result<(
     let initial_report = SyncStatus::call(client, ())
         .await
         .context("Failed to get sync status")?;
-    if initial_report.get_status() == NodeSyncStatus::Initializing {
+    if initial_report.status == NodeSyncStatus::Initializing {
         print!("Node initializing, checking snapshot status...\n\n");
         // if the snapshot download is not required, then return,
         // else wait till the snapshot download is completed.

src/health/endpoints.rs

@@ -95,7 +95,7 @@ pub(crate) async fn healthz(
 
 fn check_sync_status_synced(state: &ForestState, acc: &mut MessageAccumulator) -> bool {
     // Forest must be in sync with the network
-    if state.sync_status.read().get_status() == NodeSyncStatus::Synced {
+    if state.sync_status.read().status == NodeSyncStatus::Synced {
         acc.push_ok("sync complete");
         true
     } else {
@@ -106,7 +106,7 @@ fn check_sync_status_synced(state: &ForestState, acc: &mut MessageAccumulator) -
 
 fn check_sync_status_not_error(state: &ForestState, acc: &mut MessageAccumulator) -> bool {
     // Forest must be in sync with the network
-    if state.sync_status.read().get_status() != NodeSyncStatus::Error {
+    if state.sync_status.read().status != NodeSyncStatus::Error {
         acc.push_ok("sync ok");
         true
     } else {
@@ -128,7 +128,7 @@ fn check_epoch_up_to_date(state: &ForestState, acc: &mut MessageAccumulator) ->
     );
 
     // The current epoch of the node must be not too far behind the network
-    if state.sync_status.read().get_current_chain_head_epoch() >= now_epoch - MAX_EPOCH_DIFF {
+    if state.sync_status.read().current_head_epoch >= now_epoch - MAX_EPOCH_DIFF {
         acc.push_ok("epoch up to date");
         true
     } else {

src/health/mod.rs

@@ -118,8 +118,8 @@ mod test {
         };
 
         // instrument the state so that the ready requirements are met
-        sync_status.write().set_status(NodeSyncStatus::Synced);
-        sync_status.write().set_current_chain_head_epoch(i64::MAX);
+        sync_status.write().status = NodeSyncStatus::Synced;
+        sync_status.write().current_head_epoch = i64::MAX;
         db.set_eth_mapping_up_to_date().unwrap();
 
         assert_eq!(
@@ -136,8 +136,8 @@ mod test {
 
         // instrument the state so that the ready requirements are not met
         drop(rpc_listener);
-        sync_status.write().set_status(NodeSyncStatus::Error);
-        sync_status.write().set_current_chain_head_epoch(0);
+        sync_status.write().status = NodeSyncStatus::Error;
+        sync_status.write().current_head_epoch = 0;
 
         assert_eq!(
             call_healthcheck(false).await.unwrap().status(),
@@ -198,7 +198,7 @@ mod test {
         };
 
         // instrument the state so that the live requirements are met
-        sync_status.write().set_status(NodeSyncStatus::Syncing);
+        sync_status.write().status = NodeSyncStatus::Syncing;
         let peer = libp2p::PeerId::random();
         peer_manager.touch_peer(&peer);
 
@@ -214,7 +214,7 @@ mod test {
         assert!(text.contains("[+] peers connected"));
 
         // instrument the state so that the live requirements are not met
-        sync_status.write().set_status(NodeSyncStatus::Error);
+        sync_status.write().status = NodeSyncStatus::Error;
         peer_manager.remove_peer(&peer);
 
         assert_eq!(
@@ -274,8 +274,8 @@ mod test {
         };
 
         // instrument the state so that the health requirements are met
-        sync_status.write().set_current_chain_head_epoch(i64::MAX);
-        sync_status.write().set_status(NodeSyncStatus::Syncing);
+        sync_status.write().current_head_epoch = i64::MAX;
+        sync_status.write().status = NodeSyncStatus::Syncing;
         let peer = libp2p::PeerId::random();
         peer_manager.touch_peer(&peer);
 
@@ -293,8 +293,8 @@ mod test {
 
         // instrument the state so that the health requirements are not met
         drop(rpc_listener);
-        sync_status.write().set_status(NodeSyncStatus::Error);
-        sync_status.write().set_current_chain_head_epoch(0);
+        sync_status.write().status = NodeSyncStatus::Error;
+        sync_status.write().current_head_epoch = 0;
         peer_manager.remove_peer(&peer);
 
         assert_eq!(

src/rpc/methods/eth.rs

@@ -1671,7 +1671,7 @@ impl RpcMethod<0> for EthSyncing {
     ) -> Result<Self::Ok, ServerError> {
         let sync_status: crate::chain_sync::SyncStatusReport =
             crate::rpc::sync::SyncStatus::handle(ctx, ()).await?;
-        match sync_status.get_status() {
+        match sync_status.status {
             NodeSyncStatus::Syncing => {
                 let starting_block = match sync_status.get_min_starting_block() {
                     Some(e) => Ok(e),
@@ -1684,8 +1684,8 @@ impl RpcMethod<0> for EthSyncing {
                 Ok(EthSyncingResult {
                     done_sync: sync_status.is_synced(),
                     starting_block,
-                    current_block: sync_status.get_current_chain_head_epoch(),
-                    highest_block: sync_status.get_network_head_epoch(),
+                    current_block: sync_status.current_head_epoch,
+                    highest_block: sync_status.network_head_epoch,
                 })
             }
             _ => Err(ServerError::internal_error("sync status not found", None)),

src/rpc/methods/sync.rs

@@ -105,7 +105,7 @@ impl RpcMethod<1> for SyncSubmitBlock {
         ctx: Ctx<impl Blockstore>,
         (block_msg,): Self::Params,
     ) -> Result<Self::Ok, ServerError> {
-        if !matches!(ctx.sync_status.read().get_status(), NodeSyncStatus::Synced) {
+        if !matches!(ctx.sync_status.read().status, NodeSyncStatus::Synced) {
             Err(anyhow!("the node isn't in 'follow' mode"))?
         }
         let encoded_message = to_vec(&block_msg)?;
@@ -272,8 +272,8 @@ mod tests {
         assert_eq!(sync_status, st_copy.as_ref().read().clone());
 
         // update cloned state
-        st_copy.write().set_status(NodeSyncStatus::Syncing);
-        st_copy.write().set_current_chain_head_epoch(4);
+        st_copy.write().status = NodeSyncStatus::Syncing;
+        st_copy.write().current_head_epoch = 4;
 
         let sync_status = SyncStatus::handle(ctx.clone(), ()).await.unwrap();