tario

A library to asynchronously read and write TAR archives in Rust.

Tario supports the ustar TAR format. It focuses on efficiently abstracting TAR I/O rather than being a general purpose utility to make all kinds of TAR archives. If that's not what you need, there's tar-rs that you should check out.

Tario is:

• Minimal: Tario only does a few things, but well.
• Lightweight: Tario has minimal dependencies, is conservative on resources, makes no uneccessary copies and performs no allocations at runtime.
• Fast: Tario adds minimal overhead while working with archives.

API Documentation

Installation

Using Cargo:

$ cargo add tario

Or manually by editing your project's Cargo.toml:

[dependencies]
tario = 0.1

Usage

Tario builds on Tokio's async read and write traits but is otherwise not using anything at all from it.

Writing

use tokio::io::{AsyncWrite, AsyncWriteExt};
use tario::{Archive, Header};

let mut io: Vec<u8> = Vec::new();
let mut archive = Archive::new(&mut io);
let mut files = [
    // Assume a single entry for this example.
    ("hello.txt", "hello world!"),
];

for (path, contents) in files {
    let mut header = Header::new_ustar();
    header.set_path(path)?;
    header.set_size(contents.len() as u64);
    header.set_cksum();

    let mut entry = archive.add_entry(header).await?;
    entry.write(contents.as_bytes()).await?;
}

archive.finish().await?;

Reading

use std::io;
use tokio::io::{AsyncRead, AsyncReadExt};
use tario::Archive;

let io = io::Cursor::new(&[]); // Get a reader from somewhere
let mut archive = Archive::new(io);
let buf = &mut [0u8; 100];

while let Some(mut entry) = archive.next_entry().await? {
    loop {
        let bytes_written = entry.read(buf).await?;
        if bytes_written == 0 {
            // Reached entry EOF
            break;
        }
        // do_something_with_buffer(&buf[..bytes_written]);
    }
}

Roadmap

• Support for wasm-unknown-unknown (#1)
• Support no_std (#2)
• Support no_alloc (#3)

License

This project is licensed under the MIT license.