Comodojo\Cache\Providers\Memcached

Complexity

Total Complexity

38

Size/Duplication

Total Lines	329
Duplicated Lines	13.98 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

63.5%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setNamespaceKey()	9	9	2
A	getNamespaceKey()	0	5	1
A	getMemcachedStatus()	0	5	1
B	__construct()	0	23	5
B	set()	22	61	8
C	get()	0	36	7
B	delete()	9	35	5
B	flush()	0	24	3
B	status()	6	27	3
B	addServer()	0	41	3

<?php namespace Comodojo\Cache\Providers;

use \Comodojo\Cache\Components\InstanceTrait;
use \Comodojo\Cache\Providers\AbstractProvider;
use \Psr\Log\LoggerInterface;
use \Memcached as MemcachedInstance;
use \Comodojo\Exception\CacheException;
use \Exception;

/**
 * Memcached cache class
 *
 * @package     Comodojo Spare Parts
 * @author      Marco Giovinazzi <marco.giovinazzi@comodojo.org>
 * @license     MIT
 *
 * LICENSE:
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

class Memcached extends AbstractProvider {

    use InstanceTrait;

    /**
     * Class constructor
     *
     * @param   string          $server         Server address (or IP)
     * @param   string          $port           (optional) Server port
     * @param   string          $weight         (optional) Server weight
     * @param   string          $persistent_id  (optional) Persistent id
     * @param   \Monolog\Logger $logger         Logger instance
     *
     * @throws \Comodojo\Exception\CacheException
     */
    public function __construct( $server, $port=11211, $weight=0, $persistent_id=null, LoggerInterface $logger=null ) {

        if ( empty($server) ) throw new CacheException("Invalid or unspecified memcached server");

        if ( !is_null($persistent_id) && !is_string($persistent_id) ) throw new CacheException("Invalid persistent id");

        parent::__construct($logger);

        if ( self::getMemcachedStatus() === false ) {

            $this->logger->error("Memcached extension not available, disabling MemcachedProvider administratively");

            $this->disable();

        } else {

            $this->setInstance(new MemcachedInstance($persistent_id));

            $this->addServer($server, $port, $weight);

        }

    }

    /**
     * {@inheritdoc}
     */
    public function set($name, $data, $ttl=null) {

        if ( empty($name) ) throw new CacheException("Name of object cannot be empty");

        if ( is_null($data) ) throw new CacheException("Object content cannot be null");

        if ( !$this->isEnabled() ) return false;

        $this->resetErrorState();

        try {

            $this->setTtl($ttl);

            $namespace = $this->getNamespaceKey();

            if ( $namespace === false ) $namespace = $this->setNamespaceKey();

            if ( $namespace === false ) {

                $this->logger->error("Error writing cache (Memcached), exiting gracefully", array(
                    "RESULTCODE" => $this->instance->getResultCode(),
                    "RESULTMESSAGE" => $this->instance->getResultMessage()
                ));

                $this->setErrorState("Error writing cache (Memcached)");

                $return = false;

            } else {

This code seems to be duplicated across your project.

                $shadowName = $namespace."-".md5($name);

                $shadowTtl = /* $this->getTime() + */$this->ttl;

50% of this comment could be valid code. Did you maybe forget this after debugging?

                $shadowData = serialize($data);

                $return = $this->instance->set($shadowName, $shadowData, $shadowTtl);

                if ( $return === false ) {

                    $this->logger->error("Error writing cache (Memcached), exiting gracefully", array(
                        "RESULTCODE" => $this->instance->getResultCode(),
                        "RESULTMESSAGE" => $this->instance->getResultMessage()
                    ));

                    $this->setErrorState("Error writing cache (Memcached)");

                }

            }

        } catch (CacheException $ce) {

            throw $ce;

        }

        return $return;

    }

    /**
     * {@inheritdoc}
     */
    public function get($name) {

        if ( empty($name) ) throw new CacheException("Name of object cannot be empty");

        if ( !$this->isEnabled() ) return null;

        $this->resetErrorState();

        $namespace = $this->getNamespaceKey();

        if ( $namespace === false ) {

            $return = false;

        } else {

            $shadowName = $namespace."-".md5($name);

            $return = $this->instance->get($shadowName);

            if ( $return === false && $this->instance->getResultCode() != MemcachedInstance::RES_NOTFOUND ) {

                $this->logger->error("Error reading cache (Memcached), exiting gracefully", array(
                    "RESULTCODE" => $this->instance->getResultCode(),
                    "RESULTMESSAGE" => $this->instance->getResultMessage()
                ));

                $this->setErrorState("Error reading cache (Memcached)");

            }

        }

        return $return === false ? null : unserialize($return);

    }

    /**
     * {@inheritdoc}
     */
    public function delete($name=null) {

        if ( !$this->isEnabled() ) return false;

        $this->resetErrorState();

        $namespace = $this->getNamespaceKey();

        if ( $namespace === false ) return true;

        if ( empty($name) ) {

This code seems to be duplicated across your project.

            $delete = $this->instance->delete($this->getNamespace());

        } else {

            $delete = $this->instance->delete($namespace."-".md5($name));

        }

        if ( $delete === false ) {

            $this->logger->error("Error writing cache (Memcached), exiting gracefully", array(
                "RESULTCODE" => $this->instance->getResultCode(),
                "RESULTMESSAGE" => $this->instance->getResultMessage()
            ));

            $this->setErrorState("Error reading cache (Memcached)");

        }


        return $delete;

    }

    /**
     * {@inheritdoc}
     */
    public function flush() {

        if ( !$this->isEnabled() ) return false;

        $this->resetErrorState();

        $result = $this->instance->flush();

        if ( $result === false ) {

            $this->logger->error("Error flushing cache (Memcached), exiting gracefully", array(
                "RESULTCODE" => $this->instance->getResultCode(),
                "RESULTMESSAGE" => $this->instance->getResultMessage()
            ));

            $this->setErrorState("Error flushing cache (Memcached)");

            return false;

        }

        return true;

    }

    /**
     * {@inheritdoc}
     */
    public function status() {

        if ( !$this->isEnabled() ) return array(

This code seems to be duplicated across your project.

            "provider"  => "memcached",
            "enabled"   => false,
            "objects"   => null,
            "options"   => array()
        );

        $stats = $this->instance->getStats();

        $objects = 0;

        foreach ($stats as $key => $value) {

            $objects = max($objects, $value['curr_items']);

        }

        return array(
            "provider"  => "memcached",
            "enabled"   => $this->isEnabled(),
            "objects"   => intval($objects),
            "options"   => $stats
        );

    }

    /**
     * Set key for namespace
     *
     * @return  mixed
     */
    private function setNamespaceKey() {

This method seems to be duplicated in your project.

        $uId = self::getUniqueId();

        $return = $this->instance->set($this->getNamespace(), $uId, 0);

        return $return === false ? false : $uId;

    }

    /**
     * Get key for namespace
     *
     * @return  string
     */
    private function getNamespaceKey() {

        return $this->instance->get($this->getNamespace());

    }

    /**
     * Add a Memcached server to stack
     *
     * @param   string          $server         Server address (or IP)
     * @param   string          $port           Server port
     * @param   string          $weight         Server weight
     */
    private function addServer($server, $port, $weight) {

        $port = filter_var($port, FILTER_VALIDATE_INT, array(
            "options" => array(
                "min_range" => 1,
                "max_range" => 65535,
                "default" => 11211 )
            )
        );

        $weight = filter_var($weight, FILTER_VALIDATE_INT, array(
            "options" => array(
                "min_range" => 0,
                "default" => 0 )
            )
        );

        $status = $this->instance->addServer($server, $port, $weight);

        if ( $status === false ) {

            $this->logger->error("Error communicating with server", array(
                "RESULTCODE" => $this->instance->getResultCode(),
                "RESULTMESSAGE" => $this->instance->getResultMessage()
            ));

        }

        if ( sizeof($this->instance->getServerList()) == 0 ) {

            $this->logger->error("No available server, disabling MemcachedProvider administratively");

            $this->disable();

        } else {

            $this->enable();

        }

    }

    /**
     * Check Memcached availability
     *
     * @return  bool
     */
    private static function getMemcachedStatus() {

        return class_exists('Memcached');

    }

}