Daemon - Code Metrics - Inspection of "EventLoopContainer" - kakserpom/phpdaemon - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — EventLoopContainer ( c9a84d...6e77fa )

by Vasily
created 2016-06-06 02:46 UTC
Daemon F

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	711
Duplicated Lines	0.84 %
Coupling/Cohesion

Components	2
Dependencies	11
Importance

Changes	4
Bugs	1	Features	0
Metric	Value
c	4
b	1
f	0
dl	6
loc	711
rs	3.9999
wmc	86
lcom	2
cbo	11
20 Methods

Rating	Name	Duplication	Size	Complexity
A	initSettings()	0	11	3
A	glob()	0	8	2
A	uniqid()	0	13	1
B	loadModuleIfAbsent()	0	20	6
A	callAutoGC()	0	6	2
A	checkAutoGC()	0	11	4
A	outputFilter()	0	18	4
B	uncaughtExceptionHandler()	3	13	6
B	errorHandler()	3	32	5
A	init()	0	17	1
A	supported()	0	4	1
B	checkSupports()	0	18	6
A	lintFile()	0	17	3
C	compatRunEmul()	0	57	11
A	loadConfig()	0	17	4
C	openLogs()	0	23	7
C	getStateOfWorkers()	0	56	11
B	log()	0	23	6
A	spawnMaster()	0	12	2
A	runWorker()	0	6	1
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 Daemon 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 Daemon, and based on these observations, apply Extract Interface, too.
<?php
namespace PHPDaemon\Core;

use PHPDaemon\Config;
use PHPDaemon\FS\File;
use PHPDaemon\FS\FileSystem;
use PHPDaemon\Thread;
use PHPDaemon\Thread\Collection;
use PHPDaemon\Utils\ShmEntity;

/**
 * Daemon "namespace"
 *
 * @package Core
 *
 * @author  Vasily Zorin <[email protected]>
 */
class Daemon
{
    use \PHPDaemon\Traits\ClassWatchdog;
    use \PHPDaemon\Traits\StaticObjectWatchdog;

    /**
     * Support of runkit sandbox functionality
     * @var integer
     */
    const SUPPORT_RUNKIT_SANDBOX = 0;

    /**
     * Support of runkit on-the-fly userland code modification functionality
     * @var integer
     */
    const SUPPORT_RUNKIT_MODIFY = 1;

    /**
     * Support of runkit on-the-fly internal code modification functionality
     * @var integer
     */
    const SUPPORT_RUNKIT_INTERNAL_MODIFY = 2;

    /**
     * Support of runkit on-the-fly userland code import functionality
     * @var integer
     */
    const SUPPORT_RUNKIT_IMPORT = 3;

    /**
     * Worker state: idle. It means that the worker IS NOT in the middle of execution valuable callback (e.g. request) at this moment of time. Currently, it does not mean that worker not have any pending operations.

     * @var integer
     */
    const WSTATE_IDLE = 1;

    /**
     * Worker state: busy. It means that the worker IS in the middle of execution valuable callback.
     */
    const WSTATE_BUSY = 2;

    /**
     * Worker state: shutdown. It means that worker is shutdown. Nothing special.
     * @var integer
     */
    const WSTATE_SHUTDOWN = 3;

    /**
     * Worker state: shutdown. It means that worker is shutdown.
     * @var integer
     */
    const WSTATE_PREINIT = 4;

    /**
     * Worker state: initialization. It means that worker is starting right now.
     * @var integer
     */
    const WSTATE_INIT = 5;

    /**
     * Hash of possible worker states
     * @var array
     */
    public static $wstateRev = [
        1 => 'IDLE',
        2 => 'BUSY',
        3 => 'SHUTDOWN',
        4 => 'PREINIT',
        5 => 'INIT',
    ];

    /**
     * Shared memory WSTATE segment size
     * @var integer
     */
    const SHM_WSTATE_SIZE = 1024;

    /**
     * PHPDaemon version
     * @var string
     */
    public static $version;

    /**
     * PHPDaemon start time
     * @var integer
     */
    public static $startTime;

    /**
     * Log file resource
     * @var resource
     */
    public static $logpointer;

    /**
     * Log file async. resource
     * @var object
     */
    public static $logpointerAsync;

    /**
     * Supported things array
     * @var string
     */
    protected static $support = [];

    /**
     * Current thread object
     * @var \PHPDaemon\Thread\Master|\PHPDaemon\Thread\IPC|\PHPDaemon\Thread\Worker
     */
    public static $process;

    /**
     * AppResolver
     * @var \PHPDaemon\Core\AppResolver
     */
    public static $appResolver;

