TokenManager::logTokenData() - Code Metrics - Inspection of "Cache access token (if a CacheItemPool is provided..." - MovingImage24/VMProApiClient - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#48)

unknown

created 2018-01-11 16:14 UTC

TokenManager::logTokenData() B

↳ Parent: TokenManager

Complexity

Conditions	5
Paths	1

Size

Total Lines	12
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	12
c	0
b	0
f	0
rs	8.8571
cc	5
eloc	9
nc	1
nop	0

<?php

namespace MovingImage\Client\VMPro\Manager;

use Cache\Adapter\Void\VoidCachePool;
use GuzzleHttp\ClientInterface;
use MovingImage\Client\VMPro\Entity\ApiCredentials;
use MovingImage\Client\VMPro\Entity\Token;
use MovingImage\Client\VMPro\Extractor\TokenExtractor;
use MovingImage\Client\VMPro\Util\Logging\Traits\LoggerAwareTrait;
use Psr\Cache\CacheItemPoolInterface;
use Psr\Log\LoggerAwareInterface;

/**
 * Class TokenManager.
 *
 * @author Ruben Knol <[email protected]>
 */
class TokenManager implements LoggerAwareInterface
{
    use LoggerAwareTrait;

    /**
     * @var ClientInterface
     */
    private $httpClient;

    /**
     * @var ApiCredentials
     */
    protected $credentials;

    /**
     * @var TokenExtractor
     */
    private $tokenExtractor;

    /**
     * @var Token
     */
    private $accessToken;

    /**
     * @var Token
     */
    private $refreshToken;

    /**
     * If provided in the constructor, will be used to cache the access token.
     *
     * @var CacheItemPoolInterface
     */
    private $cacheItemPool;

    /**
     * TokenManager constructor.
     *
     * @param ClientInterface        $httpClient
     * @param ApiCredentials         $credentials
     * @param TokenExtractor         $tokenExtractor
     * @param CacheItemPoolInterface $cacheItemPool
     */
    public function __construct(
        ClientInterface $httpClient,
        ApiCredentials $credentials,
        TokenExtractor $tokenExtractor,
        CacheItemPoolInterface $cacheItemPool = null
    ) {
        $this->httpClient = $httpClient;
        $this->credentials = $credentials;
        $this->tokenExtractor = $tokenExtractor;
        $this->cacheItemPool = $cacheItemPool ?: new VoidCachePool();
    }

    /**
     * Create completely fresh Access + Refresh tokens.
     *
     * @TODO Implement proper error handling
     *
     * @return array
     */
    protected function createNewTokens()
    {
        $logger = $this->getLogger();
        $logger->debug('Starting request to create fresh access & refresh tokens');

        $response = $this->httpClient->post('auth/login', [
            'json' => [
                'username' => $this->credentials->getUsername(),
                'password' => $this->credentials->getPassword(),
            ],
            'headers' => [
                'accept: application/json',
                'cache-control: no-cache',
                'content-type: application/json',
            ],
        ]);

        $data = \json_decode($response->getBody(), true);
        $logger->debug('Successfully retrieved new access & refresh tokens', $data);

        return [
            'accessToken' => new Token(
                $data['accessToken'],
                $this->tokenExtractor->extract($data['accessToken']),
                $data['validForVideoManager']
            ),
            'refreshToken' => new Token(
                $data['refreshToken'],
                $this->tokenExtractor->extract($data['refreshToken']),
                null
            ),
        ];
    }

    /**
     * Create a new access token for a video manager using a refresh token.
     *
     * @param Token $refreshToken
     * @param int   $videoManagerId
     *
     * @return Token
     */
    protected function createAccessTokenFromRefreshToken(Token $refreshToken, $videoManagerId)
    {
        $logger = $this->getLogger();
        $logger->debug('Starting request to create fresh access token from refresh token');

        $response = $this->httpClient->post(sprintf('auth/refresh/%d', $videoManagerId), [
            'json' => [
                'refreshToken' => $refreshToken->getTokenString(),
            ],
            'headers' => [
                'accept: application/json',
                'cache-control: no-cache',
                'content-type: application/json',
            ],
        ]);

        $data = \json_decode($response->getBody(), true);
        $logger->debug('Successfully retrieved new access token', $data);

        return new Token(
            $data['accessToken'],
            $this->tokenExtractor->extract($data['accessToken']),
            $videoManagerId
        );
    }

    /**
     * Log information about which tokens we have.
     */
    protected function logTokenData()
    {
        $this->getLogger()->debug('Token information', [
            'accessTokenExists' => isset($this->accessToken),
            'accessTokenExpiration' => isset($this->accessToken) ? $this->accessToken->getTokenData()['exp'] : null,
            'accessTokenHasExpired' => isset($this->accessToken) ? $this->accessToken->expired() : null,
            'refreshTokenExists' => isset($this->refreshToken),
            'refreshTokenExpiration' => isset($this->refreshToken) ? $this->refreshToken->getTokenData()['exp'] : null,
            'refreshTokenHasExpired' => isset($this->refreshToken) ? $this->refreshToken->expired() : null,
            'localTime' => time(),
        ]);
    }

