WordPress.org
Get WordPress

Make WordPress Core

Ticket #22704: 22704.14.diff

File 22704.14.diff, 10.5 KB (added by nacin, 12 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