gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove rpc_banks from validator (#13882)

Browse Source 
* Remove rpc_banks from validator

* Bump abi-digest
This commit is contained in:
Tyera Eulberg 2020-12-01 20:25:09 -07:00 committed by GitHub
parent 8c40dd34b2
commit 10c81a2448
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 76 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
cli-config/src/config.rs
View File

@ -76,17 +76,6 @@ impl Config {
ws_url.to_string() ws_url.to_string()
} }
pub fn compute_rpc_banks_url(json_rpc_url: &str) -> String {
let json_rpc_url: Option<Url> = json_rpc_url.parse().ok();
if json_rpc_url.is_none() {
return "".to_string();
}
let mut url = json_rpc_url.unwrap();
let port = url.port().unwrap_or(8899);
url.set_port(Some(port + 3)).expect("unable to set port");
url.to_string()
}
pub fn import_address_labels<P>(&mut self, filename: P) -> Result<(), io::Error> pub fn import_address_labels<P>(&mut self, filename: P) -> Result<(), io::Error>
where where
P: AsRef<Path>, P: AsRef<Path>,
@ -133,28 +122,4 @@ mod test {
assert_eq!(Config::compute_websocket_url(&"garbage"), String::new()); assert_eq!(Config::compute_websocket_url(&"garbage"), String::new());
} }
#[test]
fn compute_rpc_banks_url() {
assert_eq!(
Config::compute_rpc_banks_url(&"http://devnet.solana.com"),
"http://devnet.solana.com:8902/".to_string()
);
assert_eq!(
Config::compute_rpc_banks_url(&"https://devnet.solana.com"),
"https://devnet.solana.com:8902/".to_string()
);
assert_eq!(
Config::compute_rpc_banks_url(&"http://example.com:8899"),
"http://example.com:8902/".to_string()
);
assert_eq!(
Config::compute_rpc_banks_url(&"https://example.com:1234"),
"https://example.com:1237/".to_string()
);
assert_eq!(Config::compute_rpc_banks_url(&"garbage"), String::new());
}
} }

17
core/src/cluster_info.rs
View File

