class.servicehelper.php

Go to the documentation of this file.

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

class ServiceHelper
{
    private static $serviceMap = null;

    private static $syntaxCheckMap = null;

    private static function initializeMappings($bearsamppBins)
    {
        if (self::$serviceMap === null) {
            self::$serviceMap = [
                BinApache::SERVICE_NAME => $bearsamppBins->getApache(),
                BinMysql::SERVICE_NAME => $bearsamppBins->getMysql(),
                BinMariadb::SERVICE_NAME => $bearsamppBins->getMariadb(),
                BinMailpit::SERVICE_NAME => $bearsamppBins->getMailpit(),
                BinMemcached::SERVICE_NAME => $bearsamppBins->getMemcached(),
                BinPostgresql::SERVICE_NAME => $bearsamppBins->getPostgresql(),
                BinXlight::SERVICE_NAME => $bearsamppBins->getXlight(),
            ];
        }
 
        if (self::$syntaxCheckMap === null) {
            self::$syntaxCheckMap = [
                BinApache::SERVICE_NAME => BinApache::CMD_SYNTAX_CHECK,
                BinMysql::SERVICE_NAME => BinMysql::CMD_SYNTAX_CHECK,
                BinMariadb::SERVICE_NAME => BinMariadb::CMD_SYNTAX_CHECK,
            ];
        }
    }

    public static function getBinFromServiceName($serviceName, $bearsamppBins)
    {
        self::initializeMappings($bearsamppBins);
        return isset(self::$serviceMap[$serviceName]) ? self::$serviceMap[$serviceName] : null;
    }

    public static function getSyntaxCheckCmd($serviceName, $bearsamppBins = null)
    {
        if ($bearsamppBins !== null) {
            self::initializeMappings($bearsamppBins);
        }
        return isset(self::$syntaxCheckMap[$serviceName]) ? self::$syntaxCheckMap[$serviceName] : null;
    }

    public static function getServiceDisplayName($bin, $service)
    {
        return $bin->getName() . ' ' . $bin->getVersion() . ' (' . $service->getName() . ')';
    }

    public static function processServices($bearsamppBins, callable $callback)
    {
        self::initializeMappings($bearsamppBins);
 
        foreach ($bearsamppBins->getServices() as $serviceName => $service) {
            $bin = self::getBinFromServiceName($serviceName, $bearsamppBins);
            $syntaxCheckCmd = self::getSyntaxCheckCmd($serviceName);
 
            if ($bin !== null) {
                $callback($serviceName, $service, $bin, $syntaxCheckCmd);
            }
        }
    }

    public static function startService($bin, $syntaxCheckCmd = null, $showErrors = true)
    {
        return Util::startService($bin, $syntaxCheckCmd, $showErrors);
    }

    public static function stopService($service)
    {
        return $service->stop();
    }

    public static function restartService($service)
    {
        return $service->restart();
    }

    public static function getAllServiceNames()
    {
        return [
            BinApache::SERVICE_NAME,
            BinMysql::SERVICE_NAME,
            BinMariadb::SERVICE_NAME,
            BinMailpit::SERVICE_NAME,
            BinMemcached::SERVICE_NAME,
            BinPostgresql::SERVICE_NAME,
            BinXlight::SERVICE_NAME,
        ];
    }

    public static function hasSyntaxCheck($serviceName)
    {
        if (self::$syntaxCheckMap === null) {
            // Initialize with dummy bins object if needed
            self::$syntaxCheckMap = [
                BinApache::SERVICE_NAME => BinApache::CMD_SYNTAX_CHECK,
                BinMysql::SERVICE_NAME => BinMysql::CMD_SYNTAX_CHECK,
                BinMariadb::SERVICE_NAME => BinMariadb::CMD_SYNTAX_CHECK,
            ];
        }
        return isset(self::$syntaxCheckMap[$serviceName]);
    }

    public static function getServicePort($serviceName, $bearsamppBins)
    {
        $bin = self::getBinFromServiceName($serviceName, $bearsamppBins);
        if ($bin === null) {
            return 0;
        }
 
        // Different services have different methods to get port
        if (method_exists($bin, 'getPort')) {
            return $bin->getPort();
        } elseif (method_exists($bin, 'getSmtpPort')) {
            return $bin->getSmtpPort();
        }
 
        return 0;
    }

