ZipStream-PHP

https://github.com/maennchen/zipstream-php
Admin
ZipStream-PHP is a fast and simple streaming zip file downloader for PHP that generates zip files...
Tokens:10,984
Snippets:55
Trust Score:9.9
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install mbstring Polyfill via Composer

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/index.rst

Run this command to install the symfony/polyfill-mbstring package as a workaround for the missing mbstring extension.

```sh
composer require symfony/polyfill-mbstring
```

--------------------------------

### Basic Usage Example for ZipStream PHP

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/index.rst

This example shows how to create a zip stream, add files from data, path, stream, and PSR-7 stream, and finish the zip. It requires the psr/http-message and guzzlehttp/psr7 dependencies for the PSR-7 stream part.

```php
// Autoload the dependencies
require 'vendor/autoload.php';

// create a new zipstream object
$zip = new ZipStream\ZipStream(
   outputName: 'example.zip',

   // enable output of HTTP headers
   sendHttpHeaders: true,
);

// create a file named 'hello.txt'
$zip->addFile(
   fileName: 'hello.txt',
   data: 'This is the contents of hello.txt',
);

// add a file named 'some_image.jpg' from a local file 'path/to/image.jpg'
$zip->addFileFromPath(
   fileName: 'some_image.jpg',
   path: 'path/to/image.jpg',
);

// add a file named 'goodbye.txt' from an open stream resource
$filePointer = tmpfile();
fwrite($filePointer, 'The quick brown fox jumped over the lazy dog.');
rewind($filePointer);
$zip->addFileFromStream(
   fileName: 'goodbye.txt',
   stream: $filePointer,
);
fclose($filePointer);

// add a file named 'streamfile.txt' from the body of a `guzzle` response
// Setup with `psr/http-message` & `guzzlehttp/psr7` dependencies required.
$zip->addFileFromPsr7Stream(
   fileName: 'streamfile.txt',
   stream: $response->getBody(),
);

// finish the zip stream
$zip->finish();
```

--------------------------------

### Configure ZipStream options and create instance

Source: https://github.com/maennchen/zipstream-php/wiki/Available-options

Creates an ArchiveOptions object, sets various options via setters, and passes it to a new ZipStream instance. The example shows all available options with their defaults and usage notes.

```php
use ZipStream\ZipStream;
use ZipStream\Option\Archive as ArchiveOptions;

require_once 'vendor/autoload.php';

$opt = new ArchiveOptions();

// Define output stream (argument is of type resource)
$opt->setOutputStream($fd);

// Set the deflate level (default is 6; use -1 to disable it)
$opt->setDeflateLevel(6);

// Add a comment to the zip file
$opt->setComment('This is a comment.');

// Size, in bytes, of the largest file to try and load into memory (used by addFileFromPath()).  Large files may also be compressed differently; see the 'largeFileMethod' option.
$opt->setLargeFileSize(30000000);

// How to handle large files.  Legal values are STORE (the default), or DEFLATE. Store sends the file raw and is significantly faster, while DEFLATE compresses the file and is much, much slower. Note that deflate must compress the file twice and is extremely slow.
$opt->setLargeFileMethod(ZipStream\Option\Method::STORE());
$opt->setLargeFileMethod(ZipStream\Option\Method::DEFLATE());

// Send http headers (default is false)
$opt->setSendHttpHeaders(false);

// HTTP Content-Disposition.  Defaults to 'attachment', where FILENAME is the specified filename. Note that this does nothing if you are not sending HTTP headers.
$opt->setContentDisposition('attachment');

// Set the content type (does nothing if you are not sending HTTP headers)
$opt->setContentType('application/x-zip');

// Set the function called for setting headers. Default is the `header()` of PHP
$opt->setHttpHeaderCallback('header');

// Enable streaming files with single read where general purpose bit 3 indicates local file header contain zero values in crc and size fields, these appear only after file contents in data descriptor block. Default is false. Set to true if your input stream is remote (used with addFileFromStream()).
$opt->setZeroHeader(false);

// Enable reading file stat for determining file size. When a 32-bit system reads file size that is over 2 GB, invalid value appears in file size due to integer overflow. Should be disabled on 32-bit systems with method addFileFromPath if any file may exceed 2 GB. In this case file will be read in blocks and correct size will be determined from content. Default is true.
$opt->setStatFiles(true);

// Enable zip64 extension, allowing very large archives (> 4Gb or file count > 64k)
// default is true
$opt->setEnableZip64(true);

// Flush output buffer after every write
// default is false
$opt->setFlushOutput(true);

// Now that everything is set you can pass the options to the ZipStream instance
$zip = new ZipStream('example.zip', $opt);
```

