IndexService::createSecondaryIndex() - Code Metrics - TYPO3GmbH/elasticorn - Measure and Improve Code Quality continuously with Scrutinizer

IndexService::createSecondaryIndex() A
last analyzed 2020-02-21 07:41 UTC

↳ Parent: IndexService

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	3

<?php
declare (strict_types=1);

namespace T3G\Elasticorn\Service;

use Elastica\Client;
use Elastica\Index;
use Elastica\Reindex;
use Psr\Log\LoggerInterface;
use T3G\Elasticorn\Configuration\ApplicationConfiguration;

/**
 * Class IndexService
 *
 */
class IndexService
{
    /**
     * @var \Elastica\Client
     */
    protected $client;

    /**
     * @var Index
     */
    private $index;

    /**
     * @var \Psr\Log\LoggerInterface
     */
    private $logger;

    /**
     * @var \T3G\Elasticorn\Service\ConfigurationService
     */
    private $configurationService;

    /**
     * IndexService constructor.
     *
     * @param \Elastica\Client                             $client
     * @param \T3G\Elasticorn\Service\ConfigurationService $configurationService
     * @param \Psr\Log\LoggerInterface                     $logger
     * @param string                                       $indexName
     */
    public function __construct(
        Client $client,
        ConfigurationService $configurationService,
        LoggerInterface $logger,
        string $indexName = null
    ) {
        $this->client = $client;
        $this->logger = $logger;
        $this->configurationService = $configurationService;
        if (null !== $indexName) {
            $this->index = $this->client->getIndex($indexName);
        }
    }

    /**
     * @return Index|null
     */
    public function getIndex()
    {
        return $this->index;
    }

    /**
     * Rename an index (creates new index with data from old)
     * CAUTION: All mappings are lost, only data is preserved
     *
     * @param string $newName
     */
    public function renameIndex(string $newName)
    {
        $newIndex = $this->client->getIndex($newName);
        $newIndex->create();
        $reindex = new Reindex($this->index, $newIndex);
        $reindex->run();
        $this->index->delete();
    }

    /**
     * Add all indices found in configuration directory
     * Creates indices with suffixes _a and _b and adds an alias as indexName
     */
    public function initIndices()
    {
        $indexConfigurations = $this->configurationService->getIndexConfigurations();
        foreach ($indexConfigurations as $indexName => $configuration) {
            $this->createIndex($indexName, $configuration);
        }
    }

    /**
     * Initializes a single index from config files
     *
     * @param string $indexName
     */
    public function initIndex(string $indexName)
    {
        $configuration = $this->configurationService->getIndexConfiguration($indexName);

        $this->createIndex($indexName, $configuration);
    }

    /**
     * Copy data from oldIndexName to newIndexName
     *
     * @param string $oldIndexName
     * @param string $newIndexName
     */
    public function copyData(string $oldIndexName, string $newIndexName)
    {
        $oldIndex = $this->client->getIndex($oldIndexName);
        $newIndex = $this->client->getIndex($newIndexName);
        $reindex = new Reindex($oldIndex, $newIndex);
        $reindex->run();
    }

    /**
     * Re-apply mappings to all indices found in configuration directory
     *
     * @see remap($indexName)
     *
     * @param bool $force
     */
    public function remapAll(bool $force = false)
    {
        $indexConfigurations = $this->configurationService->getIndexConfigurations();
        $indices = array_keys($indexConfigurations);
        foreach ($indices as $indexName) {
            $this->remap($indexName, $force);
        }
    }

    /**
     * @return array
     */
    public function getMappingForIndex()
    {
        $this->logger->debug('Get current mapping for ' . $this->index->getName());
        return $this->index->getMapping();
    }


