Implemented support for absolute purge urls and split up target_dir into target_dir and document_root

Toflar · Toflar · commit 5c547faa9c80 · 2018-12-08T16:31:37.000+01:00
diff --git a/src/ProxyClient/LiteSpeed.php b/src/ProxyClient/LiteSpeed.php
@@ -29,7 +29,7 @@ class LiteSpeed extends HttpProxyClient implements PurgeCapable, TagCapable, Cle
      */
     public function clear()
     {
-        $this->headerLines[] = 'X-LiteSpeed-Purge: *';
+        $this->addHeaderLine('X-LiteSpeed-Purge', '*');
 
         return $this;
     }
@@ -39,7 +39,15 @@ public function clear()
      */
     public function purge($url, array $headers = [])
     {
-        $this->headerLines[] = 'X-LiteSpeed-Purge: '.$url;
+        $urlParts = parse_url($url);
+        $host = null;
+
+        if (isset($urlParts['host'])) {
+            $host = $urlParts['host'];
+            $url = $urlParts['path'];
+        }
+
+        $this->addHeaderLine('X-LiteSpeed-Purge', $url, $host);
 
         return $this;
     }
@@ -51,8 +59,15 @@ protected function configureOptions()
     {
         $resolver = parent::configureOptions();
 
-        $resolver->setRequired(['target_dir']);
+        $resolver->setRequired(['document_root']);
+        $resolver->setDefaults([
+            'target_dir' => '',
+            'base_uri' => '/',
+        ]);
+
+        $resolver->setAllowedTypes('document_root', 'string');
         $resolver->setAllowedTypes('target_dir', 'string');
+        $resolver->setAllowedTypes('base_uri', 'string');
 
         return $resolver;
     }
@@ -62,7 +77,7 @@ protected function configureOptions()
      */
     public function invalidateTags(array $tags)
     {
-        $this->headerLines[] = 'X-LiteSpeed-Purge: '.implode(', ', preg_filter('/^/', 'tag=', $tags));
+        $this->addHeaderLine('X-LiteSpeed-Purge', implode(', ', preg_filter('/^/', 'tag=', $tags)));
 
         return $this;
     }
@@ -72,39 +87,81 @@ public function invalidateTags(array $tags)
      */
     public function flush()
     {
-        $filename = $this->createFile();
+        $filenames = [];
+
+        $url = '/';
+
+        if ($this->options['target_dir']) {
+            $url .= $this->options['target_dir'].'/';
+        }
 
-        $url = '/'.$filename;
+        foreach ($this->headerLines as $host => $lines) {
+            $filename = $this->createFileForHost($host);
 
-        $this->queueRequest('GET', $url, []);
+            $this->queueRequest('GET', $url.$filename, []);
+
+            $filenames[] = $filename;
+        }
+
+        try {
+            return parent::flush();
+        } finally {
+            // Reset
+            $this->headerLines = [];
+
+            foreach ($filenames as $filename) {
+                unlink($this->getFilePath().'/'.$filename);
+            }
+        }
+    }
 
-        $result = parent::flush();
+    private function addHeaderLine($header, $value, $host = null)
+    {
+        if (null === $host) {
+            $host = $this->options['base_uri'];
+        }
 
-        // Reset
-        $this->headerLines = [];
-        unlink($this->options['target_dir'].'/'.$filename);
+        if (!isset($this->headerLines[$host])) {
+            $this->headerLines[$host] = [];
+        }
 
-        return $result;
+        $this->headerLines[$host][] = $header.': '.$value;
     }
 
     /**
      * Creates the file and returns the file name.
      *
+     * @param string $host
+     *
      * @return string
      */
