TokenPool::getEndpointUrl() - Code Metrics - Inspection of "Enable endpoint selection" - treehouselabs/keystone-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#14)

unknown

created 2016-07-23 23:16 UTC

TokenPool::getEndpointUrl() A

↳ Parent: TokenPool

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	8
ccs	5
cts	5
cp	1
rs	9.4285
cc	2
eloc	4
nc	2
nop	0
crap	2

<?php

namespace TreeHouse\Keystone\Client;

use GuzzleHttp\Client;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\RequestOptions;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use TreeHouse\Cache\CacheInterface;
use TreeHouse\Keystone\Client\Exception\TokenException;
use TreeHouse\Keystone\Client\Model\Tenant;
use TreeHouse\Keystone\Client\Model\Token;

class TokenPool
{
    const TOKEN_KEY_FORMAT = 'keystone_token_3_%s';

    /**
     * @var Tenant
     */
    protected $tenant;

    /**
     * The cache where tokens are stored.
     *
     * @var CacheInterface
     */
    protected $cache;

    /**
     * Optional logger.
     *
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * Internal client to request a new token with.
     *
     * @var ClientInterface
     */
    protected $client;

    /**
     * The endpoint url that was obtained via the token.
     *
     * @var string
     */
    protected $endpointUrl;

    /**
     * Cached copy of the token id.
     *
     * @var string
     */
    protected $tokenId;

    /**
     * @param Tenant          $tenant
     * @param CacheInterface  $cache
     * @param LoggerInterface $logger
     */
    public function __construct(Tenant $tenant, CacheInterface $cache, LoggerInterface $logger = null)
    {
        $this->tenant = $tenant;
        $this->cache = $cache;
        $this->logger = $logger ?: new NullLogger();
        $this->client = new Client();
    }

    /**
     * @return string
     */
    public function getEndpointUrl()
    {
        if (null === $this->endpointUrl) {
            $this->getToken();
        }

        return $this->endpointUrl;
    }

    /**
     * @return string
     */
    public function getTokenId()
    {
        if (null === $this->tokenId) {
            $this->getToken();
        }

        return $this->tokenId;
    }

    /**
     * Returns a token to use for the keystone service. Uses cached instance
     * whenever possible.
     *
     * @param bool $forceNew Whether to force creating a new token
     *
     * @return Token
     */
    public function getToken($forceNew = false)
    {
        $tokenName = $this->getCacheKey();

        // see if token is in cache
        if (!$forceNew && $cachedToken = $this->cache->get($tokenName)) {
            $this->logger->debug('Obtained token from cache');
            $token = $this->createToken($cachedToken);
        }

        if (!isset($token) || !($token instanceof Token) || $token->isExpired()) {
            // cache the token and set it to expire 5 seconds before the
            // expiration date, to avoid any concurrence errors.
            $token = $this->requestToken();
            $this->cache->set($tokenName, json_encode($token), $token->getExpirationDate()->getTimestamp() - time() - 5);
        }

        // cache token properties
        $this->endpointUrl = $this->getEndpointUrlFromToken($token);
        $this->tokenId = $token->getId();

        return $token;
    }

