ElasticsearchModule\Service\ConnectionPoolFactory

Complexity

Total Complexity

15

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

97.92%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	create()	0	31	4
A	getServiceType()	0	4	1
B	getConnectionsFromConfiguration()	0	17	5
A	normalizeExtendedHost()	0	8	2
A	extractURIParts()	0	10	3

<?php

namespace ElasticsearchModule\Service;

use ArrayObject;
use Elasticsearch\ConnectionPool\AbstractConnectionPool;
use Elasticsearch\Connections\ConnectionFactoryInterface;
use Elasticsearch\Connections\ConnectionInterface;
use Zend\ServiceManager\Exception\InvalidArgumentException;
use Zend\ServiceManager\Exception\ServiceNotCreatedException;
use Zend\ServiceManager\ServiceLocatorInterface;
use Zend\Stdlib\ArrayObject as ZendArrayObject;

/**
 * @author Pedro Alves <pedro.m.develop@gmail.com>
 */
class ConnectionPoolFactory extends AbstractFactory
{
    use InvalidTypeExceptionTrait;
    
    /**
     * {@inheritDoc}
     */
    protected function create(ServiceLocatorInterface $serviceLocator, $config)
    {
        $className = $config['class'];
        
        if (!in_array(AbstractConnectionPool::class, class_parents($className))) {
            throw new ServiceNotCreatedException(sprintf(
                "'%s' does not implement %s",
                $className,
                AbstractConnectionPool::class
            ));
        }
        $selector = $this->getServiceOrClassObject($serviceLocator, $config['selector']);
        $connectionFactory = $this->getServiceOrClassObject($serviceLocator, $config['connection_factory']);
        
        if (!$connectionFactory instanceof ConnectionFactoryInterface) {
            throw $this->getException(
                'connection factory',
                ConnectionFactoryInterface::class,
                ServiceNotCreatedException::class,
                $connectionFactory
            );
        }
        $parameters = isset($config['parameters']) ? $config['parameters'] : [];
        $connections = $this->getConnectionsFromConfiguration($config, $connectionFactory);
        return new $className(
            $connections,
            $selector,
            $connectionFactory,
            $parameters
        );
    }

    /**
     * {@inheritDoc}
     */
    public function getServiceType()
    {
        return 'connection_pool';
    }
    
    /**
     * @param array|ArrayObject|ZendArrayObject $config
     * @param ConnectionFactoryInterface $connectionFactory
     * @return ConnectionInterface[]
     * @throws ServiceNotCreatedException
     */
    private function getConnectionsFromConfiguration($config, ConnectionFactoryInterface $connectionFactory)
    {
        $connections = [];
        
        foreach ($config['hosts'] as $host) {
            if (!is_string($host) && !is_array($host)) {
                throw new ServiceNotCreatedException("Could not parse host: " . print_r($host, true));
            }
            
            if (is_string($host)) {
                $host = $this->extractURIParts($host);
            }
            $host = $this->normalizeExtendedHost($host);
            $connections[] = $connectionFactory->create($host);
        }
        return $connections;
    }

    /**
     * @param $host
     * @return array
     */
    private function normalizeExtendedHost($host) {
        if (isset($host['host']) === false) {
            throw new ServiceNotCreatedException(
                "Required 'host' was not defined in extended format: " . print_r($host, true)
            );
        }
        return array_merge(['scheme' => 'http', 'port' => 9200], $host);
    }

    /**
     * @param string $host
     *
     * @throws InvalidArgumentException
     * @return array
     */
    private function extractURIParts($host)
    {
        $host = filter_var($host, FILTER_VALIDATE_URL, FILTER_FLAG_SCHEME_REQUIRED) ? $host : 'http://' . $host;
        $parts = parse_url($host);

        if ($parts === false) {
            throw new InvalidArgumentException("Could not parse URI");
        }
        return array_merge(['port' => 9200], $parts);
    }

}