WordPress.org

Make WordPress Core

Ticket #22704: 22704.2.diff

File 22704.2.diff, 13.0 KB (added by dd32, 5 years ago)
  • src/wp-includes/update.php

     
    121121        $updates->last_checked = time();
    122122        $updates->version_checked = $wp_version;
    123123        set_site_transient( 'update_core',  $updates);
     124
     125        wp_auto_updates_maybe_queue( 'core' );
    124126}
    125127
    126128/**
     
    218220                $new_option->response = array();
    219221
    220222        set_site_transient( 'update_plugins', $new_option );
     223
     224        wp_auto_updates_maybe_queue( 'plugins' );
    221225}
    222226
    223227/**
     
    324328                $new_update->response = $response;
    325329
    326330        set_site_transient( 'update_themes', $new_update );
     331
     332        wp_auto_updates_maybe_queue( 'themes' );
    327333}
    328334
     335/**
     336 * Queues a cron entry if a potentially upgrade is detected.
     337 *
     338 * @since 3.7.0
     339 *
     340 * @param string $type The type of update to check for, may be 'core', 'plugins', or, 'themes'.
     341 */
     342function wp_auto_updates_maybe_queue( $type = 'core' ) {
     343        include_once ABSPATH . '/wp-admin/includes/class-wp-upgrader.php';
     344        include_once ABSPATH . '/wp-admin/includes/update.php';
     345
     346        if ( WP_Automatic_Upgrader::upgrader_disabled() )
     347                return;
     348
     349        $updates_available = false;
     350        if ( 'core' == $type ) {
     351                $updates_available = (bool) find_core_auto_update();
     352        } elseif ( 'plugins' == $type ) {
     353                $plugin_updates = get_site_transient( 'update_plugins' );
     354                $updates_available = !empty( $plugin_updates->response );
     355        } elseif ( 'themes' == $type ) {
     356                $theme_updates = get_site_transient( 'update_themes' );
     357                $updates_available = empty( $theme_updates->response );
     358        }
     359
     360        if ( $updates_available && ! wp_next_scheduled( 'wp_auto_updates_execute' ) ) {
     361                // If the transient update was triggered by a user pageview, update in an hours time, else, now.
     362                $when_to_update = get_current_user_id() ? time() + HOUR_IN_SECONDS : time();
     363                $when_to_update = apply_filters( 'auto_upgrade_when_to_upgrade', $when_to_update );
     364
     365                wp_schedule_single_event( $when_to_update, 'wp_auto_updates_execute' );
     366        }
     367
     368}
     369
     370function wp_auto_updates_execute() {
     371        include_once ABSPATH . '/wp-admin/includes/admin.php';
     372        include_once ABSPATH . '/wp-admin/includes/class-wp-upgrader.php';
     373
     374        if ( WP_Automatic_Upgrader::upgrader_disabled() )
     375                return;
     376
     377        WP_Automatic_Upgrader::perform_auto_updates();
     378}
     379
    329380/*
    330381 * Collect counts and UI strings for available updates
    331382 *
     
    449500add_action( 'admin_init', '_maybe_update_themes' );
    450501add_action( 'wp_update_themes', 'wp_update_themes' );
    451502
     503// Automatic Updates - Cron callback
     504add_action( 'wp_auto_updates_execute', 'wp_auto_updates_execute' );
     505
    452506add_action('init', 'wp_schedule_update_checks');
  • src/wp-admin/includes/class-wp-upgrader.php

     
    11291129                return $result;
    11301130        }
    11311131
     1132        // Determines if this WordPress Core version should update to $offered_ver or not
     1133        // NOTE: Core_Upgrader class here, Not totally sure this should be moved here
     1134        static function should_upgrade_to_version( $offered_ver /* x.y.z */ ) {
     1135                include ABSPATH . WPINC . '/version.php'; // $wp_version; // x.y.z
     1136
     1137                $current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version  ), 0, 2 ) ); // x.y
     1138                $new_branch     = implode( '.', array_slice( preg_split( '/[.-]/', $offered_ver ), 0, 2 ) ); // x.y
     1139                $current_is_development_version = (bool) strpos( $wp_version, '-' );
     1140
     1141                // Defaults:
     1142                $upgrade_dev   = false;
     1143                $upgrade_minor = false; // @TODO: Update for release by toggling to true.
     1144                $upgrade_major = false;
     1145
     1146                // WP_AUTO_UPDATE_CORE = true (all), 'minor', false.
     1147                if ( defined( 'WP_AUTO_UPDATE_CORE' ) ) {
     1148                        if ( false === WP_AUTO_UPDATE_CORE ) {
     1149                                // Defaults to turned off, unless a filter allows it
     1150                                $upgrade_dev = $upgrade_minor = $upgrade_major = false;
     1151                        } elseif ( true === WP_AUTO_UPDATE_CORE ) {
     1152                                // ALL updates for core
     1153                                $upgrade_dev = $upgrade_minor = $upgrade_major = true;
     1154                        } elseif ( 'minor' === WP_AUTO_UPDATE_CORE ) {
     1155                                // Only minor updates for core
     1156                                $upgrade_dev = $upgrade_major = false;
     1157                                $upgrade_minor = true;
     1158                        }
     1159                }
     1160
     1161                // 1: If we're already on that version, not much point in updating?
     1162                if ( $offered_ver == $wp_version )
     1163                        return false;
     1164
     1165                // 2: If we're running a newer version, that's a nope
     1166                if ( version_compare( $wp_version, $offered_ver, '>=' ) )
     1167                        return false;
     1168
     1169                // 3: 3.7-alpha-25000 -> 3.7-alpha-25678 -> 3.7-beta1 -> 3.7-beta2
     1170                if ( $current_is_development_version ) {
     1171                        if ( ! apply_filters( 'allow_dev_background_core_updates', $upgrade_dev ) )
     1172                                return false;
     1173                        // else fall through to minor + major branches below
     1174                }
     1175
     1176                // 4: Minor In-branch updates (3.7.0 -> 3.7.1 -> 3.7.2 -> 3.7.4)
     1177                if ( $current_branch == $new_branch )
     1178                        return apply_filters( 'allow_minor_background_core_updates', $upgrade_minor );
     1179
     1180                // 5: Major version updates (3.7.0 -> 3.8.0 -> 3.9.1)
     1181                if ( version_compare( $new_branch, $current_branch, '>' ) )
     1182                        return apply_filters( 'allow_major_background_core_updates', $upgrade_major );
     1183
     1184                // If we're not sure, we don't want it
     1185                return false;
     1186        }
     1187
    11321188}
    11331189
    11341190/**
     
    12041260                return true;
    12051261        }
    12061262}
     1263
     1264/**
     1265 * WordPress Automatic Upgrader helper class
     1266 *
     1267 * @since 3.7.0
     1268 */
     1269class WP_Automatic_Upgrader {
     1270
     1271        static $skin;
     1272
     1273        static function upgrader_disabled() {
     1274                // That's a no if you don't want files changes
     1275                if ( defined( 'DISABLE_FILE_MODS' ) && DISABLE_FILE_MODS )
     1276                        return true;
     1277
     1278                // More fine grained control can be done through the WP_AUTO_UPDATE_CORE constant and filters
     1279                if ( defined( 'AUTOMATIC_UPDATER_DISABLED' ) && AUTOMATIC_UPDATER_DISABLED )
     1280                        return true;
     1281
     1282                if ( defined( 'WP_INSTALLING' ) )
     1283                        return true;
     1284
     1285                return apply_filters( 'auto_upgrader_disabled', false );
     1286        }
     1287
     1288        /**
     1289         * Tests to see if we should upgrade a specific item, does not test to see if we CAN update the item.
     1290         */
     1291        static function should_update( $type, $item, $context ) {
     1292
     1293                if ( self::upgrader_disabled() )
     1294                        return false;
     1295
     1296                // ..and also check for GIT/SVN checkouts
     1297                if ( ! apply_filters( 'auto_upgrade_ignore_checkout_status', false ) ) {
     1298                        $stop_dirs = array(
     1299                                ABSPATH,
     1300                                untrailingslashit( $context ),
     1301                        );
     1302                        if ( ! file_exists( ABSPATH . '/wp-config.php' ) ) // wp-config.php up one folder in a deployment situation
     1303                                $stop_dirs[] = dirname( ABSPATH );
     1304                        foreach ( array_unique( $stop_dirs ) as $dir ) {
     1305                                if ( file_exists( $dir . '/.svn' ) || file_exists( $dir . '/.git' ) )
     1306                                        return false;
     1307                        }
     1308                }
     1309
     1310                // Next up, do we actually have it enabled for this type of update?
     1311                switch ( $type ) {
     1312                        case 'core':
     1313                                $upgrade = Core_Upgrader::should_upgrade_to_version( $item->current );
     1314                                break;
     1315                        default:
     1316                        case 'plugin':
     1317                        case 'theme':
     1318                                $upgrade = false;
     1319                                break;
     1320                }
     1321
     1322                // And does the user / plugins want it?
     1323                // Plugins may filter on 'auto_upgrade_plugin', and check the 2nd param, $item, to only enable it for certain Plugins/Themes
     1324                if ( ! apply_filters( 'auto_upgrade_' . $type, $upgrade, $item ) )
     1325                        return false;
     1326
     1327                // If it's a core update, are we actually compatible with it's requirements?
     1328                if ( 'core' == $type ) {
     1329                        global $wpdb;
     1330
     1331                        $php_compat = version_compare( phpversion(), $item->php_version, '>=' );
     1332                        if ( file_exists( WP_CONTENT_DIR . '/db.php' ) && empty( $wpdb->is_mysql ) )
     1333                                $mysql_compat = true;
     1334                        else
     1335                                $mysql_compat = version_compare( $wpdb->db_version(), $item->mysql_version, '>=' );
     1336
     1337                        if ( ! $php_compat || ! $mysql_compat )
     1338                                return false;
     1339                }
     1340
     1341                return true;
     1342        }
     1343
     1344        // Checks to see if WP_Filesystem is setup to allow unattended upgrades
     1345        static function can_auto_update( $context ) {
     1346                if ( ! self::$skin )
     1347                        self::$skin = new WP_Background_Upgrader_Skin();
     1348                return (bool) self::$skin->request_filesystem_credentials();
     1349        }
     1350
     1351        static function upgrade( $type, $item ) {
     1352
     1353                wp_mail(
     1354                        get_site_option( 'admin_email' ),
     1355                        __METHOD__,
     1356                        "Starting an upgrade for:\n\n" . var_export( compact( 'type', 'item' ), true ) . "\n\n" . wp_debug_backtrace_summary()
     1357                );
     1358
     1359                self::$skin = new Background_Upgrader_Skin();
     1360
     1361                switch ( $type ) {
     1362                        case 'core':
     1363                                // Okay, Why does the Core upgrader not use the Upgrader's skin during the actual main part of the upgrade???
     1364                                add_filter( 'update_feedback', function( $message ) {
     1365                                        WP_Background_Upgrader::$skin->feedback( $message );
     1366                                } );
     1367                                $upgrader = new Core_Upgrader( self::$skin );
     1368                                $context  = ABSPATH;
     1369                                break;
     1370                        case 'plugin':
     1371                                $upgrader = new Plugin_Upgrader( self::$skin );
     1372                                $context  = WP_PLUGIN_DIR; // We don't support custom Plugin directories, or updates for WPMU_PLUGIN_DIR
     1373                                break;
     1374                        case 'theme':
     1375                                $upgrader = new Theme_Upgrader( self::$skin );
     1376                                $context  = get_theme_root( $item );
     1377                                break;
     1378                }
     1379
     1380                // Determine if we can perform this upgrade or not
     1381                if ( ! self::should_auto_update( $type, $item, $context )  || ! self::can_auto_update( $context ) )
     1382                        return false;
     1383
     1384                // Boom, This sites about to get a whole new splash of paint!
     1385                $upgrade_result = $upgrader->upgrade( $item, array(
     1386                        'clear_update_cache' => false,
     1387                ) );
     1388
     1389                // Core doesn't output this, so lets append it so we don't get confused
     1390                if ( 'core' == $type ) {
     1391                        if ( is_wp_error( $upgrade_result ) ) {
     1392                                self::$skin->error( __( 'Installation Failed' ), $upgrade_result );
     1393                        } else {
     1394                                self::$skin->feedback( __( 'WordPress updated successfully' ) );
     1395                        }
     1396                }
     1397
     1398                // Clear cache's and transients
     1399                switch ( $type ) {
     1400                        case 'core':
     1401                                delete_site_transient( 'update_core' );
     1402                                break;
     1403                        case 'theme':
     1404                                wp_clean_themes_cache();
     1405                                break;
     1406                        case 'plugin':
     1407                                wp_clean_plugins_cache();
     1408                                break;
     1409                }
     1410
     1411                var_dump( compact( 'type', 'item', 'upgrader', 'upgrade_result' ) );
     1412
     1413                wp_mail(
     1414                        get_site_option( 'admin_email' ),
     1415                        __METHOD__,
     1416                        var_export( array(
     1417                                $upgrade_result,
     1418                                $upgrader,
     1419                                self::$skin,
     1420                        ), true )
     1421                );
     1422
     1423                return $upgrade_result;
     1424        }
     1425
     1426        /**
     1427         * Kicks off a upgrade request for each item in the upgrade "queue"
     1428         */
     1429        static function perform_auto_updates() {
     1430
     1431                $lock_name = 'auto_upgrader.lock';
     1432                if ( get_site_transient( $lock_name ) ) {
     1433                        // Test to see if it was set more than an hour ago, if so, cleanup.
     1434                        if ( true || get_site_transient( $lock_name ) < ( time() - HOUR_IN_SECONDS ) )
     1435                                delete_site_transient( $lock_name );
     1436                        else // Recent lock
     1437                                return;
     1438                }
     1439                // Lock upgrades for us for half an hour
     1440                if ( ! set_site_transient( $lock_name, microtime( true ), HOUR_IN_SECONDS / 2 ) )
     1441                        return;
     1442
     1443                // Next, Plugins
     1444                wp_update_plugins(); // Check for Plugin updates
     1445                $plugin_updates = get_site_transient( 'update_plugins' );
     1446                if ( $plugin_updates && !empty( $plugin_updates->response ) ) {
     1447                        foreach ( array_keys( $plugin_updates->response ) as $plugin ) {
     1448                                self::upgrade( 'plugin', $plugin );
     1449                        }
     1450                        // Force refresh of plugin update information
     1451                        wp_clean_plugins_cache();
     1452                }
     1453
     1454                // Next, those themes we all love
     1455                wp_update_themes();  // Check for Theme updates
     1456                $theme_updates = get_site_transient( 'update_themes' );
     1457                if ( $theme_updates && !empty( $theme_updates->response ) ) {
     1458                        foreach ( array_keys( $theme_updates->response ) as $theme ) {
     1459                                self::upgrade( 'theme', $theme );
     1460                        }
     1461                        // Force refresh of theme update information
     1462                        wp_clean_themes_cache();
     1463                }
     1464
     1465                // Finally, Process any core upgrade
     1466                wp_version_check(); // Check for Core updates
     1467                $core_update = find_core_auto_update();
     1468                if ( $core_update )
     1469                        self::upgrade( 'core', $core_update );
     1470
     1471                // Cleanup, These won't trigger any updates this time due to the locking transient
     1472                wp_version_check();  // check for Core updates
     1473                wp_update_themes();  // Check for Theme updates
     1474                wp_update_plugins(); // Check for Plugin updates
     1475
     1476                delete_site_transient( $lock_name );
     1477
     1478        }
     1479
     1480}
     1481 No newline at end of file
  • src/wp-admin/includes/update.php

     
    5757        return $result;
    5858}
    5959
     60/**
     61 * Gets the best available (and enabled) Auto-Update for WordPress Core.
     62 *
     63 * If there's 1.2.3 and 1.3 on offer, it'll choose 1.3 if the install allows it, else, 1.2.3
     64 *
     65 * @since 3.7.0
     66 *
     67 * @return bool|array False on failure, otherwise the core update offering.
     68 */
     69function find_core_auto_update() {
     70        $updates = get_site_transient( 'update_core' );
     71        $auto_update = false;
     72        foreach ( $updates->updates as $update ) {
     73                if ( 'autoupdate' != $update->response )
     74                        continue;
     75
     76                if ( ! self::should_upgrade( 'core', $update, ABSPATH ) )
     77                        continue;
     78
     79                if ( ! $auto_update || version_compare( $update->current, $auto_update->current, '>' ) )
     80                        $auto_update = $update;
     81        }
     82        return $auto_update;
     83}
     84
    6085function dismiss_core_update( $update ) {
    6186        $dismissed = get_site_option( 'dismissed_update_core' );
    6287        $dismissed[ $update->current . '|' . $update->locale ] = true;