FilesystemPublisher::purgeAll() - Code Metrics - silverstripe/silverstripe-staticpublishqueue - Measure and Improve Code Quality continuously with Scrutinizer

FilesystemPublisher::purgeAll() A
last analyzed 2023-02-15 23:33 UTC

↳ Parent: FilesystemPublisher

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace SilverStripe\StaticPublishQueue\Publisher;

use SilverStripe\Assets\Filesystem;
use SilverStripe\Control\HTTPResponse;
use SilverStripe\Core\Config\Config;
use SilverStripe\Security\SecurityToken;
use SilverStripe\StaticPublishQueue\Publisher;
use function SilverStripe\StaticPublishQueue\PathToURL;
use function SilverStripe\StaticPublishQueue\URLtoPath;

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

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

    /**
     * @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($url)
    {
        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()
    {
        Filesystem::removeFolder($this->getDestPath());

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

    /**
     * @param string $url
     * @param bool $forcePublish
     * @return array A result array
     */
    public function publishURL($url, $forcePublish = false)
    {
        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 && $statusCode < 400) {
            // publish redirect response
            $success = $this->publishRedirect($response, $url);
        } elseif ($doPublish) {
            $success = $this->publishPage($response, $url);
        }
        return [
            'published' => $doPublish,
            'success' => $success,
            'responsecode' => $statusCode,
            'url' => $url,
        ];
    }

    /**
     * @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)) {
            $body = $response->getBody();
            if ($this->config()->get('lazy_form_recognition')) {
                $id = Config::inst()->get(SecurityToken::class, 'default_name') ?: 'SecurityID';
                // little hack to make sure we do not include pages with live forms.
                if (stripos($body, '<input type="hidden" name="' . $id . '"') !== false) {
                    return false;
                }
            }
            if ($this->getFileExtension() === 'php') {
                $phpContent = $this->generatePHPCacheFile($response);
                $success = $this->saveToPath($phpContent, $path . '.php');
            }
            return $this->saveToPath($body, $path . '.html') && $success;
        }
        return false;
    }

    /**
     * returns true on success and false on failure
     *
     * @param string $content
     * @param string $filePath
     * @return bool
     */
    protected function saveToPath($content, $filePath)
    {
        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));

        return rename($temporaryPath, $publishPath);
    }

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

        return $success;
    }

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

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

    public function getPublishedURLs($dir = null, &$result = [])
    {
        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;
    }
}


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

silverstripe / silverstripe-staticpublishqueue

FilesystemPublisher::purgeAll() A last analyzed 2023-02-15 23:33 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FilesystemPublisher::purgeAll() A
last analyzed 2023-02-15 23:33 UTC