Buffer: implement Psr\Http\Message\StreamInterface

refs #13623

library/Icinga/Data/StreamInterface.php

@@ -0,0 +1,182 @@
+<?php
+/* This file is part of PSR-7
+ *
+ * @see https://github.com/php-fig/http-message
+ *
+ * Copyright (c) 2014 PHP Framework Interoperability Group
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+namespace Icinga\Data;
+
+/**
+ * Describes a data stream.
+ *
+ * Typically, an instance will wrap a PHP stream; this interface provides
+ * a wrapper around the most common operations, including serialization of
+ * the entire stream to a string.
+ */
+interface StreamInterface
+{
+    /**
+     * Reads all data from the stream into a string, from the beginning to end.
+     *
+     * This method MUST attempt to seek to the beginning of the stream before
+     * reading data and read the stream until the end is reached.
+     *
+     * Warning: This could attempt to load a large amount of data into memory.
+     *
+     * This method MUST NOT raise an exception in order to conform with PHP's
+     * string casting operations.
+     *
+     * @see http://php.net/manual/en/language.oop5.magic.php#object.tostring
+     * @return string
+     */
+    public function __toString();
+
+    /**
+     * Closes the stream and any underlying resources.
+     *
+     * @return void
+     */
+    public function close();
+
+    /**
+     * Separates any underlying resources from the stream.
+     *
+     * After the stream has been detached, the stream is in an unusable state.
+     *
+     * @return resource|null Underlying PHP stream, if any
+     */
+    public function detach();
+
+    /**
+     * Get the size of the stream if known.
+     *
+     * @return int|null Returns the size in bytes if known, or null if unknown.
+     */
+    public function getSize();
+
+    /**
+     * Returns the current position of the file read/write pointer
+     *
+     * @return int Position of the file pointer
+     * @throws \RuntimeException on error.
+     */
+    public function tell();
+
+    /**
+     * Returns true if the stream is at the end of the stream.
+     *
+     * @return bool
+     */
+    public function eof();
+
+    /**
+     * Returns whether or not the stream is seekable.
+     *
+     * @return bool
+     */
+    public function isSeekable();
+
+    /**
+     * Seek to a position in the stream.
+     *
+     * @link http://www.php.net/manual/en/function.fseek.php
+     * @param int $offset Stream offset
+     * @param int $whence Specifies how the cursor position will be calculated
+     *     based on the seek offset. Valid values are identical to the built-in
+     *     PHP $whence values for `fseek()`.  SEEK_SET: Set position equal to
+     *     offset bytes SEEK_CUR: Set position to current location plus offset
+     *     SEEK_END: Set position to end-of-stream plus offset.
+     * @throws \RuntimeException on failure.
+     */
+    public function seek($offset, $whence = SEEK_SET);
+
+    /**
+     * Seek to the beginning of the stream.
+     *
+     * If the stream is not seekable, this method will raise an exception;
+     * otherwise, it will perform a seek(0).
+     *
+     * @see seek()
+     * @link http://www.php.net/manual/en/function.fseek.php
+     * @throws \RuntimeException on failure.
+     */
+    public function rewind();
+
+    /**
+     * Returns whether or not the stream is writable.
+     *
+     * @return bool
+     */
+    public function isWritable();
+
+    /**
+     * Write data to the stream.
+     *
+     * @param string $string The string that is to be written.
+     * @return int Returns the number of bytes written to the stream.
+     * @throws \RuntimeException on failure.
+     */
+    public function write($string);
+
+    /**
+     * Returns whether or not the stream is readable.
+     *
+     * @return bool
+     */
+    public function isReadable();
+
+    /**
+     * Read data from the stream.
+     *
+     * @param int $length Read up to $length bytes from the object and return
+     *     them. Fewer than $length bytes may be returned if underlying stream
+     *     call returns fewer bytes.
+     * @return string Returns the data read from the stream, or an empty string
+     *     if no bytes are available.
+     * @throws \RuntimeException if an error occurs.
+     */
+    public function read($length);
+
+    /**
+     * Returns the remaining contents in a string
+     *
+     * @return string
+     * @throws \RuntimeException if unable to read or an error occurs while
+     *     reading.
+     */
+    public function getContents();
+
+    /**
+     * Get stream metadata as an associative array or retrieve a specific key.
+     *
+     * The keys returned are identical to the keys returned from PHP's
+     * stream_get_meta_data() function.
+     *
+     * @link http://php.net/manual/en/function.stream-get-meta-data.php
+     * @param string $key Specific metadata to retrieve.
+     * @return array|mixed|null Returns an associative array if no key is
+     *     provided. Returns a specific key value if a key is provided and the
+     *     value is found, or null if the key is not found.
+     */
+    public function getMetadata($key = null);
+}

