Ticket #6930: 6930.wp-async-task-example.patch

src/bp-activity/bp-activity-actions.php

@@ -31 +31 @@
 add_action( 'bp_init', 'bp_register_activity_actions', 8 );
 
 /**
+ * Register asynchronous hooks for the activity component.
+ *
+ * @since 2.6.0
+ */
+function bp_activity_register_async_actions() {
+        if ( false === class_exists( 'WP_Async_Task' ) ) {
+                require buddypress()->core->path . 'bp-core/lib/wp-async-task.php';
+        }
+
+        // @todo Alter this when autoloading is ready.
+        if ( false === class_exists( 'BP_Activity_Async_Mentions' ) ) {
+                require dirname( __FILE__ ) . '/classes/class-bp-activity-async-mentions.php';
+        }
+
+        buddypress()->activity->async = new stdClass;
+        buddypress()->activity->async->mentions = new BP_Activity_Async_Mentions;
+}
+add_action( 'bp_init', 'bp_activity_register_async_actions' );
+
+/**
  * Catch and route requests for single activity item permalinks.
  *
  * @since 1.2.0

src/bp-activity/bp-activity-filters.php

@@ -305 +305 @@
                 foreach( (array) $usernames as $user_id => $username ) {
                         $activity->content = preg_replace( '/(@' . $username . '\b)/', "<a href='" . bp_core_get_user_domain( $user_id ) . "' rel='nofollow'>@$username</a>", $activity->content );
                 }
-
-                // Add our hook to send @mention emails after the activity item is saved.
-                add_action( 'bp_activity_after_save', 'bp_activity_at_name_send_emails' );
-
-                // Temporary variable to avoid having to run bp_activity_find_mentions() again.
-                buddypress()->activity->mentioned_users = $usernames;
         }
 }
 
@@ -330 +324 @@
                 return;
         }
 
-        // If our temporary variable doesn't exist, stop now.
-        if ( empty( buddypress()->activity->mentioned_users ) )
+        // Get usernames.
+        $usernames = bp_activity_find_mentions( strip_tags( $activity->content ) );
+        if ( empty( $usernames ) ) {
                 return;
-
-        // Grab our temporary variable from bp_activity_at_name_filter_updates().
-        $usernames = buddypress()->activity->mentioned_users;
-
-        // Get rid of temporary variable.
-        unset( buddypress()->activity->mentioned_users );
+        }
 
         // Send @mentions and setup BP notifications.
         foreach( (array) $usernames as $user_id => $username ) {
@@ -362 +352 @@
                 bp_activity_update_mention_count_for_user( $user_id, $activity->id );
         }
 }
+add_action( 'bp_activity_async_mentions', 'bp_activity_at_name_send_emails' );
 
 /**
  * Catch links in activity text so rel=nofollow can be added.

new file src/bp-activity/classes/class-bp-activity-async-mentions.php

@@ +1 @@
+<?php
+/**
+ * BuddyPress Activity Async Mentions.
+ *
+ * @package BuddyPress
+ * @since 2.6.0
+ */
+
+// Exit if accessed directly.
+defined( 'ABSPATH' ) || exit;
+
+/**
+ * Send activity mentions asynchronously.
+ *
+ * Instead of sending activity mention notifications when the activity item is
+ * being saved, offset this task to another page load.
+ *
+ * @since 2.6.0
+ */
+class BP_Activity_Async_Mentions extends WP_Async_Task {
+        
+        /**
+         * Hook that WP Async Task should attach itself to.
+         *
+         * @var string
+         */
+        protected $action = 'bp_activity_after_save';
+
+        /**
+         * How many arguments are we passing to the hook?
+         *
+         * @var int
+         */
+        protected $argument_count = 1;
+
+        /**
+         * Static initializer.
+         */
+        public static function init() {
+                return new self();
+        }
+
+        /**
+         * Prepare data for the asynchronous request
+         *
+         * @param  array $data Function arguments from our hook as an array.
+         * @return array Data to pass to the next pageload.
+         */
+        protected function prepare_data( $data ) {
+                $activity = $data[0];
+
+                // Are mentions disabled?
+                if ( ! bp_activity_do_mentions() ) {
+                        throw new Exception( 'BP Activity: Mentions disabled.' );
+                }
+
+                $usernames = bp_activity_find_mentions( strip_tags( $activity->content ) );
+
+                // Bail if no mentions.
+                if ( empty( $usernames ) ) {
+                        throw new Exception( 'BP Activity: No mentions found.' );
+                }
+
+                // Prepare data for offloading.
+                return array(
+                        'activity_id' => $activity->id,
+                );
+        }
+
+        /**
+         * Run the async task action.
+         *
+         * Uses the data passed from prepare_data().
+         */
+        protected function run_action() {
+                $activity = new BP_Activity_Activity( $_POST['activity_id'] );
+
+                /**
+                 * Do something when activity mentions async sending is being processed.
+                 *
+                 * @since 2.6.0
+                 *
+                 * @param BP_Activity_Activity $activity
+                 */
+                do_action( 'bp_activity_async_mentions', $activity );
+        }
+
+}
+ No newline at end of file

