Use egeloen/http-adapter for HTTP lib abstraction

Author: ddeboer

composer.json

@@ -21,10 +21,10 @@
         }
     ],
     "require": {
-        "php": ">=5.3.3",
-        "guzzle/guzzle": "~3.0",
+        "php": ">=5.4.8",
         "symfony/event-dispatcher": "~2.3",
-        "symfony/options-resolver": "~2.3"
+        "symfony/options-resolver": "~2.3",
+        "egeloen/http-adapter": "0.7.x-dev"
     },
     "require-dev": {
         "guzzle/plugin-mock": "*",

doc/cache-invalidator.rst

@@ -195,6 +195,9 @@ implements ``\Psr\Log\LoggerInterface``. For instance, when using Monolog_::
 Then add the logger as a subscriber to the cache invalidator::
 
     use FOS\HttpCache\EventListener\LogSubscriber;
+    use FOS\HttpCache\CacheInvalidator;
+    
+    $invalidator = new CacheInvalidator(
 
     $subscriber = new LogSubscriber($monolog);
     $cacheInvalidator->getEventDispatcher()->addSubscriber($subscriber);

src/Exception/ExceptionCollection.php

@@ -15,9 +15,16 @@
  * A collection of exceptions that might occur during the flush operation of a
  * ProxyClientInterface implementation
  */
-class ExceptionCollection extends \Exception implements \IteratorAggregate, \Countable,  HttpCacheExceptionInterface
+class ExceptionCollection extends \Exception implements \IteratorAggregate, \Countable, HttpCacheExceptionInterface
 {
     private $exceptions = array();
+    
+    public function __construct(array $exceptions = array())
+    {
+        foreach ($exceptions as $exception) {
+            $this->add($exception);
+        }
+    }
 
     /**
      * Add an exception to the collection

src/Exception/HttpClientException.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace FOS\HttpCache\Exception;
+
+class HttpClientException extends \InvalidArgumentException
+{
+    public function __construct()
+    {
+        parent::__construct(
+            '$client must be an instance of HttpClientInterface,'
+            . 'a Guzzle client (deprecated) or null'
+        );
+    }
+}

src/HttpClient/BuzzAdapter.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace FOS\HttpCache\HttpClient\Adapter;
+
+use FOS\HttpCache\HttpClient\HttpClientInterface;
+
+class BuzzAdapter implements HttpClientInterface
+{
+
+}

src/HttpClient/Guzzle3Adapter.php

@@ -0,0 +1,95 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache package.
+ *
+ * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace FOS\HttpCache\HttpClient;
+
+use FOS\HttpCache\Exception\ExceptionCollection;
+use FOS\HttpCache\Exception\ProxyResponseException;
+use FOS\HttpCache\Exception\ProxyUnreachableException;
+use FOS\HttpCache\ProxyClient\Request\RequestQueue;
+use Guzzle\Common\Exception\ExceptionCollection as GuzzleExceptionCollection;
+use Guzzle\Http\Client;
+use Guzzle\Http\ClientInterface;
+use Guzzle\Http\Exception\CurlException;
+use Guzzle\Http\Exception\RequestException;
+
+class Guzzle3Adapter implements HttpClientInterface
+{
+    /**
+     * Constructor
+     *
+     * @param ClientInterface $client Guzzle3 client (optional)
+     */
+    public function __construct(ClientInterface $client = null)
+    {
+        $this->client = $client ?: new Client();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function sendRequests(RequestQueue $requests)
+    {
+        $guzzleRequests = array();
+        foreach ($requests as $request) {
+            $guzzleRequests[] = $this->client->createRequest(
+                $request->getMethod(),
+                $request->getUrl(),
+                $request->getHeaders()
+            );
+        }
+        
+        try {
+            $this->client->send($guzzleRequests);
+        } catch (GuzzleExceptionCollection $e) {
+            $this->handleException($e);
+        }
+    }
+    
+    /**
+     * Handle request exception
+     *
+     * @param GuzzleExceptionCollection $exceptions
+     *
+     * @throws ExceptionCollection
+     */
+    private function handleException(GuzzleExceptionCollection $exceptions)
+    {
+        $collection = new ExceptionCollection();
+
+        foreach ($exceptions as $exception) {
+            if ($exception instanceof CurlException) {
+                // Caching proxy unreachable
+                $e = ProxyUnreachableException::proxyUnreachable(
+                    $exception->getRequest()->getHost(),
+                    $exception->getMessage(),
+                    $exception
+                );
+            } elseif ($exception instanceof RequestException) {
+                // Other error
+                $e = ProxyResponseException::proxyResponse(
+                    $exception->getRequest()->getHost(),
+                    $exception->getCode(),
+                    $exception->getMessage(),
+                    $exception->getRequest()->getRawHeaders(),
+                    $exception
+                );
+            } else {
+                // Unexpected exception type
+                $e = $exception;
+            }
+
+            $collection->add($e);
+        }
+
+        throw $collection;
+    }
+}

src/HttpClient/GuzzleAdapter.php

@@ -0,0 +1,58 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache package.
+ *
+ * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace FOS\HttpCache\HttpClient;
+
+use FOS\HttpCache\Exception\ExceptionCollection;
+use FOS\HttpCache\ProxyClient\Request\RequestQueue;
+use GuzzleHttp\Client;
+use GuzzleHttp\ClientInterface;
+
+class GuzzleAdapter implements HttpClientInterface
+{
+    private $client;
+    
+    public function __construct(ClientInterface $client = null)
+    {
+        $this->client = $client ?: new Client();
+    }
+
+    /*
+     * {@inheritdoc}
+     */
+    public function sendRequests(RequestQueue $requests)
+    {
+        $exceptions = new ExceptionCollection();
+        
+        foreach ($requests as $request) {
+            $response = $this->client->send(
+                $this->client->createRequest(
+                    $request->getMethod(),
+                    $request->getUrl(),
+                    array(
+                        'headers' => $request->getHeaders(),
+                        'future'  => true,
+                    )
+                )
+            );
+            
+            $response->then(
+                function ($response) {
+                    // ignore
+                },
+                function ($error) use ($exceptions) {
+                    $exceptions->add($error);
+                }
+            );
+        }
+    }
+}
+ 

src/HttpClient/HttpClientInterface.php

@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache package.
+ *
+ * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace FOS\HttpCache\HttpClient;
+
+use FOS\HttpCache\Exception\ExceptionCollection;
+use FOS\HttpCache\ProxyClient\Request\RequestQueue;
+
+/**
+ * HTTP client that sends invalidation requests to a reverse caching proxy
+ */
+interface HttpClientInterface
+{
+    /**
+     * Send queued requests
+     *
+     * @param RequestQueue $requests
+     *
+     * @return int Number of invalidations
+     *
+     * @throws ExceptionCollection
+     */
+    public function sendRequests(RequestQueue $requests);
+}