Bencagri\Artisan\Deployer\Deployer\AbstractDeployer

Complexity

Total Complexity

27

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	getServers()	0	3	1
A	doRollback()	0	23	2
A	beforeFinishingDeploy()	0	3	1
A	beforeStartingDeploy()	0	3	1
A	beforeFinishingRollback()	0	3	1
A	checkRequirements()	0	12	3
A	getCommandEnvVars()	0	6	2
A	getConfig()	0	3	1
B	doDeploy()	0	24	2
A	runLocal()	0	5	1
A	initialize()	0	12	1
A	beforeCancelingRollback()	0	3	1
A	beforeCancelingDeploy()	0	3	1
A	log()	0	3	1
A	safeDelete()	0	17	4
A	beforeStartingRollback()	0	3	1
A	runRemote()	0	5	1
A	runOnServer()	0	5	1
A	getContext()	0	3	1

<?php
namespace Bencagri\Artisan\Deployer\Deployer;

use Bencagri\Artisan\Deployer\Configuration\ConfigurationAdapter;
use Bencagri\Artisan\Deployer\Configuration\Option;
use Bencagri\Artisan\Deployer\Context;
use Bencagri\Artisan\Deployer\Helper\Str;
use Bencagri\Artisan\Deployer\Logger;
use Bencagri\Artisan\Deployer\Requirement\AbstractRequirement;
use Bencagri\Artisan\Deployer\Server\Property;
use Bencagri\Artisan\Deployer\Server\Server;
use Bencagri\Artisan\Deployer\Server\ServerRepository;
use Bencagri\Artisan\Deployer\Task\Task;
use Bencagri\Artisan\Deployer\Task\TaskCompleted;
use Bencagri\Artisan\Deployer\Task\TaskRunner;

abstract class AbstractDeployer
{
    /** @var Context */
    private $context;
    /** @var TaskRunner */
    private $taskRunner;
    /** @var Logger */
    private $logger;
    /** @var ConfigurationAdapter */
    private $config;

    abstract public function getRequirements() : array;

    abstract public function deploy();

    abstract public function cancelDeploy();

    abstract public function rollback();

    final public function getConfig(string $name)
    {
        return $this->config->get($name);
    }

    final public function doDeploy() : void
    {
        try {
            $this->log('Executing <hook>beforeStartingDeploy</> hook');
            $this->beforeStartingDeploy();
            $this->log('<h1>Starting the deployment</>');

            $this->deploy();

            $this->log('Executing <hook>beforeFinishingDeploy</> hook');
            $this->beforeFinishingDeploy();
            $this->log('<h1>Finishing the deployment</>');
        } catch (\Exception $e) {
            $this->log('<error>[ERROR] Cancelling the deployment and reverting the changes</>');
            $this->log(sprintf('<error>A log file with all the error details has been generated in %s</>', $this->context->getLogFilePath()));

            $this->log('Executing <hook>beforeCancelingDeploy</> hook');
            $this->beforeCancelingDeploy();
            $this->cancelDeploy();

            throw $e;
        }

        $this->log(sprintf('<success>[OK] Deployment was successful</>'));
    }

    final public function doRollback() : void
    {
        try {
            $this->log('Executing <hook>beforeStartingRollback</> hook');
            $this->beforeStartingRollback();
            $this->log('<h1>Starting the rollback</>');

            $this->rollback();

            $this->log('Executing <hook>beforeFinishingRollback</> hook');
            $this->beforeFinishingRollback();
            $this->log('<h1>Finishing the rollback</>');
        } catch (\Exception $e) {
            $this->log('<error>[ERROR] The roll back failed because of the following error</>');
            $this->log(sprintf('<error>A log file with all the error details has been generated in %s</>', $this->context->getLogFilePath()));

            $this->log('Executing <hook>beforeCancelingRollback</> hook');
            $this->beforeCancelingRollback();

            throw $e;
        }

        $this->log(sprintf('<success>[OK] Rollback was successful</>'));
    }

    public function beforeStartingDeploy()
    {
        $this->log('<h3>Nothing to execute</>');
    }

    public function beforeCancelingDeploy()
    {
        $this->log('<h3>Nothing to execute</>');
    }

    public function beforeFinishingDeploy()
    {
        $this->log('<h3>Nothing to execute</>');
    }

    public function beforeStartingRollback()
    {
        $this->log('<h3>Nothing to execute</>');
    }

    public function beforeCancelingRollback()
    {
        $this->log('<h3>Nothing to execute</>');
    }

    public function beforeFinishingRollback()
    {
        $this->log('<h3>Nothing to execute</>');
    }

    public function initialize(Context $context) : void
    {
        $this->context = $context;
        $this->logger = new Logger($context);
        $this->taskRunner = new TaskRunner($this->context->isDryRun(), $this->logger);
        $this->log('<h1>Initializing configuration</>');

        $this->log('<h2>Processing the configuration options of the deployer class</>');
        $this->config = new ConfigurationAdapter($this->configure());
        $this->log($this->config);
        $this->log('<h2>Checking technical requirements</>');
        $this->checkRequirements();
    }

    abstract protected function getConfigBuilder();

    abstract protected function configure();

    final protected function getContext() : Context
    {
        return $this->context;
    }

    final protected function getServers() : ServerRepository
    {
        return $this->config->get('servers');
    }

    final protected function log(string $message) : void
    {
        $this->logger->log($message);
    }

    final protected function runLocal(string $command) : TaskCompleted
    {
        $task = new Task([$this->getContext()->getLocalHost()], $command, $this->getCommandEnvVars());

        return $this->taskRunner->run($task)[0];
    }

    /**
     * @return TaskCompleted[]
     */
    final protected function runRemote(string $command, array $roles = [Server::ROLE_APP]) : array
    {
        $task = new Task($this->getServers()->findByRoles($roles), $command, $this->getCommandEnvVars());

        return $this->taskRunner->run($task);
    }

    final protected function runOnServer(string $command, Server $server) : TaskCompleted
    {
        $task = new Task([$server], $command, $this->getCommandEnvVars());

        return $this->taskRunner->run($task)[0];
    }

    // this method checks that any file or directory that goes into "rm -rf" command is
    // relative to the project dir. This safeguard will prevent catastrophic errors
    // related to removing the wrong file or directory on the server.
    final protected function safeDelete(Server $server, array $absolutePaths) : void
    {
        $deployDir = $server->get(Property::deploy_dir);
        $pathsToDelete = [];
        foreach ($absolutePaths as $path) {
            if (Str::startsWith($path, $deployDir)) {
                $pathsToDelete[] = $path;
            } else {
                $this->log(sprintf('Skipping the unsafe deletion of "%s" because it\'s not relative to the project directory.', $path));
            }
        }

        if (empty($pathsToDelete)) {
            $this->log('There are no paths to delete.');
        }

        $this->runOnServer(sprintf('rm -rf %s', implode(' ', $pathsToDelete)), $server);
    }

    private function getCommandEnvVars() : array
    {
        $appEnvironment = $this->getConfig(Option::appEnvironment);
        $envVars = null !== $appEnvironment ? ['APP_ENV' => $appEnvironment] : [];

        return $envVars;
    }

    private function checkRequirements() : void
    {
        /** @var AbstractRequirement[] $requirements */
        $requirements = $this->getRequirements();

        if (empty($requirements)) {
            $this->logger->log('<h3>No requirements defined</>');
        }

        foreach ($requirements as $requirement) {
            $this->taskRunner->run($requirement->getChecker());
            $this->log($requirement->getMessage());
        }
    }
}