WIP: Calculate ZIP Size

Calculates the resulting file size with the minimal amount of work
that is required.

Fixes #89

Author: maennchen

src/Exception/FileSizeIncorrectException.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ZipStream\Exception;
+
+use ZipStream\Exception;
+
+/**
+ * This Exception gets invoked if a file is not as large as it was specified.
+ */
+class FileSizeIncorrectException extends Exception
+{
+    /**
+     * @internal
+     */
+    public function __construct(
+        public readonly int $expectedSize,
+        public readonly int $actualSize
+    ) {
+        parent::__construct("File is {$actualSize} instead of {$expectedSize} bytes large. Adjust `exactSize` parameter.");
+    }
+}

src/Exception/SimulationFileUnknownException.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ZipStream\Exception;
+
+use ZipStream\Exception;
+
+/**
+ * This Exception gets invoked if a strict simulation is executed and the file
+ * information can't be determined without reading the entire file.
+ */
+class SimulationFileUnknownException extends Exception
+{
+    public function __construct()
+    {
+        parent::__construct('The details of the strict simulation file could not be determined without reading the entire file.');
+    }
+}

src/File.php

@@ -8,8 +8,10 @@
 use DateTimeInterface;
 use DeflateContext;
 use RuntimeException;
+use ZipStream\Exception\FileSizeIncorrectException;
 use ZipStream\Exception\OverflowException;
 use ZipStream\Exception\ResourceActionException;
+use ZipStream\Exception\SimulationFileUnknownException;
 use ZipStream\Exception\StreamNotReadableException;
 use ZipStream\Exception\StreamNotSeekableException;
 
@@ -32,8 +34,6 @@ class File
 
     private readonly string $fileName;
 
-    private int $totalSize = 0;
-
     /**
      * @var resource
      */
@@ -44,15 +44,18 @@ class File
      */
     public function __construct(
         string $fileName,
-        private int $startOffset,
+        private readonly OperationMode $operationMode,
+        private readonly int $startOffset,
         private readonly CompressionMethod $compressionMethod,
         private readonly string $comment,
         private readonly DateTimeInterface $lastModificationDateTime,
         private readonly int $deflateLevel,
         private readonly ?int $maxSize,
+        private readonly ?int $exactSize,
         private readonly bool $enableZip64,
         private readonly bool $enableZeroHeader,
         private readonly Closure $send,
+        private readonly Closure $recordSentBytes,
         $stream,
     ) {
         $this->fileName = self::filterFilename($fileName);
@@ -81,20 +84,61 @@ public function __construct(
 
     public function process(): string
     {
-        if (!$this->enableZeroHeader) {
+        $forecastSize = $this->forecastSize();
+
+        if ($this->enableZeroHeader) {
+            // No calculation required
+        } elseif ($this->isSimulation() && $forecastSize) {
+            $this->uncompressedSize = $forecastSize;
+            $this->compressedSize = $forecastSize;
+        } elseif ($this->operationMode === OperationMode::SIMULATE_STRICT) {
+            throw new SimulationFileUnknownException();
+        } else {
             $this->readStream(send: false);
             if (rewind($this->stream) === false) {
                 throw new ResourceActionException('rewind', $this->stream);
             }
         }
 
         $this->addFileHeader();
-        $this->readStream(send: true);
-        $this->addFileFooter();
 
+        $detectedSize = $forecastSize ?? $this->compressedSize;
+
+        if (
+            $this->isSimulation() &&
+            $detectedSize > 0
+        ) {
+            ($this->recordSentBytes)($detectedSize);
+        } elseif ($this->operationMode === OperationMode::SIMULATE_STRICT) {
+            throw new SimulationFileUnknownException();
+        } else {
+            $this->readStream(send: true);
+        }
+
+        $this->addFileFooter();
         return $this->getCdrFile();
     }
 
+    private function forecastSize(): ?int
+    {
+        if ($this->compressionMethod !== CompressionMethod::STORE) {
+            return null;
+        }
+        if ($this->exactSize) {
+            return $this->exactSize;
+        }
+        $fstat = fstat($this->stream);
+        if (!$fstat || !array_key_exists('size', $fstat) || $fstat['size'] < 1) {
+            return null;
+        }
+
+        if ($this->maxSize !== null && $this->maxSize < $fstat['size']) {
+            return $this->maxSize;
+        }
+
+        return $fstat['size'];
+    }
+
     /**
      * Create and send zip header for this file.
      */
@@ -127,8 +171,6 @@ private function addFileHeader(): void
 
 
         ($this->send)($data);
-
-        $this->totalSize +=  strlen($data);
     }
 
     /**
@@ -239,8 +281,6 @@ private function addFileFooter(): void
         }
 
         ($this->send)($footer);
-
-        $this->totalSize += strlen($footer);
     }
 
     private function readStream(bool $send): void
@@ -251,8 +291,16 @@ private function readStream(bool $send): void
 
         $deflate = $this->compressionInit();
 
-        while (!feof($this->stream) && ($this->maxSize === null || $this->uncompressedSize < $this->maxSize)) {
-            $readLength = min(($this->maxSize ?? PHP_INT_MAX) - $this->uncompressedSize, self::CHUNKED_READ_BLOCK_SIZE);
+        while (
+            !feof($this->stream) &&
+            ($this->maxSize === null || $this->uncompressedSize < $this->maxSize) &&
+            ($this->exactSize === null || $this->uncompressedSize < $this->exactSize)
+        ) {
+            $readLength = min(
+                ($this->maxSize ?? PHP_INT_MAX) - $this->uncompressedSize,
+                ($this->exactSize ?? PHP_INT_MAX) - $this->uncompressedSize,
+                self::CHUNKED_READ_BLOCK_SIZE
+            );
 
             $data = fread($this->stream, $readLength);
 
@@ -272,10 +320,13 @@ private function readStream(bool $send): void
 
             if ($send) {
                 ($this->send)($data);
-                $this->totalSize += strlen($data);
             }
         }
 
+        if ($this->exactSize && $this->uncompressedSize !== $this->exactSize) {
+            throw new FileSizeIncorrectException(expectedSize: $this->exactSize, actualSize: $this->uncompressedSize);
+        }
+
         $this->crc = hexdec(hash_final($hash));
     }
 
@@ -334,4 +385,9 @@ private function getCdrFile(): string
                 : $this->startOffset,
         );
     }
+
+    private function isSimulation(): bool
+    {
+        return $this->operationMode === OperationMode::SIMULATE_LAX || $this->operationMode === OperationMode::SIMULATE_STRICT;
+    }
 }

src/OperationMode.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ZipStream;
+
+/**
+ * ZipStream execution operation modes
+ */
+enum OperationMode
+{
+    /**
+     * Stream file into output stream
+     */
+    case NORMAL;
+
+    /**
+     * Simulate the zip to figure out the resulting file size
+     *
+     * This only supports entries where the file size is known beforehand and
+     * deflation is disabled.
+     */
+    case SIMULATE_STRICT;
+
+    /**
+     * Simulate the zip to figure out the resulting file size
+     *
+     * If the file size is not known beforehand or deflation is enabled, the
+     * entry streams will be read and rewound.
+     *
+     * If the entry does not support rewinding either, you will not be able to
+     * use the same stream in a later operation mode like `NORMAL`.
+     */
+    case SIMULATE_LAX;
+}