Master - Code Metrics - kakserpom/phpdaemon - Measure and Improve Code Quality continuously with Scrutinizer

Master F
last analyzed 2021-06-02 17:17 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	476
Duplicated Lines	10.08 %

Coupling/Cohesion

Components	1
Dependencies	13

Importance

Changes

Metric	Value
dl	48
loc	476
rs	2.96
c	0
b	0
f	0
wmc	68
lcom	1
cbo	13

21 Methods

Rating	Name	Duplication	Size	Complexity
C	run()	0	73	10
A	log()	0	4	1
B	callMPM()	0	44	7
A	prepareSystemEnv()	5	26	5
A	reloadWorker()	0	10	3
B	spawnWorkers()	12	30	7
A	spawnIPCThread()	11	23	5
A	stopWorkers()	0	27	5
A	shutdown()	0	12	2
A	sigchld()	0	8	2
A	sigint()	0	7	2
A	signalToChildren()	0	6	2
A	sigterm()	0	8	2
A	sigquit()	0	8	2
A	sigtstp()	0	8	2
A	sighup()	11	12	3
A	sigusr1()	0	9	2
A	sigusr2()	0	7	2
A	sigttin()	0	3	1
A	sigxfsz()	0	4	1
A	sigunknown()	9	9	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Master often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Master, and based on these observations, apply Extract Interface, too.

<?php
namespace PHPDaemon\Thread;

use PHPDaemon\Core\Daemon;
use PHPDaemon\Core\Debug;
use PHPDaemon\Core\EventLoop;
use PHPDaemon\Core\Timer;
use PHPDaemon\FS\FileSystem;
use PHPDaemon\Structures\StackCallbacks;

/**
 * Implementation of the master thread
 *
 * @package Core
 *
 * @author  Vasily Zorin <[email protected]>
 */
class Master extends Generic
{

    /** @var bool */
    public $delayedSigReg = true;
    /** @var bool */
    public $breakMainLoop = false;
    /** @var bool */
    public $reload = false;
    /** @var int */
    public $connCounter = 0;
    /** @var Collection */
    public $workers;
    /** @var Collection */
    public $ipcthreads;
    /** @var */
    public $lastMpmActionTs;
    /** @var int */
    public $minMpmActionInterval = 1; // in seconds
    protected $timerCb;

    /**
     * @var StackCallbacks
     */
    protected $callbacks;

    /**
     * Runtime of Master process
     * @return void
     */
    protected function run()
    {
        Daemon::$process = $this;

        $this->prepareSystemEnv();
        class_exists('Timer'); // ensure loading this class
        gc_enable();

        $this->callbacks = new StackCallbacks;

        /*
         * @todo This line must be commented according to current libevent binding implementation.
         * May be uncommented in future.
         */
        //EventLoop::init()

        if (EventLoop::$instance) {
            $this->registerEventSignals();
        } else {
            $this->registerSignals();
        }

        $this->workers = new Collection();
        $this->collections['workers'] = $this->workers;
        $this->ipcthreads = new Collection;
        $this->collections['ipcthreads'] = $this->ipcthreads;

        Daemon::$appResolver->preload(true);

        $this->spawnIPCThread();
        $this->spawnWorkers(
            min(
                Daemon::$config->startworkers->value,
                Daemon::$config->maxworkers->value
            )
        );
        $this->timerCb = function ($event) use (&$cbs) {
            static $c = 0;

            ++$c;

            if ($c > 0xFFFFF) {
                $c = 1;
            }

            if (($c % 10 == 0)) {
                gc_collect_cycles();
            }

            if (!$this->lastMpmActionTs || ((microtime(true) - $this->lastMpmActionTs) > $this->minMpmActionInterval)) {
                $this->callMPM();
            }
            if ($event) {
                $event->timeout();
            }
        };

        if (EventLoop::$instance) { // we are using libevent in Master
            Timer::add($this->timerCb, 1e6 * Daemon::$config->mpmdelay->value, 'MPM');
            EventLoop::$instance->run();
        } else { // we are NOT using libevent in Master
            $lastTimerCall = microtime(true);
            $func = $this->timerCb;
            while (!$this->breakMainLoop) {
                $this->callbacks->executeAll($this);
                if (microtime(true) > $lastTimerCall + Daemon::$config->mpmdelay->value) {
                    $func(null);
                    $lastTimerCall = microtime(true);
                }
                $this->sigwait();
            }
        }
    }

