Connection::hasCompression() - Code Metrics - Inspection of "add auth_type param to fix issue 1789 (#1790)" - ruflin/Elastica - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fe4520...b43380 )

by Nicolas

created 2020-08-06 08:57 UTC

Connection::hasCompression() A

↳ Parent: Connection

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?php

namespace Elastica;

use Elastica\Exception\InvalidException;
use Elastica\Transport\AbstractTransport;

/**
 * Elastica connection instance to an elasticasearch node.
 *
 * @author   Nicolas Ruflin <[email protected]>
 */
class Connection extends Param
{
    /**
     * Default elastic search port.
     */
    public const DEFAULT_PORT = 9200;

    /**
     * Default host.
     */
    public const DEFAULT_HOST = 'localhost';

    /**
     * Default transport.
     *
     * @var string
     */
    public const DEFAULT_TRANSPORT = 'Http';

    /**
     * Default compression.
     *
     * @var string
     */
    public const DEFAULT_COMPRESSION = false;

    /**
     * Number of seconds after a timeout occurs for every request
     * If using indexing of file large value necessary.
     */
    public const TIMEOUT = 300;

    /**
     * Number of seconds after a connection timeout occurs for every request during the connection phase.
     *
     * @see Connection::setConnectTimeout();
     */
    public const CONNECT_TIMEOUT = 0;

    /**
     * Creates a new connection object. A connection is enabled by default.
     *
     * @param array $params OPTIONAL Connection params: host, port, transport, timeout. All are optional
     */
    public function __construct(array $params = [])
    {
        $this->setParams($params);
        $this->setEnabled(true);

        // Set empty config param if not exists
        if (!$this->hasParam('config')) {
            $this->setParam('config', []);
        }
    }

    /**
     * @return int Server port
     */
    public function getPort()
    {
        return $this->hasParam('port') ? $this->getParam('port') : self::DEFAULT_PORT;
    }

    /**
     * @param int $port
     *
     * @return $this
     */
    public function setPort($port)
    {
        return $this->setParam('port', (int) $port);
    }

    /**
     * @return string Host
     */
    public function getHost()
    {
        return $this->hasParam('host') ? $this->getParam('host') : self::DEFAULT_HOST;
    }

    /**
     * @param string $host
     *
     * @return $this
     */
    public function setHost($host)
    {
        return $this->setParam('host', $host);
    }

    /**
     * @return string|null Host
     */
    public function getProxy()
    {
        return $this->hasParam('proxy') ? $this->getParam('proxy') : null;
    }

    /**
     * Set proxy for http connections. Null is for environmental proxy,
     * empty string to disable proxy and proxy string to set actual http proxy.
     *
     * @see http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTPROXY
     *
     * @param string|null $proxy
     *
     * @return $this
     */
    public function setProxy($proxy)
    {
        return $this->setParam('proxy', $proxy);
    }

    /**
     * @return array|string
     */
    public function getTransport()
    {
        return $this->hasParam('transport') ? $this->getParam('transport') : self::DEFAULT_TRANSPORT;
    }

    /**
     * @param array|string $transport
     *
     * @return $this
     */
    public function setTransport($transport)
    {
        return $this->setParam('transport', $transport);
    }

    /**
     * @return bool
     */
    public function hasCompression()
    {
        return (bool) $this->hasParam('compression') ? $this->getParam('compression') : self::DEFAULT_COMPRESSION;
    }

    /**
     * @param bool $compression
     *
     * @return $this
     */
    public function setCompression($compression = null)
    {
        return $this->setParam('compression', $compression);
    }

    /**
     * @return string
     */
    public function getPath()
    {
        return $this->hasParam('path') ? $this->getParam('path') : '';
    }

    /**
     * @param string $path
     *
     * @return $this
     */
    public function setPath($path)
    {
        return $this->setParam('path', $path);
    }

    /**
     * @param int $timeout Timeout in seconds
     *
     * @return $this
     */
    public function setTimeout($timeout)
    {
        return $this->setParam('timeout', $timeout);
    }

    /**
     * @return int Connection timeout in seconds
     */
    public function getTimeout()
    {
        return (int) $this->hasParam('timeout') ? $this->getParam('timeout') : self::TIMEOUT;
    }

