build

#!/usr/bin/env php
<?php

use Symfony\Component\Console\Input\ArgvInput;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputDefinition;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\ConsoleOutput;

require __DIR__ . '/vendor/autoload.php';

/**
 * @param int $size
 * @param int $precision
 * @return string
 */
function formatBytes($size, $precision = 4)
{
    $base = log($size, 1024);
    $suffixes = ['', 'K', 'M', 'G', 'T'];

    return round(1024 ** ($base - floor($base)), $precision) . ' ' . $suffixes[(int)floor($base)];
}

/**
 * @param string $in infile
 * @param string $out outfile
 * @param int|null $mod chmod settings
 * @return bool
 */
function cp(ConsoleOutput $output, $in, $out, $mod = null)
{
    $output->writeln(sprintf('  Copying %s to %s', $in, $out));
    $result = copy($in, $out);
    if (!$result) {
        $output->getErrorOutput()->writeln(sprintf('  <error>Something bad happened...</error>'));
    }

    if ($result && $mod) {
        chmod($out, $mod);
    }

    return $result;
}

function init(ConsoleOutput $output)
{
    $configFile = __DIR__ . DIRECTORY_SEPARATOR . 'build.json';
    if (!is_file($configFile)) {
        $output->getErrorOutput()->writeln(sprintf('  <error>Cannot find configuration file build.json</error>'));
        exit(255);
    }
    $config = json_decode(file_get_contents($configFile), true);
    if (empty($config['repository'])) {
        $output->getErrorOutput()->writeln(sprintf('  <error>Please define "repository" in your build.json</error>'));
        exit(255);
    }
    if (empty($config['pharName'])) {
        $output->getErrorOutput()->writeln(sprintf('  <error>Please define "pharName" in your build.json</error>'));
        exit(255);
    }

    define('BUILD_START_TIME', microtime(true));
    define('REPO_URL', $config['repository']);
    define('BUILD_COMMIT', isset($_SERVER['argv'][1]) ? $_SERVER['argv'][1] : 'master');
    define('PHAR_NAME', $config['pharName']);
}

/**
 * @param ConsoleOutput $output
 * @param array $tools
 */
function checkToolsInstalled(ConsoleOutput $output)
{
    $tools = [
        'git' => [
            'version' => '2.5',
            'url' => 'https://git-scm.com/downloads',
        ],
        'box' => [
            'version' => '4.1',
            'url' => 'https://github.com/humbug/box/blob/master/doc/installation.md#installation',
            'alter_path' => '/home/runner/work/jira/jira/box',
            'legend' => 'box is a tool used for building PHAR files',
        ],
        'composer' => [
            'version' => '1.5',
            'url' => 'https://getcomposer.org/download/',
        ],
    ];

    foreach ($tools as $tool => $hints) {
        if (isset($hints['alter_path']) && is_file($hints['alter_path']) && !is_executable($hints['alter_path'])) {
            passthru($hints['alter_path'] . ' --version');
            $output->getErrorOutput()->writeln(
                "<error>Please install $tool and make executable in {$hints['alter_path']} to continue</error>"
            );
            if (isset($hints['legend'])) {
                $output->writeln(sprintf('<info>hint:</info> %s', $hints['legend']));
            }
            if (isset($hints['url'])) {
                $output->writeln(sprintf('Please visit %s for more info', $hints['url']));
            }
            exit(1);
        } else {
            if (!isset($hints['alter_path']) && !trim(`which $tool`)) {
                $output->getErrorOutput()->writeln(
                    "<error>Please install $tool and make available in \$PATH to continue</error>"
                );
                if (isset($hints['legend'])) {
                    $output->writeln(sprintf('<info>hint:</info> %s', $hints['legend']));
                }
                if (isset($hints['url'])) {
                    $output->writeln(sprintf('Please visit %s for more info', $hints['url']));
                }
                exit(1);
            }
        }
        $command = isset($hints['alter_path']) && is_executable($hints['alter_path']) ? $hints['alter_path'] : $tool;
        list(, , $version) = explode(' ', `$command --version`);
        if (!version_compare($version, $hints['version'], '>=')) {
            $output->getErrorOutput()->writeln(
                sprintf(
                    "<error>Please make sure %s is at least version %s (current version is %s)</error>",
                    $tool,
                    $hints['version'],
                    $version
                )
            );
            if (isset($hints['legend'])) {
                $output->writeln(sprintf('<info>hint:</info> %s', $hints['legend']));
            }
            if (isset($hints['url'])) {
                $output->writeln(sprintf('Please visit %s for more info', $hints['url']));
            }
            exit(1);
        }
    }
}