new file src/bp-core/lib/wp-async-task.php

@@ +1 @@
+<?php
+/**
+ * Plugin Name: WP Asynchronous Tasks
+ * Version: 1.0
+ * Description: Creates an abstract class to execute asynchronous tasks
+ * Author: 10up, Eric Mann, Luke Gedeon, John P. Bloch
+ * License: MIT
+ */
+
+if ( ! class_exists( 'WP_Async_Task' ) ) {
+        abstract class WP_Async_Task {
+
+                /**
+                 * Constant identifier for a task that should be available to logged-in users
+                 *
+                 * See constructor documentation for more details.
+                 */
+                const LOGGED_IN = 1;
+
+                /**
+                 * Constant identifier for a task that should be available to logged-out users
+                 *
+                 * See constructor documentation for more details.
+                 */
+                const LOGGED_OUT = 2;
+
+                /**
+                 * Constant identifier for a task that should be available to all users regardless of auth status
+                 *
+                 * See constructor documentation for more details.
+                 */
+                const BOTH = 3;
+
+                /**
+                 * This is the argument count for the main action set in the constructor. It
+                 * is set to an arbitrarily high value of twenty, but can be overridden if
+                 * necessary
+                 *
+                 * @var int
+                 */
+                protected $argument_count = 20;
+
+                /**
+                 * Priority to fire intermediate action.
+                 *
+                 * @var int
+                 */
+                protected $priority = 10;
+
+                /**
+                 * @var string
+                 */
+                protected $action;
+
+                /**
+                 * @var array
+                 */
+                protected $_body_data;
+
+                /**
+                 * Constructor to wire up the necessary actions
+                 *
+                 * Which hooks the asynchronous postback happens on can be set by the
+                 * $auth_level parameter. There are essentially three options: logged in users
+                 * only, logged out users only, or both. Set this when you instantiate an
+                 * object by using one of the three class constants to do so:
+                 *  - LOGGED_IN
+                 *  - LOGGED_OUT
+                 *  - BOTH
+                 * $auth_level defaults to BOTH
+                 *
+                 * @throws Exception If the class' $action value hasn't been set
+                 *
+                 * @param int $auth_level The authentication level to use (see above)
+                 */
+                public function __construct( $auth_level = self::BOTH ) {
+                        if ( empty( $this->action ) ) {
+                                throw new Exception( 'Action not defined for class ' . __CLASS__ );
+                        }
+                        add_action( $this->action, array( $this, 'launch' ), (int) $this->priority, (int) $this->argument_count );
+                        if ( $auth_level & self::LOGGED_IN ) {
+                                add_action( "admin_post_wp_async_$this->action", array( $this, 'handle_postback' ) );
+                        }
+                        if ( $auth_level & self::LOGGED_OUT ) {
+                                add_action( "admin_post_nopriv_wp_async_$this->action", array( $this, 'handle_postback' ) );
+                        }
+                }
+
+                /**
+                 * Add the shutdown action for launching the real postback if we don't
+                 * get an exception thrown by prepare_data().
+                 *
+                 * @uses func_get_args() To grab any arguments passed by the action
+                 */
+                public function launch() {
+                        $data = func_get_args();
+                        try {
+                                $data = $this->prepare_data( $data );
+                        } catch ( Exception $e ) {
+                                return;
+                        }
+
+                        $data['action'] = "wp_async_$this->action";
+                        $data['_nonce'] = $this->create_async_nonce();
+
+                        $this->_body_data = $data;
+
+                        if ( ! has_action( 'shutdown', array( $this, 'launch_on_shutdown' ) ) ) {
+                                add_action( 'shutdown', array( $this, 'launch_on_shutdown' ) );
+                        }
+                }
+
+                /**
+                 * Launch the request on the WordPress shutdown hook
+                 *
+                 * On VIP we got into data races due to the postback sometimes completing
+                 * faster than the data could propogate to the database server cluster.
+                 * This made WordPress get empty data sets from the database without
+                 * failing. On their advice, we're moving the actual firing of the async
+                 * postback to the shutdown hook. Supposedly that will ensure that the
+                 * data at least has time to get into the object cache.
+                 *
+                 * @uses $_COOKIE        To send a cookie header for async postback
+                 * @uses apply_filters()
+                 * @uses admin_url()
+                 * @uses wp_remote_post()
+                 */
+                public function launch_on_shutdown() {
+                        if ( ! empty( $this->_body_data ) ) {
+                                $cookies = array();
+                                foreach ( $_COOKIE as $name => $value ) {
+                                        $cookies[] = "$name=" . urlencode( is_array( $value ) ? serialize( $value ) : $value );
+                                }
+
+                                $request_args = array(
+                                        'timeout'   => 0.01,
+                                        'blocking'  => false,
+                                        'sslverify' => apply_filters( 'https_local_ssl_verify', true ),
+                                        'body'      => $this->_body_data,
+                                        'headers'   => array(
+                                                'cookie' => implode( '; ', $cookies ),
+                                        ),
+                                );
+
+                                $url = admin_url( 'admin-post.php' );
+
+                                wp_remote_post( $url, $request_args );
+                        }
+                }
+
+                /**
+                 * Verify the postback is valid, then fire any scheduled events.
+                 *
+                 * @uses $_POST['_nonce']
+                 * @uses is_user_logged_in()
+                 * @uses add_filter()
+                 * @uses wp_die()
+                 */
+                public function handle_postback() {
+                        if ( isset( $_POST['_nonce'] ) && $this->verify_async_nonce( $_POST['_nonce'] ) ) {
+                                if ( ! is_user_logged_in() ) {
+                                        $this->action = "nopriv_$this->action";
+                                }
+                                $this->run_action();
+                        }
+
+                        add_filter( 'wp_die_handler', function() { die(); } );
+                        wp_die();
+                }
+
+                /**
+                 * Create a random, one time use token.
+                 *
+                 * Based entirely on wp_create_nonce() but does not tie the nonce to the
+                 * current logged-in user.
+                 *
+                 * @uses wp_nonce_tick()
+                 * @uses wp_hash()
+                 *
+                 * @return string The one-time use token
+                 */
+                protected function create_async_nonce() {
+                        $action = $this->get_nonce_action();
+                        $i      = wp_nonce_tick();
+
+                        return substr( wp_hash( $i . $action . get_class( $this ), 'nonce' ), - 12, 10 );
+                }
+
+                /**
+                 * Verify that the correct nonce was used within the time limit.
+                 *
+                 * @uses wp_nonce_tick()
+                 * @uses wp_hash()
+                 *
+                 * @param string $nonce Nonce to be verified
+                 *
+                 * @return bool Whether the nonce check passed or failed
+                 */
+                protected function verify_async_nonce( $nonce ) {
+                        $action = $this->get_nonce_action();
+                        $i      = wp_nonce_tick();
+
+                        // Nonce generated 0-12 hours ago
+                        if ( substr( wp_hash( $i . $action . get_class( $this ), 'nonce' ), - 12, 10 ) == $nonce ) {
+                                return 1;
+                        }
+
+                        // Nonce generated 12-24 hours ago
+                        if ( substr( wp_hash( ( $i - 1 ) . $action . get_class( $this ), 'nonce' ), - 12, 10 ) == $nonce ) {
+                                return 2;
+                        }
+
+                        // Invalid nonce
+                        return false;
+                }
+
+                /**
+                 * Get a nonce action based on the $action property of the class
+                 *
+                 * @return string The nonce action for the current instance
+                 */
+                protected function get_nonce_action() {
+                        $action = $this->action;
+                        if ( substr( $action, 0, 7 ) === 'nopriv_' ) {
+                                $action = substr( $action, 7 );
+                        }
+                        $action = "wp_async_$action";
+                        return $action;
+                }
+
+                /**
+                 * Prepare any data to be passed to the asynchronous postback
+                 *
+                 * The array this function receives will be a numerically keyed array from
+                 * func_get_args(). It is expected that you will return an associative array
+                 * so that the $_POST values used in the asynchronous call will make sense.
+                 *
+                 * The array you send back may or may not have anything to do with the data
+                 * passed into this method. It all depends on the implementation details and
+                 * what data is needed in the asynchronous postback.
+                 *
+                 * Do not set values for 'action' or '_nonce', as those will get overwritten
+                 * later in launch().
+                 *
+                 * @throws Exception If the postback should not occur for any reason
+                 *
+                 * @param array $data The raw data received by the launch method
+                 *
+                 * @return array The prepared data
+                 */
+                abstract protected function prepare_data( $data );
+
+                /**
+                 * Run the do_action function for the asynchronous postback.
+                 *
+                 * This method needs to fetch and sanitize any and all data from the $_POST
+                 * superglobal and provide them to the do_action call.
+                 *
+                 * The action should be constructed as "wp_async_task_$this->action"
+                 */
+                abstract protected function run_action();
+
+        }
+
+}
+