@ -424,7 +424,7 @@ pub fn make_accounts_hashes_message(
type Ping = ping_pong::Ping<[u8; GOSSIP_PING_TOKEN_SIZE]>; type Ping = ping_pong::Ping<[u8; GOSSIP_PING_TOKEN_SIZE]>;
// TODO These messages should go through the gpu pipeline for spam filtering // TODO These messages should go through the gpu pipeline for spam filtering
#[frozen_abi(digest = "3jHXixLRv6fuCykW47hBZSwFuwDjbZShR73GVQB6TjGr")] #[frozen_abi(digest = "8L3mKuv292LTa3XFCGNVdaFihWnsgYE4hf941p9gqUxF")]
#[derive(Serialize, Deserialize, Debug, AbiEnumVisitor, AbiExample)] #[derive(Serialize, Deserialize, Debug, AbiEnumVisitor, AbiExample)]
#[allow(clippy::large_enum_variant)] #[allow(clippy::large_enum_variant)]
enum Protocol { enum Protocol {
@ -720,7 +720,7 @@ impl ClusterInfo {
let rpc_addr = node.rpc.ip(); let rpc_addr = node.rpc.ip();
Some(format!( Some(format!(
"{:15} {:2}| {:5} | {:44} |{:^9}| {:5}| {:5}| {:5}| {}\n", "{:15} {:2}| {:5} | {:44} |{:^9}| {:5}| {:5}| {}\n",
rpc_addr.to_string(), rpc_addr.to_string(),
if node.id == my_pubkey { "me" } else { "" }.to_string(), if node.id == my_pubkey { "me" } else { "" }.to_string(),
now.saturating_sub(last_updated), now.saturating_sub(last_updated),
@ -732,7 +732,6 @@ impl ClusterInfo {
}, },
addr_to_string(&rpc_addr, &node.rpc), addr_to_string(&rpc_addr, &node.rpc),
addr_to_string(&rpc_addr, &node.rpc_pubsub), addr_to_string(&rpc_addr, &node.rpc_pubsub),
addr_to_string(&rpc_addr, &node.rpc_banks),
node.shred_version, node.shred_version,
)) ))
}) })
@ -740,9 +739,9 @@ impl ClusterInfo {
format!( format!(
"RPC Address |Age(ms)| Node identifier \ "RPC Address |Age(ms)| Node identifier \
| Version | RPC |PubSub| Banks|ShredVer\n\ | Version | RPC |PubSub|ShredVer\n\
------------------+-------+----------------------------------------------+---------+\ ------------------+-------+----------------------------------------------+---------+\
------+------+------+--------\n\ ------+------+--------\n\
{}\ {}\
RPC Enabled Nodes: {}", RPC Enabled Nodes: {}",
nodes.join(""), nodes.join(""),
@ -3000,13 +2999,11 @@ impl Node {
let rpc_pubsub_port = find_available_port_in_range(bind_ip_addr, (1024, 65535)).unwrap(); let rpc_pubsub_port = find_available_port_in_range(bind_ip_addr, (1024, 65535)).unwrap();
let rpc_pubsub_addr = let rpc_pubsub_addr =
SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), rpc_pubsub_port); SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), rpc_pubsub_port);
let rpc_banks_port = find_available_port_in_range(bind_ip_addr, (1024, 65535)).unwrap();
let rpc_banks_addr =
SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), rpc_banks_port);
let broadcast = vec![UdpSocket::bind("0.0.0.0:0").unwrap()]; let broadcast = vec![UdpSocket::bind("0.0.0.0:0").unwrap()];
let retransmit_socket = UdpSocket::bind("0.0.0.0:0").unwrap(); let retransmit_socket = UdpSocket::bind("0.0.0.0:0").unwrap();
let serve_repair = UdpSocket::bind("127.0.0.1:0").unwrap(); let serve_repair = UdpSocket::bind("127.0.0.1:0").unwrap();
let unused = UdpSocket::bind("0.0.0.0:0").unwrap();
let info = ContactInfo { let info = ContactInfo {
id: *pubkey, id: *pubkey,
gossip: gossip_addr, gossip: gossip_addr,
@ -3015,7 +3012,7 @@ impl Node {
repair: repair.local_addr().unwrap(), repair: repair.local_addr().unwrap(),
tpu: tpu.local_addr().unwrap(), tpu: tpu.local_addr().unwrap(),
tpu_forwards: tpu_forwards.local_addr().unwrap(), tpu_forwards: tpu_forwards.local_addr().unwrap(),
rpc_banks: rpc_banks_addr, unused: unused.local_addr().unwrap(),
rpc: rpc_addr, rpc: rpc_addr,
rpc_pubsub: rpc_pubsub_addr, rpc_pubsub: rpc_pubsub_addr,
serve_repair: serve_repair.local_addr().unwrap(), serve_repair: serve_repair.local_addr().unwrap(),
@ -3096,7 +3093,7 @@ impl Node {
repair: SocketAddr::new(gossip_addr.ip(), repair_port), repair: SocketAddr::new(gossip_addr.ip(), repair_port),
tpu: SocketAddr::new(gossip_addr.ip(), tpu_port), tpu: SocketAddr::new(gossip_addr.ip(), tpu_port),
tpu_forwards: SocketAddr::new(gossip_addr.ip(), tpu_forwards_port), tpu_forwards: SocketAddr::new(gossip_addr.ip(), tpu_forwards_port),
rpc_banks: socketaddr_any!(), unused: socketaddr_any!(),
rpc: socketaddr_any!(), rpc: socketaddr_any!(),
rpc_pubsub: socketaddr_any!(), rpc_pubsub: socketaddr_any!(),
serve_repair: SocketAddr::new(gossip_addr.ip(), serve_repair_port), serve_repair: SocketAddr::new(gossip_addr.ip(), serve_repair_port),

23
core/src/contact_info.rs
View File

@ -26,7 +26,7 @@ pub struct ContactInfo {
/// address to forward unprocessed transactions to /// address to forward unprocessed transactions to
pub tpu_forwards: SocketAddr, pub tpu_forwards: SocketAddr,
/// address to which to send bank state requests /// address to which to send bank state requests
pub rpc_banks: SocketAddr, pub unused: SocketAddr,
/// address to which to send JSON-RPC requests /// address to which to send JSON-RPC requests
pub rpc: SocketAddr, pub rpc: SocketAddr,
/// websocket for JSON-RPC push notifications /// websocket for JSON-RPC push notifications
@ -95,7 +95,7 @@ impl Default for ContactInfo {
repair: socketaddr_any!(), repair: socketaddr_any!(),
tpu: socketaddr_any!(), tpu: socketaddr_any!(),
tpu_forwards: socketaddr_any!(), tpu_forwards: socketaddr_any!(),
rpc_banks: socketaddr_any!(), unused: socketaddr_any!(),
rpc: socketaddr_any!(), rpc: socketaddr_any!(),
rpc_pubsub: socketaddr_any!(), rpc_pubsub: socketaddr_any!(),
serve_repair: socketaddr_any!(), serve_repair: socketaddr_any!(),
@ -115,7 +115,7 @@ impl ContactInfo {
repair: socketaddr!("127.0.0.1:1237"), repair: socketaddr!("127.0.0.1:1237"),
tpu: socketaddr!("127.0.0.1:1238"), tpu: socketaddr!("127.0.0.1:1238"),
tpu_forwards: socketaddr!("127.0.0.1:1239"), tpu_forwards: socketaddr!("127.0.0.1:1239"),
rpc_banks: socketaddr!("127.0.0.1:1240"), unused: socketaddr!("127.0.0.1:1240"),
rpc: socketaddr!("127.0.0.1:1241"), rpc: socketaddr!("127.0.0.1:1241"),
rpc_pubsub: socketaddr!("127.0.0.1:1242"), rpc_pubsub: socketaddr!("127.0.0.1:1242"),
serve_repair: socketaddr!("127.0.0.1:1243"), serve_repair: socketaddr!("127.0.0.1:1243"),
@ -145,7 +145,7 @@ impl ContactInfo {
repair: addr, repair: addr,
tpu: addr, tpu: addr,
tpu_forwards: addr, tpu_forwards: addr,
rpc_banks: addr, unused: addr,
rpc: addr, rpc: addr,
rpc_pubsub: addr, rpc_pubsub: addr,
serve_repair: addr, serve_repair: addr,
@ -170,7 +170,6 @@ impl ContactInfo {
let repair = next_port(&bind_addr, 5); let repair = next_port(&bind_addr, 5);
let rpc = SocketAddr::new(bind_addr.ip(), rpc_port::DEFAULT_RPC_PORT); let rpc = SocketAddr::new(bind_addr.ip(), rpc_port::DEFAULT_RPC_PORT);
let rpc_pubsub = SocketAddr::new(bind_addr.ip(), rpc_port::DEFAULT_RPC_PUBSUB_PORT); let rpc_pubsub = SocketAddr::new(bind_addr.ip(), rpc_port::DEFAULT_RPC_PUBSUB_PORT);
let rpc_banks = SocketAddr::new(bind_addr.ip(), rpc_port::DEFAULT_RPC_BANKS_PORT);
let serve_repair = next_port(&bind_addr, 6); let serve_repair = next_port(&bind_addr, 6);
Self { Self {
id: *pubkey, id: *pubkey,
@ -180,7 +179,7 @@ impl ContactInfo {
repair, repair,
tpu, tpu,
tpu_forwards, tpu_forwards,
rpc_banks, unused: "0.0.0.0:0".parse().unwrap(),
rpc, rpc,
rpc_pubsub, rpc_pubsub,
serve_repair, serve_repair,
@ -257,7 +256,7 @@ mod tests {
assert!(ci.rpc.ip().is_unspecified()); assert!(ci.rpc.ip().is_unspecified());
assert!(ci.rpc_pubsub.ip().is_unspecified()); assert!(ci.rpc_pubsub.ip().is_unspecified());
assert!(ci.tpu.ip().is_unspecified()); assert!(ci.tpu.ip().is_unspecified());
assert!(ci.rpc_banks.ip().is_unspecified()); assert!(ci.unused.ip().is_unspecified());
assert!(ci.serve_repair.ip().is_unspecified()); assert!(ci.serve_repair.ip().is_unspecified());
} }
#[test] #[test]
@ -269,7 +268,7 @@ mod tests {
assert!(ci.rpc.ip().is_multicast()); assert!(ci.rpc.ip().is_multicast());
assert!(ci.rpc_pubsub.ip().is_multicast()); assert!(ci.rpc_pubsub.ip().is_multicast());
assert!(ci.tpu.ip().is_multicast()); assert!(ci.tpu.ip().is_multicast());
assert!(ci.rpc_banks.ip().is_multicast()); assert!(ci.unused.ip().is_multicast());
assert!(ci.serve_repair.ip().is_multicast()); assert!(ci.serve_repair.ip().is_multicast());
} }
#[test] #[test]
@ -282,7 +281,7 @@ mod tests {
assert!(ci.rpc.ip().is_unspecified()); assert!(ci.rpc.ip().is_unspecified());
assert!(ci.rpc_pubsub.ip().is_unspecified()); assert!(ci.rpc_pubsub.ip().is_unspecified());
assert!(ci.tpu.ip().is_unspecified()); assert!(ci.tpu.ip().is_unspecified());
assert!(ci.rpc_banks.ip().is_unspecified()); assert!(ci.unused.ip().is_unspecified());
assert!(ci.serve_repair.ip().is_unspecified()); assert!(ci.serve_repair.ip().is_unspecified());
} }
#[test] #[test]
@ -295,7 +294,7 @@ mod tests {
assert_eq!(ci.tpu_forwards.port(), 13); assert_eq!(ci.tpu_forwards.port(), 13);
assert_eq!(ci.rpc.port(), rpc_port::DEFAULT_RPC_PORT); assert_eq!(ci.rpc.port(), rpc_port::DEFAULT_RPC_PORT);
assert_eq!(ci.rpc_pubsub.port(), rpc_port::DEFAULT_RPC_PUBSUB_PORT); assert_eq!(ci.rpc_pubsub.port(), rpc_port::DEFAULT_RPC_PUBSUB_PORT);
assert_eq!(ci.rpc_banks.port(), rpc_port::DEFAULT_RPC_BANKS_PORT); assert!(ci.unused.ip().is_unspecified());
assert_eq!(ci.serve_repair.port(), 16); assert_eq!(ci.serve_repair.port(), 16);
} }
@ -319,10 +318,6 @@ mod tests {
d1.rpc_pubsub, d1.rpc_pubsub,
socketaddr!(format!("127.0.0.1:{}", rpc_port::DEFAULT_RPC_PUBSUB_PORT)) socketaddr!(format!("127.0.0.1:{}", rpc_port::DEFAULT_RPC_PUBSUB_PORT))
); );
assert_eq!(
d1.rpc_banks,
socketaddr!(format!("127.0.0.1:{}", rpc_port::DEFAULT_RPC_BANKS_PORT))
);
assert_eq!(d1.tvu_forwards, socketaddr!("127.0.0.1:1238")); assert_eq!(d1.tvu_forwards, socketaddr!("127.0.0.1:1238"));
assert_eq!(d1.repair, socketaddr!("127.0.0.1:1239")); assert_eq!(d1.repair, socketaddr!("127.0.0.1:1239"));
assert_eq!(d1.serve_repair, socketaddr!("127.0.0.1:1240")); assert_eq!(d1.serve_repair, socketaddr!("127.0.0.1:1240"));

6
core/src/serve_repair.rs
View File

@ -685,7 +685,7 @@ mod tests {
repair: socketaddr!("127.0.0.1:1237"), repair: socketaddr!("127.0.0.1:1237"),
tpu: socketaddr!("127.0.0.1:1238"), tpu: socketaddr!("127.0.0.1:1238"),
tpu_forwards: socketaddr!("127.0.0.1:1239"), tpu_forwards: socketaddr!("127.0.0.1:1239"),
rpc_banks: socketaddr!("127.0.0.1:1240"), unused: socketaddr!("127.0.0.1:1240"),
rpc: socketaddr!("127.0.0.1:1241"), rpc: socketaddr!("127.0.0.1:1241"),
rpc_pubsub: socketaddr!("127.0.0.1:1242"), rpc_pubsub: socketaddr!("127.0.0.1:1242"),
serve_repair: socketaddr!("127.0.0.1:1243"), serve_repair: socketaddr!("127.0.0.1:1243"),
@ -769,7 +769,7 @@ mod tests {
repair: socketaddr!([127, 0, 0, 1], 1237), repair: socketaddr!([127, 0, 0, 1], 1237),
tpu: socketaddr!([127, 0, 0, 1], 1238), tpu: socketaddr!([127, 0, 0, 1], 1238),
tpu_forwards: socketaddr!([127, 0, 0, 1], 1239), tpu_forwards: socketaddr!([127, 0, 0, 1], 1239),
rpc_banks: socketaddr!([127, 0, 0, 1], 1240), unused: socketaddr!([127, 0, 0, 1], 1240),
rpc: socketaddr!([127, 0, 0, 1], 1241), rpc: socketaddr!([127, 0, 0, 1], 1241),
rpc_pubsub: socketaddr!([127, 0, 0, 1], 1242), rpc_pubsub: socketaddr!([127, 0, 0, 1], 1242),
serve_repair: serve_repair_addr, serve_repair: serve_repair_addr,
@ -798,7 +798,7 @@ mod tests {
repair: socketaddr!([127, 0, 0, 1], 1237), repair: socketaddr!([127, 0, 0, 1], 1237),
tpu: socketaddr!([127, 0, 0, 1], 1238), tpu: socketaddr!([127, 0, 0, 1], 1238),
tpu_forwards: socketaddr!([127, 0, 0, 1], 1239), tpu_forwards: socketaddr!([127, 0, 0, 1], 1239),
rpc_banks: socketaddr!([127, 0, 0, 1], 1240), unused: socketaddr!([127, 0, 0, 1], 1240),
rpc: socketaddr!([127, 0, 0, 1], 1241), rpc: socketaddr!([127, 0, 0, 1], 1241),
rpc_pubsub: socketaddr!([127, 0, 0, 1], 1242), rpc_pubsub: socketaddr!([127, 0, 0, 1], 1242),
serve_repair: serve_repair_addr2, serve_repair: serve_repair_addr2,

2
core/src/test_validator.rs
View File

@ -120,7 +120,7 @@ impl TestValidator {
let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config); let (ledger_path, blockhash) = create_new_tmp_ledger!(&genesis_config);
let config = ValidatorConfig { let config = ValidatorConfig {
rpc_addrs: Some((node.info.rpc, node.info.rpc_pubsub, node.info.rpc_banks)), rpc_addrs: Some((node.info.rpc, node.info.rpc_pubsub)),
..ValidatorConfig::default() ..ValidatorConfig::default()
}; };

118
core/src/validator.rs
View File

@ -30,7 +30,6 @@ use crate::{
}; };
use crossbeam_channel::{bounded, unbounded}; use crossbeam_channel::{bounded, unbounded};
use rand::{thread_rng, Rng}; use rand::{thread_rng, Rng};
use solana_banks_server::rpc_banks_service::RpcBanksService;
use solana_ledger::{ use solana_ledger::{
bank_forks_utils, bank_forks_utils,
blockstore::{Blockstore, BlockstoreSignals, CompletedSlotsReceiver, PurgeType}, blockstore::{Blockstore, BlockstoreSignals, CompletedSlotsReceiver, PurgeType},
@ -82,7 +81,7 @@ pub struct ValidatorConfig {
pub voting_disabled: bool, pub voting_disabled: bool,
pub account_paths: Vec<PathBuf>, pub account_paths: Vec<PathBuf>,
pub rpc_config: JsonRpcConfig, pub rpc_config: JsonRpcConfig,
pub rpc_addrs: Option<(SocketAddr, SocketAddr, SocketAddr)>, // (JsonRpc, JsonRpcPubSub, Banks) pub rpc_addrs: Option<(SocketAddr, SocketAddr)>, // (JsonRpc, JsonRpcPubSub)
pub pubsub_config: PubSubConfig, pub pubsub_config: PubSubConfig,
pub snapshot_config: Option<SnapshotConfig>, pub snapshot_config: Option<SnapshotConfig>,
pub max_ledger_shreds: Option<u64>, pub max_ledger_shreds: Option<u64>,
@ -176,7 +175,6 @@ struct TransactionHistoryServices {
struct RpcServices { struct RpcServices {
json_rpc_service: JsonRpcService, json_rpc_service: JsonRpcService,
pubsub_service: PubSubService, pubsub_service: PubSubService,
rpc_banks_service: RpcBanksService,
optimistically_confirmed_bank_tracker: OptimisticallyConfirmedBankTracker, optimistically_confirmed_bank_tracker: OptimisticallyConfirmedBankTracker,
} }
@ -396,62 +394,52 @@ impl Validator {
let poh_recorder = Arc::new(Mutex::new(poh_recorder)); let poh_recorder = Arc::new(Mutex::new(poh_recorder));
let rpc_override_health_check = Arc::new(AtomicBool::new(false)); let rpc_override_health_check = Arc::new(AtomicBool::new(false));
let (rpc_service, bank_notification_sender) = let (rpc_service, bank_notification_sender) = if let Some((rpc_addr, rpc_pubsub_addr)) =
if let Some((rpc_addr, rpc_pubsub_addr, rpc_banks_addr)) = config.rpc_addrs { config.rpc_addrs
if ContactInfo::is_valid_address(&node.info.rpc) { {
assert!(ContactInfo::is_valid_address(&node.info.rpc_pubsub)); if ContactInfo::is_valid_address(&node.info.rpc) {
assert!(ContactInfo::is_valid_address(&node.info.rpc_banks)); assert!(ContactInfo::is_valid_address(&node.info.rpc_pubsub));
} else {
assert!(!ContactInfo::is_valid_address(&node.info.rpc_pubsub));
assert!(!ContactInfo::is_valid_address(&node.info.rpc_banks));
}
let tpu_address = cluster_info.my_contact_info().tpu;
let (bank_notification_sender, bank_notification_receiver) = unbounded();
(
Some(RpcServices {
json_rpc_service: JsonRpcService::new(
rpc_addr,
config.rpc_config.clone(),
config.snapshot_config.clone(),
bank_forks.clone(),
block_commitment_cache.clone(),
blockstore.clone(),
cluster_info.clone(),
Some(poh_recorder.clone()),
genesis_config.hash(),
ledger_path,
validator_exit.clone(),
config.trusted_validators.clone(),
rpc_override_health_check.clone(),
optimistically_confirmed_bank.clone(),
),
pubsub_service: PubSubService::new(
config.pubsub_config.clone(),
&subscriptions,
rpc_pubsub_addr,
&exit,
),
rpc_banks_service: RpcBanksService::new(
rpc_banks_addr,
tpu_address,
&bank_forks,
&block_commitment_cache,
&exit,
),
optimistically_confirmed_bank_tracker:
OptimisticallyConfirmedBankTracker::new(
bank_notification_receiver,
&exit,
bank_forks.clone(),
optimistically_confirmed_bank,
subscriptions.clone(),
),
}),
Some(bank_notification_sender),
)
} else { } else {
(None, None) assert!(!ContactInfo::is_valid_address(&node.info.rpc_pubsub));
}; }
let (bank_notification_sender, bank_notification_receiver) = unbounded();
(
Some(RpcServices {
json_rpc_service: JsonRpcService::new(
rpc_addr,
config.rpc_config.clone(),
config.snapshot_config.clone(),
bank_forks.clone(),
block_commitment_cache.clone(),
blockstore.clone(),
cluster_info.clone(),
Some(poh_recorder.clone()),
genesis_config.hash(),
ledger_path,
validator_exit.clone(),
config.trusted_validators.clone(),
rpc_override_health_check.clone(),
optimistically_confirmed_bank.clone(),
),
pubsub_service: PubSubService::new(
config.pubsub_config.clone(),
&subscriptions,
rpc_pubsub_addr,
&exit,
),
optimistically_confirmed_bank_tracker: OptimisticallyConfirmedBankTracker::new(
bank_notification_receiver,
&exit,
bank_forks.clone(),
optimistically_confirmed_bank,
subscriptions.clone(),
),
}),
Some(bank_notification_sender),
)
} else {
(None, None)
};
if config.dev_halt_at_slot.is_some() { if config.dev_halt_at_slot.is_some() {
// Simulate a confirmed root to avoid RPC errors with CommitmentConfig::max() and // Simulate a confirmed root to avoid RPC errors with CommitmentConfig::max() and
@ -666,13 +654,11 @@ impl Validator {
if let Some(RpcServices { if let Some(RpcServices {
json_rpc_service, json_rpc_service,
pubsub_service, pubsub_service,
rpc_banks_service,
optimistically_confirmed_bank_tracker, optimistically_confirmed_bank_tracker,
}) = self.rpc_service }) = self.rpc_service
{ {
json_rpc_service.join().expect("rpc_service"); json_rpc_service.join().expect("rpc_service");
pubsub_service.join().expect("pubsub_service"); pubsub_service.join().expect("pubsub_service");
rpc_banks_service.join().expect("rpc_banks_service");
optimistically_confirmed_bank_tracker optimistically_confirmed_bank_tracker
.join() .join()
.expect("optimistically_confirmed_bank_tracker"); .expect("optimistically_confirmed_bank_tracker");
@ -1242,11 +1228,7 @@ mod tests {
let voting_keypair = Arc::new(Keypair::new()); let voting_keypair = Arc::new(Keypair::new());
let config = ValidatorConfig { let config = ValidatorConfig {
rpc_addrs: Some(( rpc_addrs: Some((validator_node.info.rpc, validator_node.info.rpc_pubsub)),
validator_node.info.rpc,
validator_node.info.rpc_pubsub,
validator_node.info.rpc_banks,
)),
..ValidatorConfig::default() ..ValidatorConfig::default()
}; };
let validator = Validator::new( let validator = Validator::new(
@ -1316,11 +1298,7 @@ mod tests {
ledger_paths.push(validator_ledger_path.clone()); ledger_paths.push(validator_ledger_path.clone());
let vote_account_keypair = Keypair::new(); let vote_account_keypair = Keypair::new();
let config = ValidatorConfig { let config = ValidatorConfig {
rpc_addrs: Some(( rpc_addrs: Some((validator_node.info.rpc, validator_node.info.rpc_pubsub)),
validator_node.info.rpc,
validator_node.info.rpc_pubsub,
validator_node.info.rpc_banks,
)),
..ValidatorConfig::default() ..ValidatorConfig::default()
}; };
Validator::new( Validator::new(

15
local-cluster/src/local_cluster.rs
View File

@ -194,11 +194,7 @@ impl LocalCluster {
let (leader_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config); let (leader_ledger_path, _blockhash) = create_new_tmp_ledger!(&genesis_config);
let leader_contact_info = leader_node.info.clone(); let leader_contact_info = leader_node.info.clone();
let mut leader_config = config.validator_configs[0].clone(); let mut leader_config = config.validator_configs[0].clone();
leader_config.rpc_addrs = Some(( leader_config.rpc_addrs = Some((leader_node.info.rpc, leader_node.info.rpc_pubsub));
leader_node.info.rpc,
leader_node.info.rpc_pubsub,
leader_node.info.rpc_banks,
));
leader_config.account_paths = vec![leader_ledger_path.join("accounts")]; leader_config.account_paths = vec![leader_ledger_path.join("accounts")];
let leader_keypair = Arc::new(Keypair::from_bytes(&leader_keypair.to_bytes()).unwrap()); let leader_keypair = Arc::new(Keypair::from_bytes(&leader_keypair.to_bytes()).unwrap());
let leader_vote_keypair = let leader_vote_keypair =
@ -343,11 +339,7 @@ impl LocalCluster {
} }
let mut config = validator_config.clone(); let mut config = validator_config.clone();
config.rpc_addrs = Some(( config.rpc_addrs = Some((validator_node.info.rpc, validator_node.info.rpc_pubsub));
validator_node.info.rpc,
validator_node.info.rpc_pubsub,
validator_node.info.rpc_banks,
));
config.account_paths = vec![ledger_path.join("accounts")]; config.account_paths = vec![ledger_path.join("accounts")];
let voting_keypair = voting_keypair.unwrap(); let voting_keypair = voting_keypair.unwrap();
let validator_server = Validator::new( let validator_server = Validator::new(
@ -629,8 +621,7 @@ impl Cluster for LocalCluster {
// Update the stored ContactInfo for this node // Update the stored ContactInfo for this node
let node = Node::new_localhost_with_pubkey(&pubkey); let node = Node::new_localhost_with_pubkey(&pubkey);
cluster_validator_info.info.contact_info = node.info.clone(); cluster_validator_info.info.contact_info = node.info.clone();
cluster_validator_info.config.rpc_addrs = cluster_validator_info.config.rpc_addrs = Some((node.info.rpc, node.info.rpc_pubsub));
Some((node.info.rpc, node.info.rpc_pubsub, node.info.rpc_banks));
let entry_point_info = { let entry_point_info = {
if *pubkey == self.entry_point_info.id { if *pubkey == self.entry_point_info.id {

14
validator/src/main.rs
View File

@ -573,11 +573,10 @@ fn verify_reachable_ports(
} }
let mut tcp_listeners = vec![]; let mut tcp_listeners = vec![];
if let Some((rpc_addr, rpc_pubsub_addr, rpc_banks_addr)) = validator_config.rpc_addrs { if let Some((rpc_addr, rpc_pubsub_addr)) = validator_config.rpc_addrs {
for (purpose, bind_addr, public_addr) in &[ for (purpose, bind_addr, public_addr) in &[
("RPC", rpc_addr, &node.info.rpc), ("RPC", rpc_addr, &node.info.rpc),
("RPC pubsub", rpc_pubsub_addr, &node.info.rpc_pubsub), ("RPC pubsub", rpc_pubsub_addr, &node.info.rpc_pubsub),
("RPC banks", rpc_banks_addr, &node.info.rpc_banks),
] { ] {
if ContactInfo::is_valid_address(&public_addr) { if ContactInfo::is_valid_address(&public_addr) {
tcp_listeners.push(( tcp_listeners.push((
@ -1510,9 +1509,9 @@ pub fn main() {
( (
SocketAddr::new(rpc_bind_address, rpc_port), SocketAddr::new(rpc_bind_address, rpc_port),
SocketAddr::new(rpc_bind_address, rpc_port + 1), SocketAddr::new(rpc_bind_address, rpc_port + 1),
// +2 is skipped to avoid a conflict with the websocket port (which is +2) in web3.js // If additional ports are added, +2 needs to be skipped to avoid a conflict with
// This odd port shifting is tracked at https://github.com/solana-labs/solana/issues/12250 // the websocket port (which is +2) in web3.js This odd port shifting is tracked at
SocketAddr::new(rpc_bind_address, rpc_port + 3), // https://github.com/solana-labs/solana/issues/12250
) )
}), }),
pubsub_config: PubSubConfig { pubsub_config: PubSubConfig {
@ -1761,12 +1760,9 @@ pub fn main() {
if let Some(public_rpc_addr) = public_rpc_addr { if let Some(public_rpc_addr) = public_rpc_addr {
node.info.rpc = public_rpc_addr; node.info.rpc = public_rpc_addr;
node.info.rpc_pubsub = public_rpc_addr; node.info.rpc_pubsub = public_rpc_addr;
node.info.rpc_banks = public_rpc_addr; } else if let Some((rpc_addr, rpc_pubsub_addr)) = validator_config.rpc_addrs {
} else if let Some((rpc_addr, rpc_pubsub_addr, rpc_banks_addr)) = validator_config.rpc_addrs
{
node.info.rpc = SocketAddr::new(node.info.gossip.ip(), rpc_addr.port()); node.info.rpc = SocketAddr::new(node.info.gossip.ip(), rpc_addr.port());
node.info.rpc_pubsub = SocketAddr::new(node.info.gossip.ip(), rpc_pubsub_addr.port()); node.info.rpc_pubsub = SocketAddr::new(node.info.gossip.ip(), rpc_pubsub_addr.port());
node.info.rpc_banks = SocketAddr::new(node.info.gossip.ip(), rpc_banks_addr.port());
} }
} }