Struct bitcoin_node::Node

pub struct Node {

    pub deserializer: Option<Box<dyn TransportDeserializer>>,
    pub serializer: Option<Box<dyn TransportSerializer>>,
    pub permission_flags: NetPermissionFlags,
    pub n_services: Atomic<ServiceFlags>,
    pub cs_v_send: Arc<Mutex<NodeVSend>>,
    pub cs_h_socket: Arc<Mutex<NodeHSocket>>,
    pub cs_v_recv: Arc<Mutex<NodeVRecv>>,
    pub cs_v_process_msg: Arc<Mutex<NodeVProcessMsg>>,
    pub n_process_queue_size: AtomicUsize,
    pub cs_send_processing: RawMutex,
    pub n_last_send: Atomic<Option<OffsetDateTime>>,
    pub n_last_recv: Atomic<Option<OffsetDateTime>>,
    pub n_time_connected: Atomic<Option<OffsetDateTime>>,
    pub n_time_offset: Atomic<Option<Duration>>,
    pub addr: Address,
    pub addr_bind: Address,
    pub addr_name: String,
    pub inbound_onion: bool,
    pub n_version: AtomicI32,
    pub clean_sub_ver: Arc<Mutex<String>>,
    pub prefer_evict: bool,
    pub client: bool,
    pub limited_node: bool,
    pub successfully_connected: AtomicBool,
    pub disconnect: AtomicBool,
    pub grant_outbound: SemaphoreGrant,
    pub n_ref_count: AtomicI32,
    pub n_keyed_net_group: u64,
    pub pause_recv: AtomicBool,
    pub pause_send: AtomicBool,
    pub bip152_highbandwidth_to: AtomicBool,
    pub bip152_highbandwidth_from: AtomicBool,
    pub tx_relay: Amo<NodeTxRelay>,
    pub n_last_block_time: Atomic<Option<OffsetDateTime>>,
    pub n_last_tx_time: Atomic<Option<OffsetDateTime>>,
    pub last_ping_time: Atomic<Option<Instant>>,
    pub min_ping_time: Atomic<Option<Duration>>,
    pub id: NodeId,
    pub n_local_host_nonce: u64,
    pub conn_type: Option<ConnectionType>,
    pub greatest_common_version: AtomicI32,
    pub n_local_services: ServiceFlags,
    pub recv_msg: Arc<Mutex<Vec<NetMessage>>>,
    pub cs_addr_local: Arc<Mutex<NodeAddrLocal>>,
}

| Information about a peer |

Fields

deserializer: Option<Box<dyn TransportDeserializer>>

serializer: Option<Box<dyn TransportSerializer>>

permission_flags: NetPermissionFlags

n_services: Atomic<ServiceFlags>

cs_v_send: Arc<Mutex<NodeVSend>>

cs_h_socket: Arc<Mutex<NodeHSocket>>

cs_v_recv: Arc<Mutex<NodeVRecv>>

cs_v_process_msg: Arc<Mutex<NodeVProcessMsg>>

n_process_queue_size: AtomicUsize

cs_send_processing: RawMutex

n_last_send: Atomic<Option<OffsetDateTime>>

n_last_recv: Atomic<Option<OffsetDateTime>>

n_time_connected: Atomic<Option<OffsetDateTime>>

| Unix epoch time at peer connection, | in seconds. |

n_time_offset: Atomic<Option<Duration>>

addr: Address

| Address of this peer |

addr_bind: Address

| Bind address of our side of the connection |

addr_name: String

inbound_onion: bool

| Whether this peer is an inbound onion, | i.e. connected via our Tor onion service. |

n_version: AtomicI32

clean_sub_ver: Arc<Mutex<String>>

| cleanSubVer is a sanitized string of | the user agent byte array we read from | the wire. This cleaned string can safely | be logged or displayed. |

prefer_evict: bool

| This peer is preferred for eviction. |

client: bool

| set by version message |

limited_node: bool

| after BIP159, set by version message |

successfully_connected: AtomicBool