--------------------------------

### Install PSR-7 Dependencies for ZipStream PHP

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/index.rst

Required if you use addFileFromPsr7Stream or a stream as outputStream.

```sh
composer require psr/http-message guzzlehttp/psr7
```

--------------------------------

### Install ZipStream PHP via Composer

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/index.rst

Use this command to add the maennchen/zipstream-php package to your project's dependencies.

```sh
composer require maennchen/zipstream-php
```

--------------------------------

### Composer Error: Missing mbstring Extension

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/index.rst

This error appears when the mbstring extension is missing. Install it or use the polyfill.

```text
Your requirements could not be resolved to an installable set of packages.

Problem 1
    - Root composer.json requires PHP extension ext-mbstring * but it is
      missing from your system. Install or enable PHP's mbstrings extension.
```

--------------------------------

### Uploading a file to S3 with ZipStream

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/Symfony.rst

Example of uploading a file to S3 with the correct permissions using stream context.

```APIDOC
## Uploading a file to S3 with ZipStream

### Description
This example shows how to upload a file to S3 with the necessary permissions (public-read ACL) using stream context.

### Method
PUT

### Endpoint
s3://{bucket}/{archivePath}

### Parameters
#### Path Parameters
- **bucket** (string) - Required - The S3 bucket name.
- **archivePath** (string) - Required - The path to the file in the bucket.

### Request Example
```php
$path = "s3://{$adapter->getBucket()}/{$this->getArchivePath()}";

// the important bit
$outputContext = stream_context_create([
    's3' => ['ACL' => 'public-read'],
]);

fopen($path, 'w', null, $outputContext);
```

### Response
No response body; the file is uploaded to S3.
```

--------------------------------

### ZipStream constructor with all options

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/Options.rst

Shows how to instantiate ZipStream with every available option. Requires the autoloader and the ZipStream class. The outputStream can be a resource or a PSR-7 StreamInterface; for the latter, install psr/http-message and guzzlehttp/psr7. The defaultDeflateLevel is 6, use -1 to disable. sendHttpHeaders defaults to true, and contentDisposition/contentType only apply when headers are sent. defaultEnableZeroHeader is useful for remote streams with addFileFromStream(). enableZip64 defaults to true for large archives. flushOutput flushes after every write.

```php
use ZipStream\ZipStream;

require_once 'vendor/autoload.php';

$zip = new ZipStream(
    // Define output stream
    // (argument is either a resource or implementing
    // `Psr\Http\Message\StreamInterface`)
    //
    // Setup with `psr/http-message` & `guzzlehttp/psr7` dependencies
    // required when using `Psr\Http\Message\StreamInterface`.
    //
    // Can also use CallbackStreamWrapper for custom output handling:
    // outputStream: CallbackStreamWrapper::open(function($data) { /* handle data */ }),
    outputStream: $filePointer,

    // Set the deflate level (default is 6; use -1 to disable it)
    defaultDeflateLevel: 6,

    // Add a comment to the zip file
    comment: 'This is a comment.',

    // Send http headers (default is true)
    sendHttpHeaders: false,

    // HTTP Content-Disposition.
    // Defaults to 'attachment', where FILENAME is the specified filename.
    // Note that this does nothing if you are not sending HTTP headers.
    contentDisposition: 'attachment',

    // Output Name for HTTP Content-Disposition
    // Defaults to no name
    outputName: "example.zip",

    // HTTP Content-Type.
    // Defaults to 'application/x-zip'.
    // Note that this does nothing if you are not sending HTTP headers.
    contentType: 'application/x-zip',

    // Set the function called for setting headers.
    // Default is the `header()` of PHP
    httpHeaderCallback: header(...),

    // Enable streaming files with single read where general purpose bit 3
    // indicates local file header contain zero values in crc and size
    // fields, these appear only after file contents in data descriptor
    // block.
    // Set to true if your input stream is remote
    // (used with addFileFromStream()).
    // Default is false.
    defaultEnableZeroHeader: false,

    // Enable zip64 extension, allowing very large archives
    // (> 4Gb or file count > 64k)
    // Default is true
    enableZip64: true,

    // Flush output buffer after every write
    // Default is false
    flushOutput: true,
);
```

