Bencagri\Artisan\Deployer\Deployer\DefaultDeployer

Complexity

Total Complexity

64

Size/Duplication

Total Lines	406
Duplicated Lines	0 %

Importance

Changes

0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	doCreateSharedDirs()	0	7	2
B	cancelDeploy()	0	12	5
A	initializeServerOptions()	0	17	4
A	beforeOptimizing()	0	3	1
A	doDeleteLastReleaseDirectory()	0	5	1
A	doSymlinkToPreviousRelease()	0	4	1
B	deleteOldReleases()	0	26	4
A	doInstallDependencies()	0	9	2
A	doClearControllers()	0	9	2
A	beforeRollingBack()	0	3	1
B	deploy()	0	35	1
A	doUpdateCode()	0	9	1
A	doOptimizeComposer()	0	4	1
A	doCreateCacheDir()	0	4	1
B	doSetPermissions()	0	32	5
A	doCheckPreviousReleases()	0	14	4
A	getConfigBuilder()	0	3	1
A	doWarmupCache()	0	9	2
A	findConsoleBinaryPath()	0	11	3
A	doCreateLogDir()	0	4	1
A	getRequirements()	0	17	2
A	doKeepReleases()	0	11	3
A	doResetOpCache()	0	9	2
A	doGetcodeRevision()	0	11	2
A	createRemoteDirectoryLayout()	0	11	3
A	initializeDirectoryLayout()	0	14	1
A	rollback()	0	10	1
A	beforeUpdating()	0	3	1
A	beforePreparing()	0	3	1
A	doCreateSymlink()	0	4	1
A	doCreateSharedFiles()	0	10	3
A	beforePublishing()	0	3	1

<?php

namespace Bencagri\Artisan\Deployer\Deployer;

use Bencagri\Artisan\Deployer\Configuration\DefaultConfiguration;
use Bencagri\Artisan\Deployer\Configuration\Option;
use Bencagri\Artisan\Deployer\Exception\InvalidConfigurationException;
use Bencagri\Artisan\Deployer\Requirement\AllowsLoginViaSsh;
use Bencagri\Artisan\Deployer\Requirement\CommandExists;
use Bencagri\Artisan\Deployer\Server\Property;
use Bencagri\Artisan\Deployer\Server\Server;
use Bencagri\Artisan\Deployer\Task\TaskCompleted;

abstract class DefaultDeployer extends AbstractDeployer
{
    private $remoteProjectDirHasBeenCreated = false;
    private $remoteSymLinkHasBeenCreated = false;

    public function getConfigBuilder() : DefaultConfiguration
    {
        return new DefaultConfiguration($this->getContext()->getLocalProjectRootDir());
    }

    public function getRequirements() : array
    {
        $requirements = [];
        $localhost = $this->getContext()->getLocalHost();
        $allServers = $this->getServers()->findAll();
        $appServers = $this->getServers()->findByRoles([Server::ROLE_APP]);

        $requirements[] = new CommandExists([$localhost], 'git');
        $requirements[] = new CommandExists([$localhost], 'ssh');

        $requirements[] = new AllowsLoginViaSsh($allServers);
        $requirements[] = new CommandExists($appServers, $this->getConfig(Option::remoteComposerBinaryPath));
        if ('acl' === $this->getConfig(Option::permissionMethod)) {
            $requirements[] = new CommandExists($appServers, $this->getConfig('setfacl'));
        }

        return $requirements;
    }

