7 unstable releases

0.4.0 Aug 30, 2023
0.3.1 Mar 21, 2022
0.2.1 Nov 16, 2021
0.1.1 Nov 15, 2021

#126 in Compression

Download history 99/week @ 2023-11-20 238/week @ 2023-11-27 340/week @ 2023-12-04 227/week @ 2023-12-11 132/week @ 2023-12-18 258/week @ 2024-01-01 480/week @ 2024-01-08 298/week @ 2024-01-15 241/week @ 2024-01-22 124/week @ 2024-01-29 164/week @ 2024-02-05 240/week @ 2024-02-12 516/week @ 2024-02-19 256/week @ 2024-02-26 431/week @ 2024-03-04

1,447 downloads per month

MIT license

27KB
336 lines

Zipit

crates.io Documentation

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

zipit = "0.3"

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).
  • futures and tokio AsyncRead / AsyncWrite compatible. Enable either the futures-async-io or the tokio-async-io feature accordingly.

Limitations

  • 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 response:

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

~0–1.7MB
~28K SLoC