--------------------------------

### Stream to callback function - Example 2: progress tracking

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/StreamOutput.rst

Tracks total bytes transferred via callback and reports progress. Uses sendHttpHeaders: false. Calls reportProgress() with cumulative byte count.

```php
// Example 2: Progress tracking
$totalBytes = 0;
$zip = new ZipStream(
    outputStream: CallbackStreamWrapper::open(function (string $data) use (&$totalBytes) {
        $totalBytes += strlen($data);
        reportProgress($totalBytes); // Report progress to your tracking system
        
        // Your actual output handling
        echo $data;
    }),
    sendHttpHeaders: false,
);

$zip->addFile('large_file.txt', str_repeat('A', 10000));
$zip->finish();
```

--------------------------------

### Stream to callback function - Example 1: multiple destinations

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/StreamOutput.rst

Streams ZIP data to a custom callback for multiple destinations: echo to browser, write to backup file, and log progress. Disables HTTP headers. Closes file handles after finish.

```php
use ZipStream\ZipStream;
use ZipStream\Stream\CallbackStreamWrapper;

// Example 1: Stream to multiple destinations with proper file handling
$backupFile = fopen('backup.zip', 'wb');
$logFile = fopen('transfer.log', 'ab');

$zip = new ZipStream(
    outputStream: CallbackStreamWrapper::open(function (string $data) use ($backupFile, $logFile) {
        // Send to browser
        echo $data;
        
        // Save to file efficiently
        fwrite($backupFile, $data);
        
        // Log transfer progress
        fwrite($logFile, "Transferred " . strlen($data) . " bytes\n");
    }),
    sendHttpHeaders: false,
);

$zip->addFile('hello.txt', 'Hello World!');
$zip->finish();

// Clean up resources
fclose($backupFile);
fclose($logFile);
```

--------------------------------

### Stream to callback function - Example 3: data transformation with stream filters

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/StreamOutput.rst

Uses built-in PHP stream filters to transform data (base64 encode) while streaming ZIP output. Avoids callback transformations for data integrity. Appends filter to output stream.

```php
// Example 3: Data transformation using PHP stream filters
// For data transformations, prefer PHP's built-in stream filters
$outputStream = fopen('php://output', 'w');
stream_filter_append($outputStream, 'convert.base64-encode');

$zip = new ZipStream(
    outputStream: $outputStream,
    sendHttpHeaders: false,
);

$zip->addFile('secret.txt', 'Confidential data');
$zip->finish();
fclose($outputStream);
```

--------------------------------

### ZipStream in Symfony Controller Action

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/Symfony.rst

Example of using ZipStream within a Symfony controller action, wrapping the stream in StreamedResponse to output a zip file to the browser.

```APIDOC
## ZipStream in Symfony Controller Action

### Description
This example demonstrates how to use ZipStream-PHP within a Symfony controller action to stream files from an AWS S3 bucket as a zip archive to the client's browser. It uses Symfony's StreamedResponse to ensure proper streaming and avoid corrupted zip files.

### Method
GET

### Endpoint
/zipstream

### Parameters
None

### Request Example
No request body required.

### Response
#### Success Response (200)
Streams a zip file named 'test.zip' containing the specified files.

#### Response Example
Binary zip file stream.

### Code Example
```php
use Symfony\Component\HttpFoundation\StreamedResponse;
use Aws\S3\S3Client;
use ZipStream;

//...