library/Icinga/File/Csv.php

@@ -3,6 +3,7 @@
 
 namespace Icinga\File;
 
+use Exception;
 use Icinga\Util\Buffer;
 use Traversable;
 
@@ -31,12 +32,17 @@ class Csv
 
     public function dump()
     {
-        $this->render()->fpassthru();
+        $this->render()->rewind();
+        $this->renderBuffer->fpassthru();
     }
 
     public function __toString()
     {
-        return (string) $this->render();
+        try {
+            return (string) $this->render();
+        } catch (Exception $e) {
+            return (string) $e;
+        }
     }
 
     /**
@@ -51,10 +57,10 @@ class Csv
             $first = true;
             foreach ($this->query as $row) {
                 if ($first) {
-                    $this->renderBuffer->append($this->renderRow(array_keys((array) $row)));
+                    $this->renderBuffer->write($this->renderRow(array_keys((array) $row)));
                     $first = false;
                 }
-                $this->renderBuffer->append($this->renderRow(array_values((array) $row)));
+                $this->renderBuffer->write($this->renderRow(array_values((array) $row)));
             }
         }
 

library/Icinga/File/Json.php

@@ -3,6 +3,7 @@
 
 namespace Icinga\File;
 
+use Exception;
 use Icinga\Exception\IcingaException;
 use Icinga\Util\Buffer;
 use stdClass;
@@ -55,7 +56,8 @@ class Json
      */
     public function dump()
     {
-        $this->render()->fpassthru();
+        $this->render()->rewind();
+        $this->renderBuffer->fpassthru();
     }
 
     /**
@@ -65,7 +67,11 @@ class Json
      */
     public function __toString()
     {
-        return (string) $this->render();
+        try {
+            return (string) $this->render();
+        } catch (Exception $e) {
+            return (string) $e;
+        }
     }
 
     /**
@@ -77,19 +83,19 @@ class Json
     {
         if ($this->renderBuffer === null) {
             $this->renderBuffer = new Buffer();
-            $this->renderBuffer->append('[');
+            $this->renderBuffer->write('[');
 
             $first = true;
             foreach ($this->query as $row) {
                 if ($first) {
                     $first = false;
                 } else {
-                    $this->renderBuffer->append(',');
+                    $this->renderBuffer->write(',');
                 }
-                $this->renderBuffer->append($this->renderRow($row));
+                $this->renderBuffer->write($this->renderRow($row));
             }
 
-            $this->renderBuffer->append(']');
+            $this->renderBuffer->write(']');
         }
 
         return $this->renderBuffer;

library/Icinga/Util/Buffer.php

@@ -3,174 +3,16 @@
 
 namespace Icinga\Util;
 
-use Icinga\Exception\IcingaException;
-
 /**
  * Stores data in memory or a temporary file not to get out of memory
  */