| fSuccessfullyConnected is set to true | on receiving VERACK from the peer. |

disconnect: AtomicBool

| Setting fDisconnect to true will cause | the node to be disconnected the next | time | | DisconnectNodes() runs |

grant_outbound: SemaphoreGrant

n_ref_count: AtomicI32

n_keyed_net_group: u64

pause_recv: AtomicBool

pause_send: AtomicBool

bip152_highbandwidth_to: AtomicBool

| We selected peer as (compact blocks) | high-bandwidth peer (BIP152) |

bip152_highbandwidth_from: AtomicBool

| Peer selected us as (compact blocks) | high-bandwidth peer (BIP152) |

tx_relay: Amo<NodeTxRelay>

| m_tx_relay == nullptr if we’re not relaying | transactions with this peer |

n_last_block_time: Atomic<Option<OffsetDateTime>>

| UNIX epoch time of the last block received | from this peer that we had not yet seen | (e.g. not already received from another | peer), that passed preliminary validity | checks and was saved to disk, even if | we don’t connect the block or it eventually | fails connection. Used as an inbound | peer eviction criterium in Connman::AttemptToEvictConnection. |

n_last_tx_time: Atomic<Option<OffsetDateTime>>

| UNIX epoch time of the last transaction | received from this peer that we had not | yet seen (e.g. not already received | from another peer) and that was accepted | into our mempool. Used as an inbound | peer eviction criterium in Connman::AttemptToEvictConnection. |

last_ping_time: Atomic<Option<Instant>>

| Last measured round-trip time. Used | only for RPC/GUI stats/debugging. |

min_ping_time: Atomic<Option<Duration>>

| Lowest measured round-trip time. Used | as an inbound peer eviction criterium | in Connman::AttemptToEvictConnection. |

id: NodeId

n_local_host_nonce: u64

conn_type: Option<ConnectionType>

greatest_common_version: AtomicI32

n_local_services: ServiceFlags

| Services offered to this peer. | | This is supplied by the parent Connman | during peer connection | (Connman::ConnectNode()) from its | attribute of the same name. | | This is const because there is no protocol | defined for renegotiating services | initially offered to a peer. The set of | local services we offer should not change | after initialization. | | An interesting example of this is | NODE_NETWORK and initial block download: | a node which starts up from scratch | doesn’t have any blocks to serve, but | still advertises NODE_NETWORK because it | will eventually fulfill this role after | IBD completes. P2P code is written in such | a way that it can gracefully handle peers | who don’t make good on their service | advertisements.

recv_msg: Arc<Mutex<Vec<NetMessage>>>

| Used only by SocketHandler thread |

cs_addr_local: Arc<Mutex<NodeAddrLocal>>

Implementations

impl Node

pub fn new( id_in: NodeId, n_local_services_in: ServiceFlags, h_socket_in: CSocket, addr_in: &Address, n_keyed_net_group_in: u64, n_local_host_nonce_in: u64, addr_bind_in: &Address, addr_name_in: &String, conn_type_in: ConnectionType, inbound_onion: bool ) -> Self

pub fn get_addr_local(&self) -> Service

pub fn connection_type_as_string(&self) -> String

Trait Implementations

impl AddKnownTx for Node

fn add_known_tx(&mut self, hash: &u256)

impl AddrBind for Node

fn addr_bind(&self) -> &Address

impl AddrName for Node

fn addr_name(&self) -> &str

impl CloseSocketDisconnect for Node

fn close_socket_disconnect(&mut self)

impl ConnType for Node

fn conn_type(&self) -> Option<ConnectionType>

impl ConnectedThroughNetwork for Node

fn connected_through_network(&self) -> Network

| Get network the peer connected through. | | Returns Network::NET_ONION for inbound | onion connections, and CNetAddr::GetNetClass() | otherwise. The latter cannot be used | directly because it doesn’t detect | the former, and it’s not the responsibility | of the CNetAddr class to know the actual | network a peer is connected through. | | | ———– | @return | | network the peer connected through. |

