PHPDaemon\Core\ShellCommand

Complexity

Total Complexity

71

Size/Duplication

Total Lines	496
Duplicated Lines	8.67 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes	3
Bugs	1	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getCmd()	0	4	1
A	setGroup()	0	5	1
A	setCwd()	0	5	1
A	setUser()	0	5	1
A	setChroot()	0	5	1
A	exec()	0	13	1
D	setFd()	8	38	10
A	setArgs()	0	6	1
A	setEnv()	0	6	1
A	onEofEvent()	0	9	2
A	nice()	0	6	1
A	onRead()	0	8	2
C	buildArgs()	0	22	9
F	execute()	0	57	15
A	finishWrite()	0	10	2
A	close()	0	8	2
A	onFinish()	0	4	1
A	closeWrite()	0	16	4
A	eof()	0	4	1
B	write()	19	20	6
B	writeln()	16	17	5
A	onEOF()	0	5	1
A	getStatus()	0	4	2

<?php
namespace PHPDaemon\Core;

use PHPDaemon\Core\CallbackWrapper;
use PHPDaemon\Core\Daemon;
use PHPDaemon\FS\File;
use PHPDaemon\Network\IOStream;

/**
 * Process
 * @package PHPDaemon\Core
 * @author  Vasily Zorin <maintainer@daemon.io>
 */
class ShellCommand extends IOStream
{

    protected $finishWrite;

    /**
     * @var string Command string
     */
    protected $cmd;

    /**
     * @var string Executable path
     */
    public $binPath;

    /**
     * @var array Opened pipes
     */
    protected $pipes;

    /**
     * @var resource Process descriptor
     */
    protected $pd;

    /**
     * @var resource FD write
     */
    protected $fdWrite;

    /**
     * @var boolean Output errors?
     */
    protected $outputErrors = true;

    /**
     * @var string SUID
     */
    public $setUser;

    /**
     * @var string SGID
     */
    public $setGroup;

    /**
     * @var string Chroot
     */
    public $chroot = '/';

    /**
     * @var array Hash of environment's variables
     */
    protected $env = []; // 

    /**
     * @var string Chdir
     */
    public $cwd;

    /**
     * @var string Path to error logfile
     */
    protected $errlogfile = null;

    /**
     * @var array Array of arguments
     */
    protected $args;

    /**
     * @var integer Process priority
     */
    protected $nice;

    /**
     * @var \EventBufferEvent
     */
    protected $bevWrite;

    /**
     * @var \EventBufferEvent
     */
    protected $bevErr;

    /**
     * @var boolean Got EOF?
     */
    protected $EOF = false;

    /**
     * Get command string
     * @return string
     */
    public function getCmd()
    {
        return $this->cmd;
    }

    /**
     * Set group
     * @return this

Should the return type not be ShellCommand?

     */
    public function setGroup($val)
    {
        $this->setGroup = $val;
        return $this;
    }

    /**
     * Set cwd
     * @param  string $dir
     * @return this

Should the return type not be ShellCommand?

     */
    public function setCwd($dir)
    {
        $this->cwd = $dir;
        return $this;
    }

    /**
     * Set group
     * @param  string $val
     * @return this

Should the return type not be ShellCommand?

     */
    public function setUser($val)
    {
        $this->setUser = $val;
        return $this;
    }

    /**
     * Set chroot
     * @param  string $dir
     * @return this

Should the return type not be ShellCommand?

     */
    public function setChroot($dir)
    {
        $this->chroot = $dir;
        return $this;
    }

    /**
     * Execute
     * @param  string   $binPath Binpath

Should the type for parameter $binPath not be string|null?

     * @param  callable $cb 	 Callback

Should the type for parameter $cb not be callable|null?

     * @param  array    $args    Optional. Arguments

Should the type for parameter $args not be array|null?

     * @param  array    $env     Optional. Hash of environment's variables

Should the type for parameter $env not be array|null?

     */
    public static function exec($binPath = null, $cb = null, $args = null, $env = null)
    {
        $o = new static;
        $data = '';
        $o->bind('read', function ($o) use (&$data, $o) {

The parameter name $o conflicts with one of the imported variables.

            $data .= $o->readUnlimited();
        });
        $o->bind('eof', function ($o) use (&$data, $cb) {
            $cb($o, $data);
            $o->close();
        });
        $o->execute($binPath, $args, $env);
    }


