OAuth\Common\Storage\Memcached

Complexity

Total Complexity

25

Size/Duplication

Total Lines	241
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	retrieveAccessToken()	0	15	3
A	storeAccessToken()	0	19	2
A	hasAccessToken()	0	12	3
A	clearToken()	0	16	2
A	clearAllTokens()	0	11	1
A	retrieveAuthorizationState()	0	15	3
A	storeAuthorizationState()	0	17	2
A	hasAuthorizationState()	0	12	3
A	clearAuthorizationState()	0	16	2
A	clearAllAuthorizationStates()	0	11	1
A	getMemcached()	0	4	1
A	getKey()	0	4	1

<?php

namespace OAuth\Common\Storage;

use OAuth\Common\Token\TokenInterface;
use OAuth\Common\Storage\Exception\TokenNotFoundException;
use OAuth\Common\Storage\Exception\AuthorizationStateNotFoundException;
/*
 * Stores a token in a Memcached server.
 */
class Memcached implements TokenStorageInterface
{
    /**
     * @var string
     */
    protected $key;

    /**
     * @var string
     */
    protected $stateKey;

    /**
     * @var object|\Memcached
     */
    protected $memcached;

    /**
     * @var object|TokenInterface
     */
    protected $cachedTokens;

    /**
     * @var object
     */
    protected $cachedStates;

    /**
     * @param \Memcached $memcache An instantiated and connected Memcached client
     * @param string $key The key to store the token under in Memcached
     * @param string $stateKey The key to store the state under in Memcached.
     */
    public function __construct(\Memcached $memcache, $key, $stateKey)
    {
        $this->memcached = $memcache;
        $this->key = $key;
        $this->stateKey = $stateKey;
        $this->cachedTokens = array();

It seems like array() of type array is incompatible with the declared type object of property $cachedTokens.

        $this->cachedStates = array();

It seems like array() of type array is incompatible with the declared type object of property $cachedStates.

    }

    /**
     * {@inheritDoc}
     */
    public function retrieveAccessToken($service)
    {
        if (!$this->hasAccessToken($service)) {
            throw new TokenNotFoundException('Token not found in Memcached');
        }

        if (isset($this->cachedTokens[$service])) {
            return $this->cachedTokens[$service];
        }

        $val = unserialize($this->memcached->get($this->key));
        $val = $val[$service];

        return $this->cachedTokens[$service] = $val;
    }

    /**
     * {@inheritDoc}
     */
    public function storeAccessToken($service, TokenInterface $token)
    {
        // (over)write the token
        $all_tokens = $this->memcached->get($this->key);

        if ($this->memcached->getResultCode() == \Memcached::RES_NOTFOUND) {
            $all_tokens = array();
        } else {
            $all_tokens = unserialize($all_tokens);
        }

        $all_tokens[$service] = $token;
        $this->memcached->set($this->key, serialize($all_tokens));

        $this->cachedTokens[$service] = $token;

        // allow chaining
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function hasAccessToken($service)
    {
        if (isset($this->cachedTokens[$service])
            && $this->cachedTokens[$service] instanceof TokenInterface
        ) {
            return true;
        }

        $all_tokens = unserialize($this->memcached->get($this->key));

        return (bool)$all_tokens[$service];
    }

    /**
     * {@inheritDoc}
     */
    public function clearToken($service)
    {
        $all_tokens = unserialize($this->memcached->get($this->key));
        unset($all_tokens[$service]);

        if (empty($all_tokens)) {
            $this->memcached->delete($this->key);
        } else {
            $this->memcached->set($this->key, serialize($all_tokens));
        }

        unset($this->cachedTokens[$service]);

        // allow chaining
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function clearAllTokens()
    {
        // memory
        $this->cachedTokens = array();

It seems like array() of type array is incompatible with the declared type object of property $cachedTokens.

        // memcached
        $this->memcached->delete($this->key);

        // allow chaining
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function retrieveAuthorizationState($service)
    {
        if (!$this->hasAuthorizationState($service)) {
            throw new AuthorizationStateNotFoundException('State not found in Memcached');
        }

        if (isset($this->cachedStates[$service])) {
            return $this->cachedStates[$service];
        }

        $val = unserialize($this->memcached->get($this->stateKey));
        $val = $val[$service];

        return $this->cachedStates[$service] = $val;
    }

    /**
     * {@inheritDoc}
     */
    public function storeAuthorizationState($service, $state)
    {
        // (over)write the token
        $all_states = $this->memcached->get($this->key);

        if ($this->memcached->getResultCode() == \Memcached::RES_NOTFOUND) {
            $all_states = array();
        } else {
            $all_states = unserialize($all_states);
        }

        $all_states[$service] = $state;
        $this->memcached->set($this->stateKey, serialize($all_states));

        // allow chaining
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function hasAuthorizationState($service)
    {
        if (isset($this->cachedStates[$service])
            && null !== $this->cachedStates[$service]
        ) {
            return true;
        }

        $all_states = unserialize($this->memcached->get($this->stateKey));

        return (bool)$all_states[$service];
    }

    /**
     * {@inheritDoc}
     */
    public function clearAuthorizationState($service)
    {
        $all_states = unserialize($this->memcached->get($this->stateKey));
        unset($all_states[$service]);

        if (empty($all_states)) {
            $this->memcached->delete($this->stateKey);
        } else {
            $this->memcached->set($this->stateKey, serialize($all_states));
        }

        unset($this->cachedTokens[$service]);

        // allow chaining
        return $this;
    }

    /**
     * {@inheritDoc}
     */
    public function clearAllAuthorizationStates()
    {
        // memory
        $this->cachedStates = array();

It seems like array() of type array is incompatible with the declared type object of property $cachedStates.

        // memcached
        $this->memcached->delete($this->stateKey);

        // allow chaining
        return $this;
    }

    /**
     * @return \Memcached $memcached
     */
    public function getMemcached()
    {
        return $this->memcached;
    }

    /**
     * @return string $key
     */
    public function getKey()
    {
        return $this->key;
    }
}