Pool - Code Metrics - Inspection of "Added worker TTL and set the default to 3 seconds" - WyriHaximus/cakephp-async-orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 44ea6a...ba5abe )

by Cees-Jan

created 2016-04-06 17:47 UTC

Pool A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Test Coverage

Coverage

54.55%

Importance

Changes	16
Bugs	3	Features	3

Metric	Value
wmc	15
c	16
b	3
f	3
lcom	2
cbo	9
dl	0
loc	148
ccs	30
cts	55
cp	0.5455
rs	10

9 Methods

Rating	Name	Size	Complexity
A	__construct()	16	1
A	getInstance()	12	4
A	reset()	4	1
A	call()	8	2
A	poolCall()	10	1
A	waitForPoolCall()	16	2
A	info()	8	2
A	getLoop()	4	1
A	getPool()	4	1

<?php

namespace WyriHaximus\React\Cake\Orm;

use Cake\Core\Configure;
use React\ChildProcess\Process;
use React\EventLoop\LoopInterface;
use React\EventLoop\Timer\TimerInterface;
use React\Promise\Deferred;
use React\Promise\PromiseInterface;
use WyriHaximus\React\ChildProcess\Messenger\Messages\Factory;
use WyriHaximus\React\ChildProcess\Pool\Factory\Flexible;
use WyriHaximus\React\ChildProcess\Pool\Options;
use WyriHaximus\React\ChildProcess\Pool\PoolInfoInterface;
use WyriHaximus\React\ChildProcess\Pool\PoolInterface;
use WyriHaximus\React\ChildProcess\Pool\PoolUtilizerInterface;

/**
 * Class Pool
 * @package WyriHaximus\React\Cake\Orm
 */
class Pool implements PoolUtilizerInterface
{
    /**
     * @var LoopInterface
     */
    protected $loop;

    /**
     * @var PoolInfoInterface
     */
    protected $pool;

    /**
     * @var Pool
     */
    protected static $instance = null;

    /**
     * @var boolean
     */
    protected static $reset = false;

    /**
     * @param LoopInterface $loop
     */
    protected function __construct(LoopInterface $loop)
    {
        $this->loop = $loop;
        Flexible::create(
            new Process(
                Configure::read('WyriHaximus.React.Cake.Orm.Process')
            ),
            $this->loop,
            [
                'processOptions' => Configure::read('WyriHaximus.React.Cake.Orm.Line'),
                Options::TTL => Configure::read('WyriHaximus.React.Cake.Orm.TTL'),
            ]
        )->then(function (PoolInterface $pool) {
            $this->pool = $pool;
        });
    }

    /**
     * @param LoopInterface $loop
     * @return Pool
     * @throws \Exception
     */
    public static function getInstance(LoopInterface $loop = null)
    {
        if (null === self::$instance || self::$reset) {
            if (null === $loop) {
                throw new \Exception('Missing event loop');
            }
            self::$instance = new static($loop);
            self::$reset = false;
        }

        return self::$instance;
    }

    public static function reset()
    {
        self::$reset = true;
    }

    /**
     * @param $tableName
     * @param $function
     * @param array $arguments
     * @return PromiseInterface
     */
    public function call($tableName, $function, array $arguments)
    {
        if ($this->pool instanceof PoolInterface) {
            return $this->poolCall($tableName, $function, $arguments);
        }

        return $this->waitForPoolCall($tableName, $function, $arguments);
    }

    /**
     * @param $tableName
     * @param $function
     * @param array $arguments
     * @return PromiseInterface
     */
    protected function poolCall($tableName, $function, array $arguments)
    {
        return $this->pool->rpc(Factory::rpc('table.call', [
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            'function' => $function,
            'table' => $tableName,
            'arguments' => serialize($arguments),
        ]))->then(function ($result) {
            return \React\Promise\resolve($result['result']);
        });
    }

    /**
     * @param $tableName
     * @param $function
     * @param array $arguments
     * @return PromiseInterface
     */
    protected function waitForPoolCall($tableName, $function, array $arguments)
    {
        $deferred = new Deferred();

        $this->loop->addPeriodicTimer(
            0.1,
            function (TimerInterface $timer) use ($deferred, $tableName, $function, $arguments) {
                if ($this->pool instanceof PoolInterface) {
                    $timer->cancel();
                    $deferred->resolve($this->call($tableName, $function, $arguments));
                }
            }
        );

        return $deferred->promise();
    }

    /**
     * @inheritDoc
     */
    public function info()
    {
        if ($this->pool instanceof PoolInterface) {
            return $this->pool->info();
        }

        return [];
    }

    /**
     * @return LoopInterface
     */
    public function getLoop()
    {
        return $this->loop;
    }

    /**
     * @return PoolInfoInterface
     */
    public function getPool()
    {
        return $this->pool;
    }
}