    final public function deploy() : void
    {
        $this->initializeServerOptions();
        $this->createRemoteDirectoryLayout();
        $this->remoteProjectDirHasBeenCreated = true;

        $this->log('Executing <hook>beforeUpdating</> hook');
        $this->beforeUpdating();
        $this->log('<h1>Updating app code</>');
        $this->doUpdateCode();

        $this->log('Executing <hook>beforePreparing</> hook');
        $this->beforePreparing();
        $this->log('<h1>Preparing app</>');
        $this->doCreateCacheDir();
        $this->doCreateLogDir();
        $this->doCreateSharedDirs();
        $this->doCreateSharedFiles();
        $this->doSetPermissions();
        $this->doInstallDependencies();

        $this->log('Executing <hook>beforeOptimizing</> hook');
        $this->beforeOptimizing();
        $this->log('<h1>Optimizing app</>');
        $this->doWarmupCache();
        $this->doClearControllers();
        $this->doOptimizeComposer();

        $this->log('Executing <hook>beforePublishing</> hook');
        $this->beforePublishing();
        $this->log('<h1>Publishing app</>');
        $this->doCreateSymlink();
        $this->remoteSymLinkHasBeenCreated = true;
        $this->doResetOpCache();
        $this->doKeepReleases();
    }

    final public function cancelDeploy() : void
    {
        if (!$this->remoteSymLinkHasBeenCreated && !$this->remoteProjectDirHasBeenCreated) {
            $this->log('<h2>No changes need to be reverted on remote servers (neither the remote project dir nor the symlink were created)</>');
        }

        if ($this->remoteSymLinkHasBeenCreated) {
            $this->doSymlinkToPreviousRelease();
        }

        if ($this->remoteProjectDirHasBeenCreated) {
            $this->doDeleteLastReleaseDirectory();
        }
    }

    final public function rollback() : void
    {
        $this->initializeServerOptions();

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

        $this->doCheckPreviousReleases();
        $this->doSymlinkToPreviousRelease();
        $this->doDeleteLastReleaseDirectory();
    }

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

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

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

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

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

    private function doCheckPreviousReleases() : void
    {
        $this->log('<h2>Getting the previous releases dirs</>');
        $results = $this->runRemote('ls -r1 {{ deploy_dir }}/releases');

        if ($this->getContext()->isDryRun()) {
            return;
        }

        foreach ($results as $result) {
            $numReleases = count(array_filter(explode("\n", $result->getOutput())));

            if ($numReleases < 2) {
                throw new \RuntimeException(sprintf('The application cannot be rolled back because the "%s" server has only 1 release and it\'s not possible to roll back to a previous version.', $result->getServer()));
            }
        }
    }

    private function doSymlinkToPreviousRelease() : void
    {
        $this->log('<h2>Reverting the current symlink to the previous version</>');
        $this->runRemote('export _previous_release_dirname=$(ls -r1 {{ deploy_dir }}/releases | head -n 2 | tail -n 1) && rm -f {{ deploy_dir }}/current && ln -s {{ deploy_dir }}/releases/$_previous_release_dirname {{ deploy_dir }}/current');
    }

    private function doDeleteLastReleaseDirectory() : void
    {
        // this is needed to avoid rolling back in the future to this version
        $this->log('<h2>Deleting the last release directory</>');
        $this->runRemote('export _last_release_dirname=$(ls -r1 {{ deploy_dir }}/releases | head -n 1) && rm -fr {{ deploy_dir }}/releases/$_last_release_dirname');
    }

    private function initializeServerOptions() : void
    {
        $this->log('<h2>Initializing server options</>');

        /** @var Server[] $allServers */
        $allServers = array_merge([$this->getContext()->getLocalHost()], $this->getServers()->findAll());
        foreach ($allServers as $server) {
            if (true === $this->getConfig(Option::useSshAgentForwarding)) {
                $this->log(sprintf('<h3>Enabling SSH agent forwarding for <server>%s</> server</>', $server));
            }
            $server->set(Property::use_ssh_agent_forwarding, $this->getConfig(Option::useSshAgentForwarding));
        }

        $appServers = $this->getServers()->findByRoles([Server::ROLE_APP]);
        foreach ($appServers as $server) {
            $this->log(sprintf('<h3>Setting the %s property for <server>%s</> server</>', Property::deploy_dir, $server));
            $server->set(Property::deploy_dir, $this->getConfig(Option::deployDir));
        }
    }