impl CopyStats for Node

fn copy_stats(&mut self, stats: &mut NodeStats)

impl DecrementNProcessQueueSize for Node

fn decrement_n_process_queue_size(&self, val: usize)

impl Default for Node

fn default() -> Self

Returns the “default value” for a type.

impl DisconnectOnStall for Node

fn disconnect_on_stall(&self)

impl Drop for Node

fn drop(&mut self)

Executes the destructor for this type.

impl ExpectServicesFromConn for Node

fn expect_services_from_conn(&self) -> bool

impl GetAddrMut for Node

fn addr_mut(&mut self) -> &mut Address

impl GetAddrRef for Node

fn addr(&self) -> &Address

impl GetCommonVersion for Node

fn get_common_version(&self) -> i32

impl GetLocalNonce for Node

fn get_local_nonce(&self) -> u64

impl GetLocalServices for Node

fn get_local_services(&self) -> ServiceFlags

impl GetNProcessQueueSize for Node

fn get_n_process_queue_size(&self) -> usize

impl GetNTimeConnected for Node

fn get_n_time_connected(&self) -> OffsetDateTime

impl GetNodeId for Node

fn get_id(&self) -> NodeId

impl GetRefCount for Node

fn get_ref_count(&self) -> i32

impl GetServiceMut for Node

fn service_mut(&mut self) -> &mut Service

impl GetServiceRef for Node

fn service(&self) -> &Service

impl GetTransportSerializer for Node

fn get_transport_serializer(&self) -> &Box<dyn TransportSerializer>

impl GetTransportSerializerMut for Node

fn get_transport_serializer_mut(&mut self) -> &mut Box<dyn TransportSerializer>

impl GetTxRelay for Node

fn get_tx_relay(&self) -> AmoReadGuard<'_, NodeTxRelay>

impl GetTxRelayMut for Node

fn get_tx_relay_mut(&self) -> AmoWriteGuard<'_, NodeTxRelay>

impl GrantOutbound for Node

fn grant_outbound(&self) -> SemaphoreGrant

impl HasPermission for Node

fn has_permission(&self, permission: NetPermissionFlags) -> bool

impl HasTxRelay for Node

fn has_tx_relay(&self) -> bool

impl IncrementNProcessQueueSize for Node

fn increment_n_process_queue_size(&self, x: usize)

impl IsAddrFetchConn for Node

fn is_addr_fetch_conn(&self) -> bool

impl IsBlockOnlyConn for Node

fn is_block_only_conn(&self) -> bool

impl IsClient for Node

fn is_client(&self) -> bool

impl IsFeelerConn for Node

fn is_feeler_conn(&self) -> bool

impl IsFullOutboundConn for Node

fn is_full_outbound_conn(&self) -> bool

impl IsInboundConn for Node

fn is_inbound_conn(&self) -> bool

impl IsLimitedNode for Node

fn is_limited_node(&self) -> bool

impl IsManualConn for Node

fn is_manual_conn(&self) -> bool

impl IsOutboundOrBlockRelayConn for Node

fn is_outbound_or_block_relay_conn(&self) -> bool

impl IsSuccessfullyConnected for Node

fn is_successfully_connected(&self) -> bool

impl LockHSocket for Node

fn lock_h_socket(&self) -> MutexGuard<'_, NodeHSocket>

impl LockRecvMsg for Node

fn lock_recv_msg(&self) -> MutexGuard<'_, Vec<NetMessage>>

impl LockSendProcessing for Node

unsafe fn lock_send_processing(&self)

impl LockVProcessMsg for Node

fn lock_v_process_msg(&self) -> MutexGuard<'_, NodeVProcessMsg>

impl LockVSend for Node

fn lock_v_send(&self) -> MutexGuard<'_, NodeVSend>

impl MarkForDisconnect for Node

fn mark_for_disconnect(&self)

| Disconnect the handler. |

impl MarkedForDisconnect for Node

fn marked_for_disconnect(&self) -> bool

impl MinPingTime for Node

