2018-12-01 12:00:30 -08:00
|
|
|
use bincode::serialize;
|
2018-11-15 13:23:26 -08:00
|
|
|
use solana_sdk::pubkey::Pubkey;
|
2019-03-16 17:43:39 -07:00
|
|
|
use solana_sdk::rpc_port;
|
2018-12-03 10:26:28 -08:00
|
|
|
use solana_sdk::signature::{Keypair, KeypairUtil, Signable, Signature};
|
2018-11-16 08:45:59 -08:00
|
|
|
use solana_sdk::timing::timestamp;
|
2019-01-02 00:46:15 -08:00
|
|
|
use std::cmp::{Ord, Ordering, PartialEq, PartialOrd};
|
2018-11-15 13:23:26 -08:00
|
|
|
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
|
|
|
|
|
|
|
|
/// Structure representing a node on the network
|
2019-01-02 00:46:15 -08:00
|
|
|
#[derive(Serialize, Deserialize, Clone, Debug)]
|
2018-11-15 13:23:26 -08:00
|
|
|
pub struct ContactInfo {
|
|
|
|
pub id: Pubkey,
|
2018-12-01 12:00:30 -08:00
|
|
|
/// signature of this ContactInfo
|
|
|
|
pub signature: Signature,
|
2018-11-15 13:23:26 -08:00
|
|
|
/// gossip address
|
2018-12-06 12:52:47 -08:00
|
|
|
pub gossip: SocketAddr,
|
2018-11-15 13:23:26 -08:00
|
|
|
/// address to connect to for replication
|
|
|
|
pub tvu: SocketAddr,
|
|
|
|
/// transactions address
|
|
|
|
pub tpu: SocketAddr,
|
2019-03-11 12:46:30 -07:00
|
|
|
/// address to forward unprocessed transactions to
|
|
|
|
pub tpu_via_blobs: SocketAddr,
|
2018-11-15 13:23:26 -08:00
|
|
|
/// storage data address
|
|
|
|
pub storage_addr: SocketAddr,
|
|
|
|
/// address to which to send JSON-RPC requests
|
|
|
|
pub rpc: SocketAddr,
|
|
|
|
/// websocket for JSON-RPC push notifications
|
|
|
|
pub rpc_pubsub: SocketAddr,
|
|
|
|
/// latest wallclock picked
|
|
|
|
pub wallclock: u64,
|
|
|
|
}
|
|
|
|
|
2019-01-02 00:46:15 -08:00
|
|
|
impl Ord for ContactInfo {
|
|
|
|
fn cmp(&self, other: &Self) -> Ordering {
|
|
|
|
self.id.cmp(&other.id)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PartialOrd for ContactInfo {
|
|
|
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
|
|
Some(self.cmp(other))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PartialEq for ContactInfo {
|
|
|
|
fn eq(&self, other: &Self) -> bool {
|
|
|
|
self.id == other.id
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Eq for ContactInfo {}
|
|
|
|
|
2018-11-15 13:23:26 -08:00
|
|
|
#[macro_export]
|
|
|
|
macro_rules! socketaddr {
|
|
|
|
($ip:expr, $port:expr) => {
|
2019-03-08 19:28:19 -08:00
|
|
|
std::net::SocketAddr::from((Ipv4Addr::from($ip), $port))
|
2018-11-15 13:23:26 -08:00
|
|
|
};
|
|
|
|
($str:expr) => {{
|
2019-03-08 19:28:19 -08:00
|
|
|
let a: std::net::SocketAddr = $str.parse().unwrap();
|
2018-11-15 13:23:26 -08:00
|
|
|
a
|
|
|
|
}};
|
|
|
|
}
|
|
|
|
#[macro_export]
|
|
|
|
macro_rules! socketaddr_any {
|
|
|
|
() => {
|
|
|
|
socketaddr!(0, 0)
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for ContactInfo {
|
|
|
|
fn default() -> Self {
|
|
|
|
ContactInfo {
|
|
|
|
id: Pubkey::default(),
|
2018-12-06 12:52:47 -08:00
|
|
|
gossip: socketaddr_any!(),
|
2018-11-15 13:23:26 -08:00
|
|
|
tvu: socketaddr_any!(),
|
|
|
|
tpu: socketaddr_any!(),
|
2019-03-11 12:46:30 -07:00
|
|
|
tpu_via_blobs: socketaddr_any!(),
|
2018-11-15 13:23:26 -08:00
|
|
|
storage_addr: socketaddr_any!(),
|
|
|
|
rpc: socketaddr_any!(),
|
|
|
|
rpc_pubsub: socketaddr_any!(),
|
|
|
|
wallclock: 0,
|
2018-12-01 12:00:30 -08:00
|
|
|
signature: Signature::default(),
|
2018-11-15 13:23:26 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ContactInfo {
|
|
|
|
pub fn new(
|
2019-03-09 19:28:43 -08:00
|
|
|
id: &Pubkey,
|
2018-12-06 12:52:47 -08:00
|
|
|
gossip: SocketAddr,
|
2018-11-15 13:23:26 -08:00
|
|
|
tvu: SocketAddr,
|
|
|
|
tpu: SocketAddr,
|
2019-03-11 12:46:30 -07:00
|
|
|
tpu_via_blobs: SocketAddr,
|
2018-11-15 13:23:26 -08:00
|
|
|
storage_addr: SocketAddr,
|
|
|
|
rpc: SocketAddr,
|
|
|
|
rpc_pubsub: SocketAddr,
|
|
|
|
now: u64,
|
|
|
|
) -> Self {
|
2019-03-08 17:15:08 -08:00
|
|
|
Self {
|
2019-03-09 19:28:43 -08:00
|
|
|
id: *id,
|
2018-12-01 12:00:30 -08:00
|
|
|
signature: Signature::default(),
|
2018-12-06 12:52:47 -08:00
|
|
|
gossip,
|
2018-11-15 13:23:26 -08:00
|
|
|
tvu,
|
|
|
|
tpu,
|
2019-03-11 12:46:30 -07:00
|
|
|
tpu_via_blobs,
|
2018-11-15 13:23:26 -08:00
|
|
|
storage_addr,
|
|
|
|
rpc,
|
|
|
|
rpc_pubsub,
|
|
|
|
wallclock: now,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-09 19:28:43 -08:00
|
|
|
pub fn new_localhost(id: &Pubkey, now: u64) -> Self {
|
2018-11-15 13:23:26 -08:00
|
|
|
Self::new(
|
|
|
|
id,
|
|
|
|
socketaddr!("127.0.0.1:1234"),
|
|
|
|
socketaddr!("127.0.0.1:1235"),
|
|
|
|
socketaddr!("127.0.0.1:1236"),
|
|
|
|
socketaddr!("127.0.0.1:1237"),
|
|
|
|
socketaddr!("127.0.0.1:1238"),
|
|
|
|
socketaddr!("127.0.0.1:1239"),
|
2019-03-08 14:59:11 -08:00
|
|
|
socketaddr!("127.0.0.1:1240"),
|
2018-11-15 13:23:26 -08:00
|
|
|
now,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
/// ContactInfo with multicast addresses for adversarial testing.
|
|
|
|
pub fn new_multicast() -> Self {
|
|
|
|
let addr = socketaddr!("224.0.1.255:1000");
|
|
|
|
assert!(addr.ip().is_multicast());
|
|
|
|
Self::new(
|
2019-03-09 19:28:43 -08:00
|
|
|
&Keypair::new().pubkey(),
|
2018-11-15 13:23:26 -08:00
|
|
|
addr,
|
|
|
|
addr,
|
|
|
|
addr,
|
|
|
|
addr,
|
|
|
|
addr,
|
|
|
|
addr,
|
2019-03-08 14:59:11 -08:00
|
|
|
addr,
|
2018-11-15 13:23:26 -08:00
|
|
|
0,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
fn next_port(addr: &SocketAddr, nxt: u16) -> SocketAddr {
|
|
|
|
let mut nxt_addr = *addr;
|
|
|
|
nxt_addr.set_port(addr.port() + nxt);
|
|
|
|
nxt_addr
|
|
|
|
}
|
2019-03-09 19:28:43 -08:00
|
|
|
fn new_with_pubkey_socketaddr(pubkey: &Pubkey, bind_addr: &SocketAddr) -> Self {
|
2018-12-07 14:09:29 -08:00
|
|
|
let tpu_addr = *bind_addr;
|
2018-11-15 13:23:26 -08:00
|
|
|
let gossip_addr = Self::next_port(&bind_addr, 1);
|
2018-12-07 14:09:29 -08:00
|
|
|
let tvu_addr = Self::next_port(&bind_addr, 2);
|
2019-03-11 12:46:30 -07:00
|
|
|
let tpu_via_blobs_addr = Self::next_port(&bind_addr, 3);
|
2019-03-16 17:43:39 -07:00
|
|
|
let rpc_addr = SocketAddr::new(bind_addr.ip(), rpc_port::DEFAULT_RPC_PORT);
|
|
|
|
let rpc_pubsub_addr = SocketAddr::new(bind_addr.ip(), rpc_port::DEFAULT_RPC_PUBSUB_PORT);
|
2019-03-08 17:15:08 -08:00
|
|
|
Self::new(
|
2018-11-15 13:23:26 -08:00
|
|
|
pubkey,
|
|
|
|
gossip_addr,
|
2018-12-07 14:09:29 -08:00
|
|
|
tvu_addr,
|
|
|
|
tpu_addr,
|
2019-03-11 12:46:30 -07:00
|
|
|
tpu_via_blobs_addr,
|
2018-11-15 13:23:26 -08:00
|
|
|
"0.0.0.0:0".parse().unwrap(),
|
|
|
|
rpc_addr,
|
|
|
|
rpc_pubsub_addr,
|
|
|
|
timestamp(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
pub fn new_with_socketaddr(bind_addr: &SocketAddr) -> Self {
|
|
|
|
let keypair = Keypair::new();
|
2019-03-09 19:28:43 -08:00
|
|
|
Self::new_with_pubkey_socketaddr(&keypair.pubkey(), bind_addr)
|
2018-11-15 13:23:26 -08:00
|
|
|
}
|
2019-03-08 17:15:08 -08:00
|
|
|
|
|
|
|
// Construct a ContactInfo that's only usable for gossip
|
|
|
|
pub fn new_gossip_entry_point(gossip_addr: &SocketAddr) -> Self {
|
2018-11-15 13:23:26 -08:00
|
|
|
let daddr: SocketAddr = socketaddr!("0.0.0.0:0");
|
2019-03-08 17:15:08 -08:00
|
|
|
Self::new(
|
2019-03-09 19:28:43 -08:00
|
|
|
&Pubkey::default(),
|
2018-11-15 13:23:26 -08:00
|
|
|
*gossip_addr,
|
|
|
|
daddr,
|
|
|
|
daddr,
|
|
|
|
daddr,
|
|
|
|
daddr,
|
|
|
|
daddr,
|
2019-03-08 14:59:11 -08:00
|
|
|
daddr,
|
2018-11-15 13:23:26 -08:00
|
|
|
timestamp(),
|
|
|
|
)
|
|
|
|
}
|
|
|
|
fn is_valid_ip(addr: IpAddr) -> bool {
|
|
|
|
!(addr.is_unspecified() || addr.is_multicast())
|
|
|
|
// || (addr.is_loopback() && !cfg_test))
|
|
|
|
// TODO: boot loopback in production networks
|
|
|
|
}
|
|
|
|
/// port must not be 0
|
|
|
|
/// ip must be specified and not mulitcast
|
|
|
|
/// loopback ip is only allowed in tests
|
|
|
|
pub fn is_valid_address(addr: &SocketAddr) -> bool {
|
|
|
|
(addr.port() != 0) && Self::is_valid_ip(addr.ip())
|
|
|
|
}
|
2019-03-12 19:25:52 -07:00
|
|
|
|
|
|
|
pub fn client_facing_addr(&self) -> (SocketAddr, SocketAddr) {
|
|
|
|
(self.rpc, self.tpu)
|
|
|
|
}
|
2018-11-15 13:23:26 -08:00
|
|
|
}
|
|
|
|
|
2018-12-01 12:00:30 -08:00
|
|
|
impl Signable for ContactInfo {
|
|
|
|
fn pubkey(&self) -> Pubkey {
|
|
|
|
self.id
|
|
|
|
}
|
|
|
|
|
|
|
|
fn signable_data(&self) -> Vec<u8> {
|
|
|
|
#[derive(Serialize)]
|
|
|
|
struct SignData {
|
|
|
|
id: Pubkey,
|
2018-12-06 12:52:47 -08:00
|
|
|
gossip: SocketAddr,
|
2018-12-01 12:00:30 -08:00
|
|
|
tvu: SocketAddr,
|
|
|
|
tpu: SocketAddr,
|
|
|
|
storage_addr: SocketAddr,
|
|
|
|
rpc: SocketAddr,
|
|
|
|
rpc_pubsub: SocketAddr,
|
|
|
|
wallclock: u64,
|
|
|
|
}
|
|
|
|
|
|
|
|
let me = self;
|
|
|
|
let data = SignData {
|
|
|
|
id: me.id,
|
2018-12-06 12:52:47 -08:00
|
|
|
gossip: me.gossip,
|
2018-12-01 12:00:30 -08:00
|
|
|
tvu: me.tvu,
|
|
|
|
tpu: me.tpu,
|
|
|
|
storage_addr: me.storage_addr,
|
|
|
|
rpc: me.rpc,
|
|
|
|
rpc_pubsub: me.rpc_pubsub,
|
|
|
|
wallclock: me.wallclock,
|
|
|
|
};
|
|
|
|
serialize(&data).expect("failed to serialize ContactInfo")
|
|
|
|
}
|
|
|
|
|
|
|
|
fn get_signature(&self) -> Signature {
|
|
|
|
self.signature
|
|
|
|
}
|
|
|
|
|
|
|
|
fn set_signature(&mut self, signature: Signature) {
|
|
|
|
self.signature = signature
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-15 13:23:26 -08:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_is_valid_address() {
|
|
|
|
assert!(cfg!(test));
|
|
|
|
let bad_address_port = socketaddr!("127.0.0.1:0");
|
|
|
|
assert!(!ContactInfo::is_valid_address(&bad_address_port));
|
|
|
|
let bad_address_unspecified = socketaddr!(0, 1234);
|
|
|
|
assert!(!ContactInfo::is_valid_address(&bad_address_unspecified));
|
|
|
|
let bad_address_multicast = socketaddr!([224, 254, 0, 0], 1234);
|
|
|
|
assert!(!ContactInfo::is_valid_address(&bad_address_multicast));
|
|
|
|
let loopback = socketaddr!("127.0.0.1:1234");
|
|
|
|
assert!(ContactInfo::is_valid_address(&loopback));
|
|
|
|
// assert!(!ContactInfo::is_valid_ip_internal(loopback.ip(), false));
|
|
|
|
}
|
|
|
|
#[test]
|
|
|
|
fn test_default() {
|
|
|
|
let ci = ContactInfo::default();
|
2018-12-06 12:52:47 -08:00
|
|
|
assert!(ci.gossip.ip().is_unspecified());
|
2018-11-15 13:23:26 -08:00
|
|
|
assert!(ci.tvu.ip().is_unspecified());
|
2019-03-11 12:46:30 -07:00
|
|
|
assert!(ci.tpu_via_blobs.ip().is_unspecified());
|
2018-11-15 13:23:26 -08:00
|
|
|
assert!(ci.rpc.ip().is_unspecified());
|
|
|
|
assert!(ci.rpc_pubsub.ip().is_unspecified());
|
|
|
|
assert!(ci.tpu.ip().is_unspecified());
|
|
|
|
assert!(ci.storage_addr.ip().is_unspecified());
|
|
|
|
}
|
|
|
|
#[test]
|
|
|
|
fn test_multicast() {
|
|
|
|
let ci = ContactInfo::new_multicast();
|
2018-12-06 12:52:47 -08:00
|
|
|
assert!(ci.gossip.ip().is_multicast());
|
2018-11-15 13:23:26 -08:00
|
|
|
assert!(ci.tvu.ip().is_multicast());
|
2019-03-11 12:46:30 -07:00
|
|
|
assert!(ci.tpu_via_blobs.ip().is_multicast());
|
2018-11-15 13:23:26 -08:00
|
|
|
assert!(ci.rpc.ip().is_multicast());
|
|
|
|
assert!(ci.rpc_pubsub.ip().is_multicast());
|
|
|
|
assert!(ci.tpu.ip().is_multicast());
|
|
|
|
assert!(ci.storage_addr.ip().is_multicast());
|
|
|
|
}
|
|
|
|
#[test]
|
|
|
|
fn test_entry_point() {
|
|
|
|
let addr = socketaddr!("127.0.0.1:10");
|
2019-03-08 17:15:08 -08:00
|
|
|
let ci = ContactInfo::new_gossip_entry_point(&addr);
|
2018-12-06 12:52:47 -08:00
|
|
|
assert_eq!(ci.gossip, addr);
|
2018-11-15 13:23:26 -08:00
|
|
|
assert!(ci.tvu.ip().is_unspecified());
|
2019-03-11 12:46:30 -07:00
|
|
|
assert!(ci.tpu_via_blobs.ip().is_unspecified());
|
2018-11-15 13:23:26 -08:00
|
|
|
assert!(ci.rpc.ip().is_unspecified());
|
|
|
|
assert!(ci.rpc_pubsub.ip().is_unspecified());
|
|
|
|
assert!(ci.tpu.ip().is_unspecified());
|
|
|
|
assert!(ci.storage_addr.ip().is_unspecified());
|
|
|
|
}
|
|
|
|
#[test]
|
|
|
|
fn test_socketaddr() {
|
|
|
|
let addr = socketaddr!("127.0.0.1:10");
|
|
|
|
let ci = ContactInfo::new_with_socketaddr(&addr);
|
|
|
|
assert_eq!(ci.tpu, addr);
|
2018-12-06 12:52:47 -08:00
|
|
|
assert_eq!(ci.gossip.port(), 11);
|
2018-11-15 13:23:26 -08:00
|
|
|
assert_eq!(ci.tvu.port(), 12);
|
2019-03-11 12:46:30 -07:00
|
|
|
assert_eq!(ci.tpu_via_blobs.port(), 13);
|
2018-11-15 13:23:26 -08:00
|
|
|
assert_eq!(ci.rpc.port(), 8899);
|
|
|
|
assert_eq!(ci.rpc_pubsub.port(), 8900);
|
|
|
|
assert!(ci.storage_addr.ip().is_unspecified());
|
|
|
|
}
|
|
|
|
#[test]
|
2018-12-07 14:09:29 -08:00
|
|
|
fn replayed_data_new_with_socketaddr_with_pubkey() {
|
2018-11-15 13:23:26 -08:00
|
|
|
let keypair = Keypair::new();
|
|
|
|
let d1 = ContactInfo::new_with_pubkey_socketaddr(
|
2019-03-09 19:28:43 -08:00
|
|
|
&keypair.pubkey(),
|
2018-11-15 13:23:26 -08:00
|
|
|
&socketaddr!("127.0.0.1:1234"),
|
|
|
|
);
|
|
|
|
assert_eq!(d1.id, keypair.pubkey());
|
2018-12-06 12:52:47 -08:00
|
|
|
assert_eq!(d1.gossip, socketaddr!("127.0.0.1:1235"));
|
2018-11-15 13:23:26 -08:00
|
|
|
assert_eq!(d1.tvu, socketaddr!("127.0.0.1:1236"));
|
2019-03-11 12:46:30 -07:00
|
|
|
assert_eq!(d1.tpu_via_blobs, socketaddr!("127.0.0.1:1237"));
|
2018-11-15 13:23:26 -08:00
|
|
|
assert_eq!(d1.tpu, socketaddr!("127.0.0.1:1234"));
|
|
|
|
assert_eq!(d1.rpc, socketaddr!("127.0.0.1:8899"));
|
|
|
|
assert_eq!(d1.rpc_pubsub, socketaddr!("127.0.0.1:8900"));
|
|
|
|
}
|
|
|
|
}
|