Daemon

Complexity

Total Complexity

31

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
D	start()	0	32	9
B	getNextTask()	0	14	6
A	task()	0	17	2
A	workDir()	0	8	2
A	unserialize()	0	7	2
A	serialize()	0	3	1
A	serializer()	0	7	2
C	check()	0	31	7

<?php

class Daemon extends Module {
    private $tasksDirResource;
    private $serializer;
    private $workDir;
    public $checked = false;

    function check() {

It is generally recommended to explicitly declare the visibility for methods.

        $workDir = $this->workDir();
        $lock = fopen($workDir . '/daemon.lock', 'w+');
        if (flock($lock, LOCK_EX | LOCK_NB)) {
            flock($lock, LOCK_UN);
            fclose($lock);
            if (function_exists('pcntl_fork') && $pid = pcntl_fork() !== -1) {
                if ($pid) {
                    return $pid;
                } else {
                    $this->start(true);
                }
            } elseif (function_exists('fsockopen')) {
                $fp = fsockopen($_SERVER['SERVER_NAME'],
                    80,
                    $errno, $errstr, 30);
                $out = "GET /daemon/start HTTP/1.1\r\n";
                $out .= "Host: " . $_SERVER['SERVER_NAME'] . "\r\n";
                $out .= "Connection: Close\r\n\r\n";
                fwrite($fp, $out);
                fclose($fp);
            } elseif (function_exists('curl_init')) {
                $ch = curl_init('http://' . $_SERVER['SERVER_NAME'] . '/daemon/start');
                curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
                curl_setopt($ch, CURLOPT_TIMEOUT_MS, 100);
                curl_setopt($ch, CURLOPT_NOSIGNAL, 1);
                $content = curl_exec($ch);

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

                curl_close($ch);
            }
        }
    }

    function start($retry = false) {

It is generally recommended to explicitly declare the visibility for methods.

        $workDir = $this->workDir();
        $lock = fopen($workDir . '/daemon.lock', 'w+');
        if (flock($lock, LOCK_EX | LOCK_NB)) {
            set_time_limit(0);
            while (true) {
                $taskFile = $this->getNextTask();
                if (!$taskFile) {

The expression $taskFile of type string|false is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === false instead.

                    for ($i = 0; $i < 358; $i++) {
                        sleep(1);
                        $taskFile = $this->getNextTask();
                        if ($taskFile) {

The expression $taskFile of type string|false is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== false instead.

                            break;
                        }
                    }
                    if (!$taskFile) {

The expression $taskFile of type string|false is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === false instead.

                        break;
                    }
                }
                $task = $this->unserialize(file_get_contents($taskFile));
                unlink($taskFile);
                if ($task) {
                    $task();
                }
            }
        } else {
            if ($retry) {
                sleep(1);
                $this->start(false);
            }
        }
    }

    function getNextTask() {

It is generally recommended to explicitly declare the visibility for methods.

        $workDir = $this->workDir();
        if (!is_resource($this->tasksDirResource)) {
            $this->tasksDirResource = opendir($workDir . '/tasks/');
        }
        if ($this->tasksDirResource) {
            while (false !== ($entry = readdir($this->tasksDirResource))) {
                if ($entry != "." && $entry != "..") {
                    return $workDir . '/tasks/' . $entry;
                }
            }
        }
        return false;
    }

    function task($callback) {

It is generally recommended to explicitly declare the visibility for methods.

        $keyLog = \App::$cur->log->start('add task');
        $workDir = $this->workDir();
        $taskFile = $workDir . '/tasks/' . microtime(true) . '.task';
        $keyLog2 = \App::$cur->log->start('serialize task');
        $serialize = $this->serialize($callback);
        \App::$cur->log->end($keyLog2);
        $keyLog3 = \App::$cur->log->start('put task to file');
        file_put_contents($taskFile, $serialize);
        \App::$cur->log->end($keyLog3);
        if (!$this->checked) {
            $this->checked = true;
            $this->check();
        }
        \App::$cur->log->end($keyLog);
        return $taskFile;
    }

    function workDir() {

It is generally recommended to explicitly declare the visibility for methods.

        if ($this->workDir) {
            return $this->workDir;
        }
        $path = App::$primary->path . '/daemon';
        Tools::createDir(App::$primary->path . '/daemon/tasks');
        return $path;
    }

    function unserialize($item) {

It is generally recommended to explicitly declare the visibility for methods.

        try {
            return $this->serializer()->unserialize($item);
        } catch (\SuperClosure\Exception\ClosureUnserializationException $e) {

The class SuperClosure\Exception\ClosureUnserializationException does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return false;
        }
    }

    function serialize($item) {

It is generally recommended to explicitly declare the visibility for methods.

        return $this->serializer()->serialize($item);
    }

    function serializer() {

It is generally recommended to explicitly declare the visibility for methods.

        if ($this->serializer) {
            return $this->serializer;
        }
        \ComposerCmd::requirePackage('jeremeamia/superclosure');
        return $this->serializer = new \SuperClosure\Serializer(new SuperClosure\Analyzer\TokenAnalyzer());
    }

}