#io #async #non-blocking #zip #archive

zipit

Create and stream a Zip archive into an AsyncWrite

4 releases

Uses new Rust 2021

0.2.1 Nov 16, 2021
0.2.0 Nov 16, 2021
0.1.1 Nov 15, 2021
0.1.0 Nov 15, 2021

#61 in Compression

MIT license

21KB
266 lines

Zipit

crates.io Documentation

🗄️ Create and stream a Zip archive into an AsyncWrite 🗄️

zipit = "0.2"

Features

  • Stream on the fly an archive from multiple AsyncRead objects.
  • Single read / seek free implementation (the CRC and file size are calculated while streaming and are sent afterwards).
  • Archive size pre-calculation (useful if you want to set the Content-Length before streaming).

Limitations

  • Depends on tokio's AsyncRead and AsyncWrite traits.
  • No compression (stored method only).
  • Only files (no directories).
  • No customizable external file attributes.

Examples

File system

Write a Zip archive to the file system using tokio::fs::File:

use std::io::Cursor;
use tokio::fs::File;
use zipit::{Archive, FileDateTime};

#[tokio::main]
async fn main() {
    let file = File::create("archive.zip").await.unwrap();
    let mut archive = Archive::new(file);
    archive.append(
        "file1.txt".to_owned(),
        FileDateTime::now(),
        &mut Cursor::new(b"hello\n".to_vec()),
    ).await.unwrap();
    archive.append(
        "file2.txt".to_owned(),
        FileDateTime::now(),
        &mut Cursor::new(b"world\n".to_vec()),
    ).await.unwrap();
    archive.finalize().await.unwrap();
}

Hyper

Stream a Zip archive as a hyper reponse:

use std::io::Cursor;
use hyper::{header, Body, Request, Response, Server, StatusCode};
use tokio::io::duplex;
use tokio_util::io::ReaderStream;
use zipit::{archive_size, Archive, FileDateTime};

async fn zip_archive(_req: Request<Body>) -> Result<Response<Body>, hyper::http::Error> {
    let (filename_1, mut fd_1) = (String::from("file1.txt"), Cursor::new(b"hello\n".to_vec()));
    let (filename_2, mut fd_2) = (String::from("file2.txt"), Cursor::new(b"world\n".to_vec()));
    let archive_size = archive_size([
        (filename_1.as_ref(), fd_1.get_ref().len()),
        (filename_2.as_ref(), fd_2.get_ref().len()),
    ]);

    let (w, r) = duplex(4096);
    tokio::spawn(async move {
        let mut archive = Archive::new(w);
        archive
            .append(
                filename_1,
                FileDateTime::now(),
                &mut fd_1,
            )
            .await
            .unwrap();
        archive
            .append(
                filename_2,
                FileDateTime::now(),
                &mut fd_2,
            )
            .await
            .unwrap();
        archive.finalize().await.unwrap();
    });

    Response::builder()
        .status(StatusCode::OK)
        .header(header::CONTENT_LENGTH, archive_size)
        .header(header::CONTENT_TYPE, "application/zip")
        .body(Body::wrap_stream(ReaderStream::new(r)))
}

Dependencies

~3MB
~41K SLoC