class.fibermoduleloader.php

Go to the documentation of this file.

<?php
/*
 * Copyright (c) 2021-2026 Bearsampp
 * License:  GNU General Public License version 3 or later; see LICENSE.txt
 * Website: https://bearsampp.com
 * Github: https://github.com/Bearsampp
 */

class FiberModuleLoader
{
    private static $fibers = [];

    private static $enabled = false;

    public static function init(): bool
    {
        self::$enabled = PHP_VERSION_ID >= 80100;
 
        if (!self::$enabled) {
            Log::warning('FiberModuleLoader unavailable (requires PHP 8.1+, using fallback async)');
        }
 
        return self::$enabled;
    }

    public static function loadInFiber(
        string $module,
        callable $loader,
        int $timeout = 5000
    ): bool {
        if (!self::$enabled) {
            // Fallback: load synchronously
            call_user_func($loader);
 
            return false;
        }
 
        // Create fiber for concurrent execution
        $fiberModule           = new FiberModule($module, $loader, $timeout);
        self::$fibers[$module] = $fiberModule;
 
        return true;
    }

    public static function waitForModule(string $module, int $timeout = 5000): bool
    {
        if (!isset(self::$fibers[$module])) {
            return true; // Not loaded in fiber, must be ready
        }
 
        return self::$fibers[$module]->wait($timeout);
    }

    public static function waitAll(int $timeout = 5000): bool
    {
        if (!self::$enabled || empty(self::$fibers)) {
            return true;
        }
 
        $start   = microtime(true);
        $maxWait = $timeout / 1000;
 
        foreach (self::$fibers as $module => $fiber) {
            $elapsed   = microtime(true) - $start;
            $remaining = max(100, ($maxWait - $elapsed) * 1000);
 
            if (!$fiber->wait((int)$remaining)) {
                Log::warning('Timeout waiting for module: ' . $module);
 
                return false;
            }
        }
 
        return true;
    }

    public static function isLoaded(string $module): bool
    {
        if (!isset(self::$fibers[$module])) {
            return true; // Not in fiber system
        }
 
        return self::$fibers[$module]->isReady();
    }

    public static function isLoading(string $module): bool
    {
        if (!isset(self::$fibers[$module])) {
            return false;
        }
 
        return !self::$fibers[$module]->isReady();
    }

    public static function getFiber(string $module): ?FiberModule
    {
        return self::$fibers[$module] ?? null;
    }

    public static function isAvailable(): bool
    {
        return self::$enabled;
    }

    public static function getLoadedModules(): array
    {
        return array_keys(self::$fibers);
    }
}

class FiberModule
{
    private $fiber;

    private $moduleName;

    private $initialized = false;

    private $result = null;

    private $timeout;

    public function __construct(string $moduleName, callable $loader, int $timeout = 5000)
    {
        $this->moduleName = $moduleName;
        $this->timeout    = $timeout;
 
        // Create fiber (PHP 8.1+)
        $this->fiber = new Fiber(function () use ($loader) {
            try {
                $this->result      = call_user_func($loader);
                $this->initialized = true;
            } catch (Throwable $e) {
                Log::error('Fiber error in ' . $this->moduleName . ': ' . $e->getMessage());
                $this->initialized = true; // Mark as done even on error
            }
        });
 
        // Start the fiber (begins execution until first yield)
        try {
            $this->fiber->start();
        } catch (Throwable $e) {
            Log::error('Failed to start fiber for ' . $this->moduleName . ': ' . $e->getMessage());
            $this->initialized = true;
        }
    }

    public function wait(int $timeout = 5000): bool
    {
        if ($this->initialized) {
            return true;
        }
 
        $start   = microtime(true);
        $maxWait = $timeout / 1000;
 
        while (!$this->initialized) {
            // Try to resume the fiber if suspended
            if ($this->fiber->isSuspended()) {
                try {
                    $this->fiber->resume();
                } catch (Throwable $e) {
                    Log::error('Fiber resume error: ' . $e->getMessage());
                    $this->initialized = true;
                    break;
                }
            }
 
            // Check if fiber completed
            if ($this->fiber->isTerminated()) {
                $this->initialized = true;
                break;
            }
 
            // Timeout check
            if ((microtime(true) - $start) > $maxWait) {
                Log::warning('Timeout waiting for module: ' . $this->moduleName);
 
                return false;
            }
 
            // Prevent busy-waiting (yield to other operations)
            usleep(1000);
        }
 
        return true;
    }

    public function isReady(): bool
    {
        return $this->initialized || $this->fiber->isTerminated();
    }

    public function isSuspended(): bool
    {
        return $this->fiber->isSuspended();
    }

    public function isTerminated(): bool
    {
        return $this->fiber->isTerminated();
    }

    public function getModuleName(): string
    {
        return $this->moduleName;
    }

    public function getResult()
    {
        return $this->result;
    }
}