Your IP : 3.145.88.155
<?php
/**
* Hoa
*
*
* @license
*
* New BSD License
*
* Copyright © 2007-2017, Hoa community. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Hoa nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
namespace Psy\Readline\Hoa;
/**
* Manipulate a processus as a stream.
*/
class ConsoleProcessus extends Stream implements StreamIn, StreamOut, StreamPathable
{
/**
* Signal: terminal line hangup (terminate process).
*/
const SIGHUP = 1;
/**
* Signal: interrupt program (terminate process).
*/
const SIGINT = 2;
/**
* Signal: quit program (create core image).
*/
const SIGQUIT = 3;
/**
* Signal: illegal instruction (create core image).
*/
const SIGILL = 4;
/**
* Signal: trace trap (create core image).
*/
const SIGTRAP = 5;
/**
* Signal: abort program, formerly SIGIOT (create core image).
*/
const SIGABRT = 6;
/**
* Signal: emulate instruction executed (create core image).
*/
const SIGEMT = 7;
/**
* Signal: floating-point exception (create core image).
*/
const SIGFPE = 8;
/**
* Signal: kill program (terminate process).
*/
const SIGKILL = 9;
/**
* Signal: bus error.
*/
const SIGBUS = 10;
/**
* Signal: segmentation violation (create core image).
*/
const SIGSEGV = 11;
/**
* Signal: non-existent system call invoked (create core image).
*/
const SIGSYS = 12;
/**
* Signal: write on a pipe with no reader (terminate process).
*/
const SIGPIPE = 13;
/**
* Signal: real-time timer expired (terminate process).
*/
const SIGALRM = 14;
/**
* Signal: software termination signal (terminate process).
*/
const SIGTERM = 15;
/**
* Signal: urgent condition present on socket (discard signal).
*/
const SIGURG = 16;
/**
* Signal: stop, cannot be caught or ignored (stop proces).
*/
const SIGSTOP = 17;
/**
* Signal: stop signal generated from keyboard (stop process).
*/
const SIGTSTP = 18;
/**
* Signal: continue after stop (discard signal).
*/
const SIGCONT = 19;
/**
* Signal: child status has changed (discard signal).
*/
const SIGCHLD = 20;
/**
* Signal: background read attempted from control terminal (stop process).
*/
const SIGTTIN = 21;
/**
* Signal: background write attempted to control terminal (stop process).
*/
const SIGTTOU = 22;
/**
* Signal: I/O is possible on a descriptor, see fcntl(2) (discard signal).
*/
const SIGIO = 23;
/**
* Signal: cpu time limit exceeded, see setrlimit(2) (terminate process).
*/
const SIGXCPU = 24;
/**
* Signal: file size limit exceeded, see setrlimit(2) (terminate process).
*/
const SIGXFSZ = 25;
/**
* Signal: virtual time alarm, see setitimer(2) (terminate process).
*/
const SIGVTALRM = 26;
/**
* Signal: profiling timer alarm, see setitimer(2) (terminate process).
*/
const SIGPROF = 27;
/**
* Signal: Window size change (discard signal).
*/
const SIGWINCH = 28;
/**
* Signal: status request from keyboard (discard signal).
*/
const SIGINFO = 29;
/**
* Signal: User defined signal 1 (terminate process).
*/
const SIGUSR1 = 30;
/**
* Signal: User defined signal 2 (terminate process).
*/
const SIGUSR2 = 31;
/**
* Command name.
*/
protected $_command = null;
/**
* Command options (options => value, or input).
*/
protected $_options = [];
/**
* Current working directory.
*/
protected $_cwd = null;
/**
* Environment.
*/
protected $_environment = null;
/**
* Timeout.
*/
protected $_timeout = 30;
/**
* Descriptor.
*/
protected $_descriptors = [
0 => ['pipe', 'r'],
1 => ['pipe', 'w'],
2 => ['pipe', 'w'],
];
/**
* Pipe descriptors of the processus.
*/
protected $_pipes = null;
/**
* Seekability of pipes.
*/
protected $_seekable = [];
/**
* Start a processus.
*/
public function __construct(
string $command,
array $options = null,
array $descriptors = null,
string $cwd = null,
array $environment = null,
int $timeout = 30
) {
$this->setCommand($command);
if (null !== $options) {
$this->setOptions($options);
}
if (null !== $descriptors) {
$this->_descriptors = [];
foreach ($descriptors as $descriptor => $nature) {
if (isset($this->_descriptors[$descriptor])) {
throw new ConsoleException('Pipe descriptor %d already exists, cannot '.'redefine it.', 0, $descriptor);
}
$this->_descriptors[$descriptor] = $nature;
}
}
$this->setCwd($cwd ?: \getcwd());
if (null !== $environment) {
$this->setEnvironment($environment);
}
$this->setTimeout($timeout);
parent::__construct($this->getCommandLine(), null, true);
$this->getListener()->addIds(['input', 'output', 'timeout', 'start', 'stop']);
return;
}
/**
* Open the stream and return the associated resource.
*/
protected function &_open(string $streamName, StreamContext $context = null)
{
$out = @\proc_open(
$streamName,
$this->_descriptors,
$this->_pipes,
$this->getCwd(),
$this->getEnvironment()
);
if (false === $out) {
throw new ConsoleException('Something wrong happen when running %s.', 1, $streamName);
}
return $out;
}
/**
* Close the current stream.
*/
protected function _close(): bool
{
foreach ($this->_pipes as $pipe) {
@\fclose($pipe);
}
return (bool) @\proc_close($this->getStream());
}
/**
* Run the process and fire events (amongst start, stop, input, output and
* timeout).
* If an event returns false, it will close the current pipe.
* For a simple run without firing events, use the $this->open() method.
*/
public function run()
{
if (false === $this->isOpened()) {
$this->open();
} else {
$this->_close();
$this->_setStream($this->_open(
$this->getStreamName(),
$this->getStreamContext()
));
}
$this->getListener()->fire('start', new EventBucket());
$_read = [];
$_write = [];
$_except = [];
foreach ($this->_pipes as $p => $pipe) {
switch ($this->_descriptors[$p][1]) {
case 'r':
\stream_set_blocking($pipe, false);
$_write[] = $pipe;
break;
case 'w':
case 'a':
\stream_set_blocking($pipe, true);
$_read[] = $pipe;
break;
}
}
while (true) {
foreach ($_read as $i => $r) {
if (false === \is_resource($r)) {
unset($_read[$i]);
}
}
foreach ($_write as $i => $w) {
if (false === \is_resource($w)) {
unset($_write[$i]);
}
}
foreach ($_except as $i => $e) {
if (false === \is_resource($e)) {
unset($_except[$i]);
}
}
if (empty($_read) && empty($_write) && empty($_except)) {
break;
}
$read = $_read;
$write = $_write;
$except = $_except;
$select = \stream_select($read, $write, $except, $this->getTimeout());
if (0 === $select) {
$this->getListener()->fire('timeout', new EventBucket());
break;
}
foreach ($read as $i => $_r) {
$pipe = \array_search($_r, $this->_pipes);
$line = $this->readLine($pipe);
if (false === $line) {
$result = [false];
} else {
$result = $this->getListener()->fire(
'output',
new EventBucket([
'pipe' => $pipe,
'line' => $line,
])
);
}
if (true === \feof($_r) || \in_array(false, $result, true)) {
\fclose($_r);
unset($_read[$i]);
break;
}
}
foreach ($write as $j => $_w) {
$result = $this->getListener()->fire(
'input',
new EventBucket([
'pipe' => \array_search($_w, $this->_pipes),
])
);
if (true === \feof($_w) || \in_array(false, $result, true)) {
\fclose($_w);
unset($_write[$j]);
}
}
if (empty($_read)) {
break;
}
}
$this->getListener()->fire('stop', new EventBucket());
return;
}
/**
* Get pipe resource.
*/
protected function getPipe(int $pipe)
{
if (!isset($this->_pipes[$pipe])) {
throw new ConsoleException('Pipe descriptor %d does not exist, cannot read from it.', 2, $pipe);
}
return $this->_pipes[$pipe];
}
/**
* Check if a pipe is seekable or not.
*/
protected function isPipeSeekable(int $pipe): bool
{
if (!isset($this->_seekable[$pipe])) {
$_pipe = $this->getPipe($pipe);
$data = \stream_get_meta_data($_pipe);
$this->_seekable[$pipe] = $data['seekable'];
}
return $this->_seekable[$pipe];
}
/**
* Test for end-of-file.
*/
public function eof(int $pipe = 1): bool
{
return \feof($this->getPipe($pipe));
}
/**
* Read n characters.
*/
public function read(int $length, int $pipe = 1)
{
if (0 > $length) {
throw new ConsoleException('Length must be greater than 0, given %d.', 3, $length);
}
return \fread($this->getPipe($pipe), $length);
}
/**
* Alias of $this->read().
*/
public function readString(int $length, int $pipe = 1)
{
return $this->read($length, $pipe);
}
/**
* Read a character.
*/
public function readCharacter(int $pipe = 1)
{
return \fgetc($this->getPipe($pipe));
}
/**
* Read a boolean.
*/
public function readBoolean(int $pipe = 1)
{
return (bool) $this->read(1, $pipe);
}
/**
* Read an integer.
*/
public function readInteger(int $length = 1, int $pipe = 1)
{
return (int) $this->read($length, $pipe);
}
/**
* Read a float.
*/
public function readFloat(int $length = 1, int $pipe = 1)
{
return (float) $this->read($length, $pipe);
}
/**
* Read an array.
* Alias of the $this->scanf() method.
*/
public function readArray(string $format = null, int $pipe = 1)
{
return $this->scanf($format, $pipe);
}
/**
* Read a line.
*/
public function readLine(int $pipe = 1)
{
return \stream_get_line($this->getPipe($pipe), 1 << 15, "\n");
}
/**
* Read all, i.e. read as much as possible.
*/
public function readAll(int $offset = -1, int $pipe = 1)
{
$_pipe = $this->getPipe($pipe);
if (true === $this->isPipeSeekable($pipe)) {
$offset += \ftell($_pipe);
} else {
$offset = -1;
}
return \stream_get_contents($_pipe, -1, $offset);
}
/**
* Parse input from a stream according to a format.
*/
public function scanf(string $format, int $pipe = 1): array
{
return \fscanf($this->getPipe($pipe), $format);
}
/**
* Write n characters.
*/
public function write(string $string, int $length, int $pipe = 0)
{
if (0 > $length) {
throw new ConsoleException('Length must be greater than 0, given %d.', 4, $length);
}
return \fwrite($this->getPipe($pipe), $string, $length);
}
/**
* Write a string.
*/
public function writeString(string $string, int $pipe = 0)
{
$string = (string) $string;
return $this->write($string, \strlen($string), $pipe);
}
/**
* Write a character.
*/
public function writeCharacter(string $char, int $pipe = 0)
{
return $this->write((string) $char[0], 1, $pipe);
}
/**
* Write a boolean.
*/
public function writeBoolean(bool $boolean, int $pipe = 0)
{
return $this->write((string) (bool) $boolean, 1, $pipe);
}
/**
* Write an integer.
*/
public function writeInteger(int $integer, int $pipe = 0)
{
$integer = (string) (int) $integer;
return $this->write($integer, \strlen($integer), $pipe);
}
/**
* Write a float.
*/
public function writeFloat(float $float, int $pipe = 0)
{
$float = (string) (float) $float;
return $this->write($float, \strlen($float), $pipe);
}
/**
* Write an array.
*/
public function writeArray(array $array, int $pipe = 0)
{
$array = \var_export($array, true);
return $this->write($array, \strlen($array), $pipe);
}
/**
* Write a line.
*/
public function writeLine(string $line, int $pipe = 0)
{
if (false === $n = \strpos($line, "\n")) {
return $this->write($line."\n", \strlen($line) + 1, $pipe);
}
++$n;
return $this->write(\substr($line, 0, $n), $n, $pipe);
}
/**
* Write all, i.e. as much as possible.
*/
public function writeAll(string $string, int $pipe = 0)
{
return $this->write($string, \strlen($string), $pipe);
}
/**
* Truncate a file to a given length.
*/
public function truncate(int $size, int $pipe = 0): bool
{
return \ftruncate($this->getPipe($pipe), $size);
}
/**
* Get filename component of path.
*/
public function getBasename(): string
{
return \basename($this->getCommand());
}
/**
* Get directory name component of path.
*/
public function getDirname(): string
{
return \dirname($this->getCommand());
}
/**
* Get status.
*/
public function getStatus(): array
{
return \proc_get_status($this->getStream());
}
/**
* Get exit code (alias of $this->getStatus()['exitcode']);.
*/
public function getExitCode(): int
{
$handle = $this->getStatus();
return $handle['exitcode'];
}
/**
* Whether the processus have ended successfully.
*
* @return bool
*/
public function isSuccessful(): bool
{
return 0 === $this->getExitCode();
}
/**
* Terminate the process.
*
* Valid signals are self::SIGHUP, SIGINT, SIGQUIT, SIGABRT, SIGKILL,
* SIGALRM and SIGTERM.
*/
public function terminate(int $signal = self::SIGTERM): bool
{
return \proc_terminate($this->getStream(), $signal);
}
/**
* Set command name.
*/
protected function setCommand(string $command)
{
$old = $this->_command;
$this->_command = \escapeshellcmd($command);
return $old;
}
/**
* Get command name.
*/
public function getCommand()
{
return $this->_command;
}
/**
* Set command options.
*/
protected function setOptions(array $options): array
{
foreach ($options as &$option) {
$option = \escapeshellarg($option);
}
$old = $this->_options;
$this->_options = $options;
return $old;
}
/**
* Get options.
*/
public function getOptions(): array
{
return $this->_options;
}
/**
* Get command-line.
*/
public function getCommandLine(): string
{
$out = $this->getCommand();
foreach ($this->getOptions() as $key => $value) {
if (!\is_int($key)) {
$out .= ' '.$key.'='.$value;
} else {
$out .= ' '.$value;
}
}
return $out;
}
/**
* Set current working directory of the process.
*/
protected function setCwd(string $cwd)
{
$old = $this->_cwd;
$this->_cwd = $cwd;
return $old;
}
/**
* Get current working directory of the process.
*/
public function getCwd(): string
{
return $this->_cwd;
}
/**
* Set environment of the process.
*/
protected function setEnvironment(array $environment)
{
$old = $this->_environment;
$this->_environment = $environment;
return $old;
}
/**
* Get environment of the process.
*/
public function getEnvironment()
{
return $this->_environment;
}
/**
* Set timeout of the process.
*/
public function setTimeout(int $timeout)
{
$old = $this->_timeout;
$this->_timeout = $timeout;
return $old;
}
/**
* Get timeout of the process.
*/
public function getTimeout(): int
{
return $this->_timeout;
}
/**
* Set process title.
*/
public static function setTitle(string $title)
{
\cli_set_process_title($title);
}
/**
* Get process title.
*/
public static function getTitle()
{
return \cli_get_process_title();
}
/**
* Found the place of a binary.
*/
public static function locate(string $binary)
{
if (isset($_ENV['PATH'])) {
$separator = ':';
$path = &$_ENV['PATH'];
} elseif (isset($_SERVER['PATH'])) {
$separator = ':';
$path = &$_SERVER['PATH'];
} elseif (isset($_SERVER['Path'])) {
$separator = ';';
$path = &$_SERVER['Path'];
} else {
return null;
}
foreach (\explode($separator, $path) as $directory) {
if (true === \file_exists($out = $directory.\DIRECTORY_SEPARATOR.$binary)) {
return $out;
}
}
return null;
}
/**
* Quick process execution.
* Returns only the STDOUT.
*/
public static function execute(string $commandLine, bool $escape = true): string
{
if (true === $escape) {
$commandLine = \escapeshellcmd($commandLine);
}
return \rtrim(\shell_exec($commandLine) ?? '');
}
}