use { clap::{crate_name, value_t, value_t_or_exit, values_t_or_exit, App, Arg}, crossbeam_channel::unbounded, log::*, solana_clap_utils::{ input_parsers::{pubkey_of, pubkeys_of, value_of}, input_validators::{ is_parsable, is_pubkey, is_pubkey_or_keypair, is_slot, is_url_or_moniker, normalize_to_url_if_moniker, }, }, solana_core::tower_storage::FileTowerStorage, solana_faucet::faucet::{run_local_faucet_with_port, FAUCET_PORT}, solana_rpc::{ rpc::{JsonRpcConfig, RpcBigtableConfig}, rpc_pubsub_service::PubSubConfig, }, solana_rpc_client::rpc_client::RpcClient, solana_sdk::{ account::AccountSharedData, clock::Slot, epoch_schedule::{EpochSchedule, MINIMUM_SLOTS_PER_EPOCH}, native_token::sol_to_lamports, pubkey::Pubkey, rent::Rent, rpc_port, signature::{read_keypair_file, write_keypair_file, Keypair, Signer}, system_program, }, solana_streamer::socket::SocketAddrSpace, solana_test_validator::*, solana_validator::{ admin_rpc_service, dashboard::Dashboard, ledger_lockfile, lock_ledger, println_name_value, redirect_stderr_to_file, }, std::{ collections::HashSet, fs, io, net::{IpAddr, Ipv4Addr, SocketAddr}, path::{Path, PathBuf}, process::exit, sync::{Arc, RwLock}, time::{Duration, SystemTime, UNIX_EPOCH}, }, }; /* 10,000 was derived empirically by watching the size * of the rocksdb/ directory self-limit itself to the * 40MB-150MB range when running `solana-test-validator` */ const DEFAULT_MAX_LEDGER_SHREDS: u64 = 10_000; const DEFAULT_FAUCET_SOL: f64 = 1_000_000.; #[derive(PartialEq, Eq)] enum Output { None, Log, Dashboard, } fn main() { let default_rpc_port = rpc_port::DEFAULT_RPC_PORT.to_string(); let default_faucet_port = FAUCET_PORT.to_string(); let default_limit_ledger_size = DEFAULT_MAX_LEDGER_SHREDS.to_string(); let default_faucet_sol = DEFAULT_FAUCET_SOL.to_string(); let matches = App::new("solana-test-validator") .about("Test Validator") .version(solana_version::version!()) .arg({ let arg = Arg::with_name("config_file") .short("C") .long("config") .value_name("PATH") .takes_value(true) .help("Configuration file to use"); if let Some(ref config_file) = *solana_cli_config::CONFIG_FILE { arg.default_value(config_file) } else { arg } }) .arg( Arg::with_name("json_rpc_url") .short("u") .long("url") .value_name("URL_OR_MONIKER") .takes_value(true) .validator(is_url_or_moniker) .help( "URL for Solana's JSON RPC or moniker (or their first letter): \ [mainnet-beta, testnet, devnet, localhost]", ), ) .arg( Arg::with_name("mint_address") .long("mint") .value_name("PUBKEY") .validator(is_pubkey) .takes_value(true) .help( "Address of the mint account that will receive tokens \ created at genesis. If the ledger already exists then \ this parameter is silently ignored [default: client keypair]", ), ) .arg( Arg::with_name("ledger_path") .short("l") .long("ledger") .value_name("DIR") .takes_value(true) .required(true) .default_value("test-ledger") .help("Use DIR as ledger location"), ) .arg( Arg::with_name("reset") .short("r") .long("reset") .takes_value(false) .help( "Reset the ledger to genesis if it exists. \ By default the validator will resume an existing ledger (if present)", ), ) .arg( Arg::with_name("quiet") .short("q") .long("quiet") .takes_value(false) .conflicts_with("log") .help("Quiet mode: suppress normal output"), ) .arg( Arg::with_name("log") .long("log") .takes_value(false) .conflicts_with("quiet") .help("Log mode: stream the validator log"), ) .arg( Arg::with_name("faucet_port") .long("faucet-port") .value_name("PORT") .takes_value(true) .default_value(&default_faucet_port) .validator(solana_validator::port_validator) .help("Enable the faucet on this port"), ) .arg( Arg::with_name("rpc_port") .long("rpc-port") .value_name("PORT") .takes_value(true) .default_value(&default_rpc_port) .validator(solana_validator::port_validator) .help("Enable JSON RPC on this port, and the next port for the RPC websocket"), ) .arg( Arg::with_name("enable_rpc_bigtable_ledger_storage") .long("enable-rpc-bigtable-ledger-storage") .takes_value(false) .hidden(true) .help("Fetch historical transaction info from a BigTable instance \ as a fallback to local ledger data"), ) .arg( Arg::with_name("rpc_bigtable_instance") .long("rpc-bigtable-instance") .value_name("INSTANCE_NAME") .takes_value(true) .hidden(true) .default_value("solana-ledger") .help("Name of BigTable instance to target"), ) .arg( Arg::with_name("rpc_bigtable_app_profile_id") .long("rpc-bigtable-app-profile-id") .value_name("APP_PROFILE_ID") .takes_value(true) .hidden(true) .default_value(solana_storage_bigtable::DEFAULT_APP_PROFILE_ID) .help("Application profile id to use in Bigtable requests") ) .arg( Arg::with_name("rpc_pubsub_enable_vote_subscription") .long("rpc-pubsub-enable-vote-subscription") .takes_value(false) .help("Enable the unstable RPC PubSub `voteSubscribe` subscription"), ) .arg( Arg::with_name("bpf_program") .long("bpf-program") .value_names(&["ADDRESS_OR_KEYPAIR", "SBF_PROGRAM.SO"]) .takes_value(true) .number_of_values(2) .multiple(true) .help( "Add a SBF program to the genesis configuration. \ If the ledger already exists then this parameter is silently ignored. \ First argument can be a pubkey string or path to a keypair", ), ) .arg( Arg::with_name("account") .long("account") .value_names(&["ADDRESS", "DUMP.JSON"]) .takes_value(true) .number_of_values(2) .allow_hyphen_values(true) .multiple(true) .help( "Load an account from the provided JSON file (see `solana account --help` on how to dump \ an account to file). Files are searched for relatively to CWD and tests/fixtures. \ If ADDRESS is omitted via the `-` placeholder, the one in the file will be used. \ If the ledger already exists then this parameter is silently ignored", ), ) .arg( Arg::with_name("account_dir") .long("account-dir") .value_name("DIRECTORY") .validator(|value| { value .parse::() .map_err(|err| format!("error parsing '{}': {}", value, err)) .and_then(|path| { if path.exists() && path.is_dir() { Ok(()) } else { Err(format!("path does not exist or is not a directory: {}", value)) } }) }) .takes_value(true) .multiple(true) .help( "Load all the accounts from the JSON files found in the specified DIRECTORY \ (see also the `--account` flag). \ If the ledger already exists then this parameter is silently ignored", ), ) .arg( Arg::with_name("no_bpf_jit") .long("no-bpf-jit") .takes_value(false) .help("Disable the just-in-time compiler and instead use the interpreter for SBF. Windows always disables JIT."), ) .arg( Arg::with_name("ticks_per_slot") .long("ticks-per-slot") .value_name("TICKS") .validator(is_parsable::) .takes_value(true) .help("The number of ticks in a slot"), ) .arg( Arg::with_name("slots_per_epoch") .long("slots-per-epoch") .value_name("SLOTS") .validator(|value| { value .parse::() .map_err(|err| format!("error parsing '{}': {}", value, err)) .and_then(|slot| { if slot < MINIMUM_SLOTS_PER_EPOCH { Err(format!("value must be >= {}", MINIMUM_SLOTS_PER_EPOCH)) } else { Ok(()) } }) }) .takes_value(true) .help( "Override the number of slots in an epoch. \ If the ledger already exists then this parameter is silently ignored", ), ) .arg( Arg::with_name("gossip_port") .long("gossip-port") .value_name("PORT") .takes_value(true) .help("Gossip port number for the validator"), ) .arg( Arg::with_name("gossip_host") .long("gossip-host") .value_name("HOST") .takes_value(true) .validator(solana_net_utils::is_host) .help( "Gossip DNS name or IP address for the validator to advertise in gossip \ [default: 127.0.0.1]", ), ) .arg( Arg::with_name("dynamic_port_range") .long("dynamic-port-range") .value_name("MIN_PORT-MAX_PORT") .takes_value(true) .validator(solana_validator::port_range_validator) .help( "Range to use for dynamically assigned ports \ [default: 1024-65535]", ), ) .arg( Arg::with_name("bind_address") .long("bind-address") .value_name("HOST") .takes_value(true) .validator(solana_net_utils::is_host) .default_value("0.0.0.0") .help("IP address to bind the validator ports [default: 0.0.0.0]"), ) .arg( Arg::with_name("clone_account") .long("clone") .short("c") .value_name("ADDRESS") .takes_value(true) .validator(is_pubkey_or_keypair) .multiple(true) .requires("json_rpc_url") .help( "Copy an account from the cluster referenced by the --url argument the \ genesis configuration. \ If the ledger already exists then this parameter is silently ignored", ), ) .arg( Arg::with_name("maybe_clone_account") .long("maybe-clone") .value_name("ADDRESS") .takes_value(true) .validator(is_pubkey_or_keypair) .multiple(true) .requires("json_rpc_url") .help( "Copy an account from the cluster referenced by the --url argument, \ skipping it if it doesn't exist. \ If the ledger already exists then this parameter is silently ignored", ), ) .arg( Arg::with_name("warp_slot") .required(false) .long("warp-slot") .short("w") .takes_value(true) .value_name("WARP_SLOT") .validator(is_slot) .min_values(0) .max_values(1) .help( "Warp the ledger to WARP_SLOT after starting the validator. \ If no slot is provided then the current slot of the cluster \ referenced by the --url argument will be used", ), ) .arg( Arg::with_name("limit_ledger_size") .long("limit-ledger-size") .value_name("SHRED_COUNT") .takes_value(true) .default_value(default_limit_ledger_size.as_str()) .help("Keep this amount of shreds in root slots."), ) .arg( Arg::with_name("faucet_sol") .long("faucet-sol") .takes_value(true) .value_name("SOL") .default_value(default_faucet_sol.as_str()) .help( "Give the faucet address this much SOL in genesis. \ If the ledger already exists then this parameter is silently ignored", ), ) .arg( Arg::with_name("geyser_plugin_config") .long("geyser-plugin-config") .alias("accountsdb-plugin-config") .value_name("FILE") .takes_value(true) .multiple(true) .help("Specify the configuration file for the Geyser plugin."), ) .arg( Arg::with_name("no_accounts_db_caching") .long("no-accounts-db-caching") .help("Disables accounts caching"), ) .arg( Arg::with_name("deactivate_feature") .long("deactivate-feature") .takes_value(true) .value_name("FEATURE_PUBKEY") .validator(is_pubkey) .multiple(true) .help("deactivate this feature in genesis.") ) .arg( Arg::with_name("compute_unit_limit") .long("compute-unit-limit") .alias("max-compute-units") .value_name("COMPUTE_UNITS") .validator(is_parsable::) .takes_value(true) .help("Override the runtime's compute unit limit per transaction") ) .arg( Arg::with_name("log_messages_bytes_limit") .long("log-messages-bytes-limit") .value_name("BYTES") .validator(is_parsable::) .takes_value(true) .help("Maximum number of bytes written to the program log before truncation") ) .arg( Arg::with_name("transaction_account_lock_limit") .long("transaction-account-lock-limit") .value_name("NUM_ACCOUNTS") .validator(is_parsable::) .takes_value(true) .help("Override the runtime's account lock limit per transaction") ) .get_matches(); let output = if matches.is_present("quiet") { Output::None } else if matches.is_present("log") { Output::Log } else { Output::Dashboard }; let ledger_path = value_t_or_exit!(matches, "ledger_path", PathBuf); let reset_ledger = matches.is_present("reset"); if !ledger_path.exists() { fs::create_dir(&ledger_path).unwrap_or_else(|err| { println!( "Error: Unable to create directory {}: {}", ledger_path.display(), err ); exit(1); }); } let mut ledger_lock = ledger_lockfile(&ledger_path); let _ledger_write_guard = lock_ledger(&ledger_path, &mut ledger_lock); if reset_ledger { remove_directory_contents(&ledger_path).unwrap_or_else(|err| { println!("Error: Unable to remove {}: {}", ledger_path.display(), err); exit(1); }) } solana_runtime::snapshot_utils::remove_tmp_snapshot_archives(&ledger_path); let validator_log_symlink = ledger_path.join("validator.log"); let logfile = if output != Output::Log { let validator_log_with_timestamp = format!( "validator-{}.log", SystemTime::now() .duration_since(UNIX_EPOCH) .unwrap() .as_millis() ); let _ = fs::remove_file(&validator_log_symlink); symlink::symlink_file(&validator_log_with_timestamp, &validator_log_symlink).unwrap(); Some( ledger_path .join(validator_log_with_timestamp) .into_os_string() .into_string() .unwrap(), ) } else { None }; let _logger_thread = redirect_stderr_to_file(logfile); info!("{} {}", crate_name!(), solana_version::version!()); info!("Starting validator with: {:#?}", std::env::args_os()); solana_core::validator::report_target_features(); // TODO: Ideally test-validator should *only* allow private addresses. let socket_addr_space = SocketAddrSpace::new(/*allow_private_addr=*/ true); let cli_config = if let Some(config_file) = matches.value_of("config_file") { solana_cli_config::Config::load(config_file).unwrap_or_default() } else { solana_cli_config::Config::default() }; let cluster_rpc_client = value_t!(matches, "json_rpc_url", String) .map(normalize_to_url_if_moniker) .map(RpcClient::new); let (mint_address, random_mint) = pubkey_of(&matches, "mint_address") .map(|pk| (pk, false)) .unwrap_or_else(|| { read_keypair_file(&cli_config.keypair_path) .map(|kp| (kp.pubkey(), false)) .unwrap_or_else(|_| (Keypair::new().pubkey(), true)) }); let rpc_port = value_t_or_exit!(matches, "rpc_port", u16); let enable_vote_subscription = matches.is_present("rpc_pubsub_enable_vote_subscription"); let faucet_port = value_t_or_exit!(matches, "faucet_port", u16); let ticks_per_slot = value_t!(matches, "ticks_per_slot", u64).ok(); let slots_per_epoch = value_t!(matches, "slots_per_epoch", Slot).ok(); let gossip_host = matches.value_of("gossip_host").map(|gossip_host| { solana_net_utils::parse_host(gossip_host).unwrap_or_else(|err| { eprintln!("Failed to parse --gossip-host: {}", err); exit(1); }) }); let gossip_port = value_t!(matches, "gossip_port", u16).ok(); let dynamic_port_range = matches.value_of("dynamic_port_range").map(|port_range| { solana_net_utils::parse_port_range(port_range).unwrap_or_else(|| { eprintln!("Failed to parse --dynamic-port-range"); exit(1); }) }); let bind_address = matches.value_of("bind_address").map(|bind_address| { solana_net_utils::parse_host(bind_address).unwrap_or_else(|err| { eprintln!("Failed to parse --bind-address: {}", err); exit(1); }) }); let compute_unit_limit = value_t!(matches, "compute_unit_limit", u64).ok(); let faucet_addr = Some(SocketAddr::new( IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), faucet_port, )); let mut programs_to_load = vec![]; if let Some(values) = matches.values_of("bpf_program") { let values: Vec<&str> = values.collect::>(); for address_program in values.chunks(2) { match address_program { [address, program] => { let address = address .parse::() .or_else(|_| read_keypair_file(address).map(|keypair| keypair.pubkey())) .unwrap_or_else(|err| { println!("Error: invalid address {}: {}", address, err); exit(1); }); let program_path = PathBuf::from(program); if !program_path.exists() { println!( "Error: program file does not exist: {}", program_path.display() ); exit(1); } programs_to_load.push(ProgramInfo { program_id: address, loader: solana_sdk::bpf_loader::id(), program_path, }); } _ => unreachable!(), } } } let mut accounts_to_load = vec![]; if let Some(values) = matches.values_of("account") { let values: Vec<&str> = values.collect::>(); for address_filename in values.chunks(2) { match address_filename { [address, filename] => { let address = if *address == "-" { None } else { Some(address.parse::().unwrap_or_else(|err| { println!("Error: invalid address {}: {}", address, err); exit(1); })) }; accounts_to_load.push(AccountInfo { address, filename }); } _ => unreachable!(), } } } let accounts_from_dirs: HashSet<_> = matches .values_of("account_dir") .unwrap_or_default() .collect(); let accounts_to_clone: HashSet<_> = pubkeys_of(&matches, "clone_account") .map(|v| v.into_iter().collect()) .unwrap_or_default(); let accounts_to_maybe_clone: HashSet<_> = pubkeys_of(&matches, "maybe_clone_account") .map(|v| v.into_iter().collect()) .unwrap_or_default(); let warp_slot = if matches.is_present("warp_slot") { Some(match matches.value_of("warp_slot") { Some(_) => value_t_or_exit!(matches, "warp_slot", Slot), None => { cluster_rpc_client.as_ref().unwrap_or_else(|_| { println!("The --url argument must be provided if --warp-slot/-w is used without an explicit slot"); exit(1); }).get_slot() .unwrap_or_else(|err| { println!("Unable to get current cluster slot: {}", err); exit(1); }) } }) } else { None }; let faucet_lamports = sol_to_lamports(value_of(&matches, "faucet_sol").unwrap()); let faucet_keypair_file = ledger_path.join("faucet-keypair.json"); if !faucet_keypair_file.exists() { write_keypair_file(&Keypair::new(), faucet_keypair_file.to_str().unwrap()).unwrap_or_else( |err| { println!( "Error: Failed to write {}: {}", faucet_keypair_file.display(), err ); exit(1); }, ); } let faucet_keypair = read_keypair_file(faucet_keypair_file.to_str().unwrap()).unwrap_or_else(|err| { println!( "Error: Failed to read {}: {}", faucet_keypair_file.display(), err ); exit(1); }); let faucet_pubkey = faucet_keypair.pubkey(); if let Some(faucet_addr) = &faucet_addr { let (sender, receiver) = unbounded(); run_local_faucet_with_port(faucet_keypair, sender, None, faucet_addr.port()); let _ = receiver.recv().expect("run faucet").unwrap_or_else(|err| { println!("Error: failed to start faucet: {}", err); exit(1); }); } let features_to_deactivate = pubkeys_of(&matches, "deactivate_feature").unwrap_or_default(); if TestValidatorGenesis::ledger_exists(&ledger_path) { for (name, long) in &[ ("bpf_program", "--bpf-program"), ("clone_account", "--clone"), ("account", "--account"), ("mint_address", "--mint"), ("ticks_per_slot", "--ticks-per-slot"), ("slots_per_epoch", "--slots-per-epoch"), ("faucet_sol", "--faucet-sol"), ("deactivate_feature", "--deactivate-feature"), ] { if matches.is_present(name) { println!("{} argument ignored, ledger already exists", long); } } } else if random_mint { println_name_value( "\nNotice!", "No wallet available. `solana airdrop` localnet SOL after creating one\n", ); } let mut genesis = TestValidatorGenesis::default(); genesis.max_ledger_shreds = value_of(&matches, "limit_ledger_size"); genesis.max_genesis_archive_unpacked_size = Some(u64::MAX); genesis.accounts_db_caching_enabled = !matches.is_present("no_accounts_db_caching"); genesis.log_messages_bytes_limit = value_t!(matches, "log_messages_bytes_limit", usize).ok(); genesis.transaction_account_lock_limit = value_t!(matches, "transaction_account_lock_limit", usize).ok(); let tower_storage = Arc::new(FileTowerStorage::new(ledger_path.clone())); let admin_service_post_init = Arc::new(RwLock::new(None)); admin_rpc_service::run( &ledger_path, admin_rpc_service::AdminRpcRequestMetadata { rpc_addr: Some(SocketAddr::new( IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), rpc_port, )), start_progress: genesis.start_progress.clone(), start_time: std::time::SystemTime::now(), validator_exit: genesis.validator_exit.clone(), authorized_voter_keypairs: genesis.authorized_voter_keypairs.clone(), staked_nodes_overrides: genesis.staked_nodes_overrides.clone(), post_init: admin_service_post_init.clone(), tower_storage: tower_storage.clone(), }, ); let dashboard = if output == Output::Dashboard { Some( Dashboard::new( &ledger_path, Some(&validator_log_symlink), Some(&mut genesis.validator_exit.write().unwrap()), ) .unwrap(), ) } else { None }; let rpc_bigtable_config = if matches.is_present("enable_rpc_bigtable_ledger_storage") { Some(RpcBigtableConfig { enable_bigtable_ledger_upload: false, bigtable_instance_name: value_t_or_exit!(matches, "rpc_bigtable_instance", String), bigtable_app_profile_id: value_t_or_exit!( matches, "rpc_bigtable_app_profile_id", String ), timeout: None, }) } else { None }; genesis .ledger_path(&ledger_path) .tower_storage(tower_storage) .add_account( faucet_pubkey, AccountSharedData::new(faucet_lamports, 0, &system_program::id()), ) .rpc_config(JsonRpcConfig { enable_rpc_transaction_history: true, enable_extended_tx_metadata_storage: true, rpc_bigtable_config, faucet_addr, ..JsonRpcConfig::default_for_test() }) .pubsub_config(PubSubConfig { enable_vote_subscription, ..PubSubConfig::default() }) .bpf_jit(!matches.is_present("no_bpf_jit")) .rpc_port(rpc_port) .add_programs_with_path(&programs_to_load) .add_accounts_from_json_files(&accounts_to_load) .unwrap_or_else(|e| { println!("Error: add_accounts_from_json_files failed: {}", e); exit(1); }) .add_accounts_from_directories(&accounts_from_dirs) .unwrap_or_else(|e| { println!("Error: add_accounts_from_directories failed: {}", e); exit(1); }) .deactivate_features(&features_to_deactivate); if !accounts_to_clone.is_empty() { if let Err(e) = genesis.clone_accounts( accounts_to_clone, cluster_rpc_client .as_ref() .expect("bug: --url argument missing?"), false, ) { println!("Error: clone_accounts failed: {}", e); exit(1); } } if !accounts_to_maybe_clone.is_empty() { if let Err(e) = genesis.clone_accounts( accounts_to_maybe_clone, cluster_rpc_client .as_ref() .expect("bug: --url argument missing?"), true, ) { println!("Error: clone_accounts failed: {}", e); exit(1); } } if let Some(warp_slot) = warp_slot { genesis.warp_slot(warp_slot); } if let Some(ticks_per_slot) = ticks_per_slot { genesis.ticks_per_slot(ticks_per_slot); } if let Some(slots_per_epoch) = slots_per_epoch { genesis.epoch_schedule(EpochSchedule::custom( slots_per_epoch, slots_per_epoch, /* enable_warmup_epochs = */ false, )); genesis.rent = Rent::with_slots_per_epoch(slots_per_epoch); } if let Some(gossip_host) = gossip_host { genesis.gossip_host(gossip_host); } if let Some(gossip_port) = gossip_port { genesis.gossip_port(gossip_port); } if let Some(dynamic_port_range) = dynamic_port_range { genesis.port_range(dynamic_port_range); } if let Some(bind_address) = bind_address { genesis.bind_ip_addr(bind_address); } if matches.is_present("geyser_plugin_config") { genesis.geyser_plugin_config_files = Some( values_t_or_exit!(matches, "geyser_plugin_config", String) .into_iter() .map(PathBuf::from) .collect(), ); } if let Some(compute_unit_limit) = compute_unit_limit { genesis.compute_unit_limit(compute_unit_limit); } match genesis.start_with_mint_address(mint_address, socket_addr_space) { Ok(test_validator) => { *admin_service_post_init.write().unwrap() = Some(admin_rpc_service::AdminRpcRequestMetadataPostInit { bank_forks: test_validator.bank_forks(), cluster_info: test_validator.cluster_info(), vote_account: test_validator.vote_account_address(), }); if let Some(dashboard) = dashboard { dashboard.run(Duration::from_millis(250)); } test_validator.join(); } Err(err) => { drop(dashboard); println!("Error: failed to start validator: {}", err); exit(1); } } } fn remove_directory_contents(ledger_path: &Path) -> Result<(), io::Error> { for entry in fs::read_dir(ledger_path)? { let entry = entry?; if entry.metadata()?.is_dir() { fs::remove_dir_all(entry.path())? } else { fs::remove_file(entry.path())? } } Ok(()) }