function box($commands, &$returnVar = null)
{
    static $box = null;
    if (is_null($box)) {
        $box = is_executable('/home/runner/work/jira/jira/box') ? '/home/runner/work/jira/jira/box' : 'box';
    }

    passthru("$box $commands", $returnVar);
}

/**
 * @param ConsoleOutput $output
 * @return string
 */
function createBuildDirectory(ConsoleOutput $output)
{
    $buildDir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . PHAR_NAME . '-' . BUILD_COMMIT . '-' . uniqid('jrbld', true);
    $output->writeln('<info>Creating build directory</info>');
    $output->writeln($buildDir);
    if (!mkdir($buildDir, 0733, true) && !is_dir($buildDir)) {
        throw new \RuntimeException(sprintf('Directory "%s" was not created', $buildDir));
    }
    if (!is_dir($buildDir)) {
        $output->getErrorOutput()->writeln('<error>Cannot create build directory!</error>');
        exit(2);
    }
    chdir($buildDir);

    return $buildDir;
}

/**
 * @param ConsoleOutput $output
 * @param $buildDir
 */
function cloneSingleCommitIntoBuildDir(ConsoleOutput $output, $buildDir)
{
    $output->writeln('<info>Initialising git repo for build</info>');

    chdir($buildDir);
    passthru(sprintf('git init && git remote add origin %s && git fetch origin', REPO_URL), $result);
    if ($result !== 0) {
        $output->getErrorOutput()->writeln(
            '<error>Cannot perform git init in build directory</error>'
        );
        exit(3);
    }
    passthru(
        sprintf('git checkout %s', BUILD_COMMIT),
        $result
    );

    if (!is_dir($buildDir . DIRECTORY_SEPARATOR . '.git') || $result !== 0) {
        $output->getErrorOutput()->writeln('<error>Git init failed!</error>');
        exit(3);
    }
}

function composerInstall(ConsoleOutput $output, $buildDir)
{
    chdir($buildDir);
    $output->writeln('<info>Running composer install...</info>');
    exec('composer install --no-dev -o');
}

/**
 * @param ConsoleOutput $output
 * @param string $buildDir
 */
function generateBoxJson(ConsoleOutput $output, $buildDir)
{
    $output->writeln('<info>Generating box config</info>');
    $configFile = __DIR__ . DIRECTORY_SEPARATOR . 'build.json';
    $config = json_decode(file_get_contents($configFile), true);
    $boxFile = $buildDir . DIRECTORY_SEPARATOR . 'box.json';
    $boxConfig = [
        'directories' => ['src'],
        'files' => [
            'vendor/symfony/dependency-injection/Loader/schema/dic/services/services-1.0.xsd',
        ],
        'output' => PHAR_NAME . '.phar',
        'finder' => [
            [
                'name' => '*.*',
                'exclude' => ['tests', 'spec', 'features', 'example', 'doc', 'docs', '*.md', '*.rst', '*.txt'],
                'in' => 'vendor',
            ],
        ],
        'compactors' => [
            'KevinGH\Box\Compactor\Php',
        ],
        'git-version' => 'git-version',
    ];
    $generatedConfig = array_merge_recursive($boxConfig, isset($config['box']) ? $config['box'] : []);
    $output->writeln(json_encode($generatedConfig));

    file_put_contents($boxFile, json_encode($generatedConfig));
}

/**
 * @param ConsoleOutput $output
 * @param string $buildDir
 * @return string
 */