    /**
     * Retrieve a valid token.
     *
     * @param int $videoManagerId Which video manager a token is requested for
     * @TODO Refactor token storage to support multiple re-usable tokens, one per video manager
     *
     * @return string
     */
    public function getToken($videoManagerId = null)
    {
        $logger = $this->getLogger();
        $this->logTokenData();

        $cacheKey = sha1(sprintf('%s.%s', __METHOD__, json_encode(func_get_args())));
        $cacheItem = $this->cacheItemPool->getItem($cacheKey);
        if (!$this->accessToken && $cacheItem->isHit()) {
            $this->accessToken = $cacheItem->get();
        }

        // Access token has expired, but expiration token has not expired.
        // Issue ourselves a new access token for the same video manager.
        if (!is_null($this->accessToken)
            && $this->accessToken->expired()
            && !$this->refreshToken->expired()) {
            $logger->info('Access token has expired - getting new one for same video manager with refresh token');
            $tokenData = $this->createAccessTokenFromRefreshToken(
                $this->refreshToken,
                $this->accessToken->getVideoManagerId()
            );

            $this->accessToken = $tokenData['accessToken'];
        } elseif (is_null($this->accessToken)
            || (!is_null($this->refreshToken) && $this->refreshToken->expired())) {
            // Either we have no token, or the refresh token has expired
            // so we will need to generate completely new tokens
            $logger->info('No access token, or refresh token has expired - generate completely new ones');
            $tokenData = $this->createNewTokens();

            $this->accessToken = $tokenData['accessToken'];
            $this->refreshToken = $tokenData['refreshToken'];
        }

        // Video manager is not matching with the one that our token
        // was generated with - issue ourselves a token for the video manager
        // we need.
        if (!is_null($videoManagerId)
            && isset($this->accessToken)
            && $this->accessToken->getVideoManagerId() != $videoManagerId) {
            $logger->info('Attempting to use token for different video manager - generate valid access token');
            $this->accessToken = $this->createAccessTokenFromRefreshToken($this->refreshToken, $videoManagerId);
        }

        $cacheItem->set($this->accessToken);
        $cacheItem->expiresAt((new \DateTime())
            ->setTimestamp($this->accessToken->getTokenData()['exp'])
            ->sub(new \DateInterval('PT30S'))
        );
        $this->cacheItemPool->save($cacheItem);

        return $this->accessToken->getTokenString();
    }
}


