3 * Upgrade API: Core_Upgrader class
11 * Core class used for updating core.
13 * It allows for WordPress to upgrade itself in combination with
14 * the wp-admin/includes/update-core.php file.
17 * @since 4.6.0 Moved to its own file from wp-admin/includes/class-wp-upgrader.php.
21 class Core_Upgrader extends WP_Upgrader {
24 * Initialize the upgrade strings.
29 public function upgrade_strings() {
30 $this->strings['up_to_date'] = __('WordPress is at the latest version.');
31 $this->strings['locked'] = __('Another update is currently in progress.');
32 $this->strings['no_package'] = __('Update package not available.');
33 $this->strings['downloading_package'] = __('Downloading update from <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.' );
42 * Upgrade WordPress core.
47 * @global WP_Filesystem_Base $wp_filesystem Subclass
48 * @global callable $_wp_filesystem_direct_method
50 * @param object $current Response object for whether WordPress is current.
51 * @param array $args {
52 * Optional. Arguments for upgrading WordPress core. Default empty array.
54 * @type bool $pre_check_md5 Whether to check the file checksums before
55 * attempting the upgrade. Default true.
56 * @type bool $attempt_rollback Whether to attempt to rollback the chances if
57 * there is a problem. Default false.
58 * @type bool $do_rollback Whether to perform this "upgrade" as a rollback.
61 * @return null|false|WP_Error False or WP_Error on failure, null on success.
63 public function upgrade( $current, $args = array() ) {
64 global $wp_filesystem;
66 include( ABSPATH . WPINC . '/version.php' ); // $wp_version;
71 'pre_check_md5' => true,
72 'attempt_rollback' => false,
73 'do_rollback' => false,
74 'allow_relaxed_file_ownership' => false,
76 $parsed_args = wp_parse_args( $args, $defaults );
79 $this->upgrade_strings();
81 // Is an update available?
82 if ( !isset( $current->response ) || $current->response == 'latest' )
83 return new WP_Error('up_to_date', $this->strings['up_to_date']);
85 $res = $this->fs_connect( array( ABSPATH, WP_CONTENT_DIR ), $parsed_args['allow_relaxed_file_ownership'] );
86 if ( ! $res || is_wp_error( $res ) ) {
90 $wp_dir = trailingslashit($wp_filesystem->abspath());
93 if ( $parsed_args['do_rollback'] )
95 elseif ( $parsed_args['pre_check_md5'] && ! $this->check_files() )
99 * If partial update is returned from the API, use that, unless we're doing
100 * a reinstall. If we cross the new_bundled version number, then use
101 * the new_bundled zip. Don't though if the constant is set to skip bundled items.
102 * If the API returns a no_content zip, go with it. Finally, default to the full zip.
104 if ( $parsed_args['do_rollback'] && $current->packages->rollback )
105 $to_download = 'rollback';
106 elseif ( $current->packages->partial && 'reinstall' != $current->response && $wp_version == $current->partial_version && $partial )
107 $to_download = 'partial';
108 elseif ( $current->packages->new_bundled && version_compare( $wp_version, $current->new_bundled, '<' )
109 && ( ! defined( 'CORE_UPGRADE_SKIP_NEW_BUNDLED' ) || ! CORE_UPGRADE_SKIP_NEW_BUNDLED ) )
110 $to_download = 'new_bundled';
111 elseif ( $current->packages->no_content )
112 $to_download = 'no_content';
114 $to_download = 'full';
116 // Lock to prevent multiple Core Updates occurring
117 $lock = WP_Upgrader::create_lock( 'core_updater', 15 * MINUTE_IN_SECONDS );
119 return new WP_Error( 'locked', $this->strings['locked'] );
122 $download = $this->download_package( $current->packages->$to_download );
123 if ( is_wp_error( $download ) ) {
124 WP_Upgrader::release_lock( 'core_updater' );
128 $working_dir = $this->unpack_package( $download );
129 if ( is_wp_error( $working_dir ) ) {
130 WP_Upgrader::release_lock( 'core_updater' );
134 // Copy update-core.php from the new version into place.
135 if ( !$wp_filesystem->copy($working_dir . '/wordpress/wp-admin/includes/update-core.php', $wp_dir . 'wp-admin/includes/update-core.php', true) ) {
136 $wp_filesystem->delete($working_dir, true);
137 WP_Upgrader::release_lock( 'core_updater' );
138 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' );
140 $wp_filesystem->chmod($wp_dir . 'wp-admin/includes/update-core.php', FS_CHMOD_FILE);
142 require_once( ABSPATH . 'wp-admin/includes/update-core.php' );
144 if ( ! function_exists( 'update_core' ) ) {
145 WP_Upgrader::release_lock( 'core_updater' );
146 return new WP_Error( 'copy_failed_space', $this->strings['copy_failed_space'] );
149 $result = update_core( $working_dir, $wp_dir );
151 // In the event of an issue, we may be able to roll back.
152 if ( $parsed_args['attempt_rollback'] && $current->packages->rollback && ! $parsed_args['do_rollback'] ) {
153 $try_rollback = false;
154 if ( is_wp_error( $result ) ) {
155 $error_code = $result->get_error_code();
157 * Not all errors are equal. These codes are critical: copy_failed__copy_dir,
158 * mkdir_failed__copy_dir, copy_failed__copy_dir_retry, and disk_full.
159 * do_rollback allows for update_core() to trigger a rollback if needed.
161 if ( false !== strpos( $error_code, 'do_rollback' ) )
162 $try_rollback = true;
163 elseif ( false !== strpos( $error_code, '__copy_dir' ) )
164 $try_rollback = true;
165 elseif ( 'disk_full' === $error_code )
166 $try_rollback = true;
169 if ( $try_rollback ) {
170 /** This filter is documented in wp-admin/includes/update-core.php */
171 apply_filters( 'update_feedback', $result );
173 /** This filter is documented in wp-admin/includes/update-core.php */
174 apply_filters( 'update_feedback', $this->strings['start_rollback'] );
176 $rollback_result = $this->upgrade( $current, array_merge( $parsed_args, array( 'do_rollback' => true ) ) );
178 $original_result = $result;
179 $result = new WP_Error( 'rollback_was_required', $this->strings['rollback_was_required'], (object) array( 'update' => $original_result, 'rollback' => $rollback_result ) );
183 /** This action is documented in wp-admin/includes/class-wp-upgrader.php */
184 do_action( 'upgrader_process_complete', $this, array( 'action' => 'update', 'type' => 'core' ) );
186 // Clear the current updates
187 delete_site_transient( 'update_core' );
189 if ( ! $parsed_args['do_rollback'] ) {
191 'update_type' => $current->response,
193 'fs_method' => $wp_filesystem->method,
194 'fs_method_forced' => defined( 'FS_METHOD' ) || has_filter( 'filesystem_method' ),
195 'fs_method_direct' => !empty( $GLOBALS['_wp_filesystem_direct_method'] ) ? $GLOBALS['_wp_filesystem_direct_method'] : '',
196 'time_taken' => time() - $start_time,
197 'reported' => $wp_version,
198 'attempted' => $current->version,
201 if ( is_wp_error( $result ) ) {
202 $stats['success'] = false;
203 // Did a rollback occur?
204 if ( ! empty( $try_rollback ) ) {
205 $stats['error_code'] = $original_result->get_error_code();
206 $stats['error_data'] = $original_result->get_error_data();
207 // Was the rollback successful? If not, collect its error too.
208 $stats['rollback'] = ! is_wp_error( $rollback_result );
209 if ( is_wp_error( $rollback_result ) ) {
210 $stats['rollback_code'] = $rollback_result->get_error_code();
211 $stats['rollback_data'] = $rollback_result->get_error_data();
214 $stats['error_code'] = $result->get_error_code();
215 $stats['error_data'] = $result->get_error_data();
219 wp_version_check( $stats );
222 WP_Upgrader::release_lock( 'core_updater' );
228 * Determines if this WordPress Core version should update to an offered version or not.
235 * @param string $offered_ver The offered version, of the format x.y.z.
236 * @return bool True if we should update to the offered version, otherwise false.
238 public static function should_update_to_version( $offered_ver ) {
239 include( ABSPATH . WPINC . '/version.php' ); // $wp_version; // x.y.z
241 $current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version ), 0, 2 ) ); // x.y
242 $new_branch = implode( '.', array_slice( preg_split( '/[.-]/', $offered_ver ), 0, 2 ) ); // x.y
243 $current_is_development_version = (bool) strpos( $wp_version, '-' );
247 $upgrade_minor = true;
248 $upgrade_major = false;
250 // WP_AUTO_UPDATE_CORE = true (all), 'minor', false.
251 if ( defined( 'WP_AUTO_UPDATE_CORE' ) ) {
252 if ( false === WP_AUTO_UPDATE_CORE ) {
253 // Defaults to turned off, unless a filter allows it
254 $upgrade_dev = $upgrade_minor = $upgrade_major = false;
255 } elseif ( true === WP_AUTO_UPDATE_CORE ) {
256 // ALL updates for core
257 $upgrade_dev = $upgrade_minor = $upgrade_major = true;
258 } elseif ( 'minor' === WP_AUTO_UPDATE_CORE ) {
259 // Only minor updates for core
260 $upgrade_dev = $upgrade_major = false;
261 $upgrade_minor = true;
265 // 1: If we're already on that version, not much point in updating?
266 if ( $offered_ver == $wp_version )
269 // 2: If we're running a newer version, that's a nope
270 if ( version_compare( $wp_version, $offered_ver, '>' ) )
273 $failure_data = get_site_option( 'auto_core_update_failed' );
274 if ( $failure_data ) {
275 // If this was a critical update failure, cannot update.
276 if ( ! empty( $failure_data['critical'] ) )
279 // Don't claim we can update on update-core.php if we have a non-critical failure logged.
280 if ( $wp_version == $failure_data['current'] && false !== strpos( $offered_ver, '.1.next.minor' ) )
283 // Cannot update if we're retrying the same A to B update that caused a non-critical failure.
284 // Some non-critical failures do allow retries, like download_failed.
285 // 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.
286 if ( empty( $failure_data['retry'] ) && $wp_version == $failure_data['current'] && $offered_ver == $failure_data['attempted'] )
290 // 3: 3.7-alpha-25000 -> 3.7-alpha-25678 -> 3.7-beta1 -> 3.7-beta2
291 if ( $current_is_development_version ) {
294 * Filters whether to enable automatic core updates for development versions.
298 * @param bool $upgrade_dev Whether to enable automatic updates for
299 * development versions.
301 if ( ! apply_filters( 'allow_dev_auto_core_updates', $upgrade_dev ) )
303 // Else fall through to minor + major branches below.
306 // 4: Minor In-branch updates (3.7.0 -> 3.7.1 -> 3.7.2 -> 3.7.4)
307 if ( $current_branch == $new_branch ) {
310 * Filters whether to enable minor automatic core updates.
314 * @param bool $upgrade_minor Whether to enable minor automatic core updates.
316 return apply_filters( 'allow_minor_auto_core_updates', $upgrade_minor );
319 // 5: Major version updates (3.7.0 -> 3.8.0 -> 3.9.1)
320 if ( version_compare( $new_branch, $current_branch, '>' ) ) {
323 * Filters whether to enable major automatic core updates.
327 * @param bool $upgrade_major Whether to enable major automatic core updates.
329 return apply_filters( 'allow_major_auto_core_updates', $upgrade_major );
332 // If we're not sure, we don't want it
337 * Compare the disk file checksums against the expected checksums.
342 * @global string $wp_version
343 * @global string $wp_local_package
345 * @return bool True if the checksums match, otherwise false.
347 public function check_files() {
348 global $wp_version, $wp_local_package;
350 $checksums = get_core_checksums( $wp_version, isset( $wp_local_package ) ? $wp_local_package : 'en_US' );
352 if ( ! is_array( $checksums ) )
355 foreach ( $checksums as $file => $checksum ) {
356 // Skip files which get updated
357 if ( 'wp-content' == substr( $file, 0, 10 ) )
359 if ( ! file_exists( ABSPATH . $file ) || md5_file( ABSPATH . $file ) !== $checksum )