php-censor/src/PHPCensor/Helper/BaseCommandExecutor.php

<?php

namespace PHPCensor\Helper;

use Exception;
use PHPCensor\Logging\BuildLogger;
use Psr\Log\LogLevel;

/**
 * Handles running system commands with variables.
 */
abstract class BaseCommandExecutor implements CommandExecutorInterface
{
    /**
     * @var BuildLogger
     */
    protected $logger;

    /**
     * @var bool
     */
    protected $quiet;

    /**
     * @var bool
     */
    protected $verbose;

    protected $lastOutput;
    protected $lastError;

    public $logExecOutput = true;

    /**
     * The path which findBinary will look in.
     * @var string
     */
    protected $rootDir;

    /**
     * Current build path
     * @var string
     */
    protected $buildPath;

    /**
     * @param BuildLogger $logger
     * @param string      $rootDir
     * @param bool        $quiet
     * @param bool        $verbose
     */
    public function __construct(BuildLogger $logger, $rootDir, &$quiet = false, &$verbose = false)
    {
        $this->logger     = $logger;
        $this->quiet      = $quiet;
        $this->verbose    = $verbose;
        $this->lastOutput = [];
        $this->rootDir    = $rootDir;
    }

    /**
     * Executes shell commands.
     * 
     * @param array $args
     * 
     * @return bool Indicates success
     */
    public function executeCommand($args = [])
    {
        $this->lastOutput = [];

        $this->logger->logDebug('Args: ' . json_encode($args));

        $command = call_user_func_array('sprintf', $args);

        $this->logger->logDebug('Command: ' . $command);

        if ($this->quiet) {
            $this->logger->log('Executing: ' . $command);
        }

        $status = 0;
        $descriptorSpec = [
            0 => ["pipe", "r"], // stdin
            1 => ["pipe", "w"], // stdout
            2 => ["pipe", "w"], // stderr
        ];

        $pipes   = [];
        $process = proc_open($command, $descriptorSpec, $pipes, $this->buildPath, null);

        $this->lastOutput = '';
        $this->lastError  = '';
        
        if (is_resource($process)) {
            fclose($pipes[0]);

            list($this->lastOutput, $this->lastError) = $this->readAlternating([$pipes[1], $pipes[2]]);

            $status = proc_close($process);
        }

        $this->lastOutput = array_filter(explode(PHP_EOL, $this->lastOutput));

        $shouldOutput = ($this->logExecOutput && ($this->verbose || $status != 0));

        if ($shouldOutput && !empty($this->lastOutput)) {
            $this->logger->log($this->lastOutput);
        }

        if (!empty($this->lastError)) {
            $this->logger->log("\033[0;31m" . $this->lastError . "\033[0m", LogLevel::ERROR);
        }

        $rtn = false;
        if ($status == 0) {
            $rtn = true;
        }

        $this->logger->logDebug('Execution status: ' . $status);

        return $rtn;
    }

    /**
     * Reads from array of streams as data becomes available.
     * @param array     $descriptors
     * @return string[] data read from each descriptor
     */
    private function readAlternating(array $descriptors)
    {
        $outputs = [];
        foreach ($descriptors as $key => $descriptor) {
            stream_set_blocking($descriptor, false);
            $outputs[$key] = '';
        }
        do {
            $read = $descriptors;
            $write = null;
            $except = null;
            stream_select($read, $write, $except, null);
            foreach ($read as $descriptor) {
                $key = array_search($descriptor, $descriptors);
                if (feof($descriptor)) {
                    fclose($descriptor);
                    unset($descriptors[$key]);
                } else {
                    $outputs[$key] .= fgets($descriptor);
                }
            }
        } while (count($descriptors) > 0);
        return $outputs;
    }

    /**
     * Returns the output from the last command run.
     */
    public function getLastOutput()
    {
        return implode(PHP_EOL, $this->lastOutput);
    }

    /**
     * Returns the stderr output from the last command run.
     */
    public function getLastError()
    {
        return $this->lastError;
    }

    /**
     * Find a binary required by a plugin
     * 
     * @param string $binary
     * @param bool   $quiet
     * 
     * @throws Exception
     * 
     * @return null|string
     */
    public function findBinary($binary, $quiet = false)
    {
        $composerBin = $this->getComposerBinDir(realpath($this->buildPath));

        if (is_string($binary)) {
            $binary = [$binary];
        }

        foreach ($binary as $bin) {
            $this->logger->logDebug(sprintf('Looking for binary: %s', $bin));

            if (is_dir($composerBin) && is_file($composerBin . DIRECTORY_SEPARATOR . $bin)) {
                $this->logger->logDebug(sprintf('Found in %s: %s', $composerBin, $bin));

                return $composerBin . DIRECTORY_SEPARATOR . $bin;
            }

            if (is_file($this->rootDir . DIRECTORY_SEPARATOR . $bin)) {
                $this->logger->logDebug(sprintf('Found in %s: %s', 'root', $bin));

                return $this->rootDir . DIRECTORY_SEPARATOR . $bin;
            }

            if (is_file($this->rootDir . 'vendor' . DIRECTORY_SEPARATOR . 'bin' . DIRECTORY_SEPARATOR . $bin)) {
                $this->logger->logDebug(sprintf('Found in %s: %s', 'vendor/bin', $bin));

                return $this->rootDir . 'vendor' . DIRECTORY_SEPARATOR . 'bin' . DIRECTORY_SEPARATOR . $bin;
            }

            $findCmdResult = $this->findGlobalBinary($bin);
            if (is_file($findCmdResult)) {
                $this->logger->logDebug(sprintf('Found in %s: %s', '', $bin));

                return $findCmdResult;
            }
        }

        if ($quiet) {
            return null;
        }

        throw new Exception(sprintf('Could not find %s', implode('/', $binary)));
    }

    /**
     * Find a binary which is installed globally on the system
     * @param string $binary
     * @return null|string
     */
    abstract protected function findGlobalBinary($binary);

    /**
     * Try to load the composer.json file in the building project
     * If the bin-dir is configured, return the full path to it
     * @param string $path Current build path
     * @return string|null
     */
    public function getComposerBinDir($path)
    {
        if (is_dir($path)) {
            $composer = $path . DIRECTORY_SEPARATOR . 'composer.json';
            if (is_file($composer)) {
                $json = json_decode(file_get_contents($composer));

                if (isset($json->config->{"bin-dir"})) {
                    return $path . DIRECTORY_SEPARATOR . $json->config->{"bin-dir"};
                } elseif (is_dir($path . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'bin')) {
                    return $path  . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'bin';
                }
            }
        }
        return null;
    }

    /**
     * Set the buildPath property.
     * @param string $path
     */
    public function setBuildPath($path)
    {
        $this->buildPath = $path;
    }
}