    /**
     * Log something
     * @param string - Message.
     * @param string $message
     * @return void
     */
    public function log($message)
    {
        Daemon::log('M#' . $this->pid . ' ' . $message);
    }

    /**
     * @return int

     */
    protected function callMPM()
    {
        $state = Daemon::getStateOfWorkers();
        if (isset(Daemon::$config->mpm->value) && is_callable($func = Daemon::$config->mpm->value)) {

            $func($this, $state);
        }

        $upToMinWorkers = Daemon::$config->minworkers->value - $state['alive'];
        $upToMaxWorkers = Daemon::$config->maxworkers->value - $state['alive'];
        $upToMinSpareWorkers = Daemon::$config->minspareworkers->value - $state['idle'];
        if ($upToMinSpareWorkers > $upToMaxWorkers) {
            $upToMinSpareWorkers = $upToMaxWorkers;
        }
        $n = max($upToMinSpareWorkers, $upToMinWorkers);
        if ($n > 0) {
            //Daemon::log('minspareworkers = '.Daemon::$config->minspareworkers->value);
            //Daemon::log('maxworkers = '.Daemon::$config->maxworkers->value);
            //Daemon::log('maxspareworkers = '.Daemon::$config->maxspareworkers->value);
            //Daemon::log(json_encode($state));
            //Daemon::log('upToMinSpareWorkers = ' . $upToMinSpareWorkers . '   upToMinWorkers = ' . $upToMinWorkers);
            Daemon::log('Spawning ' . $n . ' worker(s)');
            $this->spawnWorkers($n);
            return $n;
        }

        $a = ['default' => 0];
        if (Daemon::$config->maxspareworkers->value > 0) {
            // if MaxSpareWorkers enabled, we have to stop idle workers, keeping in mind the MinWorkers
            $a['downToMaxSpareWorkers'] = min(
                $state['idle'] - Daemon::$config->maxspareworkers->value, // downToMaxSpareWorkers
                $state['alive'] - Daemon::$config->minworkers->value //downToMinWorkers
            );
        }
        $a['downToMaxWorkers'] = $state['alive'] - $state['reloading'] - Daemon::$config->maxworkers->value;
        $n = max($a);
        if ($n > 0) {
            //Daemon::log('down = ' . json_encode($a));
            //Daemon::log(json_encode($state));
            Daemon::log('Stopping ' . $n . ' worker(s)');
            $this->stopWorkers($n);
            return -$n;
        }
        return 0;
    }

    /**
     * Setup settings on start.
     * @return void
     */
    protected function prepareSystemEnv()
    {
        register_shutdown_function(function () {
            if ($this->pid != posix_getpid()) {
                return;
            }
            if ($this->shutdown === true) {
                return;
            }
            $this->log('Unexcepted shutdown.');
            $this->shutdown();
        });

        posix_setsid();
        proc_nice(Daemon::$config->masterpriority->value);
        if (!Daemon::$config->verbosetty->value) {

            fclose(STDIN);
            fclose(STDOUT);
            fclose(STDERR);
        }

        $this->setTitle(
            Daemon::$runName . ': master process'
            . (Daemon::$config->pidfile->value !== Daemon::$config->pidfile->defaultValue ? ' (' . Daemon::$config->pidfile->value . ')' : '')
        );
    }

    /**
     * Reload worker by internal id
     * @param integer - Id of worker
     * @param integer $id
     * @return void
     */
    public function reloadWorker($id)
    {
        if (isset($this->workers->threads[$id])) {
            if (!$this->workers->threads[$id]->reloaded) {

                Daemon::$process->log('Spawning worker-replacer for reloaded worker #' . $id);
                $this->spawnWorkers(1);
                $this->workers->threads[$id]->reloaded = true;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            }
        }
    }

    /**
     * Spawn new worker processes
     * @param $n - integer - number of workers to spawn
     * @return boolean - success
     */
    protected function spawnWorkers($n)
    {
        if (FileSystem::$supported) {
            eio_event_loop();
        }
        $n = (int)$n;

        for ($i = 0; $i < $n; ++$i) {
            $thread = new Worker;
            $this->workers->push($thread);
            $this->callbacks->push(function ($self) use ($thread) {

                // @check - is it possible to run iterate of main event loop without child termination?
                $thread->start();
                $pid = $thread->getPid();
                if ($pid < 0) {
                    Daemon::$process->log('could not fork worker');
                } elseif ($pid === 0) { // worker
                    Daemon::log('Unexcepted execution return to outside of Thread->start()');
                    exit;
                }
            });
        }
        if ($n > 0) {
            $this->lastMpmActionTs = microtime(true);
            if (EventLoop::$instance) {
                EventLoop::$instance->interrupt();
            }
        }
        return true;
    }