-    private function createFile()
+    private function createFileForHost($host)
     {
         $content = '<?php'."\n\n";
 
-        foreach ($this->headerLines as $header) {
+        foreach ($this->headerLines[$host] as $header) {
             $content .= sprintf('header(\'%s\');', addslashes($header))."\n";
         }
 
         // Generate a reasonably random file name, no need to be cryptographically safe here
-        $filename = 'fos_cache_litespeed_purger_'.substr(sha1(uniqid('', true).mt_rand()), 0, mt_rand(10, 40)) . '.php';
+        $filename = 'fos_cache_litespeed_purger_'.substr(sha1(uniqid('', true).mt_rand()), 0, mt_rand(10, 40)).'.php';
 
-        file_put_contents($this->options['target_dir'].'/'.$filename, $content);
+        file_put_contents($this->getFilePath().'/'.$filename, $content);
 
         return $filename;
     }
+
+    /**
+     * @return string
+     */
+    private function getFilePath()
+    {
+        $path = $this->options['document_root'];
+
+        if ($this->options['target_dir']) {
+            $path .= '/'.$this->options['target_dir'];
+        }
+
+        return $path;
+    }
 }
diff --git a/tests/Unit/ProxyClient/LiteSpeedTest.php b/tests/Unit/ProxyClient/LiteSpeedTest.php
@@ -30,25 +30,40 @@ class LiteSpeedTest extends TestCase
     /**
      * @var string
      */
