Struct QuicConnection

pub struct QuicConnection<RES> { /* private fields */ }

Implementations

impl<RES: DeserializeOwned> QuicConnection<RES>

pub async fn new<AS: AgentSigner<RES>>( url: Url, agent_signer: &AS, server_certs: &[CertificateDer<'static>], allow_quic_insecure: bool, ) -> Result<Self>

Examples found in repository

examples/benchmark_clients.rs (line 154)

async fn connect(client: usize, args: Args, registry: Arc<dyn ServiceRegistry>) {
    #[cfg(feature = "quic")]
    let default_tunnel_cert = CertificateDer::from(DEFAULT_TUNNEL_CERT.to_vec());

    #[cfg(feature = "quic")]
    let quic_certs = if let Some(cert) = args.custom_quic_cert_base64 {
        vec![CertificateDer::from(URL_SAFE.decode(&cert).expect("Custom cert should in base64 format").to_vec())]
    } else {
        vec![default_tunnel_cert]
    };
    #[cfg(feature = "tls")]
    let tls_cert = if let Some(cert) = args.custom_tls_cert_base64 {
        Certificate::from_der(&URL_SAFE.decode(cert).expect("Custom cert should in base64 format")).expect("should load custom cert")
    } else {
        Certificate::from_der(DEFAULT_TUNNEL_CERT).expect("should load default cert")
    };
    let agent_signer = AgentLocalKey::random();

    loop {
        log::info!("Connecting to connector... {:?} addr: {}", args.connector_protocol, args.connector_addr);
        let started = Instant::now();
        match args.connector_protocol {
            #[cfg(feature = "tcp")]
            Protocol::Tcp => match TcpConnection::new(args.connector_addr.clone(), &agent_signer).await {
                Ok(conn) => {
                    log::info!("Connected to connector via tcp with res {:?}", conn.response());
                    println!("{client} connected after {:?}", started.elapsed());
                    run_connection_loop(conn, registry.clone()).await;
                }
                Err(e) => {
                    log::error!("Connect to connector via tcp error: {e}");
                }
            },
            #[cfg(feature = "tls")]
            Protocol::Tls => match TlsConnection::new(args.connector_addr.clone(), &agent_signer, tls_cert.clone(), args.allow_tls_insecure).await {
                Ok(conn) => {
                    log::info!("Connected to connector via tcp with res {:?}", conn.response());
                    println!("{client} connected after {:?}", started.elapsed());
                    run_connection_loop(conn, registry.clone()).await;
                }
                Err(e) => {
                    log::error!("Connect to connector via tcp error: {e}");
                }
            },
            #[cfg(feature = "quic")]
            Protocol::Quic => match QuicConnection::new(args.connector_addr.clone(), &agent_signer, &quic_certs, args.allow_quic_insecure).await {
                Ok(conn) => {
                    log::info!("Connected to connector via quic with res {:?}", conn.response());
                    println!("{client} connected after {:?}", started.elapsed());
                    run_connection_loop(conn, registry.clone()).await;
                }
                Err(e) => {
                    log::error!("Connect to connector via quic error: {e}");
                }
            },
        }
        //TODO exponential backoff
        sleep(std::time::Duration::from_secs(1)).await;
    }
}

pub fn response(&self) -> &RES

Examples found in repository

examples/benchmark_clients.rs (line 156)

async fn connect(client: usize, args: Args, registry: Arc<dyn ServiceRegistry>) {
    #[cfg(feature = "quic")]
    let default_tunnel_cert = CertificateDer::from(DEFAULT_TUNNEL_CERT.to_vec());

    #[cfg(feature = "quic")]
    let quic_certs = if let Some(cert) = args.custom_quic_cert_base64 {
        vec![CertificateDer::from(URL_SAFE.decode(&cert).expect("Custom cert should in base64 format").to_vec())]
    } else {
        vec![default_tunnel_cert]
    };
    #[cfg(feature = "tls")]
    let tls_cert = if let Some(cert) = args.custom_tls_cert_base64 {
        Certificate::from_der(&URL_SAFE.decode(cert).expect("Custom cert should in base64 format")).expect("should load custom cert")
    } else {
        Certificate::from_der(DEFAULT_TUNNEL_CERT).expect("should load default cert")
    };
    let agent_signer = AgentLocalKey::random();

    loop {
        log::info!("Connecting to connector... {:?} addr: {}", args.connector_protocol, args.connector_addr);
        let started = Instant::now();
        match args.connector_protocol {
            #[cfg(feature = "tcp")]
            Protocol::Tcp => match TcpConnection::new(args.connector_addr.clone(), &agent_signer).await {
                Ok(conn) => {
                    log::info!("Connected to connector via tcp with res {:?}", conn.response());
                    println!("{client} connected after {:?}", started.elapsed());
                    run_connection_loop(conn, registry.clone()).await;
                }
                Err(e) => {
                    log::error!("Connect to connector via tcp error: {e}");
                }
            },
            #[cfg(feature = "tls")]
            Protocol::Tls => match TlsConnection::new(args.connector_addr.clone(), &agent_signer, tls_cert.clone(), args.allow_tls_insecure).await {
                Ok(conn) => {
                    log::info!("Connected to connector via tcp with res {:?}", conn.response());
                    println!("{client} connected after {:?}", started.elapsed());
                    run_connection_loop(conn, registry.clone()).await;
                }
                Err(e) => {
                    log::error!("Connect to connector via tcp error: {e}");
                }
            },
            #[cfg(feature = "quic")]
            Protocol::Quic => match QuicConnection::new(args.connector_addr.clone(), &agent_signer, &quic_certs, args.allow_quic_insecure).await {
                Ok(conn) => {
                    log::info!("Connected to connector via quic with res {:?}", conn.response());
                    println!("{client} connected after {:?}", started.elapsed());
                    run_connection_loop(conn, registry.clone()).await;
                }
                Err(e) => {
                    log::error!("Connect to connector via quic error: {e}");
                }
            },
        }
        //TODO exponential backoff
        sleep(std::time::Duration::from_secs(1)).await;
    }
}

Trait Implementations

impl<RES: Send + Sync> Connection<TunnelStream<RecvStream, SendStream>> for QuicConnection<RES>

fn create_outgoing<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<QuicSubConnection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn recv<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<QuicSubConnection>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,