HM\BackUpWordPress\Site_Size

Complexity

Total Complexity

25

Size/Duplication

Total Lines	219
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	4
Bugs	1	Features	1

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	get_formatted_site_size()	0	3	1
A	is_site_size_being_calculated()	0	3	1
A	is_site_size_cached()	0	3	1
B	get_site_size()	0	32	5
B	recursive_filesize_scanner()	0	46	4
B	filesize()	0	18	6
B	directory_filesize()	0	28	4
A	rebuild_directory_filesizes()	0	14	2

<?php

namespace HM\BackUpWordPress;

use HM\Backdrop\Task;
use Symfony\Component\Finder\Finder;

/**
 * Site Size class
 *
 * Use to calculate the total or partial size of the sites database and files.
 */
class Site_Size {

	private $size = 0;
	private $type = '';
	private $excludes = array();

	/**
	 * Constructor
	 *
	 * Set up some initial conditions including whether we want to calculate the
	 * size of the database, files or both and whether to exclude any files from
	 * the file size calculation.
	 *
	 * @param string $type     Whether to calculate the size of the database, files
	 *                         or both. Should be one of 'file', 'database' or 'complete'
	 * @param array  $excludes An array of exclude rules

Should the type for parameter $excludes not be null|Excludes?

	 */
	public function __construct( $type = 'complete', Excludes $excludes = null ) {
		$this->type = $type;
		$this->excludes = $excludes;

It seems like $excludes of type null or object<HM\BackUpWordPress\Excludes> is incompatible with the declared type array of property $excludes.

	}

	/**
	 * Calculate the size total size of the database + files.
	 *
	 * Doesn't account for any compression that would be gained by zipping.
	 *
	 * @return string

Should the return type not be integer|double?

	 */
	public function get_site_size() {

		if ( $this->size ) {
			return $this->size;
		}

		$size = 0;

		// Include database size except for file only schedule.
		if ( 'file' !== $this->type ) {

			global $wpdb;
			$tables = $wpdb->get_results( 'SHOW TABLE STATUS FROM `' . DB_NAME . '`', ARRAY_A );

			foreach ( $tables as $table ) {
				$size += (float) $table['Data_length'];
			}
		}

		// Include total size of dirs/files except for database only schedule.
		if ( 'database' !== $this->type ) {

			$root = new \SplFileInfo( Path::get_root() );
			$size += $this->filesize( $root );

		}

		$this->size = $size;

It seems like $size can also be of type double. However, the property $size is declared as type integer. Maybe add an additional type check?

		return $size;

	}

	/**
	 * Get the site size formatted
	 *
	 * @see size_format
	 *
	 * @return string
	 */
	public function get_formatted_site_size() {
		return size_format( $this->get_site_size() );
	}

	/**
	 * Whether the total filesize is being calculated
	 *
	 * @return bool
	 */
	public static function is_site_size_being_calculated() {
		return false !== get_transient( 'hmbkp_directory_filesizes_running' );
	}

	/**
	 * Whether the total filesize is cached
	 *
	 * @return bool
	 */
	public static function is_site_size_cached() {
		return false !== get_transient( 'hmbkp_directory_filesizes' );
	}

	/**
	 * Recursively scans a directory to calculate the total filesize
	 *
	 * Locks should be set by the caller with `set_transient( 'hmbkp_directory_filesizes_running', true, HOUR_IN_SECONDS );`
	 *
	 * @return array $directory_sizes    An array of directory paths => filesize sum of all files in directory
	 */
	public function recursive_filesize_scanner() {

		/**
		 * Raise the `memory_limit` and `max_execution time`
		 *
		 * Respects the WP_MAX_MEMORY_LIMIT Constant and the `admin_memory_limit`
		 * filter.
		 */
		@ini_set( 'memory_limit', apply_filters( 'admin_memory_limit', WP_MAX_MEMORY_LIMIT ) );

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

		@set_time_limit( 0 );

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

		// Use the cached array directory sizes if available
		$directory_sizes = get_transient( 'hmbkp_directory_filesizes' );

		// If we do have it in cache then let's use it and also clear the lock
		if ( is_array( $directory_sizes ) ) {
			delete_transient( 'hmbkp_directory_filesizes_running' );
			return $directory_sizes;
		}

		// If we don't have it cached then we'll need to re-calculate
		$finder = new Finder();
		$finder->followLinks();
		$finder->ignoreDotFiles( false );
		$finder->ignoreUnreadableDirs( true );

		$files = $finder->in( Path::get_root() );

		foreach ( $files as $file ) {

			if ( $file->isReadable() ) {
				$directory_sizes[ wp_normalize_path( $file->getRealpath() ) ] = $file->getSize();
			} else {
				$directory_sizes[ wp_normalize_path( $file->getRealpath() ) ] = 0;
			}

		}

		set_transient( 'hmbkp_directory_filesizes', $directory_sizes, DAY_IN_SECONDS );

		// Remove the lock
		delete_transient( 'hmbkp_directory_filesizes_running' );

		return $directory_sizes;

	}

	/**
	 * Get the total filesize for a given file or directory
	 *
	 * If $file is a file then just return the result of `filesize()`.
	 * If $file is a directory then recursively calculate the size.
	 *
	 * @param \SplFileInfo   $file The file or directory you want to know the size of
	 *
	 * @return int           The total filesize of the file or directory
	 */
	public function filesize( \SplFileInfo $file ) {

		// Skip missing or unreadable files
		if ( ! file_exists( $file->getPathname() ) || ! $file->getRealpath() || ! $file->isReadable() ) {
			return 0;
		}

		// If it's a file then just pass back the filesize
		if ( $file->isFile() ) {
			return $file->getSize();
		}

		// If it's a directory then pull it from the cached filesize array
		if ( $file->isDir() ) {
			return $this->directory_filesize( $file );
		}

	}

	public function directory_filesize( \SplFileInfo $file ) {

The return type could not be reliably inferred; please add a @return annotation.

		// If we haven't calculated the site size yet then kick it off in a thread
		$directory_sizes = get_transient( 'hmbkp_directory_filesizes' );


		if ( ! is_array( $directory_sizes ) ) {
			$this->rebuild_directory_filesizes();

			// Intentionally return null so the caller can tell that the size is being calculated
			return null;
		}

		// The filepaths are stored in keys so we need to flip for use with preg_grep
		$directory_sizes = array_flip( preg_grep( '(' . wp_normalize_path( $file->getRealPath() ) . ')', array_flip( $directory_sizes ) ) );

		if ( $this->excludes ) {

The expression $this->excludes of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

			$excludes = implode( '|', $this->excludes->get_excludes_for_regex() );

The method get_excludes_for_regex cannot be called on $this->excludes (of type array).

			if ( $excludes ) {
				// Use PREG_GREP_INVERT to remove any filepaths which match an exclude rule
				$directory_sizes = array_flip( preg_grep( '(' . $excludes . ')', array_flip( $directory_sizes ), PREG_GREP_INVERT ) );
			}
		}

		// Directory size is now just a sum of all files across all sub directories
		return absint( array_sum( $directory_sizes ) );

	}

	public function rebuild_directory_filesizes() {

		if ( $this->is_site_size_being_calculated() ) {
			return false;
		}

		// Mark the filesize as being calculated
		set_transient( 'hmbkp_directory_filesizes_running', true, HOUR_IN_SECONDS );

		// Schedule a Backdrop task to trigger a recalculation
		$task = new Task( array( $this, 'recursive_filesize_scanner' ) );
		$task->schedule();

	}

}