    /**
     * Remap an index
     *
     * Drops and recreates the current inactive index, applies mappings and imports data from active index
     * After successfully importing data the alias gets set to the new index
     *
     * @param string $indexName
     * @param bool   $force
     *
     * @throws \InvalidArgumentException
     */
    public function remap(string $indexName, bool $force = false)
    {
        if ($this->configurationService->compareMappingConfiguration($indexName) === '') {
            if (false === $force) {
                $this->logger->info('No difference between configurations, no remapping done');
                return;
            } else {
                $this->logger->info('No difference between configurations but force given, remapping anyway.');
            }
        }
        $languages = ApplicationConfiguration::getLanguageConfiguration();
        if (count($languages) > 0) {
            foreach ($languages as $language) {
                $this->remapIndex($indexName, $language);
            }
            $this->logger->debug(
                'Adding alias to ' . $indexName . '_' . $languages[0] . ' from ' . $indexName
            );
            $this->client->getIndex($indexName . '_' . $languages[0])->addAlias($indexName);
        } else {
            $this->remapIndex($indexName);
        }
    }

    /**
     * @param string $indexName
     */
    private function remapIndex(string $indexName, string $language = '')
    {
        $aliasName = $indexName;
        $languageMessage = '';
        if ($language) {
            $aliasName .= '_' . $language;
            $languageMessage = ' in language ' . $language;
        }
        $this->logger->info('Remapping ' . $indexName . $languageMessage);
        $primaryIndexIdentifier = $this->getFullIndexIdentifier($indexName, 'a', $language);
        $indexA = $this->client->getIndex($primaryIndexIdentifier);
        if ($indexA->exists()) {
            $indexB = $this->client->getIndex($this->getFullIndexIdentifier($indexName, 'b', $language));

            if ($indexA->hasAlias($aliasName)) {
                $activeIndex = $indexA;
                $inactiveIndex = $indexB;
            } elseif ($indexB->hasAlias($aliasName)) {
                $activeIndex = $indexB;
                $inactiveIndex = $indexA;
            } else {
                throw new \InvalidArgumentException('No active index with name ' . $indexName . ' found.');
            }

            $this->recreateIndex($indexName, $inactiveIndex, $language);
            $this->logger->debug('Reindexing data with new mapping.');
            $reindex = new Reindex($activeIndex, $inactiveIndex);
            $reindex->run();
            $this->switchAlias($aliasName, $activeIndex, $inactiveIndex);
        } else {
            $configuration = $this->configurationService->getIndexConfigurations();
            $this->createPrimaryIndex($indexName, $configuration, $language);
            $this->createSecondaryIndex($indexName, $configuration, $language);
        }
    }

    /**
     * @param string          $indexName
     * @param \Elastica\Index $activeIndex
     * @param \Elastica\Index $inactiveIndex
     */
    private function switchAlias(string $indexName, Index $activeIndex, Index $inactiveIndex)
    {
        $this->logger->debug('Switching alias from ' . $activeIndex->getName() . ' to ' . $inactiveIndex->getName());
        $activeIndex->removeAlias($indexName);
        $inactiveIndex->addAlias($indexName);
    }

    /**
     * @param string $indexName
     * @param array  $configuration
     *
     * @throws \InvalidArgumentException
     */
    private function createIndex(string $indexName, array $configuration)
    {
        $this->logger->info('Creating index ' . $indexName);
        $index = $this->client->getIndex($indexName);
        $languages = ApplicationConfiguration::getLanguageConfiguration();
        if (!$index->exists()) {
            if (count($languages) > 0) {
                foreach ($languages as $language) {
                    $this->createPrimaryIndex($indexName, $configuration, $language);
                    $this->createSecondaryIndex($indexName, $configuration, $language);
                }
                $primaryIndex = $this->client->getIndex($indexName . '_' . $languages[0]);
                $primaryIndex->addAlias($indexName);
            } else {
                $this->createPrimaryIndex($indexName, $configuration);
                $this->createSecondaryIndex($indexName, $configuration);
            }
        } else {
            throw new \InvalidArgumentException('Index ' . $indexName . ' already exists.');
        }
    }

