OCA\FullTextSearch_ElasticSearch\Platform\ElasticSearchPlatform

Complexity

Total Complexity

30

Size/Duplication

Total Lines	325
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	getId()	0	3	1
A	getName()	0	3	1
A	getVersion()	0	3	1
A	getConfiguration()	0	22	3
A	setRunner()	0	3	1
A	updateRunner()	0	7	2
A	outputRunner()	0	7	2
A	loadPlatform()	0	15	2
A	testPlatform()	0	3	1
A	initializeIndex()	0	3	1
A	resetIndex()	0	7	2
A	indexDocuments()	0	18	4
A	indexDocument()	0	17	2
A	indexDocumentError()	0	18	1
A	deleteIndexes()	0	7	2
A	searchDocuments()	0	5	1
A	getDocument()	0	3	1
A	connectToElastic()	0	21	2

<?php
/**
 * FullTextSearch_ElasticSearch - Use Elasticsearch to index the content of your nextcloud
 *
 * This file is licensed under the Affero General Public License version 3 or
 * later. See the COPYING file.
 *
 * @author Maxence Lange <maxence@artificial-owl.com>
 * @copyright 2018
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

namespace OCA\FullTextSearch_ElasticSearch\Platform;

use Elasticsearch\Client;
use Elasticsearch\ClientBuilder;
use Elasticsearch\Common\Exceptions\BadRequest400Exception;
use Exception;
use OCA\FullTextSearch\Exceptions\InterruptException;
use OCA\FullTextSearch\Exceptions\TickDoesNotExistException;
use OCA\FullTextSearch\IFullTextSearchPlatform;
use OCA\FullTextSearch\IFullTextSearchProvider;
use OCA\FullTextSearch\Model\DocumentAccess;
use OCA\FullTextSearch\Model\Index;
use OCA\FullTextSearch\Model\IndexDocument;
use OCA\FullTextSearch\Model\Runner;
use OCA\FullTextSearch\Model\SearchRequest;
use OCA\FullTextSearch_ElasticSearch\AppInfo\Application;
use OCA\FullTextSearch_ElasticSearch\Exceptions\AccessIsEmptyException;
use OCA\FullTextSearch_ElasticSearch\Exceptions\ConfigurationException;
use OCA\FullTextSearch_ElasticSearch\Service\ConfigService;
use OCA\FullTextSearch_ElasticSearch\Service\IndexService;
use OCA\FullTextSearch_ElasticSearch\Service\MiscService;
use OCA\FullTextSearch_ElasticSearch\Service\SearchService;
use OCP\AppFramework\QueryException;


class ElasticSearchPlatform implements IFullTextSearchPlatform {

	/** @var ConfigService */
	private $configService;

	/** @var IndexService */
	private $indexService;

	/** @var SearchService */
	private $searchService;

	/** @var MiscService */
	private $miscService;

	/** @var Client */
	private $client;

	/** @var Runner */
	private $runner;


	/**
	 * return a unique Id of the platform.
	 */
	public function getId() {
		return 'elastic_search';
	}

	/**
	 * return a unique Id of the platform.
	 */
	public function getName() {
		return 'Elasticsearch';
	}


	/**
	 * @return string
	 */
	public function getVersion() {
		return $this->configService->getAppValue('installed_version');
	}


	/**
	 * @return array

Consider making the return type a bit more specific; maybe use array<string,array|string>.

	 * @throws ConfigurationException
	 */
	public function getConfiguration() {

		$result = [];
		$hosts = $this->configService->getElasticHost();

		foreach ($hosts as $host) {
			$parsedHost = parse_url($host);
			$safeHost = $parsedHost['scheme'] . '://';
			if (array_key_exists('user', $parsedHost)) {
				$safeHost .= $parsedHost['user'] . ':' . '********' . '@';
			}
			$safeHost .= $parsedHost['host'];
			$safeHost .= ':' . $parsedHost['port'];

			$result[] = $safeHost;
		}

		return [
			'elastic_host'  => $result,
			'elastic_index' => $this->configService->getElasticIndex()
		];
	}


	/**
	 * @param Runner $runner
	 */
	public function setRunner(Runner $runner) {
		$this->runner = $runner;
	}

	/**
	 * @param $action
	 *
	 * @throws InterruptException
	 * @throws TickDoesNotExistException
	 */
	private function updateRunner($action) {
		if ($this->runner === null) {
			return;
		}

		$this->runner->update($action);
	}


	/**
	 * @param $line
	 */
	private function outputRunner($line) {
		if ($this->runner === null) {
			return;
		}

		$this->runner->output($line);
	}


	/**
	 * Called when loading the platform.
	 *
	 * Loading some container and connect to ElasticSearch.
	 *
	 * @throws ConfigurationException
	 * @throws QueryException
	 * @throws Exception
	 */
	public function loadPlatform() {
		$app = new Application();

		$container = $app->getContainer();
		$this->configService = $container->query(ConfigService::class);
		$this->indexService = $container->query(IndexService::class);
		$this->searchService = $container->query(SearchService::class);
		$this->miscService = $container->query(MiscService::class);

		try {
			$this->connectToElastic($this->configService->getElasticHost());
		} catch (ConfigurationException $e) {
			throw $e;
		}
	}


	/**
	 * not used yet.
	 *
	 * @return bool
	 * @throws ConfigurationException
	 */
	public function testPlatform() {
		return $this->indexService->testIndex($this->client);
	}


	/**
	 * called before any index
	 *
	 * We create a general index.
	 *
	 * @throws ConfigurationException
	 * @throws BadRequest400Exception
	 */
	public function initializeIndex() {
		$this->indexService->initializeIndex($this->client);
	}


	/**
	 * resetIndex();
	 *
	 * Called when admin wants to remove an index specific to a $provider.
	 * $provider can be null, meaning a reset of the whole index.
	 *
	 * @param string $providerId
	 *
	 * @throws ConfigurationException
	 */
	public function resetIndex($providerId) {
		if ($providerId === 'all') {
			$this->indexService->resetIndexAll($this->client);
		} else {
			$this->indexService->resetIndex($this->client, $providerId);
		}
	}


	/**
	 * @param IFullTextSearchProvider $provider
	 * @param IndexDocument[] $documents
	 *
	 * @return Index[]
	 * @throws Exception
	 */
	public function indexDocuments(IFullTextSearchProvider $provider, $documents) {
		$indexes = [];
		foreach ($documents as $document) {

			try {
				$index = $this->indexDocument($provider, $document);
				$indexes[] = $index;
			} catch (Exception $e) {
				if ($this->runner->isStrict()) {
					throw $e;
				}
				/** we do nohtin' */
			}

		}

		return $indexes;
	}


	/**
	 * @param IFullTextSearchProvider $provider
	 * @param IndexDocument $document
	 *
	 * @return Index
	 * @throws AccessIsEmptyException
	 * @throws ConfigurationException
	 * @throws InterruptException
	 * @throws TickDoesNotExistException
	 */
	public function indexDocument(IFullTextSearchProvider $provider, IndexDocument $document) {

		$this->updateRunner('indexDocument');
		$this->outputRunner(' . Indexing: ' . $document->getTitle());

		$document->initHash();

		try {
			$result = $this->indexService->indexDocument($this->client, $provider, $document);
			$this->outputRunner('  result: ' . json_encode($result));

			return $this->indexService->parseIndexResult($document->getIndex(), $result);

$result is of type callable, but the function expects a array.

		} catch (Exception $e) {
			return $this->indexDocumentError($provider, $document, $e);
		}

	}


	/**
	 * @param IFullTextSearchProvider $provider
	 * @param IndexDocument $document
	 * @param Exception $e
	 *
	 * @return Index
	 * @throws ConfigurationException
	 * @throws AccessIsEmptyException
	 */
	private function indexDocumentError(
		IFullTextSearchProvider $provider, IndexDocument $document, Exception $e
	) {
		$message = [
			'exception' => get_class($e),
			'message'   => $e->getMessage()
		];

		$document->setContent(null);
		$index = $document->getIndex();
		$index->unsetStatus(Index::INDEX_CONTENT);
		$index->setMessage(json_encode($message));

		$result = $this->indexService->indexDocument($this->client, $provider, $document);
		$this->outputRunner('  result with no content: ' . json_encode($result));

		return $this->indexService->parseIndexResult($document->getIndex(), $result);

$result is of type callable, but the function expects a array.

	}


	/**
	 * {@inheritdoc}
	 * @throws ConfigurationException
	 */
	public function deleteIndexes($indexes) {
		try {
			$this->indexService->deleteIndexes($this->client, $indexes);
		} catch (ConfigurationException $e) {
			throw $e;
		}
	}


	/**
	 * {@inheritdoc}
	 * @throws ConfigurationException
	 * @throws Exception
	 */
	public function searchDocuments(
		IFullTextSearchProvider $provider, DocumentAccess $access, SearchRequest $request
	) {
		return $this->searchService->searchDocuments($this->client, $provider, $access, $request);
	}


	/**
	 * @param string $providerId
	 * @param string $documentId
	 *
	 * @return IndexDocument
	 */
	public function getDocument($providerId, $documentId) {
		return $this->searchService->getDocument($this->client, $providerId, $documentId);
	}


	/**
	 * @param array $hosts
	 *
	 * @throws Exception
	 */
	private function connectToElastic($hosts) {

		try {
			$hosts = array_map([MiscService::class, 'noEndSlash'], $hosts);
			$this->client = ClientBuilder::create()
										 ->setHosts($hosts)
										 ->setRetries(3)
										 ->build();

//		}

48% of this comment could be valid code. Did you maybe forget this after debugging?

//		catch (CouldNotConnectToHost $e) {
//			$this 'CouldNotConnectToHost';
//			$previous = $e->getPrevious();
//			if ($previous instanceof MaxRetriesException) {
//				echo "Max retries!";
//			}
		} catch (Exception $e) {
			throw $e;
//			echo ' ElasticSearchPlatform::load() Exception --- ' . $e->getMessage() . "\n";

48% of this comment could be valid code. Did you maybe forget this after debugging?

		}
	}


}