-class Buffer
+class Buffer extends StreamWrapper
 {
-    /**
-     * The actual buffer
-     *
-     * @var resource
-     */
-    protected $handle;
-
-    /**
-     * The amount of bytes currently stored in the buffer
-     *
-     * @var int
-     */
-    protected $size = 0;
-
-    /**
-     * Whether the current position of {@link handle} is the end of file
-     *
-     * @var bool
-     */
-    protected $atEOF = true;
-
     /**
      * Buffer constructor
      */
     public function __construct()
     {
-        $this->handle = fopen('php://temp', 'w+b');
+        parent::__construct($this->assertSuccessfulFunctionCall('fopen', array('php://temp', 'w+b')));
-    }
-
-    /**
-     * Append the given data to the buffer
-     *
-     * @param   string  $data
-     */
-    public function append($data)
-    {
-        $strlen = strlen($data);
-        if ($strlen) {
-            $this->seekToEnd();
-            $this->fwrite($this->handle, $data);
-            $this->size += $strlen;
-        }
-    }
-
-    /**
-     * Get size
-     *
-     * @return int
-     */
-    public function getSize()
-    {
-        return $this->size;
-    }
-
-    /**
-     * Get the data stored in the buffer
-     *
-     * @return  string
-     *
-     * @throws  IcingaException     In case of an error
-     */
-    public function __toString()
-    {
-        $result = '';
-
-        if ($this->size) {
-            $this->seekToBegin();
-            for (;;) {
-                $buf = fread($this->handle, $this->size);
-                if ($buf === '') {
-                    break;
-                }
-                $result .= $buf;
-            }
-
-            if (strlen($result) !== $this->size) {
-                throw new IcingaException('Couldn\'t read all data from the buffer');
-            }
-        }
-
-        return $result;
-    }
-
-    /**
-     * Pass the data stored in the buffer to the user agent (as with {@link fpassthru()})
-     */
-    public function fpassthru()
-    {
-        if ($this->size) {
-            $this->seekToBegin();
-            // fpassthru() returns the amount of bytes passed so we could perform
-            // the same error check as in __toString(), but throwing exceptions here
-            // makes no sense as we're already writing the response body
-            fpassthru($this->handle);
-        }
-    }
-
-    /**
-     * fseek({@link handle}) to the begin of the buffer if not already done
-     */
-    protected function seekToBegin()
-    {
-        if ($this->atEOF) {
-            if ($this->size) {
-                $this->fseek($this->handle, 0);
-            }
-            $this->atEOF = false;
-        }
-    }
-
-    /**
-     * fseek({@link handle}) to the end of the buffer if not already done
-     */
-    protected function seekToEnd()
-    {
-        if (! $this->atEOF) {
-            if ($this->size) {
-                $this->fseek($this->handle, 0, SEEK_END);
-            }
-            $this->atEOF = true;
-        }
-    }
-
-    /**
-     * Forwards all passed parameters to {@link fseek()}
-     *
-     * @throws  IcingaException     In case of an error
-     */
-    protected function fseek()
-    {
-        if (call_user_func_array('fseek', func_get_args()) === -1) {
-            $this->reportFunctionCallError('fseek', func_get_args());
-        }
-    }
-
-    /**
-     * Forwards all passed parameters to {@link fwrite()}
-     *
-     * @throws  IcingaException     In case of an error
-     */
-    protected function fwrite()
-    {
-        if (call_user_func_array('fwrite', func_get_args()) === 0) {
-            $this->reportFunctionCallError('fwrite', func_get_args());
-        }
-    }
-
-    /**
-     * Throw an exception telling that the given function call didn't succeed
-     *
-     * @param   string  $functionName
-     * @param   array   $passedArgs
-     *
-     * @throws  IcingaException     unconditional
-     */
-    protected function reportFunctionCallError($functionName, array $passedArgs)
-    {
-        $args = array();
-        foreach ($passedArgs as $arg) {
-            $args[] = print_r($arg, true);
-        }
-        throw new IcingaException('Couldn\'t ' . $functionName . '(' . implode(', ', $args) . ')');
     }
 }

library/Icinga/Util/StreamWrapper.php

