Ytake\LaravelCouchbase\Cache\MemcachedBucketStore

Complexity

Total Complexity

22

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

84.85%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	increment()	0	12	2
A	decrement()	0	17	3
A	flush()	0	16	3
A	setCredential()	0	10	2
D	callMulti()	0	31	9
A	timeout()	0	4	1
A	port()	0	4	1

<?php
declare(strict_types=1);

/**
 * 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.
 */

namespace Ytake\LaravelCouchbase\Cache;

use Illuminate\Cache\MemcachedStore;

/**
 * Class MemcachedBucketStore.
 *
 * @author Yuuki Takezawa<yuuki.takezawa@comnect.jp.net>
 * @deprecated
 */
class MemcachedBucketStore extends MemcachedStore
{
    /** @var  string[] */
    protected $servers;

    /** @var array */
    protected $options = [
        CURLOPT_RETURNTRANSFER => false,
        CURLOPT_SSL_VERIFYPEER => false,
    ];

    /** @var int */
    protected $port = 8091;

    /** @var int */
    protected $timeout = 1;

    /** @var string */
    protected $flushEndpoint = ':%s/pools/default/buckets/%s/controller/doFlush';

    /** @var array */
    protected $sasl = [];

    /**
     * MemcachedBucketStore constructor.
     *
     * @param \Memcached $memcached
     * @param string     $prefix
     * @param array      $servers
     * @param array      $sasl
     */
    public function __construct(
        \Memcached $memcached,
        string $prefix = '',
        array $servers,
        array $sasl = []
    ) {
        parent::__construct($memcached, $prefix);
        $this->servers = $servers;
        $this->sasl = $sasl;
    }

    /**
     * Increment the value of an item in the cache.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return int|bool
     */
    public function increment($key, $value = 1)
    {
        if ($integer = $this->get($key)) {
            $this->put($key, $integer + $value, 0);

            return $integer + $value;
        }

        $this->put($key, $value, 0);

        return $value;
    }

    /**
     * Decrement the value of an item in the cache.
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return int|bool
     */
    public function decrement($key, $value = 1)
    {
        $decrement = 0;
        if ($integer = $this->get($key)) {
            $decrement = $integer - $value;

The expression $integer - $value; of type integer|double adds the type double to the return on line 105 which is incompatible with the return type declared by the interface Illuminate\Contracts\Cache\Store::decrement of type integer|boolean.

            if ($decrement <= 0) {
                $decrement = 0;
            }
            $this->put($key, $decrement, 0);

            return $decrement;
        }

        $this->put($key, $decrement, 0);

        return $decrement;
    }

    /**
     * {@inheritdoc}
     */
    public function flush()
    {
        $handler = curl_multi_init();
        foreach ($this->servers as $server) {
            $initialize = curl_init();
            $configureOption = (isset($server['options'])) ? $server['options'] : [];

            $options = array_replace($this->options, [
                CURLOPT_POST => true,
                CURLOPT_URL  => $server['host'] . sprintf($this->flushEndpoint, $this->port, $server['bucket']),
            ], $configureOption, $this->setCredential());
            curl_setopt_array($initialize, $options);
            curl_multi_add_handle($handler, $initialize);
        }
        $this->callMulti($handler);
    }

    /**
     * @return array
     */
    protected function setCredential(): array
    {
        if (count($this->sasl) === 2) {
            list($username, $password) = $this->sasl;

            return [CURLOPT_USERPWD => "{$username}:{$password}"];
        }

        return [];
    }

    /**
     * @param $handler
     *
     * @throws \RuntimeException
     */
    protected function callMulti($handler)
    {
        $running = null;

        do {
            $stat = curl_multi_exec($handler, $running);
        } while ($stat === CURLM_CALL_MULTI_PERFORM);
        if (!$running || $stat !== CURLM_OK) {
            throw new \RuntimeException('failed to initialized cURL');
        }

        do {
            curl_multi_select($handler, $this->timeout);
            do {
                $stat = curl_multi_exec($handler, $running);
            } while ($stat === CURLM_CALL_MULTI_PERFORM);
            do {
                if ($read = curl_multi_info_read($handler, $remains)) {
                    $response = curl_multi_getcontent($read['handle']);

                    if ($response === false) {
                        $info = curl_getinfo($read['handle']);
                        throw new \RuntimeException("error: {$info['url']}: {$info['http_code']}");
                    }
                    curl_multi_remove_handle($handler, $read['handle']);
                    curl_close($read['handle']);
                }
            } while ($remains);

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

        } while ($running);
        curl_multi_close($handler);
    }

    /**
     * @param int $second
     */
    public function timeout(int $second)
    {
        $this->timeout = $second;
    }

    /**
     * @param int $port
     */
    public function port(int $port)
    {
        $this->port = $port;
    }
}