Balloon\Hook\ExternalStorage

Complexity

Total Complexity

24

Size/Duplication

Total Lines	201
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	setOptions()	0	19	4
A	preCreateCollection()	0	17	4
A	postCreateCollection()	0	8	2
A	preDeleteCollection()	0	6	3
A	postDeleteCollection()	0	14	3
B	preExecuteAsyncJobs()	0	32	6
A	addTasks()	0	17	1

<?php

declare(strict_types=1);

/**
 * balloon
 *
 * @copyright   Copryright (c) 2012-2018 gyselroth GmbH (https://gyselroth.com)
 * @license     GPL-3.0 https://opensource.org/licenses/GPL-3.0
 */

namespace Balloon\Hook;

use Balloon\Async\SmbListener;
use Balloon\Async\SmbScanner;
use Balloon\Filesystem\Exception\NotFound as NotFoundException;
use Balloon\Filesystem\Node\Collection;
use Balloon\Filesystem\Storage\Exception;

This use statement conflicts with another class in this namespace, Balloon\Hook\Exception.

use Balloon\Filesystem\Storage\Factory as StorageFactory;
use Balloon\Server;
use InvalidArgumentException;
use MongoDB\BSON\ObjectId;
use ParagonIE\Halite\HiddenString;
use ParagonIE\Halite\KeyFactory;
use ParagonIE\Halite\Symmetric\Crypto as Symmetric;
use ParagonIE\Halite\Symmetric\EncryptionKey;
use Psr\Log\LoggerInterface;
use TaskScheduler\JobInterface;
use TaskScheduler\Scheduler;

class ExternalStorage extends AbstractHook
{
    /**
     * Default key.
     */
    private const DEFAULT_KEY = '3140040033da9bd0dedd8babc8b89cda7f2132dd5009cc43c619382863d0c75e172ebf18e713e1987f35d6ea3ace43b561c50d9aefc4441a8c4418f6928a70e4655de5a9660cd323de63b4fd2fb76525470f25311c788c5e366e29bf60c438c4ac0b440e';

    /**
     * Server.
     *
     * @var Server
     */
    protected $server;

    /**
     * Scheduler.
     *
     * @var Scheduler
     */
    protected $scheduler;

    /**
     * Storage factory.
     *
     * @var StorageFactory
     */
    protected $factory;

    /**
     * Encryption key.
     *
     * @var EncryptionKey
     */
    protected $key;

    /**
     * Logger.
     *
     * @var LoggerInterface
     */
    protected $logger;

    /**
     * Interval.
     */
    protected $interval = 86400;

    /**
     * Constructor.
     */
    public function __construct(Server $server, Scheduler $scheduler, StorageFactory $factory, EncryptionKey $key, LoggerInterface $logger, ?array $config = null)
    {
        $this->server = $server;
        $this->scheduler = $scheduler;
        $this->factory = $factory;
        $this->key = $key;
        $this->logger = $logger;
        $this->setOptions($config);
    }

    /**
     * Set options.
     */
    public function setOptions(?Iterable $config = null): HookInterface
    {
        if (null === $config) {
            return $this;
        }

        foreach ($config as $option => $value) {
            switch ($option) {
                case 'interval':
                    $this->{$option} = (int) $value;

                break;
                default:
                    throw new InvalidArgumentException('invalid option '.$option.' given');
            }
        }

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function preCreateCollection(Collection $parent, string &$name, array &$attributes, bool $clone): void
    {
        if (!isset($attributes['mount'])) {
            return;
        }

        if (isset($attributes['mount']['password'])) {
            if (KeyFactory::export($this->key)->getString() === self::DEFAULT_KEY) {
                throw new Exception\InvalidEncryptionKey('smb encryption key required to be changed');
            }

            $message = new HiddenString($attributes['mount']['password']);
            $attributes['mount']['password'] = Symmetric::encrypt($message, $this->key);
        }

        $this->factory->build($attributes['mount'])->test();

It seems like you code against a concrete implementation and not the interface Balloon\Filesystem\Storage\Adapter\AdapterInterface as the method test() does only exist in the following implementations of said interface: Balloon\Filesystem\Storage\Adapter\Smb.

    }

    /**
     * {@inheritdoc}
     */
    public function postCreateCollection(Collection $parent, Collection $node, bool $clone): void
    {
        if (!$node->isMounted()) {
            return;
        }

        $this->addTasks($node->getId());
    }

    /**
     * {@inheritdoc}
     */
    public function preDeleteCollection(Collection $node, bool $force, ?string $recursion, bool $recursion_first): void
    {
        if ($node->isMounted() && $force === true) {
            throw new \Exception('mounted collection can not get removed');
        }
    }

    /**
     * {@inheritdoc}
     */
    public function postDeleteCollection(Collection $node, bool $force, ?string $recursion, bool $recursion_first): void
    {
        if (!$node->isMounted()) {
            return;
        }

        foreach ($this->scheduler->getJobs([
            '$or' => [['class' => SmbScanner::class], ['class' => SmbListener::class]],
            'data.id' => $node->getId(),
            'status' => ['$lte' => JobInterface::STATUS_PROCESSING],
        ]) as $job) {
            $this->scheduler->cancelJob($job->getId());
        }
    }

    /**
     * {@inheritdoc}
     */
    public function preExecuteAsyncJobs(): void
    {
        $fs = $this->server->getFilesystem();

        foreach ($this->scheduler->getJobs([
            '$or' => [['class' => SmbScanner::class], ['class' => SmbListener::class]],
            'status' => ['$lte' => JobInterface::STATUS_PROCESSING],
        ]) as $job) {
            try {
                if ($fs->findNodeById($job->getData()['id'])->isDeleted()) {
                    $this->scheduler->cancelJob($job->getId());
                }
            } catch (NotFoundException $e) {
                $this->scheduler->cancelJob($job->getId());
            } catch (\Exception $e) {
                $this->logger->error('failed pre check mount job ['.$job->getId().']', [
                    'category' => get_class($this),
                    'exception' => $e,
                ]);
            }
        }

        $nodes = $fs->findNodesByFilter([
            'deleted' => false,
            'directory' => true,
            'mount' => ['$type' => 3],
        ]);

        foreach ($nodes as $node) {
            $this->addTasks($node->getId());
        }
    }

    /**
     * Add tasks.
     */
    protected function addTasks(ObjectId $node): bool
    {
        $this->scheduler->addJobOnce(SmbScanner::class, [
            'id' => $node,
        ], [
            Scheduler::OPTION_INTERVAL => $this->interval,
        ]);

        $job = $this->scheduler->addJobOnce(SmbListener::class, [

$job is not used, you could remove the assignment.

            'id' => $node,
        ], [
            Scheduler::OPTION_IGNORE_MAX_CHILDREN => true,
            Scheduler::OPTION_RETRY => -1,
        ]);

        return true;
    }
}