@@ -0,0 +1,209 @@
+<?php
+/* Icinga Web 2 | (c) 2017 Icinga Development Team | GPLv2+ */
+
+namespace Icinga\Util;
+
+use Exception;
+use Icinga\Data\StreamInterface;
+use RuntimeException;
+
+/**
+ * Wrap a stream
+ */
+class StreamWrapper implements StreamInterface
+{
+    /**
+     * The stream being wrapped
+     *
+     * @var resource
+     */
+    protected $handle;
+
+    /**
+     * StreamWrapper constructor
+     *
+     * @param   resource    $handle
+     */
+    public function __construct($handle)
+    {
+        $this->handle = $handle;
+    }
+
+    /**
+     * @see {@link StreamInterface::__toString()}
+     */
+    public function __toString()
+    {
+        try {
+            $this->rewind();
+            return $this->getContents();
+        } catch (Exception $e) {
+            return (string) $e;
+        }
+    }
+
+    /**
+     * @see {@link StreamInterface::close()}
+     */
+    public function close()
+    {
+        $this->assertSuccessfulFunctionCall('fclose', array($this->handle));
+    }
+
+    /**
+     * @see {@link StreamInterface::detach()}
+     */
+    public function detach()
+    {
+        $handle = $this->handle;
+        $this->handle = null;
+        return $handle;
+    }
+
+    /**
+     * @see {@link StreamInterface::getSize()}
+     */
+    public function getSize()
+    {
+        $stats = $this->assertSuccessfulFunctionCall('fstat', array($this->handle));
+        return $stats['size'];
+    }
+
+    /**
+     * @see {@link StreamInterface::tell()}
+     */
+    public function tell()
+    {
+        return $this->assertSuccessfulFunctionCall('ftell', array($this->handle));
+    }
+
+    /**
+     * @see {@link StreamInterface::eof()}
+     */
+    public function eof()
+    {
+        return feof($this->handle);
+    }
+
+    /**
+     * @see {@link StreamInterface::isSeekable()}
+     */
+    public function isSeekable()
+    {
+        return $this->getMetadata('seekable');
+    }
+
+    /**
+     * @see {@link StreamInterface::seek()}
+     */
+    public function seek($offset, $whence = SEEK_SET)
+    {
+        $this->assertSuccessfulFunctionCall('fseek', array($this->handle, $offset, $whence), function ($value) {
+            return $value !== -1;
+        });
+    }
+
+    /**
+     * @see {@link StreamInterface::rewind()}
+     */
+    public function rewind()
+    {
+        $this->assertSuccessfulFunctionCall('rewind', array($this->handle));
+    }
+
+    /**
+     * @see {@link StreamInterface::isWritable()}
+     */
+    public function isWritable()
+    {
+        return ! preg_match('/^r(?!\+)/', $this->getMetadata('mode'));
+    }
+
+    /**
+     * @see {@link StreamInterface::write()}
+     */
+    public function write($string)
+    {
+        return $this->assertSuccessfulFunctionCall('fwrite', array($this->handle, $string));
+    }
+
+    /**
+     * @see {@link StreamInterface::isReadable()}
+     */
+    public function isReadable()
+    {
+        return preg_match('/[r|+]/', $this->getMetadata('mode'));
+    }
+
+    /**
+     * @see {@link StreamInterface::read()}
+     */
+    public function read($length)
+    {
+        return $this->assertSuccessfulFunctionCall('fread', array($this->handle, $length));
+    }
+
+    /**
+     * @see {@link StreamInterface::getContents()}
+     */
+    public function getContents()
+    {
+        return $this->assertSuccessfulFunctionCall('stream_get_contents', array($this->handle));
+    }
+
+    /**
+     * @see {@link StreamInterface::getMetadata()}
+     */
+    public function getMetadata($key = null)
+    {
+        $result = stream_get_meta_data($this->handle);
+        return isset($result[$key]) ? $result[$key] : $result;
+    }
+
+    /**
+     * Pass the data stored in the buffer to the user agent (as with {@link fpassthru()})
+     */
+    public function fpassthru()
+    {
+        // fpassthru() returns the amount of bytes passed so we could
+        // perform an error check, but throwing exceptions here makes
+        // no sense as we're already writing the response body
+        fpassthru($this->handle);
+    }
+
+    /**
+     * Call a function as with {@link call_user_func_array()}
+     *
+     * @param   string      $functionName
+     * @param   array       $args
+     * @param   callable    $resultValidator
+     *
+     * @return  mixed
+     *
+     * @throws  RuntimeException    If the function call didn't succeed
+     */
+    protected function assertSuccessfulFunctionCall($functionName, array $args, $resultValidator = null)
+    {
+        $result = call_user_func_array($functionName, $args);
+        if ($resultValidator === null ? $result === false : ! call_user_func($resultValidator, $result)) {
+            throw new RuntimeException(
+                'Error: ' . $functionName . '(' . implode(', ', array_map(array($this, 'represent'), $args))
+                    . ') = ' . $this->represent($result)
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * Return a value's string representation
+     *
+     * @param   mixed   $value
+     *
+     * @return  string
+     */
+    protected function represent($value)
+    {
+        return is_scalar($value) ? var_export($value, true) : print_r($value, true);
+    }
+}