Struct rpki_rtr::client::Client

pub struct Client<Sock, Target> { /* private fields */ }

An RTR client.

The client wraps a socket – represented by the type argument Sock which needs to support Tokio’s asynchronous writing and reading – and runs an RTR client over it. All data received will be passed on a VrpTarget of type Target.

The client keeps the socket open until either the server closes the connection, an error happens, or the client is dropped. It will periodically push a new dataset to the target.

Implementations

impl<Sock, Target> Client<Sock, Target>

pub fn new(sock: Sock, target: Target, state: Option<State>) -> Self

Creates a new client.

The client will use sock for communicating with the server and target to send updates to.

If the last state of a connection with this server is known – it can be determined by calling state on the client – it can be reused via the state argument. Make sure to also have the matching data in your target in this case since the there will not necessarily be a reset update. If you don’t have any state or don’t want to reuse an earlier session, simply pass None.

pub fn target(&self) -> &Target

Returns a reference to the target.

pub fn target_mut(&mut self) -> &mut Target

Returns a mutable reference to the target.

pub fn into_target(self) -> Target

Converts the client into its target.

pub fn state(&self) -> Option<State>

Returns the current state of the session.

The method will return None if there hasn’t been initial state and there has not been any converstation with the server yet.

impl<Sock, Target> Client<Sock, Target>where
    Sock: AsyncRead + AsyncWrite + Unpin,
    Target: VrpTarget,

pub async fn run(&mut self) -> Result<(), Error>

Runs the client.

The method will keep the client asynchronously running, fetching any new data that becomes available on the server and pushing it to the target until either the server closes the connection – in which case the method will return Ok(()) –, an error happens – which will be returned or the future gets dropped.

pub async fn update(&mut self) -> Result<Target::Update, Error>

Performs a single update of the client data.

The method will wait until the next update is due and the request one single update from the server. It will request a new update object from the target, apply the update to that object and, if the update succeeds, return the object.

pub async fn reset(&mut self) -> Result<Target::Update, Error>

Performs a reset query.