Add wen_restart module

Cargo.toml

@@ -111,6 +111,7 @@ members = [
     "version",
     "vote",
     "watchtower",
+    "wen-restart",
     "zk-keygen",
     "zk-token-sdk",
 ]
@@ -370,6 +371,7 @@ solana-udp-client = { path = "udp-client", version = "=1.17.0" }
 solana-version = { path = "version", version = "=1.17.0" }
 solana-vote = { path = "vote", version = "=1.17.0" }
 solana-vote-program = { path = "programs/vote", version = "=1.17.0" }
+solana-wen-restart = { path = "wen-restart", version = "=1.17.0" }
 solana-zk-keygen = { path = "zk-keygen", version = "=1.17.0" }
 solana-zk-token-proof-program = { path = "programs/zk-token-proof", version = "=1.17.0" }
 solana-zk-token-sdk = { path = "zk-token-sdk", version = "=1.17.0" }

core/Cargo.toml

@@ -71,6 +71,7 @@ solana-turbine = { workspace = true }
 solana-version = { workspace = true }
 solana-vote = { workspace = true }
 solana-vote-program = { workspace = true }
+solana-wen-restart = { workspace = true }
 strum = { workspace = true, features = ["derive"] }
 strum_macros = { workspace = true }
 sys-info = { workspace = true }

core/src/replay_stage.rs

@@ -29,7 +29,6 @@ use {
         },
         rewards_recorder_service::{RewardsMessage, RewardsRecorderSender},
         unfrozen_gossip_verified_vote_hashes::UnfrozenGossipVerifiedVoteHashes,
-        validator::ProcessBlockStore,
         voting_service::VoteOp,
         window_service::DuplicateSlotReceiver,
     },
