Serve::setUpServer() - Code Metrics - Inspection of "Update CHANGELOG" - Cecilapp/Cecil - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f60aa5...78e74f )

unknown

created 2025-08-01 15:13 UTC

Serve::setUpServer() A

↳ Parent: Serve

Complexity

Conditions	6
Paths	30

Size

Total Lines	28
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
cc	6
eloc	18
nc	30
nop	0
dl	0
loc	28
rs	9.0444
c	3
b	0
f	0

<?php

/**
 * This file is part of Cecil.
 *
 * (c) Arnaud Ligny <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Cecil\Command;

use Cecil\Exception\RuntimeException;
use Cecil\Util;
use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Process\Exception\ProcessFailedException;
use Symfony\Component\Process\PhpExecutableFinder;
use Symfony\Component\Process\Process;
use Yosymfony\ResourceWatcher\Crc32ContentHash;
use Yosymfony\ResourceWatcher\ResourceCacheMemory;
use Yosymfony\ResourceWatcher\ResourceWatcher;

/**
 * Serve command.
 *
 * This command starts the built-in web server with live reloading capabilities.
 * It allows users to serve their website locally and automatically rebuild it when changes are detected.
 * It also supports opening the web browser automatically and includes options for drafts, optimization, and more.
 */
class Serve extends AbstractCommand
{
    /** @var boolean */
    protected $watcherEnabled;

    /**
     * {@inheritdoc}
     */
    protected function configure()
    {
        $this
            ->setName('serve')
            ->setDescription('Starts the built-in server')
            ->setDefinition([
                new InputArgument('path', InputArgument::OPTIONAL, 'Use the given path as working directory'),
                new InputOption('open', 'o', InputOption::VALUE_NONE, 'Open web browser automatically'),
                new InputOption('host', null, InputOption::VALUE_REQUIRED, 'Server host', 'localhost'),
                new InputOption('port', null, InputOption::VALUE_REQUIRED, 'Server port', '8000'),
                new InputOption('watch', 'w', InputOption::VALUE_NEGATABLE, 'Enable (or disable --no-watch) changes watcher (enabled by default)', true),
                new InputOption('drafts', 'd', InputOption::VALUE_NONE, 'Include drafts'),
                new InputOption('optimize', null, InputOption::VALUE_NEGATABLE, 'Enable (or disable --no-optimize) optimization of generated files'),
                new InputOption('config', 'c', InputOption::VALUE_REQUIRED, 'Set the path to extra config files (comma-separated)'),
                new InputOption('clear-cache', null, InputOption::VALUE_OPTIONAL, 'Clear cache before build (optional cache key as regular expression)', false),
                new InputOption('page', 'p', InputOption::VALUE_REQUIRED, 'Build a specific page'),
                new InputOption('no-ignore-vcs', null, InputOption::VALUE_NONE, 'Changes watcher must not ignore VCS directories'),
                new InputOption('metrics', 'm', InputOption::VALUE_NONE, 'Show build metrics (duration and memory) of each step'),
                new InputOption('timeout', null, InputOption::VALUE_REQUIRED, 'Sets the process timeout (max. runtime) in seconds', 7200), // default is 2 hours
            ])
            ->setHelp(
                <<<'EOF'
The <info>%command.name%</> command starts the live-reloading-built-in web server.

  <info>%command.full_name%</>
  <info>%command.full_name% path/to/the/working/directory</>
  <info>%command.full_name% --open</>
  <info>%command.full_name% --drafts</>
  <info>%command.full_name% --no-watch</>

You can use a custom host and port by using the <info>--host</info> and <info>--port</info> options:

  <info>%command.full_name% --host=127.0.0.1 --port=8080</>

To build the website with an extra configuration file, you can use the <info>--config</info> option.
This is useful during local development to <comment>override some settings</comment> without modifying the main configuration:

  <info>%command.full_name% --config=config/dev.yml</>

To start the server with changes watcher <comment>not ignoring VCS</comment> directories, run:

  <info>%command.full_name% --no-ignore-vcs</>

To define the process <comment>timeout</comment> (in seconds), run:

  <info>%command.full_name% --timeout=7200</>
EOF
            );
    }

