608 lines
14 KiB
PHP
608 lines
14 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Kiri\Di;
|
|
|
|
use DirectoryIterator;
|
|
use Kiri\Abstracts\Component;
|
|
use Kiri\Di\Inject\Container;
|
|
use Kiri\Di\Inject\Skip;
|
|
use Kiri\Di\Interface\InjectMethodInterface;
|
|
use Psr\Container\ContainerInterface;
|
|
use ReflectionClass;
|
|
use ReflectionMethod;
|
|
use Throwable;
|
|
|
|
class Scanner extends Component
|
|
{
|
|
#[Container(ContainerInterface::class)]
|
|
public ContainerInterface $container;
|
|
|
|
public array $files = [];
|
|
|
|
private array $fileMtimes = [];
|
|
|
|
private ?bool $hasOpcache = null;
|
|
|
|
private string $basePath;
|
|
|
|
private ScanManifest $manifest;
|
|
|
|
private ?ChangeSet $changeSet = null;
|
|
|
|
private array $visitedFiles = [];
|
|
|
|
private array $config = [
|
|
'skip_patterns' => ['/vendor/', '/tests/', '/cache/', '/node_modules/'],
|
|
'skip_directories' => [],
|
|
'extensions' => ['php'],
|
|
'max_depth' => 20,
|
|
'follow_links' => false,
|
|
'cache_enabled' => false,
|
|
'cache_ttl' => 3600,
|
|
'debug' => false,
|
|
];
|
|
|
|
public function __construct()
|
|
{
|
|
$this->basePath = $this->normalizePath($_SERVER['PWD'] ?? APP_PATH ?? getcwd());
|
|
$this->manifest = new ScanManifest();
|
|
}
|
|
|
|
public function setConfig(array $config): void
|
|
{
|
|
$this->config = array_merge($this->config, $config);
|
|
}
|
|
|
|
public function scan(string $path, ?string $cacheFile = null): ChangeSet
|
|
{
|
|
$path = $this->normalizePath($path);
|
|
$this->changeSet = new ChangeSet();
|
|
$this->visitedFiles = [];
|
|
$cacheLoaded = false;
|
|
|
|
if ($this->config['cache_enabled']) {
|
|
$cacheFile = $cacheFile ?? $this->getDefaultCacheFile();
|
|
if ($this->loadFromCache($cacheFile, $path)) {
|
|
$this->replayManifest($path);
|
|
return $this->changeSet;
|
|
}
|
|
$cacheLoaded = $this->manifest->all() !== [];
|
|
}
|
|
|
|
$this->scanDirectory($path);
|
|
$this->detectRemovedFiles($path);
|
|
|
|
if ($cacheLoaded) {
|
|
$this->replayManifest($path, $this->changeSet->getChangedFiles());
|
|
}
|
|
|
|
$this->syncLegacyState();
|
|
|
|
if ($this->config['cache_enabled']) {
|
|
$this->saveToCache($cacheFile);
|
|
}
|
|
|
|
return $this->changeSet;
|
|
}
|
|
|
|
public function scanFiles(array $files, ?string $scopePath = null, ?string $cacheFile = null): ChangeSet
|
|
{
|
|
$this->changeSet = new ChangeSet();
|
|
$this->visitedFiles = [];
|
|
$cacheLoaded = false;
|
|
|
|
if ($scopePath !== null) {
|
|
$scopePath = $this->normalizePath($scopePath);
|
|
}
|
|
|
|
if ($this->config['cache_enabled'] && $scopePath !== null) {
|
|
$cacheFile = $cacheFile ?? $this->getDefaultCacheFile();
|
|
$this->loadFromCache($cacheFile, $scopePath);
|
|
$cacheLoaded = $this->manifest->all() !== [];
|
|
}
|
|
|
|
foreach (array_values(array_unique($files)) as $file) {
|
|
$path = $this->normalizePath($file);
|
|
if (file_exists($path)) {
|
|
$this->processFile($path);
|
|
continue;
|
|
}
|
|
|
|
$this->markRemovedFile($path);
|
|
}
|
|
|
|
if ($cacheLoaded && $scopePath !== null) {
|
|
$this->replayManifest($scopePath, $this->changeSet->getChangedFiles());
|
|
}
|
|
|
|
$this->syncLegacyState();
|
|
return $this->changeSet;
|
|
}
|
|
|
|
private function scanDirectory(string $path, int $depth = 0): void
|
|
{
|
|
if ($depth > $this->config['max_depth']) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
$dir = new DirectoryIterator($path);
|
|
} catch (Throwable $e) {
|
|
$this->logError($e, ['path' => $path, 'action' => 'open_directory']);
|
|
return;
|
|
}
|
|
|
|
foreach ($dir as $item) {
|
|
if ($this->shouldSkipItem($item)) {
|
|
continue;
|
|
}
|
|
|
|
$realPath = $this->normalizePath($item->getRealPath() ?: $item->getPathname());
|
|
if ($item->isDir()) {
|
|
if ($this->shouldSkipDirectory($realPath)) {
|
|
continue;
|
|
}
|
|
|
|
if ($item->isLink() && !$this->config['follow_links']) {
|
|
continue;
|
|
}
|
|
|
|
$this->scanDirectory($realPath, $depth + 1);
|
|
continue;
|
|
}
|
|
|
|
if ($item->isFile()) {
|
|
$this->processFile($realPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function shouldSkipItem(DirectoryIterator $item): bool
|
|
{
|
|
return $item->isDot() || str_starts_with($item->getFilename(), '.');
|
|
}
|
|
|
|
private function shouldSkipDirectory(string $path): bool
|
|
{
|
|
$path = rtrim($this->normalizePath($path), '/') . '/';
|
|
$skipDirs = array_merge(
|
|
$this->config['skip_directories'],
|
|
config('site.scanner.skip', [])
|
|
);
|
|
|
|
if (in_array($path, $skipDirs, true)) {
|
|
return true;
|
|
}
|
|
|
|
foreach ($this->config['skip_patterns'] as $pattern) {
|
|
if (strpos($path, $pattern) !== false) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function processFile(string $path): void
|
|
{
|
|
$path = $this->normalizePath($path);
|
|
if (!in_array(pathinfo($path, PATHINFO_EXTENSION), $this->config['extensions'], true)) {
|
|
return;
|
|
}
|
|
|
|
$this->visitedFiles[$path] = true;
|
|
if (!$this->shouldProcessFile($path)) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
$oldClasses = $this->manifest->getClasses($path);
|
|
$this->invalidateClasses($oldClasses);
|
|
$newClasses = $this->loadAndParseFile($path);
|
|
|
|
$this->manifest->set($path, (int)filemtime($path), $newClasses);
|
|
$this->changeSet?->addChangedFile($path);
|
|
|
|
foreach (array_diff($oldClasses, $newClasses) as $class) {
|
|
$this->changeSet?->addRemovedClass($class);
|
|
}
|
|
|
|
foreach ($newClasses as $class) {
|
|
$this->changeSet?->addChangedClass($class);
|
|
}
|
|
} catch (Throwable $e) {
|
|
$this->logError($e, [
|
|
'file' => $path,
|
|
'action' => 'process_file',
|
|
]);
|
|
|
|
if ($e instanceof \ParseError) {
|
|
throw $e;
|
|
}
|
|
}
|
|
}
|
|
|
|
private function shouldProcessFile(string $path): bool
|
|
{
|
|
if (!file_exists($path)) {
|
|
return false;
|
|
}
|
|
|
|
$mtime = (int)filemtime($path);
|
|
$cachedMtime = $this->manifest->getMtime($path);
|
|
|
|
return $cachedMtime === null || $cachedMtime < $mtime;
|
|
}
|
|
|
|
private function loadAndParseFile(string $path): array
|
|
{
|
|
$this->optimizeWithOpcache($path);
|
|
|
|
$before = get_declared_classes();
|
|
require_once $path;
|
|
$after = get_declared_classes();
|
|
|
|
$classes = array_values(array_diff($after, $before));
|
|
foreach ($classes as $class) {
|
|
if (class_exists($class)) {
|
|
$this->analyzeClass($class);
|
|
}
|
|
}
|
|
|
|
return $classes;
|
|
}
|
|
|
|
private function optimizeWithOpcache(string $path): void
|
|
{
|
|
if ($this->hasOpcache === null) {
|
|
$this->hasOpcache = function_exists('opcache_invalidate') && function_exists('opcache_compile_file');
|
|
}
|
|
|
|
if (!$this->hasOpcache) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
opcache_invalidate($path, true);
|
|
opcache_compile_file($path);
|
|
} catch (Throwable $e) {
|
|
if ($this->config['debug']) {
|
|
$this->logError($e, [
|
|
'file' => $path,
|
|
'action' => 'opcache_optimize',
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function analyzeClass(string $class): void
|
|
{
|
|
try {
|
|
$reflect = $this->container->getReflectionClass($class);
|
|
if (!$reflect->isInstantiable() || $reflect->isTrait() || $reflect->isEnum() || $reflect->isInterface()) {
|
|
return;
|
|
}
|
|
|
|
if ($this->shouldSkipClass($reflect)) {
|
|
return;
|
|
}
|
|
|
|
$this->analyzeClassMethods($reflect, $class);
|
|
} catch (Throwable $e) {
|
|
$this->logError($e, [
|
|
'class' => $class,
|
|
'action' => 'analyze_class',
|
|
]);
|
|
}
|
|
}
|
|
|
|
private function shouldSkipClass(ReflectionClass $reflect): bool
|
|
{
|
|
$attributes = array_map(fn($attr) => $attr->getName(), $reflect->getAttributes());
|
|
|
|
return in_array(Skip::class, $attributes, true)
|
|
|| in_array(\Attribute::class, $attributes, true);
|
|
}
|
|
|
|
private function analyzeClassMethods(ReflectionClass $reflect, string $class): void
|
|
{
|
|
foreach ($reflect->getMethods() as $method) {
|
|
if ($method->isStatic() || $method->getDeclaringClass()->getName() !== $class) {
|
|
continue;
|
|
}
|
|
|
|
$this->processMethodAttributes($method, $class);
|
|
}
|
|
}
|
|
|
|
private function processMethodAttributes(ReflectionMethod $method, string $class): void
|
|
{
|
|
foreach ($method->getAttributes() as $attribute) {
|
|
$attributeName = $attribute->getName();
|
|
if (!class_exists($attributeName)) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
$instance = $attribute->newInstance();
|
|
if ($instance instanceof InjectMethodInterface) {
|
|
$instance->dispatch($class, $method->getName());
|
|
}
|
|
} catch (Throwable $e) {
|
|
$this->logError($e, [
|
|
'class' => $class,
|
|
'method' => $method->getName(),
|
|
'attribute' => $attributeName,
|
|
'action' => 'process_attribute',
|
|
]);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function getDefaultCacheFile(): string
|
|
{
|
|
$cacheDir = defined('APP_PATH')
|
|
? rtrim(str_replace('\\', '/', APP_PATH), '/') . '/storage/.kiri-scanner-cache/'
|
|
: sys_get_temp_dir() . '/kiri-scanner-cache/';
|
|
if (!is_dir($cacheDir)) {
|
|
mkdir($cacheDir, 0755, true);
|
|
}
|
|
|
|
$projectHash = md5(__DIR__);
|
|
return $cacheDir . 'scanner_' . $projectHash . '.json';
|
|
}
|
|
|
|
private function loadFromCache(string $cacheFile, string $path): bool
|
|
{
|
|
if (!file_exists($cacheFile)) {
|
|
return false;
|
|
}
|
|
|
|
if (filemtime($cacheFile) + $this->config['cache_ttl'] < time()) {
|
|
return false;
|
|
}
|
|
|
|
$data = json_decode(file_get_contents($cacheFile), true);
|
|
if (!is_array($data) || !isset($data['manifest'])) {
|
|
return false;
|
|
}
|
|
|
|
$this->manifest->fromArray($data['manifest']);
|
|
$this->syncLegacyState();
|
|
|
|
return !$this->hasDirectoryChanged($path);
|
|
}
|
|
|
|
private function hasDirectoryChanged(string $path): bool
|
|
{
|
|
$currentFiles = $this->collectFiles($path);
|
|
$cachedFiles = $this->manifest->paths(rtrim($path, '/\\') . '/');
|
|
|
|
sort($currentFiles);
|
|
sort($cachedFiles);
|
|
if ($currentFiles !== $cachedFiles) {
|
|
return true;
|
|
}
|
|
|
|
foreach ($currentFiles as $file) {
|
|
if (!file_exists($file)) {
|
|
return true;
|
|
}
|
|
|
|
if ($this->manifest->getMtime($file) !== (int)filemtime($file)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function saveToCache(string $cacheFile): void
|
|
{
|
|
$data = [
|
|
'manifest' => $this->manifest->all(),
|
|
'timestamp' => time(),
|
|
'version' => '2.0',
|
|
];
|
|
|
|
file_put_contents($cacheFile, json_encode($data, JSON_PRETTY_PRINT));
|
|
$this->cleanupOldCacheFiles(dirname($cacheFile));
|
|
}
|
|
|
|
private function cleanupOldCacheFiles(string $cacheDir): void
|
|
{
|
|
$files = glob($cacheDir . '/scanner_*.json');
|
|
$now = time();
|
|
|
|
foreach ($files as $file) {
|
|
if (filemtime($file) + (7 * 24 * 3600) < $now) {
|
|
unlink($file);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function logError(Throwable $e, array $context = []): void
|
|
{
|
|
$fullContext = array_merge($context, [
|
|
'message' => $e->getMessage(),
|
|
'code' => $e->getCode(),
|
|
'file' => $e->getFile(),
|
|
'line' => $e->getLine(),
|
|
'trace' => $e->getTraceAsString(),
|
|
'time' => date('Y-m-d H:i:s'),
|
|
]);
|
|
|
|
if (function_exists('error')) {
|
|
error($e, $fullContext);
|
|
} else {
|
|
error_log(json_encode($fullContext));
|
|
}
|
|
|
|
if ($this->config['debug'] && php_sapi_name() === 'cli') {
|
|
echo "Scanner Error: {$e->getMessage()} in {$e->getFile()}:{$e->getLine()}\n";
|
|
if ($context !== []) {
|
|
echo 'Context: ' . json_encode($context) . "\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
public function load_directory(string $path): void
|
|
{
|
|
$this->scan($path);
|
|
}
|
|
|
|
protected function parseFile($file): void
|
|
{
|
|
$absolutePath = $this->normalizePath($this->basePath . '/' . ltrim((string)$file, '/')) . '.php';
|
|
if (file_exists($absolutePath)) {
|
|
$this->processFile($absolutePath);
|
|
}
|
|
}
|
|
|
|
protected function skipNames(ReflectionClass $reflect): array
|
|
{
|
|
return array_map(fn($attr) => $attr->getName(), $reflect->getAttributes());
|
|
}
|
|
|
|
public function getStats(): array
|
|
{
|
|
return [
|
|
'total_files' => count($this->files),
|
|
'cached_mtimes' => count($this->fileMtimes),
|
|
'base_path' => $this->basePath,
|
|
'config' => $this->config,
|
|
'manifest_entries' => count($this->manifest->all()),
|
|
];
|
|
}
|
|
|
|
|
|
/**
|
|
* 返回 Master 扫描产生的完整清单数据，供 Worker 轻量重建注解路由
|
|
* @return array{string: array{mtime: int, classes: string[]}}
|
|
*/
|
|
public function getManifestClasses(): array
|
|
{
|
|
return $this->manifest->all();
|
|
}
|
|
|
|
public function reset(): void
|
|
{
|
|
$this->files = [];
|
|
$this->fileMtimes = [];
|
|
$this->hasOpcache = null;
|
|
$this->manifest = new ScanManifest();
|
|
$this->changeSet = null;
|
|
$this->visitedFiles = [];
|
|
}
|
|
|
|
private function detectRemovedFiles(string $path): void
|
|
{
|
|
$prefix = rtrim($path, '/\\') . '/';
|
|
foreach ($this->manifest->paths($prefix) as $file) {
|
|
if (!isset($this->visitedFiles[$file])) {
|
|
$this->markRemovedFile($file);
|
|
}
|
|
}
|
|
}
|
|
|
|
private function markRemovedFile(string $path): void
|
|
{
|
|
if (!$this->manifest->has($path)) {
|
|
return;
|
|
}
|
|
|
|
$classes = $this->manifest->remove($path);
|
|
$this->invalidateClasses($classes);
|
|
foreach ($classes as $class) {
|
|
$this->changeSet?->addRemovedClass($class);
|
|
}
|
|
|
|
$this->changeSet?->addRemovedFile($path);
|
|
}
|
|
|
|
private function syncLegacyState(): void
|
|
{
|
|
$this->files = array_keys($this->manifest->all());
|
|
$this->fileMtimes = [];
|
|
foreach ($this->manifest->all() as $path => $entry) {
|
|
$this->fileMtimes[$path] = (int)$entry['mtime'];
|
|
}
|
|
}
|
|
|
|
private function collectFiles(string $path, int $depth = 0): array
|
|
{
|
|
if ($depth > $this->config['max_depth']) {
|
|
return [];
|
|
}
|
|
|
|
$files = [];
|
|
try {
|
|
$dir = new DirectoryIterator($path);
|
|
} catch (Throwable) {
|
|
return [];
|
|
}
|
|
|
|
foreach ($dir as $item) {
|
|
if ($this->shouldSkipItem($item)) {
|
|
continue;
|
|
}
|
|
|
|
$realPath = $this->normalizePath($item->getRealPath() ?: $item->getPathname());
|
|
if ($item->isDir()) {
|
|
if ($this->shouldSkipDirectory($realPath)) {
|
|
continue;
|
|
}
|
|
if ($item->isLink() && !$this->config['follow_links']) {
|
|
continue;
|
|
}
|
|
$files = array_merge($files, $this->collectFiles($realPath, $depth + 1));
|
|
continue;
|
|
}
|
|
|
|
if ($item->isFile() && in_array(pathinfo($realPath, PATHINFO_EXTENSION), $this->config['extensions'], true)) {
|
|
$files[] = $realPath;
|
|
}
|
|
}
|
|
|
|
return $files;
|
|
}
|
|
|
|
private function normalizePath(string $path): string
|
|
{
|
|
$resolved = realpath($path) ?: $path;
|
|
return str_replace('\\', '/', $resolved);
|
|
}
|
|
|
|
private function replayManifest(string $path, array $skipPaths = []): void
|
|
{
|
|
$skip = array_fill_keys(array_map([$this, 'normalizePath'], $skipPaths), true);
|
|
$prefix = rtrim($path, '/\\') . '/';
|
|
|
|
foreach ($this->manifest->paths($prefix) as $file) {
|
|
if (isset($skip[$file])) {
|
|
continue;
|
|
}
|
|
|
|
foreach ($this->manifest->getClasses($file) as $class) {
|
|
if (class_exists($class)) {
|
|
$this->analyzeClass($class);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private function invalidateClasses(array $classes): void
|
|
{
|
|
foreach ($classes as $class) {
|
|
if (method_exists($this->container, 'forgetClass')) {
|
|
$this->container->forgetClass($class);
|
|
}
|
|
if (class_exists(\Kiri\Router\Defer\DeferRegistry::class)) {
|
|
\Kiri\Router\Defer\DeferRegistry::removeClass($class);
|
|
}
|
|
}
|
|
}
|
|
}
|