Peridot\WebDriverManager\Process\SeleniumProcess

Complexity

Total Complexity

24

Size/Duplication

Total Lines	210
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	2
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	addBinary()	0	17	4
A	pathContains()	0	4	1
A	getArgs()	0	4	1
A	addArg()	0	8	2
A	addArgs()	0	6	2
A	isAvailable()	0	10	1
A	start()	0	12	2
A	getCommand()	0	4	1
A	getStatus()	0	9	3
A	isRunning()	0	5	1
A	getError()	0	4	1
A	close()	0	5	1
A	formatCommand()	0	7	2
A	getDescriptorSpec()	0	8	1

<?php
namespace Peridot\WebDriverManager\Process;

use Peridot\WebDriverManager\Binary\BinaryInterface;
use Peridot\WebDriverManager\Binary\DriverInterface;

/**
 * SeleniumProcess is responsible for controlling Selenium Server processes.
 *
 * @package Peridot\WebDriverManager\Process
 */
class SeleniumProcess implements SeleniumProcessInterface
{
    /**
     * @var array
     */
    protected $args = [];

    /**
     * @var resource
     */
    protected $process = null;

    /**
     * @var array
     */
    protected $pipes = [];

    public function __construct()
    {
    }

    /**
     * {@inheritdoc}
     *
     * @param BinaryInterface $binary
     * @param string $directory
     * @return void
     */
    public function addBinary(BinaryInterface $binary, $directory)
    {
        if (! $binary->exists($directory)) {
            return;
        }

        if ($binary instanceof DriverInterface) {
            $this->addArg('-D' . $binary->getDriverPath($directory));
            return;
        }

        if($this->pathContains($binary->getFileName(), ".jar")){
            $this->addArg('-jar');
        }

        $this->addArg(realpath($directory . '/' . $binary->getFileName()));
    }

    private function pathContains($path, $match)
    {
        return strpos($path, $match) !== false;
    }


    /**
     * {@inheritdoc}
     *
     * @return array
     */
    public function getArgs()
    {
        return $this->args;
    }

    /**
     * {@inheritdoc}
     *
     * @param string $arg
     * @return void
     */
    public function addArg($arg)
    {
        $this->args[] = $arg;
        $rest = array_slice(func_get_args(), 1);
        foreach ($rest as $arg) {
            $this->args[] = $arg;
        }
    }

    /**
     * {@inheritdoc}
     *
     * @param array $args
     * @return void
     */
    public function addArgs(array $args)
    {
        foreach ($args as $arg) {
            $this->args[] = $arg;
        }
    }

    /**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function isAvailable()
    {
        $command = 'java -version';
        $descriptors = $this->getDescriptorSpec();
        $this->process = proc_open($this->formatCommand($command), $descriptors, $this->pipes);
        $status = $this->getStatus(true);
        $available = $status['exitcode'] == 0;
        proc_close($this->process);
        return $available;
    }

    /**
     * {@inheritdoc}
     *
     * @return $this
     */
    public function start($background = false)
    {
        $command = $this->getCommand();
        if (! $background) {
            exec($command);
            return $this;
        }

        $descriptors = $this->getDescriptorSpec();
        $this->process = proc_open($command, $descriptors, $this->pipes);
        return $this;
    }

    /**
     * {@inheritdoc}
     *
     * @return string
     */
    public function getCommand()
    {
        return $this->formatCommand('java ' . implode(' ', $this->args));
    }

    /**
     * {@inheritdoc}
     *
     * @param bool $loop
     * @return array
     */
    public function getStatus($loop = false)
    {
        $status = proc_get_status($this->process);
        while ($loop && $status['running']) {
            usleep(20000);
            $status = proc_get_status($this->process);
        }
        return $status;
    }

    /**
     * {@inheritdoc}
     *
     * @return bool
     */
    public function isRunning()
    {
        $status = $this->getStatus();
        return $status['running'];
    }

    /**
     * {@inheritdoc}
     *
     * @return string
     */
    public function getError()
    {
        return stream_get_contents($this->pipes[2]);
    }

    /**
     * {@inheritdoc}
     *
     * @return int
     */
    public function close()
    {
        proc_terminate($this->process);
        return proc_close($this->process);
    }

    /**
     * Format a shell command according to the running Operating System to avoid zombie processes.
     *
     * @param string $command A shell command.
     * @return string
     */
    private function formatCommand($command)
    {
        if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
            return $command;
        }
        return 'exec ' . $command;
    }

    /**
     * Helper to create an array suitable as a descriptor for process streams.
     *
     * @return array
     */
    private function getDescriptorSpec()
    {
        return [
            0 => ['pipe', 'r'],
            1 => ['pipe', 'w'],
            2 => ['pipe', 'w']
        ];
    }
}