Ticket #34878: 34878.diff

src/wp-admin/includes/class-wp-upgrader.php

@@ -2156 +2156 @@
  *
  * @since 2.8.0
  *
  * @see WP_Upgrader
  */
 class Core_Upgrader extends WP_Upgrader {
 
         /**
          * Initialize the upgrade strings.
          *
          * @since 2.8.0
          * @access public
          */
         public function upgrade_strings() {
                 $this->strings['up_to_date'] = __('WordPress is at the latest version.');
+                $this->strings['locked'] = __('Another update is currently in progress.');
                 $this->strings['no_package'] = __('Update package not available.');
                 $this->strings['downloading_package'] = __('Downloading update from <span class="code">%s</span>&#8230;');
                 $this->strings['unpack_package'] = __('Unpacking the update&#8230;');
                 $this->strings['copy_failed'] = __('Could not copy files.');
                 $this->strings['copy_failed_space'] = __('Could not copy files. You may have run out of disk space.' );
                 $this->strings['start_rollback'] = __( 'Attempting to roll back to previous version.' );
                 $this->strings['rollback_was_required'] = __( 'Due to an error during updating, WordPress has rolled back to your previous version.' );
         }
 
         /**
          * Upgrade WordPress core.
          *
          * @since 2.8.0
          * @access public
          *
@@ -2240 +2241 @@
                  * the new_bundled zip. Don't though if the constant is set to skip bundled items.
                  * If the API returns a no_content zip, go with it. Finally, default to the full zip.
                  */
                 if ( $parsed_args['do_rollback'] && $current->packages->rollback )
                         $to_download = 'rollback';
                 elseif ( $current->packages->partial && 'reinstall' != $current->response && $wp_version == $current->partial_version && $partial )
                         $to_download = 'partial';
                 elseif ( $current->packages->new_bundled && version_compare( $wp_version, $current->new_bundled, '<' )
                         && ( ! defined( 'CORE_UPGRADE_SKIP_NEW_BUNDLED' ) || ! CORE_UPGRADE_SKIP_NEW_BUNDLED ) )
                         $to_download = 'new_bundled';
                 elseif ( $current->packages->no_content )
                         $to_download = 'no_content';
                 else
                         $to_download = 'full';
 
+                // Lock to prevent multiple Core Updates occuring
+                $lock = wp_create_lock( 'core_updater', 15 * MINUTE_IN_SECONDS );
+                if ( ! $lock ) {
+                        return new WP_Error( 'locked', $this->strings['locked'] );
+                }
+
                 $download = $this->download_package( $current->packages->$to_download );
-                if ( is_wp_error($download) )
+                if ( is_wp_error( $download ) ) {
+                        wp_release_lock( 'core_updater' );
                         return $download;
+                }
 
                 $working_dir = $this->unpack_package( $download );
-                if ( is_wp_error($working_dir) )
+                if ( is_wp_error( $working_dir ) ) {
+                        wp_release_lock( 'core_updater' );
                         return $working_dir;
+                }
 
                 // Copy update-core.php from the new version into place.
                 if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
                         $wp_filesystem->delete($working_dir, true);
+                        wp_release_lock( 'core_updater' );
                         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' );
                 }
                 $wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);
 
                 require_once( ABSPATH . 'wp-admin/includes/update-core.php' );
 