    /**
     * Running application instances
     * @var array
     */
    public static $appInstances = [];

    /**
     * Running request
     * @var \PHPDaemon\Request\Generic
     */
    public static $req;

    /**
     * Running context
     * @var object
     */
    public static $context;

    /**
     * Collection of workers
     * @var \PHPDaemon\Thread\Collection
     */
    protected static $workers;

    /**
     * Collection of masters
     * @var \PHPDaemon\Thread\Collection
     */
    protected static $masters;

    /**
     * Copy of $_SERVER on the daemon start
     * @var array
     */
    protected static $initservervar;

    /**
     * Shared memory 'WSTATE' entity
     * @var \PHPDaemon\Thread\Collection
     */
    public static $shm_wstate;

    /**
     * Running under Apache/PHP-FPM in compatibility mode?
     * @var boolean
     */
    public static $compatMode = false;

    /**
     * Base name of daemon instance
     * @var string
     */
    public static $runName = 'phpdaemon';

    /**
     * Configuration object
     * @var \PHPDaemon\Config\Object
     */
    public static $config;

    /**
     * Path to application resolver
     * @var string
     */
    public static $appResolverPath;


    /**
     * Restrict error control. When true, operator '@' means nothing.
     * @var boolean
     */
    public static $restrictErrorControl = false;

    /**
     * Default error reporting level
     * @var integer
     */
    public static $defaultErrorLevel;

    /**
     * Is it running under master-less 'runworker' mode?
     * @var bool
     */
    public static $runworkerMode = false;

    /**
     * Whether if the current execution stack contains ob-filter
     * @var bool
     */
    public static $obInStack = false;

    /**
     * Mechanism of catching errors. Set it to true, then run your suspect code, and then check this property again. If false, there was error message.

     * @var bool
     */
    public static $noError = false;

    /**
     * Loads default setting.
     * @return void
     */
    public static function initSettings()
    {
        Daemon::$version = file_get_contents('VERSION', true);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}

