home *** CD-ROM | disk | FTP | other *** search
/ HTML Examples / WP.iso / wordpress / wp-admin / includes / class-core-upgrader.php < prev    next >
Encoding:
PHP Script  |  2017-10-18  |  13.1 KB  |  363 lines
  1. <?php
  2. /**
  3.  * Upgrade API: Core_Upgrader class
  4.  *
  5.  * @package WordPress
  6.  * @subpackage Upgrader
  7.  * @since 4.6.0
  8.  */
  9.  
  10. /**
  11.  * Core class used for updating core.
  12.  *
  13.  * It allows for WordPress to upgrade itself in combination with
  14.  * the wp-admin/includes/update-core.php file.
  15.  *
  16.  * @since 2.8.0
  17.  * @since 4.6.0 Moved to its own file from wp-admin/includes/class-wp-upgrader.php.
  18.  *
  19.  * @see WP_Upgrader
  20.  */
  21. class Core_Upgrader extends WP_Upgrader {
  22.  
  23.     /**
  24.      * Initialize the upgrade strings.
  25.      *
  26.      * @since 2.8.0
  27.      */
  28.     public function upgrade_strings() {
  29.         $this->strings['up_to_date'] = __('WordPress is at the latest version.');
  30.         $this->strings['locked'] = __('Another update is currently in progress.');
  31.         $this->strings['no_package'] = __('Update package not available.');
  32.         /* translators: %s: package URL */
  33.         $this->strings['downloading_package'] = sprintf( __( 'Downloading update from %s…' ), '<span class="code">%s</span>' );
  34.         $this->strings['unpack_package'] = __('Unpacking the update…');
  35.         $this->strings['copy_failed'] = __('Could not copy files.');
  36.         $this->strings['copy_failed_space'] = __('Could not copy files. You may have run out of disk space.' );
  37.         $this->strings['start_rollback'] = __( 'Attempting to roll back to previous version.' );
  38.         $this->strings['rollback_was_required'] = __( 'Due to an error during updating, WordPress has rolled back to your previous version.' );
  39.     }
  40.  
  41.     /**
  42.      * Upgrade WordPress core.
  43.      *
  44.      * @since 2.8.0
  45.      *
  46.      * @global WP_Filesystem_Base $wp_filesystem Subclass
  47.      * @global callable           $_wp_filesystem_direct_method
  48.      *
  49.      * @param object $current Response object for whether WordPress is current.
  50.      * @param array  $args {
  51.      *        Optional. Arguments for upgrading WordPress core. Default empty array.
  52.      *
  53.      *        @type bool $pre_check_md5    Whether to check the file checksums before
  54.      *                                     attempting the upgrade. Default true.
  55.      *        @type bool $attempt_rollback Whether to attempt to rollback the chances if
  56.      *                                     there is a problem. Default false.
  57.      *        @type bool $do_rollback      Whether to perform this "upgrade" as a rollback.
  58.      *                                     Default false.
  59.      * }
  60.      * @return null|false|WP_Error False or WP_Error on failure, null on success.
  61.      */
  62.     public function upgrade( $current, $args = array() ) {
  63.         global $wp_filesystem;
  64.  
  65.         include( ABSPATH . WPINC . '/version.php' ); // $wp_version;
  66.  
  67.         $start_time = time();
  68.  
  69.         $defaults = array(
  70.             'pre_check_md5'    => true,
  71.             'attempt_rollback' => false,
  72.             'do_rollback'      => false,
  73.             'allow_relaxed_file_ownership' => false,
  74.         );
  75.         $parsed_args = wp_parse_args( $args, $defaults );
  76.  
  77.         $this->init();
  78.         $this->upgrade_strings();
  79.  
  80.         // Is an update available?
  81.         if ( !isset( $current->response ) || $current->response == 'latest' )
  82.             return new WP_Error('up_to_date', $this->strings['up_to_date']);
  83.  
  84.         $res = $this->fs_connect( array( ABSPATH, WP_CONTENT_DIR ), $parsed_args['allow_relaxed_file_ownership'] );
  85.         if ( ! $res || is_wp_error( $res ) ) {
  86.             return $res;
  87.         }
  88.  
  89.         $wp_dir = trailingslashit($wp_filesystem->abspath());
  90.  
  91.         $partial = true;
  92.         if ( $parsed_args['do_rollback'] )
  93.             $partial = false;
  94.         elseif ( $parsed_args['pre_check_md5'] && ! $this->check_files() )
  95.             $partial = false;
  96.  
  97.         /*
  98.          * If partial update is returned from the API, use that, unless we're doing
  99.          * a reinstallation. If we cross the new_bundled version number, then use
  100.          * the new_bundled zip. Don't though if the constant is set to skip bundled items.
  101.          * If the API returns a no_content zip, go with it. Finally, default to the full zip.
  102.          */
  103.         if ( $parsed_args['do_rollback'] && $current->packages->rollback )
  104.             $to_download = 'rollback';
  105.         elseif ( $current->packages->partial && 'reinstall' != $current->response && $wp_version == $current->partial_version && $partial )
  106.             $to_download = 'partial';
  107.         elseif ( $current->packages->new_bundled && version_compare( $wp_version, $current->new_bundled, '<' )
  108.             && ( ! defined( 'CORE_UPGRADE_SKIP_NEW_BUNDLED' ) || ! CORE_UPGRADE_SKIP_NEW_BUNDLED ) )
  109.             $to_download = 'new_bundled';
  110.         elseif ( $current->packages->no_content )
  111.             $to_download = 'no_content';
  112.         else
  113.             $to_download = 'full';
  114.  
  115.         // Lock to prevent multiple Core Updates occurring
  116.         $lock = WP_Upgrader::create_lock( 'core_updater', 15 * MINUTE_IN_SECONDS );
  117.         if ( ! $lock ) {
  118.             return new WP_Error( 'locked', $this->strings['locked'] );
  119.         }
  120.  
  121.         $download = $this->download_package( $current->packages->$to_download );
  122.         if ( is_wp_error( $download ) ) {
  123.             WP_Upgrader::release_lock( 'core_updater' );
  124.             return $download;
  125.         }
  126.  
  127.         $working_dir = $this->unpack_package( $download );
  128.         if ( is_wp_error( $working_dir ) ) {
  129.             WP_Upgrader::release_lock( 'core_updater' );
  130.             return $working_dir;
  131.         }
  132.  
  133.         // Copy update-core.php from the new version into place.
  134.         if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
  135.             $wp_filesystem->delete($working_dir, true);
  136.             WP_Upgrader::release_lock( 'core_updater' );
  137.             return new WP_Error( 'copy_failed_for_update_core_file', __( 'The update cannot be installed because we will be unable to copy some files. This is usually due to inconsistent file permissions.' ), 'wp-admin/includes/update-core.php' );
  138.         }
  139.         $wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);
  140.  
  141.         require_once( ABSPATH . 'wp-admin/includes/update-core.php' );
  142.  
  143.         if ( ! function_exists( 'update_core' ) ) {
  144.             WP_Upgrader::release_lock( 'core_updater' );
  145.             return new WP_Error( 'copy_failed_space', $this->strings['copy_failed_space'] );
  146.         }
  147.  
  148.         $result = update_core( $working_dir, $wp_dir );
  149.  
  150.         // In the event of an issue, we may be able to roll back.
  151.         if ( $parsed_args['attempt_rollback'] && $current->packages->rollback && ! $parsed_args['do_rollback'] ) {
  152.             $try_rollback = false;
  153.             if ( is_wp_error( $result ) ) {
  154.                 $error_code = $result->get_error_code();
  155.                 /*
  156.                  * Not all errors are equal. These codes are critical: copy_failed__copy_dir,
  157.                  * mkdir_failed__copy_dir, copy_failed__copy_dir_retry, and disk_full.
  158.                  * do_rollback allows for update_core() to trigger a rollback if needed.
  159.                  */
  160.                 if ( false !== strpos( $error_code, 'do_rollback' ) )
  161.                     $try_rollback = true;
  162.                 elseif ( false !== strpos( $error_code, '__copy_dir' ) )
  163.                     $try_rollback = true;
  164.                 elseif ( 'disk_full' === $error_code )
  165.                     $try_rollback = true;
  166.             }
  167.  
  168.             if ( $try_rollback ) {
  169.                 /** This filter is documented in wp-admin/includes/update-core.php */
  170.                 apply_filters( 'update_feedback', $result );
  171.  
  172.                 /** This filter is documented in wp-admin/includes/update-core.php */
  173.                 apply_filters( 'update_feedback', $this->strings['start_rollback'] );
  174.  
  175.                 $rollback_result = $this->upgrade( $current, array_merge( $parsed_args, array( 'do_rollback' => true ) ) );
  176.  
  177.                 $original_result = $result;
  178.                 $result = new WP_Error( 'rollback_was_required', $this->strings['rollback_was_required'], (object) array( 'update' => $original_result, 'rollback' => $rollback_result ) );
  179.             }
  180.         }
  181.  
  182.         /** This action is documented in wp-admin/includes/class-wp-upgrader.php */
  183.         do_action( 'upgrader_process_complete', $this, array( 'action' => 'update', 'type' => 'core' ) );
  184.  
  185.         // Clear the current updates
  186.         delete_site_transient( 'update_core' );
  187.  
  188.         if ( ! $parsed_args['do_rollback'] ) {
  189.             $stats = array(
  190.                 'update_type'      => $current->response,
  191.                 'success'          => true,
  192.                 'fs_method'        => $wp_filesystem->method,
  193.                 'fs_method_forced' => defined( 'FS_METHOD' ) || has_filter( 'filesystem_method' ),
  194.                 'fs_method_direct' => !empty( $GLOBALS['_wp_filesystem_direct_method'] ) ? $GLOBALS['_wp_filesystem_direct_method'] : '',
  195.                 'time_taken'       => time() - $start_time,
  196.                 'reported'         => $wp_version,
  197.                 'attempted'        => $current->version,
  198.             );
  199.  
  200.             if ( is_wp_error( $result ) ) {
  201.                 $stats['success'] = false;
  202.                 // Did a rollback occur?
  203.                 if ( ! empty( $try_rollback ) ) {
  204.                     $stats['error_code'] = $original_result->get_error_code();
  205.                     $stats['error_data'] = $original_result->get_error_data();
  206.                     // Was the rollback successful? If not, collect its error too.
  207.                     $stats['rollback'] = ! is_wp_error( $rollback_result );
  208.                     if ( is_wp_error( $rollback_result ) ) {
  209.                         $stats['rollback_code'] = $rollback_result->get_error_code();
  210.                         $stats['rollback_data'] = $rollback_result->get_error_data();
  211.                     }
  212.                 } else {
  213.                     $stats['error_code'] = $result->get_error_code();
  214.                     $stats['error_data'] = $result->get_error_data();
  215.                 }
  216.             }
  217.  
  218.             wp_version_check( $stats );
  219.         }
  220.  
  221.         WP_Upgrader::release_lock( 'core_updater' );
  222.  
  223.         return $result;
  224.     }
  225.  
  226.     /**
  227.      * Determines if this WordPress Core version should update to an offered version or not.
  228.      *
  229.      * @since 3.7.0
  230.      *
  231.      * @static
  232.      *
  233.      * @param string $offered_ver The offered version, of the format x.y.z.
  234.      * @return bool True if we should update to the offered version, otherwise false.
  235.      */
  236.     public static function should_update_to_version( $offered_ver ) {
  237.         include( ABSPATH . WPINC . '/version.php' ); // $wp_version; // x.y.z
  238.  
  239.         $current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version  ), 0, 2 ) ); // x.y
  240.         $new_branch     = implode( '.', array_slice( preg_split( '/[.-]/', $offered_ver ), 0, 2 ) ); // x.y
  241.         $current_is_development_version = (bool) strpos( $wp_version, '-' );
  242.  
  243.         // Defaults:
  244.         $upgrade_dev   = true;
  245.         $upgrade_minor = true;
  246.         $upgrade_major = false;
  247.  
  248.         // WP_AUTO_UPDATE_CORE = true (all), 'minor', false.
  249.         if ( defined( 'WP_AUTO_UPDATE_CORE' ) ) {
  250.             if ( false === WP_AUTO_UPDATE_CORE ) {
  251.                 // Defaults to turned off, unless a filter allows it
  252.                 $upgrade_dev = $upgrade_minor = $upgrade_major = false;
  253.             } elseif ( true === WP_AUTO_UPDATE_CORE ) {
  254.                 // ALL updates for core
  255.                 $upgrade_dev = $upgrade_minor = $upgrade_major = true;
  256.             } elseif ( 'minor' === WP_AUTO_UPDATE_CORE ) {
  257.                 // Only minor updates for core
  258.                 $upgrade_dev = $upgrade_major = false;
  259.                 $upgrade_minor = true;
  260.             }
  261.         }
  262.  
  263.         // 1: If we're already on that version, not much point in updating?
  264.         if ( $offered_ver == $wp_version )
  265.             return false;
  266.  
  267.         // 2: If we're running a newer version, that's a nope
  268.         if ( version_compare( $wp_version, $offered_ver, '>' ) )
  269.             return false;
  270.  
  271.         $failure_data = get_site_option( 'auto_core_update_failed' );
  272.         if ( $failure_data ) {
  273.             // If this was a critical update failure, cannot update.
  274.             if ( ! empty( $failure_data['critical'] ) )
  275.                 return false;
  276.  
  277.             // Don't claim we can update on update-core.php if we have a non-critical failure logged.
  278.             if ( $wp_version == $failure_data['current'] && false !== strpos( $offered_ver, '.1.next.minor' ) )
  279.                 return false;
  280.  
  281.             // Cannot update if we're retrying the same A to B update that caused a non-critical failure.
  282.             // Some non-critical failures do allow retries, like download_failed.
  283.             // 3.7.1 => 3.7.2 resulted in files_not_writable, if we are still on 3.7.1 and still trying to update to 3.7.2.
  284.             if ( empty( $failure_data['retry'] ) && $wp_version == $failure_data['current'] && $offered_ver == $failure_data['attempted'] )
  285.                 return false;
  286.         }
  287.  
  288.         // 3: 3.7-alpha-25000 -> 3.7-alpha-25678 -> 3.7-beta1 -> 3.7-beta2
  289.         if ( $current_is_development_version ) {
  290.  
  291.             /**
  292.              * Filters whether to enable automatic core updates for development versions.
  293.              *
  294.              * @since 3.7.0
  295.              *
  296.              * @param bool $upgrade_dev Whether to enable automatic updates for
  297.              *                          development versions.
  298.              */
  299.             if ( ! apply_filters( 'allow_dev_auto_core_updates', $upgrade_dev ) )
  300.                 return false;
  301.             // Else fall through to minor + major branches below.
  302.         }
  303.  
  304.         // 4: Minor In-branch updates (3.7.0 -> 3.7.1 -> 3.7.2 -> 3.7.4)
  305.         if ( $current_branch == $new_branch ) {
  306.  
  307.             /**
  308.              * Filters whether to enable minor automatic core updates.
  309.              *
  310.              * @since 3.7.0
  311.              *
  312.              * @param bool $upgrade_minor Whether to enable minor automatic core updates.
  313.              */
  314.             return apply_filters( 'allow_minor_auto_core_updates', $upgrade_minor );
  315.         }
  316.  
  317.         // 5: Major version updates (3.7.0 -> 3.8.0 -> 3.9.1)
  318.         if ( version_compare( $new_branch, $current_branch, '>' ) ) {
  319.  
  320.             /**
  321.              * Filters whether to enable major automatic core updates.
  322.              *
  323.              * @since 3.7.0
  324.              *
  325.              * @param bool $upgrade_major Whether to enable major automatic core updates.
  326.              */
  327.             return apply_filters( 'allow_major_auto_core_updates', $upgrade_major );
  328.         }
  329.  
  330.         // If we're not sure, we don't want it
  331.         return false;
  332.     }
  333.  
  334.     /**
  335.      * Compare the disk file checksums against the expected checksums.
  336.      *
  337.      * @since 3.7.0
  338.      *
  339.      * @global string $wp_version
  340.      * @global string $wp_local_package
  341.      *
  342.      * @return bool True if the checksums match, otherwise false.
  343.      */
  344.     public function check_files() {
  345.         global $wp_version, $wp_local_package;
  346.  
  347.         $checksums = get_core_checksums( $wp_version, isset( $wp_local_package ) ? $wp_local_package : 'en_US' );
  348.  
  349.         if ( ! is_array( $checksums ) )
  350.             return false;
  351.  
  352.         foreach ( $checksums as $file => $checksum ) {
  353.             // Skip files which get updated
  354.             if ( 'wp-content' == substr( $file, 0, 10 ) )
  355.                 continue;
  356.             if ( ! file_exists( ABSPATH . $file ) || md5_file( ABSPATH . $file ) !== $checksum )
  357.                 return false;
  358.         }
  359.  
  360.         return true;
  361.     }
  362. }
  363.