    /**
     * {@inheritdoc}
     *
     * @throws RuntimeException
     */
    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('Can\'t 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) {
            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;
    }

    /**
     * Build success actions.
     */
    private function buildSuccessActions(OutputInterface $output): void
    {
        // writes `changes.flag` file
        if ($this->watcherEnabled) {
            Util\File::getFS()->dumpFile(Util::joinFile($this->getPath(), self::TMP_DIR, 'changes.flag'), time());
        }
        // writes `headers.ini` file
        $headers = $this->getBuilder()->getConfig()->get('server.headers');
        if (is_iterable($headers)) {
            $output->writeln('Writing headers file...');
            Util\File::getFS()->remove(Util::joinFile($this->getPath(), self::TMP_DIR, 'headers.ini'));
            foreach ($headers as $entry) {
                Util\File::getFS()->appendToFile(Util::joinFile($this->getPath(), self::TMP_DIR, 'headers.ini'), "[{$entry['path']}]\n");
                foreach ($entry['headers'] ?? [] as $header) {
                    Util\File::getFS()->appendToFile(Util::joinFile($this->getPath(), self::TMP_DIR, 'headers.ini'), "{$header['key']} = \"{$header['value']}\"\n");
                }
            }
        }
    }

    /**
     * Sets up the watcher.
     */
    private function setupWatcher(bool $noignorevcs = false): ResourceWatcher
    {
        $finder = new Finder();
        $finder->files()
            ->in($this->getPath())
            ->exclude((string) $this->getBuilder()->getConfig()->get('output.dir'));
        if (file_exists(Util::joinFile($this->getPath(), '.gitignore')) && $noignorevcs === false) {
            $finder->ignoreVCSIgnored(true);
        }
        return new ResourceWatcher(new ResourceCacheMemory(), $finder, new Crc32ContentHash());
    }

    /**
     * Prepares server's files.
     *
     * @throws RuntimeException
     */
    private function setUpServer(): void
    {
        try {
            // define root path
            $root = Util\Platform::isPhar() ? Util\Platform::getPharPath() . '/' : realpath(Util::joinFile(__DIR__, '/../../'));
            // copying router
            Util\File::getFS()->copy(
                $root . '/resources/server/router.php',
                Util::joinFile($this->getPath(), self::TMP_DIR, 'router.php'),
                true
            );
            // copying livereload JS for watcher
            $livereloadJs = Util::joinFile($this->getPath(), self::TMP_DIR, 'livereload.js');
            if (is_file($livereloadJs)) {
                Util\File::getFS()->remove($livereloadJs);
            }
            if ($this->watcherEnabled) {
                Util\File::getFS()->copy(
                    $root . '/resources/server/livereload.js',
                    $livereloadJs,
                    true
                );
            }
        } catch (IOExceptionInterface $e) {
            throw new RuntimeException(\sprintf('An error occurred while copying server\'s files to "%s".', $e->getPath()));
        }
        if (!is_file(Util::joinFile($this->getPath(), self::TMP_DIR, 'router.php'))) {
            throw new RuntimeException(\sprintf('Router not found: "%s".', Util::joinFile(self::TMP_DIR, 'router.php')));
        }
    }

    /**
     * Removes temporary directory.
     *
     * @throws RuntimeException
     */
    public function tearDownServer(): void
    {
        $this->output->writeln('');
        $this->output->writeln('<info>Server stopped.</info>');

        try {
            Util\File::getFS()->remove(Util::joinFile($this->getPath(), self::TMP_DIR));
        } catch (IOExceptionInterface $e) {
            throw new RuntimeException($e->getMessage());
        }
    }
}