        Daemon::$config = new Config\Object;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}

        if (!defined('SO_REUSEPORT') && mb_orig_strpos(php_uname('s'), 'BSD') !== false) {
            // @TODO: better if-BSD check

            define('SO_REUSEPORT', 0x200);
        }
    }

    /**
     * Glob function with support of include_path
     * @param string $pattern
     * @param int $flags
     * @return array
     */
    public static function glob($pattern, $flags = 0)
    {
        $r = [];
        foreach (explode(':', get_include_path()) as $path) {
            $r = array_merge($r, glob($p = $path . '/' . $pattern, $flags));
        }
        return array_unique($r);
    }

    /**
     * Generate a unique ID.
     * @return string Returns the unique identifier, as a string.
     */
    public static function uniqid()
    {
        static $n = 0;
        return str_shuffle(
            md5(
                str_shuffle(
                    microtime(true) . chr(mt_rand(0, 0xFF))
                    . Daemon::$process->getPid() . chr(mt_rand(0, 0xFF))
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    . (++$n) . mt_rand(0, mt_getrandmax())
                )
            )
        );
    }

    /**
     * Load PHP extension (module) if absent
     * @param string $mod
     * @param string $version

     * @param string $compare
     * @return bool $success
     */
    public static function loadModuleIfAbsent($mod, $version = null, $compare = '>=')
    {
        if (!extension_loaded($mod)) {
            if (!get_cfg_var('enable_dl')) {
                return false;
            }
            if (!@dl(basename($mod) . '.so')) {
                return false;
            }
        }
        if (!$version) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return true;
        }
        try {
            $ext = new \ReflectionExtension($mod);
            return version_compare($ext->getVersion(), $version, $compare);
        } catch (\ReflectionException $e) {
            return false;
        }
    }

    /**
     * Call automatic garbage collector
     * @return void
     */
    public static function callAutoGC()
    {
        if (self::checkAutoGC()) {
            gc_collect_cycles();
        }
    }

    /**
     * Check if we need to run automatic garbage collector
     * @return bool
     */
    public static function checkAutoGC()
    {
        if ((Daemon::$config->autogc->value > 0)
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            && (Daemon::$process->counterGC > 0)
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            && (Daemon::$process->counterGC >= Daemon::$config->autogc->value)
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        ) {
            Daemon::$process->counterGC = 0;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            return true;
        }
        return false;
    }

    /**
     * Output filter
     * @return string Output
     */
    public static function outputFilter($s)
    {
        static $n = 0; // recursion counter

        if ($s === '') {
            return '';
        }
        ++$n;
        Daemon::$obInStack = true;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        if (Daemon::$config->obfilterauto->value && Daemon::$context instanceof \PHPDaemon\Request\Generic) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            Daemon::$context->out($s, false);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        } else {
            Daemon::log('Unexcepted output (len. ' . mb_orig_strlen($s) . '): \'' . $s . '\'');
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        }
        --$n;
        Daemon::$obInStack = $n > 0;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        return '';
    }

    /**
     * Uncaught exception handler
     * @param \Exception $e
     * @return void
     */
    public static function uncaughtExceptionHandler(\Exception $e)
    {
        if (Daemon::$context !== null) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            if (Daemon::$context->handleException($e)) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                return;
            }
        }
        $msg = $e->getMessage();
        Daemon::log('Uncaught ' . get_class($e) . ' (' . $e->getCode() . ')' . (mb_orig_strlen($msg) ? ': ' . $msg : '') . ".\n" . $e->getTraceAsString());
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        if (Daemon::$context instanceof \PHPDaemon\Request\Generic) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            Daemon::$context->out('<b>Uncaught ' . get_class($e) . ' (' . $e->getCode() . ')</b>' . (mb_orig_strlen($msg) ? ': ' . $msg : '') . '.<br />');
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        }
    }

    /**
     * Error handler
     * @param integer $errno
     * @param string $errstr
     * @param string $errfile
     * @param integer $errline
     * @param array $errcontext
     */
    public static function errorHandler($errno, $errstr, $errfile, $errline, $errcontext)

    {
        Daemon::$noError = false;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        $l = error_reporting();
        if ($l === 0) {
            if (!Daemon::$restrictErrorControl) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                return;
            }
        } elseif (!($l & $errno)) {
            return;
        }

        static $errtypes = [
            E_ERROR => 'Fatal error',
            E_WARNING => 'Warning',
            E_PARSE => 'Parse error',
            E_NOTICE => 'Notice',
            E_PARSE => 'Parse error',
            E_USER_ERROR => 'Fatal error (userland)',
            E_USER_WARNING => 'Warning (userland)',
            E_USER_NOTICE => 'Notice (userland)',
            E_STRICT => 'Notice (userland)',
            E_RECOVERABLE_ERROR => 'Fatal error (recoverable)',
            E_DEPRECATED => 'Deprecated',
            E_USER_DEPRECATED => 'Deprecated (userland)',
        ];
        $errtype = $errtypes[$errno];
        Daemon::log($errtype . ': ' . $errstr . ' in ' . $errfile . ':' . $errline . "\n" . Debug::backtrace());
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        if (Daemon::$context instanceof \PHPDaemon\Request\Generic) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            Daemon::$context->out('<strong>' . $errtype . '</strong>: ' . $errstr . ' in ' . basename($errfile) . ':' . $errline . '<br />');
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        }
    }

    /**
     * Performs initial actions.
     * @return void
     */
    public static function init()
    {
        Daemon::$startTime = time();
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        set_time_limit(0);

        Daemon::$defaultErrorLevel = error_reporting();
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        Daemon::$restrictErrorControl = (bool)Daemon::$config->restricterrorcontrol->value;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        ob_start(['\PHPDaemon\Core\Daemon', 'outputFilter']);
        set_error_handler(['\PHPDaemon\Core\Daemon', 'errorHandler']);

        Daemon::checkSupports();
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}

        Daemon::$initservervar = $_SERVER;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        Daemon::$masters = new Collection;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        Daemon::$shm_wstate = new ShmEntity(Daemon::$config->pidfile->value, Daemon::SHM_WSTATE_SIZE, 'wstate', true);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        Daemon::openLogs();
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
    }

    /**
     * Is thing supported
     * @param integer $what Thing to check
     * @return boolean
     */
    public static function supported($what)
    {
        return isset(self::$support[$what]);
    }

    /**
     * Method to fill $support array
     * @return void
     */
    protected static function checkSupports()
    {
        if (is_callable('runkit_lint_file')) {
            self::$support[self::SUPPORT_RUNKIT_SANDBOX] = true;
        }

        if (is_callable('runkit_function_add')) {
            self::$support[self::SUPPORT_RUNKIT_MODIFY] = true;
        }

        if (is_callable('runkit_import')) {
            self::$support[self::SUPPORT_RUNKIT_IMPORT] = true;
        }

        if (self::supported(self::SUPPORT_RUNKIT_MODIFY) && ini_get('runkit.internal_override')) {
            self::$support[self::SUPPORT_RUNKIT_INTERNAL_MODIFY] = true;
        }
    }

    /**
     * Check file syntax via runkit_lint_file if supported or via php -l
     * @param string File name
     * @return boolean
     */
    public static function lintFile($filename)
    {
        if (!file_exists($filename)) {
            return false;
        }

        if (self::supported(self::SUPPORT_RUNKIT_SANDBOX)) {
            /** @noinspection PhpUndefinedFunctionInspection */
            return runkit_lint_file($filename);
        }

        $cmd = 'php -l ' . escapeshellcmd($filename) . ' 2>&1';

        exec($cmd, $output, $retcode);

        return 0 === $retcode;
    }

    /**
     * It allows to run your simple web-apps in spawn-fcgi/php-fpm environment.
     * @return boolean|null - Success.
     */
    public static function compatRunEmul()
    {
        Daemon::$compatMode = true;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        Daemon::initSettings();
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}

        $argv = isset($_SERVER['CMD_ARGV']) ? $_SERVER['CMD_ARGV'] : '';

        $args = \PHPDaemon\Core\Bootstrap::getArgs($argv);

        if (isset($args[$k = 'configfile'])) {
            Daemon::$config[$k] = $args[$k];
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        }

        if (!Daemon::$config->loadCmdLineArgs($args)) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            $error = true;
        }

        if (isset(Daemon::$config->configfile->value) && !Daemon::loadConfig(Daemon::$config->configfile->value)) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            $error = true;
        }

        if (!isset(Daemon::$config->path->value)) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            exit('\'path\' is not defined');
        }

        if ($error) {
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            exit;
        }

        $appResolver = require Daemon::$config->path->value;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        $appResolver->init();

        $req = new \stdClass;
        $req->attrs = new \stdClass;
        $req->attrs->request = $_REQUEST;
        $req->attrs->get = $_GET;
        $req->attrs->post = $_REQUEST;
        $req->attrs->cookie = $_REQUEST;
        $req->attrs->server = $_SERVER;
        $req->attrs->files = $_FILES;
        $req->attrs->session = isset($_SESSION) ? $_SESSION : null;
        $req->attrs->connId = 1;
        $req->attrs->trole = 'RESPONDER';
        $req->attrs->flags = 0;
        $req->attrs->id = 1;
        $req->attrs->paramsDone = true;
        $req->attrs->inputDone = true;
        $req = $appResolver->getRequest($req);

        while (true) {
            $ret = $req->call();

            if ($ret === 1) {
                return;
            }
        }
    }

    /**
     * Load config-file
     * @param string $paths Path
     * @return boolean - Success.
     */
    public static function loadConfig($paths)
    {
        $apaths = explode(';', $paths);
        foreach ($apaths as $path) {
            if (is_file($p = realpath($path))) {
                $ext = strtolower(pathinfo($p, PATHINFO_EXTENSION));
                if ($ext === 'conf') {
                    return Daemon::$config->loadFile($p);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                } else {
                    Daemon::log('Config file \'' . $p . '\' has unsupported file extension.');
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    return false;
                }
            }
        }
        Daemon::log('Config file not found in \'' . $paths . '\'.');
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        return false;
    }

    /**
     * Open logs
     * @return void
     */
    public static function openLogs()
    {
        if (Daemon::$config->logging->value) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            Daemon::$logpointer = fopen(Daemon::$config->logstorage->value, 'a');
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            if (isset(Daemon::$config->group->value)) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                chgrp(Daemon::$config->logstorage->value, Daemon::$config->group->value); // @TODO: rewrite to async I/O
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            }
            if (isset(Daemon::$config->user->value)) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                chown(Daemon::$config->logstorage->value, Daemon::$config->user->value); // @TODO: rewrite to async I/O
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            }
            if ((Daemon::$process instanceof Thread\Worker) && FileSystem::$supported) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                FileSystem::open(Daemon::$config->logstorage->value, 'a!', function ($file) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    Daemon::$logpointerAsync = $file;
                    if (!$file) {
                        return;
                    }
                });
            }
        } else {
            Daemon::$logpointer = null;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            Daemon::$logpointerAsync = null;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        }
    }

    /**
     * Get state of workers.
     * @return array - information.
     */
    public static function getStateOfWorkers()
    {
        $offset = 0;

        $stat = [
            'idle' => 0,
            'busy' => 0,
            'alive' => 0,
            'shutdown' => 0,
            'preinit' => 0,
            'init' => 0,
            'reloading' => 0,
        ];
        $readed = 0;
        while (($buf = Daemon::$shm_wstate->read($readed, 1024)) !== false) {
class ParentClass {
    private $data = array();

    public function __call($method, array $args) {
        if (0 === strpos($method, 'get')) {
            return $this->data[strtolower(substr($method, 3))];
        }

        throw new \LogicException(sprintf('Unsupported method: %s', $method));
    }
}

/**
 * If this class knows which fields exist, you can specify the methods here:
 *
 * @method string getName()
 */
class SomeClass extends ParentClass { }
            $buflen = mb_orig_strlen($buf);
            $readed += $buflen;
            for ($i = 0; $i < $buflen; ++$i) {
                $code = ord($buf[$i]);
                if ($code >= 100) {
                    // reloaded (shutdown)
                    $code -= 100;
                    if ($code !== Daemon::WSTATE_SHUTDOWN) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                        ++$stat['alive'];
                        if (Daemon::$process instanceof Thread\Master) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                            Daemon::$process->reloadWorker($offset + $i + 1);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                            ++$stat['reloading'];
                            continue;
                        }
                    }
                }
                if ($code === Daemon::WSTATE_IDLE) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    // idle
                    ++$stat['alive'];
                    ++$stat['idle'];
                } elseif ($code === Daemon::WSTATE_BUSY) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    // busy
                    ++$stat['alive'];
                    ++$stat['busy'];
                } elseif ($code === Daemon::WSTATE_SHUTDOWN) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    // shutdown
                    ++$stat['shutdown'];
                } elseif ($code === Daemon::WSTATE_PREINIT) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    // pre-init
                    ++$stat['alive'];
                    ++$stat['preinit'];
                    ++$stat['idle'];
                } elseif ($code === Daemon::WSTATE_INIT) { // init
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                    ++$stat['alive'];
                    ++$stat['init'];
                    ++$stat['idle'];
                }
            }
        }
        return $stat;
    }

    /**
     *  Send message to the log
     *
     * @param array ...$args
     */
    public static function log(...$args)
    {
        if (sizeof($args) === 1) {
            $msg = is_scalar($args[0]) ? $args[0] : Debug::dump($args[0]);
        } else {
            $msg = Debug::dump($args);
        }

        $mt = explode(' ', microtime());

        if (is_resource(STDERR)) {
            fwrite(STDERR, '[PHPD] ' . $msg . "\n");
        }

        $msg = str_replace("\x01", $msg, date(strtr(Daemon::$config->logformat->value,
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
                ['%msg%' => "\x01", '\\u' => '\\u', 'u' => sprintf('%06d', $mt[0] * 1000000)]))) . "\n";

        if (Daemon::$logpointerAsync) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            Daemon::$logpointerAsync->write($msg);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        } elseif (Daemon::$logpointer) {
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            fwrite(Daemon::$logpointer, $msg);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        }
    }

    /**
     * Spawn a master process
     * @return null|integer - success
     */
    public static function spawnMaster()
    {
        Daemon::$masters->push($thread = new Thread\Master);
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        $thread->start();

        if (-1 === $thread->getPid()) {
            Daemon::log('could not start master');
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
            exit(0);
        }

        return $thread->getPid();
    }

    /**
     * Run worker thread
     * @return void
     */
    public static function runWorker()
    {
        Daemon::$runworkerMode = true;
<?php

class Certificate {
    const TRIPLEDES_CBC = 'ASDFGHJKL';

    private $key;

    public function __construct()
    {
        $this->key = Certificate::TRIPLEDES_CBC;
    }
}
        $thread = new Thread\Worker;
        $thread();
    }
}

1			<?php
2			namespace PHPDaemon\Core;
3
4			use PHPDaemon\Config;
5			use PHPDaemon\FS\File;
6			use PHPDaemon\FS\FileSystem;
7			use PHPDaemon\Thread;
8			use PHPDaemon\Thread\Collection;
9			use PHPDaemon\Utils\ShmEntity;
10
11			/**
12			* Daemon "namespace"
13			*
14			* @package Core
15			*
16			* @author Vasily Zorin <[email protected]>
17			*/
18			class Daemon
19			{
20			use \PHPDaemon\Traits\ClassWatchdog;
21			use \PHPDaemon\Traits\StaticObjectWatchdog;
22
23			/**
24			* Support of runkit sandbox functionality
25			* @var integer
26			*/
27			const SUPPORT_RUNKIT_SANDBOX = 0;
28
29			/**
30			* Support of runkit on-the-fly userland code modification functionality
31			* @var integer
32			*/
33			const SUPPORT_RUNKIT_MODIFY = 1;
34
35			/**
36			* Support of runkit on-the-fly internal code modification functionality
37			* @var integer
38			*/
39			const SUPPORT_RUNKIT_INTERNAL_MODIFY = 2;
40
kakserpom / phpdaemon
