kimojio 0.16.2

A thread-per-core Linux io_uring async runtime optimized for latency.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use std::{os::fd::OwnedFd, time::Instant};

use rustix_uring::Errno;

use crate::{
    AsyncStreamRead, AsyncStreamWrite,
    operations::spawn_task,
    pipe::bipipe,
    ssl2::tests::{create_openssl_acceptor, create_openssl_connector},
    tlscontext::{TlsContext, test::test_utils::CertAndKeyFileNames},
};

async fn c_server2(
    cert_and_key_file_names: &CertAndKeyFileNames,
    server_fd: OwnedFd,
    deadline: Option<Instant>,
) -> Result<(), Errno> {
    let bufsize = 16384;
    let acceptor = create_openssl_acceptor(cert_and_key_file_names);
    let ctx = acceptor.into_context();
    let tls_context = TlsContext::from_openssl(ctx);
    let mut stream = tls_context.server(bufsize, server_fd, deadline).await?;

    let mut message = [0; 5];
    stream.read(&mut message, deadline).await.unwrap();
    assert_eq!(message, "hello".as_bytes());
    stream.write("goodbye".as_bytes(), None).await.unwrap();

    stream.shutdown().await.unwrap();

    Ok(())
}
pub(crate) async fn c_client2(
    cert_and_key_file_names: &CertAndKeyFileNames,
    client_fd: OwnedFd,
    deadline: Option<Instant>,
) -> Result<(), Errno> {
    let bufsize = 16384;
    let connector = create_openssl_connector(cert_and_key_file_names);

    // TODO: need to set servername sni verification etc. openssl crate has a builder to do this.
    // Most likely we do not do this in the current implementation.
    let tls_context = TlsContext::from_openssl(connector.into_context());
    let mut stream = tls_context.client(bufsize, client_fd, deadline).await?;

    stream.write("hello".as_bytes(), None).await.unwrap();
    let mut response = [0; 7];
    stream.read(&mut response, deadline).await?;
    assert_eq!(response, "goodbye".as_bytes());

    stream.shutdown().await.unwrap();

    Ok(())
}

/// This tests constructing tls context from OpenSSL crate SslContext.
/// And use it to create a client and server stream.
#[crate::test]
async fn test_c_stream() {
    let cert_and_key_file_names =
        crate::tlscontext::test::test_utils::setup_default_certs().unwrap();
    let (client_fd, server_fd) = bipipe();
    let cert_and_key_file_names_clone = cert_and_key_file_names.clone();
    spawn_task(async move {
        c_server2(&cert_and_key_file_names_clone, server_fd, None)
            .await
            .unwrap();
    });

    c_client2(&cert_and_key_file_names, client_fd, None)
        .await
        .unwrap();
}