Struct openethereum::informant::Informant

pub struct Informant<T> {
    last_tick: RwLock<Instant>,
    with_color: bool,
    target: T,
    snapshot: Option<Arc<SnapshotService>>,
    rpc_stats: Option<Arc<RpcStats>>,
    last_import: Mutex<Instant>,
    skipped: AtomicUsize,
    skipped_txs: AtomicUsize,
    in_shutdown: AtomicBool,
    last_report: Mutex<ClientReport>,
}

Fields

last_tick: RwLock<Instant>

with_color: bool

target: T

snapshot: Option<Arc<SnapshotService>>

rpc_stats: Option<Arc<RpcStats>>

last_import: Mutex<Instant>

skipped: AtomicUsize

skipped_txs: AtomicUsize

in_shutdown: AtomicBool

last_report: Mutex<ClientReport>

Implementations

impl<T: InformantData> Informant<T>

pub fn new(
    target: T,
    snapshot: Option<Arc<SnapshotService>>,
    rpc_stats: Option<Arc<RpcStats>>,
    with_color: bool
) -> Self

Make a new instance potentially with_color output.

pub fn shutdown(&self)

Signal that we’re shutting down; no more output necessary.

pub fn tick(&self)

Trait Implementations

impl ChainNotify for Informant<FullNodeInformantData>

fn new_blocks(&self, new_blocks: NewBlocks)

fires when chain has new blocks.

fn start(&self)

fires when chain achieves active mode

fn stop(&self)

fires when chain achieves passive mode

fn broadcast(&self, _message_type: ChainMessageType)

fires when chain broadcasts a message

fn block_pre_import(
    &self,
    _bytes: &Vec<u8, Global>,
    _hash: &H256,
    _difficulty: &U256
)

fires when new block is about to be imported implementations should be light

fn transactions_received(&self, _txs: &[UnverifiedTransaction], _peer_id: usize)

fires when new transactions are received from a peer

impl<T: InformantData> IoHandler<ClientIoMessage> for Informant<T>

fn initialize(&self, io: &IoContext<ClientIoMessage>)

Initialize the handler

fn timeout(&self, _io: &IoContext<ClientIoMessage>, timer: TimerToken)

Timer function called after a timeout created with HandlerIo::timeout.

fn message(&self, _io: &IoContext<Message>, _message: &Message)

Called when a broadcasted message is received. The message can only be sent from a different IO handler.

fn stream_hup(&self, _io: &IoContext<Message>, _stream: usize)

Called when an IO stream gets closed

fn stream_readable(&self, _io: &IoContext<Message>, _stream: usize)

Called when an IO stream can be read from

fn stream_writable(&self, _io: &IoContext<Message>, _stream: usize)

Called when an IO stream can be written to

fn register_stream(
    &self,
    _stream: usize,
    _reg: Token,
    _event_loop: &mut EventLoop<IoManager<Message>>
)

Register a new stream with the event loop

fn update_stream(
    &self,
    _stream: usize,
    _reg: Token,
    _event_loop: &mut EventLoop<IoManager<Message>>
)

Re-register a stream with the event loop

fn deregister_stream(
    &self,
    _stream: usize,
    _event_loop: &mut EventLoop<IoManager<Message>>
)

Deregister a stream. Called whenstream is removed from event loop