    /**
     * Spawn IPC process
     * @param $n - integer - number of workers to spawn
     * @return boolean - success
     */
    protected function spawnIPCThread()
    {
        if (FileSystem::$supported) {
            eio_event_loop();
        }
        $thread = new IPC;
        $this->ipcthreads->push($thread);

        $this->callbacks->push(function ($self) use ($thread) {

            $thread->start();
            $pid = $thread->getPid();
            if ($pid < 0) {
                Daemon::$process->log('could not fork IPCThread');
            } elseif ($pid === 0) { // worker
                $this->log('Unexcepted execution return to outside of Thread->start()');
                exit;
            }
        });
        if (EventLoop::$instance) {
            EventLoop::$instance->interrupt();
        }
        return true;
    }

    /**
     * Stop the workers
     * @param $n - integer - number of workers to stop
     * @return boolean - success
     */
    protected function stopWorkers($n = 1)
    {
        Daemon::log('--' . $n . '-- ' . Debug::backtrace() . '-----');

        $n = (int)$n;
        $i = 0;

        foreach ($this->workers->threads as &$w) {
            if ($i >= $n) {
                break;
            }

            if ($w->shutdown) {
                continue;
            }

            if ($w->reloaded) {

                continue;
            }

            $w->stop();
            ++$i;
        }

        $this->lastMpmActionTs = microtime(true);
        return true;
    }

    /**
     * Called when master is going to shutdown
     * @param integer System singal's number
     * @return void
     */
    protected function shutdown(int $signo = null)
    {
        if ($signo) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            $this->signalToChildren($signo);
        }
        $this->shutdown = true;
        $this->waitAll();
        Daemon::$shm_wstate->delete();
        file_put_contents(Daemon::$config->pidfile->value, '');
        posix_kill(getmypid(), SIGKILL);
        exit(0);
    }

    /**
     * Handler for the SIGCHLD (child is dead) signal in master process.
     * @return void
     */
    protected function sigchld()
    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGCHLD.');
        }

        parent::sigchld();
    }

    /**
     * Handler for the SIGINT (shutdown) signal in master process. Shutdown.
     * @return void
     */
    protected function sigint()
    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGINT.');
        }
        $this->shutdown(SIGKILL);
    }

    /**
     * @param $signo
     */
    public function signalToChildren($signo)
    {
        foreach ($this->collections as $col) {
            $col->signal($signo);
        }
    }

    /**
     * Handler for the SIGTERM (shutdown) signal in master process
     * @return void
     */
    protected function sigterm()
    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGTERM.');
        }

        $this->shutdown(SIGTERM);
    }

    /**
     * Handler for the SIGQUIT signal in master process
     * @return void
     */
    protected function sigquit()
    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGQUIT.');
        }

        $this->shutdown(SIGQUIT);
    }

    /**
     * Handler for the SIGTSTP (graceful stop all workers) signal in master process
     * @return void
     */
    protected function sigtstp()
    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGTSTP (graceful stop all workers).');
        }

        $this->shutdown(SIGTSTP);
    }

    /**
     * Handler for the SIGHUP (reload config) signal in master process
     * @return void
     */
    protected function sighup()

    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGHUP (reload config).');
        }

        if (isset(Daemon::$config->configfile)) {
            Daemon::loadConfig(Daemon::$config->configfile->value);
        }

        $this->signalToChildren(SIGHUP);
    }

    /**
     * Handler for the SIGUSR1 (re-open log-file) signal in master process
     * @return void
     */
    protected function sigusr1()
    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGUSR1 (re-open log-file).');
        }

        Daemon::openLogs();
        $this->signalToChildren(SIGUSR1);
    }

    /**
     * Handler for the SIGUSR2 (graceful restart all workers) signal in master process
     * @return void
     */
    protected function sigusr2()
    {
        if (Daemon::$config->logsignals->value) {
            $this->log('Caught SIGUSR2 (graceful restart all workers).');
        }
        $this->signalToChildren(SIGUSR2);
    }

    /**
     * Handler for the SIGTTIN signal in master process
     * Used as "ping" signal
     * @return void
     */
    protected function sigttin()
    {
    }

    /**
     * Handler for the SIGXSFZ signal in master process
     * @return void
     */
    protected function sigxfsz()
    {
        $this->log('Caught SIGXFSZ.');
    }

    /**
     * Handler for non-known signals
     * @return void
     */
    protected function sigunknown($signo)

    {
        if (isset(Generic::$signals[$signo])) {
            $sig = Generic::$signals[$signo];
        } else {
            $sig = 'UNKNOWN';
        }
        $this->log('Caught signal #' . $signo . ' (' . $sig . ').');
    }
}


