VersionControl\GitCommandBundle\GitCommands\GitCommand

Complexity

Total Complexity

46

Size/Duplication

Total Lines	444
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getGitUser()	0	3	1
A	runLocalCommand()	0	33	5
B	runCommand()	0	31	7
A	getGitPath()	0	3	1
A	setDispatcher()	0	5	1
A	getLogger()	0	3	1
A	getDispatcher()	0	3	1
A	setGitPath()	0	5	1
A	setSshProcess()	0	5	1
A	setLogger()	0	5	1
A	setStopwatch()	0	3	1
A	getGitEnvironment()	0	3	1
A	triggerGitAlterFilesEvent()	0	4	1
A	runRemoteCommand()	0	26	1
A	logCommand()	0	15	3
A	setGitEnvironment()	0	6	1
A	setSftpProcess()	0	5	1
B	command()	0	38	11
A	getLastExitStatus()	0	7	2
A	getSftpProcess()	0	5	1
A	setCache()	0	3	1
A	setGitUser()	0	3	1
A	overRideGitEnvironment()	0	6	1

<?php
/*
 * This file is part of the GitCommandBundle package.
 *
 * (c) Paul Schweppe <paulschweppe@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace VersionControl\GitCommandBundle\GitCommands;

use Doctrine\Common\Cache\CacheProvider;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Process\Exception\LogicException;
use Symfony\Component\Process\Exception\RuntimeException;
use Symfony\Component\Process\Process;
use Symfony\Component\Process\ProcessBuilder;
use Symfony\Component\Stopwatch\Stopwatch;
use VersionControl\GitCommandBundle\GitCommands\Command\GitUserInterface;
use VersionControl\GitCommandBundle\Service\SshProcessInterface;
use VersionControl\GitCommandBundle\Service\SftpProcessInterface;
use VersionControl\GitCommandBundle\GitCommands\Exception\InvalidArgumentException;
use VersionControl\GitCommandBundle\Logger\GitCommandLogger;
use VersionControl\GitCommandBundle\Event\GitAlterFilesEvent;
use VersionControl\GitCommandBundle\GitCommands\Exception\RunGitCommandException;

/**
 * @author Paul Schweppe <paulschweppe@gmail.com>
 */
class GitCommand
{
    /**
     * @var string
     */
    protected $gitPath;

    /**
     * @var GitUserInterface
     */
    private $gitUser;

    /**
     * The git gitEnvironment entity.
     *
     * @var GitEnvironmentInterface
     */
    protected $gitEnvironment;

    /**
     * @var EventDispatcherInterface
     */
    public $dispatcher;

    /**
     * Git Command Logger.
     *
     * @var GitCommandLogger
     */
    protected $logger;

    /**
     * Symfony's debugging Stopwatch.
     *
     * @var Stopwatch|null
     */
    private $stopwatch;

    /**
     * SSH Process.
     *
     * @var SshProcessInterface
     */
    private $sshProcess;

    /**
     * Sftp Process.
     *
     * @var SftpProcessInterface
     */
    private $sftpProcess;

    /**
     * Cache in memory.
     *
     * @var CacheProvider
     */
    private $cache;

    /**
     * Last Exit code of local command.
     *
     * @var int
     */
    private $exitCode;

    /**
     * Wrapper function to run shell commands. Supports local and remote commands
     * depending on the gitEnvironment details.
     *
     * @param string $command command to run
     * @param bool $cacheCommand command to run
     * @param bool $trim do not trim response. Maybe need for some command responses
     *
     * @return string Result of command
     *
     * @throws RuntimeException
     * @throws LogicException
     * @throws \RuntimeException
     * @throws RunGitCommandException
     */
    public function runCommand($command, $cacheCommand = true, $trim = true): string
    {
        if ($this->stopwatch) {
            $this->stopwatch->start('git_request', 'version_control');
        }

        $fullCommand = sprintf('cd %s && %s', $this->gitPath, $command);
        $cacheId = md5($this->gitEnvironment->getId() . $fullCommand);

        if ($this->gitEnvironment->getSsh() === false) {
            //Run local commands
            $start = microtime(true);
            $response = $this->runLocalCommand($command);

            $this->logCommand($fullCommand, 'local', array(), $start);

            return $trim === true ? trim($response) : $response;
        }

        //Run remote command over ssh
        if ($cacheCommand === true) {
            $response = $this->cache->fetch($cacheId);
            if ($response === false) {
                $response = $this->runRemoteCommand($fullCommand);
                $this->cache->save($cacheId, $response);
            }
        } else {
            $response = $this->runRemoteCommand($fullCommand);
        }

        return $trim === true ? trim($response) : $response;
    }

