Struct massa_bootstrap::bindings::server::BootstrapServerBinder

pub struct BootstrapServerBinder {
    max_consensus_block_ids: u64,
    thread_count: u8,
    max_datastore_key_length: u8,
    randomness_size_bytes: usize,
    local_keypair: KeyPair,
    duplex: Limiter<TcpStream>,
    prev_message: Option<Hash>,
    version_serializer: VersionSerializer,
    version_deserializer: VersionDeserializer,
    write_error_timeout: MassaTime,
}

Bootstrap server binder

Fields

max_consensus_block_ids: u64

max number of block ids accepted in the client’s cumulative bootstrap cursor

thread_count: u8

max_datastore_key_length: u8

randomness_size_bytes: usize

local_keypair: KeyPair

duplex: Limiter<TcpStream>

prev_message: Option<Hash>

version_serializer: VersionSerializer

version_deserializer: VersionDeserializer

write_error_timeout: MassaTime

Implementations

impl BootstrapServerBinder

pub fn new( duplex: TcpStream, local_keypair: KeyPair, cfg: BootstrapSrvBindCfg, rw_limit: Option<u64>, ) -> Self

Creates a new WriteBinder.

Argument

• duplex: duplex stream.
• local_keypair: local node user keypair
• limit: limit max bytes per second (up and down)

pub fn handshake_timeout( &mut self, version: Version, duration: Option<Duration>, ) -> Result<(), BootstrapError>

Performs a handshake. Should be called after connection MUST always be followed by a send of the BootstrapMessage::BootstrapTime

pub fn send_msg( &mut self, timeout: Duration, msg: BootstrapServerMessage, ) -> Result<(), BootstrapError>

pub(crate) fn close_and_send_error<F>( self, msg: String, addr: SocketAddr, close_fn: F, )

where F: FnOnce() + Send + 'static,

1. Spawns a thread, unless MAX_CONCURRENT_ERROR_SENDS are already running
2. blocks on the passed in runtime
3. uses passed in handle to send a message to the client
4. logs an error if the send times out
5. runs the passed in closure (typically a custom logging msg)

consumes the binding in the process. When the refusal budget is exhausted or the OS refuses the spawn, the binding is dropped instead, closing the connection without the courtesy message.

pub fn send_error_timeout( &mut self, error: String, ) -> Result<(), BootstrapError>

pub fn send_timeout( &mut self, msg: BootstrapServerMessage, duration: Option<Duration>, ) -> Result<(), BootstrapError>

Writes the next message.

pub fn next_timeout( &mut self, duration: Option<Duration>, ) -> Result<BootstrapClientMessage, BootstrapError>

Read a message sent from the client (not signed).

fn decode_message_leader( &self, leader_buf: &[u8], ) -> Result<ClientMessageLeader, BootstrapError>

We are using this instead of of our library deserializer as the process is relatively straight forward and makes error-type management cleaner

Trait Implementations

impl BindingReadExact for BootstrapServerBinder

fn set_read_timeout(&mut self, duration: Option<Duration>) -> Result<(), Error>

Internal helper

fn read_exact_timeout( &mut self, buf: &mut [u8], deadline: Option<Instant>, ) -> Result<(), (Error, usize)>

similar to std::io::Read::read_exact, but with a timeout that is function-global instead of per-individual-read

impl BindingWriteExact for BootstrapServerBinder

fn set_write_timeout(&mut self, duration: Option<Duration>) -> Result<(), Error>

Internal helper

fn write_all_timeout( &mut self, write_buf: &[u8], deadline: Option<Instant>, ) -> Result<(), (Error, usize)>

impl Read for BootstrapServerBinder

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl Write for BootstrapServerBinder

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.