    private function initializeDirectoryLayout(Server $server) : void
    {
        $this->log('<h2>Initializing server directory layout</>');

        $remoteProjectDir = $server->get(Property::project_dir);
        $server->set(Property::config_dir, sprintf('%s/%s', $remoteProjectDir, $this->getConfig(Option::configDir)));
        $server->set(Property::cache_dir, sprintf('%s/%s', $remoteProjectDir, $this->getConfig(Option::cacheDir)));
        $server->set(Property::log_dir, sprintf('%s/%s', $remoteProjectDir, $this->getConfig(Option::logDir)));
        $server->set(Property::src_dir, sprintf('%s/%s', $remoteProjectDir, $this->getConfig(Option::srcDir)));
        $server->set(Property::templates_dir, sprintf('%s/%s', $remoteProjectDir, $this->getConfig(Option::templatesDir)));
        $server->set(Property::web_dir, sprintf('%s/%s', $remoteProjectDir, $this->getConfig(Option::webDir)));


        $server->set(Property::console_bin, sprintf('%s artisan', $this->getConfig(Option::remotePhpBinaryPath)));
    }


    private function findConsoleBinaryPath(Server $server) : string

The method findConsoleBinaryPath() is not used, and could be removed.

    {
        $consoleBinary = '{{ project_dir }}/artisan';

        $localConsoleBinary = $this->getContext()->getLocalHost()->resolveProperties($consoleBinary);
        if (is_executable($localConsoleBinary)) {
            return $server->resolveProperties($consoleBinary);
        }

        if (null === $server->get(Property::console_bin)) {
            throw new InvalidConfigurationException(sprintf('The artisan binary of your laravel application is not available in any of the following directories: %s. Configure the "baseDir" option and set it to the directory that contains the "artisan" binary.', $consoleBinary));
        }

The function implicitly returns null when the if condition on line 209 is false. This is incompatible with the type-hinted return string. Consider adding a return statement or allowing null as return value.

    }

    private function createRemoteDirectoryLayout() : void
    {
        $this->log('<h2>Creating the remote directory layout</>');
        $this->runRemote('mkdir -p {{ deploy_dir }} && mkdir -p {{ deploy_dir }}/releases && mkdir -p {{ deploy_dir }}/shared');

        /** @var TaskCompleted[] $results */
        $results = $this->runRemote('export _release_path="{{ deploy_dir }}/releases/$(date +%Y%m%d%H%M%S)" && mkdir -p $_release_path && echo $_release_path');
        foreach ($results as $result) {
            $remoteProjectDir = $this->getContext()->isDryRun() ? '(the remote project_dir)' : $result->getTrimmedOutput();
            $result->getServer()->set(Property::project_dir, $remoteProjectDir);
            $this->initializeDirectoryLayout($result->getServer());
        }
    }

    private function doGetcodeRevision() : string
    {
        $this->log('<h2>Getting the revision ID of the code repository</>');
        $result = $this->runLocal(sprintf('git ls-remote %s %s', $this->getConfig(Option::repositoryUrl), $this->getConfig(Option::repositoryBranch)));
        $revision = explode("\t", $result->getTrimmedOutput())[0];
        if ($this->getContext()->isDryRun()) {
            $revision = '(the code revision)';
        }
        $this->log(sprintf('<h3>Code revision hash = %s</>', $revision));

        return $revision;
    }

    private function doUpdateCode() : void
    {
        $repositoryRevision = $this->doGetcodeRevision();

        $this->log('<h2>Updating code base with remote_cache strategy</>');
        $this->runRemote(sprintf('if [ -d {{ deploy_dir }}/repo ]; then cd {{ deploy_dir }}/repo && git fetch -q origin && git fetch --tags -q origin && git reset -q --hard %s && git clean -q -d -x -f; else git clone -q -b %s %s {{ deploy_dir }}/repo && cd {{ deploy_dir }}/repo && git checkout -q -b deploy %s; fi', $repositoryRevision, $this->getConfig(Option::repositoryBranch), $this->getConfig(Option::repositoryUrl), $repositoryRevision));

        $this->log('<h3>Copying the updated code to the new release directory</>');
        $this->runRemote(sprintf('cp -RPp {{ deploy_dir }}/repo/* {{ project_dir }}'));
    }

