hidev\components\Deployer

Complexity

Total Complexity

55

Size/Duplication

Total Lines	320
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	chmod()	0	3	1
A	__construct()	0	32	4
A	refresh()	0	3	1
A	getSystemd()	0	7	2
A	extractCwd()	0	9	2
A	getAltTier()	0	4	1
A	findVariants()	0	3	1
A	checkHost()	0	6	2
A	getEnv()	0	3	1
A	phplog()	0	11	3
A	call()	0	8	3
A	getHosts()	0	14	4
A	up()	0	4	1
A	getHost()	0	4	1
A	createDotenv()	0	6	2
A	getConfig()	0	8	1
A	symlinks()	0	9	1
A	genByTemplate()	0	9	2
A	getCwd()	0	7	2
A	genSystemdConfig()	0	3	1
A	restart()	0	5	1
A	all()	0	6	1
A	getComposer()	0	7	2
A	findDefaultPath()	0	11	3
A	status()	0	4	1
A	getPath()	0	9	2
A	down()	0	3	1
A	findTemplatePath()	0	16	4
A	findDocker()	0	17	4

<?php

namespace hidev\components;

use Dotenv\Dotenv;

The type Dotenv\Dotenv was not found. Maybe you did not declare it correctly or list all dependencies?

use hidev\helpers\Sys;

class Deployer
{
    private $dir;
    private $path;
    private $name;
    private $tier;
    private $dotenv;

    public function __construct(string $path = null)
    {
        if ($path === null) {
            $path = $this->findDefaultPath();
        } else {
            $path = trim($path);
        }
        if (strncmp($path, '/', 1) !== 0) {
            $path = getcwd() . '/' . $path;
        }
        if (!file_exists($path)) {
            throw new \Exception("no env file at $path");
        }

        $this->dir = dirname($path);
        $this->path = $path;

        $this->getComposer()->autoload();

        $file = basename($path);
        $ps = explode('.', $file, 3);
        $name = $ps[2];
        $ps = explode('-', $name);

        $this->file = $file;

The property file does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        $this->name = $name;
        $this->tier = $ps[1] ?? $name;

        $this->dotenv = $this->createDotenv($this->dir, $this->file);
        $this->dotenv->load();

        $this->checkHost();
    }

    private static $pathVariants = ['beta', 'dev', 'sol-beta', 'sol-dev', 'bladeroot-beta'];

The private property $pathVariants is not used, and could be removed.

    private function findDefaultPath(): string
    {
        $dir = basename($this->getCwd());
        foreach ($this->findVariants() as $path) {
            $name = pathinfo($path, PATHINFO_EXTENSION);
            if (strncmp($dir, "${name}-", strlen($name)+1) === 0) {
                return $path;
            }
        }

        return '.env.dist';
    }

