Use a custom fwrite behavior, to avoid random EPIPE errors

Author: joelwurtz

src/Client.php

@@ -220,7 +220,7 @@ private function doConnect($options)
 
     private function doSend($connection, $content)
     {
-        return fwrite($connection, $content);
+        return $this->fwrite($connection, $content);
     }
 
     private function doGet($connection)
@@ -254,4 +254,54 @@ private static function handleInternalError($type, $message, $file, $line)
     {
         throw new \ErrorException($message, 0, $type, $file, $line);
     }
+
+    /**
+     * Replace fwrite behavior as api is broken in PHP.
+     *
+     * @see https://secure.phabricator.com/rPHU69490c53c9c2ef2002bc2dd4cecfe9a4b080b497
+     *
+     * @param resource $stream The stream resource
+     * @param string   $bytes  Bytes written in the stream
+     *
+     * @return bool|int false if pipe is broken, number of bytes written otherwise
+     */
+    private function fwrite($stream, $bytes)
+    {
+        if (!strlen($bytes)) {
+            return 0;
+        }
+        $result = @fwrite($stream, $bytes);
+        if (0 !== $result) {
+            // In cases where some bytes are witten (`$result > 0`) or
+            // an error occurs (`$result === false`), the behavior of fwrite() is
+            // correct. We can return the value as-is.
+            return $result;
+        }
+        // If we make it here, we performed a 0-length write. Try to distinguish
+        // between EAGAIN and EPIPE. To do this, we're going to `stream_select()`
+        // the stream, write to it again if PHP claims that it's writable, and
+        // consider the pipe broken if the write fails.
+        $read = [];
+        $write = [$stream];
+        $except = [];
+        @stream_select($read, $write, $except, 0);
+        if (!$write) {
+            // The stream isn't writable, so we conclude that it probably really is
+            // blocked and the underlying error was EAGAIN. Return 0 to indicate that
+            // no data could be written yet.
+            return 0;
+        }
+        // If we make it here, PHP **just** claimed that this stream is writable, so
+        // perform a write. If the write also fails, conclude that these failures are
+        // EPIPE or some other permanent failure.
+        $result = @fwrite($stream, $bytes);
+        if (0 !== $result) {
+            // The write worked or failed explicitly. This value is fine to return.
+            return $result;
+        }
+        // We performed a 0-length write, were told that the stream was writable, and
+        // then immediately performed another 0-length write. Conclude that the pipe
+        // is broken and return `false`.
+        return false;
+    }
 }