src/Apache/Ignite/ClientConfiguration.php - ignite-php-thin-client - Git at Google

 <?php
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 namespace Apache\Ignite;

 use Apache\Ignite\Exception\ClientException;
 use Apache\Ignite\Internal\Utils\ArgumentChecker;

 /**
  * Class representing Ignite client configuration.
  *
  * The configuration includes:
  *   - (mandatory) Ignite node endpoint(s)
  *   - (optional) user credentials for authentication
  *   - (optional) TLS options for secure connection
  *   - (optional) connection options
  */
 class ClientConfiguration
 {
     private $endpoints;
     private $userName;
     private $password;
     private $tlsOptions;
     private $timeout;
     private $sendChunkSize;
     private $receiveChunkSize;
     private $tcpNoDelay;

     const ENDPOINT_PORT_DEFAULT = 10800;

     /**
      * Creates an instance of Ignite client configuration
      * with the provided mandatory settings and default optional settings.
      *
      * By default, the client does not use authentication and secure connection.
      *
      * @param string ...$endpoints Ignite node endpoint(s). The client randomly connects/reconnects
      * to one of the specified node.
      *
      * @throws ClientException if error.
      */
     public function __construct(string ...$endpoints)
     {
         ArgumentChecker::notEmpty($endpoints, 'endpoints');
         $this->endpoints = array_map(array($this, 'parseEndpoint'), $endpoints);
         $this->userName = null;
         $this->password = null;
         $this->tlsOptions = null;
         $this->timeout = 0;
         $this->sendChunkSize = 0;
         $this->receiveChunkSize = 0;
         $this->tcpNoDelay = true;
     }

     /**
      * Returns Ignite node endpoints specified in the constructor.
      *
      * @return string[] endpoints
      */
     public function getEndpoints(): array
     {
         return $this->endpoints;
     }

     /**
      * Sets username which will be used for authentication during the client's connection.
      *
      * If username is not set, the client does not use authentication during connection.
      *
      * @param string|null $userName username. If null, authentication is disabled.
      *
      * @return ClientConfiguration the same instance of the ClientConfiguration.
      */
     public function setUserName(?string $userName): ClientConfiguration
     {
         $this->userName = $userName;
         return $this;
     }

     /**
      * Returns the current username.
      *
      * @return string|null username or null (if authentication is disabled).
      */
     public function getUserName(): ?string
     {
         return $this->userName;
     }

     /**
      * Sets password which will be used for authentication during the client's connection.
      *
      * Password is ignored, if username is not set.
      * If password is not set, it is considered empty.
      *
      * @param string|null $password password. If null, password is empty.
      *
      * @return ClientConfiguration the same instance of the ClientConfiguration.
      */
     public function setPassword(?string $password): ClientConfiguration
     {
         $this->password = $password;
         return $this;
     }

     /**
      * Returns the current password.
      *
      * @return string|null password or null (if password is empty).
      */
     public function getPassword(): ?string
     {
         return $this->password;
     }

     /**
      * Enables and setup TLS connection.
      *
      * If not enabled (by default), the client does not use secure connection.
      *
      * @param array|null $tlsOptions TLS connection options in the format defined here: http://php.net/manual/en/context.ssl.php
      * If null, secure connection is not used.
      *
      * @return ClientConfiguration the same instance of the ClientConfiguration.
      */
     public function setTLSOptions(?array $tlsOptions): ClientConfiguration
     {
         $this->tlsOptions = $tlsOptions;
         return $this;
     }

     /**
      * Returns the current TLS connection options.
      *
      * @return array|null TLS connection options or null (if secure connection is not used).
      */
     public function getTLSOptions(): ?array
     {
         return $this->tlsOptions;
     }

     /**
      * Sets send/receive timeout.
      *
      * Default value is defined by the PHP settings.
      *
      * @param int $timeout send/receive timeout (in milliseconds).
      *
      * @return ClientConfiguration the same instance of the ClientConfiguration.
      */
     public function setTimeout(int $timeout): ClientConfiguration
     {
         $this->timeout = $timeout;
         return $this;
     }

     /**
      * Returns the current send/receive timeout.
      *
      * @return int send/receive timeout (in milliseconds).
      */
     public function getTimeout(): int
     {
         return $this->timeout;
     }

     /**
      * Sets the size of the send chunk.
      *
      * 8192 bytes by default.
      *
      * @param int $size size of the send chunk (in bytes).
      *
      * @return ClientConfiguration the same instance of the ClientConfiguration.
      */
     public function setSendChunkSize(int $size): ClientConfiguration
     {
         $this->sendChunkSize = $size;
         return $this;
     }

     /**
      * Returns the current size of the send chunk.
      *
      * @return int size of the send chunk (in bytes).
      */
     public function getSendChunkSize(): int
     {
         return $this->sendChunkSize;
     }

     /**
      * Sets the size of the receive chunk.
      *
      * 8192 bytes by default.
      *
      * @param int $size size of the receive chunk (in bytes).
      *
      * @return ClientConfiguration the same instance of the ClientConfiguration.
      */
     public function setReceiveChunkSize(int $size): ClientConfiguration
     {
         $this->receiveChunkSize = $size;
         return $this;
     }

     /**
      * Returns the current size of the receive chunk.
      *
      * @return int size of the receive chunk (in bytes).
      */
     public function getReceiveChunkSize(): int
     {
         return $this->receiveChunkSize;
     }

     /**
      * Disables/enables the TCP Nagle algorithm.
      *
      * Enabled by default.
      *
      * @param bool $tcpNoDelay true to enable, false to disable.
      *
      * @return ClientConfiguration the same instance of the ClientConfiguration.
      */
     public function setTcpNoDelay(bool $tcpNoDelay): ClientConfiguration
     {
         $this->tcpNoDelay = $tcpNoDelay;
         return $this;
     }

     /**
      * Returns the current status of the TCP Nagle algorithm.
      *
      * @return bool true if enabled, false if disabled.
      */
     public function getTcpNoDelay(): bool
     {
         return $this->tcpNoDelay;
     }

     private function parseEndpoint(string $endpoint): string
     {
         $endpoint = trim($endpoint);
         $host = $endpoint;
         $port = null;
         $parsed = explode(':', $endpoint);
         if (count($parsed) > 2) {
             // IPv6 address
             $index = strrpos($endpoint, ']:');
             if ($index !== false) {
                 $host = substr($endpoint, 0, $index + 1);
                 $port = substr($endpoint, $index + 2);
             }
             $first = $host[0];
             $last = $host[strlen($host) - 1];
             if ($first === '[' || $last === ']') {
                 if (!($first === '[' && $last === ']')) {
                     ArgumentChecker::illegalArgument('Incorrect endpoint format: ' . $endpoint);
                 }
             } else {
                 $host = sprintf('[%s]', $host);
             }
         }
         else {
             // IPv4 address
             $host = $parsed[0];
             if (count($parsed) === 2) {
                 $port = $parsed[1];
             }
         }
         if ($port === null) {
             $port = self::ENDPOINT_PORT_DEFAULT;
         } elseif (!ctype_digit($port)) {
             ArgumentChecker::illegalArgument('Incorrect endpoint format: ' . $endpoint);
         }
         return sprintf('%s:%s', $host, $port);
     }
 }
	<?php
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	namespace Apache\Ignite;

	use Apache\Ignite\Exception\ClientException;
	use Apache\Ignite\Internal\Utils\ArgumentChecker;

	/**
	* Class representing Ignite client configuration.
	*
	* The configuration includes:
	* - (mandatory) Ignite node endpoint(s)
	* - (optional) user credentials for authentication
	* - (optional) TLS options for secure connection
	* - (optional) connection options
	*/
	class ClientConfiguration
	{
	private $endpoints;
	private $userName;
	private $password;
	private $tlsOptions;
	private $timeout;
	private $sendChunkSize;
	private $receiveChunkSize;
	private $tcpNoDelay;

	const ENDPOINT_PORT_DEFAULT = 10800;

	/**
	* Creates an instance of Ignite client configuration
	* with the provided mandatory settings and default optional settings.
	*
	* By default, the client does not use authentication and secure connection.
	*
	* @param string ...$endpoints Ignite node endpoint(s). The client randomly connects/reconnects
	* to one of the specified node.
	*
	* @throws ClientException if error.
	*/
	public function __construct(string ...$endpoints)
	{
	ArgumentChecker::notEmpty($endpoints, 'endpoints');
	$this->endpoints = array_map(array($this, 'parseEndpoint'), $endpoints);
	$this->userName = null;
	$this->password = null;
	$this->tlsOptions = null;
	$this->timeout = 0;
	$this->sendChunkSize = 0;
	$this->receiveChunkSize = 0;
	$this->tcpNoDelay = true;
	}

	/**
	* Returns Ignite node endpoints specified in the constructor.
	*
	* @return string[] endpoints
	*/
	public function getEndpoints(): array
	{
	return $this->endpoints;
	}

	/**
	* Sets username which will be used for authentication during the client's connection.
	*
	* If username is not set, the client does not use authentication during connection.
	*
	* @param string\|null $userName username. If null, authentication is disabled.
	*
	* @return ClientConfiguration the same instance of the ClientConfiguration.
	*/
	public function setUserName(?string $userName): ClientConfiguration
	{
	$this->userName = $userName;
	return $this;
	}

	/**
	* Returns the current username.
	*
	* @return string\|null username or null (if authentication is disabled).
	*/
	public function getUserName(): ?string
	{
	return $this->userName;
	}

	/**
	* Sets password which will be used for authentication during the client's connection.
	*
	* Password is ignored, if username is not set.
	* If password is not set, it is considered empty.
	*
	* @param string\|null $password password. If null, password is empty.
	*
	* @return ClientConfiguration the same instance of the ClientConfiguration.
	*/
	public function setPassword(?string $password): ClientConfiguration
	{
	$this->password = $password;
	return $this;
	}

	/**
	* Returns the current password.
	*
	* @return string\|null password or null (if password is empty).
	*/
	public function getPassword(): ?string
	{
	return $this->password;
	}

	/**
	* Enables and setup TLS connection.
	*
	* If not enabled (by default), the client does not use secure connection.
	*
	* @param array\|null $tlsOptions TLS connection options in the format defined here: http://php.net/manual/en/context.ssl.php
	* If null, secure connection is not used.
	*
	* @return ClientConfiguration the same instance of the ClientConfiguration.
	*/
	public function setTLSOptions(?array $tlsOptions): ClientConfiguration
	{
	$this->tlsOptions = $tlsOptions;
	return $this;
	}

	/**
	* Returns the current TLS connection options.
	*
	* @return array\|null TLS connection options or null (if secure connection is not used).
	*/
	public function getTLSOptions(): ?array
	{
	return $this->tlsOptions;
	}

	/**
	* Sets send/receive timeout.
	*
	* Default value is defined by the PHP settings.
	*
	* @param int $timeout send/receive timeout (in milliseconds).
	*
	* @return ClientConfiguration the same instance of the ClientConfiguration.
	*/
	public function setTimeout(int $timeout): ClientConfiguration
	{
	$this->timeout = $timeout;
	return $this;
	}

	/**
	* Returns the current send/receive timeout.
	*
	* @return int send/receive timeout (in milliseconds).
	*/
	public function getTimeout(): int
	{
	return $this->timeout;
	}

	/**
	* Sets the size of the send chunk.
	*
	* 8192 bytes by default.
	*
	* @param int $size size of the send chunk (in bytes).
	*
	* @return ClientConfiguration the same instance of the ClientConfiguration.
	*/
	public function setSendChunkSize(int $size): ClientConfiguration
	{
	$this->sendChunkSize = $size;
	return $this;
	}

	/**
	* Returns the current size of the send chunk.
	*
	* @return int size of the send chunk (in bytes).
	*/
	public function getSendChunkSize(): int
	{
	return $this->sendChunkSize;
	}

	/**
	* Sets the size of the receive chunk.
	*
	* 8192 bytes by default.
	*
	* @param int $size size of the receive chunk (in bytes).
	*
	* @return ClientConfiguration the same instance of the ClientConfiguration.
	*/
	public function setReceiveChunkSize(int $size): ClientConfiguration
	{
	$this->receiveChunkSize = $size;
	return $this;
	}

	/**
	* Returns the current size of the receive chunk.
	*
	* @return int size of the receive chunk (in bytes).
	*/
	public function getReceiveChunkSize(): int
	{
	return $this->receiveChunkSize;
	}

	/**
	* Disables/enables the TCP Nagle algorithm.
	*
	* Enabled by default.
	*
	* @param bool $tcpNoDelay true to enable, false to disable.
	*
	* @return ClientConfiguration the same instance of the ClientConfiguration.
	*/
	public function setTcpNoDelay(bool $tcpNoDelay): ClientConfiguration
	{
	$this->tcpNoDelay = $tcpNoDelay;
	return $this;
	}

	/**
	* Returns the current status of the TCP Nagle algorithm.
	*
	* @return bool true if enabled, false if disabled.
	*/
	public function getTcpNoDelay(): bool
	{
	return $this->tcpNoDelay;
	}

	private function parseEndpoint(string $endpoint): string
	{
	$endpoint = trim($endpoint);
	$host = $endpoint;
	$port = null;
	$parsed = explode(':', $endpoint);
	if (count($parsed) > 2) {
	// IPv6 address
	$index = strrpos($endpoint, ']:');
	if ($index !== false) {
	$host = substr($endpoint, 0, $index + 1);
	$port = substr($endpoint, $index + 2);
	}
	$first = $host[0];
	$last = $host[strlen($host) - 1];
	if ($first === '[' \|\| $last === ']') {
	if (!($first === '[' && $last === ']')) {
	ArgumentChecker::illegalArgument('Incorrect endpoint format: ' . $endpoint);
	}
	} else {
	$host = sprintf('[%s]', $host);
	}
	}
	else {
	// IPv4 address
	$host = $parsed[0];
	if (count($parsed) === 2) {
	$port = $parsed[1];
	}
	}
	if ($port === null) {
	$port = self::ENDPOINT_PORT_DEFAULT;
	} elseif (!ctype_digit($port)) {
	ArgumentChecker::illegalArgument('Incorrect endpoint format: ' . $endpoint);
	}
	return sprintf('%s:%s', $host, $port);
	}
	}