Dazzle\Filesystem\Driver\DriverEio

Complexity

Total Complexity

23

Size/Duplication

Total Lines	210
Duplicated Lines	7.62 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

0%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	stat()	0	6	1
A	chmod()	0	6	1
A	chown()	0	6	1
A	call()	0	23	2
B	callDelayed()	0	29	4
A	register()	0	9	2
A	unregister()	0	9	2
A	handleEvent()	0	17	4
A	workPendingCount()	0	4	1
A	getPath()	0	4	1
A	createConfiguration()	8	8	1
A	createInvoker()	8	8	2

<?php

namespace Dazzle\Filesystem\Driver;

use Dazzle\Filesystem\Invoker\InvokerInterface;
use Dazzle\Filesystem\Invoker\InvokerStandard;
use Dazzle\Loop\LoopInterface;
use Dazzle\Promise\Promise;
use Dazzle\Promise\PromiseInterface;
use Dazzle\Throwable\Exception\Runtime\ExecutionException;
use Dazzle\Throwable\Exception\Runtime\UnexpectedValueException;

class DriverEio extends DriverAbstract implements DriverInterface
{
    /**
     * @var InvokerInterface
     */
    protected $invoker;

    /**
     * @var resource
     */
    protected $stream;

    /**
     * @var bool
     */
    protected $active = false;

    /**
     * @param LoopInterface $loop
     * @param array $options
     */
    public function __construct(LoopInterface $loop, $options = [])
    {
        eio_init();
        $this->loop = $loop;
        $this->options = $this->createConfiguration($options);
        $this->invoker = $this->createInvoker();
        $this->stream = eio_get_event_stream();
    }

    /**
     * @override
     * @inheritDoc
     */
    public function stat($path)
    {
        return $this->invoker
            ->call('eio_lstat', [ $this->getPath($path) ])
            ->then([ $this, 'handleStat' ]);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function chmod($path, $mode)
    {
        return $this->invoker
            ->call('eio_chmod', [ $this->getPath($path), decoct($mode) ])
            ->then([ $this, 'handleChmod' ]);
    }

    /**
     * @override
     * @inheritDoc
     */
    public function chown($path, $uid = -1, $gid = -1)
    {
        return $this->invoker
            ->call('eio_chown', [ $this->getPath($path), $uid, $gid ])
            ->then([ $this, 'handleChown' ]);
    }

    /**
     * @internal
     * @override
     * @inheritDoc
     */
    public function call($func, $args = [])
    {
        $loop = $this->loop;

        if ($loop->isRunning())
        {
            return $this->callDelayed($func, $args);
        }

        $promise = new Promise();
        $loop->onTick(function() use($func, $args, $promise) {
            $this
                ->callDelayed($func, $args)
                ->then(function($result) use($promise) {
                    return $promise->resolve($result);
                })
                ->failure(function($ex) use($promise) {
                    return $promise->reject($ex);
                });
        });

        return $promise;
    }

    /**
     * @param string $func
     * @param array $args
     * @return PromiseInterface

Should the return type not be PromiseInterface|null?

     */
    protected function callDelayed($func, $args = [])
    {
        $this->register();

        $promise = new Promise();

        $args[] = EIO_PRI_DEFAULT;
        $args[] = function($data, $result, $req) use($func, $args, $promise) {

            if ($result == -1)
            {
                $ex = new UnexpectedValueException(@eio_get_last_error($req));
                $ex->setContext($args);
                return $promise->reject($ex);
            }

            return $promise->resolve($result);
        };

        if (!$func(...$args))
        {
            $name = is_string($func) ? $func : get_class($func);
            $ex = new ExecutionException('Unknown error in response for "' . $name . '"');
            $ex->setContext($args);
            return $promise->reject($ex);
        };

        return $promise;
    }

    protected function register()
    {
        if ($this->active) {
            return;
        }

        $this->active = true;
        $this->loop->addReadStream($this->stream, [ $this, 'handleEvent' ]);
    }

    protected function unregister()
    {
        if (!$this->active) {
            return;
        }

        $this->active = false;
        $this->loop->removeReadStream($this->stream);
    }

    public function handleEvent()
    {
        if ($this->workPendingCount() == 0)
        {
            return;
        }

        while (eio_npending())
        {
            eio_poll();
        }

        if ($this->workPendingCount() == 0)
        {
            $this->unregister();
        }
    }

    public function workPendingCount()
    {
        return eio_nreqs() + eio_npending() + eio_nready();
    }

    /**
     * Get path.
     *
     * @param string $path
     * @return string
     */
    protected function getPath($path)
    {
        return $this->options['root'] . '/' . ltrim($path, '/');
    }

    /**
     * Create valid configuration for the driver.
     *
     * @param array $options
     * @return array
     */
    protected function createConfiguration($options = [])

This method seems to be duplicated in your project.

    {
        return array_merge([
            'root' => '',
            'invoker.class' => InvokerStandard::class,
            'output.control' => false,
        ], $options);
    }

    /**
     * Create invoker for the driver.
     *
     * @return InvokerInterface
     */
    protected function createInvoker()

This method seems to be duplicated in your project.

    {
        $invoker = class_exists($this->options['invoker.class'])
            ? $this->options['invoker.class']
            : InvokerStandard::class
        ;
        return new $invoker($this);
    }
}