FilesystemPublisher::compressFile() - Code Metrics - Inspection of "adding gzip option / fixing bugs / linting" - silverstripe/silverstripe-staticpublishqueue - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#118)

by Nicolaas

created 2020-09-09 20:29 UTC

FilesystemPublisher::compressFile() A

↳ Parent: FilesystemPublisher

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	5
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	9
rs	10

<?php

namespace SilverStripe\StaticPublishQueue\Publisher;

use SilverStripe\Assets\Filesystem;
use SilverStripe\Control\HTTPResponse;
use function SilverStripe\StaticPublishQueue\PathToURL;
use SilverStripe\StaticPublishQueue\Publisher;
use function SilverStripe\StaticPublishQueue\URLtoPath;

class FilesystemPublisher extends Publisher
{
    /**
     * @var string
     */
    protected $destFolder = 'cache';

    /**
     * @var string
     */
    protected $fileExtension = 'html';

    /**
     * @var bool
     */
    private static $use_gzip_compression = true;


    /**
     * @return string
     */
    public function getDestPath()
    {
        $base = defined('PUBLIC_PATH') ? PUBLIC_PATH : BASE_PATH;
        return $base . DIRECTORY_SEPARATOR . $this->getDestFolder();
    }

    public function setDestFolder($destFolder)
    {
        $this->destFolder = $destFolder;
        return $this;
    }

    public function getDestFolder()
    {
        return $this->destFolder;
    }