1			<?php
2
3			/**
4			* This file is part of Cecil.
5			*
6			* (c) Arnaud Ligny <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			declare(strict_types=1);
13
14			namespace Cecil\Command;
15
16			use Cecil\Exception\RuntimeException;
17			use Cecil\Util;
18			use Symfony\Component\Console\Input\InputArgument;
19			use Symfony\Component\Console\Input\InputInterface;
20			use Symfony\Component\Console\Input\InputOption;
21			use Symfony\Component\Console\Output\OutputInterface;
22			use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
23			use Symfony\Component\Finder\Finder;
24			use Symfony\Component\Process\Exception\ProcessFailedException;
25			use Symfony\Component\Process\PhpExecutableFinder;
26			use Symfony\Component\Process\Process;
27			use Yosymfony\ResourceWatcher\Crc32ContentHash;
28			use Yosymfony\ResourceWatcher\ResourceCacheMemory;
29			use Yosymfony\ResourceWatcher\ResourceWatcher;
30
31			/**
32			* Serve command.
33			*
34			* This command starts the built-in web server with live reloading capabilities.
35			* It allows users to serve their website locally and automatically rebuild it when changes are detected.
36			* It also supports opening the web browser automatically and includes options for drafts, optimization, and more.
37			*/
38			class Serve extends AbstractCommand
39			{
40			/** @var boolean */
41			protected $watcherEnabled;
42
43			/**
44			* {@inheritdoc}
45			*/
46			protected function configure()
47			{
48			$this
49			->setName('serve')
50			->setDescription('Starts the built-in server')
51			->setDefinition([
52			new InputArgument('path', InputArgument::OPTIONAL, 'Use the given path as working directory'),
53			new InputOption('open', 'o', InputOption::VALUE_NONE, 'Open web browser automatically'),
54			new InputOption('host', null, InputOption::VALUE_REQUIRED, 'Server host', 'localhost'),
55			new InputOption('port', null, InputOption::VALUE_REQUIRED, 'Server port', '8000'),
56			new InputOption('watch', 'w', InputOption::VALUE_NEGATABLE, 'Enable (or disable --no-watch) changes watcher (enabled by default)', true),
57			new InputOption('drafts', 'd', InputOption::VALUE_NONE, 'Include drafts'),
58			new InputOption('optimize', null, InputOption::VALUE_NEGATABLE, 'Enable (or disable --no-optimize) optimization of generated files'),
59			new InputOption('config', 'c', InputOption::VALUE_REQUIRED, 'Set the path to extra config files (comma-separated)'),
60			new InputOption('clear-cache', null, InputOption::VALUE_OPTIONAL, 'Clear cache before build (optional cache key as regular expression)', false),
61			new InputOption('page', 'p', InputOption::VALUE_REQUIRED, 'Build a specific page'),
62			new InputOption('no-ignore-vcs', null, InputOption::VALUE_NONE, 'Changes watcher must not ignore VCS directories'),
63			new InputOption('metrics', 'm', InputOption::VALUE_NONE, 'Show build metrics (duration and memory) of each step'),
64			new InputOption('timeout', null, InputOption::VALUE_REQUIRED, 'Sets the process timeout (max. runtime) in seconds', 7200), // default is 2 hours
65			])
66			->setHelp(
67			<<<'EOF'
68			The <info>%command.name%</> command starts the live-reloading-built-in web server.
69
70			<info>%command.full_name%</>
71			<info>%command.full_name% path/to/the/working/directory</>
72			<info>%command.full_name% --open</>
73			<info>%command.full_name% --drafts</>
74			<info>%command.full_name% --no-watch</>
75
76			You can use a custom host and port by using the <info>--host</info> and <info>--port</info> options:
77
78			<info>%command.full_name% --host=127.0.0.1 --port=8080</>
79
80			To build the website with an extra configuration file, you can use the <info>--config</info> option.
81			This is useful during local development to <comment>override some settings</comment> without modifying the main configuration:
82
83			<info>%command.full_name% --config=config/dev.yml</>
84
85			To start the server with changes watcher <comment>not ignoring VCS</comment> directories, run:
86
87			<info>%command.full_name% --no-ignore-vcs</>
88
89			To define the process <comment>timeout</comment> (in seconds), run:
90
91			<info>%command.full_name% --timeout=7200</>
92			EOF
93			);
94			}
95
96			/**
97			* {@inheritdoc}
98			*
99			* @throws RuntimeException
100			*/
101			protected function execute(InputInterface $input, OutputInterface $output)
102			{
103			$open = $input->getOption('open');
104			$host = $input->getOption('host');
105			$port = $input->getOption('port');
106			$drafts = $input->getOption('drafts');
107			$optimize = $input->getOption('optimize');
108			$clearcache = $input->getOption('clear-cache');
109			$page = $input->getOption('page');
110			$noignorevcs = $input->getOption('no-ignore-vcs');
111			$metrics = $input->getOption('metrics');
112			$timeout = $input->getOption('timeout');
113			$verbose = $input->getOption('verbose');
114
115			$resourceWatcher = null;
116			$this->watcherEnabled = $input->getOption('watch');
117
118			// checks if PHP executable is available
119			$phpFinder = new PhpExecutableFinder();
120			$php = $phpFinder->find();
121			if ($php === false) {
122			throw new RuntimeException('Can\'t find a local PHP executable.');
123			}
124
125			// setup server
126			$this->setUpServer();
127			$command = \sprintf(
128			'"%s" -S %s:%d -t "%s" "%s"',
129			$php,
130			$host,
131			$port,
132			Util::joinFile($this->getPath(), self::SERVE_OUTPUT),
133			Util::joinFile($this->getPath(), self::TMP_DIR, 'router.php')
134			);
135			$process = Process::fromShellCommandline($command);
136
137			// setup build process
138			$buildProcessArguments = [
139			$php,
140			$_SERVER['argv'][0],
141			];
142			$buildProcessArguments[] = 'build';
143			$buildProcessArguments[] = $this->getPath();
144			if (!empty($this->getConfigFiles())) {
145			$buildProcessArguments[] = '--config';
146			$buildProcessArguments[] = implode(',', $this->getConfigFiles());
147			}
148			if ($drafts) {
149			$buildProcessArguments[] = '--drafts';
150			}
151			if ($optimize === true) {
152			$buildProcessArguments[] = '--optimize';
153			}
154			if ($optimize === false) {
155			$buildProcessArguments[] = '--no-optimize';
156			}
157			if ($clearcache === null) {
158			$buildProcessArguments[] = '--clear-cache';
159			}
160			if (!empty($clearcache)) {
161			$buildProcessArguments[] = '--clear-cache';
162			$buildProcessArguments[] = $clearcache;
163			}
164			if ($verbose) {
165			$buildProcessArguments[] = '-' . str_repeat('v', $_SERVER['SHELL_VERBOSITY']);
166			}
167			if (!empty($page)) {
168			$buildProcessArguments[] = '--page';
169			$buildProcessArguments[] = $page;
170			}
171			if (!empty($metrics)) {
172			$buildProcessArguments[] = '--metrics';
173			}
174			$buildProcessArguments[] = '--baseurl';
175			$buildProcessArguments[] = "http://$host:$port/";
176			$buildProcessArguments[] = '--output';
177			$buildProcessArguments[] = self::SERVE_OUTPUT;
178			$buildProcess = new Process(
179			$buildProcessArguments,
180			null,
181			['BOX_REQUIREMENT_CHECKER' => '0'] // prevents double check (build then serve)
182			);
183			$buildProcess->setTty(Process::isTtySupported());
184			$buildProcess->setPty(Process::isPtySupported());
185			$buildProcess->setTimeout((float) $timeout);
186			$processOutputCallback = function ($type, $buffer) use ($output) {
187			$output->write($buffer, false, OutputInterface::OUTPUT_RAW);
188			};
189
190			// builds before serve
191			$output->writeln(\sprintf('<comment>Build process: %s</comment>', implode(' ', $buildProcessArguments)), OutputInterface::VERBOSITY_DEBUG);
192			$buildProcess->run($processOutputCallback);
193			if ($buildProcess->isSuccessful()) {
194			$this->buildSuccessActions($output);
195			}
196			if ($buildProcess->getExitCode() !== 0) {
197			return 1;
198			}
199
200			// handles serve process
201			if (!$process->isStarted()) {
202			$messageSuffix = '';
203			// setup resource watcher
204			if ($this->watcherEnabled) {
205			$resourceWatcher = $this->setupWatcher($noignorevcs);
206			$resourceWatcher->initialize();
207			$messageSuffix = ' with changes watcher';
208			}
209			// starts server
210			try {
211			if (\function_exists('\pcntl_signal')) {
212			pcntl_async_signals(true);
213			pcntl_signal(SIGINT, [$this, 'tearDownServer']);
214			pcntl_signal(SIGTERM, [$this, 'tearDownServer']);
215			}
216			$output->writeln(\sprintf('<comment>Server process: %s</comment>', $command), OutputInterface::VERBOSITY_DEBUG);
217			$output->writeln(\sprintf('Starting server (<href=http://%s:%d>http://%s:%d</>)%s...', $host, $port, $host, $port, $messageSuffix));
218			$process->start(function ($type, $buffer) {
219			if ($type === Process::ERR) {
220			error_log($buffer, 3, Util::joinFile($this->getPath(), self::TMP_DIR, 'errors.log'));
221			}
222			});
223			if ($open) {
224			$output->writeln('Opening web browser...');
225			Util\Platform::openBrowser(\sprintf('http://%s:%s', $host, $port));
226			}
227			while ($process->isRunning()) {
228			sleep(1); // wait for server is ready
229			if (!fsockopen($host, (int) $port)) {
230			$output->writeln('<info>Server is not ready.</info>');
231
232			return 1;
233			}
234			if ($this->watcherEnabled && $resourceWatcher instanceof ResourceWatcher) {
235			$watcher = $resourceWatcher->findChanges();
236			if ($watcher->hasChanges()) {
237			$output->writeln('<comment>Changes detected.</comment>');
238			// prints deleted/new/updated files in debug mode
239			if (\count($watcher->getDeletedFiles()) > 0) {
240			$output->writeln('<comment>Deleted files:</comment>', OutputInterface::VERBOSITY_DEBUG);
241			foreach ($watcher->getDeletedFiles() as $file) {
242			$output->writeln("<comment>- $file</comment>", OutputInterface::VERBOSITY_DEBUG);
243			}
244			}
245			if (\count($watcher->getNewFiles()) > 0) {
246			$output->writeln('<comment>New files:</comment>', OutputInterface::VERBOSITY_DEBUG);
247			foreach ($watcher->getNewFiles() as $file) {
248			$output->writeln("<comment>- $file</comment>", OutputInterface::VERBOSITY_DEBUG);
249			}
250			}
251			if (\count($watcher->getUpdatedFiles()) > 0) {
252			$output->writeln('<comment>Updated files:</comment>', OutputInterface::VERBOSITY_DEBUG);
253			foreach ($watcher->getUpdatedFiles() as $file) {
254			$output->writeln("<comment>- $file</comment>", OutputInterface::VERBOSITY_DEBUG);
255			}
256			}
257			$output->writeln('');
258			// re-builds
259			$buildProcess->run($processOutputCallback);
260			if ($buildProcess->isSuccessful()) {
261			$this->buildSuccessActions($output);
262			}
263			$output->writeln('<info>Server is runnning...</info>');
264			}
265			}
266			}
267			if ($process->getExitCode() > 0) {
268			$output->writeln(\sprintf('<comment>%s</comment>', trim($process->getErrorOutput())));
269			}
270			} catch (ProcessFailedException $e) {
271			$this->tearDownServer();
272
273			throw new RuntimeException(\sprintf($e->getMessage()));
274			}
275			}
276
277			return 0;
278			}
279
280			/**
281			* Build success actions.
282			*/
283			private function buildSuccessActions(OutputInterface $output): void
284			{
285			// writes `changes.flag` file
286			if ($this->watcherEnabled) {
287			Util\File::getFS()->dumpFile(Util::joinFile($this->getPath(), self::TMP_DIR, 'changes.flag'), time());
288			}
289			// writes `headers.ini` file
290			$headers = $this->getBuilder()->getConfig()->get('server.headers');
291			if (is_iterable($headers)) {
292			$output->writeln('Writing headers file...');
293			Util\File::getFS()->remove(Util::joinFile($this->getPath(), self::TMP_DIR, 'headers.ini'));
294			foreach ($headers as $entry) {
295			Util\File::getFS()->appendToFile(Util::joinFile($this->getPath(), self::TMP_DIR, 'headers.ini'), "[{$entry['path']}]\n");
296			foreach ($entry['headers'] ?? [] as $header) {
297			Util\File::getFS()->appendToFile(Util::joinFile($this->getPath(), self::TMP_DIR, 'headers.ini'), "{$header['key']} = \"{$header['value']}\"\n");
298			}
299			}
300			}
301			}
302
303			/**
304			* Sets up the watcher.
305			*/
306			private function setupWatcher(bool $noignorevcs = false): ResourceWatcher
307			{
308			$finder = new Finder();
309			$finder->files()
310			->in($this->getPath())
311			->exclude((string) $this->getBuilder()->getConfig()->get('output.dir'));
312			if (file_exists(Util::joinFile($this->getPath(), '.gitignore')) && $noignorevcs === false) {
313			$finder->ignoreVCSIgnored(true);
314			}
315			return new ResourceWatcher(new ResourceCacheMemory(), $finder, new Crc32ContentHash());
316			}
317
318			/**
319			* Prepares server's files.
320			*
321			* @throws RuntimeException
322			*/
323			private function setUpServer(): void
324			{
325			try {
326			// define root path
327			$root = Util\Platform::isPhar() ? Util\Platform::getPharPath() . '/' : realpath(Util::joinFile(__DIR__, '/../../'));
328			// copying router
329			Util\File::getFS()->copy(
330			$root . '/resources/server/router.php',
331			Util::joinFile($this->getPath(), self::TMP_DIR, 'router.php'),
332			true
333			);
334			// copying livereload JS for watcher
335			$livereloadJs = Util::joinFile($this->getPath(), self::TMP_DIR, 'livereload.js');
336			if (is_file($livereloadJs)) {
337			Util\File::getFS()->remove($livereloadJs);
338			}
339			if ($this->watcherEnabled) {
340			Util\File::getFS()->copy(
341			$root . '/resources/server/livereload.js',
342			$livereloadJs,
343			true
344			);
345			}
346			} catch (IOExceptionInterface $e) {
347			throw new RuntimeException(\sprintf('An error occurred while copying server\'s files to "%s".', $e->getPath()));
348			}
349			if (!is_file(Util::joinFile($this->getPath(), self::TMP_DIR, 'router.php'))) {
350			throw new RuntimeException(\sprintf('Router not found: "%s".', Util::joinFile(self::TMP_DIR, 'router.php')));
351			}
352			}
353
354			/**
355			* Removes temporary directory.
356			*
357			* @throws RuntimeException
358			*/
359			public function tearDownServer(): void
360			{
361			$this->output->writeln('');
362			$this->output->writeln('<info>Server stopped.</info>');
363
364			try {
365			Util\File::getFS()->remove(Util::joinFile($this->getPath(), self::TMP_DIR));
366			} catch (IOExceptionInterface $e) {
367			throw new RuntimeException($e->getMessage());
368			}
369			}
370			}
371

Cecilapp / Cecil

Push — master ( f60aa5...78e74f )

Serve::setUpServer() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like