-                if ( ! function_exists( 'update_core' ) )
+                if ( ! function_exists( 'update_core' ) ) {
+                        wp_release_lock( 'core_updater' );
                         return new WP_Error( 'copy_failed_space', $this->strings['copy_failed_space'] );
+                }
 
                 $result = update_core( $working_dir, $wp_dir );
 
                 // In the event of an issue, we may be able to roll back.
                 if ( $parsed_args['attempt_rollback'] && $current->packages->rollback && ! $parsed_args['do_rollback'] ) {
                         $try_rollback = false;
                         if ( is_wp_error( $result ) ) {
                                 $error_code = $result->get_error_code();
                                 /*
                                  * Not all errors are equal. These codes are critical: copy_failed__copy_dir,
                                  * mkdir_failed__copy_dir, copy_failed__copy_dir_retry, and disk_full.
                                  * do_rollback allows for update_core() to trigger a rollback if needed.
                                  */
                                 if ( false !== strpos( $error_code, 'do_rollback' ) )
                                         $try_rollback = true;
@@ -2333 +2347 @@
                                         // Was the rollback successful? If not, collect its error too.
                                         $stats['rollback'] = ! is_wp_error( $rollback_result );
                                         if ( is_wp_error( $rollback_result ) ) {
                                                 $stats['rollback_code'] = $rollback_result->get_error_code();
                                                 $stats['rollback_data'] = $rollback_result->get_error_data();
                                         }
                                 } else {
                                         $stats['error_code'] = $result->get_error_code();
                                         $stats['error_data'] = $result->get_error_data();
                                 }
                         }
 
                         wp_version_check( $stats );
                 }
 
