Trait AioFileExt

pub trait AioFileExt: AsFd {
    // Provided methods
    fn read_at<'a>(
        &'a self,
        buf: &'a mut [u8],
        offset: u64,
    ) -> Result<ReadAt<'a>> { ... }
    fn readv_at<'a>(
        &'a self,
        bufs: &mut [IoSliceMut<'a>],
        offset: u64,
    ) -> Result<ReadvAt<'a>> { ... }
    fn sync_all(&self) -> Result<SyncAll<'_>> { ... }
    fn write_at<'a>(&'a self, buf: &'a [u8], offset: u64) -> Result<WriteAt<'a>> { ... }
    fn writev_at<'a>(
        &'a self,
        bufs: &[IoSlice<'a>],
        offset: u64,
    ) -> Result<WritevAt<'a>> { ... }
}

Adds POSIX AIO-based asynchronous methods to files.

Provided Methods

fn read_at<'a>(&'a self, buf: &'a mut [u8], offset: u64) -> Result<ReadAt<'a>>

Asynchronous equivalent of std::fs::File::read_at

Examples

use std::fs;
use std::io::Write;
use tempfile::TempDir;
use tokio_file::AioFileExt;

const WBUF: &[u8] = b"abcdef";
const EXPECT: &[u8] = b"cdef";
let mut rbuf = vec![0; 4];
let dir = TempDir::new().unwrap();
let path = dir.path().join("foo");
let mut f = fs::File::create(&path).unwrap();
f.write(WBUF).unwrap();

let file = fs::OpenOptions::new()
    .read(true)
    .open(path)
    .unwrap();
let r = file.read_at(&mut rbuf[..], 2).unwrap().await.unwrap();
assert_eq!(&rbuf[..], &EXPECT[..]);

fn readv_at<'a>( &'a self, bufs: &mut [IoSliceMut<'a>], offset: u64, ) -> Result<ReadvAt<'a>>

Asynchronous equivalent of preadv.

Similar to preadv(2) but asynchronous. Reads a contiguous portion of a file into a scatter-gather list of buffers.

Parameters

• bufs: The destination for the read. A scatter-gather list of buffers.
• offset: Offset within the file at which to begin the read

Returns

• Ok(x): The operation was successfully created. The future may be polled and will eventually return the final status of the operation.
• Err(x): An error occurred before issueing the operation. The result may be dropped.

Examples

use std::borrow::BorrowMut;
use std::fs;
use std::io::{IoSliceMut, Write};
use tempfile::TempDir;
use tokio_file::AioFileExt;

const WBUF: &[u8] = b"abcdefghijklmnopqrwtuvwxyz";
const EXPECT0: &[u8] = b"cdef";
const EXPECT1: &[u8] = b"ghijklmn";
let l0 = 4;
let l1 = 8;
let mut rbuf0 = vec![0; l0];
let mut rbuf1 = vec![0; l1];
let mut rbufs = [IoSliceMut::new(&mut rbuf0), IoSliceMut::new(&mut rbuf1)];

let dir = TempDir::new().unwrap();
let path = dir.path().join("foo");
let mut f = fs::File::create(&path).unwrap();
f.write(WBUF).unwrap();

let file = fs::OpenOptions::new()
    .read(true)
    .open(path)
    .unwrap();
let mut r = file.readv_at(&mut rbufs[..], 2).unwrap().await.unwrap();

assert_eq!(l0 + l1, r);
assert_eq!(&rbuf0[..], &EXPECT0[..]);
assert_eq!(&rbuf1[..], &EXPECT1[..]);

fn sync_all(&self) -> Result<SyncAll<'_>>

Asynchronous equivalent of std::fs::File::sync_all

Examples

use std::borrow::BorrowMut;
use std::fs;
use std::io::Write;
use tempfile::TempDir;
use tokio_file::AioFileExt;

let dir = TempDir::new().unwrap();
let path = dir.path().join("foo");

let file = fs::OpenOptions::new()
    .write(true)
    .create(true)
    .open(path)
    .unwrap();
let r = AioFileExt::sync_all(&file).unwrap().await.unwrap();

fn write_at<'a>(&'a self, buf: &'a [u8], offset: u64) -> Result<WriteAt<'a>>

Asynchronous equivalent of std::fs::File::write_at.

Examples

use std::fs;
use std::io::Read;
use tempfile::TempDir;
use tokio_file::AioFileExt;

let contents = b"abcdef";
let mut rbuf = Vec::new();

let dir = TempDir::new().unwrap();
let path = dir.path().join("foo");
let file = fs::OpenOptions::new()
    .create(true)
    .write(true)
    .open(&path)
    .unwrap();
let r = file.write_at(contents, 0).unwrap().await.unwrap();
assert_eq!(r, contents.len());
drop(file);

let mut file = fs::File::open(path).unwrap();
assert_eq!(file.read_to_end(&mut rbuf).unwrap(), contents.len());
assert_eq!(&contents[..], &rbuf[..]);

fn writev_at<'a>( &'a self, bufs: &[IoSlice<'a>], offset: u64, ) -> Result<WritevAt<'a>>

Asynchronous equivalent of pwritev

Similar to pwritev(2) but asynchronous. Writes a scatter-gather list of buffers into a contiguous portion of a file.

Parameters

• bufs: The data to write. A scatter-gather list of buffers.
• offset: Offset within the file at which to begin the write

Returns

• Ok(x): The operation was successfully created. The future may be polled and will eventually return the final status of the operation.
• Err(x): An error occurred before issueing the operation. The result may be dropped.

Examples

use std::fs;
use std::io::{IoSlice, Read};
use tempfile::TempDir;
use tokio_file::AioFileExt;

const EXPECT: &[u8] = b"abcdefghij";
let wbuf0 = b"abcdef";
let wbuf1 = b"ghij";
let wbufs = vec![IoSlice::new(wbuf0), IoSlice::new(wbuf1)];
let mut rbuf = Vec::new();

let dir = TempDir::new().unwrap();
let path = dir.path().join("foo");
let file = fs::OpenOptions::new()
    .create(true)
    .write(true)
    .open(&path)
    .unwrap();
let r = file.writev_at(&wbufs[..], 0).unwrap().await.unwrap();

assert_eq!(r, 10);

let mut f = fs::File::open(path).unwrap();
let len = f.read_to_end(&mut rbuf).unwrap();
assert_eq!(len, EXPECT.len());
assert_eq!(rbuf, EXPECT);

Implementors

impl<T: AsFd> AioFileExt for T