1			<?php
2
3			namespace MovingImage\Client\VMPro\Manager;
4
5			use Cache\Adapter\Void\VoidCachePool;
6			use GuzzleHttp\ClientInterface;
7			use MovingImage\Client\VMPro\Entity\ApiCredentials;
8			use MovingImage\Client\VMPro\Entity\Token;
9			use MovingImage\Client\VMPro\Extractor\TokenExtractor;
10			use MovingImage\Client\VMPro\Util\Logging\Traits\LoggerAwareTrait;
11			use Psr\Cache\CacheItemPoolInterface;
12			use Psr\Log\LoggerAwareInterface;
13
14			/**
15			* Class TokenManager.
16			*
17			* @author Ruben Knol <[email protected]>
18			*/
19			class TokenManager implements LoggerAwareInterface
20			{
21			use LoggerAwareTrait;
22
23			/**
24			* @var ClientInterface
25			*/
26			private $httpClient;
27
28			/**
29			* @var ApiCredentials
30			*/
31			protected $credentials;
32
33			/**
34			* @var TokenExtractor
35			*/
36			private $tokenExtractor;
37
38			/**
39			* @var Token
40			*/
41			private $accessToken;
42
43			/**
44			* @var Token
45			*/
46			private $refreshToken;
47
48			/**
49			* If provided in the constructor, will be used to cache the access token.
50			*
51			* @var CacheItemPoolInterface
52			*/
53			private $cacheItemPool;
54
55			/**
56			* TokenManager constructor.
57			*
58			* @param ClientInterface $httpClient
59			* @param ApiCredentials $credentials
60			* @param TokenExtractor $tokenExtractor
61			* @param CacheItemPoolInterface $cacheItemPool
62			*/
63			public function __construct(
64			ClientInterface $httpClient,
65			ApiCredentials $credentials,
66			TokenExtractor $tokenExtractor,
67			CacheItemPoolInterface $cacheItemPool = null
68			) {
69			$this->httpClient = $httpClient;
70			$this->credentials = $credentials;
71			$this->tokenExtractor = $tokenExtractor;
72			$this->cacheItemPool = $cacheItemPool ?: new VoidCachePool();
73			}
74
75			/**
76			* Create completely fresh Access + Refresh tokens.
77			*
78			* @TODO Implement proper error handling
79			*
80			* @return array
81			*/
82			protected function createNewTokens()
83			{
84			$logger = $this->getLogger();
85			$logger->debug('Starting request to create fresh access & refresh tokens');
86
87			$response = $this->httpClient->post('auth/login', [
88			'json' => [
89			'username' => $this->credentials->getUsername(),
90			'password' => $this->credentials->getPassword(),
91			],
92			'headers' => [
93			'accept: application/json',
94			'cache-control: no-cache',
95			'content-type: application/json',
96			],
97			]);
98
99			$data = \json_decode($response->getBody(), true);
100			$logger->debug('Successfully retrieved new access & refresh tokens', $data);
101
102			return [
103			'accessToken' => new Token(
104			$data['accessToken'],
105			$this->tokenExtractor->extract($data['accessToken']),
106			$data['validForVideoManager']
107			),
108			'refreshToken' => new Token(
109			$data['refreshToken'],
110			$this->tokenExtractor->extract($data['refreshToken']),
111			null
112			),
113			];
114			}
115
116			/**
117			* Create a new access token for a video manager using a refresh token.
118			*
119			* @param Token $refreshToken
120			* @param int $videoManagerId
121			*
122			* @return Token
123			*/
124			protected function createAccessTokenFromRefreshToken(Token $refreshToken, $videoManagerId)
125			{
126			$logger = $this->getLogger();
127			$logger->debug('Starting request to create fresh access token from refresh token');
128
129			$response = $this->httpClient->post(sprintf('auth/refresh/%d', $videoManagerId), [
130			'json' => [
131			'refreshToken' => $refreshToken->getTokenString(),
132			],
133			'headers' => [
134			'accept: application/json',
135			'cache-control: no-cache',
136			'content-type: application/json',
137			],
138			]);
139
140			$data = \json_decode($response->getBody(), true);
141			$logger->debug('Successfully retrieved new access token', $data);
142
143			return new Token(
144			$data['accessToken'],
145			$this->tokenExtractor->extract($data['accessToken']),
146			$videoManagerId
147			);
148			}
149
150			/**
151			* Log information about which tokens we have.
152			*/
153			protected function logTokenData()
154			{
155			$this->getLogger()->debug('Token information', [
156			'accessTokenExists' => isset($this->accessToken),
157			'accessTokenExpiration' => isset($this->accessToken) ? $this->accessToken->getTokenData()['exp'] : null,
158			'accessTokenHasExpired' => isset($this->accessToken) ? $this->accessToken->expired() : null,
159			'refreshTokenExists' => isset($this->refreshToken),
160			'refreshTokenExpiration' => isset($this->refreshToken) ? $this->refreshToken->getTokenData()['exp'] : null,
161			'refreshTokenHasExpired' => isset($this->refreshToken) ? $this->refreshToken->expired() : null,
162			'localTime' => time(),
163			]);
164			}
165
166			/**
167			* Retrieve a valid token.
168			*
169			* @param int $videoManagerId Which video manager a token is requested for
170			* @TODO Refactor token storage to support multiple re-usable tokens, one per video manager
171			*
172			* @return string
173			*/
174			public function getToken($videoManagerId = null)
175			{
176			$logger = $this->getLogger();
177			$this->logTokenData();
178
179			$cacheKey = sha1(sprintf('%s.%s', __METHOD__, json_encode(func_get_args())));
180			$cacheItem = $this->cacheItemPool->getItem($cacheKey);
181			if (!$this->accessToken && $cacheItem->isHit()) {
182			$this->accessToken = $cacheItem->get();
183			}
184
185			// Access token has expired, but expiration token has not expired.
186			// Issue ourselves a new access token for the same video manager.
187			if (!is_null($this->accessToken)
188			&& $this->accessToken->expired()
189			&& !$this->refreshToken->expired()) {
190			$logger->info('Access token has expired - getting new one for same video manager with refresh token');
191			$tokenData = $this->createAccessTokenFromRefreshToken(
192			$this->refreshToken,
193			$this->accessToken->getVideoManagerId()
194			);
195
196			$this->accessToken = $tokenData['accessToken'];
197			} elseif (is_null($this->accessToken)
198			\|\| (!is_null($this->refreshToken) && $this->refreshToken->expired())) {
199			// Either we have no token, or the refresh token has expired
200			// so we will need to generate completely new tokens
201			$logger->info('No access token, or refresh token has expired - generate completely new ones');
202			$tokenData = $this->createNewTokens();
203
204			$this->accessToken = $tokenData['accessToken'];
205			$this->refreshToken = $tokenData['refreshToken'];
206			}
207
208			// Video manager is not matching with the one that our token
209			// was generated with - issue ourselves a token for the video manager
210			// we need.
211			if (!is_null($videoManagerId)
212			&& isset($this->accessToken)
213			&& $this->accessToken->getVideoManagerId() != $videoManagerId) {
214			$logger->info('Attempting to use token for different video manager - generate valid access token');
215			$this->accessToken = $this->createAccessTokenFromRefreshToken($this->refreshToken, $videoManagerId);
216			}
217
218			$cacheItem->set($this->accessToken);
219			$cacheItem->expiresAt((new \DateTime())
220			->setTimestamp($this->accessToken->getTokenData()['exp'])
221			->sub(new \DateInterval('PT30S'))
222			);
223			$this->cacheItemPool->save($cacheItem);
224
225			return $this->accessToken->getTokenString();
226			}
227			}
228

MovingImage24 / VMProApiClient

Pull Request — master (#48)

TokenManager::logTokenData() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like