    /**
     * Run remote command over ssh.
     *
     * @param string $fullCommand
     *
     * @return string Commands response
     */
    private function runRemoteCommand($fullCommand): string
    {
        $start = microtime(true);

        $this->sshProcess->run(
            array($fullCommand),
            $this->gitEnvironment->getHost(),
            $this->gitEnvironment->getUsername(),
            22,
            $this->gitEnvironment->getPassword(),
            null,
            $this->gitEnvironment->getPrivateKey(),
            $this->gitEnvironment->getPrivateKeyPassword()
        );

        $this->logCommand(
            $fullCommand,
            'remote',
            array('host' => $this->gitEnvironment->getHost()),
            $start,
            $this->sshProcess->getStdout(),
            $this->sshProcess->getStderr(),
            $this->sshProcess->getExitStatus()

It seems like $this->sshProcess->getExitStatus() can also be of type false; however, parameter $exitStatus of VersionControl\GitCommandBundle\GitCommands\GitCommand::logCommand() does only seem to accept integer, maybe add an additional type check?

        );

        return $this->sshProcess->getStdout();
    }

    /**
     * Run local command.
     *
     * @param string|array $command
     *
     * @return string Commands response
     * @throws RuntimeException
     * @throws RunGitCommandException
     * @throws LogicException
     * @throws RunGitCommandException
     */
    private function runLocalCommand($command)
    {
        $fullCommand = sprintf('cd %s && %s', $this->gitPath, $command);

It seems like $command can also be of type array; however, parameter $args of sprintf() does only seem to accept string, maybe add an additional type check?

        //Run local commands
        if (is_array($command)) {
            //$finalCommands = array_merge(array('cd',$this->gitPath,'&&'),$command);
            $builder = new ProcessBuilder($command);
            $builder->setPrefix('cd ' . $this->gitPath . ' && ');
            $process = $builder->getProcess();
        } else {
            $process = new Process($fullCommand);
        }

        //Run Proccess
        $process->run();

        $this->exitCode = $process->getExitCode();

        $response = '';
        // executes after the command finishes
        if ($process->isSuccessful()) {
            $response = $process->getOutput();
            if (trim($process->getErrorOutput()) !== '') {
                $response = $process->getErrorOutput();
            }
        } else {
            if (trim($process->getErrorOutput()) !== '') {
                throw new RunGitCommandException($process->getErrorOutput());
            }
        }

        return $response;
    }

    public function getLastExitStatus()
    {
        if ($this->gitEnvironment->getSsh() === true) {
            return $this->sshProcess->getExitStatus();
        }

        return $this->exitCode;
    }

    /**
     * Gets the git path.
     *
     * @return string
     */
    public function getGitPath(): string
    {
        return $this->gitPath;
    }

    /**
     * Sets the git path.
     *
     * @param string $gitPath
     *
     * @return GitCommand
     */
    protected function setGitPath(string $gitPath)
    {
        $this->gitPath = rtrim(trim($gitPath), DIRECTORY_SEPARATOR);

        return $this;
    }

    /**
     * Sets the Git Environment.
     *
     * @param GitEnvironmentInterface $gitEnvironment
     *
     * @return GitCommand
     */
    public function setGitEnvironment(GitEnvironmentInterface $gitEnvironment)
    {
        $this->gitEnvironment = $gitEnvironment;
        $this->setGitPath($this->gitEnvironment->getPath());

        return $this;
    }

    /**
     * Allows you to override the git Environment.
     *
     * @param GitEnvironmentInterface $gitEnvironment
     *
     * @return GitCommand
     */
    public function overRideGitEnvironment(GitEnvironmentInterface $gitEnvironment)
    {
        $this->gitEnvironment = $gitEnvironment;
        $this->setGitPath($this->gitEnvironment->getPath());

        return $this;
    }

