AppserverIo\Server\Standalone::start()

Complexity

Conditions	13
Paths	214

Size

Total Lines	127
Code Lines	58

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	182

Importance

Changes	5
Bugs	0	Features	2

<?php
    public function start()
    {
        // check environment first
        $this->checkEnvironment();

        // register autoloader if exists
        if (!is_null(SERVER_AUTOLOADER)) {
            require SERVER_AUTOLOADER;
        }

        // check which config format should be used based on file extension
        if ($configType = str_replace('.', '', strrchr(SERVER_CONFIGFILE, '.'))) {
            $mainConfigurationType = '\AppserverIo\Server\Configuration\Main' . ucfirst($configType) . 'Configuration';
            // try to instantiate configuration type based on file
            if (class_exists($mainConfigurationType)) {
                $mainConfiguration = new $mainConfigurationType(SERVER_CONFIGFILE);
            } else {
                die("Configuration file '$configType' is not valid or not found.". PHP_EOL);

The method start() contains an exit expression.

            }
        } else {
            die("No valid configuration file given." . PHP_EOL);

The method start() contains an exit expression.

        }

        // init loggers
        $loggers = array();
        foreach ($mainConfiguration->getLoggerConfigs() as $loggerConfig) {
            // init processors
            $processors = array();
            foreach ($loggerConfig->getProcessors() as $processorType) {
                // create processor
                $processors[] = new $processorType();
            }
            // init handlers
            $handlers = array();
            foreach ($loggerConfig->getHandlers() as $handlerType => $handlerData) {
                // create handler
                $handlerTypeClass = new \ReflectionClass($handlerType);
                $handler = $handlerTypeClass->newInstanceArgs($handlerData["params"]);
                if (isset($handlerData['formatter'])) {
                    $formatterData = $handlerData['formatter'];
                    $formatterType = $formatterData['type'];
                    // create formatter
                    $formatterClass = new \ReflectionClass($formatterType);
                    $formatter = $formatterClass->newInstanceArgs($formatterData['params']);
                    // set formatter to logger
                    $handler->setFormatter($formatter);
                }
                $handlers[] = $handler;
            }

            // get logger type
            $loggerType = $loggerConfig->getType();
            // init logger instance
            $logger = new $loggerType($loggerConfig->getName(), $handlers, $processors);

            $logger->debug(sprintf('logger initialised: %s (%s)', $loggerConfig->getName(), $loggerType));

            // set logger by name
            $loggers[$loggerConfig->getName()] = $logger;
        }

        // init upstreams
        $upstreams = array();
        foreach ($mainConfiguration->getUpstreamConfigs() as $upstreamConfig) {
            // get upstream type
            $upstreamType = $upstreamConfig->getType();
            // init upstream instance
            $upstream = new $upstreamType();
            // init upstream servers
            $servers = array();
            foreach ($upstreamConfig->getServers() as $serverName => $serverData) {
                $serverType = $serverData['type'];
                $serverParams = $serverData['params'];
                $servers[$serverName] = new $serverType($serverParams);
            }
            // inject server instances to upstream
            $upstream->injectServers($servers);
            // set upstream by name
            $upstreams[$upstreamConfig->getName()] = $upstream;
        }

        // init servers
        $servers = array();
        foreach ($mainConfiguration->getServerConfigs() as $serverConfig) {
            // get type definitions
            $serverType = $serverConfig->getType();
            $serverContextType = $serverConfig->getServerContextType();

            // init server context
            $serverContext = new $serverContextType();
            $serverContext->init($serverConfig);

            // check if logger name exists
            if (isset($loggers[$serverConfig->getLoggerName()])) {
                $serverContext->injectLoggers($loggers);
            } else {
                throw new \Exception(sprintf('Logger %s not found.', $serverConfig->getLoggerName()));
            }

            // inject upstreams to server context
            $serverContext->injectUpstreams($upstreams);

            // Create the server (which should start it automatically)
            $server = new $serverType($serverContext);
            // Collect the servers we started
            $servers[] = $server;

            // Synchronize the server so we can wait until preparation of the server finished.
            // This is used e.g. to wait for port opening or other important dependencies to proper server functionality

            /*
            $server->synchronized(
                function ($self) {
                    $self->wait();
                },
                $server
            );
            */
        }

        // @TODO here we are able to switch user to someone with lower rights (e.g. www-data or nobody)

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

        // wait for servers
        foreach ($servers as $server) {
            $server->join();
        }
    }
}