    private function findVariants(): array
    {
        return glob('.env.*');

The expression return glob('.env.*') could return the type false which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    private function checkHost()
    {
        $dir = basename($this->dir);
        $host = $this->getHost();
        if ($dir !== $host) {
            die("Dir:$dir and Host:$host doesn't match\n");

Using exit here is not recommended.

        }
    }

    /**
     * Creates Dotenv object.
     * Supports both 2 and 3 version of `phpdotenv`
     * @param mixed $dir
     * @param mixed $file
     * @return Dotenv
     */
    private function createDotenv($dir, $file)
    {
        if (method_exists(Dotenv::class, 'create')) {
            return Dotenv::create($dir, $file);
        } else {
            return new Dotenv($dir, $file);
        }
    }

    public function call(string $name = null)
    {
        $name = $name ?: 'all';
        if (!method_exists($this, $name)) {
            throw new \Exception("wrong command: $name");
        }

        $this->{$name}();
    }

    public function all()
    {
        $this->symlinks();
        $this->chmod();
        $this->phplog();
        $this->up();
    }

    public function symlinks()
    {
        $envSrc = $this->getPath($this->file);
        $envDst = $this->getPath('.env');
        $docSrc = $this->findDocker();
        $docDst = $this->getPath('docker-compose.yml');

        Sys::passthru("ln -sf $envSrc $envDst");
        Sys::passthru("ln -sf $docSrc $docDst");
    }

    private function findDocker(): string
    {
        $path = $this->getPath("core/docker-compose.yml.{$this->name}");
        if (file_exists($path)) {
            return $path;
        }
        $path = $this->getPath("core/docker-compose.yml.{$this->tier}");
        if (file_exists($path)) {
            return $path;
        }
        $tier = $this->getAltTier();
        $path = $this->getPath("core/docker-compose.yml.$tier");
        if (file_exists($path)) {
            return $path;
        }

        throw new \Exception("no docker-compose file: $path");
    }

    private function getAltTier()
    {
        //return $this->tier === 'beta' ? 'dist' : $this->tier;
        return 'dist';
    }

    public function chmod()
    {
        Sys::chmod('a+w', 'runtime public/assets');
    }

    public function phplog()
    {
        $phplog = $this->getPath('.docker/php/var/log/php/php.log');
        $dir = dirname($phplog);
        if (!file_exists($dir)) {
            Sys::mkdir($dir);
        }
        if (!file_exists($phplog)) {
            Sys::passthru("sudo touch $phplog");
        }
        Sys::chmod('a+w', $phplog);
    }

    private $composer;

    private function getComposer()
    {
        if ($this->composer === null) {
            $this->composer = new Composer($this->dir);
        }

        return $this->composer;
    }

    private function up()
    {
        $this->refresh();
        $this->getSystemd()->up($this->genSystemdConfig());
    }

    private function down()
    {
        $this->getSystemd()->down();
    }

    private function restart()
    {
        $this->refresh();
        $this->getSystemd()->restart();
        $this->getSystemd()->status();
    }

    private function status()
    {
        $this->refresh();
        $this->getSystemd()->status();
    }

    private $systemd;

    private function getSystemd()
    {
        if ($this->systemd === null) {
            $this->systemd = new Systemd($this->getHost());
        }

        return $this->systemd;
    }

    public function refresh()
    {
        $this->getComposer()->dump();
    }

    private $systemdTemplate = 'core/systemd.service';

    private function genSystemdConfig()
    {
        return $this->genByTemplate($this->systemdTemplate);
    }

    private function genByTemplate($file): string
    {
        $tpl = file_get_contents($this->findTemplatePath($file));

Are you sure the usage of $this->findTemplatePath($file) targeting hidev\components\Deployer::findTemplatePath() seems to always return null.

$this->findTemplatePath($file) of type void is incompatible with the type string expected by parameter $filename of file_get_contents().

        $subs = [];
        foreach ($this->getConfig() as $key => $value) {
            $subs["{{$key}}"] = $value;
        }

        return strtr($tpl, $subs);
    }

    /**
     * undocumented function
     *
     * @return void
     */
    private function findTemplatePath($file)
    {
        $path = $this->getPath($file);
        if (file_exists($path)) {
            return $path;

The expression return $path returns the type string which is incompatible with the documented return type void.

        }
        $path = __DIR__ . DIRECTORY_SEPARATOR . $file;
        if (file_exists($path)) {
            return $path;

The expression return $path returns the type string which is incompatible with the documented return type void.

        }
        $path = __DIR__ . DIRECTORY_SEPARATOR . basename($file);
        if (file_exists($path)) {
            return $path;

The expression return $path returns the type string which is incompatible with the documented return type void.

        }

        throw new \Exception("failed find `$file` template");
    }

    public function getConfig(): array
    {
        return array_merge(
            [
                'HOST'  => $this->getHost(),
                'DIR'   => $this->dir,
            ],
            $this->getEnv()
        );
    }

    public function getEnv(): array
    {
        return $_ENV;
    }

    public function getHost(): string
    {
        $hosts = $this->getHosts();
        return $_ENV['HOST'] ?? reset($hosts);
    }

    public function getHosts(): array
    {
        if (!empty($_ENV['HOSTS'])) {
            $hosts = explode(',', $_ENV['HOSTS']);
        } elseif (!empty($_ENV['HOST'])) {
            $hosts = [$_ENV['HOSTS']];
        } else {
            throw new \Exception('no HOST given');
        }
        foreach ($hosts as &$host) {
            $host = trim($host);
        }

        return $hosts;
    }

    public function getPath(string $file): string
    {
        if (strncmp($file, '/', 1) === 0) {
            $path = $file;
        } else {
            $path = $this->dir . DIRECTORY_SEPARATOR . $file;
        }

        return $this->extractCwd($path);
    }

    private function extractCwd(string $path): string
    {
        $cwd = $this->getCwd();
        $len = strlen($cwd);
        if (strncmp($path, $cwd, $len) === 0) {
            $path = substr($path, $len+1);
        }

        return $path;
    }

    private $cwd;

    private function getCwd(): string
    {
        if ($this->cwd === null) {
            $this->cwd = \getcwd();
        }

        return $this->cwd;
    }
}