ByJG\Cache\Engine\MemcachedEngine

Complexity

Total Complexity

19

Size/Duplication

Total Lines	142
Duplicated Lines	14.79 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	14	14	3
B	lazyLoadMemCachedServers()	0	15	5
A	get()	4	12	2
A	set()	3	12	2
A	release()	0	6	1
A	append()	0	7	1
A	lock()	0	6	1
A	unlock()	0	6	1
A	isAvailable()	0	13	3

<?php

namespace ByJG\Cache\Engine;

use ByJG\Cache\CacheEngineInterface;
use Memcached;
use Psr\Log\NullLogger;

class MemcachedEngine implements CacheEngineInterface
{

    /**
     *
     * @var Memcached
     */
    protected $memCached = null;

    protected $logger = null;

    protected $servers = null;

    public function __construct($servers = null, $logger = null)

This method seems to be duplicated in your project.

    {
        $this->servers = (array)$servers;
        if (is_null($servers)) {
            $this->servers = [
                '127.0.0.1:11211'
            ];
        }

        $this->logger = $logger;
        if (is_null($logger)) {
            $this->logger = new NullLogger();
        }
    }

    protected function lazyLoadMemCachedServers()
    {
        if (is_null($this->memCached)) {
            $this->memCached = new Memcached();
            foreach ($this->servers as $server) {
                $data = explode(":", $server);
                $this->memCached->addServer($data[0], $data[1]);

                $stats = $this->memCached->getStats();
                if (!isset($stats[$server]) || $stats[$server]['pid'] === -1) {
                    throw new \Exception("Memcached server $server is down");
                }
            }
        }
    }

    /**
     * @param string $key The object KEY
     * @param int $ttl IGNORED IN MEMCACHED.
     * @return object Description
     */
    public function get($key, $ttl = 0)
    {
        $this->lazyLoadMemCachedServers();

        $value = $this->memCached->get($key);
        if ($this->memCached->getResultCode() !== Memcached::RES_SUCCESS) {

This code seems to be duplicated across your project.

            $this->logger->info("[Memcached] Cache '$key' missed with status " . $this->memCached->getResultCode());
            return null;
        }

        return $value;
    }

    /**
     * @param string $key The object Key
     * @param object $object The object to be cached
     * @param int $ttl The time to live in seconds of this objects
     * @return bool If the object is successfully posted
     */
    public function set($key, $object, $ttl = 0)
    {
        $this->lazyLoadMemCachedServers();

        $this->memCached->set($key, $object, $ttl);
        $this->logger->info("[Memcached] Set '$key' result " . $this->memCached->getResultCode());
        if ($this->memCached->getResultCode() !== Memcached::RES_SUCCESS) {

This code seems to be duplicated across your project.

            $this->logger->error("[Memcached] Set '$key' failed with status " . $this->memCached->getResultCode());
        }

        return $this->memCached->getResultCode() === Memcached::RES_SUCCESS;
    }

    /**
     * Unlock resource
     * @param string $key
     */
    public function release($key)
    {
        $this->lazyLoadMemCachedServers();

        $this->memCached->delete($key);
    }

    /**
     *
     * @param string $key
     * @param string $str
     * @return bool
     */
    public function append($key, $str)
    {
        $this->lazyLoadMemCachedServers();

        $this->logger->info("[Memcached] Append '$key' in Memcached");
        return $this->memCached->append($key, $str);
    }

    /**
     * Lock resource before set it.
     * @param string $key
     */
    public function lock($key)
    {
        $this->lazyLoadMemCachedServers();

        return;
    }

    /**
     * UnLock resource after set it
     * @param string $key
     */
    public function unlock($key)
    {
        $this->lazyLoadMemCachedServers();

        return;
    }

    public function isAvailable()
    {
        if (!class_exists('\Memcached')) {
            return false;
        }

        try {
            $this->lazyLoadMemCachedServers();
            return true;
        } catch (\Exception $ex) {
            return false;
        }
    }
}