    private function doCreateCacheDir() : void
    {
        $this->log('<h2>Creating cache directory</>');
        $this->runRemote('if [ -d {{ cache_dir }} ]; then rm -rf {{ cache_dir }}; fi; mkdir -p {{ cache_dir }}');
    }

    private function doCreateLogDir() : void
    {
        $this->log('<h2>Creating log directory</>');
        $this->runRemote('if [ -d {{ log_dir }} ] ; then rm -rf {{ log_dir }}; fi; mkdir -p {{ log_dir }}');
    }

    private function doCreateSharedDirs() : void
    {
        $this->log('<h2>Creating symlinks for shared directories</>');
        foreach ($this->getConfig(Option::sharedDirs) as $sharedDir) {
            $this->runRemote(sprintf('mkdir -p {{ deploy_dir }}/shared/%s', $sharedDir));
            $this->runRemote(sprintf('if [ -d {{ project_dir }}/%s ] ; then rm -rf {{ project_dir }}/%s; fi', $sharedDir, $sharedDir));
            $this->runRemote(sprintf('ln -nfs {{ deploy_dir }}/shared/%s {{ project_dir }}/%s', $sharedDir, $sharedDir));
        }
    }

    private function doCreateSharedFiles() : void
    {
        $this->log('<h2>Creating symlinks for shared files</>');
        if (!is_array($this->getConfig(Option::sharedFiles))) return;

        foreach ($this->getConfig(Option::sharedFiles) as $sharedFile) {
            $sharedFileParentDir = dirname($sharedFile);
            $this->runRemote(sprintf('mkdir -p {{ deploy_dir }}/shared/%s', $sharedFileParentDir));
            $this->runRemote(sprintf('touch {{ deploy_dir }}/shared/%s', $sharedFile));
            $this->runRemote(sprintf('ln -nfs {{ deploy_dir }}/shared/%s {{ project_dir }}/%s', $sharedFile, $sharedFile));
        }
    }

    // this method was inspired by https://github.com/deployphp/deployer/blob/master/recipe/deploy/writable.php
    // (c) Anton Medvedev <anton@medv.io>
    private function doSetPermissions() : void
    {
        $permissionMethod = $this->getConfig(Option::permissionMethod);
        $writableDirs = implode(' ', $this->getConfig(Option::writableDirs));
        $this->log(sprintf('<h2>Setting permissions for writable dirs using the "%s" method</>', $permissionMethod));

        if ('chmod' === $permissionMethod) {
            $this->runRemote(sprintf('chmod -R %s %s', $this->getConfig(Option::permissionMode), $writableDirs));

            return;
        }

        if ('chown' === $permissionMethod) {
            $this->runRemote(sprintf('sudo chown -RL %s %s', $this->getConfig(Option::permissionUser), $writableDirs));

            return;
        }

        if ('chgrp' === $permissionMethod) {
            $this->runRemote(sprintf('sudo chgrp -RH %s %s', $this->getConfig(Option::permissionGroup), $writableDirs));

            return;
        }

        if ('acl' === $permissionMethod) {
            $this->runRemote(sprintf('sudo setfacl -RL -m u:"%s":rwX -m u:`whoami`:rwX %s', $this->getConfig(Option::permissionUser), $writableDirs));
            $this->runRemote(sprintf('sudo setfacl -dRL -m u:"%s":rwX -m u:`whoami`:rwX %s', $this->getConfig(Option::permissionUser), $writableDirs));

            return;
        }

        throw new InvalidConfigurationException(sprintf('The "%s" permission method is not valid. Select one of the supported methods.', $permissionMethod));
    }

    private function doInstallDependencies() : void
    {
        if (true === $this->getConfig(Option::updateRemoteComposerBinary)) {
            $this->log('<h2>Self Updating the Composer binary</>');
            $this->runRemote(sprintf('%s self-update', $this->getConfig(Option::remoteComposerBinaryPath)));
        }

        $this->log('<h2>Installing Composer dependencies</>');
        $this->runRemote(sprintf('%s install %s', $this->getConfig(Option::remoteComposerBinaryPath), $this->getConfig(Option::composerInstallFlags)));
    }