function buildPhar(ConsoleOutput $output, $buildDir)
{
    $buildfile = $buildDir . DIRECTORY_SEPARATOR . PHAR_NAME . '.phar';
    $output->writeln('<info>Building phar...</info>');

    box('validate');
    box('compile', $compileResult);

    if (!is_file($buildfile) || $compileResult !== 0) {
        $output->getErrorOutput()->writeln('<error>Error while building phar!</error>');
        exit(4);
    } else {
        $output->writeln('<info>Done!</info>');
    }

    return $buildfile;
}

/**
 * @param ConsoleOutput $output
 * @param string $buildFile
 * @return string
 */
function copyPharToDestinations(ConsoleOutput $output, $buildFile)
{
    $output->writeln('<info>Copying files</info>');
    $releaseFile = __DIR__
        . DIRECTORY_SEPARATOR . 'builds'
        . DIRECTORY_SEPARATOR . PHAR_NAME . '-' . BUILD_COMMIT . '-' . md5_file($buildFile) . '.phar';
    $localBuildFile = __DIR__
        . DIRECTORY_SEPARATOR . PHAR_NAME . '.phar';
    if (!mkdir(dirname($releaseFile), 0733, true) && !is_dir(dirname($releaseFile))) {
        throw new \RuntimeException(sprintf('Directory "%s" was not created', dirname($releaseFile)));
    }

    if (cp($output, $buildFile, $releaseFile, 0755) !== true || cp(
            $output,
            $buildFile,
            $localBuildFile,
            0755
        ) !== true) {
        $output->getErrorOutput()->writeln(
            "<error>Unable to copy files into destination</error>"
        );
        exit(5);
    }

    return $releaseFile;
}

/**
 * @param ConsoleOutput $output
 * @param string $pharFile
 */
function testPhar(ConsoleOutput $output, $pharFile)
{
    $output->writeln('<info>Testing phar...</info>');
    chdir(dirname($pharFile));

    box(sprintf('verify %s', $pharFile), $verifyResult);
    if ($verifyResult !== 0) {
        $output->getErrorOutput()->writeln('<error>Box verify failed!!</error>');
        exit(6);
    }

    $output->writeln('<info>Checking if phar version works</info>');
    passthru(sprintf('./%s --version', pathinfo($pharFile, PATHINFO_BASENAME)), $result);
    if ($result !== 0) {
        $output->getErrorOutput()->writeln('<error>Error in PHAR file, please check the output above</error>');
        exit(6);
    }
}

/**
 * @return void
 */
function main()
{
    $input = new ArgvInput(
        null,
        new InputDefinition(
            [
                new InputArgument('version', InputArgument::OPTIONAL, 'git tag to build'),
                new InputOption('workflow', 'w', InputOption::VALUE_NONE, 'run in github workflow mode'),
                new InputOption('help', 'h', InputOption::VALUE_NONE, 'show help'),
            ]
        )
    );
    $output = new ConsoleOutput;

    if ($input->getOption('help')) {
        $output->writeln(
            [
                'Usage:',
                __FILE__ . ' [options]',
                '',
                'Options:',
                '--workflow|-w: run in github workflow mode',
                '--help|-h: show this help'
            ]
        );
        exit(0);
    }

    init($output);
    checkToolsInstalled($output);
    if ($input->getOption('workflow')) {
        $buildDir = getcwd();
        generateBoxJson($output, $buildDir);
        $buildFile = buildPhar($output, $buildDir);
        testPhar($output, $buildFile);
        $releaseFile = $buildFile;
    } else {
        $buildDir = createBuildDirectory($output);
        cloneSingleCommitIntoBuildDir($output, $buildDir);
        composerInstall($output, $buildDir);
        generateBoxJson($output, $buildDir);
        $buildFile = buildPhar($output, $buildDir);
        testPhar($output, $buildFile);
        $releaseFile = copyPharToDestinations($output, $buildFile);
    }

    $output->writeln(
        [
            "<info>🍺  Build done</info>",
            '',
            sprintf(
                'Built %s (size %s) in %.4f seconds, consumed %s memory',
                $releaseFile,
                formatBytes(filesize($releaseFile), 2),
                microtime(true) - BUILD_START_TIME,
                formatBytes(memory_get_peak_usage(true), 2)
            ),
        ]
    );
    exit(0);
}

main();