Comodojo\Cache\Drivers\Memcached

Complexity

Total Complexity

37

Size/Duplication

Total Lines	245
Duplicated Lines	12.65 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

95.56%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	test()	0	5	2
A	ping()	0	12	1
A	get()	0	15	3
A	set()	0	15	4
A	delete()	11	11	2
A	clear()	13	17	3
A	deleteMultiple()	0	15	2
A	has()	0	5	2
A	stats()	0	5	1
A	setNamespaceKey()	7	7	2
A	getNamespaceKey()	0	5	1
A	__construct()	0	20	4
B	getMultiple()	0	30	5
B	setMultiple()	0	19	5

<?php namespace Comodojo\Cache\Drivers;

use \Comodojo\Cache\Traits\InstanceTrait;
use \Comodojo\Foundation\Utils\UniqueId;
use \Memcached as MemcachedInstance;
use \Exception;

/**
 * @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 AbstractDriver {

    use InstanceTrait;

    const DRIVER_NAME = "memcached";

    /**
     * {@inheritdoc}
     */
    public function __construct(array $configuration = []) {

        if ( class_exists('Memcached') === false ) throw new Exception("ext-memcached not available");

        $instance = new MemcachedInstance($configuration['persistent_id']);

        $instance->addServer(
            $configuration['server'],
            $configuration['port'],
            $configuration['weight']
        );

        if ( !empty($configuration['username']) && !empty($configuration['password']) ) {
            $instance->setOption(MemcachedInstance::OPT_BINARY_PROTOCOL, true);
            $instance->setSaslAuthData($configuration['username'], $configuration['password']);
        }

        $this->setInstance($instance);

    }

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

        return sizeof($this->getInstance()->getServerList()) > 0 && $this->ping();

    }

    public function ping() {

        // try to read a fake value from cache and check it's return code
        $instance = $this->getInstance();
        $instance->get('cache-internals');
        $code = $instance->getResultCode();

        // check if code represents a failure
        // $code != [MEMCACHED_SUCCESS, MEMCACHED_NOTFOUND]

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

        return in_array($code, [0, 16]);

    }

    /**
     * {@inheritdoc}
     */
    public function get($key, $namespace) {

        $scope = $this->getNamespaceKey($namespace);

        if ( $scope === false ) return null;

        $shadowName = "$scope-$key";

        $instance = $this->getInstance();

        $item = $instance->get($shadowName);

        return $instance->getResultCode() == MemcachedInstance::RES_NOTFOUND ? null : $item;

    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $namespace, $value, $ttl = null) {

        if ( $ttl == null ) $ttl = 0;

It seems like you are loosely comparing $ttl of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison === instead.

        $scope = $this->getNamespaceKey($namespace);

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

        if ( $scope === false ) return false;

        $shadowName = "$scope-$key";

        return $this->getInstance()->set($shadowName, $value, $ttl);

    }

    /**
     * {@inheritdoc}
     */
    public function delete($key, $namespace) {

This method seems to be duplicated in your project.

        $scope = $this->getNamespaceKey($namespace);

        if ( $scope === false ) return false;

        $shadowName = "$scope-$key";

        return $this->getInstance()->delete($shadowName);

    }

    /**
     * {@inheritdoc}
     */
    public function clear($namespace = null) {

        if ( $namespace == null ) {

It seems like you are loosely comparing $namespace of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

This code seems to be duplicated across your project.

            return $this->getInstance()->flush();

        } else {

            $scope = $this->getNamespaceKey($namespace);

            if ( $scope === false ) return false;

            return $this->getInstance()->delete($namespace);

        }

    }

    /**
     * {@inheritdoc}
     */
    public function getMultiple(array $keys, $namespace) {

        if ( empty($keys) ) return [];

        $keypad = array_combine($keys, array_fill(0, count($keys), null));

        $scope = $this->getNamespaceKey($namespace);

        if ( $scope === false ) return $keypad;

        $keyscope = array_map(function($key) use($scope) {
            return "$scope-$key";
        }, $keys);

        if ( version_compare(phpversion(), '7.0.0', '<') ) {
            $data = $this->getInstance()->getMulti($keyscope, $null = null, MemcachedInstance::GET_PRESERVE_ORDER);
        } else {
            $data = $this->getInstance()->getMulti($keyscope, MemcachedInstance::GET_PRESERVE_ORDER);
        }

        $return = [];

        foreach ( $data as $scoped_key => $value ) {
            $key = substr($scoped_key, strlen("$scope-"));
            $return[$key] = $value;
        }

        return array_replace($keypad, $return);

    }

    /**
     * {@inheritdoc}
     */
    public function setMultiple(array $key_values, $namespace, $ttl = null) {

        if ( $ttl == null ) $ttl = 0;

It seems like you are loosely comparing $ttl of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison === instead.

        $scope = $this->getNamespaceKey($namespace);

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

        if ( $scope === false ) return false;

        $shadowNames = [];

        foreach ( $key_values as $key => $value ) {
            $shadowNames["$scope-$key"] = $value;
        }

        return $this->getInstance()->setMulti($shadowNames, $ttl);

    }

    /**
     * {@inheritdoc}
     */
    public function deleteMultiple(array $keys, $namespace) {

        $scope = $this->getNamespaceKey($namespace);

        if ( $scope === false ) return false;

        $shadowNames = array_map(function($key) use($scope) {
            return "$scope-$key";
        }, $keys);

        $delete = $this->getInstance()->deleteMulti($shadowNames);

        return count(array_diff(array_unique($delete), [true])) === 0;

    }

    /**
     * {@inheritdoc}
     */
    public function has($key, $namespace) {

        return $this->get($key, $namespace) === null ? false : true;

$key is of type array, but the function expects a string.

    }

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

        return $this->getInstance()->getStats();

    }

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

This method seems to be duplicated in your project.

        $uId = UniqueId::generate(64);

        return $this->getInstance()->set($namespace, $uId, 0) === false ? false : $uId;

    }

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

        return $this->getInstance()->get($namespace);

    }

}