Cecil\Command\Serve::execute()

Complexity

Conditions	32
Paths	> 20000

Size

Total Lines	179
Code Lines	123

Duplication

Lines	0
Ratio	0 %

Importance

Changes	7
Bugs	3	Features	0

<?php
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $open = $input->getOption('open');
        $host = $input->getOption('host');
        $port = $input->getOption('port');
        $drafts = $input->getOption('drafts');
        $optimize = $input->getOption('optimize');
        $clearcache = $input->getOption('clear-cache');
        $page = $input->getOption('page');
        $noignorevcs = $input->getOption('no-ignore-vcs');
        $metrics = $input->getOption('metrics');
        $timeout = $input->getOption('timeout');
        $verbose = $input->getOption('verbose');

        $resourceWatcher = null;
        $this->watcherEnabled = $input->getOption('watch');

        // checks if PHP executable is available
        $phpFinder = new PhpExecutableFinder();
        $php = $phpFinder->find();
        if ($php === false) {
            throw new RuntimeException('Unable to find a local PHP executable.');
        }

        // setup server
        $this->setUpServer();
        $command = \sprintf(
            '"%s" -S %s:%d -t "%s" "%s"',
            $php,
            $host,
            $port,
            Util::joinFile($this->getPath(), self::SERVE_OUTPUT),
            Util::joinFile($this->getPath(), self::TMP_DIR, 'router.php')
        );
        $process = Process::fromShellCommandline($command);

        // setup build process
        $buildProcessArguments = [
            $php,
            $_SERVER['argv'][0],
        ];
        $buildProcessArguments[] = 'build';
        $buildProcessArguments[] = $this->getPath();
        if (!empty($this->getConfigFiles())) {
            $buildProcessArguments[] = '--config';
            $buildProcessArguments[] = implode(',', $this->getConfigFiles());
        }
        if ($drafts) {
            $buildProcessArguments[] = '--drafts';
        }
        if ($optimize === true) {
            $buildProcessArguments[] = '--optimize';
        }
        if ($optimize === false) {
            $buildProcessArguments[] = '--no-optimize';
        }
        if ($clearcache === null) {
            $buildProcessArguments[] = '--clear-cache';
        }
        if (!empty($clearcache)) {
            $buildProcessArguments[] = '--clear-cache';
            $buildProcessArguments[] = $clearcache;
        }
        if ($verbose) {
            $buildProcessArguments[] = '-' . str_repeat('v', $_SERVER['SHELL_VERBOSITY']);
        }
        if (!empty($page)) {
            $buildProcessArguments[] = '--page';
            $buildProcessArguments[] = $page;
        }
        if (!empty($metrics)) {
            $buildProcessArguments[] = '--metrics';
        }
        $buildProcessArguments[] = '--baseurl';
        $buildProcessArguments[] = "http://$host:$port/";
        $buildProcessArguments[] = '--output';
        $buildProcessArguments[] = self::SERVE_OUTPUT;
        $buildProcess = new Process(
            $buildProcessArguments,
            null,
            ['BOX_REQUIREMENT_CHECKER' => '0'] // prevents double check (build then serve)
        );
        $buildProcess->setTty(Process::isTtySupported());
        $buildProcess->setPty(Process::isPtySupported());
        $buildProcess->setTimeout((float) $timeout);
        $processOutputCallback = function ($type, $buffer) use ($output) {
            $output->write($buffer, false, OutputInterface::OUTPUT_RAW);
        };

        // builds before serve
        $output->writeln(\sprintf('<comment>Build process: %s</comment>', implode(' ', $buildProcessArguments)), OutputInterface::VERBOSITY_DEBUG);
        $buildProcess->run($processOutputCallback);
        if ($buildProcess->isSuccessful()) {
            $this->buildSuccessActions($output);
        }
        if ($buildProcess->getExitCode() !== 0) {
            $this->tearDownServer();

            return 1;
        }

        // handles serve process
        if (!$process->isStarted()) {
            $messageSuffix = '';
            // setup resource watcher
            if ($this->watcherEnabled) {
                $resourceWatcher = $this->setupWatcher($noignorevcs);
                $resourceWatcher->initialize();
                $messageSuffix = ' with changes watcher';
            }
            // starts server
            try {
                if (\function_exists('\pcntl_signal')) {
                    pcntl_async_signals(true);
                    pcntl_signal(SIGINT, [$this, 'tearDownServer']);
                    pcntl_signal(SIGTERM, [$this, 'tearDownServer']);
                }
                $output->writeln(\sprintf('<comment>Server process: %s</comment>', $command), OutputInterface::VERBOSITY_DEBUG);
                $output->writeln(\sprintf('Starting server (<href=http://%s:%d>http://%s:%d</>)%s...', $host, $port, $host, $port, $messageSuffix));
                $process->start(function ($type, $buffer) {
                    if ($type === Process::ERR) {
                        error_log($buffer, 3, Util::joinFile($this->getPath(), self::TMP_DIR, 'errors.log'));
                    }
                });
                if ($open) {
                    $output->writeln('Opening web browser...');
                    Util\Platform::openBrowser(\sprintf('http://%s:%s', $host, $port));
                }
                while ($process->isRunning()) {
                    sleep(1); // wait for server is ready
                    if (!fsockopen($host, (int) $port)) {
                        $output->writeln('<info>Server is not ready.</info>');

                        return 1;
                    }
                    if ($this->watcherEnabled && $resourceWatcher instanceof ResourceWatcher) {
                        $watcher = $resourceWatcher->findChanges();
                        if ($watcher->hasChanges()) {
                            $output->writeln('<comment>Changes detected.</comment>');
                            // prints deleted/new/updated files in debug mode
                            if (\count($watcher->getDeletedFiles()) > 0) {
                                $output->writeln('<comment>Deleted files:</comment>', OutputInterface::VERBOSITY_DEBUG);
                                foreach ($watcher->getDeletedFiles() as $file) {
                                    $output->writeln("<comment>- $file</comment>", OutputInterface::VERBOSITY_DEBUG);
                                }
                            }
                            if (\count($watcher->getNewFiles()) > 0) {
                                $output->writeln('<comment>New files:</comment>', OutputInterface::VERBOSITY_DEBUG);
                                foreach ($watcher->getNewFiles() as $file) {
                                    $output->writeln("<comment>- $file</comment>", OutputInterface::VERBOSITY_DEBUG);
                                }
                            }
                            if (\count($watcher->getUpdatedFiles()) > 0) {
                                $output->writeln('<comment>Updated files:</comment>', OutputInterface::VERBOSITY_DEBUG);
                                foreach ($watcher->getUpdatedFiles() as $file) {
                                    $output->writeln("<comment>- $file</comment>", OutputInterface::VERBOSITY_DEBUG);
                                }
                            }
                            $output->writeln('');
                            // re-builds
                            $buildProcess->run($processOutputCallback);
                            if ($buildProcess->isSuccessful()) {
                                $this->buildSuccessActions($output);
                            }
                            $output->writeln('<info>Server is runnning...</info>');
                        }
                    }
                }
                if ($process->getExitCode() > 0) {
                    $output->writeln(\sprintf('<comment>%s</comment>', trim($process->getErrorOutput())));
                }
            } catch (ProcessFailedException $e) {
                $this->tearDownServer();

                throw new RuntimeException(\sprintf($e->getMessage()));
            }
        }

        return 0;
    }