    public function setFileExtension($fileExtension)
    {
        $fileExtension = strtolower($fileExtension);
        if (! in_array($fileExtension, ['html', 'php'], true)) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Bad file extension "%s" passed to %s::%s',
                    $fileExtension,
                    static::class,
                    __FUNCTION__
                )
            );
        }
        $this->fileExtension = $fileExtension;
        return $this;
    }

    public function getFileExtension()
    {
        return $this->fileExtension;
    }

    public function purgeURL(string $url): array
    {
        if (! $url) {
            user_error('Bad url:' . var_export($url, true), E_USER_WARNING);
            return [];
        }
        if ($path = $this->URLtoPath($url)) {
            $success = $this->deleteFromPath($path . '.html') && $this->deleteFromPath($path . '.php');
            return [
                'success' => $success,
                'url' => $url,
                'path' => $this->getDestPath() . DIRECTORY_SEPARATOR . $path,
            ];
        }
        return [
            'success' => false,
            'url' => $url,
            'path' => false,
        ];
    }

    public function purgeAll(): bool
    {
        Filesystem::removeFolder($this->getDestPath());

        return file_exists($this->getDestPath()) ? false : true;
    }

    /**
     * @param string $url
     * @return array A result array
     */
    public function publishURL(string $url, ?bool $forcePublish = false): array
    {
        if (!$url) {
            user_error('Bad url:' . var_export($url, true), E_USER_WARNING);
            return [];
        }
        $success = false;
        $response = $this->generatePageResponse($url);
        $statusCode = $response->getStatusCode();
        $doPublish = ($forcePublish && $this->getFileExtension() === 'php') || $statusCode < 400;


        if ($statusCode < 300) {
            // publish success response
            $success = $this->publishPage($response, $url);
        } elseif ($statusCode < 400) {
            // publish redirect response
            $success = $this->publishRedirect($response, $url);
        } elseif ($doPublish) {
            // only publish error pages if we are able to send status codes via PHP
            $success = $this->publishPage($response, $url);
        }
        return [
            'published' => $doPublish,
            'success' => $success,
            'responsecode' => $statusCode,
            'url' => $url,
        ];
    }

    public function getPublishedURLs(?string $dir = null, array &$result = []): array
    {
        if ($dir === null) {
            $dir = $this->getDestPath();
        }

        $root = scandir($dir);
        foreach ($root as $fileOrDir) {
            if (strpos($fileOrDir, '.') === 0) {
                continue;
            }
            $fullPath = $dir . DIRECTORY_SEPARATOR . $fileOrDir;
            // we know html will always be generated, this prevents double ups
            if (is_file($fullPath) && pathinfo($fullPath, PATHINFO_EXTENSION) === 'html') {
                $result[] = $this->pathToURL($fullPath);
                continue;
            }

            if (is_dir($fullPath)) {
                $this->getPublishedURLs($fullPath, $result);
            }
        }
        return $result;
    }

    /**
     * @param HTTPResponse $response
     * @param string       $url
     * @return bool
     */
    protected function publishRedirect($response, $url)
    {
        $success = true;
        if ($path = $this->URLtoPath($url)) {
            $location = $response->getHeader('Location');
            if ($this->getFileExtension() === 'php') {
                $phpContent = $this->generatePHPCacheFile($response);
                $success = $this->saveToPath($phpContent, $path . '.php');
            }
            return $this->saveToPath($this->generateHTMLCacheRedirection($location), $path . '.html') && $success;
        }
        return false;
    }

    /**
     * @param HTTPResponse $response
     * @param string       $url
     * @return bool
     */
    protected function publishPage($response, $url)
    {
        $success = true;
        if ($path = $this->URLtoPath($url)) {
            // little hack to make sure we do not include pages with live forms.
            if (stripos($response->getBody(), 'name="SecurityID"')) {
                return false;
            }
            if ($this->getFileExtension() === 'php') {
                $phpContent = $this->generatePHPCacheFile($response);
                $success = $this->saveToPath($phpContent, $path . '.php');
            }
            return $this->saveToPath($response->getBody(), $path . '.html') && $success;
        }
        return false;
    }

    /**
     * returns true on access and false on failure
     * @param string $content
     * @param string $filePath
     * @return bool
     */
    protected function saveToPath($content, $filePath): bool
    {
        if (empty($content)) {
            return false;
        }

        // Write to a temporary file first
        $temporaryPath = tempnam(TEMP_PATH, 'filesystempublisher_');
        if (file_put_contents($temporaryPath, $content) === false) {
            return false;
        }

        // Move the temporary file to the desired location (prevents unlocked files from being read during write)
        $publishPath = $this->getDestPath() . DIRECTORY_SEPARATOR . $filePath;
        Filesystem::makeFolder(dirname($publishPath));
        $successWithPublish = rename($temporaryPath, $publishPath);
        if ($successWithPublish) {
            if (FilesystemPublisher::config()->get('use_gzip_compression')) {
                $publishPath = $this->compressFile($publishPath);
            }
        }

        return file_exists($publishPath);
    }

    protected function compressFile(string $publishPath): string
    {
        //we keep the html file for now ... so use second parameter to achieve this.
        $publishPathGZipped = $publishPath . '.gz';
        exec('rm ' . $publishPathGZipped . ' -rf');
        exec('gzip ' . $publishPath);
        exec('chmod 0777 ' . $publishPathGZipped);

        return $publishPathGZipped;
    }

    protected function deleteFromPath($filePath)
    {
        $deletePath = $this->getDestPath() . DIRECTORY_SEPARATOR . $filePath;
        if (file_exists($deletePath)) {
            $success = unlink($deletePath);
        } else {
            $success = true;
        }
        if (file_exists($deletePath . '.gz')) {
            return $this->deleteFromPath($deletePath . '.gz');
        }

        return $success;
    }

    protected function URLtoPath(string $url): string
    {
        return URLtoPath($url, BASE_URL, FilesystemPublisher::config()->get('domain_based_caching'));
    }

    protected function pathToURL(string $path): string
    {
        return PathToURL($path, $this->getDestPath(), FilesystemPublisher::config()->get('domain_based_caching'));
    }
}