    /**
     * Gets git Environment.
     *
     * @return GitEnvironmentInterface
     */
    public function getGitEnvironment()
    {
        return $this->gitEnvironment;
    }

    public function getDispatcher()
    {
        return $this->dispatcher;
    }

    public function setDispatcher(EventDispatcherInterface $dispatcher)
    {
        $this->dispatcher = $dispatcher;

        return $this;
    }

    public function triggerGitAlterFilesEvent($eventName = 'git.alter_files')
    {
        $event = new GitAlterFilesEvent($this->gitEnvironment, array());
        $this->dispatcher->dispatch($eventName, $event);
    }

    public function getLogger()
    {
        return $this->logger;
    }

    public function setLogger(GitCommandLogger $logger)
    {
        $this->logger = $logger;

        return $this;
    }

    /**
     * Sets a stopwatch instance for debugging purposes.
     *
     * @param Stopwatch $stopwatch
     */
    public function setStopwatch(Stopwatch $stopwatch = null)
    {
        $this->stopwatch = $stopwatch;
    }

    /**
     * Log the query if we have an instance of ElasticaLogger.
     *
     * @param string $command
     * @param string $method
     * @param array $data
     * @param int $start
     * @param string $response
     * @param string $error
     * @param int $exitStatus
     */
    public function logCommand(
        $command,
        $method,
        $data,
        $start,
        $response = '',
        $error = '',
        $exitStatus = 0
    ) {
        if (!$this->logger || !$this->logger instanceof GitCommandLogger) {
            return;
        }
        $time = microtime(true) - $start;

        $this->logger->logCommand($command, $method, $data, $time, $response, $error, $exitStatus);
    }

    /**
     * Sets the SSH Process.
     *
     * @param SshProcessInterface $sshProcess
     *
     * @return GitCommand
     */
    public function setSshProcess(SshProcessInterface $sshProcess)
    {
        $this->sshProcess = $sshProcess;

        return $this;
    }

    /**
     * Sets the SFTP Process.
     *
     * @param SftpProcessInterface $sftpProcess
     *
     * @return GitCommand
     */
    public function setSftpProcess(SftpProcessInterface $sftpProcess)
    {
        $this->sftpProcess = $sftpProcess;

        return $this;
    }

    /**
     * Gets the SFTP Process.
     *
     * @return SftpProcessInterface
     */
    public function getSftpProcess()
    {
        $this->sftpProcess->setGitEnviroment($this->gitEnvironment);

        return $this->sftpProcess;
    }

    public function setCache(CacheProvider $cache)
    {
        $this->cache = $cache;
    }

    /**
     * Get git command groups.
     *
     * @param string $name
     *
     * @return Command\GitBranchCommand|Command\GitCommitCommand|Command\GitDiffCommand|Command\GitFilesCommand|Command\GitInitCommand|Command\GitLogCommand|Command\GitTagCommand
     *
     * @throws InvalidArgumentException
     */
    public function command($name)
    {
        switch (trim($name)) {
            case 'branch':
                $command = new Command\GitBranchCommand($this);
                break;
            case 'tag':
                $command = new Command\GitTagCommand($this);
                break;
            case 'commit':
                $command = new Command\GitCommitCommand($this);
                break;
            case 'diff':
                $command = new Command\GitDiffCommand($this);
                break;
            case 'files':
                $command = new Command\GitFilesCommand($this);
                break;
            case 'init':
                $command = new Command\GitInitCommand($this);
                break;
            case 'log':
                $command = new Command\GitLogCommand($this);
                break;
            case 'status':
                $command = new Command\GitStatusCommand($this);
                break;
            case 'sync':
                $command = new Command\GitSyncCommand($this);
                break;
            case 'undo':
                $command = new Command\GitUndoCommand($this);
                break;
            default:
                throw new InvalidArgumentException(sprintf('Unknown command instance called: "%s"', $name));
        }

        return $command;
    }

    /**
     * @return GitUserInterface
     */
    public function getGitUser(): GitUserInterface
    {
        return $this->gitUser;
    }

    /**
     * @param GitUserInterface $gitUser
     */
    public function setGitUser(GitUserInterface $gitUser): void
    {
        $this->gitUser = $gitUser;
    }
}