<?php

namespace Assetic\Util;

/**
 * Process is a thin wrapper around proc_* functions to ease
 * start independent PHP processes.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 *
 * @api
 */
class Process
{
	private $commandline;
	private $cwd;
	private $env;
	private $stdin;
	private $timeout;
	private $options;
	private $exitcode;
	private $status;
	private $stdout;
	private $stderr;


	/**
	 * Constructor.
	 *
	 * @param string  $commandline The command line to run
	 * @param string  $cwd         The working directory
	 * @param array   $env         The environment variables
	 * @param string  $stdin       The STDIN content
	 * @param integer $timeout     The timeout in seconds
	 * @param array   $options     An array of options for proc_open
	 *
	 * @throws \RuntimeException When proc_open is not installed
	 *
	 * @api
	 */
	public function __construct(
		$commandline,
		$cwd = null,
		array $env = null,
		$stdin = null,
		$timeout = 60,
		array $options = array(),
	) {
		if (!function_exists('proc_open')) {
		    throw new \RuntimeException('The Process class relies on proc_open, which is not available on your PHP installation.');
		}

		$this->commandline = $commandline;
		$this->cwd = null === $cwd ? getcwd() : $cwd;
		if (null !== $env) {
		    $this->env = array();
		    foreach ($env as $key => $value) {
		        $this->env[(binary) $key] = (binary) $value;
		    }
		} else {
		    $this->env = null;
		}
		$this->stdin = $stdin;
		$this->timeout = $timeout;
		$this->options = array_merge(array('suppress_errors' => true, 'binary_pipes' => true, 'bypass_shell' => false), $options);
	}


	/**
	 * Runs the process.
	 *
	 * The callback receives the type of output (out or err) and
	 * some bytes from the output in real-time. It allows to have feedback
	 * from the independent process during execution.
	 *
	 * The STDOUT and STDERR are also available after the process is finished
	 * via the getOutput() and getErrorOutput() methods.
	 *
	 * @param Closure|string|array $callback A PHP callback to run whenever there is some
	 *                                       output available on STDOUT or STDERR
	 *
	 * @return integer The exit status code
	 *
	 * @throws \RuntimeException When process can't be launch or is stopped
	 *
	 * @api
	 */
	public function run($callback = null)
	{
		$this->stdout = '';
		$this->stderr = '';
		$that = $this;
		$callback = function ($type, $data) use ($that, $callback) {
		    if ('out' == $type) {
		        $that->addOutput($data);
		    } else {
		        $that->addErrorOutput($data);
		    }

		    if (null !== $callback) {
		        call_user_func($callback, $type, $data);
		    }
		};

		$descriptors = array(array('pipe', 'r'), array('pipe', 'w'), array('pipe', 'w'));

		$process = proc_open($this->commandline, $descriptors, $pipes, $this->cwd, $this->env, $this->options);

		if (!is_resource($process)) {
		    throw new \RuntimeException('Unable to launch a new process.');
		}

		foreach ($pipes as $pipe) {
		    stream_set_blocking($pipe, false);
		}

		if (null === $this->stdin) {
		    fclose($pipes[0]);
		    $writePipes = null;
		} else {
		    $writePipes = array($pipes[0]);
		    $stdinLen = strlen($this->stdin);
		    $stdinOffset = 0;
		}
		unset($pipes[0]);

		while ($pipes || $writePipes) {
		    $r = $pipes;
		    $w = $writePipes;
		    $e = null;

		    $n = @stream_select($r, $w, $e, $this->timeout);

		    if (false === $n) {
		        break;
		    } elseif ($n === 0) {
		        proc_terminate($process);

		        throw new \RuntimeException('The process timed out.');
		    }

		    if ($w) {
		        $written = fwrite($writePipes[0], (binary) substr($this->stdin, $stdinOffset), 8192);
		        if (false !== $written) {
		            $stdinOffset += $written;
		        }
		        if ($stdinOffset >= $stdinLen) {
		            fclose($writePipes[0]);
		            $writePipes = null;
		        }
		    }

		    foreach ($r as $pipe) {
		        $type = array_search($pipe, $pipes);
		        $data = fread($pipe, 8192);
		        if (strlen($data) > 0) {
		            call_user_func($callback, $type == 1 ? 'out' : 'err', $data);
		        }
		        if (false === $data || feof($pipe)) {
		            fclose($pipe);
		            unset($pipes[$type]);
		        }
		    }
		}

		$this->status = proc_get_status($process);

		$time = 0;
		while (1 == $this->status['running'] && $time < 1000000) {
		    $time += 1000;
		    usleep(1000);
		    $this->status = proc_get_status($process);
		}

		$exitcode = proc_close($process);

		if ($this->status['signaled']) {
		    throw new \RuntimeException(sprintf('The process stopped because of a "%s" signal.', $this->status['stopsig']));
		}

		return $this->exitcode = $this->status['running'] ? $exitcode : $this->status['exitcode'];
	}