1		<?php
2		namespace PHPDaemon\Thread;
3
4		use PHPDaemon\Core\Daemon;
5		use PHPDaemon\Core\Debug;
6		use PHPDaemon\Core\EventLoop;
7		use PHPDaemon\Core\Timer;
8		use PHPDaemon\FS\FileSystem;
9		use PHPDaemon\Structures\StackCallbacks;
10
11		/**
12		* Implementation of the master thread
13		*
14		* @package Core
15		*
16		* @author Vasily Zorin <[email protected]>
17		*/
18		class Master extends Generic
19		{
20
21		/** @var bool */
22		public $delayedSigReg = true;
23		/** @var bool */
24		public $breakMainLoop = false;
25		/** @var bool */
26		public $reload = false;
27		/** @var int */
28		public $connCounter = 0;
29		/** @var Collection */
30		public $workers;
31		/** @var Collection */
32		public $ipcthreads;
33		/** @var */
34		public $lastMpmActionTs;
35		/** @var int */
36		public $minMpmActionInterval = 1; // in seconds
37		protected $timerCb;
38
39		/**
40		* @var StackCallbacks
41		*/
42		protected $callbacks;
43
44		/**
45		* Runtime of Master process
46		* @return void
47		*/
48		protected function run()
49		{
50		Daemon::$process = $this;
51
52		$this->prepareSystemEnv();
53		class_exists('Timer'); // ensure loading this class
54		gc_enable();
55
56		$this->callbacks = new StackCallbacks;
57
58		/*
59		* @todo This line must be commented according to current libevent binding implementation.
60		* May be uncommented in future.
61		*/
62		//EventLoop::init()
63
64		if (EventLoop::$instance) {
65		$this->registerEventSignals();
66		} else {
67		$this->registerSignals();
68		}
69
70		$this->workers = new Collection();
71		$this->collections['workers'] = $this->workers;
72		$this->ipcthreads = new Collection;
73		$this->collections['ipcthreads'] = $this->ipcthreads;
74
75		Daemon::$appResolver->preload(true);
76
77		$this->spawnIPCThread();
78		$this->spawnWorkers(
79		min(
80		Daemon::$config->startworkers->value,
81		Daemon::$config->maxworkers->value
82		)
83		);
84		$this->timerCb = function ($event) use (&$cbs) {
85		static $c = 0;
86
87		++$c;
88
89		if ($c > 0xFFFFF) {
90		$c = 1;
91		}
92
93		if (($c % 10 == 0)) {
94		gc_collect_cycles();
95		}
96
97		if (!$this->lastMpmActionTs \|\| ((microtime(true) - $this->lastMpmActionTs) > $this->minMpmActionInterval)) {
98		$this->callMPM();
99		}
100		if ($event) {
101		$event->timeout();
102		}
103		};
104
105		if (EventLoop::$instance) { // we are using libevent in Master
106		Timer::add($this->timerCb, 1e6 * Daemon::$config->mpmdelay->value, 'MPM');
107		EventLoop::$instance->run();
108		} else { // we are NOT using libevent in Master
109		$lastTimerCall = microtime(true);
110		$func = $this->timerCb;
111		while (!$this->breakMainLoop) {
112		$this->callbacks->executeAll($this);
113		if (microtime(true) > $lastTimerCall + Daemon::$config->mpmdelay->value) {
114		$func(null);
115		$lastTimerCall = microtime(true);
116		}
117		$this->sigwait();
118		}
119		}
120		}
121
122		/**
123		* Log something
124		* @param string - Message.
125		* @param string $message
126		* @return void
127		*/
128		public function log($message)
129		{
130		Daemon::log('M#' . $this->pid . ' ' . $message);
131		}
132
133		/**
134		* @return int
		0 ignored issues – show Documentation introduced 2016-03-02 14:58 UTC by Report Bug Copy Issue Report Should the return type not be `integer\|double`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
135		*/
136		protected function callMPM()
137		{
138		$state = Daemon::getStateOfWorkers();
139		if (isset(Daemon::$config->mpm->value) && is_callable($func = Daemon::$config->mpm->value)) {
		0 ignored issues – show Bug introduced 2018-05-21 18:18 UTC by Report Bug Copy Issue Report The property `mpm` does not seem to exist in `PHPDaemon\Config\_Object`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
140		$func($this, $state);
141		}
142
143		$upToMinWorkers = Daemon::$config->minworkers->value - $state['alive'];
144		$upToMaxWorkers = Daemon::$config->maxworkers->value - $state['alive'];
145		$upToMinSpareWorkers = Daemon::$config->minspareworkers->value - $state['idle'];
146		if ($upToMinSpareWorkers > $upToMaxWorkers) {
147		$upToMinSpareWorkers = $upToMaxWorkers;
148		}
149		$n = max($upToMinSpareWorkers, $upToMinWorkers);
150		if ($n > 0) {
151		//Daemon::log('minspareworkers = '.Daemon::$config->minspareworkers->value);
152		//Daemon::log('maxworkers = '.Daemon::$config->maxworkers->value);
153		//Daemon::log('maxspareworkers = '.Daemon::$config->maxspareworkers->value);
154		//Daemon::log(json_encode($state));
155		//Daemon::log('upToMinSpareWorkers = ' . $upToMinSpareWorkers . ' upToMinWorkers = ' . $upToMinWorkers);
156		Daemon::log('Spawning ' . $n . ' worker(s)');
157		$this->spawnWorkers($n);
158		return $n;
159		}
160
161		$a = ['default' => 0];
162		if (Daemon::$config->maxspareworkers->value > 0) {
163		// if MaxSpareWorkers enabled, we have to stop idle workers, keeping in mind the MinWorkers
164		$a['downToMaxSpareWorkers'] = min(
165		$state['idle'] - Daemon::$config->maxspareworkers->value, // downToMaxSpareWorkers
166		$state['alive'] - Daemon::$config->minworkers->value //downToMinWorkers
167		);
168		}
169		$a['downToMaxWorkers'] = $state['alive'] - $state['reloading'] - Daemon::$config->maxworkers->value;
170		$n = max($a);
171		if ($n > 0) {
172		//Daemon::log('down = ' . json_encode($a));
173		//Daemon::log(json_encode($state));
174		Daemon::log('Stopping ' . $n . ' worker(s)');
175		$this->stopWorkers($n);
176		return -$n;
177		}
178		return 0;
179		}
180
181		/**
182		* Setup settings on start.
183		* @return void
184		*/
185		protected function prepareSystemEnv()
186		{
187		register_shutdown_function(function () {
188		if ($this->pid != posix_getpid()) {
189		return;
190		}
191		if ($this->shutdown === true) {
192		return;
193		}
194		$this->log('Unexcepted shutdown.');
195		$this->shutdown();
196		});
197
198		posix_setsid();
199		proc_nice(Daemon::$config->masterpriority->value);
200	View Code Duplication	if (!Daemon::$config->verbosetty->value) {
		0 ignored issues – show Duplication introduced 2015-12-06 14:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
201		fclose(STDIN);
202		fclose(STDOUT);
203		fclose(STDERR);
204		}
205
206		$this->setTitle(
207		Daemon::$runName . ': master process'
208		. (Daemon::$config->pidfile->value !== Daemon::$config->pidfile->defaultValue ? ' (' . Daemon::$config->pidfile->value . ')' : '')
209		);
210		}
211
212		/**
213		* Reload worker by internal id
214		* @param integer - Id of worker
215		* @param integer $id
216		* @return void
217		*/
218		public function reloadWorker($id)
219		{
220		if (isset($this->workers->threads[$id])) {
221		if (!$this->workers->threads[$id]->reloaded) {
		0 ignored issues – show Bug introduced 2016-05-10 19:29 UTC by Report Bug Copy Issue Report The property `reloaded` does not seem to exist in `PHPDaemon\Thread\Generic`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
222		Daemon::$process->log('Spawning worker-replacer for reloaded worker #' . $id);
223		$this->spawnWorkers(1);
224		$this->workers->threads[$id]->reloaded = true;
		0 ignored issues – show Documentation introduced 2016-05-10 19:29 UTC by Report Bug Copy Issue Report The property `reloaded` does not exist on `object<PHPDaemon\Thread\Generic>`. Since you implemented `__set`, maybe consider adding a @property annotation. Since your code implements the magic setter `_set`, this function will be called for any write access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } Since the property has write access only, you can use the @property-write annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
225		}
226		}
227		}
228
229		/**
230		* Spawn new worker processes
231		* @param $n - integer - number of workers to spawn
232		* @return boolean - success
233		*/
234		protected function spawnWorkers($n)
235		{
236		if (FileSystem::$supported) {
237		eio_event_loop();
238		}
239		$n = (int)$n;
240
241		for ($i = 0; $i < $n; ++$i) {
242		$thread = new Worker;
243		$this->workers->push($thread);
244	View Code Duplication	$this->callbacks->push(function ($self) use ($thread) {
		0 ignored issues – show Unused Code introduced 2016-03-02 14:58 UTC by Report Bug Copy Issue Report The parameter `$self` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2016-03-02 14:58 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
245		// @check - is it possible to run iterate of main event loop without child termination?
246		$thread->start();
247		$pid = $thread->getPid();
248		if ($pid < 0) {
249		Daemon::$process->log('could not fork worker');
250		} elseif ($pid === 0) { // worker
251		Daemon::log('Unexcepted execution return to outside of Thread->start()');
252		exit;
253		}
254		});
255		}
256		if ($n > 0) {
257		$this->lastMpmActionTs = microtime(true);
258		if (EventLoop::$instance) {
259		EventLoop::$instance->interrupt();
260		}
261		}
262		return true;
263		}
264
265		/**
266		* Spawn IPC process
267		* @param $n - integer - number of workers to spawn
268		* @return boolean - success
269		*/
270		protected function spawnIPCThread()
271		{
272		if (FileSystem::$supported) {
273		eio_event_loop();
274		}
275		$thread = new IPC;
276		$this->ipcthreads->push($thread);
277
278	View Code Duplication	$this->callbacks->push(function ($self) use ($thread) {
		0 ignored issues – show Unused Code introduced 2016-03-02 14:58 UTC by Report Bug Copy Issue Report The parameter `$self` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Duplication introduced 2016-03-02 14:58 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
279		$thread->start();
280		$pid = $thread->getPid();
281		if ($pid < 0) {
282		Daemon::$process->log('could not fork IPCThread');
283		} elseif ($pid === 0) { // worker
284		$this->log('Unexcepted execution return to outside of Thread->start()');
285		exit;
286		}
287		});
288		if (EventLoop::$instance) {
289		EventLoop::$instance->interrupt();
290		}
291		return true;
292		}
293
294		/**
295		* Stop the workers
296		* @param $n - integer - number of workers to stop
297		* @return boolean - success
298		*/
299		protected function stopWorkers($n = 1)
300		{
301		Daemon::log('--' . $n . '-- ' . Debug::backtrace() . '-----');
302
303		$n = (int)$n;
304		$i = 0;
305
306		foreach ($this->workers->threads as &$w) {
307		if ($i >= $n) {
308		break;
309		}
310
311		if ($w->shutdown) {
312		continue;
313		}
314
315		if ($w->reloaded) {
		0 ignored issues – show Bug introduced 2016-05-10 19:29 UTC by Report Bug Copy Issue Report The property `reloaded` does not seem to exist in `PHPDaemon\Thread\Generic`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
316		continue;
317		}
318
319		$w->stop();
320		++$i;
321		}
322
323		$this->lastMpmActionTs = microtime(true);
324		return true;
325		}
326
327		/**
328		* Called when master is going to shutdown
329		* @param integer System singal's number
330		* @return void
331		*/
332		protected function shutdown(int $signo = null)
333		{
334		if ($signo) {
		0 ignored issues – show Bug Best Practice introduced 2020-06-30 08:46 UTC by Report Bug Copy Issue Report The expression `$signo` of type `null\|integer` is loosely compared to `true`; this is ambiguous if the integer can be zero. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
335		$this->signalToChildren($signo);
336		}
337		$this->shutdown = true;
338		$this->waitAll();
339		Daemon::$shm_wstate->delete();
340		file_put_contents(Daemon::$config->pidfile->value, '');
341		posix_kill(getmypid(), SIGKILL);
342		exit(0);
343		}
344
345		/**
346		* Handler for the SIGCHLD (child is dead) signal in master process.
347		* @return void
348		*/
349		protected function sigchld()
350		{
351		if (Daemon::$config->logsignals->value) {
352		$this->log('Caught SIGCHLD.');
353		}
354
355		parent::sigchld();
356		}
357
358		/**
359		* Handler for the SIGINT (shutdown) signal in master process. Shutdown.
360		* @return void
361		*/
362		protected function sigint()
363		{
364		if (Daemon::$config->logsignals->value) {
365		$this->log('Caught SIGINT.');
366		}
367		$this->shutdown(SIGKILL);
368		}
369
370		/**
371		* @param $signo
372		*/
373		public function signalToChildren($signo)
374		{
375		foreach ($this->collections as $col) {
376		$col->signal($signo);
377		}
378		}
379
380		/**
381		* Handler for the SIGTERM (shutdown) signal in master process
382		* @return void
383		*/
384		protected function sigterm()
385		{
386		if (Daemon::$config->logsignals->value) {
387		$this->log('Caught SIGTERM.');
388		}
389
390		$this->shutdown(SIGTERM);
391		}
392
393		/**
394		* Handler for the SIGQUIT signal in master process
395		* @return void
396		*/
397		protected function sigquit()
398		{
399		if (Daemon::$config->logsignals->value) {
400		$this->log('Caught SIGQUIT.');
401		}
402
403		$this->shutdown(SIGQUIT);
404		}
405
406		/**
407		* Handler for the SIGTSTP (graceful stop all workers) signal in master process
408		* @return void
409		*/
410		protected function sigtstp()
411		{
412		if (Daemon::$config->logsignals->value) {
413		$this->log('Caught SIGTSTP (graceful stop all workers).');
414		}
415
416		$this->shutdown(SIGTSTP);
417		}
418
419		/**
420		* Handler for the SIGHUP (reload config) signal in master process
421		* @return void
422		*/
423	View Code Duplication	protected function sighup()
		0 ignored issues – show Duplication introduced 2018-01-16 22:41 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
