Struct hyper_alpn::AlpnConnector

pub struct AlpnConnector { /* private fields */ }

Connector for Application-Layer Protocol Negotiation to form a TLS connection for Hyper.

Implementations

impl AlpnConnector

pub fn new() -> Self

Construct a new AlpnConnector.

pub fn with_client_cert(cert_pem: &[u8], key_pem: &[u8]) -> Result<Self, Error>

Construct a new AlpnConnector with a custom certificate and private key, which should be in PEM format.

extern crate openssl;
extern crate hyper;
extern crate hyper_alpn;
extern crate tokio;

use hyper_alpn::AlpnConnector;
use hyper::Client;
use openssl::pkcs12::Pkcs12;
use std::{fs::File, io::Read};

fn main() {
    let mut certificate = File::open("path/to/cert.p12").unwrap();
    let mut der: Vec<u8> = Vec::new();
    certificate.read_to_end(&mut der).unwrap();

    let pkcs = Pkcs12::from_der(&der)
        .unwrap()
        .parse("my_p12_password")
        .unwrap();

    let connector = AlpnConnector::with_client_cert(
        &pkcs.cert.to_pem().unwrap(),
        &pkcs.pkey.private_key_to_pem_pkcs8().unwrap(),
    ).unwrap();

    let mut builder = Client::builder();
    builder.http2_only(true);

    let client: Client<AlpnConnector> = builder.build(connector);
}

Trait Implementations

impl Clone for AlpnConnector

fn clone(&self) -> AlpnConnector

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AlpnConnector

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

Formats the value using the given formatter.

impl Default for AlpnConnector

fn default() -> Self

Returns the “default value” for a type.

impl Service<Uri> for AlpnConnector

type Response = AlpnStream

Responses given by the service.

type Error = Error

Errors produced by the service.

type Future = AlpnConnecting

The future response value.

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, dst: Uri) -> Self::Future

Process the request and return the response asynchronously.