[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

/wp-admin/includes/ -> class-wp-upgrader.php (source)

   1  <?php
   2  /**
   3   * Upgrade API: WP_Upgrader class
   4   *
   5   * Requires skin classes and WP_Upgrader subclasses for backward compatibility.
   6   *
   7   * @package WordPress
   8   * @subpackage Upgrader
   9   * @since 2.8.0
  10   */
  11  
  12  /** WP_Upgrader_Skin class */
  13  require_once  ABSPATH . 'wp-admin/includes/class-wp-upgrader-skin.php';
  14  
  15  /** Plugin_Upgrader_Skin class */
  16  require_once  ABSPATH . 'wp-admin/includes/class-plugin-upgrader-skin.php';
  17  
  18  /** Theme_Upgrader_Skin class */
  19  require_once  ABSPATH . 'wp-admin/includes/class-theme-upgrader-skin.php';
  20  
  21  /** Bulk_Upgrader_Skin class */
  22  require_once  ABSPATH . 'wp-admin/includes/class-bulk-upgrader-skin.php';
  23  
  24  /** Bulk_Plugin_Upgrader_Skin class */
  25  require_once  ABSPATH . 'wp-admin/includes/class-bulk-plugin-upgrader-skin.php';
  26  
  27  /** Bulk_Theme_Upgrader_Skin class */
  28  require_once  ABSPATH . 'wp-admin/includes/class-bulk-theme-upgrader-skin.php';
  29  
  30  /** Plugin_Installer_Skin class */
  31  require_once  ABSPATH . 'wp-admin/includes/class-plugin-installer-skin.php';
  32  
  33  /** Theme_Installer_Skin class */
  34  require_once  ABSPATH . 'wp-admin/includes/class-theme-installer-skin.php';
  35  
  36  /** Language_Pack_Upgrader_Skin class */
  37  require_once  ABSPATH . 'wp-admin/includes/class-language-pack-upgrader-skin.php';
  38  
  39  /** Automatic_Upgrader_Skin class */
  40  require_once  ABSPATH . 'wp-admin/includes/class-automatic-upgrader-skin.php';
  41  
  42  /** WP_Ajax_Upgrader_Skin class */
  43  require_once  ABSPATH . 'wp-admin/includes/class-wp-ajax-upgrader-skin.php';
  44  
  45  /**
  46   * Core class used for upgrading/installing a local set of files via
  47   * the Filesystem Abstraction classes from a Zip file.
  48   *
  49   * @since 2.8.0
  50   */
  51  #[AllowDynamicProperties]
  52  class WP_Upgrader {
  53  
  54      /**
  55       * The error/notification strings used to update the user on the progress.
  56       *
  57       * @since 2.8.0
  58       * @var array $strings
  59       */
  60      public $strings = array();
  61  
  62      /**
  63       * The upgrader skin being used.
  64       *
  65       * @since 2.8.0
  66       * @var Automatic_Upgrader_Skin|WP_Upgrader_Skin $skin
  67       */
  68      public $skin = null;
  69  
  70      /**
  71       * The result of the installation.
  72       *
  73       * This is set by WP_Upgrader::install_package(), only when the package is installed
  74       * successfully. It will then be an array, unless a WP_Error is returned by the
  75       * {@see 'upgrader_post_install'} filter. In that case, the WP_Error will be assigned to
  76       * it.
  77       *
  78       * @since 2.8.0
  79       *
  80       * @var array|WP_Error $result {
  81       *     @type string $source             The full path to the source the files were installed from.
  82       *     @type string $source_files       List of all the files in the source directory.
  83       *     @type string $destination        The full path to the installation destination folder.
  84       *     @type string $destination_name   The name of the destination folder, or empty if `$destination`
  85       *                                      and `$local_destination` are the same.
  86       *     @type string $local_destination  The full local path to the destination folder. This is usually
  87       *                                      the same as `$destination`.
  88       *     @type string $remote_destination The full remote path to the destination folder
  89       *                                      (i.e., from `$wp_filesystem`).
  90       *     @type bool   $clear_destination  Whether the destination folder was cleared.
  91       * }
  92       */
  93      public $result = array();
  94  
  95      /**
  96       * The total number of updates being performed.
  97       *
  98       * Set by the bulk update methods.
  99       *
 100       * @since 3.0.0
 101       * @var int $update_count
 102       */
 103      public $update_count = 0;
 104  
 105      /**
 106       * The current update if multiple updates are being performed.
 107       *
 108       * Used by the bulk update methods, and incremented for each update.
 109       *
 110       * @since 3.0.0
 111       * @var int
 112       */
 113      public $update_current = 0;
 114  
 115      /**
 116       * Stores the list of plugins or themes added to temporary backup directory.
 117       *
 118       * Used by the rollback functions.
 119       *
 120       * @since 6.3.0
 121       * @var array
 122       */
 123      private $temp_backups = array();
 124  
 125      /**
 126       * Stores the list of plugins or themes to be restored from temporary backup directory.
 127       *
 128       * Used by the rollback functions.
 129       *
 130       * @since 6.3.0
 131       * @var array
 132       */
 133      private $temp_restores = array();
 134  
 135      /**
 136       * Construct the upgrader with a skin.
 137       *
 138       * @since 2.8.0
 139       *
 140       * @param WP_Upgrader_Skin $skin The upgrader skin to use. Default is a WP_Upgrader_Skin
 141       *                               instance.
 142       */
 143  	public function __construct( $skin = null ) {
 144          if ( null === $skin ) {
 145              $this->skin = new WP_Upgrader_Skin();
 146          } else {
 147              $this->skin = $skin;
 148          }
 149      }
 150  
 151      /**
 152       * Initializes the upgrader.
 153       *
 154       * This will set the relationship between the skin being used and this upgrader,
 155       * and also add the generic strings to `WP_Upgrader::$strings`.
 156       *
 157       * Additionally, it will schedule a weekly task to clean up the temporary backup directory.
 158       *
 159       * @since 2.8.0
 160       * @since 6.3.0 Added the `schedule_temp_backup_cleanup()` task.
 161       */
 162  	public function init() {
 163          $this->skin->set_upgrader( $this );
 164          $this->generic_strings();
 165  
 166          if ( ! wp_installing() ) {
 167              $this->schedule_temp_backup_cleanup();
 168          }
 169      }
 170  
 171      /**
 172       * Schedules the cleanup of the temporary backup directory.
 173       *
 174       * @since 6.3.0
 175       */
 176  	protected function schedule_temp_backup_cleanup() {
 177          if ( false === wp_next_scheduled( 'wp_delete_temp_updater_backups' ) ) {
 178              wp_schedule_event( time(), 'weekly', 'wp_delete_temp_updater_backups' );
 179          }
 180      }
 181  
 182      /**
 183       * Adds the generic strings to WP_Upgrader::$strings.
 184       *
 185       * @since 2.8.0
 186       */
 187  	public function generic_strings() {
 188          $this->strings['bad_request']    = __( 'Invalid data provided.' );
 189          $this->strings['fs_unavailable'] = __( 'Could not access filesystem.' );
 190          $this->strings['fs_error']       = __( 'Filesystem error.' );
 191          $this->strings['fs_no_root_dir'] = __( 'Unable to locate WordPress root directory.' );
 192          /* translators: %s: Directory name. */
 193          $this->strings['fs_no_content_dir'] = sprintf( __( 'Unable to locate WordPress content directory (%s).' ), 'wp-content' );
 194          $this->strings['fs_no_plugins_dir'] = __( 'Unable to locate WordPress plugin directory.' );
 195          $this->strings['fs_no_themes_dir']  = __( 'Unable to locate WordPress theme directory.' );
 196          /* translators: %s: Directory name. */
 197          $this->strings['fs_no_folder'] = __( 'Unable to locate needed folder (%s).' );
 198  
 199          $this->strings['no_package']           = __( 'Package not available.' );
 200          $this->strings['download_failed']      = __( 'Download failed.' );
 201          $this->strings['installing_package']   = __( 'Installing the latest version&#8230;' );
 202          $this->strings['no_files']             = __( 'The package contains no files.' );
 203          $this->strings['folder_exists']        = __( 'Destination folder already exists.' );
 204          $this->strings['mkdir_failed']         = __( 'Could not create directory.' );
 205          $this->strings['incompatible_archive'] = __( 'The package could not be installed.' );
 206          $this->strings['files_not_writable']   = __( 'The update cannot be installed because some files could not be copied. This is usually due to inconsistent file permissions.' );
 207  
 208          $this->strings['maintenance_start'] = __( 'Enabling Maintenance mode&#8230;' );
 209          $this->strings['maintenance_end']   = __( 'Disabling Maintenance mode&#8230;' );
 210  
 211          /* translators: %s: upgrade-temp-backup */
 212          $this->strings['temp_backup_mkdir_failed'] = sprintf( __( 'Could not create the %s directory.' ), 'upgrade-temp-backup' );
 213          /* translators: %s: upgrade-temp-backup */
 214          $this->strings['temp_backup_move_failed'] = sprintf( __( 'Could not move the old version to the %s directory.' ), 'upgrade-temp-backup' );
 215          /* translators: %s: The plugin or theme slug. */
 216          $this->strings['temp_backup_restore_failed'] = __( 'Could not restore the original version of %s.' );
 217          /* translators: %s: The plugin or theme slug. */
 218          $this->strings['temp_backup_delete_failed'] = __( 'Could not delete the temporary backup directory for %s.' );
 219      }
 220  
 221      /**
 222       * Connects to the filesystem.
 223       *
 224       * @since 2.8.0
 225       *
 226       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
 227       *
 228       * @param string[] $directories                  Optional. Array of directories. If any of these do
 229       *                                               not exist, a WP_Error object will be returned.
 230       *                                               Default empty array.
 231       * @param bool     $allow_relaxed_file_ownership Whether to allow relaxed file ownership.
 232       *                                               Default false.
 233       * @return bool|WP_Error True if able to connect, false or a WP_Error otherwise.
 234       */
 235  	public function fs_connect( $directories = array(), $allow_relaxed_file_ownership = false ) {
 236          global $wp_filesystem;
 237  
 238          $credentials = $this->skin->request_filesystem_credentials( false, $directories[0], $allow_relaxed_file_ownership );
 239          if ( false === $credentials ) {
 240              return false;
 241          }
 242  
 243          if ( ! WP_Filesystem( $credentials, $directories[0], $allow_relaxed_file_ownership ) ) {
 244              $error = true;
 245              if ( is_object( $wp_filesystem ) && $wp_filesystem->errors->has_errors() ) {
 246                  $error = $wp_filesystem->errors;
 247              }
 248              // Failed to connect. Error and request again.
 249              $this->skin->request_filesystem_credentials( $error, $directories[0], $allow_relaxed_file_ownership );
 250              return false;
 251          }
 252  
 253          if ( ! is_object( $wp_filesystem ) ) {
 254              return new WP_Error( 'fs_unavailable', $this->strings['fs_unavailable'] );
 255          }
 256  
 257          if ( is_wp_error( $wp_filesystem->errors ) && $wp_filesystem->errors->has_errors() ) {
 258              return new WP_Error( 'fs_error', $this->strings['fs_error'], $wp_filesystem->errors );
 259          }
 260  
 261          foreach ( (array) $directories as $dir ) {
 262              switch ( $dir ) {
 263                  case ABSPATH:
 264                      if ( ! $wp_filesystem->abspath() ) {
 265                          return new WP_Error( 'fs_no_root_dir', $this->strings['fs_no_root_dir'] );
 266                      }
 267                      break;
 268                  case WP_CONTENT_DIR:
 269                      if ( ! $wp_filesystem->wp_content_dir() ) {
 270                          return new WP_Error( 'fs_no_content_dir', $this->strings['fs_no_content_dir'] );
 271                      }
 272                      break;
 273                  case WP_PLUGIN_DIR:
 274                      if ( ! $wp_filesystem->wp_plugins_dir() ) {
 275                          return new WP_Error( 'fs_no_plugins_dir', $this->strings['fs_no_plugins_dir'] );
 276                      }
 277                      break;
 278                  case get_theme_root():
 279                      if ( ! $wp_filesystem->wp_themes_dir() ) {
 280                          return new WP_Error( 'fs_no_themes_dir', $this->strings['fs_no_themes_dir'] );
 281                      }
 282                      break;
 283                  default:
 284                      if ( ! $wp_filesystem->find_folder( $dir ) ) {
 285                          return new WP_Error( 'fs_no_folder', sprintf( $this->strings['fs_no_folder'], esc_html( basename( $dir ) ) ) );
 286                      }
 287                      break;
 288              }
 289          }
 290          return true;
 291      }
 292  
 293      /**
 294       * Downloads a package.
 295       *
 296       * @since 2.8.0
 297       * @since 5.2.0 Added the `$check_signatures` parameter.
 298       * @since 5.5.0 Added the `$hook_extra` parameter.
 299       *
 300       * @param string $package          The URI of the package. If this is the full path to an
 301       *                                 existing local file, it will be returned untouched.
 302       * @param bool   $check_signatures Whether to validate file signatures. Default false.
 303       * @param array  $hook_extra       Extra arguments to pass to the filter hooks. Default empty array.
 304       * @return string|WP_Error The full path to the downloaded package file, or a WP_Error object.
 305       */
 306  	public function download_package( $package, $check_signatures = false, $hook_extra = array() ) {
 307          /**
 308           * Filters whether to return the package.
 309           *
 310           * @since 3.7.0
 311           * @since 5.5.0 Added the `$hook_extra` parameter.
 312           *
 313           * @param bool        $reply      Whether to bail without returning the package.
 314           *                                Default false.
 315           * @param string      $package    The package file name.
 316           * @param WP_Upgrader $upgrader   The WP_Upgrader instance.
 317           * @param array       $hook_extra Extra arguments passed to hooked filters.
 318           */
 319          $reply = apply_filters( 'upgrader_pre_download', false, $package, $this, $hook_extra );
 320          if ( false !== $reply ) {
 321              return $reply;
 322          }
 323  
 324          if ( ! preg_match( '!^(http|https|ftp)://!i', $package ) && file_exists( $package ) ) { // Local file or remote?
 325              return $package; // Must be a local file.
 326          }
 327  
 328          if ( empty( $package ) ) {
 329              return new WP_Error( 'no_package', $this->strings['no_package'] );
 330          }
 331  
 332          $this->skin->feedback( 'downloading_package', $package );
 333  
 334          $download_file = download_url( $package, 300, $check_signatures );
 335  
 336          if ( is_wp_error( $download_file ) && ! $download_file->get_error_data( 'softfail-filename' ) ) {
 337              return new WP_Error( 'download_failed', $this->strings['download_failed'], $download_file->get_error_message() );
 338          }
 339  
 340          return $download_file;
 341      }
 342  
 343      /**
 344       * Unpacks a compressed package file.
 345       *
 346       * @since 2.8.0
 347       *
 348       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
 349       *
 350       * @param string $package        Full path to the package file.
 351       * @param bool   $delete_package Optional. Whether to delete the package file after attempting
 352       *                               to unpack it. Default true.
 353       * @return string|WP_Error The path to the unpacked contents, or a WP_Error on failure.
 354       */
 355  	public function unpack_package( $package, $delete_package = true ) {
 356          global $wp_filesystem;
 357  
 358          $this->skin->feedback( 'unpack_package' );
 359  
 360          if ( ! $wp_filesystem->wp_content_dir() ) {
 361              return new WP_Error( 'fs_no_content_dir', $this->strings['fs_no_content_dir'] );
 362          }
 363  
 364          $upgrade_folder = $wp_filesystem->wp_content_dir() . 'upgrade/';
 365  
 366          // Clean up contents of upgrade directory beforehand.
 367          $upgrade_files = $wp_filesystem->dirlist( $upgrade_folder );
 368          if ( ! empty( $upgrade_files ) ) {
 369              foreach ( $upgrade_files as $file ) {
 370                  $wp_filesystem->delete( $upgrade_folder . $file['name'], true );
 371              }
 372          }
 373  
 374          // We need a working directory - strip off any .tmp or .zip suffixes.
 375          $working_dir = $upgrade_folder . basename( basename( $package, '.tmp' ), '.zip' );
 376  
 377          // Clean up working directory.
 378          if ( $wp_filesystem->is_dir( $working_dir ) ) {
 379              $wp_filesystem->delete( $working_dir, true );
 380          }
 381  
 382          // Unzip package to working directory.
 383          $result = unzip_file( $package, $working_dir );
 384  
 385          // Once extracted, delete the package if required.
 386          if ( $delete_package ) {
 387              unlink( $package );
 388          }
 389  
 390          if ( is_wp_error( $result ) ) {
 391              $wp_filesystem->delete( $working_dir, true );
 392              if ( 'incompatible_archive' === $result->get_error_code() ) {
 393                  return new WP_Error( 'incompatible_archive', $this->strings['incompatible_archive'], $result->get_error_data() );
 394              }
 395              return $result;
 396          }
 397  
 398          return $working_dir;
 399      }
 400  
 401      /**
 402       * Flattens the results of WP_Filesystem_Base::dirlist() for iterating over.
 403       *
 404       * @since 4.9.0
 405       * @access protected
 406       *
 407       * @param array  $nested_files Array of files as returned by WP_Filesystem_Base::dirlist().
 408       * @param string $path         Relative path to prepend to child nodes. Optional.
 409       * @return array A flattened array of the $nested_files specified.
 410       */
 411  	protected function flatten_dirlist( $nested_files, $path = '' ) {
 412          $files = array();
 413  
 414          foreach ( $nested_files as $name => $details ) {
 415              $files[ $path . $name ] = $details;
 416  
 417              // Append children recursively.
 418              if ( ! empty( $details['files'] ) ) {
 419                  $children = $this->flatten_dirlist( $details['files'], $path . $name . '/' );
 420  
 421                  // Merge keeping possible numeric keys, which array_merge() will reindex from 0..n.
 422                  $files = $files + $children;
 423              }
 424          }
 425  
 426          return $files;
 427      }
 428  
 429      /**
 430       * Clears the directory where this item is going to be installed into.
 431       *
 432       * @since 4.3.0
 433       *
 434       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
 435       *
 436       * @param string $remote_destination The location on the remote filesystem to be cleared.
 437       * @return true|WP_Error True upon success, WP_Error on failure.
 438       */
 439  	public function clear_destination( $remote_destination ) {
 440          global $wp_filesystem;
 441  
 442          $files = $wp_filesystem->dirlist( $remote_destination, true, true );
 443  
 444          // False indicates that the $remote_destination doesn't exist.
 445          if ( false === $files ) {
 446              return true;
 447          }
 448  
 449          // Flatten the file list to iterate over.
 450          $files = $this->flatten_dirlist( $files );
 451  
 452          // Check all files are writable before attempting to clear the destination.
 453          $unwritable_files = array();
 454  
 455          // Check writability.
 456          foreach ( $files as $filename => $file_details ) {
 457              if ( ! $wp_filesystem->is_writable( $remote_destination . $filename ) ) {
 458                  // Attempt to alter permissions to allow writes and try again.
 459                  $wp_filesystem->chmod( $remote_destination . $filename, ( 'd' === $file_details['type'] ? FS_CHMOD_DIR : FS_CHMOD_FILE ) );
 460                  if ( ! $wp_filesystem->is_writable( $remote_destination . $filename ) ) {
 461                      $unwritable_files[] = $filename;
 462                  }
 463              }
 464          }
 465  
 466          if ( ! empty( $unwritable_files ) ) {
 467              return new WP_Error( 'files_not_writable', $this->strings['files_not_writable'], implode( ', ', $unwritable_files ) );
 468          }
 469  
 470          if ( ! $wp_filesystem->delete( $remote_destination, true ) ) {
 471              return new WP_Error( 'remove_old_failed', $this->strings['remove_old_failed'] );
 472          }
 473  
 474          return true;
 475      }
 476  
 477      /**
 478       * Install a package.
 479       *
 480       * Copies the contents of a package from a source directory, and installs them in
 481       * a destination directory. Optionally removes the source. It can also optionally
 482       * clear out the destination folder if it already exists.
 483       *
 484       * @since 2.8.0
 485       * @since 6.2.0 Use move_dir() instead of copy_dir() when possible.
 486       *
 487       * @global WP_Filesystem_Base $wp_filesystem        WordPress filesystem subclass.
 488       * @global array              $wp_theme_directories
 489       *
 490       * @param array|string $args {
 491       *     Optional. Array or string of arguments for installing a package. Default empty array.
 492       *
 493       *     @type string $source                      Required path to the package source. Default empty.
 494       *     @type string $destination                 Required path to a folder to install the package in.
 495       *                                               Default empty.
 496       *     @type bool   $clear_destination           Whether to delete any files already in the destination
 497       *                                               folder. Default false.
 498       *     @type bool   $clear_working               Whether to delete the files from the working directory
 499       *                                               after copying them to the destination. Default false.
 500       *     @type bool   $abort_if_destination_exists Whether to abort the installation if
 501       *                                               the destination folder already exists. Default true.
 502       *     @type array  $hook_extra                  Extra arguments to pass to the filter hooks called by
 503       *                                               WP_Upgrader::install_package(). Default empty array.
 504       * }
 505       *
 506       * @return array|WP_Error The result (also stored in `WP_Upgrader::$result`), or a WP_Error on failure.
 507       */
 508  	public function install_package( $args = array() ) {
 509          global $wp_filesystem, $wp_theme_directories;
 510  
 511          $defaults = array(
 512              'source'                      => '', // Please always pass this.
 513              'destination'                 => '', // ...and this.
 514              'clear_destination'           => false,
 515              'clear_working'               => false,
 516              'abort_if_destination_exists' => true,
 517              'hook_extra'                  => array(),
 518          );
 519  
 520          $args = wp_parse_args( $args, $defaults );
 521  
 522          // These were previously extract()'d.
 523          $source            = $args['source'];
 524          $destination       = $args['destination'];
 525          $clear_destination = $args['clear_destination'];
 526  
 527          if ( function_exists( 'set_time_limit' ) ) {
 528              set_time_limit( 300 );
 529          }
 530  
 531          if (
 532              ( ! is_string( $source ) || '' === $source || trim( $source ) !== $source ) ||
 533              ( ! is_string( $destination ) || '' === $destination || trim( $destination ) !== $destination )
 534          ) {
 535              return new WP_Error( 'bad_request', $this->strings['bad_request'] );
 536          }
 537          $this->skin->feedback( 'installing_package' );
 538  
 539          /**
 540           * Filters the installation response before the installation has started.
 541           *
 542           * Returning a value that could be evaluated as a `WP_Error` will effectively
 543           * short-circuit the installation, returning that value instead.
 544           *
 545           * @since 2.8.0
 546           *
 547           * @param bool|WP_Error $response   Installation response.
 548           * @param array         $hook_extra Extra arguments passed to hooked filters.
 549           */
 550          $res = apply_filters( 'upgrader_pre_install', true, $args['hook_extra'] );
 551  
 552          if ( is_wp_error( $res ) ) {
 553              return $res;
 554          }
 555  
 556          // Retain the original source and destinations.
 557          $remote_source     = $args['source'];
 558          $local_destination = $destination;
 559  
 560          $source_files       = array_keys( $wp_filesystem->dirlist( $remote_source ) );
 561          $remote_destination = $wp_filesystem->find_folder( $local_destination );
 562  
 563          // Locate which directory to copy to the new folder. This is based on the actual folder holding the files.
 564          if ( 1 === count( $source_files ) && $wp_filesystem->is_dir( trailingslashit( $args['source'] ) . $source_files[0] . '/' ) ) {
 565              // Only one folder? Then we want its contents.
 566              $source = trailingslashit( $args['source'] ) . trailingslashit( $source_files[0] );
 567          } elseif ( 0 === count( $source_files ) ) {
 568              // There are no files?
 569              return new WP_Error( 'incompatible_archive_empty', $this->strings['incompatible_archive'], $this->strings['no_files'] );
 570          } else {
 571              /*
 572               * It's only a single file, the upgrader will use the folder name of this file as the destination folder.
 573               * Folder name is based on zip filename.
 574               */
 575              $source = trailingslashit( $args['source'] );
 576          }
 577  
 578          /**
 579           * Filters the source file location for the upgrade package.
 580           *
 581           * @since 2.8.0
 582           * @since 4.4.0 The $hook_extra parameter became available.
 583           *
 584           * @param string      $source        File source location.
 585           * @param string      $remote_source Remote file source location.
 586           * @param WP_Upgrader $upgrader      WP_Upgrader instance.
 587           * @param array       $hook_extra    Extra arguments passed to hooked filters.
 588           */
 589          $source = apply_filters( 'upgrader_source_selection', $source, $remote_source, $this, $args['hook_extra'] );
 590  
 591          if ( is_wp_error( $source ) ) {
 592              return $source;
 593          }
 594  
 595          if ( ! empty( $args['hook_extra']['temp_backup'] ) ) {
 596              $temp_backup = $this->move_to_temp_backup_dir( $args['hook_extra']['temp_backup'] );
 597  
 598              if ( is_wp_error( $temp_backup ) ) {
 599                  return $temp_backup;
 600              }
 601  
 602              $this->temp_backups[] = $args['hook_extra']['temp_backup'];
 603          }
 604  
 605          // Has the source location changed? If so, we need a new source_files list.
 606          if ( $source !== $remote_source ) {
 607              $source_files = array_keys( $wp_filesystem->dirlist( $source ) );
 608          }
 609  
 610          /*
 611           * Protection against deleting files in any important base directories.
 612           * Theme_Upgrader & Plugin_Upgrader also trigger this, as they pass the
 613           * destination directory (WP_PLUGIN_DIR / wp-content/themes) intending
 614           * to copy the directory into the directory, whilst they pass the source
 615           * as the actual files to copy.
 616           */
 617          $protected_directories = array( ABSPATH, WP_CONTENT_DIR, WP_PLUGIN_DIR, WP_CONTENT_DIR . '/themes' );
 618  
 619          if ( is_array( $wp_theme_directories ) ) {
 620              $protected_directories = array_merge( $protected_directories, $wp_theme_directories );
 621          }
 622  
 623          if ( in_array( $destination, $protected_directories, true ) ) {
 624              $remote_destination = trailingslashit( $remote_destination ) . trailingslashit( basename( $source ) );
 625              $destination        = trailingslashit( $destination ) . trailingslashit( basename( $source ) );
 626          }
 627  
 628          if ( $clear_destination ) {
 629              // We're going to clear the destination if there's something there.
 630              $this->skin->feedback( 'remove_old' );
 631  
 632              $removed = $this->clear_destination( $remote_destination );
 633  
 634              /**
 635               * Filters whether the upgrader cleared the destination.
 636               *
 637               * @since 2.8.0
 638               *
 639               * @param true|WP_Error $removed            Whether the destination was cleared.
 640               *                                          True upon success, WP_Error on failure.
 641               * @param string        $local_destination  The local package destination.
 642               * @param string        $remote_destination The remote package destination.
 643               * @param array         $hook_extra         Extra arguments passed to hooked filters.
 644               */
 645              $removed = apply_filters( 'upgrader_clear_destination', $removed, $local_destination, $remote_destination, $args['hook_extra'] );
 646  
 647              if ( is_wp_error( $removed ) ) {
 648                  return $removed;
 649              }
 650          } elseif ( $args['abort_if_destination_exists'] && $wp_filesystem->exists( $remote_destination ) ) {
 651              /*
 652               * If we're not clearing the destination folder and something exists there already, bail.
 653               * But first check to see if there are actually any files in the folder.
 654               */
 655              $_files = $wp_filesystem->dirlist( $remote_destination );
 656              if ( ! empty( $_files ) ) {
 657                  $wp_filesystem->delete( $remote_source, true ); // Clear out the source files.
 658                  return new WP_Error( 'folder_exists', $this->strings['folder_exists'], $remote_destination );
 659              }
 660          }
 661  
 662          /*
 663           * If 'clear_working' is false, the source should not be removed, so use copy_dir() instead.
 664           *
 665           * Partial updates, like language packs, may want to retain the destination.
 666           * If the destination exists or has contents, this may be a partial update,
 667           * and the destination should not be removed, so use copy_dir() instead.
 668           */
 669          if ( $args['clear_working']
 670              && (
 671                  // Destination does not exist or has no contents.
 672                  ! $wp_filesystem->exists( $remote_destination )
 673                  || empty( $wp_filesystem->dirlist( $remote_destination ) )
 674              )
 675          ) {
 676              $result = move_dir( $source, $remote_destination, true );
 677          } else {
 678              // Create destination if needed.
 679              if ( ! $wp_filesystem->exists( $remote_destination ) ) {
 680                  if ( ! $wp_filesystem->mkdir( $remote_destination, FS_CHMOD_DIR ) ) {
 681                      return new WP_Error( 'mkdir_failed_destination', $this->strings['mkdir_failed'], $remote_destination );
 682                  }
 683              }
 684              $result = copy_dir( $source, $remote_destination );
 685          }
 686  
 687          // Clear the working directory?
 688          if ( $args['clear_working'] ) {
 689              $wp_filesystem->delete( $remote_source, true );
 690          }
 691  
 692          if ( is_wp_error( $result ) ) {
 693              return $result;
 694          }
 695  
 696          $destination_name = basename( str_replace( $local_destination, '', $destination ) );
 697          if ( '.' === $destination_name ) {
 698              $destination_name = '';
 699          }
 700  
 701          $this->result = compact( 'source', 'source_files', 'destination', 'destination_name', 'local_destination', 'remote_destination', 'clear_destination' );
 702  
 703          /**
 704           * Filters the installation response after the installation has finished.
 705           *
 706           * @since 2.8.0
 707           *
 708           * @param bool  $response   Installation response.
 709           * @param array $hook_extra Extra arguments passed to hooked filters.
 710           * @param array $result     Installation result data.
 711           */
 712          $res = apply_filters( 'upgrader_post_install', true, $args['hook_extra'], $this->result );
 713  
 714          if ( is_wp_error( $res ) ) {
 715              $this->result = $res;
 716              return $res;
 717          }
 718  
 719          // Bombard the calling function will all the info which we've just used.
 720          return $this->result;
 721      }
 722  
 723      /**
 724       * Runs an upgrade/installation.
 725       *
 726       * Attempts to download the package (if it is not a local file), unpack it, and
 727       * install it in the destination folder.
 728       *
 729       * @since 2.8.0
 730       *
 731       * @param array $options {
 732       *     Array or string of arguments for upgrading/installing a package.
 733       *
 734       *     @type string $package                     The full path or URI of the package to install.
 735       *                                               Default empty.
 736       *     @type string $destination                 The full path to the destination folder.
 737       *                                               Default empty.
 738       *     @type bool   $clear_destination           Whether to delete any files already in the
 739       *                                               destination folder. Default false.
 740       *     @type bool   $clear_working               Whether to delete the files from the working
 741       *                                               directory after copying them to the destination.
 742       *                                               Default true.
 743       *     @type bool   $abort_if_destination_exists Whether to abort the installation if the destination
 744       *                                               folder already exists. When true, `$clear_destination`
 745       *                                               should be false. Default true.
 746       *     @type bool   $is_multi                    Whether this run is one of multiple upgrade/installation
 747       *                                               actions being performed in bulk. When true, the skin
 748       *                                               WP_Upgrader::header() and WP_Upgrader::footer()
 749       *                                               aren't called. Default false.
 750       *     @type array  $hook_extra                  Extra arguments to pass to the filter hooks called by
 751       *                                               WP_Upgrader::run().
 752       * }
 753       * @return array|false|WP_Error The result from self::install_package() on success, otherwise a WP_Error,
 754       *                              or false if unable to connect to the filesystem.
 755       */
 756  	public function run( $options ) {
 757  
 758          $defaults = array(
 759              'package'                     => '', // Please always pass this.
 760              'destination'                 => '', // ...and this.
 761              'clear_destination'           => false,
 762              'clear_working'               => true,
 763              'abort_if_destination_exists' => true, // Abort if the destination directory exists. Pass clear_destination as false please.
 764              'is_multi'                    => false,
 765              'hook_extra'                  => array(), // Pass any extra $hook_extra args here, this will be passed to any hooked filters.
 766          );
 767  
 768          $options = wp_parse_args( $options, $defaults );
 769  
 770          /**
 771           * Filters the package options before running an update.
 772           *
 773           * See also {@see 'upgrader_process_complete'}.
 774           *
 775           * @since 4.3.0
 776           *
 777           * @param array $options {
 778           *     Options used by the upgrader.
 779           *
 780           *     @type string $package                     Package for update.
 781           *     @type string $destination                 Update location.
 782           *     @type bool   $clear_destination           Clear the destination resource.
 783           *     @type bool   $clear_working               Clear the working resource.
 784           *     @type bool   $abort_if_destination_exists Abort if the Destination directory exists.
 785           *     @type bool   $is_multi                    Whether the upgrader is running multiple times.
 786           *     @type array  $hook_extra {
 787           *         Extra hook arguments.
 788           *
 789           *         @type string $action               Type of action. Default 'update'.
 790           *         @type string $type                 Type of update process. Accepts 'plugin', 'theme', or 'core'.
 791           *         @type bool   $bulk                 Whether the update process is a bulk update. Default true.
 792           *         @type string $plugin               Path to the plugin file relative to the plugins directory.
 793           *         @type string $theme                The stylesheet or template name of the theme.
 794           *         @type string $language_update_type The language pack update type. Accepts 'plugin', 'theme',
 795           *                                            or 'core'.
 796           *         @type object $language_update      The language pack update offer.
 797           *     }
 798           * }
 799           */
 800          $options = apply_filters( 'upgrader_package_options', $options );
 801  
 802          if ( ! $options['is_multi'] ) { // Call $this->header separately if running multiple times.
 803              $this->skin->header();
 804          }
 805  
 806          // Connect to the filesystem first.
 807          $res = $this->fs_connect( array( WP_CONTENT_DIR, $options['destination'] ) );
 808          // Mainly for non-connected filesystem.
 809          if ( ! $res ) {
 810              if ( ! $options['is_multi'] ) {
 811                  $this->skin->footer();
 812              }
 813              return false;
 814          }
 815  
 816          $this->skin->before();
 817  
 818          if ( is_wp_error( $res ) ) {
 819              $this->skin->error( $res );
 820              $this->skin->after();
 821              if ( ! $options['is_multi'] ) {
 822                  $this->skin->footer();
 823              }
 824              return $res;
 825          }
 826  
 827          /*
 828           * Download the package. Note: If the package is the full path
 829           * to an existing local file, it will be returned untouched.
 830           */
 831          $download = $this->download_package( $options['package'], false, $options['hook_extra'] );
 832  
 833          /*
 834           * Allow for signature soft-fail.
 835           * WARNING: This may be removed in the future.
 836           */
 837          if ( is_wp_error( $download ) && $download->get_error_data( 'softfail-filename' ) ) {
 838  
 839              // Don't output the 'no signature could be found' failure message for now.
 840              if ( 'signature_verification_no_signature' !== $download->get_error_code() || WP_DEBUG ) {
 841                  // Output the failure error as a normal feedback, and not as an error.
 842                  $this->skin->feedback( $download->get_error_message() );
 843  
 844                  // Report this failure back to WordPress.org for debugging purposes.
 845                  wp_version_check(
 846                      array(
 847                          'signature_failure_code' => $download->get_error_code(),
 848                          'signature_failure_data' => $download->get_error_data(),
 849                      )
 850                  );
 851              }
 852  
 853              // Pretend this error didn't happen.
 854              $download = $download->get_error_data( 'softfail-filename' );
 855          }
 856  
 857          if ( is_wp_error( $download ) ) {
 858              $this->skin->error( $download );
 859              $this->skin->after();
 860              if ( ! $options['is_multi'] ) {
 861                  $this->skin->footer();
 862              }
 863              return $download;
 864          }
 865  
 866          $delete_package = ( $download !== $options['package'] ); // Do not delete a "local" file.
 867  
 868          // Unzips the file into a temporary directory.
 869          $working_dir = $this->unpack_package( $download, $delete_package );
 870          if ( is_wp_error( $working_dir ) ) {
 871              $this->skin->error( $working_dir );
 872              $this->skin->after();
 873              if ( ! $options['is_multi'] ) {
 874                  $this->skin->footer();
 875              }
 876              return $working_dir;
 877          }
 878  
 879          // With the given options, this installs it to the destination directory.
 880          $result = $this->install_package(
 881              array(
 882                  'source'                      => $working_dir,
 883                  'destination'                 => $options['destination'],
 884                  'clear_destination'           => $options['clear_destination'],
 885                  'abort_if_destination_exists' => $options['abort_if_destination_exists'],
 886                  'clear_working'               => $options['clear_working'],
 887                  'hook_extra'                  => $options['hook_extra'],
 888              )
 889          );
 890  
 891          /**
 892           * Filters the result of WP_Upgrader::install_package().
 893           *
 894           * @since 5.7.0
 895           *
 896           * @param array|WP_Error $result     Result from WP_Upgrader::install_package().
 897           * @param array          $hook_extra Extra arguments passed to hooked filters.
 898           */
 899          $result = apply_filters( 'upgrader_install_package_result', $result, $options['hook_extra'] );
 900  
 901          $this->skin->set_result( $result );
 902  
 903          if ( is_wp_error( $result ) ) {
 904              // An automatic plugin update will have already performed its rollback.
 905              if ( ! empty( $options['hook_extra']['temp_backup'] ) ) {
 906                  $this->temp_restores[] = $options['hook_extra']['temp_backup'];
 907  
 908                  /*
 909                   * Restore the backup on shutdown.
 910                   * Actions running on `shutdown` are immune to PHP timeouts,
 911                   * so in case the failure was due to a PHP timeout,
 912                   * it will still be able to properly restore the previous version.
 913                   *
 914                   * Zero arguments are accepted as a string can sometimes be passed
 915                   * internally during actions, causing an error because
 916                   * `WP_Upgrader::restore_temp_backup()` expects an array.
 917                   */
 918                  add_action( 'shutdown', array( $this, 'restore_temp_backup' ), 10, 0 );
 919              }
 920              $this->skin->error( $result );
 921  
 922              if ( ! method_exists( $this->skin, 'hide_process_failed' ) || ! $this->skin->hide_process_failed( $result ) ) {
 923                  $this->skin->feedback( 'process_failed' );
 924              }
 925          } else {
 926              // Installation succeeded.
 927              $this->skin->feedback( 'process_success' );
 928          }
 929  
 930          $this->skin->after();
 931  
 932          // Clean up the backup kept in the temporary backup directory.
 933          if ( ! empty( $options['hook_extra']['temp_backup'] ) ) {
 934              // Delete the backup on `shutdown` to avoid a PHP timeout.
 935              add_action( 'shutdown', array( $this, 'delete_temp_backup' ), 100, 0 );
 936          }
 937  
 938          if ( ! $options['is_multi'] ) {
 939  
 940              /**
 941               * Fires when the upgrader process is complete.
 942               *
 943               * See also {@see 'upgrader_package_options'}.
 944               *
 945               * @since 3.6.0
 946               * @since 3.7.0 Added to WP_Upgrader::run().
 947               * @since 4.6.0 `$translations` was added as a possible argument to `$hook_extra`.
 948               *
 949               * @param WP_Upgrader $upgrader   WP_Upgrader instance. In other contexts this might be a
 950               *                                Theme_Upgrader, Plugin_Upgrader, Core_Upgrade, or Language_Pack_Upgrader instance.
 951               * @param array       $hook_extra {
 952               *     Array of bulk item update data.
 953               *
 954               *     @type string $action       Type of action. Default 'update'.
 955               *     @type string $type         Type of update process. Accepts 'plugin', 'theme', 'translation', or 'core'.
 956               *     @type bool   $bulk         Whether the update process is a bulk update. Default true.
 957               *     @type array  $plugins      Array of the basename paths of the plugins' main files.
 958               *     @type array  $themes       The theme slugs.
 959               *     @type array  $translations {
 960               *         Array of translations update data.
 961               *
 962               *         @type string $language The locale the translation is for.
 963               *         @type string $type     Type of translation. Accepts 'plugin', 'theme', or 'core'.
 964               *         @type string $slug     Text domain the translation is for. The slug of a theme/plugin or
 965               *                                'default' for core translations.
 966               *         @type string $version  The version of a theme, plugin, or core.
 967               *     }
 968               * }
 969               */
 970              do_action( 'upgrader_process_complete', $this, $options['hook_extra'] );
 971  
 972              $this->skin->footer();
 973          }
 974  
 975          return $result;
 976      }
 977  
 978      /**
 979       * Toggles maintenance mode for the site.
 980       *
 981       * Creates/deletes the maintenance file to enable/disable maintenance mode.
 982       *
 983       * @since 2.8.0
 984       *
 985       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
 986       *
 987       * @param bool $enable True to enable maintenance mode, false to disable.
 988       */
 989  	public function maintenance_mode( $enable = false ) {
 990          global $wp_filesystem;
 991  
 992          if ( ! $wp_filesystem ) {
 993              require_once  ABSPATH . 'wp-admin/includes/file.php';
 994              WP_Filesystem();
 995          }
 996  
 997          $file = $wp_filesystem->abspath() . '.maintenance';
 998          if ( $enable ) {
 999              if ( ! wp_doing_cron() ) {
1000                  $this->skin->feedback( 'maintenance_start' );
1001              }
1002              // Create maintenance file to signal that we are upgrading.
1003              $maintenance_string = '<?php $upgrading = ' . time() . '; ?>';
1004              $wp_filesystem->delete( $file );
1005              $wp_filesystem->put_contents( $file, $maintenance_string, FS_CHMOD_FILE );
1006          } elseif ( ! $enable && $wp_filesystem->exists( $file ) ) {
1007              if ( ! wp_doing_cron() ) {
1008                  $this->skin->feedback( 'maintenance_end' );
1009              }
1010              $wp_filesystem->delete( $file );
1011          }
1012      }
1013  
1014      /**
1015       * Creates a lock using WordPress options.
1016       *
1017       * @since 4.5.0
1018       *
1019       * @global wpdb $wpdb The WordPress database abstraction object.
1020       *
1021       * @param string $lock_name       The name of this unique lock.
1022       * @param int    $release_timeout Optional. The duration in seconds to respect an existing lock.
1023       *                                Default: 1 hour.
1024       * @return bool False if a lock couldn't be created or if the lock is still valid. True otherwise.
1025       */
1026  	public static function create_lock( $lock_name, $release_timeout = null ) {
1027          global $wpdb;
1028          if ( ! $release_timeout ) {
1029              $release_timeout = HOUR_IN_SECONDS;
1030          }
1031          $lock_option = $lock_name . '.lock';
1032  
1033          // Try to lock.
1034          $lock_result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` ( `option_name`, `option_value`, `autoload` ) VALUES (%s, %s, 'off') /* LOCK */", $lock_option, time() ) );
1035  
1036          if ( ! $lock_result ) {
1037              $lock_result = get_option( $lock_option );
1038  
1039              // If a lock couldn't be created, and there isn't a lock, bail.
1040              if ( ! $lock_result ) {
1041                  return false;
1042              }
1043  
1044              // Check to see if the lock is still valid. If it is, bail.
1045              if ( $lock_result > ( time() - $release_timeout ) ) {
1046                  return false;
1047              }
1048  
1049              // There must exist an expired lock, clear it and re-gain it.
1050              WP_Upgrader::release_lock( $lock_name );
1051  
1052              return WP_Upgrader::create_lock( $lock_name, $release_timeout );
1053          }
1054  
1055          // Update the lock, as by this point we've definitely got a lock, just need to fire the actions.
1056          update_option( $lock_option, time() );
1057  
1058          return true;
1059      }
1060  
1061      /**
1062       * Releases an upgrader lock.
1063       *
1064       * @since 4.5.0
1065       *
1066       * @see WP_Upgrader::create_lock()
1067       *
1068       * @param string $lock_name The name of this unique lock.
1069       * @return bool True if the lock was successfully released. False on failure.
1070       */
1071  	public static function release_lock( $lock_name ) {
1072          return delete_option( $lock_name . '.lock' );
1073      }
1074  
1075      /**
1076       * Moves the plugin or theme being updated into a temporary backup directory.
1077       *
1078       * @since 6.3.0
1079       *
1080       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
1081       *
1082       * @param string[] $args {
1083       *     Array of data for the temporary backup.
1084       *
1085       *     @type string $slug Plugin or theme slug.
1086       *     @type string $src  Path to the root directory for plugins or themes.
1087       *     @type string $dir  Destination subdirectory name. Accepts 'plugins' or 'themes'.
1088       * }
1089       *
1090       * @return bool|WP_Error True on success, false on early exit, otherwise WP_Error.
1091       */
1092  	public function move_to_temp_backup_dir( $args ) {
1093          global $wp_filesystem;
1094  
1095          if ( empty( $args['slug'] ) || empty( $args['src'] ) || empty( $args['dir'] ) ) {
1096              return false;
1097          }
1098  
1099          /*
1100           * Skip any plugin that has "." as its slug.
1101           * A slug of "." will result in a `$src` value ending in a period.
1102           *
1103           * On Windows, this will cause the 'plugins' folder to be moved,
1104           * and will cause a failure when attempting to call `mkdir()`.
1105           */
1106          if ( '.' === $args['slug'] ) {
1107              return false;
1108          }
1109  
1110          if ( ! $wp_filesystem->wp_content_dir() ) {
1111              return new WP_Error( 'fs_no_content_dir', $this->strings['fs_no_content_dir'] );
1112          }
1113  
1114          $dest_dir = $wp_filesystem->wp_content_dir() . 'upgrade-temp-backup/';
1115          $sub_dir  = $dest_dir . $args['dir'] . '/';
1116  
1117          // Create the temporary backup directory if it does not exist.
1118          if ( ! $wp_filesystem->is_dir( $sub_dir ) ) {
1119              if ( ! $wp_filesystem->is_dir( $dest_dir ) ) {
1120                  $wp_filesystem->mkdir( $dest_dir, FS_CHMOD_DIR );
1121              }
1122  
1123              if ( ! $wp_filesystem->mkdir( $sub_dir, FS_CHMOD_DIR ) ) {
1124                  // Could not create the backup directory.
1125                  return new WP_Error( 'fs_temp_backup_mkdir', $this->strings['temp_backup_mkdir_failed'] );
1126              }
1127          }
1128  
1129          $src_dir = $wp_filesystem->find_folder( $args['src'] );
1130          $src     = trailingslashit( $src_dir ) . $args['slug'];
1131          $dest    = $dest_dir . trailingslashit( $args['dir'] ) . $args['slug'];
1132  
1133          // Delete the temporary backup directory if it already exists.
1134          if ( $wp_filesystem->is_dir( $dest ) ) {
1135              $wp_filesystem->delete( $dest, true );
1136          }
1137  
1138          // Move to the temporary backup directory.
1139          $result = move_dir( $src, $dest, true );
1140          if ( is_wp_error( $result ) ) {
1141              return new WP_Error( 'fs_temp_backup_move', $this->strings['temp_backup_move_failed'] );
1142          }
1143  
1144          return true;
1145      }
1146  
1147      /**
1148       * Restores the plugin or theme from temporary backup.
1149       *
1150       * @since 6.3.0
1151       * @since 6.6.0 Added the `$temp_backups` parameter.
1152       *
1153       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
1154       *
1155       * @param array[] $temp_backups {
1156       *     Optional. An array of temporary backups.
1157       *
1158       *     @type array ...$0 {
1159       *         Information about the backup.
1160       *
1161       *         @type string $dir  The temporary backup location in the upgrade-temp-backup directory.
1162       *         @type string $slug The item's slug.
1163       *         @type string $src  The directory where the original is stored. For example, `WP_PLUGIN_DIR`.
1164       *     }
1165       * }
1166       * @return bool|WP_Error True on success, false on early exit, otherwise WP_Error.
1167       */
1168  	public function restore_temp_backup( array $temp_backups = array() ) {
1169          global $wp_filesystem;
1170  
1171          $errors = new WP_Error();
1172  
1173          if ( empty( $temp_backups ) ) {
1174              $temp_backups = $this->temp_restores;
1175          }
1176  
1177          foreach ( $temp_backups as $args ) {
1178              if ( empty( $args['slug'] ) || empty( $args['src'] ) || empty( $args['dir'] ) ) {
1179                  return false;
1180              }
1181  
1182              if ( ! $wp_filesystem->wp_content_dir() ) {
1183                  $errors->add( 'fs_no_content_dir', $this->strings['fs_no_content_dir'] );
1184                  return $errors;
1185              }
1186  
1187              $src      = $wp_filesystem->wp_content_dir() . 'upgrade-temp-backup/' . $args['dir'] . '/' . $args['slug'];
1188              $dest_dir = $wp_filesystem->find_folder( $args['src'] );
1189              $dest     = trailingslashit( $dest_dir ) . $args['slug'];
1190  
1191              if ( $wp_filesystem->is_dir( $src ) ) {
1192                  // Cleanup.
1193                  if ( $wp_filesystem->is_dir( $dest ) && ! $wp_filesystem->delete( $dest, true ) ) {
1194                      $errors->add(
1195                          'fs_temp_backup_delete',
1196                          sprintf( $this->strings['temp_backup_restore_failed'], $args['slug'] )
1197                      );
1198                      continue;
1199                  }
1200  
1201                  // Move it.
1202                  $result = move_dir( $src, $dest, true );
1203                  if ( is_wp_error( $result ) ) {
1204                      $errors->add(
1205                          'fs_temp_backup_delete',
1206                          sprintf( $this->strings['temp_backup_restore_failed'], $args['slug'] )
1207                      );
1208                      continue;
1209                  }
1210              }
1211          }
1212  
1213          return $errors->has_errors() ? $errors : true;
1214      }
1215  
1216      /**
1217       * Deletes a temporary backup.
1218       *
1219       * @since 6.3.0
1220       * @since 6.6.0 Added the `$temp_backups` parameter.
1221       *
1222       * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass.
1223       *
1224       * @param array[] $temp_backups {
1225       *     Optional. An array of temporary backups.
1226       *
1227       *     @type array ...$0 {
1228       *         Information about the backup.
1229       *
1230       *         @type string $dir  The temporary backup location in the upgrade-temp-backup directory.
1231       *         @type string $slug The item's slug.
1232       *         @type string $src  The directory where the original is stored. For example, `WP_PLUGIN_DIR`.
1233       *     }
1234       * }
1235       * @return bool|WP_Error True on success, false on early exit, otherwise WP_Error.
1236       */
1237  	public function delete_temp_backup( array $temp_backups = array() ) {
1238          global $wp_filesystem;
1239  
1240          $errors = new WP_Error();
1241  
1242          if ( empty( $temp_backups ) ) {
1243              $temp_backups = $this->temp_backups;
1244          }
1245  
1246          foreach ( $temp_backups as $args ) {
1247              if ( empty( $args['slug'] ) || empty( $args['dir'] ) ) {
1248                  return false;
1249              }
1250  
1251              if ( ! $wp_filesystem->wp_content_dir() ) {
1252                  $errors->add( 'fs_no_content_dir', $this->strings['fs_no_content_dir'] );
1253                  return $errors;
1254              }
1255  
1256              $temp_backup_dir = $wp_filesystem->wp_content_dir() . "upgrade-temp-backup/{$args['dir']}/{$args['slug']}";
1257  
1258              if ( ! $wp_filesystem->delete( $temp_backup_dir, true ) ) {
1259                  $errors->add(
1260                      'temp_backup_delete_failed',
1261                      sprintf( $this->strings['temp_backup_delete_failed'], $args['slug'] )
1262                  );
1263                  continue;
1264              }
1265          }
1266  
1267          return $errors->has_errors() ? $errors : true;
1268      }
1269  }
1270  
1271  /** Plugin_Upgrader class */
1272  require_once  ABSPATH . 'wp-admin/includes/class-plugin-upgrader.php';
1273  
1274  /** Theme_Upgrader class */
1275  require_once  ABSPATH . 'wp-admin/includes/class-theme-upgrader.php';
1276  
1277  /** Language_Pack_Upgrader class */
1278  require_once  ABSPATH . 'wp-admin/includes/class-language-pack-upgrader.php';
1279  
1280  /** Core_Upgrader class */
1281  require_once  ABSPATH . 'wp-admin/includes/class-core-upgrader.php';
1282  
1283  /** File_Upload_Upgrader class */
1284  require_once  ABSPATH . 'wp-admin/includes/class-file-upload-upgrader.php';
1285  
1286  /** WP_Automatic_Updater class */
1287  require_once  ABSPATH . 'wp-admin/includes/class-wp-automatic-updater.php';


Generated : Mon Jul 15 08:20:02 2024 Cross-referenced by PHPXref