fn min_ping_time(&self) -> Option<Duration>

impl NKeyedNetGroup for Node

fn n_keyed_net_group(&self) -> u64

impl NLastBlockTime for Node

fn n_last_block_time(&self) -> Option<OffsetDateTime>

impl NLastRecv for Node

fn n_last_recv(&self) -> Option<OffsetDateTime>

impl NLastSend for Node

fn n_last_send(&self) -> Option<OffsetDateTime>

impl NLastTxTime for Node

fn n_last_tx_time(&self) -> Option<OffsetDateTime>

impl NProcessQueueSize for Node

fn n_process_queue_size(&self) -> usize

impl NServices for Node

fn n_services(&self) -> ServiceFlags

impl NTimeConnected for Node

fn n_time_connected(&self) -> Option<OffsetDateTime>

impl NVersion for Node

fn n_version(&self) -> i32

impl NodeInterfaceAddRef for Node

fn add_ref(&mut self) -> *mut dyn NodeInterface

impl PartialEq<Node> for Node

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PauseRecv for Node

fn pause_recv(&self) -> bool

impl PongReceived for Node

fn pong_received(&mut self, ping_time: Duration)

| A ping-pong round trip has completed | successfully. Update latest and minimum | ping times. |

impl PreferEvict for Node

fn prefer_evict(&self) -> bool

impl PushTxInventory for Node

fn push_tx_inventory(&mut self, hash: &u256)

impl ReceiveMsgBytes for Node

fn receive_msg_bytes(&mut self, msg_bytes: &[u8], complete: &mut bool) -> bool

| Receive bytes from the buffer and deserialize | them into messages. | | ———– | @param[in] msg_bytes | | The raw data | ––––– | @param[out] complete | | Set True if at least one message has been | deserialized and is ready to be processed | | ———– | @return | | True if the peer should stay connected, | | False if the peer should be disconnected | from. |

impl Release for Node

fn release(&mut self)

impl ReleaseGrantOutbound for Node

fn release_grant_outbound(&mut self)

impl SendPaused for Node

fn send_paused(&self) -> bool

impl SetAddrLocal for Node

fn set_addr_local(&mut self, addr_local_in: &Service)

| May not be called more than once |

impl SetBip152HighBandwidthFrom for Node

fn set_bip152_highbandwidth_from(&mut self, x: bool)

impl SetBip152HighBandwidthTo for Node

fn set_bip152_highbandwidth_to(&mut self, x: bool)

impl SetCleanSubVer for Node

fn set_clean_sub_ver(&mut self, x: &str)

impl SetCommonVersion for Node

fn set_common_version(&mut self, greatest_common_version: i32)

impl SetIsClient for Node

fn set_is_client(&mut self, x: bool)

impl SetLimitedNode for Node

fn set_limited_node(&mut self, x: bool)

impl SetNLastBlockTime for Node

fn set_n_last_block_time(&mut self, x: Option<OffsetDateTime>)

impl SetNLastTxTime for Node

fn set_n_last_tx_time(&mut self, x: Option<OffsetDateTime>)

impl SetNServices for Node

fn set_n_services(&mut self, x: ServiceFlags)

impl SetNTimeOffset for Node

fn set_n_time_offset(&mut self, x: Option<Duration>)

impl SetNVersion for Node

fn set_n_version(&mut self, x: i32)

impl SetPauseRecv for Node

fn set_pause_recv(&self, x: bool)

impl SetPauseSend for Node

fn set_pause_send(&self, x: bool)

impl SetPermissionFlags for Node

fn set_permission_flags(&mut self, x: NetPermissionFlags)

impl SetPreferEvict for Node

fn set_prefer_evict(&mut self, x: bool)

impl SetSuccessfullyConnected for Node

fn set_successfully_connected(&self, val: bool)

impl SuccessfullyConnected for Node

fn successfully_connected(&self) -> bool

impl UnlockSendProcessing for Node

unsafe fn unlock_send_processing(&self)

impl Eq for Node

impl Send for Node

impl Sync for Node