| <?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); |
| } |
| } |