    /**
     * @throws TokenException
     *
     * @return Token
     */
    protected function requestToken()
    {
        $this->logger->debug('Requesting a new token');

        $data = [
            'auth' => [
                'passwordCredentials' => [
                    'password' => $this->tenant->getPassword(),
                    'username' => $this->tenant->getUsername(),
                ],
            ],
        ];

        if ($name = $this->tenant->getTenantName()) {
            $data['auth']['tenantName'] = $name;
        }

        try {
            $response = $this->client->request('POST', $this->tenant->getTokenUrl(), [
                RequestOptions::JSON => $data,
            ]);

            return $this->createToken($response->getBody()->getContents());
        } catch (RequestException $e) {
            $this->logger->error(sprintf('Error requesting token: %s', $e->getMessage()));

            throw new TokenException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * @param string $jsonData
     *
     * @throws TokenException
     *
     * @return Token
     */
    private function createToken($jsonData)
    {
        $content = json_decode($jsonData, true);

        if (!is_array($content)) {
            throw new TokenException(sprintf('Could not decode JSON string: "%s"', $jsonData));
        }

        return Token::create($content);
    }

    /**
     * @param Token $token
     *
     * @throws TokenException
     *
     * @return string
     */
    private function getEndpointUrlFromToken(Token $token)
    {
        $catalog = $token->getServiceCatalog($this->tenant->getServiceType(), $this->tenant->getServiceName());

        // use the first endpoint that has was requested
        $endpointType = $this->tenant->getServiceEndpoint() . 'url';
        foreach ($catalog as $endpoint) {
            $endpoint = array_change_key_case($endpoint, CASE_LOWER);
            if (array_key_exists($endpointType, $endpoint)) {
                return $endpoint[$endpointType];
            }
        }

        throw new TokenException('No endpoint with a ' . $this->tenant->getServiceEndpoint() . ' url found');
    }

    /**
     * @return string
     */
    private function getCacheKey()
    {
        return sprintf(self::TOKEN_KEY_FORMAT, rawurlencode($this->tenant->getTokenUrl()));
    }
}


1		<?php
2
3		namespace TreeHouse\Keystone\Client;
4
5		use GuzzleHttp\Client;
6		use GuzzleHttp\ClientInterface;
7		use GuzzleHttp\Exception\RequestException;
8		use GuzzleHttp\RequestOptions;
9		use Psr\Log\LoggerInterface;
10		use Psr\Log\NullLogger;
11		use TreeHouse\Cache\CacheInterface;
12		use TreeHouse\Keystone\Client\Exception\TokenException;
13		use TreeHouse\Keystone\Client\Model\Tenant;
14		use TreeHouse\Keystone\Client\Model\Token;
15
16		class TokenPool
17		{
18		const TOKEN_KEY_FORMAT = 'keystone_token_3_%s';
19
20		/**
21		* @var Tenant
22		*/
23		protected $tenant;
24
25		/**
26		* The cache where tokens are stored.
27		*
28		* @var CacheInterface
29		*/
30		protected $cache;
31
32		/**
33		* Optional logger.
34		*
35		* @var LoggerInterface
36		*/
37		protected $logger;
38
39		/**
40		* Internal client to request a new token with.
41		*
42		* @var ClientInterface
43		*/
44		protected $client;
45
46		/**
47		* The endpoint url that was obtained via the token.
48		*
49		* @var string
50		*/
51		protected $endpointUrl;
52
53		/**
54		* Cached copy of the token id.
55		*
56		* @var string
57		*/
58		protected $tokenId;
59
60		/**
61		* @param Tenant $tenant
62		* @param CacheInterface $cache
63		* @param LoggerInterface $logger
64		*/
65	14	public function __construct(Tenant $tenant, CacheInterface $cache, LoggerInterface $logger = null)
66		{
67	14	$this->tenant = $tenant;
68	14	$this->cache = $cache;
69	14	$this->logger = $logger ?: new NullLogger();
70	14	$this->client = new Client();
71	14	}
72
73		/**
74		* @return string
75		*/
76	9	public function getEndpointUrl()
77		{
78	9	if (null === $this->endpointUrl) {
79	5	$this->getToken();
80	5	}
81
82	9	return $this->endpointUrl;
83		}
84
85		/**
86		* @return string
87		*/
88	9	public function getTokenId()
89		{
90	9	if (null === $this->tokenId) {
91		$this->getToken();
92		}
93
94	9	return $this->tokenId;
95		}
96
97		/**
98		* Returns a token to use for the keystone service. Uses cached instance
99		* whenever possible.
100		*
101		* @param bool $forceNew Whether to force creating a new token
102		*
103		* @return Token
104		*/
105	10	public function getToken($forceNew = false)
106		{
107	10	$tokenName = $this->getCacheKey();
108
109		// see if token is in cache
110	10	if (!$forceNew && $cachedToken = $this->cache->get($tokenName)) {
111	7	$this->logger->debug('Obtained token from cache');
112	7	$token = $this->createToken($cachedToken);
113	6	}
114
115	9	if (!isset($token) \|\| !($token instanceof Token) \|\| $token->isExpired()) {
116		// cache the token and set it to expire 5 seconds before the
117		// expiration date, to avoid any concurrence errors.
118	7	$token = $this->requestToken();
119	6	$this->cache->set($tokenName, json_encode($token), $token->getExpirationDate()->getTimestamp() - time() - 5);
120	6	}
121
122		// cache token properties
123	9	$this->endpointUrl = $this->getEndpointUrlFromToken($token);
124	9	$this->tokenId = $token->getId();
125
126	9	return $token;
127		}
128
129		/**
130		* @throws TokenException
131		*
132		* @return Token
133		*/
134	4	protected function requestToken()
135		{
136	4	$this->logger->debug('Requesting a new token');
137
138		$data = [
139		'auth' => [
140		'passwordCredentials' => [
141	4	'password' => $this->tenant->getPassword(),
142	4	'username' => $this->tenant->getUsername(),
143	4	],
144	4	],
145	4	];
146
147	4	if ($name = $this->tenant->getTenantName()) {
148		$data['auth']['tenantName'] = $name;
149		}
150
151		try {
152	4	$response = $this->client->request('POST', $this->tenant->getTokenUrl(), [
153	4	RequestOptions::JSON => $data,
154	4	]);
155
156	3	return $this->createToken($response->getBody()->getContents());
157	1	} catch (RequestException $e) {
158	1	$this->logger->error(sprintf('Error requesting token: %s', $e->getMessage()));
159
160	1	throw new TokenException($e->getMessage(), $e->getCode(), $e);
161		}
162		}
163
164		/**
165		* @param string $jsonData
166		*
167		* @throws TokenException
168		*
169		* @return Token
170		*/
171	8	private function createToken($jsonData)
172		{
173	8	$content = json_decode($jsonData, true);
174
175	8	if (!is_array($content)) {
176	1	throw new TokenException(sprintf('Could not decode JSON string: "%s"', $jsonData));
177		}
178
179	7	return Token::create($content);
180		}
181
182		/**
183		* @param Token $token
184		*
185		* @throws TokenException
186		*
187		* @return string
188		*/
189	9	private function getEndpointUrlFromToken(Token $token)
190		{
191	9	$catalog = $token->getServiceCatalog($this->tenant->getServiceType(), $this->tenant->getServiceName());
192
193		// use the first endpoint that has was requested
194	9	$endpointType = $this->tenant->getServiceEndpoint() . 'url';
195	9	foreach ($catalog as $endpoint) {
196	9	$endpoint = array_change_key_case($endpoint, CASE_LOWER);
197	9	if (array_key_exists($endpointType, $endpoint)) {
198	9	return $endpoint[$endpointType];
199		}
200		}
201
202		throw new TokenException('No endpoint with a ' . $this->tenant->getServiceEndpoint() . ' url found');
203		}
204
205		/**
206		* @return string
207		*/
208	10	private function getCacheKey()
209		{
210	10	return sprintf(self::TOKEN_KEY_FORMAT, rawurlencode($this->tenant->getTokenUrl()));
211		}
212		}
213

treehouselabs / keystone-client

Pull Request — master (#14)

TokenPool::getEndpointUrl() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like