WordPress.org

Make WordPress Core

Ticket #46645: 46645.3.diff

File 46645.3.diff, 13.7 KB (added by azaozz, 6 months ago)
  • src/wp-admin/includes/class-wp-debug-data.php

     
    312312                        );
    313313                }
    314314
     315                $size_db = WP_Debug_Data::get_database_size();
     316
    315317                // Go through the various installation directories and calculate their sizes.
    316318                $uploads_dir = wp_upload_dir();
    317                 $inaccurate  = false;
    318319
    319320                /*
    320321                 * We will be using the PHP max execution time to prevent the size calculations
    321                  * from causing a timeout. We provide a default value of 30 seconds, as some
     322                 * from causing a timeout. The default value is 30 seconds, and some
    322323                 * hosts do not allow you to read configuration values.
    323324                 */
    324                 $max_execution_time   = 30;
    325                 $start_execution_time = microtime( true );
     325                $max_execution_time = 30;
     326
    326327                if ( function_exists( 'ini_get' ) ) {
    327328                        $max_execution_time = ini_get( 'max_execution_time' );
    328329                }
    329330
     331                // Here 20 seconds is a "sensible default" for how long to make the user wait for the directory size calculation.
     332                // When testing 20 seconds seem enough in nearly all cases. The remaining edge cases are likely testing or development sites
     333                // that have very large number of files, for example `node_modules` in plugins or themes, etc.
     334                if ( $max_execution_time > 20  ) {
     335                        $max_execution_time = 20;
     336                } elseif ( $max_execution_time > 2 ) {
     337                        // If the max_execution_time is set to lower than 20 seconds, reduce it a bit to prevent
     338                        // edge-case timeouts that may happen after the size loop has finished running.
     339                        $max_execution_time -= 1;
     340                }
     341
    330342                $size_directories = array(
    331343                        'wordpress' => array(
    332344                                'path' => ABSPATH,
     
    346358                        ),
    347359                );
    348360
     361                $timeout = __( 'The directory size calculation has timed out. Usually caused by a very large number of sub-directories and files.' );
     362                $inaccessible = __( 'The size cannot be calculated. The directory is not accessible. Usually caused by invalid permissions.' );
     363                $size_total = 0;
     364
    349365                // Loop over all the directories we want to gather the sizes for.
    350366                foreach ( $size_directories as $size => $attributes ) {
    351                         /*
    352                          * We run a helper function with a RecursiveIterator, which
    353                          * may throw an exception if it can't access directories.
    354                          *
    355                          * If a failure is detected we mark the result as inaccurate.
    356                          */
    357                         try {
    358                                 $calculated_size = WP_Debug_data::get_directory_size( $attributes['path'], $max_execution_time, $start_execution_time );
     367                        $dir_size = null; // Default to timeout.
    359368
    360                                 $size_directories[ $size ]['size'] = $calculated_size;
     369                        if ( microtime( true ) - WP_START_TIMESTAMP < $max_execution_time ) {
     370                                $dir_size = get_dirsize( $attributes['path'], $max_execution_time );
     371                        }
    361372
    362                                 /*
    363                                  * If the size returned is -1, this means execution has
    364                                  * exceeded the maximum execution time, also denoting an
    365                                  * inaccurate value in the end.
    366                                  */
    367                                 if ( -1 === $calculated_size ) {
    368                                         $inaccurate = true;
     373                        if ( $dir_size === false ) {
     374                                // Error reading
     375                                $dir_size = $inaccessible;
     376                                $size_total = null;
     377                        } elseif ( $dir_size === null ) {
     378                                // Timeout
     379                                $dir_size = $timeout;
     380                                $size_total = null;
     381                        } else {
     382                                if ( $size_total !== null ) {
     383                                        $size_total += $dir_size;
    369384                                }
    370                         } catch ( Exception $e ) {
    371                                 $inaccurate = true;
     385
     386                                $dir_size = size_format( $dir_size, 2 );
    372387                        }
     388
     389                        $size_directories[ $size ]['size'] = $dir_size;
    373390                }
    374391
    375                 $size_db = WP_Debug_Data::get_database_size();
     392                if ( $size_total !== null && $size_db > 0 ) {
     393                        $size_total = size_format( $size_total + $size_db, 2 );
     394                } else {
     395                        $size_total = __( 'Total size is not available. Some errors were encountered when determining the size of your installation.' );
     396                }
    376397
    377                 $size_total = $size_directories['wordpress']['size'] + $size_db;
    378 
    379398                $info['wp-paths-sizes']['fields'] = array(
    380399                        array(
    381400                                'label' => __( 'Uploads Directory Location' ),
     
    383402                        ),
    384403                        array(
    385404                                'label' => __( 'Uploads Directory Size' ),
    386                                 'value' => ( -1 === $size_directories['uploads']['size'] ? __( 'Unable to determine the size of this directory' ) : size_format( $size_directories['uploads']['size'], 2 ) ),
     405                                'value' => $size_directories['uploads']['size'],
    387406                        ),
    388407                        array(
    389408                                'label' => __( 'Themes Directory Location' ),
     
    395414                        ),
    396415                        array(
    397416                                'label' => __( 'Themes Directory Size' ),
    398                                 'value' => ( -1 === $size_directories['themes']['size'] ? __( 'Unable to determine the size of this directory' ) : size_format( $size_directories['themes']['size'], 2 ) ),
     417                                'value' => $size_directories['themes']['size'],
    399418                        ),
    400419                        array(
    401420                                'label' => __( 'Plugins Directory Location' ),
     
    403422                        ),
    404423                        array(
    405424                                'label' => __( 'Plugins Directory Size' ),
    406                                 'value' => ( -1 === $size_directories['plugins']['size'] ? __( 'Unable to determine the size of this directory' ) : size_format( $size_directories['plugins']['size'], 2 ) ),
     425                                'value' => $size_directories['plugins']['size'],
    407426                        ),
    408427                        array(
    409428                                'label' => __( 'WordPress Directory Location' ),
     
    411430                        ),
    412431                        array(
    413432                                'label' => __( 'WordPress Directory Size' ),
    414                                 'value' => size_format( $size_directories['wordpress']['size'], 2 ),
     433                                'value' => $size_directories['wordpress']['size'],
    415434                        ),
    416435                        array(
    417436                                'label' => __( 'Database size' ),
     
    419438                        ),
    420439                        array(
    421440                                'label' => __( 'Total installation size' ),
    422                                 'value' => sprintf(
    423                                         '%s%s',
    424                                         size_format( $size_total, 2 ),
    425                                         ( false === $inaccurate ? '' : __( '- Some errors, likely caused by invalid permissions, were encountered when determining the size of your installation. This means the values represented may be inaccurate.' ) )
    426                                 ),
     441                                'value' => $size_total,
    427442                        ),
    428443                );
    429444
     
    933948        }
    934949
    935950        /**
    936          * Return the size of a directory, including all subdirectories.
    937          *
    938          * @since 5.2.0
    939          *
    940          * @param string     $path                 The directory to check.
    941          * @param string|int $max_execution_time   How long a PHP script can run on this host.
    942          * @param float      $start_execution_time When we started executing this section of the script.
    943          *
    944          * @return int The directory size, in bytes.
    945          */
    946         public static function get_directory_size( $path, $max_execution_time, $start_execution_time ) {
    947                 $size = 0;
    948 
    949                 foreach ( new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $path ) ) as $file ) {
    950                         // Check if the maximum execution time is a value considered "infinite".
    951                         if ( 0 !== $max_execution_time && -1 !== $max_execution_time ) {
    952                                 $runtime = ( microtime( true ) - $start_execution_time );
    953 
    954                                 // If the script has been running as long, or longer, as it is allowed, return a failure message.
    955                                 if ( $runtime >= $max_execution_time ) {
    956                                         return -1;
    957                                 }
    958                         }
    959                         $size += $file->getSize();
    960                 }
    961 
    962                 return $size;
    963         }
    964 
    965         /**
    966951         * Fetch the total size of all the database tables for the active database user.
    967952         *
    968953         * @since 5.2.0
     
    980965                        }
    981966                }
    982967
    983                 return $size;
     968                return (int) $size;
    984969        }
    985970}
  • src/wp-includes/default-constants.php

     
    2929        define( 'TB_IN_BYTES', 1024 * GB_IN_BYTES );
    3030        /**#@-*/
    3131
     32        // Start of run timestamp.
     33        if ( ! defined( 'WP_START_TIMESTAMP' ) ) {
     34                define( 'WP_START_TIMESTAMP', microtime( true ) );
     35        }
     36
    3237        $current_limit     = @ini_get( 'memory_limit' );
    3338        $current_limit_int = wp_convert_hr_to_bytes( $current_limit );
    3439
  • src/wp-includes/functions.php

     
    68976897        );
    68986898        echo '</p>';
    68996899}
     6900
     6901/**
     6902 * Get the size of a directory.
     6903 *
     6904 * A helper function that is used primarily to check whether
     6905 * a blog has exceeded its allowed upload space.
     6906 *
     6907 * @since MU (3.0.0)
     6908 *
     6909 * @param string $directory Full path of a directory.
     6910 * @param int    $max_execution_time Maximum time to run before giving up. In seconds.
     6911 *                                   The timeout is global and is measured from the moment WordPress started to load.
     6912 * @return int|false|null Size in MB if a valid directory. False if not. Null if timeout.
     6913 */
     6914function get_dirsize( $directory, $max_execution_time = null ) {
     6915        $dirsize = get_transient( 'dirsize_cache' );
     6916
     6917        if ( is_array( $dirsize ) && isset( $dirsize[ $directory ]['size'] ) ) {
     6918                return $dirsize[ $directory ]['size'];
     6919        }
     6920
     6921        if ( ! is_array( $dirsize ) ) {
     6922                $dirsize = array();
     6923        }
     6924
     6925        // Exclude individual site directories from the total when checking the main site,
     6926        // as they are subdirectories and should not be counted.
     6927        if ( is_main_site() ) {
     6928                $dirsize[ $directory ]['size'] = recurse_dirsize( $directory, $directory . '/sites', $max_execution_time );
     6929        } else {
     6930                $dirsize[ $directory ]['size'] = recurse_dirsize( $directory, null, $max_execution_time );
     6931        }
     6932
     6933        set_transient( 'dirsize_cache', $dirsize, HOUR_IN_SECONDS );
     6934        return $dirsize[ $directory ]['size'];
     6935}
     6936
     6937/**
     6938 * Get the size of a directory recursively.
     6939 *
     6940 * Used by get_dirsize() to get a directory's size when it contains
     6941 * other directories.
     6942 *
     6943 * @since MU (3.0.0)
     6944 * @since 4.3.0 $exclude parameter added.
     6945 *
     6946 * @param string $directory Full path of a directory.
     6947 * @param string $exclude   Optional. Full path of a subdirectory to exclude from the total.
     6948 * @param int    $max_execution_time Maximum time to run before giving up. In seconds.
     6949 *                                   The timeout is global and is measured from the moment WordPress started to load.
     6950 * @return int|false|null Size in MB if a valid directory. False if not. Null if timeout.
     6951 */
     6952function recurse_dirsize( $directory, $exclude = null, $max_execution_time = null ) {
     6953        $size = 0;
     6954
     6955        $directory = untrailingslashit( $directory );
     6956
     6957        if ( ! file_exists( $directory ) || ! is_dir( $directory ) || ! is_readable( $directory ) || $directory === $exclude ) {
     6958                return false;
     6959        }
     6960
     6961        if ( ! $max_execution_time ) {
     6962                // Keep the previous behavior but attempt to prevent fatal errors from timeout.
     6963                if ( function_exists( 'ini_get' ) ) {
     6964                        $max_execution_time = ini_get( 'max_execution_time' );
     6965                } else {
     6966                        // Use PHP default.
     6967                        $max_execution_time = 30;
     6968                }
     6969
     6970                // Leave 1 second "buffer" for other operations if $max_execution_time has reasonable value.
     6971                if ( $max_execution_time > 10 ) {
     6972                        $max_execution_time -= 1;
     6973                }
     6974        }
     6975
     6976        if ( $handle = opendir( $directory ) ) {
     6977                while ( ( $file = readdir( $handle ) ) !== false ) {
     6978                        $path = $directory . '/' . $file;
     6979                        if ( $file != '.' && $file != '..' ) {
     6980                                if ( is_file( $path ) ) {
     6981                                        $size += filesize( $path );
     6982                                } elseif ( is_dir( $path ) ) {
     6983                                        $handlesize = recurse_dirsize( $path, $exclude, $max_execution_time );
     6984                                        if ( $handlesize > 0 ) {
     6985                                                $size += $handlesize;
     6986                                        }
     6987                                }
     6988
     6989                                if ( microtime( true ) - WP_START_TIMESTAMP > $max_execution_time ) {
     6990                                        // Time exceeded. Give up instead of risking a fatal timeout.
     6991                                        $size = null;
     6992                                        break;
     6993                                }
     6994                        }
     6995                }
     6996                closedir( $handle );
     6997        }
     6998        return $size;
     6999}
  • src/wp-includes/ms-functions.php

     
    17781778// Misc functions
    17791779
    17801780/**
    1781  * Get the size of a directory.
    1782  *
    1783  * A helper function that is used primarily to check whether
    1784  * a blog has exceeded its allowed upload space.
    1785  *
    1786  * @since MU (3.0.0)
    1787  *
    1788  * @param string $directory Full path of a directory.
    1789  * @return int Size of the directory in MB.
    1790  */
    1791 function get_dirsize( $directory ) {
    1792         $dirsize = get_transient( 'dirsize_cache' );
    1793         if ( is_array( $dirsize ) && isset( $dirsize[ $directory ]['size'] ) ) {
    1794                 return $dirsize[ $directory ]['size'];
    1795         }
    1796 
    1797         if ( ! is_array( $dirsize ) ) {
    1798                 $dirsize = array();
    1799         }
    1800 
    1801         // Exclude individual site directories from the total when checking the main site,
    1802         // as they are subdirectories and should not be counted.
    1803         if ( is_main_site() ) {
    1804                 $dirsize[ $directory ]['size'] = recurse_dirsize( $directory, $directory . '/sites' );
    1805         } else {
    1806                 $dirsize[ $directory ]['size'] = recurse_dirsize( $directory );
    1807         }
    1808 
    1809         set_transient( 'dirsize_cache', $dirsize, HOUR_IN_SECONDS );
    1810         return $dirsize[ $directory ]['size'];
    1811 }
    1812 
    1813 /**
    1814  * Get the size of a directory recursively.
    1815  *
    1816  * Used by get_dirsize() to get a directory's size when it contains
    1817  * other directories.
    1818  *
    1819  * @since MU (3.0.0)
    1820  * @since 4.3.0 $exclude parameter added.
    1821  *
    1822  * @param string $directory Full path of a directory.
    1823  * @param string $exclude   Optional. Full path of a subdirectory to exclude from the total.
    1824  * @return int|false Size in MB if a valid directory. False if not.
    1825  */
    1826 function recurse_dirsize( $directory, $exclude = null ) {
    1827         $size = 0;
    1828 
    1829         $directory = untrailingslashit( $directory );
    1830 
    1831         if ( ! file_exists( $directory ) || ! is_dir( $directory ) || ! is_readable( $directory ) || $directory === $exclude ) {
    1832                 return false;
    1833         }
    1834 
    1835         if ( $handle = opendir( $directory ) ) {
    1836                 while ( ( $file = readdir( $handle ) ) !== false ) {
    1837                         $path = $directory . '/' . $file;
    1838                         if ( $file != '.' && $file != '..' ) {
    1839                                 if ( is_file( $path ) ) {
    1840                                         $size += filesize( $path );
    1841                                 } elseif ( is_dir( $path ) ) {
    1842                                         $handlesize = recurse_dirsize( $path, $exclude );
    1843                                         if ( $handlesize > 0 ) {
    1844                                                 $size += $handlesize;
    1845                                         }
    1846                                 }
    1847                         }
    1848                 }
    1849                 closedir( $handle );
    1850         }
    1851         return $size;
    1852 }
    1853 
    1854 /**
    18551781 * Check an array of MIME types against a whitelist.
    18561782 *
    18571783 * WordPress ships with a set of allowed upload filetypes,