-    private $targetDir;
+    private $documentRoot;
 
     protected function setUp()
     {
         $this->httpDispatcher = \Mockery::mock(HttpDispatcher::class);
 
-        $targetDir = sys_get_temp_dir().'/fos_ls_tests';
-        if (is_dir($targetDir)) {
-            array_map('unlink', glob($targetDir.'/*'));
-            rmdir($targetDir);
+        $deleteFilesAndFolders = function ($path) use (&$deleteFilesAndFolders) {
+            $files = glob($path.'/*');
+            foreach ($files as $file) {
+                is_dir($file) ? $deleteFilesAndFolders($file) : unlink($file);
+            }
+            rmdir($path);
+
+            return;
+        };
+
+        $documentRoot = sys_get_temp_dir().'/fos_ls_tests';
+        if (is_dir($documentRoot)) {
+            $deleteFilesAndFolders($documentRoot);
         }
-        mkdir($targetDir);
+        mkdir($documentRoot);
 
-        $this->targetDir = $targetDir;
+        $this->documentRoot = $documentRoot;
     }
 
     public function testPurge()
     {
-        $ls = new LiteSpeed($this->httpDispatcher, ['target_dir' => $this->targetDir]);
+        $ls = new LiteSpeed($this->httpDispatcher, [
+            'document_root' => $this->documentRoot,
+            'target_dir' => 'subfolder',
+        ]);
+
+        // We're also testing target_dir here so we have to create the subfolder
+        mkdir($this->documentRoot.'/subfolder');
 
         $expectedContent = <<<'EOT'
 <?php
@@ -59,7 +74,7 @@ public function testPurge()
 header('X-LiteSpeed-Purge: foo\'); exec(\\\'rm -rf /\\\');//');
 
 EOT;
-        $this->assertLiteSpeedPurger($expectedContent);
+        $this->assertLiteSpeedPurger([$expectedContent], 'subfolder');
 
         $ls->purge('/url');
         $ls->purge('/another/url');
@@ -68,12 +83,50 @@ public function testPurge()
         $ls->flush();
 
         // Assert file has been deleted again
-        $this->assertDirectoryEmpty($this->targetDir);
+        $this->assertDirectoryEmpty($this->documentRoot.'/subfolder');
+    }
+
+    public function testPurgeWithAbsoluteUrls()
+    {
+        $ls = new LiteSpeed($this->httpDispatcher, [
+            'document_root' => $this->documentRoot,
+        ]);
+
+        $expectedContents = [];
+        $expectedContents[] = <<<'EOT'
+<?php
+
+header('X-LiteSpeed-Purge: /url');
+
+EOT;
+        $expectedContents[] = <<<'EOT'
+<?php
+
+header('X-LiteSpeed-Purge: /foobar');
+
+EOT;
+        $expectedContents[] = <<<'EOT'
+<?php
+
+header('X-LiteSpeed-Purge: /foobar');
+
+EOT;
+        $this->assertLiteSpeedPurger($expectedContents);
+
+        $ls->purge('/url');
+        $ls->purge('https://www.domain.com/foobar');
+        $ls->purge('https://www.domain.ch/foobar');
+        $ls->flush();
+
+        // Assert file has been deleted again
+        $this->assertDirectoryEmpty($this->documentRoot);
     }
 
     public function testInvalidateTags()
     {
-        $ls = new LiteSpeed($this->httpDispatcher, ['target_dir' => $this->targetDir]);
+        $ls = new LiteSpeed($this->httpDispatcher, [
+            'document_root' => $this->documentRoot,
+        ]);
 
         $expectedContent = <<<'EOT'
 <?php
@@ -82,55 +135,70 @@ public function testInvalidateTags()
 header('X-LiteSpeed-Purge: tag=more, tag=tags');
 
 EOT;
-        $this->assertLiteSpeedPurger($expectedContent);
+        $this->assertLiteSpeedPurger([$expectedContent]);
 
         $ls->invalidateTags(['foobar', 'tag']);
         $ls->invalidateTags(['more', 'tags']);
         $ls->flush();
 
         // Assert file has been deleted again
-        $this->assertDirectoryEmpty($this->targetDir);
+        $this->assertDirectoryEmpty($this->documentRoot);
     }
 
     public function testClear()
     {
-        $ls = new LiteSpeed($this->httpDispatcher, ['target_dir' => $this->targetDir]);
+        $ls = new LiteSpeed($this->httpDispatcher, [
+            'document_root' => $this->documentRoot,
+        ]);
 
         $expectedContent = <<<'EOT'
 <?php
 
 header('X-LiteSpeed-Purge: *');
 
 EOT;
-        $this->assertLiteSpeedPurger($expectedContent);
+        $this->assertLiteSpeedPurger([$expectedContent]);
 
         $ls->clear();
         $ls->flush();
 
         // Assert file has been deleted again
-        $this->assertDirectoryEmpty($this->targetDir);
+        $this->assertDirectoryEmpty($this->documentRoot);
     }
 
-    private function assertLiteSpeedPurger($expectedContent)
+    private function assertLiteSpeedPurger(array $expectedContents, $targetDir = '')
     {
-        $this->httpDispatcher->shouldReceive('invalidate')->once()->with(
-            \Mockery::on(
-                function (RequestInterface $request) use ($expectedContent) {
+        $methodCallCount = 0;
+
+        $this->httpDispatcher->shouldReceive('invalidate')
+            ->times(count($expectedContents))
+            ->with(\Mockery::on(
+                function (RequestInterface $request) use ($expectedContents, $targetDir, &$methodCallCount) {
                     $this->assertEquals('GET', $request->getMethod());
 
-                    $filename = ltrim($request->getRequestTarget(), '/');
+                    $cutOff = $targetDir ? (strlen($targetDir) + 2) : 1;
+                    $filename = substr_replace($request->getRequestTarget(), '', 0, $cutOff);
+
+                    $path = $this->documentRoot;
+
+                    if ($targetDir) {
+                        $path .= '/'.$targetDir;
+                    }
 
                     // Assert file has been generated
-                    $this->assertFileExists($this->targetDir.'/'.$filename);
+                    $this->assertFileExists($path.'/'.$filename);
 
                     // Assert file contents
-                    $this->assertSame($expectedContent, file_get_contents($this->targetDir.'/'.$filename));
+                    $this->assertSame($expectedContents[$methodCallCount], file_get_contents($path.'/'.$filename));
+
+                    ++$methodCallCount;
 
                     return true;
                 }
             ),
             true
-        );
+            );
+
         $this->httpDispatcher->shouldReceive('flush')->once();
     }
 