    private function createPrimaryIndex(string $indexName, array $configuration, string $language = '')
    {
        $index = $this->client->getIndex($this->getFullIndexIdentifier($indexName, 'a', $language));
        $this->createWithMapping($indexName, $index, $configuration, $language);
        $index->addAlias($indexName . ($language ? '_' . $language : ''));
    }

    /**
     * @param string $indexName
     * @param array  $configuration
     * @param string $language
     */
    private function createSecondaryIndex(string $indexName, array $configuration, string $language = '')
    {
        $index = $this->client->getIndex($this->getFullIndexIdentifier($indexName, 'b', $language));
        $this->createWithMapping($indexName, $index, $configuration, $language);
    }

    private function getFullIndexIdentifier(string $indexName, string $suffix = '', string $language = '')
    {
        return $indexName . ($language ? '_' . $language : '') . ($suffix ? '_' . $suffix : '');
    }

    /**
     * @param string          $indexName
     * @param \Elastica\Index $index
     * @param                 $indexConfiguration
     */
    private function createWithMapping(
        string $indexName,
        Index $index,
        array $indexConfiguration,
        string $language = ''
    ) {
        $index->create($indexConfiguration);
        $this->logger->debug('Creating index ' . $indexName);
        $this->configurationService->applyMapping($indexName, $index, $language);
    }

    /**
     * @param string $indexName
     * @param Index  $index
     * @param string $language
     */
    private function recreateIndex(string $indexName, Index $index, string $language)
    {
        $indexConfiguration = $this->configurationService->getIndexConfiguration($indexName);
        $this->logger->debug('Deleting index ' . $indexName);
        $index->delete();
        $this->createWithMapping($indexName, $index, $indexConfiguration, $language);
    }
}