@@ -483,7 +482,7 @@ impl ReplayStage {
         ledger_signal_receiver: Receiver<bool>,
         duplicate_slots_receiver: DuplicateSlotReceiver,
         poh_recorder: Arc<RwLock<PohRecorder>>,
-        maybe_process_blockstore: Option<ProcessBlockStore>,
+        maybe_tower: Option<Tower>,
         vote_tracker: Arc<VoteTracker>,
         cluster_slots: Arc<ClusterSlots>,
         retransmit_slots_sender: Sender<Slot>,
@@ -502,13 +501,15 @@ impl ReplayStage {
         banking_tracer: Arc<BankingTracer>,
         popular_pruned_forks_receiver: PopularPrunedForksReceiver,
     ) -> Result<Self, String> {
-        let mut tower = if let Some(process_blockstore) = maybe_process_blockstore {
-            let tower = process_blockstore.process_to_create_tower()?;
-            info!("Tower state: {:?}", tower);
-            tower
-        } else {
-            warn!("creating default tower....");
-            Tower::default()
+        let mut tower = match maybe_tower {
+            Some(tower) => {
+                info!("Tower state: {:?}", tower);
+                tower
+            }
+            None => {
+                warn!("creating default tower....");
+                Tower::default()
+            }
         };
 
         let ReplayStageConfig {

core/src/tvu.rs

@@ -11,15 +11,14 @@ use {
         },
         cluster_slots_service::{cluster_slots::ClusterSlots, ClusterSlotsService},
         completed_data_sets_service::CompletedDataSetsSender,
-        consensus::tower_storage::TowerStorage,
+        consensus::{tower_storage::TowerStorage, Tower},
         cost_update_service::CostUpdateService,
         drop_bank_service::DropBankService,
         ledger_cleanup_service::LedgerCleanupService,
         repair::{quic_endpoint::LocalRequest, repair_service::RepairInfo},
         replay_stage::{ReplayStage, ReplayStageConfig},
         rewards_recorder_service::RewardsRecorderSender,
         shred_fetch_stage::ShredFetchStage,
-        validator::ProcessBlockStore,
         voting_service::VotingService,
         warm_quic_cache_service::WarmQuicCacheService,
         window_service::WindowService,
@@ -109,7 +108,7 @@ impl Tvu {
         ledger_signal_receiver: Receiver<bool>,
         rpc_subscriptions: &Arc<RpcSubscriptions>,
         poh_recorder: &Arc<RwLock<PohRecorder>>,
-        maybe_process_block_store: Option<ProcessBlockStore>,
+        maybe_tower: Option<Tower>,
         tower_storage: Arc<dyn TowerStorage>,
         leader_schedule_cache: &Arc<LeaderScheduleCache>,
         exit: Arc<AtomicBool>,
@@ -292,7 +291,7 @@ impl Tvu {
             ledger_signal_receiver,
             duplicate_slots_receiver,
             poh_recorder.clone(),
-            maybe_process_block_store,
+            maybe_tower,
             vote_tracker,
             cluster_slots,
             retransmit_slots_sender,

core/src/validator.rs

@@ -119,6 +119,7 @@ use {
     solana_streamer::{socket::SocketAddrSpace, streamer::StakedNodes},
     solana_turbine::{self, broadcast_stage::BroadcastStageType},
     solana_vote_program::vote_state,
+    solana_wen_restart::wen_restart::wait_for_wen_restart,
     std::{
         collections::{HashMap, HashSet},
         net::SocketAddr,
@@ -259,6 +260,7 @@ pub struct ValidatorConfig {
     pub block_production_method: BlockProductionMethod,
     pub generator_config: Option<GeneratorConfig>,
     pub use_snapshot_archives_at_startup: UseSnapshotArchivesAtStartup,
+    pub wen_restart_proto_path: Option<PathBuf>,
 }
 
 impl Default for ValidatorConfig {
@@ -326,6 +328,7 @@ impl Default for ValidatorConfig {
             block_production_method: BlockProductionMethod::default(),
             generator_config: None,
             use_snapshot_archives_at_startup: UseSnapshotArchivesAtStartup::default(),
+            wen_restart_proto_path: None,
         }
     }
 }
@@ -1202,6 +1205,10 @@ impl Validator {
             )
             .unwrap();
 
+        let in_wen_restart = config.wen_restart_proto_path.is_some() && !waited_for_supermajority;
+        let tower = process_blockstore.process_to_create_tower()?;
+        let last_vote = tower.last_vote();
+
         let (replay_vote_sender, replay_vote_receiver) = unbounded();
         let tvu = Tvu::new(
             vote_account,
@@ -1218,7 +1225,7 @@ impl Validator {
             ledger_signal_receiver,
             &rpc_subscriptions,
             &poh_recorder,
-            Some(process_blockstore),
+            Some(tower),
             config.tower_storage.clone(),
             &leader_schedule_cache,
             exit.clone(),
@@ -1257,6 +1264,24 @@ impl Validator {
             repair_quic_endpoint_sender,
         )?;
 
+        if in_wen_restart {
+            info!("Waiting for wen_restart phase one to finish");
+            match wait_for_wen_restart(
+                &config.wen_restart_proto_path.clone().unwrap(),
+                last_vote,
+                blockstore.clone(),
+                cluster_info.clone(),
+            ) {
+                Ok(()) => {
+                    return Err(
+                        "wen_restart phase one completed, will restart to wait for supermajority"
+                            .to_string(),
+                    );
+                }
+                Err(e) => return Err(format!("wait_for_wen_restart failed: {e:?}")),
+            };
+        }
+
         let tpu = Tpu::new(
             &cluster_info,
             &poh_recorder,

local-cluster/src/validator_configs.rs

@@ -68,6 +68,7 @@ pub fn safe_clone_config(config: &ValidatorConfig) -> ValidatorConfig {
         block_production_method: config.block_production_method.clone(),
         generator_config: config.generator_config.clone(),
         use_snapshot_archives_at_startup: config.use_snapshot_archives_at_startup,
+        wen_restart_proto_path: config.wen_restart_proto_path.clone(),
     }
 }
 

validator/src/cli.rs

@@ -1373,6 +1373,25 @@ pub fn app<'a>(version: &'a str, default_args: &'a DefaultArgs) -> App<'a, 'a> {
                 .possible_values(BlockProductionMethod::cli_names())
                 .help(BlockProductionMethod::cli_message())
         )
+        .arg(
+            Arg::with_name("wen_restart")
+                .long("wen-restart")
+                .value_name("DIR")
+                .takes_value(true)
+                .required(false)
+                .default_value(&default_args.wen_restart_path)
+                .conflicts_with("wait_for_supermajority")
+                .help(
+                    "When specified, make validator enter Wen Restart, where it doesn't
+                    vote, create new blocks, or transmit new blocks. The only thing it
+                    does is Gossip last vote information with other validators in Wen
+                    Restart and figure out whether consensus can be reached to proceed
+                    into a cluster restart.
+                    The progress will be saved in the file location provided. When all is
+                    done, exit the validator and use the progress and snapshot generated
+                    previously to enter wait_for_supermajority mode automatically.
+                ")
+        )
         .args(&get_deprecated_arguments())
         .after_help("The default subcommand is run")
         .subcommand(
@@ -1922,6 +1941,8 @@ pub struct DefaultArgs {
     pub wait_for_restart_window_max_delinquent_stake: String,
 
     pub banking_trace_dir_byte_limit: String,
+
+    pub wen_restart_path: String,
 }
 
 impl DefaultArgs {
@@ -2000,6 +2021,7 @@ impl DefaultArgs {
             wait_for_restart_window_min_idle_time: "10".to_string(),
             wait_for_restart_window_max_delinquent_stake: "5".to_string(),
             banking_trace_dir_byte_limit: BANKING_TRACE_DIR_DEFAULT_BYTE_LIMIT.to_string(),
+            wen_restart_path: "wen_restart_progress.proto".to_string(),
         }
     }
 }

wen-restart/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "solana-wen-restart"
+description = "Automatically repair and restart protocol"
+documentation = "https://github.com/solana-foundation/solana-improvement-documents/pull/46"
+version = { workspace = true }
+authors = { workspace = true }
+repository = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+edition = { workspace = true }
+publish = false
+
+[dependencies]
+log = { workspace = true }
+prost = { workspace = true }
+prost-types = { workspace = true }
+solana-gossip = { workspace = true }
+solana-ledger = { workspace = true }
+solana-logger = { workspace = true }
+solana-program = { workspace = true }
+solana-runtime = { workspace = true }
+solana-sdk = { workspace = true }
+solana-vote-program = { workspace = true }
+
+[dev-dependencies]
+serial_test = { workspace = true }
+solana-entry = { workspace = true }
+solana-streamer = { workspace = true }
+
+[build-dependencies]
+prost-build = "0.11.4"
+rustc_version = { workspace = true }
+
+# windows users should install the protobuf compiler manually and set the PROTOC
+# envar to point to the installed binary
+[target."cfg(not(windows))".build-dependencies]
+protobuf-src = { workspace = true }
+
+[lib]
+name = "solana_wen_restart"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

wen-restart/build.rs

@@ -0,0 +1,41 @@
+extern crate rustc_version;
+
+use {
+    rustc_version::{version_meta, Channel},
+    std::io::Result,
+};
+
+fn main() -> Result<()> {
+    const PROTOC_ENVAR: &str = "PROTOC";
+    if std::env::var(PROTOC_ENVAR).is_err() {
+        #[cfg(not(windows))]
+        std::env::set_var(PROTOC_ENVAR, protobuf_src::protoc());
+    }
+
+    // Copied and adapted from
+    // https://github.com/Kimundi/rustc-version-rs/blob/1d692a965f4e48a8cb72e82cda953107c0d22f47/README.md#example
+    // Licensed under Apache-2.0 + MIT
+    match version_meta().unwrap().channel {
+        Channel::Stable => {
+            println!("cargo:rustc-cfg=RUSTC_WITHOUT_SPECIALIZATION");
+        }
+        Channel::Beta => {
+            println!("cargo:rustc-cfg=RUSTC_WITHOUT_SPECIALIZATION");
+        }
+        Channel::Nightly => {
+            println!("cargo:rustc-cfg=RUSTC_WITH_SPECIALIZATION");
+        }
+        Channel::Dev => {
+            println!("cargo:rustc-cfg=RUSTC_WITH_SPECIALIZATION");
+            // See https://github.com/solana-labs/solana/issues/11055
+            // We may be running the custom `rust-bpf-builder` toolchain,
+            // which currently needs `#![feature(proc_macro_hygiene)]` to
+            // be applied.
+            println!("cargo:rustc-cfg=RUSTC_NEEDS_PROC_MACRO_HYGIENE");
+        }
+    }
+
+    // Generate rust files from protos.
+    prost_build::compile_protos(&["protos/wen_restart.proto"], &["protos/"])?;
+    Ok(())
+}