    /**
     * Sets fd
     * @param  resource          $fd File descriptor
     * @param  \EventBufferEvent $bev

Should the type for parameter $bev not be \EventBufferEvent|null?

     * @return void
     */
    public function setFd($fd, $bev = null)
    {
        $this->fd = $fd;
        if ($fd === false) {
            $this->finish();
            return;
        }
        $this->fdWrite = $this->pipes[0];
        $flags         = !is_resource($this->fd) ? \EventBufferEvent::OPT_CLOSE_ON_FREE : 0;
        $flags |= \EventBufferEvent::OPT_DEFER_CALLBACKS; /* buggy option */
        $this->bev      = new \EventBufferEvent(Daemon::$process->eventBase, $this->fd, 0, [$this, 'onReadEv'], null, [$this, 'onStateEv']);

This line exceeds maximum limit of 120 characters; contains 140 characters

        $this->bevWrite = new \EventBufferEvent(Daemon::$process->eventBase, $this->fdWrite, 0, null, [$this, 'onWriteEv'], null);

This line exceeds maximum limit of 120 characters; contains 130 characters

        if (!$this->bev || !$this->bevWrite) {
            $this->finish();
            return;
        }
        if ($this->priority !== null) {
            $this->bev->priority = $this->priority;
        }
        if ($this->timeout !== null) {
            $this->setTimeout($this->timeout);
        }
        if (!$this->bev->enable(\Event::READ | \Event::TIMEOUT | \Event::PERSIST)) {

This code seems to be duplicated across your project.

            $this->finish();
            return;
        }
        if (!$this->bevWrite->enable(\Event::WRITE | \Event::TIMEOUT | \Event::PERSIST)) {

This code seems to be duplicated across your project.

            $this->finish();
            return;
        }
        $this->bev->setWatermark(\Event::READ, $this->lowMark, $this->highMark);

        init:
        if (!$this->inited) {
            $this->inited = true;
            $this->init();
        }
    }

    /**
     * Sets an array of arguments
     * @param  array Arguments
     * @return this

Should the return type not be ShellCommand?

     */
    public function setArgs($args = null)
    {
        $this->args = $args;

        return $this;
    }

    /**
     * Set a hash of environment's variables
     * @param  array Hash of environment's variables
     * @return this

Should the return type not be ShellCommand?

     */
    public function setEnv($env = null)
    {
        $this->env = $env;

        return $this;
    }

    /**
     * Called when got EOF
     * @return void
     */
    public function onEofEvent()
    {
        if ($this->EOF) {
            return;
        }
        $this->EOF = true;

        $this->event('eof');
    }

    /**
     * Set priority
     * @param  integer $nice Priority

Should the type for parameter $nice not be integer|null?

     * @return this

Should the return type not be ShellCommand?

     */
    public function nice($nice = null)
    {
        $this->nice = $nice;

        return $this;
    }

    /**
     * Called when new data received
     * @return this|null

Should the return type not be ShellCommand|null?

     */
    protected function onRead()
    {
        if (func_num_args() === 1) {
            $this->onRead = func_get_arg(0);

The property onRead does not exist on object<PHPDaemon\Core\ShellCommand>. Since you implemented __set, maybe consider adding a @property annotation.

            return $this;
        }
        $this->event('read');
    }

    /**
     * Build arguments string from associative/enumerated array (may be mixed)
     * @param  array $args
     * @return string
     */
    public static function buildArgs($args)
    {
        if (!is_array($args)) {
            return '';
        }
        $ret = '';
        foreach ($args as $k => $v) {
            if (!is_int($v) && ($v !== null)) {
                $v = escapeshellarg($v);
            }
            if (is_int($k)) {
                $ret .= ' ' . $v;
            } else {
                if ($k{0} !== '-') {
                    $ret .= ' --' . $k . ($v !== null ? '=' . $v : '');
                } else {
                    $ret .= ' ' . $k . ($v !== null ? '=' . $v : '');
                }
            }
        }
        return $ret;
    }