1			<?php
2			declare (strict_types=1);
3
4			namespace T3G\Elasticorn\Service;
5
6			use Elastica\Client;
7			use Elastica\Index;
8			use Elastica\Reindex;
9			use Psr\Log\LoggerInterface;
10			use T3G\Elasticorn\Configuration\ApplicationConfiguration;
11
12			/**
13			* Class IndexService
14			*
15			*/
16			class IndexService
17			{
18			/**
19			* @var \Elastica\Client
20			*/
21			protected $client;
22
23			/**
24			* @var Index
25			*/
26			private $index;
27
28			/**
29			* @var \Psr\Log\LoggerInterface
30			*/
31			private $logger;
32
33			/**
34			* @var \T3G\Elasticorn\Service\ConfigurationService
35			*/
36			private $configurationService;
37
38			/**
39			* IndexService constructor.
40			*
41			* @param \Elastica\Client $client
42			* @param \T3G\Elasticorn\Service\ConfigurationService $configurationService
43			* @param \Psr\Log\LoggerInterface $logger
44			* @param string $indexName
45			*/
46			public function __construct(
47			Client $client,
48			ConfigurationService $configurationService,
49			LoggerInterface $logger,
50			string $indexName = null
51			) {
52			$this->client = $client;
53			$this->logger = $logger;
54			$this->configurationService = $configurationService;
55			if (null !== $indexName) {
56			$this->index = $this->client->getIndex($indexName);
57			}
58			}
59
60			/**
61			* @return Index\|null
62			*/
63			public function getIndex()
64			{
65			return $this->index;
66			}
67
68			/**
69			* Rename an index (creates new index with data from old)
70			* CAUTION: All mappings are lost, only data is preserved
71			*
72			* @param string $newName
73			*/
74			public function renameIndex(string $newName)
75			{
76			$newIndex = $this->client->getIndex($newName);
77			$newIndex->create();
78			$reindex = new Reindex($this->index, $newIndex);
79			$reindex->run();
80			$this->index->delete();
81			}
82
83			/**
84			* Add all indices found in configuration directory
85			* Creates indices with suffixes _a and _b and adds an alias as indexName
86			*/
87			public function initIndices()
88			{
89			$indexConfigurations = $this->configurationService->getIndexConfigurations();
90			foreach ($indexConfigurations as $indexName => $configuration) {
91			$this->createIndex($indexName, $configuration);
92			}
93			}
94
95			/**
96			* Initializes a single index from config files
97			*
98			* @param string $indexName
99			*/
100			public function initIndex(string $indexName)
101			{
102			$configuration = $this->configurationService->getIndexConfiguration($indexName);
103
104			$this->createIndex($indexName, $configuration);
105			}
106
107			/**
108			* Copy data from oldIndexName to newIndexName
109			*
110			* @param string $oldIndexName
111			* @param string $newIndexName
112			*/
113			public function copyData(string $oldIndexName, string $newIndexName)
114			{
115			$oldIndex = $this->client->getIndex($oldIndexName);
116			$newIndex = $this->client->getIndex($newIndexName);
117			$reindex = new Reindex($oldIndex, $newIndex);
118			$reindex->run();
119			}
120
121			/**
122			* Re-apply mappings to all indices found in configuration directory
123			*
124			* @see remap($indexName)
125			*
126			* @param bool $force
127			*/
128			public function remapAll(bool $force = false)
129			{
130			$indexConfigurations = $this->configurationService->getIndexConfigurations();
131			$indices = array_keys($indexConfigurations);
132			foreach ($indices as $indexName) {
133			$this->remap($indexName, $force);
134			}
135			}
136
137			/**
138			* @return array
139			*/
140			public function getMappingForIndex()
141			{
142			$this->logger->debug('Get current mapping for ' . $this->index->getName());
143			return $this->index->getMapping();
144			}
145
146
147			/**
148			* Remap an index
149			*
150			* Drops and recreates the current inactive index, applies mappings and imports data from active index
151			* After successfully importing data the alias gets set to the new index
152			*
153			* @param string $indexName
154			* @param bool $force
155			*
156			* @throws \InvalidArgumentException
157			*/
158			public function remap(string $indexName, bool $force = false)
159			{
160			if ($this->configurationService->compareMappingConfiguration($indexName) === '') {
161			if (false === $force) {
162			$this->logger->info('No difference between configurations, no remapping done');
163			return;
164			} else {
165			$this->logger->info('No difference between configurations but force given, remapping anyway.');
166			}
167			}
168			$languages = ApplicationConfiguration::getLanguageConfiguration();
169			if (count($languages) > 0) {
170			foreach ($languages as $language) {
171			$this->remapIndex($indexName, $language);
172			}
173			$this->logger->debug(
174			'Adding alias to ' . $indexName . '_' . $languages[0] . ' from ' . $indexName
175			);
176			$this->client->getIndex($indexName . '_' . $languages[0])->addAlias($indexName);
177			} else {
178			$this->remapIndex($indexName);
179			}
180			}
181
182			/**
183			* @param string $indexName
184			*/
185			private function remapIndex(string $indexName, string $language = '')
186			{
187			$aliasName = $indexName;
188			$languageMessage = '';
189			if ($language) {
190			$aliasName .= '_' . $language;
191			$languageMessage = ' in language ' . $language;
192			}
193			$this->logger->info('Remapping ' . $indexName . $languageMessage);
194			$primaryIndexIdentifier = $this->getFullIndexIdentifier($indexName, 'a', $language);
195			$indexA = $this->client->getIndex($primaryIndexIdentifier);
196			if ($indexA->exists()) {
197			$indexB = $this->client->getIndex($this->getFullIndexIdentifier($indexName, 'b', $language));
198
199			if ($indexA->hasAlias($aliasName)) {
200			$activeIndex = $indexA;
201			$inactiveIndex = $indexB;
202			} elseif ($indexB->hasAlias($aliasName)) {
203			$activeIndex = $indexB;
204			$inactiveIndex = $indexA;
205			} else {
206			throw new \InvalidArgumentException('No active index with name ' . $indexName . ' found.');
207			}
208
209			$this->recreateIndex($indexName, $inactiveIndex, $language);
210			$this->logger->debug('Reindexing data with new mapping.');
211			$reindex = new Reindex($activeIndex, $inactiveIndex);
212			$reindex->run();
213			$this->switchAlias($aliasName, $activeIndex, $inactiveIndex);
214			} else {
215			$configuration = $this->configurationService->getIndexConfigurations();
216			$this->createPrimaryIndex($indexName, $configuration, $language);
217			$this->createSecondaryIndex($indexName, $configuration, $language);
218			}
219			}
220
221			/**
222			* @param string $indexName
223			* @param \Elastica\Index $activeIndex
224			* @param \Elastica\Index $inactiveIndex
225			*/
226			private function switchAlias(string $indexName, Index $activeIndex, Index $inactiveIndex)
227			{
228			$this->logger->debug('Switching alias from ' . $activeIndex->getName() . ' to ' . $inactiveIndex->getName());
229			$activeIndex->removeAlias($indexName);
230			$inactiveIndex->addAlias($indexName);
231			}
232
233			/**
234			* @param string $indexName
235			* @param array $configuration
236			*
237			* @throws \InvalidArgumentException
238			*/
239			private function createIndex(string $indexName, array $configuration)
240			{
241			$this->logger->info('Creating index ' . $indexName);
242			$index = $this->client->getIndex($indexName);
243			$languages = ApplicationConfiguration::getLanguageConfiguration();
244			if (!$index->exists()) {
245			if (count($languages) > 0) {
246			foreach ($languages as $language) {
247			$this->createPrimaryIndex($indexName, $configuration, $language);
248			$this->createSecondaryIndex($indexName, $configuration, $language);
249			}
250			$primaryIndex = $this->client->getIndex($indexName . '_' . $languages[0]);
251			$primaryIndex->addAlias($indexName);
252			} else {
253			$this->createPrimaryIndex($indexName, $configuration);
254			$this->createSecondaryIndex($indexName, $configuration);
255			}
256			} else {
257			throw new \InvalidArgumentException('Index ' . $indexName . ' already exists.');
258			}
259			}
260
261			private function createPrimaryIndex(string $indexName, array $configuration, string $language = '')
262			{
263			$index = $this->client->getIndex($this->getFullIndexIdentifier($indexName, 'a', $language));
264			$this->createWithMapping($indexName, $index, $configuration, $language);
265			$index->addAlias($indexName . ($language ? '_' . $language : ''));
266			}
267
268			/**
269			* @param string $indexName
270			* @param array $configuration
271			* @param string $language
272			*/
273			private function createSecondaryIndex(string $indexName, array $configuration, string $language = '')
274			{
275			$index = $this->client->getIndex($this->getFullIndexIdentifier($indexName, 'b', $language));
276			$this->createWithMapping($indexName, $index, $configuration, $language);
277			}
278
279			private function getFullIndexIdentifier(string $indexName, string $suffix = '', string $language = '')
280			{
281			return $indexName . ($language ? '_' . $language : '') . ($suffix ? '_' . $suffix : '');
282			}
283
284			/**
285			* @param string $indexName
286			* @param \Elastica\Index $index
287			* @param $indexConfiguration
288			*/
289			private function createWithMapping(
290			string $indexName,
291			Index $index,
292			array $indexConfiguration,
293			string $language = ''
294			) {
295			$index->create($indexConfiguration);
296			$this->logger->debug('Creating index ' . $indexName);
297			$this->configurationService->applyMapping($indexName, $index, $language);
298			}
299
300			/**
301			* @param string $indexName
302			* @param Index $index
303			* @param string $language
304			*/
305			private function recreateIndex(string $indexName, Index $index, string $language)
306			{
307			$indexConfiguration = $this->configurationService->getIndexConfiguration($indexName);
308			$this->logger->debug('Deleting index ' . $indexName);
309			$index->delete();
310			$this->createWithMapping($indexName, $index, $indexConfiguration, $language);
311			}
312			}
313

TYPO3GmbH / elasticorn

IndexService::createSecondaryIndex() A last analyzed 2020-02-21 07:41 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

IndexService::createSecondaryIndex() A
last analyzed 2020-02-21 07:41 UTC