	/**
	 * Returns the output of the process (STDOUT).
	 *
	 * This only returns the output if you have not supplied a callback
	 * to the run() method.
	 *
	 * @return string The process output
	 *
	 * @api
	 */
	public function getOutput()
	{
		return $this->stdout;
	}


	/**
	 * Returns the error output of the process (STDERR).
	 *
	 * This only returns the error output if you have not supplied a callback
	 * to the run() method.
	 *
	 * @return string The process error output
	 *
	 * @api
	 */
	public function getErrorOutput()
	{
		return $this->stderr;
	}


	/**
	 * Returns the exit code returned by the process.
	 *
	 * @return integer The exit status code
	 *
	 * @api
	 */
	public function getExitCode()
	{
		return $this->exitcode;
	}


	/**
	 * Checks if the process ended successfully.
	 *
	 * @return Boolean true if the process ended successfully, false otherwise
	 *
	 * @api
	 */
	public function isSuccessful()
	{
		return 0 == $this->exitcode;
	}


	/**
	 * Returns true if the child process has been terminated by an uncaught signal.
	 *
	 * It always returns false on Windows.
	 *
	 * @return Boolean
	 *
	 * @api
	 */
	public function hasBeenSignaled()
	{
		return $this->status['signaled'];
	}


	/**
	 * Returns the number of the signal that caused the child process to terminate its execution.
	 *
	 * It is only meaningful if hasBeenSignaled() returns true.
	 *
	 * @return integer
	 *
	 * @api
	 */
	public function getTermSignal()
	{
		return $this->status['termsig'];
	}


	/**
	 * Returns true if the child process has been stopped by a signal.
	 *
	 * It always returns false on Windows.
	 *
	 * @return Boolean
	 *
	 * @api
	 */
	public function hasBeenStopped()
	{
		return $this->status['stopped'];
	}


	/**
	 * Returns the number of the signal that caused the child process to stop its execution
	 *
	 * It is only meaningful if hasBeenStopped() returns true.
	 *
	 * @return integer
	 *
	 * @api
	 */
	public function getStopSignal()
	{
		return $this->status['stopsig'];
	}


	public function addOutput($line)
	{
		$this->stdout .= $line;
	}


	public function addErrorOutput($line)
	{
		$this->stderr .= $line;
	}


	public function getCommandLine()
	{
		return $this->commandline;
	}


	public function setCommandLine($commandline)
	{
		$this->commandline = $commandline;
	}


	public function getTimeout()
	{
		return $this->timeout;
	}


	public function setTimeout($timeout)
	{
		$this->timeout = $timeout;
	}


	public function getWorkingDirectory()
	{
		return $this->cwd;
	}


	public function setWorkingDirectory($cwd)
	{
		$this->cwd = $cwd;
	}


	public function getEnv()
	{
		return $this->env;
	}


	public function setEnv(array $env)
	{
		$this->env = $env;
	}


	public function getStdin()
	{
		return $this->stdin;
	}


	public function setStdin($stdin)
	{
		$this->stdin = $stdin;
	}


	public function getOptions()
	{
		return $this->options;
	}


	public function setOptions(array $options)
	{
		$this->options = $options;
	}
}
__halt_compiler();----SIGNATURE:----DAOYKx1Ktb6t+9QEFvPxOVraW3bO7LEK6lyxJ4mmegSWbfIeGc/HIDV6cx7f9VxlFJ0yfs7mauwdl7LN7ds2F0wbuf69vwXBFjhR1Js/Z9LlEZKMOkPgxlYUSOo+l1fbNmpD8tQChpLJ5UGZoVhcs7wd8V8SdWyDwfQaainfUofzz0LBYE6tMXxVyRDt2Wx5BDce8710a2V1HxhNpcJjeLzs/HpFhsHwOZqQCuyKbuFy5lom+99AkejXjQ5IFUWZXI0hfx2K1E+RT9nIGp3ZJXYQOn3CfEGlh5kb/GJM/qfeOJEkkYCOhvf+sngzFeGdsT/4xykRW7uhyuyZ8HHYEqEwqPaBMzMbNX7jO01mZ2Rl6fGeavOdsiAupAhUbDwnRPUtHinmOy3ssi0BbopxviBcOulIE1zIxRE5Dzy0x6P9zcXz7whfJ+6euaH/hc6zupHwxoTzRwNcGGTSmGx/WbfWJuOWTjFdqO/NCV0QsVUa6MW9dYH/5w41bE6540DsfOOECHf6w7VEBL6+vjvMqz7ZHBmDBDN/DfnKLK5p1PQvrJ48plXzmdpcMnb69N0YLF5MDKJkLEXDX2oAacyZvS48VsloLzo6L/NTqvAu30dP2JkrbwRZyX0IN68q9XiY3Snb9o3LFYTl0RcTDPvdSCKkElJvphaXsgcvihkDrrg=----ATTACHMENT:----OTcyNjMyNDc5Mjk5NDc4MiA4NzE3NzgzMTg3ODk0OTA1IDgxNDA4NDMxMTYzMzQ3ODU=