    private function doWarmupCache() : void
    {
        if (true !== $this->getConfig(Option::warmupCache)) {
            return;
        }

        $this->log('<h2>Clearing Cache</>');
        $this->runRemote(sprintf('{{ console_bin }} cache:clear --no-debug --env=%s', $this->getConfig(Option::appEnvironment)));
        $this->runRemote('chmod -R g+w {{ cache_dir }}');
    }

    private function doClearControllers() : void
    {
        $this->log('<h2>Clearing controllers</>');
        foreach ($this->getServers()->findByRoles([Server::ROLE_APP]) as $server) {
            $absolutePaths = array_map(function ($relativePath) use ($server) {
                return $server->resolveProperties(sprintf('{{ project_dir }}/%s', $relativePath));
            }, $this->getConfig(Option::controllersToRemove));

            $this->safeDelete($server, $absolutePaths);
        }
    }

    private function doOptimizeComposer() : void
    {
        $this->log('<h2>Optimizing Composer autoloader</>');
        $this->runRemote(sprintf('%s dump-autoload %s', $this->getConfig(Option::remoteComposerBinaryPath), $this->getConfig(Option::composerOptimizeFlags)));
    }

    private function doCreateSymlink() : void
    {
        $this->log('<h2>Updating the symlink</>');
        $this->runRemote('rm -f {{ deploy_dir }}/current && ln -s {{ project_dir }} {{ deploy_dir }}/current');
    }

    private function doResetOpCache() : void
    {
        if (null === $homepageUrl = $this->getConfig(Option::resetOpCacheFor)) {
            return;
        }

        $this->log('<h2>Resetting the OPcache contents</>');
        $phpScriptPath = sprintf('__easy_deploy_opcache_reset_%s.php', bin2hex(random_bytes(8)));
        $this->runRemote(sprintf('echo "<?php opcache_reset();" > {{ web_dir }}/%s && wget %s/%s && rm -f {{ web_dir }}/%s', $phpScriptPath, $homepageUrl, $phpScriptPath, $phpScriptPath));
    }

    private function doKeepReleases() : void
    {
        if (-1 === $this->getConfig(Option::keepReleases)) {
            $this->log('<h3>No releases to delete</>');

            return;
        }

        $results = $this->runRemote('ls -1 {{ deploy_dir }}/releases');
        foreach ($results as $result) {
            $this->deleteOldReleases($result->getServer(), explode("\n", $result->getTrimmedOutput()));
        }
    }

    private function deleteOldReleases(Server $server, array $releaseDirs) : void
    {
        foreach ($releaseDirs as $releaseDir) {
            if (!preg_match('/\d{14}/', $releaseDir)) {
                $this->log(sprintf('[<server>%s</>] Skipping cleanup of old releases; unexpected "%s" directory found (all directory names should be timestamps)', $server, $releaseDir));

                return;
            }
        }

        if (count($releaseDirs) <= $this->getConfig(Option::keepReleases)) {
            $this->log(sprintf('[<server>%s</>] No releases to delete (there are %d releases and the config keeps %d releases).', $server, count($releaseDirs), $this->getConfig(Option::keepReleases)));

            return;
        }

        $relativeDirsToRemove = array_slice($releaseDirs, 0, -$this->getConfig(Option::keepReleases));
        $absoluteDirsToRemove = array_map(function ($v) {
            return sprintf('%s/releases/%s', $this->getConfig(Option::deployDir), $v);
        }, $relativeDirsToRemove);

        // the command must be run only on one server because the timestamps are
        // different for all servers, even when they belong to the same deploy and
        // because new servers may have been added to the deploy and old releases don't exist on them
        $this->log(sprintf('Deleting these old release directories: %s', implode(', ', $absoluteDirsToRemove)));
        $this->safeDelete($server, $absoluteDirsToRemove);
    }
}