1			<?php
2
3			namespace SilverStripe\StaticPublishQueue\Publisher;
4
5			use SilverStripe\Assets\Filesystem;
6			use SilverStripe\Control\HTTPResponse;
7			use function SilverStripe\StaticPublishQueue\PathToURL;
8			use SilverStripe\StaticPublishQueue\Publisher;
9			use function SilverStripe\StaticPublishQueue\URLtoPath;
10
11			class FilesystemPublisher extends Publisher
12			{
13			/**
14			* @var string
15			*/
16			protected $destFolder = 'cache';
17
18			/**
19			* @var string
20			*/
21			protected $fileExtension = 'html';
22
23			/**
24			* @var bool
25			*/
26			private static $use_gzip_compression = true;
			0 ignored issues – show introduced 2020-07-05 21:21 UTC by Report Bug Copy Issue Report The private property `$use_gzip_compression` is not used, and could be removed. Loading history...
27
28			/**
29			* @return string
30			*/
31			public function getDestPath()
32			{
33			$base = defined('PUBLIC_PATH') ? PUBLIC_PATH : BASE_PATH;
34			return $base . DIRECTORY_SEPARATOR . $this->getDestFolder();
35			}
36
37			public function setDestFolder($destFolder)
38			{
39			$this->destFolder = $destFolder;
40			return $this;
41			}
42
43			public function getDestFolder()
44			{
45			return $this->destFolder;
46			}
47
48			public function setFileExtension($fileExtension)
49			{
50			$fileExtension = strtolower($fileExtension);
51			if (! in_array($fileExtension, ['html', 'php'], true)) {
52			throw new \InvalidArgumentException(
53			sprintf(
54			'Bad file extension "%s" passed to %s::%s',
55			$fileExtension,
56			static::class,
57			__FUNCTION__
58			)
59			);
60			}
61			$this->fileExtension = $fileExtension;
62			return $this;
63			}
64
65			public function getFileExtension()
66			{
67			return $this->fileExtension;
68			}
69
70			public function purgeURL(string $url): array
71			{
72			if (! $url) {
73			user_error('Bad url:' . var_export($url, true), E_USER_WARNING);
74			return [];
75			}
76			if ($path = $this->URLtoPath($url)) {
77			$success = $this->deleteFromPath($path . '.html') && $this->deleteFromPath($path . '.php');
78			return [
79			'success' => $success,
80			'url' => $url,
81			'path' => $this->getDestPath() . DIRECTORY_SEPARATOR . $path,
82			];
83			}
84			return [
85			'success' => false,
86			'url' => $url,
87			'path' => false,
88			];
89			}
90
91			public function purgeAll(): bool
92			{
93			Filesystem::removeFolder($this->getDestPath());
94
95			return file_exists($this->getDestPath()) ? false : true;
96			}
97
98			/**
99			* @param string $url
100			* @return array A result array
101			*/
102			public function publishURL(string $url, ?bool $forcePublish = false): array
103			{
104			if (!$url) {
105			user_error('Bad url:' . var_export($url, true), E_USER_WARNING);
106			return [];
107			}
108			$success = false;
109			$response = $this->generatePageResponse($url);
110			$statusCode = $response->getStatusCode();
111			$doPublish = ($forcePublish && $this->getFileExtension() === 'php') \|\| $statusCode < 400;
			0 ignored issues – show introduced 2020-07-05 21:21 UTC by Report Bug Copy Issue Report Consider adding parentheses for clarity. Current Interpretation: `$doPublish = ($forcePubl...' \|\| $statusCode < 400)`, Probably Intended Meaning: `$doPublish = $forcePubli...' \|\| $statusCode < 400)` Loading history...
112
113			if ($statusCode < 300) {
114			// publish success response
115			$success = $this->publishPage($response, $url);
116			} elseif ($statusCode < 400) {
117			// publish redirect response
118			$success = $this->publishRedirect($response, $url);
119			} elseif ($doPublish) {
120			// only publish error pages if we are able to send status codes via PHP
121			$success = $this->publishPage($response, $url);
122			}
123			return [
124			'published' => $doPublish,
125			'success' => $success,
126			'responsecode' => $statusCode,
127			'url' => $url,
128			];
129			}
130
131			public function getPublishedURLs(?string $dir = null, array &$result = []): array
132			{
133			if ($dir === null) {
134			$dir = $this->getDestPath();
135			}
136
137			$root = scandir($dir);
138			foreach ($root as $fileOrDir) {
139			if (strpos($fileOrDir, '.') === 0) {
140			continue;
141			}
142			$fullPath = $dir . DIRECTORY_SEPARATOR . $fileOrDir;
143			// we know html will always be generated, this prevents double ups
144			if (is_file($fullPath) && pathinfo($fullPath, PATHINFO_EXTENSION) === 'html') {
145			$result[] = $this->pathToURL($fullPath);
146			continue;
147			}
148
149			if (is_dir($fullPath)) {
150			$this->getPublishedURLs($fullPath, $result);
151			}
152			}
153			return $result;
154			}
155
156			/**
157			* @param HTTPResponse $response
158			* @param string $url
159			* @return bool
160			*/
161			protected function publishRedirect($response, $url)
162			{
163			$success = true;
164			if ($path = $this->URLtoPath($url)) {
165			$location = $response->getHeader('Location');
166			if ($this->getFileExtension() === 'php') {
167			$phpContent = $this->generatePHPCacheFile($response);
168			$success = $this->saveToPath($phpContent, $path . '.php');
169			}
170			return $this->saveToPath($this->generateHTMLCacheRedirection($location), $path . '.html') && $success;
171			}
172			return false;
173			}
174
175			/**
176			* @param HTTPResponse $response
177			* @param string $url
178			* @return bool
179			*/
180			protected function publishPage($response, $url)
181			{
182			$success = true;
183			if ($path = $this->URLtoPath($url)) {
184			// little hack to make sure we do not include pages with live forms.
185			if (stripos($response->getBody(), 'name="SecurityID"')) {
186			return false;
187			}
188			if ($this->getFileExtension() === 'php') {
189			$phpContent = $this->generatePHPCacheFile($response);
190			$success = $this->saveToPath($phpContent, $path . '.php');
191			}
192			return $this->saveToPath($response->getBody(), $path . '.html') && $success;
193			}
194			return false;
195			}
196
197			/**
198			* returns true on access and false on failure
199			* @param string $content
200			* @param string $filePath
201			* @return bool
202			*/
203			protected function saveToPath($content, $filePath): bool
204			{
205			if (empty($content)) {
206			return false;
207			}
208
209			// Write to a temporary file first
210			$temporaryPath = tempnam(TEMP_PATH, 'filesystempublisher_');
211			if (file_put_contents($temporaryPath, $content) === false) {
212			return false;
213			}
214
215			// Move the temporary file to the desired location (prevents unlocked files from being read during write)
216			$publishPath = $this->getDestPath() . DIRECTORY_SEPARATOR . $filePath;
217			Filesystem::makeFolder(dirname($publishPath));
218			$successWithPublish = rename($temporaryPath, $publishPath);
219			if ($successWithPublish) {
220			if (FilesystemPublisher::config()->get('use_gzip_compression')) {
221			$publishPath = $this->compressFile($publishPath);
222			}
223			}
224
225			return file_exists($publishPath);
226			}
227
228			protected function compressFile(string $publishPath): string
229			{
230			//we keep the html file for now ... so use second parameter to achieve this.
231			$publishPathGZipped = $publishPath . '.gz';
232			exec('rm ' . $publishPathGZipped . ' -rf');
233			exec('gzip ' . $publishPath);
234			exec('chmod 0777 ' . $publishPathGZipped);
235
236			return $publishPathGZipped;
237			}
238
239			protected function deleteFromPath($filePath)
240			{
241			$deletePath = $this->getDestPath() . DIRECTORY_SEPARATOR . $filePath;
242			if (file_exists($deletePath)) {
243			$success = unlink($deletePath);
244			} else {
245			$success = true;
246			}
247			if (file_exists($deletePath . '.gz')) {
248			return $this->deleteFromPath($deletePath . '.gz');
249			}
250
251			return $success;
252			}
253
254			protected function URLtoPath(string $url): string
255			{
256			return URLtoPath($url, BASE_URL, FilesystemPublisher::config()->get('domain_based_caching'));
257			}
258
259			protected function pathToURL(string $path): string
260			{
261			return PathToURL($path, $this->getDestPath(), FilesystemPublisher::config()->get('domain_based_caching'));
262			}
263			}
264

silverstripe / silverstripe-staticpublishqueue

Pull Request — master (#118)

FilesystemPublisher::compressFile() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like