    public static function stopAllServicesParallel($bearsamppBins, ?callable $progressCallback = null, $shutdownTimeout = 15)
    {
        Log::trace('ServiceHelper::stopAllServicesParallel() starting');
        $startTime = microtime(true);
 
        $services = $bearsamppBins->getServices();
        if (empty($services)) {
            Log::trace('No services to shut down');
            return true;
        }
 
        Log::trace('Starting parallel shutdown of ' . count($services) . ' services');
 
        // Try parallel shutdown
        $parallelSuccess = self::shutdownServicesParallel($services, $progressCallback, $shutdownTimeout);
 
        if ($parallelSuccess) {
            $duration = round(microtime(true) - $startTime, 3);
            Log::info('Parallel shutdown completed successfully in ' . $duration . 's');
            return true;
        }
 
        // Fallback to sequential
        Log::info('Parallel shutdown timed out, falling back to sequential shutdown');
        $sequentialSuccess = self::shutdownServicesSequential($services, $progressCallback);
 
        $totalDuration = round(microtime(true) - $startTime, 3);
        Log::info('Sequential shutdown completed in ' . $totalDuration . 's');
 
        return $sequentialSuccess;
    }

    private static function shutdownServicesParallel($services, ?callable $progressCallback = null, $shutdownTimeout = 15)
    {
        Log::trace('Phase 1: Sending stop commands to all services');
        $totalServices = count($services);
        $currentIndex = 0;
 
        // Phase 1: Send stop commands (non-blocking)
        foreach ($services as $serviceName => $service) {
            $currentIndex++;
            if ($progressCallback) {
                $progressCallback($currentIndex, $totalServices, $serviceName);
            }
 
            Log::trace('Sending stop to: ' . $serviceName);
            $service->stop();
        }
 
        // Phase 2: Monitor status
        Log::trace('Phase 2: Monitoring service status');
        $monitorStartTime = microtime(true);
        $monitorTimeout = $shutdownTimeout;
        $checkInterval = 0.5;
        $allStopped = false;
 
        while ((microtime(true) - $monitorStartTime) < $monitorTimeout) {
            $allStopped = true;
 
            foreach ($services as $serviceName => $service) {
                if (!$service->isStopped()) {
                    $allStopped = false;
                    break;
                }
            }
 
            if ($allStopped) {
                Log::trace('All services stopped in parallel phase');
                return true;
            }
 
            usleep($checkInterval * 1000000);
        }
 
        // Phase 3: Force kill remaining services
        Log::trace('Phase 3: Force killing remaining services');
        foreach ($services as $serviceName => $service) {
            if (!$service->isStopped()) {
                Log::trace('Force killing: ' . $serviceName);
                self::forceKillService($serviceName);
            }
        }
 
        // Final check
        return self::allServicesStopped($services);
    }

    private static function shutdownServicesSequential($services, ?callable $progressCallback = null)
    {
        Log::trace('Starting sequential shutdown phase');
        $totalServices = count($services);
        $currentIndex = 0;
 
        foreach ($services as $serviceName => $service) {
            $currentIndex++;
            if ($progressCallback) {
                $progressCallback($currentIndex, $totalServices, $serviceName);
            }
 
            Log::trace('Sequential stop: ' . $serviceName);
            $service->stop();
 
            if (!$service->isStopped()) {
                Log::trace('Force killing: ' . $serviceName);
                self::forceKillService($serviceName);
            }
        }
 
        return self::allServicesStopped($services);
    }

    private static function forceKillService($serviceName)
    {
        $processMap = [
            BinApache::SERVICE_NAME => 'httpd.exe',
            BinMysql::SERVICE_NAME => 'mysqld.exe',
            BinMariadb::SERVICE_NAME => 'mysqld.exe',
            BinMailpit::SERVICE_NAME => 'mailpit.exe',
            BinMemcached::SERVICE_NAME => 'memcached.exe',
            BinPostgresql::SERVICE_NAME => 'postgres.exe',
            BinXlight::SERVICE_NAME => 'xlightftpd.exe',
            'nodejs' => 'node.exe',  // NodeJS - not a Windows service but needs to be killed on exit
        ];
 
        if (isset($processMap[$serviceName])) {
            Log::trace('Killing process: ' . $processMap[$serviceName]);
            Win32Ps::killBins([$processMap[$serviceName]]);
            return true;
        }
 
        return false;
    }

    private static function allServicesStopped($services)
    {
        foreach ($services as $serviceName => $service) {
            if (!$service->isStopped()) {
                return false;
            }
        }
        return true;
    }

