pub struct Context { /* private fields */ }
Implementations§
Source§impl Context
impl Context
pub fn new(uring: Uring, spawner: LocalSpawner) -> Self
Sourcepub async fn accept(&mut self, socket: &mut TcpListener) -> Result<TcpStream>
pub async fn accept(&mut self, socket: &mut TcpListener) -> Result<TcpStream>
Accepts a new connection on the given listener.
Sourcepub fn buffer(&mut self, size: usize) -> Box<[u8]>
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)
19async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
20 // Set up the connection limit
21 let mut kio = kio.timeout(time::Duration::from_secs(5));
22 let mut buffer = kio.buffer(4096);
23
24 loop {
25 let size = kio.read(&mut conn, &mut buffer).await?;
26 if size == 0 {
27 return Ok(());
28 }
29
30 kio.write_full(&mut conn, &buffer[..size]).await?;
31 }
32}
More examples
examples/echo-client.rs (line 23)
11async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
12 // Set up the connection limit
13 let mut kio = kio.timeout(time::Duration::from_secs(5));
14
15 let mut stream = kio.connect("127.0.0.1:8080").await?;
16 let message = "hello world";
17
18 kio.write_full(&mut stream, message.as_bytes()).await?;
19 kio.write_close(&mut stream)?;
20
21 println!("sent: {}", message);
22
23 let mut buffer = kio.buffer(32);
24 let size = kio.read_full(&mut stream, &mut buffer).await?;
25
26 println!("received: {}", String::from_utf8_lossy(&buffer[..size]));
27
28 Ok(())
29}
Sourcepub async fn connect<A>(&mut self, addr: A) -> Result<TcpStream>where
A: ToSocketAddrs,
pub async fn connect<A>(&mut self, addr: A) -> Result<TcpStream>where
A: ToSocketAddrs,
Examples found in repository?
examples/echo-client.rs (line 15)
11async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
12 // Set up the connection limit
13 let mut kio = kio.timeout(time::Duration::from_secs(5));
14
15 let mut stream = kio.connect("127.0.0.1:8080").await?;
16 let message = "hello world";
17
18 kio.write_full(&mut stream, message.as_bytes()).await?;
19 kio.write_close(&mut stream)?;
20
21 println!("sent: {}", message);
22
23 let mut buffer = kio.buffer(32);
24 let size = kio.read_full(&mut stream, &mut buffer).await?;
25
26 println!("received: {}", String::from_utf8_lossy(&buffer[..size]));
27
28 Ok(())
29}
Sourcepub fn listen<A>(&mut self, addr: A) -> Result<TcpListener>where
A: ToSocketAddrs,
pub fn listen<A>(&mut self, addr: A) -> Result<TcpListener>where
A: ToSocketAddrs,
Wrapper around net::TcpListener::bind.
Sourcepub async fn read(
&mut self,
stream: &mut TcpStream,
buffer: &mut [u8],
) -> Result<usize>
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)
19async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
20 // Set up the connection limit
21 let mut kio = kio.timeout(time::Duration::from_secs(5));
22 let mut buffer = kio.buffer(4096);
23
24 loop {
25 let size = kio.read(&mut conn, &mut buffer).await?;
26 if size == 0 {
27 return Ok(());
28 }
29
30 kio.write_full(&mut conn, &buffer[..size]).await?;
31 }
32}
Sourcepub async fn read_full(
&mut self,
stream: &mut TcpStream,
buffer: &mut [u8],
) -> Result<usize>
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)
11async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
12 // Set up the connection limit
13 let mut kio = kio.timeout(time::Duration::from_secs(5));
14
15 let mut stream = kio.connect("127.0.0.1:8080").await?;
16 let message = "hello world";
17
18 kio.write_full(&mut stream, message.as_bytes()).await?;
19 kio.write_close(&mut stream)?;
20
21 println!("sent: {}", message);
22
23 let mut buffer = kio.buffer(32);
24 let size = kio.read_full(&mut stream, &mut buffer).await?;
25
26 println!("received: {}", String::from_utf8_lossy(&buffer[..size]));
27
28 Ok(())
29}
pub fn read_close(&self, stream: &mut TcpStream) -> Result<()>
Sourcepub async fn write(
&mut self,
stream: &mut TcpStream,
buffer: &[u8],
) -> Result<usize>
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.
Sourcepub async fn write_then(
&mut self,
stream: &mut TcpStream,
buffer: &[u8],
) -> Result<usize>
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.
Sourcepub async fn write_full(
&mut self,
stream: &mut TcpStream,
buffer: &[u8],
) -> Result<()>
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)
19async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
20 // Set up the connection limit
21 let mut kio = kio.timeout(time::Duration::from_secs(5));
22 let mut buffer = kio.buffer(4096);
23
24 loop {
25 let size = kio.read(&mut conn, &mut buffer).await?;
26 if size == 0 {
27 return Ok(());
28 }
29
30 kio.write_full(&mut conn, &buffer[..size]).await?;
31 }
32}
More examples
examples/echo-client.rs (line 18)
11async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
12 // Set up the connection limit
13 let mut kio = kio.timeout(time::Duration::from_secs(5));
14
15 let mut stream = kio.connect("127.0.0.1:8080").await?;
16 let message = "hello world";
17
18 kio.write_full(&mut stream, message.as_bytes()).await?;
19 kio.write_close(&mut stream)?;
20
21 println!("sent: {}", message);
22
23 let mut buffer = kio.buffer(32);
24 let size = kio.read_full(&mut stream, &mut buffer).await?;
25
26 println!("received: {}", String::from_utf8_lossy(&buffer[..size]));
27
28 Ok(())
29}
Sourcepub fn write_close(&self, stream: &mut TcpStream) -> Result<()>
pub fn write_close(&self, stream: &mut TcpStream) -> Result<()>
Examples found in repository?
examples/echo-client.rs (line 19)
11async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
12 // Set up the connection limit
13 let mut kio = kio.timeout(time::Duration::from_secs(5));
14
15 let mut stream = kio.connect("127.0.0.1:8080").await?;
16 let message = "hello world";
17
18 kio.write_full(&mut stream, message.as_bytes()).await?;
19 kio.write_close(&mut stream)?;
20
21 println!("sent: {}", message);
22
23 let mut buffer = kio.buffer(32);
24 let size = kio.read_full(&mut stream, &mut buffer).await?;
25
26 println!("received: {}", String::from_utf8_lossy(&buffer[..size]));
27
28 Ok(())
29}
Sourcepub fn timeout(&mut self, _expires: Duration) -> Self
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)
19async fn run_conn(mut kio: kio::Context, mut conn: net::TcpStream) -> io::Result<()> {
20 // Set up the connection limit
21 let mut kio = kio.timeout(time::Duration::from_secs(5));
22 let mut buffer = kio.buffer(4096);
23
24 loop {
25 let size = kio.read(&mut conn, &mut buffer).await?;
26 if size == 0 {
27 return Ok(());
28 }
29
30 kio.write_full(&mut conn, &buffer[..size]).await?;
31 }
32}
More examples
examples/echo-client.rs (line 13)
11async fn run(mut kio: kio::Context) -> anyhow::Result<()> {
12 // Set up the connection limit
13 let mut kio = kio.timeout(time::Duration::from_secs(5));
14
15 let mut stream = kio.connect("127.0.0.1:8080").await?;
16 let message = "hello world";
17
18 kio.write_full(&mut stream, message.as_bytes()).await?;
19 kio.write_close(&mut stream)?;
20
21 println!("sent: {}", message);
22
23 let mut buffer = kio.buffer(32);
24 let size = kio.read_full(&mut stream, &mut buffer).await?;
25
26 println!("received: {}", String::from_utf8_lossy(&buffer[..size]));
27
28 Ok(())
29}
Trait Implementations§
Auto Trait Implementations§
impl Freeze for Context
impl !RefUnwindSafe for Context
impl !Send for Context
impl !Sync for Context
impl Unpin for Context
impl !UnwindSafe for Context
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more