Struct iroh_rpc_client::gateway::GatewayClient

pub struct GatewayClient { /* private fields */ }

Implementations

impl GatewayClient

pub async fn new(addr: GatewayAddr) -> Result<Self>

Examples found in repository

src/client.rs (line 96)

    pub async fn new(cfg: Config) -> Result<Self> {
        let Config {
            gateway_addr,
            p2p_addr,
            store_addr,
            channels,
        } = cfg;

        let gateway = if let Some(addr) = gateway_addr {
            Some(
                GatewayClient::new(addr)
                    .await
                    .context("Could not create gateway rpc client")?,
            )
        } else {
            None
        };

        let n_channels = channels.unwrap_or(1);

        let mut p2p = P2pLBClient::new();
        if let Some(addr) = p2p_addr {
            for _i in 0..n_channels {
                let sc = P2pClient::new(addr.clone())
                    .await
                    .context("Could not create store rpc client")?;
                p2p.clients.push(sc);
            }
        }

        let mut store = StoreLBClient::new();
        if let Some(addr) = store_addr {
            for _i in 0..n_channels {
                let sc = StoreClient::new(addr.clone())
                    .await
                    .context("Could not create store rpc client")?;
                store.clients.push(sc);
            }
        }

        Ok(Client {
            gateway,
            p2p,
            store,
        })
    }

pub async fn version(&self) -> Result<String>

pub async fn check(&self) -> (StatusType, String)

Examples found in repository

src/client.rs (line 149)

    pub async fn check(&self) -> crate::status::ClientStatus {
        let g = if let Some(ref g) = self.gateway {
            let (s, v) = g.check().await;
            Some(ServiceStatus::new(ServiceType::Gateway, s, v))
        } else {
            None
        };
        let p = if let Some(ref p) = self.p2p.get() {
            let (s, v) = p.check().await;
            Some(ServiceStatus::new(ServiceType::P2p, s, v))
        } else {
            None
        };
        let s = if let Some(ref s) = self.store.get() {
            let (s, v) = s.check().await;
            Some(ServiceStatus::new(ServiceType::Store, s, v))
        } else {
            None
        };
        ClientStatus::new(g, p, s)
    }

pub async fn watch(&self) -> impl Stream<Item = (StatusType, String)>

Trait Implementations

impl Clone for GatewayClient

fn clone(&self) -> GatewayClient

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GatewayClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.