    public static function startAllServicesParallel($serviceInfos, ?callable $progressCallback = null, $startupTimeout = 30)
    {
        Log::trace('ServiceHelper::startAllServicesParallel() starting with ' . count($serviceInfos) . ' services');
        $startTime = microtime(true);
 
        if (empty($serviceInfos)) {
            Log::trace('No services to start');
            return true;
        }
 
        Log::trace('Starting parallel startup of ' . count($serviceInfos) . ' services');
 
        // Try parallel startup
        $parallelSuccess = self::startServicesParallel($serviceInfos, $progressCallback, $startupTimeout);
 
        if ($parallelSuccess) {
            $duration = round(microtime(true) - $startTime, 3);
            Log::info('Parallel startup completed successfully in ' . $duration . 's');
            return true;
        }
 
        // Fallback to sequential
        Log::info('Parallel startup timed out, falling back to sequential startup');
        $sequentialSuccess = self::startServicesSequential($serviceInfos, $progressCallback);
 
        $totalDuration = round(microtime(true) - $startTime, 3);
        Log::info('Sequential startup completed in ' . $totalDuration . 's');
 
        return $sequentialSuccess;
    }

    private static function startServicesParallel($serviceInfos, ?callable $progressCallback = null, $startupTimeout = 30)
    {
        Log::trace('Phase 1: Sending start commands to all services');
        $totalServices = count($serviceInfos);
        $currentIndex = 0;
 
        // Phase 1: Send start commands (non-blocking)
        foreach ($serviceInfos as $serviceName => $serviceInfo) {
            $currentIndex++;
            if ($progressCallback) {
                $progressCallback($currentIndex, $totalServices, $serviceInfo['name']);
            }
 
            Log::trace('Sending start to: ' . $serviceName);
            $service = $serviceInfo['service'];
 
            // Start the service
            $service->start();
        }
 
        // Phase 2: Monitor status
        Log::trace('Phase 2: Monitoring service status');
        $monitorStartTime = microtime(true);
        $monitorTimeout = $startupTimeout;
        $checkInterval = 0.5;
        $allRunning = false;
        $failedServices = [];
 
        while ((microtime(true) - $monitorStartTime) < $monitorTimeout) {
            $allRunning = true;
 
            foreach ($serviceInfos as $serviceName => $serviceInfo) {
                $service = $serviceInfo['service'];
 
                if (!$service->isRunning()) {
                    $allRunning = false;
                    $failedServices[$serviceName] = $serviceInfo;
                }
            }
 
            if ($allRunning) {
                Log::trace('All services running in parallel phase');
                return true;
            }
 
            usleep($checkInterval * 1000000);
        }
 
        // Phase 3: Retry failed services
        if (!empty($failedServices)) {
            Log::trace('Phase 3: Retrying ' . count($failedServices) . ' failed services');
 
            foreach ($failedServices as $serviceName => $serviceInfo) {
                $service = $serviceInfo['service'];
 
                if (!$service->isRunning()) {
                    Log::trace('Retrying start for: ' . $serviceName);
                    $service->start();
                    usleep(500000); // 500ms delay between retries
                }
            }
 
            // Final check
            return self::allServicesRunning($serviceInfos);
        }
 
        return true;
    }

    private static function startServicesSequential($serviceInfos, ?callable $progressCallback = null)
    {
        Log::trace('Starting sequential startup phase');
        $totalServices = count($serviceInfos);
        $currentIndex = 0;
 
        foreach ($serviceInfos as $serviceName => $serviceInfo) {
            $currentIndex++;
            if ($progressCallback) {
                $progressCallback($currentIndex, $totalServices, $serviceInfo['name']);
            }
 
            Log::trace('Sequential start: ' . $serviceName);
            $service = $serviceInfo['service'];
 
            $service->start();
 
            // Small delay between service starts
            usleep(200000);
 
            if (!$service->isRunning()) {
                Log::trace('Service failed to start: ' . $serviceName);
                // Retry once
                $service->start();
                usleep(500000);
            }
        }
 
        return self::allServicesRunning($serviceInfos);
    }

    private static function allServicesRunning($serviceInfos)
    {
        foreach ($serviceInfos as $serviceName => $serviceInfo) {
            $service = $serviceInfo['service'];
            if (!$service->isRunning()) {
                return false;
            }
        }
        return true;
    }
}