FOS\HttpCache\ProxyClient\Varnish

Complexity

Total Complexity

18

Size/Duplication

Total Lines	151
Duplicated Lines	4.64 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getTagsHeaderName()	0	4	1
A	ban()	0	11	1
A	purge()	0	6	1
A	refresh()	7	7	1
A	getTagsHeaderValue()	0	4	2
B	invalidateTags()	0	29	6
B	banPath()	0	22	5
B	configureOptions()	0	25	1

<?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\ProxyClient;

use FOS\HttpCache\Exception\InvalidArgumentException;
use FOS\HttpCache\ProxyClient\Invalidation\BanInterface;
use FOS\HttpCache\ProxyClient\Invalidation\PurgeInterface;
use FOS\HttpCache\ProxyClient\Invalidation\RefreshInterface;
use FOS\HttpCache\ProxyClient\Invalidation\TagsInterface;

/**
 * Varnish HTTP cache invalidator.
 *
 * Additional constructor options:
 * - tags_header         Header for tagging responses, defaults to X-Cache-Tags
 * - header_length       Maximum header length, defaults to 7500 bytes
 * - default_ban_headers Map of headers that are set on each ban request,
 *                       merged with the built-in headers
 *
 * @author David de Boer <david@driebit.nl>
 */
class Varnish extends HttpProxyClient implements BanInterface, PurgeInterface, RefreshInterface, TagsInterface
{
    const HTTP_METHOD_BAN = 'BAN';
    const HTTP_METHOD_PURGE = 'PURGE';
    const HTTP_METHOD_REFRESH = 'GET';
    const HTTP_HEADER_HOST = 'X-Host';
    const HTTP_HEADER_URL = 'X-Url';
    const HTTP_HEADER_CONTENT_TYPE = 'X-Content-Type';
    const DEFAULT_HTTP_HEADER_CACHE_TAGS = 'X-Cache-Tags';
    const DEFAULT_HTTP_PURGE_HEADER_CACHE_TAGS = 'key';

    /**
     * {@inheritdoc}
     */
    public function invalidateTags(array $tags)
    {
        $tagMode = $this->options['tag_mode'];
        $escapedTags = array_map('preg_quote', $this->escapeTags($tags));

        if ($tagMode === 'purge_single') {
            $elems = 1;
        } elseif (mb_strlen(implode('|', $escapedTags)) >= $this->options['header_length']) {
            /*
             * estimate the amount of tags to invalidate by dividing the max
             * header length by the largest tag (minus 1 for the implode character)
             */
            $tagsize = max(array_map('mb_strlen', $escapedTags));
            $elems = floor($this->options['header_length'] / ($tagsize - 1)) ?: 1;
        } else {
            $elems = count($escapedTags);
        }

        foreach (array_chunk($escapedTags, $elems) as $tagchunk) {
            if ($tagMode === 'ban') {
                $tagExpression = sprintf('(%s)(,.+)?$', implode('|', $tagchunk));
                $this->ban([$this->options['tags_header'] => $tagExpression]);
            } else {
                $this->purge('/', [$this->options['tags_purge_header'] => implode(' ', $tagchunk)]);
            }
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getTagsHeaderValue(array $tags)
    {
        return implode(($this->options['tag_mode'] === 'ban' ? ',' : ' '), array_unique($this->escapeTags($tags)));
    }

    /**
     * {@inheritdoc}
     */
    public function getTagsHeaderName()
    {
        return $this->options['tags_header'];
    }

    /**
     * {@inheritdoc}
     */
    public function ban(array $headers)
    {
        $headers = array_merge(
            $this->options['default_ban_headers'],
            $headers
        );

        $this->queueRequest(self::HTTP_METHOD_BAN, '/', $headers);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function banPath($path, $contentType = null, $hosts = null)
    {
        if (is_array($hosts)) {
            if (!count($hosts)) {
                throw new InvalidArgumentException('Either supply a list of hosts or null, but not an empty array.');
            }
            $hosts = '^('.implode('|', $hosts).')$';
        }

        $headers = [
            self::HTTP_HEADER_URL => $path,
        ];

        if ($contentType) {

The expression $contentType of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $headers[self::HTTP_HEADER_CONTENT_TYPE] = $contentType;
        }
        if ($hosts) {

The expression $hosts of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $headers[self::HTTP_HEADER_HOST] = $hosts;
        }

        return $this->ban($headers);
    }

    /**
     * {@inheritdoc}
     */
    public function purge($url, array $headers = [])
    {
        $this->queueRequest(self::HTTP_METHOD_PURGE, $url, $headers);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function refresh($url, array $headers = [])

This method seems to be duplicated in your project.

    {
        $headers = array_merge($headers, ['Cache-Control' => 'no-cache']);
        $this->queueRequest(self::HTTP_METHOD_REFRESH, $url, $headers);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    protected function configureOptions()
    {
        $resolver = parent::configureOptions();
        $resolver->setDefaults([
            'tags_header' => self::DEFAULT_HTTP_HEADER_CACHE_TAGS,
            'tags_purge_header' => self::DEFAULT_HTTP_PURGE_HEADER_CACHE_TAGS,
            'tag_mode' => 'ban',
            'header_length' => 7500,
            'default_ban_headers' => [],
        ]);
        // tag_mode options: 'ban', 'purge' or 'purge_single' for purge invalidation per tag
        $resolver->setAllowedValues('tag_mode', ['ban', 'purge', 'purge_single']);
        $resolver->setNormalizer('default_ban_headers', function ($resolver, $specified) {
            return array_merge(
                [
                    self::HTTP_HEADER_HOST => self::REGEX_MATCH_ALL,
                    self::HTTP_HEADER_URL => self::REGEX_MATCH_ALL,
                    self::HTTP_HEADER_CONTENT_TYPE => self::REGEX_MATCH_ALL,
                ],
                $specified
            );
        });

        return $resolver;
    }
}