/**
  * {@inheritdoc}
  */
 public function flush()
 {
     if (0 === $this->queue->count()) {
         return 0;
     }
     $queue = clone $this->queue;
     $this->queue->clear();
     try {
         $responses = $this->httpAdapter->sendRequests($queue->all());
     } catch (MultiHttpAdapterException $e) {
         // Handle all networking errors: php-http only throws an exception
         // if no response is available.
         $collection = new ExceptionCollection();
         foreach ($e->getExceptions() as $exception) {
             // php-http only throws an exception if no response is available
             if (!$exception->getResponse()) {
                 // Assume networking error if no response was returned.
                 $collection->add(ProxyUnreachableException::proxyUnreachable($exception));
             }
         }
         foreach ($this->handleErrorResponses($e->getResponses()) as $exception) {
             $collection->add($exception);
         }
         throw $collection;
     }
     $exceptions = $this->handleErrorResponses($responses);
     if (count($exceptions) > 0) {
         throw new ExceptionCollection($exceptions);
     }
     return count($queue);
 }
示例#2
0
    public function testCollection()
    {
        $collection = new ExceptionCollection();
        $this->assertNull($collection->getFirst());

        $e1 = new \RuntimeException();
        $collection->add($e1);

        $e2 = new \RuntimeException('Message');
        $collection->add($e2);
        $this->assertEquals('Message', $collection->getMessage());

        $this->assertCount(2, $collection);

        $this->assertSame($e1, $collection->getFirst());

        $actual = array();
        foreach ($collection as $e) {
            $actual[] = $e;
        }
        $this->assertEquals(array($e1, $e2), $actual);
    }
示例#3
0
    /**
     * Handle request exception
     *
     * @param GuzzleExceptionCollection $exceptions
     *
     * @throws ExceptionCollection
     */
    protected 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->getRequest()->getRawHeaders(),
                    $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;
    }
示例#4
0
    /**
     * @expectedException \FOS\HttpCache\Exception\ExceptionCollection
     */
    public function testProxyClientExceptionsAreLogged()
    {
        $unreachableException = ProxyUnreachableException::proxyUnreachable('http://127.0.0.1', 'Couldn\'t connect to host');
        $responseException    = ProxyResponseException::proxyResponse('http://127.0.0.1', 403, 'Forbidden');

        $exceptions = new ExceptionCollection();
        $exceptions->add($unreachableException)->add($responseException);

        $proxyClient = \Mockery::mock('\FOS\HttpCache\ProxyClient\ProxyClientInterface')
            ->shouldReceive('flush')->once()->andThrow($exceptions)
            ->getMock();

        $cacheInvalidator = new CacheInvalidator($proxyClient);

        $logger = \Mockery::mock('\Psr\Log\LoggerInterface')
            ->shouldReceive('log')->once()
            ->with(
                'critical',
                'Request to caching proxy at http://127.0.0.1 failed with message "Couldn\'t connect to host"',
                array(
                    'exception' => $unreachableException
                )
            )
            ->shouldReceive('log')->once()
            ->with('critical', '403 error response "Forbidden" from caching proxy at http://127.0.0.1', array('exception' => $responseException))
            ->getMock();

        $cacheInvalidator->addSubscriber(new LogSubscriber($logger));

        $cacheInvalidator
            ->flush()
        ;
    }