424		{
425		if (Daemon::$config->logsignals->value) {
426		$this->log('Caught SIGHUP (reload config).');
427		}
428
429		if (isset(Daemon::$config->configfile)) {
430		Daemon::loadConfig(Daemon::$config->configfile->value);
431		}
432
433		$this->signalToChildren(SIGHUP);
434		}
435
436		/**
437		* Handler for the SIGUSR1 (re-open log-file) signal in master process
438		* @return void
439		*/
440		protected function sigusr1()
441		{
442		if (Daemon::$config->logsignals->value) {
443		$this->log('Caught SIGUSR1 (re-open log-file).');
444		}
445
446		Daemon::openLogs();
447		$this->signalToChildren(SIGUSR1);
448		}
449
450		/**
451		* Handler for the SIGUSR2 (graceful restart all workers) signal in master process
452		* @return void
453		*/
454		protected function sigusr2()
455		{
456		if (Daemon::$config->logsignals->value) {
457		$this->log('Caught SIGUSR2 (graceful restart all workers).');
458		}
459		$this->signalToChildren(SIGUSR2);
460		}
461
462		/**
463		* Handler for the SIGTTIN signal in master process
464		* Used as "ping" signal
465		* @return void
466		*/
467		protected function sigttin()
468		{
469		}
470
471		/**
472		* Handler for the SIGXSFZ signal in master process
473		* @return void
474		*/
475		protected function sigxfsz()
476		{
477		$this->log('Caught SIGXFSZ.');
478		}
479
480		/**
481		* Handler for non-known signals
482		* @return void
483		*/
484	View Code Duplication	protected function sigunknown($signo)
		0 ignored issues – show Duplication introduced 2018-01-16 22:41 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
485		{
486		if (isset(Generic::$signals[$signo])) {
487		$sig = Generic::$signals[$signo];
488		} else {
489		$sig = 'UNKNOWN';
490		}
491		$this->log('Caught signal #' . $signo . ' (' . $sig . ').');
492		}
493		}
494

kakserpom / phpdaemon

Master F last analyzed 2021-06-02 17:17 UTC