MikoPBX\PBXCoreREST\Workers\WorkerApiCommands

Complexity

Total Complexity

27

Size/Duplication

Total Lines	192
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

<?php
 * @package MikoPBX\PBXCoreREST\Workers
 */
class WorkerApiCommands extends WorkerBase
{
    /**
     * Maximum time to wait for child process (seconds)
     */
    private const int CHILD_PROCESS_TIMEOUT = 60;

A parse error occurred: Syntax error, unexpected T_STRING, expecting '=' on line 54 at column 22

    /**
     * Starts the worker.
     *
     * @param array $argv The command-line arguments passed to the worker.
     *
     * @return void
     */
    public function start(array $argv): void
    {
        /** @var BeanstalkConnectionWorkerApiProvider $beanstalk */
        $beanstalk = $this->di->getShared(BeanstalkConnectionWorkerApiProvider::SERVICE_NAME);
        if ($beanstalk->isConnected() === false) {
            SystemMessages::sysLogMsg(self::class, 'Fail connect to beanstalkd...');
            sleep(2);
            return;
        }
        $beanstalk->subscribe($this->makePingTubeName(self::class), [$this, 'pingCallBack']);
        $beanstalk->subscribe(__CLASS__, [$this, 'prepareAnswer']);

        while ($this->needRestart === false) {
            $beanstalk->wait();
        }
    }

    /**
     * Process API request from frontend
     *
     * @param BeanstalkClient $message
     *
     */
    public function prepareAnswer(BeanstalkClient $message): void
    {
        // Use fork to run the callback in a separate process
        $pid = pcntl_fork();
        if ($pid === -1) {
            // Fork failed
            throw new \RuntimeException("Failed to fork a new process.");
        }

        if ($pid === 0) {
            try {
                // Child process
                $this->setForked();
                $this->processRequest($message);
            } catch (Throwable $e) {
                CriticalErrorsHandler::handleExceptionWithSyslog($e);
                exit(1); // Exit with error
            }
            exit(0);
        }

        // Parent process
        $startTime = time();
        $status = 0;

        // Wait for child with timeout
        while (time() - $startTime < self::CHILD_PROCESS_TIMEOUT) {
            $res = pcntl_waitpid($pid, $status, WNOHANG);
            if ($res === -1) {
                throw new RuntimeException("Failed to wait for child process");
            }
            if ($res > 0) {
                // Child process completed
                if (pcntl_wifexited($status)) {
                    $exitStatus = pcntl_wexitstatus($status);
                    if ($exitStatus !== 0) {
                        throw new RuntimeException("Child process failed with status: $exitStatus");
                    }
                    return;
                }
                if (pcntl_wifsignaled($status)) {
                    $signal = pcntl_wtermsig($status);
                    throw new RuntimeException("Child process terminated by signal: $signal");
                }
                return;
            }
            usleep(100000); // Sleep 100ms
        }

        // Timeout reached
        posix_kill($pid, SIGTERM);
        throw new RuntimeException("Child process timed out");
    }

    /**
     * Process individual API request
     *
     * @param BeanstalkClient $message The message from beanstalk queue
     *
     * @throws JsonException If JSON parsing fails
     * @throws RuntimeException|Throwable If processor execution fails
     */
    private function processRequest(BeanstalkClient $message): void
    {
        $res = new PBXApiResult();
        $res->processor = __METHOD__;
        try {
            // Parse request JSON
            $request = $this->parseRequestJson($message);

            // Setup basic request parameters
            $async = (bool)($request['async'] ?? false);
            $processor = $this->resolveProcessor($request);

            $res->processor = $processor;

            // Old style, we can remove it in 2025
            if ($processor === 'modules') {
                $processor = PbxExtensionsProcessor::class;
            }

            // Handle debug mode if needed
            $this->handleDebugMode($request);

            // Process the request
            if (!method_exists($processor, 'callback')) {
                throw new RuntimeException("Unknown processor - {$processor}");
            }

            cli_set_process_title(__CLASS__ . '-' . $request['action']);

            // Execute request based on async flag
            if ($async) {
                $this->handleAsyncRequest($message, $request, $res);
            } else {
                $res = $processor::callback($request);
                $this->sendResponse($message, $res);
            }

            // Check if reload is needed after successful execution
            if ($res->success) {
                $this->checkNeedReload($request);
            }

        } catch (JsonException $e) {
            $this->handleError($res, "Invalid JSON in request: {$e->getMessage()}");
            $this->sendResponse($message, $res);
        } catch (InvalidArgumentException $e) {
            $this->handleError($res, "Invalid request parameters: {$e->getMessage()}");
            $this->sendResponse($message, $res);
        } catch (Throwable $e) {
            $this->handleError($res, CriticalErrorsHandler::handleExceptionWithSyslog($e));
            $this->sendResponse($message, $res);
            throw $e; // Re-throw for parent process to handle
        }
    }

    /**
     * Parse and validate request JSON
     *
     * @param BeanstalkClient $message
     * @return array
     * @throws JsonException
     */
    private function parseRequestJson(BeanstalkClient $message): array
    {
        $request = json_decode(
            $message->getBody(),
            true,
            512,
            JSON_THROW_ON_ERROR
        );

        if (!is_array($request)) {
            throw new InvalidArgumentException('Request must be a JSON object');
        }

        return $request;
    }

    /**
     * Resolve processor class name
     *
     * @param array $request
     * @return string
     * @throws InvalidArgumentException
     */
    private function resolveProcessor(array $request): string
    {
        $processor = $request['processor'] ?? '';

        // Handle legacy 'modules' processor name
        if ($processor === 'modules') {