1		<?php
2
3		namespace WyriHaximus\React\Cake\Orm;
4
5		use Cake\Core\Configure;
6		use React\ChildProcess\Process;
7		use React\EventLoop\LoopInterface;
8		use React\EventLoop\Timer\TimerInterface;
9		use React\Promise\Deferred;
10		use React\Promise\PromiseInterface;
11		use WyriHaximus\React\ChildProcess\Messenger\Messages\Factory;
12		use WyriHaximus\React\ChildProcess\Pool\Factory\Flexible;
13		use WyriHaximus\React\ChildProcess\Pool\Options;
14		use WyriHaximus\React\ChildProcess\Pool\PoolInfoInterface;
15		use WyriHaximus\React\ChildProcess\Pool\PoolInterface;
16		use WyriHaximus\React\ChildProcess\Pool\PoolUtilizerInterface;
17
18		/**
19		* Class Pool
20		* @package WyriHaximus\React\Cake\Orm
21		*/
22		class Pool implements PoolUtilizerInterface
23		{
24		/**
25		* @var LoopInterface
26		*/
27		protected $loop;
28
29		/**
30		* @var PoolInfoInterface
31		*/
32		protected $pool;
33
34		/**
35		* @var Pool
36		*/
37		protected static $instance = null;
38
39		/**
40		* @var boolean
41		*/
42		protected static $reset = false;
43
44		/**
45		* @param LoopInterface $loop
46		*/
47	6	protected function __construct(LoopInterface $loop)
48		{
49	6	$this->loop = $loop;
50	6	Flexible::create(
51	6	new Process(
52	6	Configure::read('WyriHaximus.React.Cake.Orm.Process')
53	6	),
54	6	$this->loop,
55		[
56	6	'processOptions' => Configure::read('WyriHaximus.React.Cake.Orm.Line'),
57	6	Options::TTL => Configure::read('WyriHaximus.React.Cake.Orm.TTL'),
58		]
59		)->then(function (PoolInterface $pool) {
60	6	$this->pool = $pool;
61	6	});
62	6	}
63
64		/**
65		* @param LoopInterface $loop
66		* @return Pool
67		* @throws \Exception
68		*/
69	6	public static function getInstance(LoopInterface $loop = null)
70		{
71	6	if (null === self::$instance \|\| self::$reset) {
72	6	if (null === $loop) {
73		throw new \Exception('Missing event loop');
74		}
75	6	self::$instance = new static($loop);
76	6	self::$reset = false;
77	6	}
78
79	6	return self::$instance;
80		}
81
82	23	public static function reset()
83		{
84	23	self::$reset = true;
85	23	}
86
87		/**
88		* @param $tableName
89		* @param $function
90		* @param array $arguments
91		* @return PromiseInterface
92		*/
93		public function call($tableName, $function, array $arguments)
94		{
95		if ($this->pool instanceof PoolInterface) {
96		return $this->poolCall($tableName, $function, $arguments);
97		}
98
99		return $this->waitForPoolCall($tableName, $function, $arguments);
100		}
101
102		/**
103		* @param $tableName
104		* @param $function
105		* @param array $arguments
106		* @return PromiseInterface
107		*/
108		protected function poolCall($tableName, $function, array $arguments)
109		{
110		return $this->pool->rpc(Factory::rpc('table.call', [
		0 ignored issues – show Bug introduced 2016-03-02 20:10 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `WyriHaximus\React\ChildP...\Pool\PoolInfoInterface` as the method `rpc()` does only exist in the following implementations of said interface: `WyriHaximus\React\ChildProcess\Pool\Pool\Dummy`, `WyriHaximus\React\ChildProcess\Pool\Pool\Fixed`, `WyriHaximus\React\ChildProcess\Pool\Pool\Flexible`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
111		'function' => $function,
112		'table' => $tableName,
113		'arguments' => serialize($arguments),
114		]))->then(function ($result) {
115		return \React\Promise\resolve($result['result']);
116		});
117		}
118
119		/**
120		* @param $tableName
121		* @param $function
122		* @param array $arguments
123		* @return PromiseInterface
124		*/
125		protected function waitForPoolCall($tableName, $function, array $arguments)
126		{
127		$deferred = new Deferred();
128
129		$this->loop->addPeriodicTimer(
130		0.1,
131		function (TimerInterface $timer) use ($deferred, $tableName, $function, $arguments) {
132		if ($this->pool instanceof PoolInterface) {
133		$timer->cancel();
134		$deferred->resolve($this->call($tableName, $function, $arguments));
135		}
136		}
137		);
138
139		return $deferred->promise();
140		}
141
142		/**
143		* @inheritDoc
144		*/
145	1	public function info()
146		{
147	1	if ($this->pool instanceof PoolInterface) {
148	1	return $this->pool->info();
149		}
150
151		return [];
152		}
153
154		/**
155		* @return LoopInterface
156		*/
157	1	public function getLoop()
158	1	{
159	1	return $this->loop;
160		}
161
162		/**
163		* @return PoolInfoInterface
164		*/
165	1	public function getPool()
166		{
167	1	return $this->pool;
168		}
169		}
170

WyriHaximus / cakephp-async-orm

Push — master ( 44ea6a...ba5abe )

Pool A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

9 Methods

Available Fixes

Duplication Side-by-Side

Filter issues like