/**
* @Route("/zipstream", name="zipstream")
*/
public function zipStreamAction()
{
    // sample test file on s3
    $s3keys = array(
        "ziptestfolder/file1.txt"
    );

    $s3Client = $this->get('app.amazon.s3'); //s3client service
    $s3Client->registerStreamWrapper(); //required

    // using StreamedResponse to wrap ZipStream functionality
    // for files on AWS s3.
    $response = new StreamedResponse(function() use($s3keys, $s3Client)
    {
        // Define suitable options for ZipStream Archive.
        // this is needed to prevent issues with truncated zip files
        //initialise zipstream with output zip filename and options.
        $zip = new ZipStream\ZipStream(
            outputName: 'test.zip',
            defaultEnableZeroHeader: true,
            contentType: 'application/octet-stream',
        );

        //loop keys - useful for multiple files
        foreach ($s3keys as $key) {
            // Get the file name in S3 key so we can save it to the zip
            //file using the same name.
            $fileName = basename($key);

            // concatenate s3path.
            // replace with your bucket name or get from parameters file.
            $bucket = 'bucketname';
            $s3path = "s3://" . $bucket . "/" . $key;

            //addFileFromStream
            if ($streamRead = fopen($s3path, 'r')) {
                $zip->addFileFromStream(
                    fileName: $fileName,
                    stream: $streamRead,
                );
            } else {
                die('Could not open stream for reading');
            }
        }

        $zip->finish();

    });

    return $response;
}
```
```

--------------------------------

### Create a ZIP file with ZipStream

Source: https://github.com/maennchen/zipstream-php/blob/main/README.md

Basic usage of ZipStream to create a ZIP archive. Requires autoloading via 'vendor/autoload.php'. Creates a new ZipStream instance with output name 'example.zip' and enables HTTP headers. Adds files 'hello.txt' from a string and 'some_image.jpg' from a local path, then finishes the stream.

```php
// Autoload the dependencies
require 'vendor/autoload.php';

// create a new zipstream object
$zip = new ZipStream\ZipStream(
    outputName: 'example.zip',

    // enable output of HTTP headers
    sendHttpHeaders: true,
);

// create a file named 'hello.txt'
$zip->addFile(
    fileName: 'hello.txt',
    data: 'This is the contents of hello.txt',
);

// add a file named 'some_image.jpg' from a local file 'path/to/image.jpg'
$zip->addFileFromPath(
    fileName: 'some_image.jpg',
    path: 'path/to/image.jpg',
);

// finish the zip stream
$zip->finish();
```

--------------------------------

### Flysystem putStream with ZipStream

Source: https://github.com/maennchen/zipstream-php/wiki/FlySystem-Example

This code snippet demonstrates how to generate a zip file using ZipStream and store it via Flysystem's putStream method. It opens a memory stream, creates the zip, and saves it using a local adapter.

```APIDOC
## putStream

### Description
This example shows how to use Flysystem's putStream method to save a zip file generated by ZipStream. It opens a memory stream, creates the zip archive, and stores it using a local adapter.

### Method
PUT

### Endpoint
N/A (Flysystem method)

### Parameters
#### Request Body
- **stream** (resource) - Required - The stream containing the zip file content.
- **location** (string) - Required - The path where the file should be stored.

### Request Example
```php
$tempStream = fopen('php://memory', 'w+');
$zipStreamOptions = new Archive();
$zipStreamOptions->setOutputStream($tempStream);
$zipStream = new ZipStream('test.zip', $zipStreamOptions);
$zipStream->addFile('test.txt', 'text');
$zipStream->finish();
$adapter = new Local(__DIR__.'/path/to/folder');
$filesystem = new Filesystem($adapter);
$filesystem->putStream('test.zip', $tempStream);
fclose($tempStream);
```

### Response
#### Success Response (200)
No specific response body is documented.

#### Response Example
No response example provided.
```

--------------------------------

### Varnish VCL Configuration

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/Varnish.rst

VCL configuration to pipe requests for large file extensions, avoiding stream interception and ensuring reliable streaming of big zips.

```APIDOC
## Varnish VCL Configuration

### Description
VCL configuration to pipe requests for streaming large zip files. This prevents Varnish from intercepting the connection, which can cause random stream closes.

### vcl_recv

#### Description
Checks if the request URL ends with the specified file extensions and returns `pipe` to bypass caching.

#### Code
```vcl
sub vcl_recv {
    # Varnish can’t intercept the discussion anymore
    # helps for streaming big zips
    if (req.url ~ "\.(tar|gz|zip|7z|exe)$") {
        return (pipe);
    }
}
```

### vcl_pipe

#### Description
Sets the backend request connection header to `close` and returns `pipe`, ensuring the streaming connection is not intercepted.

#### Code
```vcl
# Varnish can’t intercept the discussion anymore
# helps for streaming big zips
sub vcl_pipe {
    set bereq.http.connection = "close";
    return (pipe);
}
```
```