    /**
     * Number of seconds after a connection timeout occurs for every request during the connection phase.
     * Use a small value if you need a fast fail in case of dead, unresponsive or unreachable servers (~5 sec).
     *
     * Set to zero to switch to the default built-in connection timeout (300 seconds in curl).
     *
     * @see http://curl.haxx.se/libcurl/c/CURLOPT_CONNECTTIMEOUT.html
     *
     * @param int $timeout Connect timeout in seconds
     *
     * @return $this
     */
    public function setConnectTimeout($timeout)
    {
        return $this->setParam('connectTimeout', $timeout);
    }

    /**
     * @return int Connection timeout in seconds
     */
    public function getConnectTimeout()
    {
        return (int) $this->hasParam('connectTimeout') ? $this->getParam('connectTimeout') : self::CONNECT_TIMEOUT;
    }

    /**
     * Enables a connection.
     *
     * @param bool $enabled OPTIONAL (default = true)
     *
     * @return $this
     */
    public function setEnabled($enabled = true)
    {
        return $this->setParam('enabled', $enabled);
    }

    /**
     * @return bool True if enabled
     */
    public function isEnabled()
    {
        return (bool) $this->getParam('enabled');
    }

    /**
     * Returns an instance of the transport type.
     *
     * @throws \Elastica\Exception\InvalidException If invalid transport type
     *
     * @return \Elastica\Transport\AbstractTransport Transport object
     */
    public function getTransportObject()
    {
        $transport = $this->getTransport();

        return AbstractTransport::create($transport, $this);
    }

    /**
     * @return bool Returns true if connection is persistent. True by default
     */
    public function isPersistent()
    {
        return (bool) $this->hasParam('persistent') ? $this->getParam('persistent') : true;
    }

    /**
     * @return $this
     */
    public function setConfig(array $config)
    {
        return $this->setParam('config', $config);
    }

    /**
     * @param string $key
     * @param mixed  $value
     *
     * @return $this
     */
    public function addConfig($key, $value)
    {
        $this->_params['config'][$key] = $value;

        return $this;
    }

    /**
     * @param string $key
     *
     * @return bool
     */
    public function hasConfig($key)
    {
        $config = $this->getConfig();

        return isset($config[$key]);
    }

    /**
     * Returns a specific config key or the whole
     * config array if not set.
     *
     * @param string $key Config key
     *
     * @throws \Elastica\Exception\InvalidException
     *
     * @return array|string Config value
     */
    public function getConfig($key = '')
    {
        $config = $this->getParam('config');
        if (empty($key)) {
            return $config;
        }

        if (!\array_key_exists($key, $config)) {
            throw new InvalidException('Config key is not set: '.$key);
        }

        return $config[$key];
    }

    /**
     * @param array|\Elastica\Connection $params Params to create a connection
     *
     * @throws Exception\InvalidException
     *
     * @return self
     */
    public static function create($params = [])
    {
        if (\is_array($params)) {
            return new static($params);
        }

        if ($params instanceof self) {
            return $params;
        }

        throw new InvalidException('Invalid data type');
    }

    /**
     * @return string User
     */
    public function getUsername()
    {
        return $this->hasParam('username') ? $this->getParam('username') : null;
    }

    /**
     * @return string Password
     */
    public function getPassword()
    {
        return $this->hasParam('password') ? $this->getParam('password') : null;
    }

    /**
     * @return string AuthType
     */
    public function getAuthType()
    {
        return $this->hasParam('auth_type') ? \strtolower($this->getParam('auth_type')) : null;
    }
}


