class WindowsPipes in Zircon Profile 8
Same name and namespace in other branches
- 8.0 vendor/symfony/process/Pipes/WindowsPipes.php \Symfony\Component\Process\Pipes\WindowsPipes
WindowsPipes implementation uses temporary files as handles.
@author Romain Neutron <imprec@gmail.com>
@internal
Hierarchy
- class \Symfony\Component\Process\Pipes\AbstractPipes implements PipesInterface
- class \Symfony\Component\Process\Pipes\WindowsPipes
Expanded class hierarchy of WindowsPipes
See also
https://bugs.php.net/bug.php?id=51800
https://bugs.php.net/bug.php?id=65650
1 file declares its use of WindowsPipes
- Process.php in vendor/
symfony/ process/ Process.php
File
- vendor/
symfony/ process/ Pipes/ WindowsPipes.php, line 27
Namespace
Symfony\Component\Process\PipesView source
class WindowsPipes extends AbstractPipes {
/** @var array */
private $files = array();
/** @var array */
private $fileHandles = array();
/** @var array */
private $readBytes = array(
Process::STDOUT => 0,
Process::STDERR => 0,
);
/** @var bool */
private $disableOutput;
public function __construct($disableOutput, $input) {
$this->disableOutput = (bool) $disableOutput;
if (!$this->disableOutput) {
// Fix for PHP bug #51800: reading from STDOUT pipe hangs forever on Windows if the output is too big.
// Workaround for this problem is to use temporary files instead of pipes on Windows platform.
//
// @see https://bugs.php.net/bug.php?id=51800
$this->files = array(
Process::STDOUT => tempnam(sys_get_temp_dir(), 'out_sf_proc'),
Process::STDERR => tempnam(sys_get_temp_dir(), 'err_sf_proc'),
);
foreach ($this->files as $offset => $file) {
if (false === $file || false === ($this->fileHandles[$offset] = fopen($file, 'rb'))) {
throw new RuntimeException('A temporary file could not be opened to write the process output to, verify that your TEMP environment variable is writable');
}
}
}
if (is_resource($input)) {
$this->input = $input;
}
else {
$this->inputBuffer = $input;
}
}
public function __destruct() {
$this
->close();
$this
->removeFiles();
}
/**
* {@inheritdoc}
*/
public function getDescriptors() {
if ($this->disableOutput) {
$nullstream = fopen('NUL', 'c');
return array(
array(
'pipe',
'r',
),
$nullstream,
$nullstream,
);
}
// We're not using pipe on Windows platform as it hangs (https://bugs.php.net/bug.php?id=51800)
// We're not using file handles as it can produce corrupted output https://bugs.php.net/bug.php?id=65650
// So we redirect output within the commandline and pass the nul device to the process
return array(
array(
'pipe',
'r',
),
array(
'file',
'NUL',
'w',
),
array(
'file',
'NUL',
'w',
),
);
}
/**
* {@inheritdoc}
*/
public function getFiles() {
return $this->files;
}
/**
* {@inheritdoc}
*/
public function readAndWrite($blocking, $close = false) {
$this
->write($blocking, $close);
$read = array();
$fh = $this->fileHandles;
foreach ($fh as $type => $fileHandle) {
if (0 !== fseek($fileHandle, $this->readBytes[$type])) {
continue;
}
$data = '';
$dataread = null;
while (!feof($fileHandle)) {
if (false !== ($dataread = fread($fileHandle, self::CHUNK_SIZE))) {
$data .= $dataread;
}
}
if (0 < ($length = strlen($data))) {
$this->readBytes[$type] += $length;
$read[$type] = $data;
}
if (false === $dataread || true === $close && feof($fileHandle) && '' === $data) {
fclose($this->fileHandles[$type]);
unset($this->fileHandles[$type]);
}
}
return $read;
}
/**
* {@inheritdoc}
*/
public function areOpen() {
return (bool) $this->pipes && (bool) $this->fileHandles;
}
/**
* {@inheritdoc}
*/
public function close() {
parent::close();
foreach ($this->fileHandles as $handle) {
fclose($handle);
}
$this->fileHandles = array();
}
/**
* Creates a new WindowsPipes instance.
*
* @param Process $process The process
* @param $input
*
* @return WindowsPipes
*/
public static function create(Process $process, $input) {
return new static($process
->isOutputDisabled(), $input);
}
/**
* Removes temporary files.
*/
private function removeFiles() {
foreach ($this->files as $filename) {
if (file_exists($filename)) {
@unlink($filename);
}
}
$this->files = array();
}
/**
* Writes input to stdin.
*
* @param bool $blocking
* @param bool $close
*/
private function write($blocking, $close) {
if (empty($this->pipes)) {
return;
}
$this
->unblock();
$r = null !== $this->input ? array(
'input' => $this->input,
) : null;
$w = isset($this->pipes[0]) ? array(
$this->pipes[0],
) : null;
$e = null;
// let's have a look if something changed in streams
if (false === ($n = @stream_select($r, $w, $e, 0, $blocking ? Process::TIMEOUT_PRECISION * 1000000.0 : 0))) {
// if a system call has been interrupted, forget about it, let's try again
// otherwise, an error occurred, let's reset pipes
if (!$this
->hasSystemCallBeenInterrupted()) {
$this->pipes = array();
}
return;
}
// nothing has changed
if (0 === $n) {
return;
}
if (null !== $w && 0 < count($r)) {
$data = '';
while ($dataread = fread($r['input'], self::CHUNK_SIZE)) {
$data .= $dataread;
}
$this->inputBuffer .= $data;
if (false === $data || true === $close && feof($r['input']) && '' === $data) {
// no more data to read on input resource
// use an empty buffer in the next reads
$this->input = null;
}
}
if (null !== $w && 0 < count($w)) {
while (strlen($this->inputBuffer)) {
$written = fwrite($w[0], $this->inputBuffer, 2 << 18);
if ($written > 0) {
$this->inputBuffer = (string) substr($this->inputBuffer, $written);
}
else {
break;
}
}
}
// no input to read on resource, buffer is empty and stdin still open
if ('' === $this->inputBuffer && null === $this->input && isset($this->pipes[0])) {
fclose($this->pipes[0]);
unset($this->pipes[0]);
}
}
}
Members
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
AbstractPipes:: |
private | property | @var bool | |
AbstractPipes:: |
protected | property | @var resource|null | |
AbstractPipes:: |
protected | property | @var string | |
AbstractPipes:: |
public | property | @var array | |
AbstractPipes:: |
protected | function | Returns true if a system call has been interrupted. | |
AbstractPipes:: |
protected | function | Unblocks streams. | |
PipesInterface:: |
constant | |||
WindowsPipes:: |
private | property | @var bool | |
WindowsPipes:: |
private | property | @var array | |
WindowsPipes:: |
private | property | @var array | |
WindowsPipes:: |
private | property | @var array | |
WindowsPipes:: |
public | function |
Returns if the current state has open file handles or pipes. Overrides PipesInterface:: |
|
WindowsPipes:: |
public | function |
Closes file handles and pipes. Overrides AbstractPipes:: |
|
WindowsPipes:: |
public static | function | Creates a new WindowsPipes instance. | |
WindowsPipes:: |
public | function |
Returns an array of descriptors for the use of proc_open. Overrides PipesInterface:: |
|
WindowsPipes:: |
public | function |
Returns an array of filenames indexed by their related stream in case these pipes use temporary files. Overrides PipesInterface:: |
|
WindowsPipes:: |
public | function |
Reads data in file handles and pipes. Overrides PipesInterface:: |
|
WindowsPipes:: |
private | function | Removes temporary files. | |
WindowsPipes:: |
private | function | Writes input to stdin. | |
WindowsPipes:: |
public | function | ||
WindowsPipes:: |
public | function |