--------------------------------

### VCL Configuration for Piping Archive Requests

Source: https://github.com/maennchen/zipstream-php/wiki/Varnish

Add this VCL code to your Varnish configuration file to handle large zip files. It pipes requests for .tar, .gz, .zip, .7z, and .exe files in vcl_recv, and sets the backend connection to close in vcl_pipe to prevent stream interruptions.

```vcl
sub vcl_recv {
    # Varnish can’t intercept the discussion anymore
    # helps for streaming big zips
    if (req.url ~ "\.(tar|gz|zip|7z|exe)$") {
        return (pipe);
    }
}
# Varnish can’t intercept the discussion anymore
# helps for streaming big zips
sub vcl_pipe {
    set bereq.http.connection = "close";
    return (pipe);
}
```

--------------------------------

### Uploading a file to S3 with public-read ACL using S3 stream context

Source: https://github.com/maennchen/zipstream-php/wiki/Symfony-example

When uploading to S3, ensure correct permissions (see GitHub issue #120). Create a stream context with 's3' => ['ACL' => 'public-read'] and pass it to fopen with mode 'w'.

```php
$path = "s3://{$adapter->getBucket()}/{$this->getArchivePath()}";

// the important bit
$outputContext = stream_context_create([
    's3' => ['ACL' => 'public-read'],
]);

fopen($path, 'w', null, $outputContext);

```

--------------------------------

### Stream ZIP to a custom callback with CallbackStreamWrapper

Source: https://github.com/maennchen/zipstream-php/blob/main/README.md

Advanced usage to stream ZIP data to a custom callback function instead of directly to the browser. Uses CallbackStreamWrapper::open() to handle data as it's generated, writing to multiple destinations (browser and backup file). Requires opening output and backup files with fopen(). Disables HTTP headers with sendHttpHeaders: false. Closes file resources after finishing.

```php
use ZipStream\ZipStream;
use ZipStream\Stream\CallbackStreamWrapper;

// Stream to a callback function with proper file handling
$outputFile = fopen('output.zip', 'wb');
$backupFile = fopen('backup.zip', 'wb');

$zip = new ZipStream(
    outputStream: CallbackStreamWrapper::open(function (string $data) use ($outputFile, $backupFile) {
        // Handle ZIP data as it's generated
        fwrite($outputFile, $data);
        
        // Send to multiple destinations efficiently
        echo $data; // Browser
        fwrite($backupFile, $data); // Backup file
    }),
    sendHttpHeaders: false,
);

$zip->addFile('hello.txt', 'Hello World!');
$zip->finish();

// Clean up resources
fclose($outputFile);
fclose($backupFile);
```

--------------------------------

### Stream to S3 bucket

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/StreamOutput.rst

Streams a ZIP archive directly to an S3 bucket using S3Client's stream wrapper. Requires AWS SDK for PHP configuration with region, bucket name, and credentials. Set enableZip64 to false and provide outputStream as the S3 stream.

```php
use Aws\S3\S3Client;
use Aws\Credentials\CredentialProvider;
use ZipStream\ZipStream;

$bucket = 'your bucket name';
$client = new S3Client([
    'region' => 'your region',
    'version' => 'latest',
    'bucketName' => $bucket,
    'credentials' => CredentialProvider::defaultProvider(),
]);
$client->registerStreamWrapper();

$zipFile = fopen("s3://$bucket/example.zip", 'w');

$zip = new ZipStream(
    enableZip64: false,
    outputStream: $zipFile,
);

$zip->addFile(
    fileName: 'file1.txt',
    data: 'File1 data',
);
$zip->addFile(
    fileName: 'file2.txt',
    data: 'File2 data',
);
$zip->finish();

fclose($zipFile);
```

--------------------------------

### MultipartUploadBufferStream class for S3 multipart upload

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/LargeFilesToS3.rst

Implements a PSR-7 stream that buffers data and uploads it in 5 MiB parts to S3 using the AWS SDK. It creates a multipart upload on construction, uploads parts when the buffer reaches the part size, and completes the upload on close. The class throws exceptions for seek and tell operations as it is not seekable.

```php
<?php

declare(strict_types=1);

use Aws\S3\S3ClientInterface;
use Psr\Http\Message\StreamInterface;

use function strlen;
use function substr;

final class MultipartUploadBufferStream implements StreamInterface
{
    private const int PART_SIZE = 5242880; // 5 MiB in bytes

    private string $buffer = '';
    private int $bufferSize = 0;
    private int $partNumber = 1;
    private array $parts = [];

    private string $uploadId;

    public function __construct(
        private readonly string $destinationFileName,
        private readonly string $bucket,
        private readonly S3ClientInterface $client
    ) {
        $result = $this->client->createMultipartUpload(
            [
                'Bucket'       => $bucket,
                'Key'          => $destinationFileName,
                'StorageClass' => 'REDUCED_REDUNDANCY',
            ]
        );

        $this->uploadId = $result['UploadId'];

        $this->parts['Parts'] = [];
    }

    public function write($string): int
    {
        $chunkSize           = strlen($string);

        $this->buffer     .= $string;
        $this->bufferSize += $chunkSize;

        if ($this->bufferSize >= self::PART_SIZE) {
            $this->uploadPart();
        }

        return $chunkSize;
    }

    public function close(): void
    {
        // Upload remaining closing bytes from zip
        $this->uploadPart();

        $this->client->completeMultipartUpload([
            'Bucket'          => $this->bucket,
            'Key'             => $this->destinationFileName,
            'UploadId'        => $this->uploadId,
            'MultipartUpload' => $this->parts,
        ]);

        $this->buffer = '';
        $this->bufferSize = 0;
    }

    private function uploadPart(): void
    {
        $result = $this->client->uploadPart([
            'Bucket'     => $this->bucket,
            'Key'        => $this->destinationFileName,
            'UploadId'   => $this->uploadId,
            'PartNumber' => $this->partNumber,
            'Body'       => $this->buffer,
        ]);

        $this->buffer = '';
        $this->bufferSize = 0;

        $this->parts['Parts'][$this->partNumber] = [
            'PartNumber' => $this->partNumber,
            'ETag' => $result['ETag'],
        ];

        $this->partNumber++;

        $result = null;
        gc_collect_cycles(); // To avoid memory leaks. @see github.com/aws/aws-sdk-php/issues/1273
    }

    public function __toString(): string
    {
        return $this->getContents();
    }

    public function getContents(): string
    {
        $buffer = $this->buffer;
        $this->buffer = '';
        $this->bufferSize = 0;

        return $buffer;
    }

    public function detach(): null
    {
        $this->close();

        return null;
    }

    public function getSize(): int
    {
        return $this->bufferSize;
    }

    public function isReadable(): bool
    {
        return true;
    }

    public function isWritable(): bool
    {
        return true;
    }

    public function isSeekable(): bool
    {
        return false;
    }

    public function rewind(): void
    {
        $this->seek(0);
    }

    public function seek($offset, $whence = SEEK_SET): void
    {
        throw new \RuntimeException('Cannot seek a BufferStream');
    }

    public function eof(): bool
    {
        return $this->bufferSize === 0;
    }

    public function tell(): int
    {
        throw new \RuntimeException('Cannot determine the position of a BufferStream');
    }

    public function read($length): string
    {
        $currentLength = $this->bufferSize;

```

--------------------------------

### Zip class wrapping ZipStream with Content-Length header

Source: https://github.com/maennchen/zipstream-php/wiki/ContentLength

Use this class to generate a ZIP archive with a Content-Length header. It disables compression and sends HTTP headers automatically. The getEstimate() method calculates the archive size, and finish() sends the header and streams the ZIP.

```php
class Zip
{
  /** @var string */
  private $name;

  private $files = [];

  public function __construct($name)
  {
    $this->name = $name;
  }

  public function addFile($name, $data)
  {
    $this->files[] = ['type' => 'addFile', 'name' => $name, 'data' => $data];
  }

  public function addFileFromPath($name, $path)
  {
    $this->files[] = ['type' => 'addFileFromPath', 'name' => $name, 'path' => $path];
  }

  public function getEstimate()
  {
    $estimate = 22;
    foreach ($this->files as $file) {
      $estimate += 76 + 2 * strlen($file['name']);
      if ($file['type'] === 'addFile') {
        $estimate += strlen($file['data']);
      }
      if ($file['type'] === 'addFileFromPath') {
        $estimate += filesize($file['path']);
      }
    }
    return $estimate;
  }

  public function finish()
  {
    header('Content-Length: ' . $this->getEstimate());
    $options = new \ZipStream\Option\Archive();
    $options->setSendHttpHeaders(true);
    $options->setEnableZip64(false);
    $options->setDeflateLevel(-1);
    $zip = new \ZipStream\ZipStream($this->name, $options);

    $fileOptions = new \ZipStream\Option\File();
    $fileOptions->setMethod(\ZipStream\Option\Method::STORE());
    foreach ($this->files as $file) {
      if ($file['type'] === 'addFile') {
        $zip->addFile($file['name'], $file['data'], $fileOptions);
      }
      if ($file['type'] === 'addFileFromPath') {
        $zip->addFileFromPath($file['name'], $file['path'], $fileOptions);
      }
    }
    $zip->finish();
    exit;
  }
}
```

--------------------------------

### Symfony controller action streaming S3 files with ZipStream and StreamedResponse

Source: https://github.com/maennchen/zipstream-php/wiki/Symfony-example

Wrap ZipStream in Symfony's StreamedResponse to stream files from AWS S3 to the browser. Requires aws/aws-sdk-php-symfony and registerStreamWrapper. The s3Client streams are used in 'r' mode, which are not seekable by default, so configure S3 context if seeking is needed.

```php

use Symfony\Component\HttpFoundation\StreamedResponse;
use Aws\S3\S3Client;
use ZipStream;

//...

/**
 * @Route("/zipstream", name="zipstream")
 */
public function zipStreamAction()
{
    //sample test file on s3
    $s3keys = array(
      "ziptestfolder/file1.txt"
    );

    $s3Client = $this->get('app.amazon.s3'); //s3client service
    $s3Client->registerStreamWrapper(); //required

    //using StreamedResponse to wrap ZipStream functionality for files on AWS s3.
    $response = new StreamedResponse(function() use($s3keys, $s3Client)
    {
        // Define suitable options for ZipStream Archive.
        $options = new \ZipStream\Option\Archive();
        $options->setContentType('application/octet-stream');
        // this is needed to prevent issues with truncated zip files
        $options->setZeroHeader(true);
        $options->setComment('test zip file.');

        //initialise zipstream with output zip filename and options.
        $zip = new ZipStream\ZipStream('test.zip', $options);

        //loop keys - useful for multiple files
        foreach ($s3keys as $key) {
            // Get the file name in S3 key so we can save it to the zip
            //file using the same name.
            $fileName = basename($key);

            //concatenate s3path.
            $bucket = 'bucketname'; //replace with your bucket name or get from parameters file.
            $s3path = "s3://" . $bucket . "/" . $key;

            //addFileFromStream
            if ($streamRead = fopen($s3path, 'r')) {
              $zip->addFileFromStream($fileName, $streamRead);
            } else {
              die('Could not open stream for reading');
            }
        }

        $zip->finish();

    });

    return $response;
}

```

--------------------------------

### Disable nginx buffering with X-Accel-Buffering header

Source: https://github.com/maennchen/zipstream-php/blob/main/guides/Nginx.rst

Set the X-Accel-Buffering header to 'no' to prevent nginx from buffering the response. Use the first line for a plain PHP header, or the second line when using Symfony's Response class.

```php
header('X-Accel-Buffering: no');
# or with the Response class from Symfony
$response->headers->set('X-Accel-Buffering', 'no');
```

--------------------------------

### Add PSR-7 Stream to Zip Archive

Source: https://github.com/maennchen/zipstream-php/wiki/Usage-with-PSR-7-Streams

Use this snippet to add a file from a PSR-7 stream to the zip archive. The stream is obtained from the response body, and the file is named 'streamfile.txt' in the archive.

```php
$stream = $response->getBody();
// add a file named 'streamfile.txt' from the content of the stream
$zip->addFileFromPsr7Stream('streamfile.txt', $stream);
```
Tokens:
Raw