Socket.php

<?php
/*
    This file is part of Plop, a simple logging library for PHP.

    Copyright © 2010-2014 François Poirotte

    Plop is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Plop is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Plop.  If not, see <http://www.gnu.org/licenses/>.
*/

namespace Plop\Handler;

class Socket extends \Plop\HandlerAbstract
{
    protected $host;

    protected $port;

    protected $socket;

    protected $closeOnError;

    protected $retryTime;

    protected $retryStart;

    protected $retryMax;

    protected $retryFactor;

    protected $retryPeriod;

    public function __construct($host, $port)
    {
        parent::__construct();

        if (strpos($host, ':') !== false) {
            // IPv6 addresses must be enclosed in brackets.
            $host = "[$host]";
        }

        $this->host         = $host;
        $this->port         = $port;
        $this->socket       = false;
        $this->closeOnError = false;
        $this->retryTime    = null;
        $this->retryStart   = 1.0;
        $this->retryMax     = 30.0;
        $this->retryFactor  = 2.0;
        $this->retryPeriod  = 0;
    }

    public function __destruct()
    {
        $this->close();
    }

    public function getCloseOnError()
    {
        return $this->closeOnError;
    }

    public function setCloseOnError($close)
    {
        if (!is_bool($close)) {
            throw new \Plop\Exception('Invalid value');
        }
        $this->closeOnError = $close;
        return $this;
    }

    public function getInitialRetryDelay()
    {
        return $this->retryStart;
    }

    public function setInitialRetryDelay($delay)
    {
        if (!(is_int($delay) || is_float($delay)) || $delay < 0) {
            throw new \Plop\Exception('Invalid value');
        }
        $this->retryStart = $delay;
        return $this;
    }

    public function getRetryFactor()
    {
        return $this->retryFactor;
    }

    public function setRetryFactor($factor)
    {
        if (!(is_int($factor) || is_float($factor)) || $factor < 1) {
            throw new \Plop\Exception('Invalid value');
        }
        $this->retryFactor = $factor;
        return $this;
    }

    public function getMaximumRetryDelay()
    {
        return $this->retryMax;
    }

    public function setMaximumRetryDelay($max)
    {
        if (!(is_int($max) || is_float($max)) || $max < 0) {
            throw new \Plop\Exception('Invalid value');
        }
        $this->retryMax = $max;
        return $this;
    }

    protected function makeSocket($timeout = 1)
    {
        return fsockopen(
            'tcp://' . $this->host,
            $this->port,
            $errno,
            $errstr,
            $timeout
        );
    }

    protected function getCurrentTime()
    {
        return time();
    }

    protected function createSocket()
    {
        $now = $this->getCurrentTime();
        if ($this->retryTime === null) {
            $attempt = true;
        } else {
            $attempt = ($now >= $this->retryTime);
        }

        if (!$attempt) {
            return;
        }

        $this->socket = $this->makeSocket();
        if ($this->socket !== false) {
            $this->retryTime = null;
            return;
        }

        if ($this->retryTime === null) {
            $this->retryPeriod = $this->retryStart;
        } else {
            $this->retryPeriod *= $this->retryFactor;
            if ($this->retryPeriod > $this->retryMax) {
                $this->retryPeriod = $this->retryMax;
            }
        }
        $this->retryTime = $now + $this->retryPeriod;
    }

    protected function send($s)
    {
        if (!$this->socket) {
            $this->createSocket();
        }

        if (!$this->socket) {
            return false;
        }

        $written = 0;
        while ($s != '') {
            $written = $this->write($s);
            if ($written === false) {
                throw new \Plop\Exception('Connection lost');
            }
            $s = (string) substr($s, $written);
        }
        return true;
    }

    protected function write($s)
    {
        return @fwrite($this->socket, $s);
    }

    protected function makePickle(\Plop\RecordInterface $record)
    {
        // To maintain full compatibility with Python,
        // we should emulate pickle here, but it seems
        // to be quite some work and PHP already has
        // it's own serialization mechanism anyway.
        $s      = serialize($record);
        $slen   = pack('N', strlen($s));
        return $slen.$s;
    }

    public function handleError(
        \Plop\RecordInterface $record,
        \Exception $exception
    ) {
        if ($this->closeOnError) {
            $this->close();
        }
        return parent::handleError($record, $exception);
    }

    protected function emit(\Plop\RecordInterface $record)
    {
        try {
            $s = $this->makePickle($record);
            $this->send($s);
        } catch (\Exception $e) {
            $this->handleError($record, $e);
        }
    }

    protected function close()
    {
        if (is_resource($this->socket)) {
            fclose($this->socket);
        }
        $this->socket = false;
    }
}