    /**
     * Execute
     * @param  string $binPath Optional. Binpath

Should the type for parameter $binPath not be string|null?

     * @param  array  $args    Optional. Arguments

Should the type for parameter $args not be array|null?

     * @param  array  $env     Optional. Hash of environment's variables

Should the type for parameter $env not be array|null?

     * @return this

Should the return type not be ShellCommand?

     */
    public function execute($binPath = null, $args = null, $env = null)
    {
        if ($binPath !== null) {
            $this->binPath = $binPath;
        }

        if ($env !== null) {
            $this->env = $env;
        }

        if ($args !== null) {
            $this->args = $args;
        }
        $this->cmd = $this->binPath . static::buildArgs($this->args) . ($this->outputErrors ? ' 2>&1' : '');

        if (
                isset($this->setUser)
                || isset($this->setGroup)
        ) {
            if (
                    isset($this->setUser)
                    && isset($this->setGroup)
                    && ($this->setUser !== $this->setGroup)
            ) {
                $this->cmd = 'sudo -g ' . escapeshellarg($this->setGroup) . '  -u ' . escapeshellarg($this->setUser) . ' ' . $this->cmd;

This line exceeds maximum limit of 120 characters; contains 136 characters

            } else {
                $this->cmd = 'su ' . escapeshellarg($this->setGroup) . ' -c ' . escapeshellarg($this->cmd);
            }
        }

        if ($this->chroot !== '/') {
            $this->cmd = 'chroot ' . escapeshellarg($this->chroot) . ' ' . $this->cmd;
        }

        if ($this->nice !== null) {
            $this->cmd = 'nice -n ' . ((int)$this->nice) . ' ' . $this->cmd;
        }

        $pipesDescr = [
            0 => ['pipe', 'r'], // stdin is a pipe that the child will read from
            1 => ['pipe', 'w'] // stdout is a pipe that the child will write to
        ];

        if (
                ($this->errlogfile !== null)
                && !$this->outputErrors
        ) {
            $pipesDescr[2] = ['file', $this->errlogfile, 'a']; // @TODO: refactoring

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

        }

        $this->pd = proc_open($this->cmd, $pipesDescr, $this->pipes, $this->cwd, $this->env);
        if ($this->pd) {
            $this->setFd($this->pipes[1]);
        }

        return $this;
    }

    /**
     * Finish write stream
     * @return boolean
     */
    public function finishWrite()
    {
        if (!$this->writing) {
            $this->closeWrite();
        }

        $this->finishWrite = true;

        return true;
    }

    /**
     * Close the process
     * @return void
     */
    public function close()
    {
        parent::close();
        $this->closeWrite();
        if (is_resource($this->pd)) {
            proc_close($this->pd);
        }
    }

    /**
     * Called when stream is finished
     */
    public function onFinish()
    {
        $this->onEofEvent();
    }

    /**
     * Close write stream
     * @return this

Should the return type not be ShellCommand?

     */
    public function closeWrite()
    {
        if ($this->bevWrite) {
            if (isset($this->bevWrite)) {
                $this->bevWrite->free();
            }
            $this->bevWrite = null;
        }

        if ($this->fdWrite) {
            fclose($this->fdWrite);
            $this->fdWrite = null;
        }

        return $this;
    }

    /**
     * Got EOF?
     * @return boolean
     */
    public function eof()
    {
        return $this->EOF;
    }

    /**
     * Send data to the connection. Note that it just writes to buffer that flushes at every baseloop
     * @param  string $data Data to send
     * @return boolean Success
     */
    public function write($data)

This method seems to be duplicated in your project.

    {
        if (!$this->alive) {
            Daemon::log('Attempt to write to dead IOStream (' . get_class($this) . ')');
            return false;
        }
        if (!isset($this->bevWrite)) {
            return false;
        }
        if (!mb_orig_strlen($data)) {
            return true;
        }
        $this->writing   = true;
        Daemon::$noError = true;
        if (!$this->bevWrite->write($data) || !Daemon::$noError) {
            $this->close();
            return false;
        }
        return true;
    }

    /**
     * Send data and appending \n to connection. Note that it just writes to buffer flushed at every baseloop
     * @param  string Data to send
     * @return boolean Success
     */
    public function writeln($data)

This method seems to be duplicated in your project.

    {
        if (!$this->alive) {
            Daemon::log('Attempt to write to dead IOStream (' . get_class($this) . ')');
            return false;
        }
        if (!isset($this->bevWrite)) {
            return false;
        }
        if (!mb_orig_strlen($data) && !mb_orig_strlen($this->EOL)) {
            return true;
        }
        $this->writing = true;
        $this->bevWrite->write($data);
        $this->bevWrite->write($this->EOL);
        return true;
    }

    /**
     * Sets callback which will be called once when got EOF
     * @param  callable $cb

Should the type for parameter $cb not be callable|null?

     * @return this

Should the return type not be ShellCommand?

     */
    public function onEOF($cb = null)
    {
        $this->onEOF = CallbackWrapper::wrap($cb);

The property onEOF does not exist on object<PHPDaemon\Core\ShellCommand>. Since you implemented __set, maybe consider adding a @property annotation.

It seems like $cb defined by parameter $cb on line 499 can also be of type null; however, PHPDaemon\Core\CallbackWrapper::wrap() does only seem to accept callable, maybe add an additional type check?

        return $this;
    }

    public function getStatus()
    {
        return !empty($this->pd) ? proc_get_status($this->pd) : null;
    }
}