use std::path::{Path, PathBuf};
use async_trait::async_trait;
use tracing::debug;
use crate::error::{Aria2Error, Result};
use super::SeekableDiskWriter;
pub struct IoUringDiskWriter {
file: Option<tokio_uring::fs::File>,
path: PathBuf,
total_size: Option<u64>,
}
impl IoUringDiskWriter {
pub fn new(path: &Path, total_size: Option<u64>) -> Self {
Self {
file: None,
path: path.to_path_buf(),
total_size,
}
}
pub fn total_size(&self) -> Option<u64> {
self.total_size
}
}
#[async_trait]
impl SeekableDiskWriter for IoUringDiskWriter {
async fn open(&mut self) -> Result<()> {
if self.file.is_some() {
return Ok(());
}
if let Some(parent) = self.path.parent()
&& !parent.as_os_str().is_empty()
&& !parent.exists()
{
std::fs::create_dir_all(parent)
.map_err(|e| Aria2Error::DirCreate(format!("{}: {e}", parent.display())))?;
debug!("Created parent directories for {:?}", self.path);
}
if let Some(size) = self.total_size {
let std_file = std::fs::OpenOptions::new()
.create(true)
.write(true)
.read(true)
.open(&self.path)
.map_err(|e| Aria2Error::FileOpen(format!("{}: {e}", self.path.display())))?;
let current_size = std_file.metadata()?.len();
if current_size == 0 && size > 0 {
std_file.set_len(size)?;
debug!("Pre-allocated file to {} bytes: {:?}", size, self.path);
}
drop(std_file);
}
let file = tokio_uring::fs::OpenOptions::new()
.create(true)
.write(true)
.read(true)
.open(&self.path)
.await
.map_err(|e| Aria2Error::FileOpen(format!("io_uring open failed: {e}")))?;
debug!("Opened file for io_uring positioned I/O: {:?}", self.path);
self.file = Some(file);
Ok(())
}
async fn write_at(&mut self, offset: u64, data: &[u8]) -> Result<()> {
let file = self
.file
.as_ref()
.ok_or_else(|| Aria2Error::FileOpen("io_uring file not open".into()))?;
write_all_at_uring(file, data, offset).await
}
async fn write_bytes_at(&mut self, offset: u64, data: bytes::Bytes) -> Result<()> {
self.write_at(offset, &data).await
}
async fn read_at(&mut self, offset: u64, buf: &mut [u8]) -> Result<usize> {
let file = self
.file
.as_ref()
.ok_or_else(|| Aria2Error::Io("io_uring file not open".into()))?;
read_exact_at_uring(file, buf, offset).await
}
async fn truncate(&mut self, length: u64) -> Result<()> {
if let Some(file) = self.file.take() {
let _ = file.close().await.map_err(|e| {
Aria2Error::Io(format!("io_uring close during truncate failed: {e}"))
})?;
}
std::fs::OpenOptions::new()
.write(true)
.open(&self.path)?
.set_len(length)?;
let file = tokio_uring::fs::OpenOptions::new()
.create(true)
.write(true)
.read(true)
.open(&self.path)
.await
.map_err(|e| Aria2Error::Io(format!("io_uring reopen after truncate failed: {e}")))?;
self.file = Some(file);
Ok(())
}
async fn flush(&mut self) -> Result<()> {
if let Some(ref file) = self.file {
file.sync_all()
.await
.map_err(|e| Aria2Error::FileIo(format!("io_uring sync_all failed: {e}")))?;
}
Ok(())
}
async fn sync_data(&mut self) -> Result<()> {
self.flush().await
}
async fn sync_all(&mut self) -> Result<()> {
self.flush().await?;
crate::filesystem::durability::sync_parent_directories(&self.path).await
}
async fn len(&self) -> Result<u64> {
if self.file.is_some() {
Ok(std::fs::metadata(&self.path)
.map(|m| m.len())
.unwrap_or_else(|_| self.total_size.unwrap_or(0)))
} else if let Some(size) = self.total_size {
Ok(size)
} else {
Ok(0)
}
}
fn path(&self) -> &Path {
&self.path
}
async fn close(&mut self) -> Result<()> {
if let Some(file) = self.file.take() {
file.close()
.await
.map_err(|e| Aria2Error::FileIo(format!("io_uring close failed: {e}")))?;
}
Ok(())
}
}
async fn write_all_at_uring(
file: &tokio_uring::fs::File,
mut buf: &[u8],
mut offset: u64,
) -> Result<()> {
while !buf.is_empty() {
let (res, _) = file.write_at(buf, offset).await;
let n = res.map_err(|e| Aria2Error::FileIo(format!("io_uring write_at failed: {e}")))?;
if n == 0 {
return Err(Aria2Error::FileIo(
"io_uring write_at returned 0 — failed to write whole buffer".into(),
));
}
offset += n as u64;
buf = &buf[n..];
}
Ok(())
}
async fn read_exact_at_uring(
file: &tokio_uring::fs::File,
mut buf: &mut [u8],
mut offset: u64,
) -> Result<usize> {
let mut filled = 0usize;
while !buf.is_empty() {
let (res, returned_buf) = file.read_at(buf, offset).await;
let n = res.map_err(|e| Aria2Error::FileIo(format!("io_uring read_at failed: {e}")))?;
if n == 0 {
break; }
filled += n;
offset += n as u64;
buf = &mut returned_buf[n..];
}
Ok(filled)
}