1			<?php
2
3			namespace Elastica;
4
5			use Elastica\Exception\InvalidException;
6			use Elastica\Transport\AbstractTransport;
7
8			/**
9			* Elastica connection instance to an elasticasearch node.
10			*
11			* @author Nicolas Ruflin <[email protected]>
12			*/
13			class Connection extends Param
14			{
15			/**
16			* Default elastic search port.
17			*/
18			public const DEFAULT_PORT = 9200;
19
20			/**
21			* Default host.
22			*/
23			public const DEFAULT_HOST = 'localhost';
24
25			/**
26			* Default transport.
27			*
28			* @var string
29			*/
30			public const DEFAULT_TRANSPORT = 'Http';
31
32			/**
33			* Default compression.
34			*
35			* @var string
36			*/
37			public const DEFAULT_COMPRESSION = false;
38
39			/**
40			* Number of seconds after a timeout occurs for every request
41			* If using indexing of file large value necessary.
42			*/
43			public const TIMEOUT = 300;
44
45			/**
46			* Number of seconds after a connection timeout occurs for every request during the connection phase.
47			*
48			* @see Connection::setConnectTimeout();
49			*/
50			public const CONNECT_TIMEOUT = 0;
51
52			/**
53			* Creates a new connection object. A connection is enabled by default.
54			*
55			* @param array $params OPTIONAL Connection params: host, port, transport, timeout. All are optional
56			*/
57			public function __construct(array $params = [])
58			{
59			$this->setParams($params);
60			$this->setEnabled(true);
61
62			// Set empty config param if not exists
63			if (!$this->hasParam('config')) {
64			$this->setParam('config', []);
65			}
66			}
67
68			/**
69			* @return int Server port
70			*/
71			public function getPort()
72			{
73			return $this->hasParam('port') ? $this->getParam('port') : self::DEFAULT_PORT;
74			}
75
76			/**
77			* @param int $port
78			*
79			* @return $this
80			*/
81			public function setPort($port)
82			{
83			return $this->setParam('port', (int) $port);
84			}
85
86			/**
87			* @return string Host
88			*/
89			public function getHost()
90			{
91			return $this->hasParam('host') ? $this->getParam('host') : self::DEFAULT_HOST;
92			}
93
94			/**
95			* @param string $host
96			*
97			* @return $this
98			*/
99			public function setHost($host)
100			{
101			return $this->setParam('host', $host);
102			}
103
104			/**
105			* @return string\|null Host
106			*/
107			public function getProxy()
108			{
109			return $this->hasParam('proxy') ? $this->getParam('proxy') : null;
110			}
111
112			/**
113			* Set proxy for http connections. Null is for environmental proxy,
114			* empty string to disable proxy and proxy string to set actual http proxy.
115			*
116			* @see http://curl.haxx.se/libcurl/c/curl_easy_setopt.html#CURLOPTPROXY
117			*
118			* @param string\|null $proxy
119			*
120			* @return $this
121			*/
122			public function setProxy($proxy)
123			{
124			return $this->setParam('proxy', $proxy);
125			}
126
127			/**
128			* @return array\|string
129			*/
130			public function getTransport()
131			{
132			return $this->hasParam('transport') ? $this->getParam('transport') : self::DEFAULT_TRANSPORT;
133			}
134
135			/**
136			* @param array\|string $transport
137			*
138			* @return $this
139			*/
140			public function setTransport($transport)
141			{
142			return $this->setParam('transport', $transport);
143			}
144
145			/**
146			* @return bool
147			*/
148			public function hasCompression()
149			{
150			return (bool) $this->hasParam('compression') ? $this->getParam('compression') : self::DEFAULT_COMPRESSION;
151			}
152
153			/**
154			* @param bool $compression
155			*
156			* @return $this
157			*/
158			public function setCompression($compression = null)
159			{
160			return $this->setParam('compression', $compression);
161			}
162
163			/**
164			* @return string
165			*/
166			public function getPath()
167			{
168			return $this->hasParam('path') ? $this->getParam('path') : '';
169			}
170
171			/**
172			* @param string $path
173			*
174			* @return $this
175			*/
176			public function setPath($path)
177			{
178			return $this->setParam('path', $path);
179			}
180
181			/**
182			* @param int $timeout Timeout in seconds
183			*
184			* @return $this
185			*/
186			public function setTimeout($timeout)
187			{
188			return $this->setParam('timeout', $timeout);
189			}
190
191			/**
192			* @return int Connection timeout in seconds
193			*/
194			public function getTimeout()
195			{
196			return (int) $this->hasParam('timeout') ? $this->getParam('timeout') : self::TIMEOUT;
197			}
198
199			/**
200			* Number of seconds after a connection timeout occurs for every request during the connection phase.
201			* Use a small value if you need a fast fail in case of dead, unresponsive or unreachable servers (~5 sec).
202			*
203			* Set to zero to switch to the default built-in connection timeout (300 seconds in curl).
204			*
205			* @see http://curl.haxx.se/libcurl/c/CURLOPT_CONNECTTIMEOUT.html
206			*
207			* @param int $timeout Connect timeout in seconds
208			*
209			* @return $this
210			*/
211			public function setConnectTimeout($timeout)
212			{
213			return $this->setParam('connectTimeout', $timeout);
214			}
215
216			/**
217			* @return int Connection timeout in seconds
218			*/
219			public function getConnectTimeout()
220			{
221			return (int) $this->hasParam('connectTimeout') ? $this->getParam('connectTimeout') : self::CONNECT_TIMEOUT;
222			}
223
224			/**
225			* Enables a connection.
226			*
227			* @param bool $enabled OPTIONAL (default = true)
228			*
229			* @return $this
230			*/
231			public function setEnabled($enabled = true)
232			{
233			return $this->setParam('enabled', $enabled);
234			}
235
236			/**
237			* @return bool True if enabled
238			*/
239			public function isEnabled()
240			{
241			return (bool) $this->getParam('enabled');
242			}
243
244			/**
245			* Returns an instance of the transport type.
246			*
247			* @throws \Elastica\Exception\InvalidException If invalid transport type
248			*
249			* @return \Elastica\Transport\AbstractTransport Transport object
250			*/
251			public function getTransportObject()
252			{
253			$transport = $this->getTransport();
254
255			return AbstractTransport::create($transport, $this);
256			}
257
258			/**
259			* @return bool Returns true if connection is persistent. True by default
260			*/
261			public function isPersistent()
262			{
263			return (bool) $this->hasParam('persistent') ? $this->getParam('persistent') : true;
264			}
265
266			/**
267			* @return $this
268			*/
269			public function setConfig(array $config)
270			{
271			return $this->setParam('config', $config);
272			}
273
274			/**
275			* @param string $key
276			* @param mixed $value
277			*
278			* @return $this
279			*/
280			public function addConfig($key, $value)
281			{
282			$this->_params['config'][$key] = $value;
283
284			return $this;
285			}
286
287			/**
288			* @param string $key
289			*
290			* @return bool
291			*/
292			public function hasConfig($key)
293			{
294			$config = $this->getConfig();
295
296			return isset($config[$key]);
297			}
298
299			/**
300			* Returns a specific config key or the whole
301			* config array if not set.
302			*
303			* @param string $key Config key
304			*
305			* @throws \Elastica\Exception\InvalidException
306			*
307			* @return array\|string Config value
308			*/
309			public function getConfig($key = '')
310			{
311			$config = $this->getParam('config');
312			if (empty($key)) {
313			return $config;
314			}
315
316			if (!\array_key_exists($key, $config)) {
317			throw new InvalidException('Config key is not set: '.$key);
318			}
319
320			return $config[$key];
321			}
322
323			/**
324			* @param array\|\Elastica\Connection $params Params to create a connection
325			*
326			* @throws Exception\InvalidException
327			*
328			* @return self
329			*/
330			public static function create($params = [])
331			{
332			if (\is_array($params)) {
333			return new static($params);
334			}
335
336			if ($params instanceof self) {
337			return $params;
338			}
339
340			throw new InvalidException('Invalid data type');
341			}
342
343			/**
344			* @return string User
345			*/
346			public function getUsername()
347			{
348			return $this->hasParam('username') ? $this->getParam('username') : null;
349			}
350
351			/**
352			* @return string Password
353			*/
354			public function getPassword()
355			{
356			return $this->hasParam('password') ? $this->getParam('password') : null;
357			}
358
359			/**
360			* @return string AuthType
361			*/
362			public function getAuthType()
363			{
364			return $this->hasParam('auth_type') ? \strtolower($this->getParam('auth_type')) : null;
365			}
366			}
367

ruflin / Elastica

Push — master ( fe4520...b43380 )

Connection::hasCompression() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like