+                wp_release_lock( 'core_updater' );
+
                 return $result;
         }
 
         /**
          * Determines if this WordPress Core version should update to an offered version or not.
          *
          * @since 3.7.0
          * @access public
          *
          * @static
          *
          * @param string $offered_ver The offered version, of the format x.y.z.
          * @return bool True if we should update to the offered version, otherwise false.
          */
         public static function should_update_to_version( $offered_ver ) {
@@ -2926 +2942 @@
                 $upgrade_result = $upgrader->upgrade( $upgrader_item, array(
                         'clear_update_cache' => false,
                         // Always use partial builds if possible for core updates.
                         'pre_check_md5'      => false,
                         // Only available for core updates.
                         'attempt_rollback'   => true,
                         // Allow relaxed file ownership in some scenarios
                         'allow_relaxed_file_ownership' => $allow_relaxed_file_ownership,
                 ) );
 
                 // If the filesystem is unavailable, false is returned.
                 if ( false === $upgrade_result ) {
                         $upgrade_result = new WP_Error( 'fs_unavailable', __( 'Could not access filesystem.' ) );
                 }
 
-                // Core doesn't output this, so let's append it so we don't get confused.
                 if ( 'core' == $type ) {
+                        if ( is_wp_error( $upgrade_result ) && ( 'up_to_date' == $upgrade_result->get_error_code() || 'locked' == $upgrade_result->get_error_code() ) ) {
+                                // These aren't actual errors, treat it as a skipped-update instead to avoid triggering the post-core update failure routines.
+                                return false;
+                        }
+
+                        // Core doesn't output this, so let's append it so we don't get confused.
                         if ( is_wp_error( $upgrade_result ) ) {
                                 $skin->error( __( 'Installation Failed' ), $upgrade_result );
                         } else {
                                 $skin->feedback( __( 'WordPress updated successfully' ) );
                         }
                 }
 
                 $this->update_results[ $type ][] = (object) array(
                         'item'     => $item,
                         'result'   => $upgrade_result,
                         'name'     => $item_name,
                         'messages' => $skin->get_upgrade_messages()
                 );
 
                 return $upgrade_result;
@@ -2963 +2984 @@
          * @since 3.7.0
          * @access public
          *
          * @global wpdb   $wpdb
          * @global string $wp_version
          */
         public function run() {
                 global $wpdb, $wp_version;
 
                 if ( $this->is_disabled() )
                         return;
 
                 if ( ! is_main_network() || ! is_main_site() )
                         return;
 
-                $lock_name = 'auto_updater.lock';
-
-                // Try to lock
-                $lock_result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` ( `option_name`, `option_value`, `autoload` ) VALUES (%s, %s, 'no') /* LOCK */", $lock_name, time() ) );
-
-                if ( ! $lock_result ) {
-                        $lock_result = get_option( $lock_name );
-
-                        // If we couldn't create a lock, and there isn't a lock, bail
-                        if ( ! $lock_result )
-                                return;
-
-                        // Check to see if the lock is still valid
-                        if ( $lock_result > ( time() - HOUR_IN_SECONDS ) )
-                                return;
-                }
-
-                // Update the lock, as by this point we've definitely got a lock, just need to fire the actions
-                update_option( $lock_name, time() );
+                if ( ! wp_create_lock( 'auto_updater' ) )
+                        return;
 
                 // Don't automatically run these thins, as we'll handle it ourselves
                 remove_action( 'upgrader_process_complete', array( 'Language_Pack_Upgrader', 'async_upgrade' ), 20 );
                 remove_action( 'upgrader_process_complete', 'wp_version_check' );
                 remove_action( 'upgrader_process_complete', 'wp_update_plugins' );
                 remove_action( 'upgrader_process_complete', 'wp_update_themes' );
 
                 // Next, Plugins
                 wp_update_plugins(); // Check for Plugin updates
                 $plugin_updates = get_site_transient( 'update_plugins' );
                 if ( $plugin_updates && !empty( $plugin_updates->response ) ) {
                         foreach ( $plugin_updates->response as $plugin ) {
                                 $this->update( 'plugin', $plugin );
                         }
                         // Force refresh of plugin update information
@@ -3080 +3084 @@
                                 $this->send_debug_email();
 
                         if ( ! empty( $this->update_results['core'] ) )
                                 $this->after_core_update( $this->update_results['core'][0] );
 
                         /**
                          * Fires after all automatic updates have run.
                          *
                          * @since 3.8.0
                          *
                          * @param array $update_results The results of all attempted updates.
                          */
                         do_action( 'automatic_updates_complete', $this->update_results );
                 }
 
-                // Clear the lock
-                delete_option( $lock_name );
+                wp_release_lock( 'core_updater' );
         }
 
         /**
          * If we tried to perform a core update, check if we should send an email,
          * and if we need to avoid processing future updates.
          *
          * @since Unknown
          * @access protected
          *
          * @global string $wp_version
          *
          * @param object|WP_Error $update_result The result of the core update. Includes the update offer and result.
          */
         protected function after_core_update( $update_result ) {
                 global $wp_version;
@@ -3151 +3154 @@
                         return;
                 }
 
                 /*
                  * Any other WP_Error code (like download_failed or files_not_writable) occurs before
                  * we tried to copy over core files. Thus, the failures are early and graceful.
                  *
                  * We should avoid trying to perform a background update again for the same version.
                  * But we can try again if another version is released.
                  *
                  * For certain 'transient' failures, like download_failed, we should allow retries.
                  * In fact, let's schedule a special update for an hour from now. (It's possible
                  * the issue could actually be on WordPress.org's side.) If that one fails, then email.
                  */
                 $send = true;
-                $transient_failures = array( 'incompatible_archive', 'download_failed', 'insane_distro' );
+                $transient_failures = array( 'incompatible_archive', 'download_failed', 'insane_distro', 'locked' );
                 if ( in_array( $error_code, $transient_failures ) && ! get_site_option( 'auto_core_update_failed' ) ) {
                         wp_schedule_single_event( time() + HOUR_IN_SECONDS, 'wp_maybe_auto_update' );
                         $send = false;
                 }
 
                 $n = get_site_option( 'auto_core_update_notified' );
                 // Don't notify if we've already notified the same email address of the same version of the same notification type.
                 if ( $n && 'fail' == $n['type'] && $n['email'] == get_site_option( 'admin_email' ) && $n['version'] == $core_update->current )
                         $send = false;
 
                 update_site_option( 'auto_core_update_failed', array(
                         'attempted'  => $core_update->current,
                         'current'    => $wp_version,
                         'error_code' => $error_code,
                         'error_data' => $result->get_error_data(),

src/wp-admin/update-core.php

@@ -472 +472 @@
                 return;
         }
 
         if ( $reinstall )
                 $update->response = 'reinstall';
 
         add_filter( 'update_feedback', 'show_message' );
 
         $upgrader = new Core_Upgrader();
         $result = $upgrader->upgrade( $update, array(
                 'allow_relaxed_file_ownership' => $allow_relaxed_file_ownership
         ) );
 
         if ( is_wp_error($result) ) {
                 show_message($result);
-                if ('up_to_date' != $result->get_error_code() )
+                if ( 'up_to_date' != $result->get_error_code() && 'locked' != $result->get_error_code() )
                         show_message( __('Installation Failed') );
                 echo '</div>';
                 return;
         }
 
         show_message( __('WordPress updated successfully') );
         show_message( '<span class="hide-if-no-js">' . sprintf( __( 'Welcome to WordPress %1$s. You will be redirected to the About WordPress screen. If not, click <a href="%2$s">here</a>.' ), $result, esc_url( self_admin_url( 'about.php?updated' ) ) ) . '</span>' );
         show_message( '<span class="hide-if-js">' . sprintf( __( 'Welcome to WordPress %1$s. <a href="%2$s">Learn more</a>.' ), $result, esc_url( self_admin_url( 'about.php?updated' ) ) ) . '</span>' );
         ?>
         </div>
         <script type="text/javascript">
         window.location = '<?php echo self_admin_url( 'about.php?updated' ); ?>';
         </script>
         <?php
 }

src/wp-includes/option.php

@@ -1667 +1667 @@
                 do_action( 'set_site_transient_' . $transient, $value, $expiration, $transient );
 
                 /**
                  * Fires after the value for a site transient has been set.
                  *
                  * @since 3.0.0
                  *
                  * @param string $transient  The name of the site transient.
                  * @param mixed  $value      Site transient value.
                  * @param int    $expiration Time until expiration in seconds.
                  */
                 do_action( 'setted_site_transient', $transient, $value, $expiration );
         }
         return $result;
 }
+
+/**
+ * Create a Lock using WordPress options.
+ *
+ * @since 4.5.0
+ * @param $lock_name       string The name of this unique lock.
+ * @param $release_timeout int    The duration in seconds to respect an existing lock. Default: 1 hour.
+ * @return bool
+ */
+function wp_create_lock( $lock_name, $release_timeout = null ) {
+        global $wpdb;
+        if ( ! $release_timeout ) {
+                $release_timeout = HOUR_IN_SECONDS;
+        }
+        /**
+         * Filter doc TODO
+         */
+        if ( null !== ( $result = apply_filters( 'create_lock', null, $lock_name, $release_timeout ) ) ) {
+                return $reslt;
+        }
+
+        $lock_option = $lock_name . '.lock';
+
+        // Try to lock
+        $lock_result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` ( `option_name`, `option_value`, `autoload` ) VALUES (%s, %s, 'no') /* LOCK */", $lock_option, time() ) );
+
+        if ( ! $lock_result ) {
+                $lock_result = get_option( $lock_option );
+        
+                // If we couldn't create a lock, and there isn't a lock, bail
+                if ( ! $lock_result ) {
+                        return false;
+                }
+        
+                // Check to see if the lock is still valid
+                if ( $lock_result > ( time() - $release_timeout ) ) {
+                        return false;
+                }
+
+                // There must exist an expired lock, clear it and re-gain it.
+                wp_release_lock( $lock_name );
+
+                return wp_create_lock( $lock_name, $release_timeout );
+        }
+
+        // Update the lock, as by this point we've definitely got a lock, just need to fire the actions
+        update_option( $lock_option, time() );
+
+        return true;
+}
+
+/**
+ * Release a lock created by `wp_create_lock()`
+ *
+ * @since 4.5.0
+ * @param $lock_name string The name of this unique lock.
+ * @return bool
+ */
+function wp_release_lock( $lock_name ) {
+        /**
+         * Filter doc TODO
+         */
+        if ( null !== ( $result = apply_filters( 'release_lock', null, $lock_name ) ) ) {
+                return $reslt;
+        }
+        $lock_option = $lock_name . '.lock';
+        return delete_option( $lock_option );
+}
+ No newline at end of file