Changeset 25421 for trunk/src/wp-admin/includes/class-wp-upgrader.php

Timestamp:

09/13/2013 06:18:16 AM (13 years ago)

Author:

dd32

Message:

WordPress Core Automatic Updates: Add the first slice of Automatic Upgrades, This is presently disabled, and requires a filter to enable ( 'auto_upgrade_core' ). See #22704

File:

• trunk/src/wp-admin/includes/class-wp-upgrader.php (modified) (2 diffs)

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

@@ -1138 +1138 @@
         }
 
+        // Determines if this WordPress Core version should update to $offered_ver or not
+        static function should_upgrade_to_version( $offered_ver /* x.y.z */ ) {
+                include ABSPATH . WPINC . '/version.php'; // $wp_version; // x.y.z
+
+                $current_branch = implode( '.', array_slice( preg_split( '/[.-]/', $wp_version  ), 0, 2 ) ); // x.y
+                $new_branch     = implode( '.', array_slice( preg_split( '/[.-]/', $offered_ver ), 0, 2 ) ); // x.y
+                $current_is_development_version = (bool) strpos( $wp_version, '-' );
+
+                // Defaults:
+                $upgrade_dev   = false;
+                $upgrade_minor = false; // @TODO: Update for release by toggling to true.
+                $upgrade_major = false;
+
+                // WP_AUTO_UPDATE_CORE = true (all), 'minor', false.
+                if ( defined( 'WP_AUTO_UPDATE_CORE' ) ) {
+                        if ( false === WP_AUTO_UPDATE_CORE ) {
+                                // Defaults to turned off, unless a filter allows it
+                                $upgrade_dev = $upgrade_minor = $upgrade_major = false;
+                        } elseif ( true === WP_AUTO_UPDATE_CORE ) {
+                                // ALL updates for core
+                                $upgrade_dev = $upgrade_minor = $upgrade_major = true;
+                        } elseif ( 'minor' === WP_AUTO_UPDATE_CORE ) {
+                                // Only minor updates for core
+                                $upgrade_dev = $upgrade_major = false;
+                                $upgrade_minor = true;
+                        }
+                }
+
+                // 1: If we're already on that version, not much point in updating?
+                if ( $offered_ver == $wp_version )
+                        return false;
+
+                // 2: If we're running a newer version, that's a nope
+                if ( version_compare( $wp_version, $offered_ver, '>=' ) )
+                        return false;
+
+                // 3: 3.7-alpha-25000 -> 3.7-alpha-25678 -> 3.7-beta1 -> 3.7-beta2
+                if ( $current_is_development_version ) {
+                        if ( ! apply_filters( 'allow_dev_auto_core_updates', $upgrade_dev ) )
+                                return false;
+                        // else fall through to minor + major branches below
+                }
+
+                // 4: Minor In-branch updates (3.7.0 -> 3.7.1 -> 3.7.2 -> 3.7.4)
+                if ( $current_branch == $new_branch )
+                        return apply_filters( 'allow_minor_auto_core_updates', $upgrade_minor );
+
+                // 5: Major version updates (3.7.0 -> 3.8.0 -> 3.9.1)
+                if ( version_compare( $new_branch, $current_branch, '>' ) )
+                        return apply_filters( 'allow_major_auto_core_updates', $upgrade_major );
+
+                // If we're not sure, we don't want it
+                return false;
+        }
+
 }
 
@@ -1213 +1268 @@
         }
 }
