mirror of
https://github.com/crazywhalecc/static-php-cli.git
synced 2026-03-18 21:04:52 +08:00
579 lines
19 KiB
PHP
579 lines
19 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace SPC\builder;
|
|
|
|
use PharIo\FileSystem\File;
|
|
use SPC\exception\ExceptionHandler;
|
|
use SPC\exception\FileSystemException;
|
|
use SPC\exception\InterruptException;
|
|
use SPC\exception\RuntimeException;
|
|
use SPC\exception\WrongUsageException;
|
|
use SPC\store\Config;
|
|
use SPC\store\FileSystem;
|
|
use SPC\store\LockFile;
|
|
use SPC\store\SourceManager;
|
|
use SPC\util\CustomExt;
|
|
|
|
abstract class BuilderBase
|
|
{
|
|
/** @var int Concurrency */
|
|
public int $concurrency = 1;
|
|
|
|
/** @var array<string, LibraryBase> libraries */
|
|
protected array $libs = [];
|
|
|
|
/** @var array<string, Extension> extensions */
|
|
protected array $exts = [];
|
|
|
|
/** @var array<int, string> extension names */
|
|
protected array $ext_list = [];
|
|
|
|
/** @var array<int, string> library names */
|
|
protected array $lib_list = [];
|
|
|
|
/** @var bool compile libs only (just mark it) */
|
|
protected bool $libs_only = false;
|
|
|
|
/** @var array<string, mixed> compile options */
|
|
protected array $options = [];
|
|
|
|
/** @var string patch point name */
|
|
protected string $patch_point = '';
|
|
|
|
/**
|
|
* Convert libraries to class
|
|
*
|
|
* @param array<string> $sorted_libraries Libraries to build (if not empty, must sort first)
|
|
* @throws FileSystemException
|
|
* @throws RuntimeException
|
|
* @throws WrongUsageException
|
|
* @internal
|
|
*/
|
|
abstract public function proveLibs(array $sorted_libraries);
|
|
|
|
/**
|
|
* Set-Up libraries
|
|
*
|
|
* @throws FileSystemException
|
|
* @throws RuntimeException
|
|
* @throws WrongUsageException
|
|
*/
|
|
public function setupLibs(): void
|
|
{
|
|
// build all libs
|
|
foreach ($this->libs as $lib) {
|
|
$starttime = microtime(true);
|
|
match ($lib->setup($this->getOption('rebuild', false))) {
|
|
LIB_STATUS_OK => logger()->info('lib [' . $lib::NAME . '] setup success, took ' . round(microtime(true) - $starttime, 2) . ' s'),
|
|
LIB_STATUS_ALREADY => logger()->notice('lib [' . $lib::NAME . '] already built'),
|
|
LIB_STATUS_BUILD_FAILED => logger()->error('lib [' . $lib::NAME . '] build failed'),
|
|
LIB_STATUS_INSTALL_FAILED => logger()->error('lib [' . $lib::NAME . '] install failed'),
|
|
default => logger()->warning('lib [' . $lib::NAME . '] build status unknown'),
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add library to build.
|
|
*
|
|
* @param LibraryBase $library Library object
|
|
*/
|
|
public function addLib(LibraryBase $library): void
|
|
{
|
|
$this->libs[$library::NAME] = $library;
|
|
}
|
|
|
|
/**
|
|
* Get library object by name.
|
|
*/
|
|
public function getLib(string $name): ?LibraryBase
|
|
{
|
|
return $this->libs[$name] ?? null;
|
|
}
|
|
|
|
/**
|
|
* Get all library objects.
|
|
*
|
|
* @return LibraryBase[]
|
|
*/
|
|
public function getLibs(): array
|
|
{
|
|
return $this->libs;
|
|
}
|
|
|
|
/**
|
|
* Add extension to build.
|
|
*/
|
|
public function addExt(Extension $extension): void
|
|
{
|
|
$this->exts[$extension->getName()] = $extension;
|
|
}
|
|
|
|
/**
|
|
* Get extension object by name.
|
|
*/
|
|
public function getExt(string $name): ?Extension
|
|
{
|
|
return $this->exts[$name] ?? null;
|
|
}
|
|
|
|
/**
|
|
* Get all extension objects.
|
|
*
|
|
* @return Extension[]
|
|
*/
|
|
public function getExts(bool $including_shared = true): array
|
|
{
|
|
if ($including_shared) {
|
|
return $this->exts;
|
|
}
|
|
return array_filter($this->exts, fn ($ext) => $ext->isBuildStatic());
|
|
}
|
|
|
|
/**
|
|
* Check if there is a cpp extensions or libraries.
|
|
*
|
|
* @throws FileSystemException
|
|
* @throws WrongUsageException
|
|
*/
|
|
public function hasCpp(): bool
|
|
{
|
|
// judge cpp-extension
|
|
$exts = array_keys($this->getExts(false));
|
|
foreach ($exts as $ext) {
|
|
if (Config::getExt($ext, 'cpp-extension', false) === true) {
|
|
return true;
|
|
}
|
|
}
|
|
$libs = array_keys($this->getLibs());
|
|
foreach ($libs as $lib) {
|
|
if (Config::getLib($lib, 'cpp-library', false) === true) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Set libs only mode.
|
|
*
|
|
* @internal
|
|
*/
|
|
public function setLibsOnly(bool $status = true): void
|
|
{
|
|
$this->libs_only = $status;
|
|
}
|
|
|
|
/**
|
|
* Verify the list of "ext" extensions for validity and declare an Extension object to check the dependencies of the extensions.
|
|
*
|
|
* @throws FileSystemException
|
|
* @throws RuntimeException
|
|
* @throws \ReflectionException
|
|
* @throws \Throwable|WrongUsageException
|
|
* @internal
|
|
*/
|
|
public function proveExts(array $static_extensions, array $shared_extensions = [], bool $skip_check_deps = false, bool $skip_extract = false): void
|
|
{
|
|
CustomExt::loadCustomExt();
|
|
// judge ext
|
|
foreach ($static_extensions as $ext) {
|
|
// if extension does not support static build, throw exception
|
|
if (!in_array('static', Config::getExtTarget($ext))) {
|
|
throw new WrongUsageException('Extension [' . $ext . '] does not support static build!');
|
|
}
|
|
}
|
|
foreach ($shared_extensions as $ext) {
|
|
// if extension does not support shared build, throw exception
|
|
if (!in_array('shared', Config::getExtTarget($ext)) && !in_array($ext, $shared_extensions)) {
|
|
throw new WrongUsageException('Extension [' . $ext . '] does not support shared build!');
|
|
}
|
|
}
|
|
if (!$skip_extract) {
|
|
$this->emitPatchPoint('before-php-extract');
|
|
SourceManager::initSource(sources: ['php-src'], source_only: true);
|
|
$this->emitPatchPoint('after-php-extract');
|
|
if ($this->getPHPVersionID() >= 80000) {
|
|
$this->emitPatchPoint('before-micro-extract');
|
|
SourceManager::initSource(sources: ['micro'], source_only: true);
|
|
$this->emitPatchPoint('after-micro-extract');
|
|
}
|
|
$this->emitPatchPoint('before-exts-extract');
|
|
SourceManager::initSource(exts: [...$static_extensions, ...$shared_extensions]);
|
|
$this->emitPatchPoint('after-exts-extract');
|
|
}
|
|
|
|
foreach ([...$static_extensions, ...$shared_extensions] as $extension) {
|
|
$class = CustomExt::getExtClass($extension);
|
|
/** @var Extension $ext */
|
|
$ext = new $class($extension, $this);
|
|
if (in_array($extension, $static_extensions)) {
|
|
$ext->setBuildStatic();
|
|
}
|
|
if (in_array($extension, $shared_extensions)) {
|
|
$ext->setBuildShared();
|
|
}
|
|
$this->addExt($ext);
|
|
}
|
|
|
|
if ($skip_check_deps) {
|
|
return;
|
|
}
|
|
|
|
foreach ($this->getExts() as $ext) {
|
|
$ext->checkDependency();
|
|
}
|
|
$this->ext_list = [...$static_extensions, ...$shared_extensions];
|
|
}
|
|
|
|
/**
|
|
* Start to build PHP
|
|
*
|
|
* @param int $build_target Build target, see BUILD_TARGET_*
|
|
*/
|
|
abstract public function buildPHP(int $build_target = BUILD_TARGET_NONE);
|
|
|
|
/**
|
|
* Test PHP
|
|
*/
|
|
abstract public function testPHP(int $build_target = BUILD_TARGET_NONE);
|
|
|
|
/**
|
|
* @throws WrongUsageException
|
|
* @throws RuntimeException
|
|
* @throws FileSystemException
|
|
*/
|
|
public function buildSharedExts(): void
|
|
{
|
|
$lines = file(BUILD_BIN_PATH . '/php-config');
|
|
$extension_dir_line = null;
|
|
foreach ($lines as $key => $value) {
|
|
if (str_starts_with($value, 'extension_dir=')) {
|
|
$lines[$key] = 'extension_dir="' . BUILD_MODULES_PATH . '"' . PHP_EOL;
|
|
$extension_dir_line = $value;
|
|
break;
|
|
}
|
|
}
|
|
file_put_contents(BUILD_BIN_PATH . '/php-config', implode('', $lines));
|
|
FileSystem::createDir(BUILD_MODULES_PATH);
|
|
try {
|
|
foreach ($this->getExts() as $ext) {
|
|
if (!$ext->isBuildShared()) {
|
|
continue;
|
|
}
|
|
$ext->buildShared();
|
|
}
|
|
} catch (RuntimeException $e) {
|
|
FileSystem::replaceFileLineContainsString(BUILD_BIN_PATH . '/php-config', 'extension_dir=', $extension_dir_line);
|
|
throw $e;
|
|
}
|
|
FileSystem::replaceFileLineContainsString(BUILD_BIN_PATH . '/php-config', 'extension_dir=', $extension_dir_line);
|
|
}
|
|
|
|
/**
|
|
* Generate extension enable arguments for configure.
|
|
* e.g. --enable-mbstring
|
|
*
|
|
* @throws FileSystemException
|
|
* @throws WrongUsageException
|
|
*/
|
|
public function makeStaticExtensionArgs(): string
|
|
{
|
|
$ret = [];
|
|
foreach ($this->getExts() as $ext) {
|
|
$arg = $ext->getConfigureArg();
|
|
if ($ext->isBuildShared() && !$ext->isBuildStatic()) {
|
|
if (
|
|
(Config::getExt($ext->getName(), 'type') === 'builtin' &&
|
|
!file_exists(SOURCE_PATH . '/php-src/ext/' . $ext->getName() . '/config.m4')) ||
|
|
Config::getExt($ext->getName(), 'build-with-php') === true
|
|
) {
|
|
$arg = $ext->getConfigureArg(true);
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
logger()->info($ext->getName() . ' is using ' . $arg);
|
|
$ret[] = trim($arg);
|
|
}
|
|
logger()->debug('Using configure: ' . implode(' ', $ret));
|
|
return implode(' ', $ret);
|
|
}
|
|
|
|
/**
|
|
* Get libs only mode.
|
|
*/
|
|
public function isLibsOnly(): bool
|
|
{
|
|
return $this->libs_only;
|
|
}
|
|
|
|
/**
|
|
* Get PHP Version ID from php-src/main/php_version.h
|
|
*
|
|
* @throws RuntimeException
|
|
* @throws WrongUsageException
|
|
*/
|
|
public function getPHPVersionID(): int
|
|
{
|
|
if (!file_exists(SOURCE_PATH . '/php-src/main/php_version.h')) {
|
|
throw new WrongUsageException('PHP source files are not available, you need to download them first');
|
|
}
|
|
|
|
$file = file_get_contents(SOURCE_PATH . '/php-src/main/php_version.h');
|
|
if (preg_match('/PHP_VERSION_ID (\d+)/', $file, $match) !== 0) {
|
|
return intval($match[1]);
|
|
}
|
|
|
|
throw new RuntimeException('PHP version file format is malformed, please remove it and download again');
|
|
}
|
|
|
|
public function getPHPVersion(): string
|
|
{
|
|
if (!file_exists(SOURCE_PATH . '/php-src/main/php_version.h')) {
|
|
throw new WrongUsageException('PHP source files are not available, you need to download them first');
|
|
}
|
|
$file = file_get_contents(SOURCE_PATH . '/php-src/main/php_version.h');
|
|
if (preg_match('/PHP_VERSION "(.*)"/', $file, $match) !== 0) {
|
|
return $match[1];
|
|
}
|
|
|
|
throw new RuntimeException('PHP version file format is malformed, please remove it and download again');
|
|
}
|
|
|
|
/**
|
|
* Get PHP version from archive file name.
|
|
*
|
|
* @param null|string $file php-*.*.*.tar.gz filename, read from lockfile if empty
|
|
*/
|
|
public function getPHPVersionFromArchive(?string $file = null): false|string
|
|
{
|
|
if ($file === null) {
|
|
$lock = LockFile::get('php-src');
|
|
if ($lock === null) {
|
|
return false;
|
|
}
|
|
$file = LockFile::getLockFullPath($lock);
|
|
}
|
|
if (preg_match('/php-(\d+\.\d+\.\d+(?:RC\d+)?)\.tar\.(?:gz|bz2|xz)/', $file, $match)) {
|
|
return $match[1];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public function getMicroVersion(): false|string
|
|
{
|
|
$file = FileSystem::convertPath(SOURCE_PATH . '/php-src/sapi/micro/php_micro.h');
|
|
if (!file_exists($file)) {
|
|
return false;
|
|
}
|
|
|
|
$content = file_get_contents($file);
|
|
$ver = '';
|
|
preg_match('/#define PHP_MICRO_VER_MAJ (\d)/m', $content, $match);
|
|
$ver .= $match[1] . '.';
|
|
preg_match('/#define PHP_MICRO_VER_MIN (\d)/m', $content, $match);
|
|
$ver .= $match[1] . '.';
|
|
preg_match('/#define PHP_MICRO_VER_PAT (\d)/m', $content, $match);
|
|
$ver .= $match[1];
|
|
return $ver;
|
|
}
|
|
|
|
/**
|
|
* Get build type name string to display.
|
|
*
|
|
* @param int $type Build target type
|
|
*/
|
|
public function getBuildTypeName(int $type): string
|
|
{
|
|
$ls = [];
|
|
if (($type & BUILD_TARGET_CLI) === BUILD_TARGET_CLI) {
|
|
$ls[] = 'cli';
|
|
}
|
|
if (($type & BUILD_TARGET_MICRO) === BUILD_TARGET_MICRO) {
|
|
$ls[] = 'micro';
|
|
}
|
|
if (($type & BUILD_TARGET_FPM) === BUILD_TARGET_FPM) {
|
|
$ls[] = 'fpm';
|
|
}
|
|
if (($type & BUILD_TARGET_EMBED) === BUILD_TARGET_EMBED) {
|
|
$ls[] = 'embed';
|
|
}
|
|
if (($type & BUILD_TARGET_FRANKENPHP) === BUILD_TARGET_FRANKENPHP) {
|
|
$ls[] = 'frankenphp';
|
|
}
|
|
return implode(', ', $ls);
|
|
}
|
|
|
|
/**
|
|
* Get builder options (maybe changed by user)
|
|
*
|
|
* @param string $key Option key
|
|
* @param mixed $default If not exists, return this value
|
|
*/
|
|
public function getOption(string $key, mixed $default = null): mixed
|
|
{
|
|
return $this->options[$key] ?? $default;
|
|
}
|
|
|
|
/**
|
|
* Get all builder options
|
|
*/
|
|
public function getOptions(): array
|
|
{
|
|
return $this->options;
|
|
}
|
|
|
|
/**
|
|
* Set builder options if not exists.
|
|
*/
|
|
public function setOptionIfNotExist(string $key, mixed $value): void
|
|
{
|
|
if (!isset($this->options[$key])) {
|
|
$this->options[$key] = $value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set builder options.
|
|
*/
|
|
public function setOption(string $key, mixed $value): void
|
|
{
|
|
$this->options[$key] = $value;
|
|
}
|
|
|
|
public function getEnvString(array $vars = ['cc', 'cxx', 'ar', 'ld']): string
|
|
{
|
|
$env = [];
|
|
foreach ($vars as $var) {
|
|
$var = strtoupper($var);
|
|
if (getenv($var) !== false) {
|
|
$env[] = "{$var}=" . getenv($var);
|
|
}
|
|
}
|
|
return implode(' ', $env);
|
|
}
|
|
|
|
/**
|
|
* Get builder patch point name.
|
|
*/
|
|
public function getPatchPoint(): string
|
|
{
|
|
return $this->patch_point;
|
|
}
|
|
|
|
/**
|
|
* Validate libs and exts can be compiled successfully in current environment
|
|
*/
|
|
public function validateLibsAndExts(): void
|
|
{
|
|
foreach ($this->libs as $lib) {
|
|
$lib->validate();
|
|
}
|
|
foreach ($this->getExts() as $ext) {
|
|
$ext->validate();
|
|
}
|
|
}
|
|
|
|
public function emitPatchPoint(string $point_name): void
|
|
{
|
|
$this->patch_point = $point_name;
|
|
if (($patches = $this->getOption('with-added-patch', [])) === []) {
|
|
return;
|
|
}
|
|
|
|
foreach ($patches as $patch) {
|
|
try {
|
|
if (!file_exists($patch)) {
|
|
throw new RuntimeException("Additional patch script file {$patch} not found!");
|
|
}
|
|
logger()->debug('Running additional patch script: ' . $patch);
|
|
require $patch;
|
|
} catch (InterruptException $e) {
|
|
if ($e->getCode() === 0) {
|
|
logger()->notice('Patch script ' . $patch . ' interrupted' . ($e->getMessage() ? (': ' . $e->getMessage()) : '.'));
|
|
} else {
|
|
logger()->error('Patch script ' . $patch . ' interrupted with error code [' . $e->getCode() . ']' . ($e->getMessage() ? (': ' . $e->getMessage()) : '.'));
|
|
}
|
|
exit($e->getCode());
|
|
} catch (\Throwable $e) {
|
|
logger()->critical('Patch script ' . $patch . ' failed to run.');
|
|
if ($this->getOption('debug')) {
|
|
ExceptionHandler::getInstance()->handle($e);
|
|
} else {
|
|
logger()->critical('Please check with --debug option to see more details.');
|
|
}
|
|
throw $e;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function checkBeforeBuildPHP(int $rule): void
|
|
{
|
|
if (($rule & BUILD_TARGET_FRANKENPHP) === BUILD_TARGET_FRANKENPHP) {
|
|
if (!$this->getOption('enable-zts')) {
|
|
throw new WrongUsageException('FrankenPHP SAPI requires ZTS enabled PHP, build with `--enable-zts`!');
|
|
}
|
|
// frankenphp doesn't support windows, BSD is currently not supported by static-php-cli
|
|
if (!in_array(PHP_OS_FAMILY, ['Linux', 'Darwin'])) {
|
|
throw new WrongUsageException('FrankenPHP SAPI is only available on Linux and macOS!');
|
|
}
|
|
// frankenphp needs package go-xcaddy installed
|
|
$pkg_dir = PKG_ROOT_PATH . '/go-xcaddy-' . arch2gnu(php_uname('m')) . '-' . osfamily2shortname();
|
|
if (!file_exists("{$pkg_dir}/bin/go") || !file_exists("{$pkg_dir}/bin/xcaddy")) {
|
|
global $argv;
|
|
throw new WrongUsageException("FrankenPHP SAPI requires the go-xcaddy package, please install it first: {$argv[0]} install-pkg go-xcaddy");
|
|
}
|
|
// frankenphp needs libxml2 lib on macos, see: https://github.com/php/frankenphp/blob/main/frankenphp.go#L17
|
|
if (PHP_OS_FAMILY === 'Darwin' && !$this->getLib('libxml2')) {
|
|
throw new WrongUsageException('FrankenPHP SAPI for macOS requires libxml2 library, please include the `xml` extension in your build.');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate micro extension test php code.
|
|
*/
|
|
protected function generateMicroExtTests(): string
|
|
{
|
|
$php = "<?php\n\necho '[micro-test-start]' . PHP_EOL;\n";
|
|
|
|
foreach ($this->getExts(false) as $ext) {
|
|
$ext_name = $ext->getDistName();
|
|
if (!empty($ext_name)) {
|
|
$php .= "echo 'Running micro with {$ext_name} test' . PHP_EOL;\n";
|
|
$php .= "assert(extension_loaded('{$ext_name}'));\n\n";
|
|
}
|
|
}
|
|
$php .= "echo '[micro-test-end]';\n";
|
|
return $php;
|
|
}
|
|
|
|
protected function getMicroTestTasks(): array
|
|
{
|
|
return [
|
|
'micro_ext_test' => [
|
|
'content' => ($this->getOption('without-micro-ext-test') ? '<?php echo "[micro-test-start][micro-test-end]";' : $this->generateMicroExtTests()),
|
|
'conditions' => [
|
|
// program success
|
|
function ($ret) { return $ret === 0; },
|
|
// program returns expected output
|
|
function ($ret, $out) {
|
|
$raw_out = trim(implode('', $out));
|
|
return str_starts_with($raw_out, '[micro-test-start]') && str_ends_with($raw_out, '[micro-test-end]');
|
|
},
|
|
],
|
|
],
|
|
'micro_zend_bug_test' => [
|
|
'content' => ($this->getOption('without-micro-ext-test') ? '<?php echo "hello";' : file_get_contents(ROOT_DIR . '/src/globals/common-tests/micro_zend_mm_heap_corrupted.txt')),
|
|
'conditions' => [
|
|
// program success
|
|
function ($ret) { return $ret === 0; },
|
|
],
|
|
],
|
|
];
|
|
}
|
|
}
|