Changeset 49744 for trunk/tests/phpunit/tests/multisite/cleanDirsizeCache.php

Timestamp:

12/03/2020 08:37:43 PM (5 years ago)

Author:

iandunn

Message:

Multisite: Cache absolute dirsize paths to avoid PHP 8 fatal.

r49212 greatly improved the performance of get_dirsize(), but also changed the structure of the data stored in the dirsize_cache transient. It stored relative paths instead of absolute ones, and also removed the unnecessary size array.

That difference in data structures led to a fatal error in the following environment:

• PHP 8
• Multisite
• A custom WP_CONTENT_DIR which is not a child of WP's ABSPATH folder (e.g., ​Bedrock)
• The upload_space_check_disabled option set to 0

After upgrading to WP 5.6, the dirsize_cache transient still had data in the old format. When wp-admin.php/index.php was visited, get_space_used() received an array instead of an int, and tried to divide it by another int. PHP 7 would silently cast the arguments to match data types, but ​PHP 8 throws a fatal error:

Uncaught TypeError: Unsupported operand types: array / int

recurse_dirsize() was using ABSPATH to convert the absolute paths to relative ones, but some upload locations are not located under ABSPATH. In those cases, $directory and $cache_path were identical, and that triggered the early return of the old array, instead of the expected int.

In order to avoid that, this commit restores the absolute paths, but without the size array. It also adds a type check when returning cached values. Using absolute paths without size has the result of overwriting the old data, so that it matches the new format. The type check and upgrade routine are additional safety measures.

Props peterwilsoncc, janthiel, helen, hellofromtonya, francina, pbiron.
Fixes #51913. See #19879.

File:

• trunk/tests/phpunit/tests/multisite/cleanDirsizeCache.php (modified) (4 diffs)

trunk/tests/phpunit/tests/multisite/cleanDirsizeCache.php

@@ -94 +94 @@
 
             $upload_dir       = wp_upload_dir();
-            $cache_key_prefix = untrailingslashit( str_replace( ABSPATH, '', $upload_dir['basedir'] ) );
+            $cache_key_prefix = untrailingslashit( $upload_dir['basedir'] );
 
             // Clear the dirsize cache.
@@ -142 +142 @@
 
             $upload_dir       = wp_upload_dir();
-            $cache_key_prefix = untrailingslashit( str_replace( ABSPATH, '', $upload_dir['basedir'] ) );
+            $cache_key_prefix = untrailingslashit( $upload_dir['basedir'] );
 
             // Clear the dirsize cache.
@@ -206 +206 @@
 
             // `dirsize_cache` should now be filled after upload and recurse_dirsize() call.
-            $cache_path = untrailingslashit( str_replace( ABSPATH, '', $upload_dir['path'] ) );
+            $cache_path = untrailingslashit( $upload_dir['path'] );
             $this->assertSame( true, is_array( get_transient( 'dirsize_cache' ) ) );
             $this->assertSame( $size, get_transient( 'dirsize_cache' )[ $cache_path ] );
@@ -234 +234 @@
 
         function _get_mock_dirsize_cache_for_site( $site_id ) {
+            $prefix = wp_upload_dir()['basedir'];
+
             return array(
-                "wp-content/uploads/sites/$site_id/2/2" => 22,
-                "wp-content/uploads/sites/$site_id/2/1" => 21,
-                "wp-content/uploads/sites/$site_id/2"   => 2,
-                "wp-content/uploads/sites/$site_id/1/3" => 13,
-                "wp-content/uploads/sites/$site_id/1/2" => 12,
-                "wp-content/uploads/sites/$site_id/1/1" => 11,
-                "wp-content/uploads/sites/$site_id/1"   => 1,
-                "wp-content/uploads/sites/$site_id/custom_directory" => 42,
+                "$prefix/2/2"              => 22,
+                "$prefix/2/1"              => 21,
+                "$prefix/2"                => 2,
+                "$prefix/1/3"              => 13,
+                "$prefix/1/2"              => 12,
+                "$prefix/1/1"              => 11,
+                "$prefix/1"                => 1,
+                "$prefix/custom_directory" => 42,
             );
         }
+
+        /*
+         * Test that 5.6+ gracefully handles the old 5.5 transient structure.
+         *
+         * @ticket 51913
+         */
+        function test_5_5_transient_structure_compat() {
+            $blog_id = self::factory()->blog->create();
+            switch_to_blog( $blog_id );
+
+            /*
+             * Our comparison of space relies on an initial value of 0. If a previous test has failed
+             * or if the `src` directory already contains a directory with site content, then the initial
+             * expectation will be polluted. We create sites until an empty one is available.
+             */
+            while ( 0 !== get_space_used() ) {
+                restore_current_blog();
+                $blog_id = self::factory()->blog->create();
+                switch_to_blog( $blog_id );
+            }
+
+            // Clear the dirsize cache.
+            delete_transient( 'dirsize_cache' );
+
+            // Set the dirsize cache to our mock.
+            set_transient( 'dirsize_cache', $this->_get_mock_5_5_dirsize_cache( $blog_id ) );
+
+            $upload_dir = wp_upload_dir();
+
+            /*
+             * The cached size should be ignored, because it's in the old format. The function
+             * will try to fetch a live value, but in this case the folder doesn't actually
+             * exist on disk, so the function should fail.
+             */
+            $this->assertSame( false, recurse_dirsize( $upload_dir['basedir'] . '/2/1' ) );
+
+            /*
+             * Now that it's confirmed that old cached values aren't being returned, create the
+             * folder on disk, so that the the rest of the function can be tested.
+             */
+            wp_mkdir_p( $upload_dir['basedir'] . '/2/1' );
+            $filename = $upload_dir['basedir'] . '/2/1/this-needs-to-exist.txt';
+            file_put_contents( $filename, 'this file is 21 bytes' );
+
+            // Clear the dirsize cache.
+            delete_transient( 'dirsize_cache' );
+
+            // Set the dirsize cache to our mock.
+            set_transient( 'dirsize_cache', $this->_get_mock_5_5_dirsize_cache( $blog_id ) );
+
+            /*
+             * Now that the folder exists, the old cached value should be overwritten
+             * with the size, using the current format.
+             */
+            $this->assertSame( 21, recurse_dirsize( $upload_dir['basedir'] . '/2/1' ) );
+            $this->assertSame( 21, get_transient( 'dirsize_cache' )[ $upload_dir['basedir'] . '/2/1' ] );
+
+            // No cache match on non existing directory should return false.
+            $this->assertSame( false, recurse_dirsize( $upload_dir['basedir'] . '/does_not_exist' ) );
+
+            // Cleanup.
+            $this->remove_added_uploads();
+            rmdir( $upload_dir['basedir'] . '/2/1' );
+
+            restore_current_blog();
+        }
+
+        function _get_mock_5_5_dirsize_cache( $site_id ) {
+            $prefix = untrailingslashit( wp_upload_dir()['basedir'] );
+
+            return array(
+                "$prefix/2/2"              => array( 'size' => 22 ),
+                "$prefix/2/1"              => array( 'size' => 21 ),
+                "$prefix/2"                => array( 'size' => 2 ),
+                "$prefix/1/3"              => array( 'size' => 13 ),
+                "$prefix/1/2"              => array( 'size' => 12 ),
+                "$prefix/1/1"              => array( 'size' => 11 ),
+                "$prefix/1"                => array( 'size' => 1 ),
+                "$prefix/custom_directory" => array( 'size' => 42 ),
+            );
+        }
     }