+
+/**
+ * WordPress Automatic Upgrader helper class
+ *
+ * @since 3.7.0
+ */
+class WP_Automatic_Upgrader {
+
+        static $skin;
+
+        static function upgrader_disabled() {
+                // That's a no if you don't want files changes
+                if ( defined( 'DISABLE_FILE_MODS' ) && DISABLE_FILE_MODS )
+                        return true;
+
+                // More fine grained control can be done through the WP_AUTO_UPDATE_CORE constant and filters
+                if ( defined( 'AUTOMATIC_UPDATER_DISABLED' ) && AUTOMATIC_UPDATER_DISABLED )
+                        return true;
+
+                if ( defined( 'WP_INSTALLING' ) )
+                        return true;
+
+                return apply_filters( 'auto_upgrader_disabled', false );
+        }
+
+        /**
+         * Tests to see if we should upgrade a specific item, does not test to see if we CAN update the item.
+         */
+        static function should_auto_update( $type, $item, $context ) {
+
+                if ( self::upgrader_disabled() )
+                        return false;
+
+                // ..and also check for GIT/SVN checkouts
+                if ( ! apply_filters( 'auto_upgrade_ignore_checkout_status', false ) ) {
+                        $stop_dirs = array(
+                                ABSPATH,
+                                untrailingslashit( $context ),
+                        );
+                        if ( ! file_exists( ABSPATH . '/wp-config.php' ) ) // wp-config.php up one folder in a deployment situation
+                                $stop_dirs[] = dirname( ABSPATH );
+                        foreach ( array_unique( $stop_dirs ) as $dir ) {
+                                if ( file_exists( $dir . '/.svn' ) || file_exists( $dir . '/.git' ) )
+                                        return false;
+                        }
+                }
+
+                // Next up, do we actually have it enabled for this type of update?
+                switch ( $type ) {
+                        case 'core':
+                                $upgrade = Core_Upgrader::should_upgrade_to_version( $item->current );
+                                break;
+                        default:
+                        case 'plugin':
+                        case 'theme':
+                                $upgrade = false;
+                                break;
+                }
+
+                // And does the user / plugins want it?
+                // Plugins may filter on 'auto_upgrade_plugin', and check the 2nd param, $item, to only enable it for certain Plugins/Themes
+                if ( ! apply_filters( 'auto_upgrade_' . $type, $upgrade, $item ) )
+                        return false;
+
+                // If it's a core update, are we actually compatible with it's requirements?
+                if ( 'core' == $type ) {
+                        global $wpdb;
+
+                        $php_compat = version_compare( phpversion(), $item->php_version, '>=' );
+                        if ( file_exists( WP_CONTENT_DIR . '/db.php' ) && empty( $wpdb->is_mysql ) )
+                                $mysql_compat = true;
+                        else
+                                $mysql_compat = version_compare( $wpdb->db_version(), $item->mysql_version, '>=' );
+
+                        if ( ! $php_compat || ! $mysql_compat )
+                                return false;
+                }
+
+                return true;
+        }
+
+        // Checks to see if WP_Filesystem is setup to allow unattended upgrades
+        static function can_auto_update( $context ) {
+                if ( ! self::$skin )
+                        self::$skin = new Automatic_Upgrader_Skin();
+                return (bool) self::$skin->request_filesystem_credentials();
+        }
+
+        static function upgrade( $type, $item ) {
+
+                self::$skin = new Automatic_Upgrader_Skin();
+
+                switch ( $type ) {
+                        case 'core':
+                                // The Core upgrader doesn't use the Upgrader's skin during the actual main part of the upgrade, instead, firing a filter
+                                add_filter( 'update_feedback', function( $message ) {
+                                        WP_Background_Upgrader::$skin->feedback( $message );
+                                        return $message;
+                                } );
+                                $upgrader = new Core_Upgrader( self::$skin );
+                                $context  = ABSPATH;
+                                break;
+                        case 'plugin':
+                                $upgrader = new Plugin_Upgrader( self::$skin );
+                                $context  = WP_PLUGIN_DIR; // We don't support custom Plugin directories, or updates for WPMU_PLUGIN_DIR
+                                break;
+                        case 'theme':
+                                $upgrader = new Theme_Upgrader( self::$skin );
+                                $context  = get_theme_root( $item );
+                                break;
+                }
+
+                // Determine if we can perform this upgrade or not
+                if ( ! self::should_auto_update( $type, $item, $context )  || ! self::can_auto_update( $context ) )
+                        return false;
+
+                /*wp_mail(
+                        get_site_option( 'admin_email' ),
+                        __METHOD__,
+                        "Starting an upgrade for:\n\n" . var_export( compact( 'type', 'item' ), true ) . "\n\n" . wp_debug_backtrace_summary()
+                );*/
+
+                // Boom, This sites about to get a whole new splash of paint!
+                $upgrade_result = $upgrader->upgrade( $item, array(
+                        'clear_update_cache' => false,
+                ) );
+
+                // Core doesn't output this, so lets append it so we don't get confused
+                if ( 'core' == $type ) {
+                        if ( is_wp_error( $upgrade_result ) ) {
+                                self::$skin->error( __( 'Installation Failed' ), $upgrade_result );
+                        } else {
+                                self::$skin->feedback( __( 'WordPress updated successfully' ) );
+                        }
+                }
+
+                // Clear cache's and transients
+                switch ( $type ) {
+                        case 'core':
+                                delete_site_transient( 'update_core' );
+                                break;
+                        case 'theme':
+                                wp_clean_themes_cache();
+                                break;
+                        case 'plugin':
+                                wp_clean_plugins_cache();
+                                break;
+                }
+
+                //var_dump( compact( 'type', 'item', 'upgrader', 'upgrade_result' ) );
+
+                wp_mail(
+                        get_site_option( 'admin_email' ),
+                        __METHOD__,
+                        var_export( array(
+                                $upgrade_result,
+                                $upgrader,
+                                self::$skin,
+                        ), true )
+                );
+
+                return $upgrade_result;
+        }
+
+        /**
+         * Kicks off a upgrade request for each item in the upgrade "queue"
+         */
+        static function perform_auto_updates() {
+
+                $lock_name = 'auto_upgrader.lock';
+                if ( get_site_transient( $lock_name ) ) {
+                        // Test to see if it was set more than an hour ago, if so, cleanup.
+                        if ( true || get_site_transient( $lock_name ) < ( time() - HOUR_IN_SECONDS ) )
+                                delete_site_transient( $lock_name );
+                        else // Recent lock
+                                return;
+                }
+                // Lock upgrades for us for half an hour
+                if ( ! set_site_transient( $lock_name, microtime( true ), HOUR_IN_SECONDS / 2 ) )
+                        return;
+
+                // Next, Plugins
+                wp_update_plugins(); // Check for Plugin updates
+                $plugin_updates = get_site_transient( 'update_plugins' );
+                if ( $plugin_updates && !empty( $plugin_updates->response ) ) {
+                        foreach ( array_keys( $plugin_updates->response ) as $plugin ) {
+                                self::upgrade( 'plugin', $plugin );
+                        }
+                        // Force refresh of plugin update information
+                        wp_clean_plugins_cache();
+                }
+
+                // Next, those themes we all love
+                wp_update_themes();  // Check for Theme updates
+                $theme_updates = get_site_transient( 'update_themes' );
+                if ( $theme_updates && !empty( $theme_updates->response ) ) {
+                        foreach ( array_keys( $theme_updates->response ) as $theme ) {
+                                self::upgrade( 'theme', $theme );
+                        }
+                        // Force refresh of theme update information
+                        wp_clean_themes_cache();
+                }
+
+                // Finally, Process any core upgrade
+                wp_version_check(); // Check for Core updates
+                $core_update = find_core_auto_update();
+                if ( $core_update )
+                        self::upgrade( 'core', $core_update );
+
+                // Cleanup, These won't trigger any updates this time due to the locking transient
+                wp_version_check();  // check for Core updates
+                wp_update_themes();  // Check for Theme updates
+                wp_update_plugins(); // Check for Plugin updates
+
+                // TODO The core database upgrade has already cleared this transient..
+                delete_site_transient( $lock_name );
+
+        }
+
+}