diff -r 5b37998e522e -r 162c1de6545a web/lib/Zend/Wildfire/Channel/HttpHeaders.php
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/Zend/Wildfire/Channel/HttpHeaders.php	Fri Mar 11 15:05:35 2011 +0100
@@ -0,0 +1,343 @@
+<?php
+/**
+ * Zend Framework
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * It is also available through the world-wide-web at this URL:
+ * http://framework.zend.com/license/new-bsd
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to license@zend.com so we can send you a copy immediately.
+ *
+ * @category   Zend
+ * @package    Zend_Wildfire
+ * @subpackage Channel
+ * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ * @version    $Id: HttpHeaders.php 23096 2010-10-12 20:36:15Z cadorn $
+ */
+
+/** Zend_Wildfire_Channel_Interface */
+require_once 'Zend/Wildfire/Channel/Interface.php';
+
+/** Zend_Controller_Request_Abstract */
+require_once('Zend/Controller/Request/Abstract.php');
+
+/** Zend_Controller_Response_Abstract */
+require_once('Zend/Controller/Response/Abstract.php');
+
+/** Zend_Controller_Plugin_Abstract */
+require_once 'Zend/Controller/Plugin/Abstract.php';
+
+/** Zend_Wildfire_Protocol_JsonStream */
+require_once 'Zend/Wildfire/Protocol/JsonStream.php';
+
+/** Zend_Controller_Front **/
+require_once 'Zend/Controller/Front.php';
+
+/**
+ * Implements communication via HTTP request and response headers for Wildfire Protocols.
+ *
+ * @category   Zend
+ * @package    Zend_Wildfire
+ * @subpackage Channel
+ * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license    http://framework.zend.com/license/new-bsd     New BSD License
+ */
+class Zend_Wildfire_Channel_HttpHeaders extends Zend_Controller_Plugin_Abstract implements Zend_Wildfire_Channel_Interface
+{
+    /**
+     * The string to be used to prefix the headers.
+     * @var string
+     */
+    protected static $_headerPrefix = 'X-WF-';
+
+    /**
+     * Singleton instance
+     * @var Zend_Wildfire_Channel_HttpHeaders
+     */
+    protected static $_instance = null;
+
+    /**
+     * The index of the plugin in the controller dispatch loop plugin stack
+     * @var integer
+     */
+    protected static $_controllerPluginStackIndex = 999;
+
+    /**
+     * The protocol instances for this channel
+     * @var array
+     */
+    protected $_protocols = null;
+
+    /**
+     * Initialize singleton instance.
+     *
+     * @param string $class OPTIONAL Subclass of Zend_Wildfire_Channel_HttpHeaders
+     * @return Zend_Wildfire_Channel_HttpHeaders Returns the singleton Zend_Wildfire_Channel_HttpHeaders instance
+     * @throws Zend_Wildfire_Exception
+     */
+    public static function init($class = null)
+    {
+        if (self::$_instance !== null) {
+            require_once 'Zend/Wildfire/Exception.php';
+            throw new Zend_Wildfire_Exception('Singleton instance of Zend_Wildfire_Channel_HttpHeaders already exists!');
+        }
+        if ($class !== null) {
+            if (!is_string($class)) {
+                require_once 'Zend/Wildfire/Exception.php';
+                throw new Zend_Wildfire_Exception('Third argument is not a class string');
+            }
+
+            if (!class_exists($class)) {
+                require_once 'Zend/Loader.php';
+                Zend_Loader::loadClass($class);
+            }
+
+            self::$_instance = new $class();
+
+            if (!self::$_instance instanceof Zend_Wildfire_Channel_HttpHeaders) {
+                self::$_instance = null;
+                require_once 'Zend/Wildfire/Exception.php';
+                throw new Zend_Wildfire_Exception('Invalid class to third argument. Must be subclass of Zend_Wildfire_Channel_HttpHeaders.');
+            }
+        } else {
+            self::$_instance = new self();
+        }
+
+        return self::$_instance;
+    }
+
+
+    /**
+     * Get or create singleton instance
+     *
+     * @param $skipCreate boolean True if an instance should not be created
+     * @return Zend_Wildfire_Channel_HttpHeaders
+     */
+    public static function getInstance($skipCreate=false)
+    {
+        if (self::$_instance===null && $skipCreate!==true) {
+            return self::init();
+        }
+        return self::$_instance;
+    }
+
+    /**
+     * Destroys the singleton instance
+     *
+     * Primarily used for testing.
+     *
+     * @return void
+     */
+    public static function destroyInstance()
+    {
+        self::$_instance = null;
+    }
+
+    /**
+     * Get the instance of a give protocol for this channel
+     *
+     * @param string $uri The URI for the protocol
+     * @return object Returns the protocol instance for the diven URI
+     */
+    public function getProtocol($uri)
+    {
+        if (!isset($this->_protocols[$uri])) {
+            $this->_protocols[$uri] = $this->_initProtocol($uri);
+        }
+
+        $this->_registerControllerPlugin();
+
+        return $this->_protocols[$uri];
+    }
+
+    /**
+     * Initialize a new protocol
+     *
+     * @param string $uri The URI for the protocol to be initialized
+     * @return object Returns the new initialized protocol instance
+     * @throws Zend_Wildfire_Exception
+     */
+    protected function _initProtocol($uri)
+    {
+        switch ($uri) {
+            case Zend_Wildfire_Protocol_JsonStream::PROTOCOL_URI;
+                return new Zend_Wildfire_Protocol_JsonStream();
+        }
+        require_once 'Zend/Wildfire/Exception.php';
+        throw new Zend_Wildfire_Exception('Tyring to initialize unknown protocol for URI "'.$uri.'".');
+    }
+
+
+    /**
+     * Flush all data from all protocols and send all data to response headers.
+     *
+     * @return boolean Returns TRUE if data was flushed
+     */
+    public function flush()
+    {
+        if (!$this->_protocols || !$this->isReady()) {
+            return false;
+        }
+
+        foreach ( $this->_protocols as $protocol ) {
+
+            $payload = $protocol->getPayload($this);
+
+            if ($payload) {
+                foreach( $payload as $message ) {
+
+                    $this->getResponse()->setHeader(self::$_headerPrefix.$message[0],
+                                                    $message[1], true);
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Set the index of the plugin in the controller dispatch loop plugin stack
+     *
+     * @param integer $index The index of the plugin in the stack
+     * @return integer The previous index.
+     */
+    public static function setControllerPluginStackIndex($index)
+    {
+        $previous = self::$_controllerPluginStackIndex;
+        self::$_controllerPluginStackIndex = $index;
+        return $previous;
+    }
+
+    /**
+     * Register this object as a controller plugin.
+     *
+     * @return void
+     */
+    protected function _registerControllerPlugin()
+    {
+        $controller = Zend_Controller_Front::getInstance();
+        if (!$controller->hasPlugin(get_class($this))) {
+            $controller->registerPlugin($this, self::$_controllerPluginStackIndex);
+        }
+    }
+
+
+    /*
+     * Zend_Wildfire_Channel_Interface
+     */
+
+    /**
+     * Determine if channel is ready.
+     *
+     * The channel is ready as long as the request and response objects are initialized,
+     * can send headers and the FirePHP header exists in the User-Agent.
+     *
+     * If the header does not exist in the User-Agent, no appropriate client
+     * is making this request and the messages should not be sent.
+     *
+     * A timing issue arises when messages are logged before the request/response
+     * objects are initialized. In this case we do not yet know if the client
+     * will be able to accept the messages. If we consequently indicate that
+     * the channel is not ready, these messages will be dropped which is in
+     * most cases not the intended behaviour. The intent is to send them at the
+     * end of the request when the request/response objects will be available
+     * for sure.
+     *
+     * If the request/response objects are not yet initialized we assume if messages are
+     * logged, the client will be able to receive them. As soon as the request/response
+     * objects are availoable and a message is logged this assumption is challenged.
+     * If the client cannot accept the messages any further messages are dropped
+     * and messages sent prior are kept but discarded when the channel is finally
+     * flushed at the end of the request.
+     *
+     * When the channel is flushed the $forceCheckRequest option is used to force
+     * a check of the request/response objects. This is the last verification to ensure
+     * messages are only sent when the client can accept them.
+     *
+     * @param boolean $forceCheckRequest OPTIONAL Set to TRUE if the request must be checked
+     * @return boolean Returns TRUE if channel is ready.
+     */
+    public function isReady($forceCheckRequest=false)
+    {
+        if (!$forceCheckRequest
+            && !$this->_request
+            && !$this->_response
+        ) {
+            return true;
+        }
+
+        if (!($this->getRequest() instanceof Zend_Controller_Request_Http)) {
+            return false;
+        }
+
+        return ($this->getResponse()->canSendHeaders()
+                && (preg_match_all(
+                        '/\s?FirePHP\/([\.\d]*)\s?/si',
+                        $this->getRequest()->getHeader('User-Agent'),
+                        $m
+                    ) ||
+                    (($header = $this->getRequest()->getHeader('X-FirePHP-Version'))
+                     && preg_match_all('/^([\.\d]*)$/si', $header, $m)
+                   ))
+               );
+    }
+
+
+    /*
+     * Zend_Controller_Plugin_Abstract
+     */
+
+    /**
+     * Flush messages to headers as late as possible but before headers have been sent.
+     *
+     * @return void
+     */
+    public function dispatchLoopShutdown()
+    {
+        $this->flush();
+    }
+
+    /**
+     * Get the request object
+     *
+     * @return Zend_Controller_Request_Abstract
+     * @throws Zend_Wildfire_Exception
+     */
+    public function getRequest()
+    {
+        if (!$this->_request) {
+            $controller = Zend_Controller_Front::getInstance();
+            $this->setRequest($controller->getRequest());
+        }
+        if (!$this->_request) {
+            require_once 'Zend/Wildfire/Exception.php';
+            throw new Zend_Wildfire_Exception('Request objects not initialized.');
+        }
+        return $this->_request;
+    }
+
+    /**
+     * Get the response object
+     *
+     * @return Zend_Controller_Response_Abstract
+     * @throws Zend_Wildfire_Exception
+     */
+    public function getResponse()
+    {
+        if (!$this->_response) {
+            $response = Zend_Controller_Front::getInstance()->getResponse();
+            if ($response) {
+                $this->setResponse($response);
+            }
+        }
+        if (!$this->_response) {
+            require_once 'Zend/Wildfire/Exception.php';
+            throw new Zend_Wildfire_Exception('Response objects not initialized.');
+        }
+        return $this->_response;
+    }
+}