OCA\Ocr\Service\RedisService

Complexity

Total Complexity

11

Size/Duplication

Total Lines	170
Duplicated Lines	4.71 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

17.24%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
B	sendJob()	0	24	3
A	readingFinishedJobs()	0	16	2
A	setupRedisInstance()	8	18	4
A	handleException()	0	6	1

<?php

/**
 * Nextcloud - OCR
 * This file is licensed under the Affero General Public License version 3 or
 * later. See the COPYING file.
 * 
 * @author Janis Koehr <janiskoehr@icloud.com>
 * @copyright Janis Koehr 2017
 */
namespace OCA\Ocr\Service;

use Exception;
use OCA\Ocr\Db\OcrJob;
use OCA\Ocr\Db\OcrJobMapper;
use OCP\IConfig;
use OCP\IL10N;
use OCP\ILogger;
use OCA\Ocr\Constants\OcrConstants;


/**
 * Class RedisService
 * 
 * @package OCA\Ocr\Service
 */
class RedisService {

    /**
     *
     * @var IConfig
     */
    private $config;

    /**
     *
     * @var OcrJobMapper
     */
    private $mapper;

    /**
     *
     * @var FileService
     */
    private $fileService;

    /**
     *
     * @var ILogger
     */
    private $logger;

    /**
     *
     * @var IL10N
     */
    private $l10n;

    /**
     *
     * @var string
     */
    private $redisHost;

    /**
     *
     * @var integer
     */
    private $redisPort;

    /**
     *
     * @var integer
     */
    private $redisDb;

    /**
     *
     * @var string
     */
    private $appName = 'ocr';

    /**
     * QueueService constructor.
     * 
     * @param OcrJobMapper $mapper            
     * @param FileService $fileService            
     * @param IConfig $config            
     * @param IL10N $l10n            
     * @param ILogger $logger            
     */
    public function __construct(OcrJobMapper $mapper, FileService $fileService, IConfig $config, IL10N $l10n, 
            ILogger $logger) {
        $this->mapper = $mapper;
        $this->fileService = $fileService;
        $this->logger = $logger;
        $this->l10n = $l10n;
        $this->config = $config;
        $this->redisHost = $this->config->getAppValue($this->appName, 'redisHost');
        $this->redisPort = intval($this->config->getAppValue($this->appName, 'redisPort'));
        $this->redisDb = intval($this->config->getAppValue($this->appName, 'redisDb'));
    }

    /**
     * Inits the client and sends the task to the background worker (async)
     * 
     * @param OcrJob $job            
     * @param string[] $languages            
     * @param string $occDir            
     */
    public function sendJob($job, $languages, $occDir) {

The parameter $occDir is not used and could be removed.

        try {
            // check for messaging and put everything together
            $redis = $this->setupRedisInstance();
            $job = $this->mapper->insert($job);
            $msg = json_encode(
                    array(
                            'id' => $job->getId(),
                            'type' => $job->getType(),
                            'source' => $job->getSource(),
                            'tempFile' => $job->getTempFile(),
                            'languages' => $languages
                    ));
            if (!$redis->lPush(OcrConstants::REDIS_NEW_JOBS_QUEUE, $msg)) {
                throw new NotFoundException($this->l10n->t('Could not add files to the redis OCR processing queue.'));
            }
        } catch (Exception $e) {
            $this->fileService->execRemove($job->getTempFile());
            $job->setStatus('FAILED');
            $job->setErrorLog($this->l10n->t('Could not add files to the redis OCR processing queue.'));
            $this->mapper->update($job);
            $this->handleException($e);
        }
    }

    /**
     * Retrieves all finished jobs from redis and returns them.
     * 
     * @return string[]
     */
    public function readingFinishedJobs() {
        try {
            $redis = $this->setupRedisInstance();
            $result = $redis->multi()
                ->lRange(OcrConstants::REDIS_FINISHED_JOBS_QUEUE, 0, -1)
                ->delete(OcrConstants::REDIS_FINISHED_JOBS_QUEUE)
                ->exec();
            $this->logger->debug('Retrieved the following array from redis: {result}', 
                    [
                            'result' => $result[0]
                    ]);
            return $result[0];
        } catch (Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * Setup the Redis instance and return to whom ever it needs.
     * 
     * @throws NotFoundException
     * @return \Redis
     */
    private function setupRedisInstance() {
        if (!extension_loaded('redis')) {

This code seems to be duplicated across your project.

            $this->logger->debug(
                    'It seems that the message queueing capabilities are not available in your local php installation. Please install php-redis.');
            throw new NotFoundException($this->l10n->t('Message queueing capabilities are missing on the server.'));
        }
        $redis = new \Redis();
        if (!$redis->connect($this->redisHost, $this->redisPort, 2.5, NULL, 100)) {
            $this->logger->debug('Cannot connect to Redis.');
            throw new NotFoundException($this->l10n->t('Cannot connect to Redis.'));
        }
        if (!$redis->select($this->redisDb)) {

This code seems to be duplicated across your project.

            $this->logger->debug('Cannot connect to the right Redis database.');
            throw new NotFoundException($this->l10n->t('Cannot connect to the right Redis database.'));
        }
        $redis->setOption(\Redis::OPT_PREFIX, OcrConstants::REDIS_KEY_PREFIX);
        return $redis;
    }

    /**
     * Handle the possible thrown Exceptions from all methods of this class.
     * 
     * @param Exception $e            
     * @throws Exception
     * @throws NotFoundException
     */
    private function handleException($e) {
        $this->logger->logException($e, [
                'message' => 'Exception during message queue processing'
        ]);
        throw $e;
    }
}