HDNET\CacheCheck\Cache\Backend\AbstractAnalyzerBackend

Complexity

Total Complexity

6

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	4
Bugs	1	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setCache()	0	14	2
A	logEntry()	0	17	2
A	getDatabaseConnection()	0	4	1

<?php
/**
 * Abstract Analyse backend
 *
 * @package CacheCheck\Cache\Backend
 * @author  Tim Lochmüller
 */

namespace HDNET\CacheCheck\Cache\Backend;

use HDNET\CacheCheck\Domain\Repository\CacheRepository;
use TYPO3\CMS\Core\Cache\Backend\AbstractBackend;
use TYPO3\CMS\Core\Cache\Backend\BackendInterface;
use TYPO3\CMS\Core\Cache\Backend\FreezableBackendInterface;
use TYPO3\CMS\Core\Cache\Backend\PhpCapableBackendInterface;
use TYPO3\CMS\Core\Cache\Backend\TaggableBackendInterface;
use TYPO3\CMS\Core\Cache\Exception\InvalidBackendException;
use TYPO3\CMS\Core\Cache\Frontend\FrontendInterface;
use TYPO3\CMS\Core\Database\DatabaseConnection;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * Class CacheAnalyzerBackend
 */
abstract class AbstractAnalyzerBackend extends AbstractBackend implements FreezableBackendInterface, PhpCapableBackendInterface, TaggableBackendInterface
{

    /**
     * Original Backend
     *
     * @var AbstractBackend
     */
    protected $originalBackend;

    /**
     * Options
     *
     * @var array
     */
    protected $options;

    /**
     * Build up the object
     *
     * @param string $context
     * @param array  $options
     */
    public function __construct($context, array $options = [])
    {
        $this->options = $options;
        parent::__construct($context, $options);
    }

    /**
     * Set the cache and init the original backend
     *
     * @param FrontendInterface $cache
     *
     * @throws InvalidBackendException
     */
    public function setCache(FrontendInterface $cache)
    {
        parent::setCache($cache);

        $cacheRepository = GeneralUtility::makeInstance(CacheRepository::class);
        $cacheObject = $cacheRepository->findByName($this->cacheIdentifier);

        $backendObjectName = '\\' . ltrim($cacheObject->getOriginalBackend(), '\\');
        $this->originalBackend = new $backendObjectName($this->context, $this->options);
        if (!$this->originalBackend instanceof BackendInterface) {
            throw new InvalidBackendException('"' . $backendObjectName . '" is not a valid cache backend object.', 1216304301);
        }
        $this->originalBackend->setCache($cache);
    }

    /**
     * Log one entry
     *
     * @param string $calledMethod
     * @param string $entryIdentifier
     * @param string $data
     */
    protected function logEntry($calledMethod, $entryIdentifier = '', $data = '')
    {
        static $requestHash = null;
        if ($requestHash === null) {
            $requestHash = uniqid();
        }
        $fieldsValues = [
            'timestamp'        => GeneralUtility::milliseconds(),
            'request_hash'     => $requestHash,
            'cache_name'       => $this->cacheIdentifier,
            'called_method'    => $calledMethod,
            'entry_identifier' => $entryIdentifier,
            'entry_size'       => strlen($data),
        ];
        $this->getDatabaseConnection()
            ->exec_INSERTquery('tx_cachecheck_domain_model_log', $fieldsValues);
    }

    /**
     * Get the database connection
     *
     * @return DatabaseConnection
     */
    protected function getDatabaseConnection()
    {
        return $GLOBALS['TYPO3_DB'];
    }
}