Struct Context

pub struct Context { /* private fields */ }

Implementations

impl Context

pub fn new(uring: Uring, spawner: LocalSpawner) -> Self

pub fn spawn<C, F>(&mut self, c: C)

where C: FnOnce(Context) -> F, F: Future<Output = ()> + 'static,

Examples found in repository

examples/echo-server.rs (line 15)

async fn run_server(mut kio: kio::Context) -> io::Result<()> {
    let mut socket = kio.listen("127.0.0.1:8080")?;

    loop {
        let conn = kio.accept(&mut socket).await?;
        kio.spawn(move |kio| async { run_conn(kio, conn).await.unwrap() });
    }
}

pub async fn accept(&mut self, socket: &mut TcpListener) -> Result<TcpStream>

Accepts a new connection on the given listener.

Examples found in repository

examples/echo-server.rs (line 14)

async fn run_server(mut kio: kio::Context) -> io::Result<()> {
    let mut socket = kio.listen("127.0.0.1:8080")?;

    loop {
        let conn = kio.accept(&mut socket).await?;
        kio.spawn(move |kio| async { run_conn(kio, conn).await.unwrap() });
    }
}

pub fn buffer(&mut self, size: usize) -> Box<[u8]>

Returns a buffer of at least the given size.

Examples found in repository

examples/echo-server.rs (line 22)

async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));
    let mut buffer = kio.buffer(4096);

    loop {
        let size = kio.read(&mut conn, &mut buffer).await?;
        if size == 0 {
            return Ok(());
        }

        kio.write_full(&mut conn, &buffer[..size]).await?;
    }
}

examples/echo-client.rs (line 23)

async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));

    let mut stream = kio.connect("127.0.0.1:8080").await?;
    let message = "hello world";

    kio.write_full(&mut stream, message.as_bytes()).await?;
    kio.write_close(&mut stream)?;

    println!("sent: {}", message);

    let mut buffer = kio.buffer(32);
    let size = kio.read_full(&mut stream, &mut buffer).await?;

    println!("received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

pub async fn connect<A>(&mut self, addr: A) -> Result<TcpStream>

where A: ToSocketAddrs,

Examples found in repository

examples/echo-client.rs (line 15)

async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));

    let mut stream = kio.connect("127.0.0.1:8080").await?;
    let message = "hello world";

    kio.write_full(&mut stream, message.as_bytes()).await?;
    kio.write_close(&mut stream)?;

    println!("sent: {}", message);

    let mut buffer = kio.buffer(32);
    let size = kio.read_full(&mut stream, &mut buffer).await?;

    println!("received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

pub fn listen<A>(&mut self, addr: A) -> Result<TcpListener>

where A: ToSocketAddrs,

Wrapper around net::TcpListener::bind.

Examples found in repository

examples/echo-server.rs (line 11)

async fn run_server(mut kio: kio::Context) -> io::Result<()> {
    let mut socket = kio.listen("127.0.0.1:8080")?;

    loop {
        let conn = kio.accept(&mut socket).await?;
        kio.spawn(move |kio| async { run_conn(kio, conn).await.unwrap() });
    }
}

pub async fn read( &mut self, stream: &mut TcpStream, buffer: &mut [u8], ) -> Result<usize>

Reads at least one byte into the buffer range and returns the size. If the stream is closed, returns zero.

Examples found in repository

examples/echo-server.rs (line 25)

async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));
    let mut buffer = kio.buffer(4096);

    loop {
        let size = kio.read(&mut conn, &mut buffer).await?;
        if size == 0 {
            return Ok(());
        }

        kio.write_full(&mut conn, &buffer[..size]).await?;
    }
}

pub async fn read_full( &mut self, stream: &mut TcpStream, buffer: &mut [u8], ) -> Result<usize>

Reads until the entire buffer range is populated or the stream is closed.

Examples found in repository

examples/echo-client.rs (line 24)

async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));

    let mut stream = kio.connect("127.0.0.1:8080").await?;
    let message = "hello world";

    kio.write_full(&mut stream, message.as_bytes()).await?;
    kio.write_close(&mut stream)?;

    println!("sent: {}", message);

    let mut buffer = kio.buffer(32);
    let size = kio.read_full(&mut stream, &mut buffer).await?;

    println!("received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

pub fn read_close(&self, stream: &mut TcpStream) -> Result<()>

pub async fn write( &mut self, stream: &mut TcpStream, buffer: &[u8], ) -> Result<usize>

Writes at least one byte within the buffer range to the socket. Returns the amount written.

pub async fn write_then( &mut self, stream: &mut TcpStream, buffer: &[u8], ) -> Result<usize>

Writes at least one byte within the buffer range to the socket before running the next task. Returns the amount written.

pub async fn write_full( &mut self, stream: &mut TcpStream, buffer: &[u8], ) -> Result<()>

Writes the entire buffer range to the socket.

Examples found in repository

examples/echo-server.rs (line 30)

async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));
    let mut buffer = kio.buffer(4096);

    loop {
        let size = kio.read(&mut conn, &mut buffer).await?;
        if size == 0 {
            return Ok(());
        }

        kio.write_full(&mut conn, &buffer[..size]).await?;
    }
}

examples/echo-client.rs (line 18)

async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));

    let mut stream = kio.connect("127.0.0.1:8080").await?;
    let message = "hello world";

    kio.write_full(&mut stream, message.as_bytes()).await?;
    kio.write_close(&mut stream)?;

    println!("sent: {}", message);

    let mut buffer = kio.buffer(32);
    let size = kio.read_full(&mut stream, &mut buffer).await?;

    println!("received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

pub fn write_close(&self, stream: &mut TcpStream) -> Result<()>

Examples found in repository

examples/echo-client.rs (line 19)

async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));

    let mut stream = kio.connect("127.0.0.1:8080").await?;
    let message = "hello world";

    kio.write_full(&mut stream, message.as_bytes()).await?;
    kio.write_close(&mut stream)?;

    println!("sent: {}", message);

    let mut buffer = kio.buffer(32);
    let size = kio.read_full(&mut stream, &mut buffer).await?;

    println!("received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

pub fn cancel(&mut self)

Cancels all active tasks.

pub fn timeout(&mut self, _expires: Duration) -> Self

Creates a new context that will be cancelled after the given duration.

Examples found in repository

examples/echo-server.rs (line 21)

async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));
    let mut buffer = kio.buffer(4096);

    loop {
        let size = kio.read(&mut conn, &mut buffer).await?;
        if size == 0 {
            return Ok(());
        }

        kio.write_full(&mut conn, &buffer[..size]).await?;
    }
}

examples/echo-client.rs (line 13)

async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
    // Set up the connection limit
    let mut kio = kio.timeout(time::Duration::from_secs(5));

    let mut stream = kio.connect("127.0.0.1:8080").await?;
    let message = "hello world";

    kio.write_full(&mut stream, message.as_bytes()).await?;
    kio.write_close(&mut stream)?;

    println!("sent: {}", message);

    let mut buffer = kio.buffer(32);
    let size = kio.read_full(&mut stream, &mut buffer).await?;

    println!("received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a copy of the value.

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

Performs copy-assignment from source.