WordPress.org

Make WordPress Core

Ticket #22704: 22704.14.diff

File 22704.14.diff, 10.5 KB (added by nacin, 4 years ago)

Changes upgrade() to update() in the automatic upgrader, which is now called the background updater. (It could be useful for more than just 'auto' updates.) The skin remains the Automatic_Upgrader. It kind of makes sense in my head.

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

     
    14021402        } 
    14031403 
    14041404        // Determines if this WordPress Core version should update to $offered_ver or not 
    1405         static function should_upgrade_to_version( $offered_ver /* x.y.z */ ) { 
     1405        static function should_update_to_version( $offered_ver /* x.y.z */ ) { 
    14061406                include ABSPATH . WPINC . '/version.php'; // $wp_version; // x.y.z 
    14071407 
    14081408                $current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version  ), 0, 2 ) ); // x.y 
     
    15511551} 
    15521552 
    15531553/** 
    1554  * WordPress automatic background upgrader. 
     1554 * WordPress automatic background updater. 
    15551555 * 
    15561556 * @since 3.7.0 
    15571557 */ 
    1558 class WP_Automatic_Upgrader { 
     1558class WP_Background_Updater { 
    15591559 
    15601560        protected $update_results = array(); 
    15611561 
     
    15701570                // More fine grained control can be done through the WP_AUTO_UPDATE_CORE constant and filters. 
    15711571                $disabled = defined( 'AUTOMATIC_UPDATES_DISABLED' ) && AUTOMATIC_UPDATES_DISABLED; 
    15721572 
    1573                 return apply_filters( 'auto_upgrader_disabled', $disabled ); 
     1573                return apply_filters( 'auto_updates_disabled', $disabled ); 
    15741574        } 
    15751575 
    15761576        /** 
     
    16001600                                        break 2; 
    16011601                        } 
    16021602                } 
    1603                 return apply_filters( 'auto_upgrade_is_vcs_checkout', $checkout, $context ); 
     1603                return apply_filters( 'auto_updates_is_vcs_checkout', $checkout, $context ); 
    16041604        } 
    16051605 
    16061606        /** 
    1607          * Tests to see if we can and should upgrade a specific item. 
     1607         * Tests to see if we can and should update a specific item. 
    16081608         */ 
    1609         function should_upgrade( $type, $item, $context ) { 
     1609        function should_update( $type, $item, $context ) { 
    16101610                if ( $this->is_disabled() ) 
    16111611                        return false; 
    16121612 
    1613                 // Checks to see if WP_Filesystem is set up to allow unattended upgrades. 
     1613                // Checks to see if WP_Filesystem is set up to allow unattended updates. 
    16141614                $skin = new Automatic_Upgrader_Skin; 
    16151615                if ( ! $skin->request_filesystem_credentials( false, $context ) ) 
    16161616                        return false; 
     
    16211621                // Next up, do we actually have it enabled for this type of update? 
    16221622                switch ( $type ) { 
    16231623                        case 'language': 
    1624                                 $upgrade = ! empty( $item->autoupdate ); 
     1624                                $update = ! empty( $item->autoupdate ); 
    16251625                                break; 
    16261626                        case 'core': 
    1627                                 $upgrade = Core_Upgrader::should_upgrade_to_version( $item->current ); 
     1627                                $update = Core_Upgrader::should_update_to_version( $item->current ); 
    16281628                                break; 
    16291629                        default: 
    16301630                        case 'plugin': 
    16311631                        case 'theme': 
    1632                                 $upgrade = false; 
     1632                                $update = false; 
    16331633                                break; 
    16341634                } 
    16351635 
    16361636                // And does the user / plugins want it? 
    1637                 // Plugins may filter on 'auto_upgrade_plugin', and check the 2nd param, $item, to only enable it for certain Plugins/Themes 
    1638                 if ( ! apply_filters( 'auto_upgrade_' . $type, $upgrade, $item ) ) 
     1637                // Plugins may filter on 'auto_update_plugin', and check the 2nd param, $item, to only enable it for certain Plugins/Themes 
     1638                if ( ! apply_filters( 'auto_update_' . $type, $update, $item ) ) 
    16391639                        return false; 
    16401640 
    16411641                // If it's a core update, are we actually compatible with its requirements? 
     
    16551655                return true; 
    16561656        } 
    16571657 
    1658         function upgrade( $type, $item ) { 
     1658        function update( $type, $item ) { 
    16591659 
    1660                 $skin = new Automatic_Upgrader_Skin(); 
     1660                $skin = new Automatic_Upgrader_Skin; 
    16611661 
    16621662                switch ( $type ) { 
    16631663                        case 'core': 
    1664                                 // The Core upgrader doesn't use the Upgrader's skin during the actual main part of the upgrade, instead, firing a filter 
     1664                                // The Core upgrader doesn't use the Upgrader's skin during the actual main part of the upgrade, instead, firing a filter. 
    16651665                                add_filter( 'update_feedback', array( $skin, 'feedback' ) ); 
    16661666                                $upgrader = new Core_Upgrader( $skin ); 
    16671667                                $context  = ABSPATH; 
     
    16801680                                break; 
    16811681                } 
    16821682 
    1683                 // Determine whether we can and should perform this upgrade. 
    1684                 if ( ! $this->should_upgrade( $type, $item, $context ) ) 
     1683                // Determine whether we can and should perform this update. 
     1684                if ( ! $this->should_update( $type, $item, $context ) ) 
    16851685                        return false; 
    16861686 
    16871687                switch ( $type ) { 
     
    17331733        } 
    17341734 
    17351735        /** 
    1736          * Kicks off a upgrade request for each item in the upgrade "queue" 
     1736         * Kicks off a update request for each item in the update "queue". 
    17371737         */ 
    17381738        function run() { 
    17391739                global $wpdb; 
     
    17411741                if ( ! is_main_network() || ! is_main_site() ) 
    17421742                        return; 
    17431743 
    1744                 $lock_name = 'auto_upgrader.lock'; 
     1744                $lock_name = 'auto_updater.lock'; 
    17451745 
    17461746                // Try to lock 
    17471747                $lock_result = $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO `$wpdb->options` ( `option_name`, `option_value`, `autoload` ) VALUES (%s, %s, 'no') /* LOCK */", $lock_name, time() ) ); 
     
    17721772                $plugin_updates = get_site_transient( 'update_plugins' ); 
    17731773                if ( $plugin_updates && !empty( $plugin_updates->response ) ) { 
    17741774                        foreach ( array_keys( $plugin_updates->response ) as $plugin ) { 
    1775                                 $this->upgrade( 'plugin', $plugin ); 
     1775                                $this->update( 'plugin', $plugin ); 
    17761776                        } 
    17771777                        // Force refresh of plugin update information 
    17781778                        wp_clean_plugins_cache(); 
     
    17831783                $theme_updates = get_site_transient( 'update_themes' ); 
    17841784                if ( $theme_updates && !empty( $theme_updates->response ) ) { 
    17851785                        foreach ( array_keys( $theme_updates->response ) as $theme ) { 
    1786                                 $this->upgrade( 'theme', $theme ); 
     1786                                $this->update( 'theme', $theme ); 
    17871787                        } 
    17881788                        // Force refresh of theme update information 
    17891789                        wp_clean_themes_cache(); 
    17901790                } 
    17911791 
    1792                 // Next, Process any core upgrade 
     1792                // Next, Process any core update 
    17931793                wp_version_check(); // Check for Core updates 
    17941794                $extra_update_stats = array(); 
    17951795                $core_update = find_core_auto_update(); 
     
    17971797                if ( $core_update ) { 
    17981798                        $start_time = time(); 
    17991799 
    1800                         $core_update_result = $this->upgrade( 'core', $core_update ); 
     1800                        $core_update_result = $this->update( 'core', $core_update ); 
    18011801                        delete_site_transient( 'update_core' ); 
    18021802 
    18031803                        $extra_update_stats['success'] = is_wp_error( $core_update_result ) ? $core_update_result->get_error_code() : true; 
     
    18261826                $language_updates = wp_get_translation_updates(); 
    18271827                if ( $language_updates ) { 
    18281828                        foreach ( $language_updates as $update ) { 
    1829                                 $this->upgrade( 'language', $update ); 
     1829                                $this->update( 'language', $update ); 
    18301830                        } 
    18311831 
    18321832                        // Clear existing caches 
     
    18501850                if ( empty( $this->update_results ) ) 
    18511851                        return; 
    18521852 
    1853                 $upgrade_count = 0; 
    1854                 foreach ( $this->update_results as $type => $upgrades ) 
    1855                         $upgrade_count += count( $upgrades ); 
     1853                $update_count = 0; 
     1854                foreach ( $this->update_results as $type => $updates ) 
     1855                        $update_count += count( $updates ); 
    18561856 
    18571857                $body = array(); 
    18581858                $failures = 0; 
     
    19101910                        $subject = sprintf( '[%s] Background updates have finished', get_bloginfo( 'name' ) ); 
    19111911                } 
    19121912 
    1913                 $body[] = 'UPGRADE LOG'; 
    1914                 $body[] = '==========='; 
     1913                $body[] = 'UPDATE LOG'; 
     1914                $body[] = '=========='; 
    19151915                $body[] = ''; 
    19161916 
    19171917                foreach ( array( 'core', 'plugin', 'theme', 'language' ) as $type ) { 
    19181918                        if ( ! isset( $this->update_results[ $type ] ) ) 
    19191919                                continue; 
    1920                         foreach ( $this->update_results[ $type ] as $upgrade ) { 
    1921                                 $body[] = $upgrade->name; 
    1922                                 $body[] = str_repeat( '-', strlen( $upgrade->name ) ); 
    1923                                 foreach ( $upgrade->messages as $message ) 
     1920                        foreach ( $this->update_results[ $type ] as $update ) { 
     1921                                $body[] = $update->name; 
     1922                                $body[] = str_repeat( '-', strlen( $update->name ) ); 
     1923                                foreach ( $update->messages as $message ) 
    19241924                                        $body[] = "  " . html_entity_decode( str_replace( '…', '...', $message ) ); 
    1925                                 if ( is_wp_error( $upgrade->result ) ) 
    1926                                         $body[] = '  Error: [' . $upgrade->result->get_error_code() . '] ' . $upgrade->result->get_error_message(); 
     1925                                if ( is_wp_error( $update->result ) ) 
     1926                                        $body[] = '  Error: [' . $update->result->get_error_code() . '] ' . $update->result->get_error_message(); 
    19271927                                $body[] = ''; 
    19281928                        } 
    19291929                } 
  • src/wp-admin/includes/update.php

     
    7777        include_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php'; 
    7878 
    7979        $auto_update = false; 
    80         $upgrader = new WP_Automatic_Upgrader; 
     80        $upgrader = new WP_Background_Updater; 
    8181        foreach ( $updates->updates as $update ) { 
    8282                if ( 'autoupdate' != $update->response ) 
    8383                        continue; 
    8484 
    85                 if ( ! $upgrader->should_upgrade( 'core', $update, ABSPATH ) ) 
     85                if ( ! $upgrader->should_update( 'core', $update, ABSPATH ) ) 
    8686                        continue; 
    8787 
    8888                if ( ! $auto_update || version_compare( $update->current, $auto_update->current, '>' ) ) 
  • src/wp-admin/update-core.php

     
    148148 
    149149                if ( wp_http_supports( 'ssl' ) ) { 
    150150                        require_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php'; 
    151                         $upgrader = new WP_Automatic_Upgrader; 
     151                        $upgrader = new WP_Background_Updater; 
    152152                        $future_minor_update = (object) array( 
    153153                                'current'       => $wp_version . '.1-update-core.php', 
    154154                                'version'       => $wp_version . '.1-update-core.php', 
     
    155155                                'php_version'   => $required_php_version, 
    156156                                'mysql_version' => $required_mysql_version, 
    157157                        ); 
    158                         $should_auto_update = $upgrader->should_upgrade( 'core', $future_minor_update, ABSPATH ); 
     158                        $should_auto_update = $upgrader->should_update( 'core', $future_minor_update, ABSPATH ); 
    159159                        if ( $should_auto_update ) 
    160160                                echo ' ' . __( 'Future security updates will be applied automatically.' ); 
    161161                } 
     
    172172 
    173173        if ( isset( $updates[0] ) && $updates[0]->response == 'development' ) { 
    174174                require_once ABSPATH . 'wp-admin/includes/class-wp-upgrader.php'; 
    175                 $upgrader = new WP_Automatic_Upgrader; 
    176                 if ( wp_http_supports( 'ssl' ) && $upgrader->should_upgrade( 'core', $updates[0], ABSPATH ) ) 
     175                $upgrader = new WP_Background_Updater; 
     176                if ( wp_http_supports( 'ssl' ) && $upgrader->should_update( 'core', $updates[0], ABSPATH ) ) 
    177177                        echo '<div class="updated inline"><p><strong>BETA TESTERS:</strong> This site is set up to install updates of future beta versions automatically.</p></div>'; 
    178178        } 
    179179 
  • src/wp-includes/update.php

     
    414414        include_once ABSPATH . '/wp-admin/includes/admin.php'; 
    415415        include_once ABSPATH . '/wp-admin/includes/class-wp-upgrader.php'; 
    416416 
    417         $upgrader = new WP_Automatic_Upgrader; 
     417        $upgrader = new WP_Background_Updater; 
    418418        if ( $upgrader->is_disabled() ) 
    419419                return; 
    420420