class.jetpack-sync-actions.php
| 1 | <?php |
| 2 | |
| 3 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-modules.php'; |
| 4 | |
| 5 | /** |
| 6 | * The role of this class is to hook the Sync subsystem into WordPress - when to listen for actions, |
| 7 | * when to send, when to perform a full sync, etc. |
| 8 | * |
| 9 | * It also binds the action to send data to WPCOM to Jetpack's XMLRPC client object. |
| 10 | */ |
| 11 | class Jetpack_Sync_Actions { |
| 12 | static $sender = null; |
| 13 | static $listener = null; |
| 14 | const DEFAULT_SYNC_CRON_INTERVAL_NAME = 'jetpack_sync_interval'; |
| 15 | const DEFAULT_SYNC_CRON_INTERVAL_VALUE = 300; // 5 * MINUTE_IN_SECONDS; |
| 16 | |
| 17 | static function init() { |
| 18 | |
| 19 | // everything below this point should only happen if we're a valid sync site |
| 20 | if ( ! self::sync_allowed() ) { |
| 21 | return; |
| 22 | } |
| 23 | |
| 24 | if ( self::sync_via_cron_allowed() ) { |
| 25 | self::init_sync_cron_jobs(); |
| 26 | } elseif ( wp_next_scheduled( 'jetpack_sync_cron' ) ) { |
| 27 | self::clear_sync_cron_jobs(); |
| 28 | } |
| 29 | // When importing via cron, do not sync |
| 30 | add_action( 'wp_cron_importer_hook', array( __CLASS__, 'set_is_importing_true' ), 1 ); |
| 31 | |
| 32 | // Sync connected user role changes to .com |
| 33 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-users.php'; |
| 34 | |
| 35 | // publicize filter to prevent publicizing blacklisted post types |
| 36 | add_filter( 'publicize_should_publicize_published_post', array( __CLASS__, 'prevent_publicize_blacklisted_posts' ), 10, 2 ); |
| 37 | |
| 38 | /** |
| 39 | * Fires on every request before default loading sync listener code. |
| 40 | * Return false to not load sync listener code that monitors common |
| 41 | * WP actions to be serialized. |
| 42 | * |
| 43 | * By default this returns true for cron jobs, non-GET-requests, or requests where the |
| 44 | * user is logged-in. |
| 45 | * |
| 46 | * @since 4.2.0 |
| 47 | * |
| 48 | * @param bool should we load sync listener code for this request |
| 49 | */ |
| 50 | if ( apply_filters( 'jetpack_sync_listener_should_load', true ) ) { |
| 51 | self::initialize_listener(); |
| 52 | } |
| 53 | |
| 54 | add_action( 'init', array( __CLASS__, 'add_sender_shutdown' ), 90 ); |
| 55 | } |
| 56 | |
| 57 | static function add_sender_shutdown() { |
| 58 | /** |
| 59 | * Fires on every request before default loading sync sender code. |
| 60 | * Return false to not load sync sender code that serializes pending |
| 61 | * data and sends it to WPCOM for processing. |
| 62 | * |
| 63 | * By default this returns true for cron jobs, POST requests, admin requests, or requests |
| 64 | * by users who can manage_options. |
| 65 | * |
| 66 | * @since 4.2.0 |
| 67 | * |
| 68 | * @param bool should we load sync sender code for this request |
| 69 | */ |
| 70 | if ( apply_filters( |
| 71 | 'jetpack_sync_sender_should_load', |
| 72 | ( |
| 73 | ( isset( $_SERVER['REQUEST_METHOD'] ) && 'POST' === $_SERVER['REQUEST_METHOD'] ) |
| 74 | || |
| 75 | current_user_can( 'manage_options' ) |
| 76 | || |
| 77 | is_admin() |
| 78 | || |
| 79 | defined( 'PHPUNIT_JETPACK_TESTSUITE' ) |
| 80 | ) |
| 81 | ) ) { |
| 82 | self::initialize_sender(); |
| 83 | add_action( 'shutdown', array( self::$sender, 'do_sync' ) ); |
| 84 | add_action( 'shutdown', array( self::$sender, 'do_full_sync' ) ); |
| 85 | } |
| 86 | } |
| 87 | |
| 88 | static function sync_allowed() { |
| 89 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php'; |
| 90 | return ( ! Jetpack_Sync_Settings::get_setting( 'disable' ) |
| 91 | && ( doing_action( 'jetpack_user_authorized' ) || Jetpack::is_active() ) |
| 92 | && ! ( Jetpack::is_development_mode() || Jetpack::is_staging_site() ) ) |
| 93 | || defined( 'PHPUNIT_JETPACK_TESTSUITE' ); |
| 94 | } |
| 95 | |
| 96 | static function sync_via_cron_allowed() { |
| 97 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php'; |
| 98 | return ( Jetpack_Sync_Settings::get_setting( 'sync_via_cron' ) ); |
| 99 | } |
| 100 | |
| 101 | static function prevent_publicize_blacklisted_posts( $should_publicize, $post ) { |
| 102 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php'; |
| 103 | if ( in_array( $post->post_type, Jetpack_Sync_Settings::get_setting( 'post_types_blacklist' ) ) ) { |
| 104 | return false; |
| 105 | } |
| 106 | |
| 107 | return $should_publicize; |
| 108 | } |
| 109 | |
| 110 | static function set_is_importing_true() { |
| 111 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php'; |
| 112 | Jetpack_Sync_Settings::set_importing( true ); |
| 113 | } |
| 114 | |
| 115 | static function send_data( $data, $codec_name, $sent_timestamp, $queue_id, $checkout_duration, $preprocess_duration ) { |
| 116 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-functions.php'; |
| 117 | Jetpack::load_xml_rpc_client(); |
| 118 | |
| 119 | $query_args = array( |
| 120 | 'sync' => '1', // add an extra parameter to the URL so we can tell it's a sync action |
| 121 | 'codec' => $codec_name, // send the name of the codec used to encode the data |
| 122 | 'timestamp' => $sent_timestamp, // send current server time so we can compensate for clock differences |
| 123 | 'queue' => $queue_id, // sync or full_sync |
| 124 | 'home' => Jetpack_Sync_Functions::home_url(), // Send home url option to check for Identity Crisis server-side |
| 125 | 'siteurl' => Jetpack_Sync_Functions::site_url(), // Send siteurl option to check for Identity Crisis server-side |
| 126 | 'cd' => sprintf( '%.4f', $checkout_duration ), // Time spent retrieving queue items from the DB |
| 127 | 'pd' => sprintf( '%.4f', $preprocess_duration ), // Time spent converting queue items into data to send |
| 128 | ); |
| 129 | |
| 130 | // Has the site opted in to IDC mitigation? |
| 131 | if ( Jetpack::sync_idc_optin() ) { |
| 132 | $query_args['idc'] = true; |
| 133 | } |
| 134 | |
| 135 | if ( Jetpack_Options::get_option( 'migrate_for_idc', false ) ) { |
| 136 | $query_args['migrate_for_idc'] = true; |
| 137 | } |
| 138 | |
| 139 | $query_args['timeout'] = Jetpack_Sync_Settings::is_doing_cron() ? 30 : 15; |
| 140 | |
| 141 | /** |
| 142 | * Filters query parameters appended to the Sync request URL sent to WordPress.com. |
| 143 | * |
| 144 | * @since 4.7.0 |
| 145 | * |
| 146 | * @param array $query_args associative array of query parameters. |
| 147 | */ |
| 148 | $query_args = apply_filters( 'jetpack_sync_send_data_query_args', $query_args ); |
| 149 | |
| 150 | $url = add_query_arg( $query_args, Jetpack::xmlrpc_api_url() ); |
| 151 | |
| 152 | $rpc = new Jetpack_IXR_Client( |
| 153 | array( |
| 154 | 'url' => $url, |
| 155 | 'user_id' => JETPACK_MASTER_USER, |
| 156 | 'timeout' => $query_args['timeout'], |
| 157 | ) |
| 158 | ); |
| 159 | |
| 160 | $result = $rpc->query( 'jetpack.syncActions', $data ); |
| 161 | |
| 162 | if ( ! $result ) { |
| 163 | return $rpc->get_jetpack_error(); |
| 164 | } |
| 165 | |
| 166 | $response = $rpc->getResponse(); |
| 167 | |
| 168 | // Check if WordPress.com IDC mitigation blocked the sync request |
| 169 | if ( is_array( $response ) && isset( $response['error_code'] ) ) { |
| 170 | $error_code = $response['error_code']; |
| 171 | $allowed_idc_error_codes = array( |
| 172 | 'jetpack_url_mismatch', |
| 173 | 'jetpack_home_url_mismatch', |
| 174 | 'jetpack_site_url_mismatch', |
| 175 | ); |
| 176 | |
| 177 | if ( in_array( $error_code, $allowed_idc_error_codes ) ) { |
| 178 | Jetpack_Options::update_option( |
| 179 | 'sync_error_idc', |
| 180 | Jetpack::get_sync_error_idc_option( $response ) |
| 181 | ); |
| 182 | } |
| 183 | |
| 184 | return new WP_Error( |
| 185 | 'sync_error_idc', |
| 186 | esc_html__( 'Sync has been blocked from WordPress.com because it would cause an identity crisis', 'jetpack' ) |
| 187 | ); |
| 188 | } |
| 189 | |
| 190 | return $response; |
| 191 | } |
| 192 | |
| 193 | static function do_initial_sync() { |
| 194 | // Lets not sync if we are not suppose to. |
| 195 | if ( ! self::sync_allowed() ) { |
| 196 | return false; |
| 197 | } |
| 198 | |
| 199 | $initial_sync_config = array( |
| 200 | 'options' => true, |
| 201 | 'functions' => true, |
| 202 | 'constants' => true, |
| 203 | 'users' => array( get_current_user_id() ), |
| 204 | ); |
| 205 | |
| 206 | if ( is_multisite() ) { |
| 207 | $initial_sync_config['network_options'] = true; |
| 208 | } |
| 209 | |
| 210 | self::do_full_sync( $initial_sync_config ); |
| 211 | } |
| 212 | |
| 213 | static function do_full_sync( $modules = null ) { |
| 214 | if ( ! self::sync_allowed() ) { |
| 215 | return false; |
| 216 | } |
| 217 | |
| 218 | $full_sync_module = Jetpack_Sync_Modules::get_module( 'full-sync' ); |
| 219 | |
| 220 | if ( ! $full_sync_module ) { |
| 221 | return false; |
| 222 | } |
| 223 | |
| 224 | self::initialize_listener(); |
| 225 | |
| 226 | $full_sync_module->start( $modules ); |
| 227 | |
| 228 | return true; |
| 229 | } |
| 230 | |
| 231 | static function jetpack_cron_schedule( $schedules ) { |
| 232 | if ( ! isset( $schedules[ self::DEFAULT_SYNC_CRON_INTERVAL_NAME ] ) ) { |
| 233 | $schedules[ self::DEFAULT_SYNC_CRON_INTERVAL_NAME ] = array( |
| 234 | 'interval' => self::DEFAULT_SYNC_CRON_INTERVAL_VALUE, |
| 235 | 'display' => sprintf( |
| 236 | esc_html( _n( 'Every minute', 'Every %d minutes', intval( self::DEFAULT_SYNC_CRON_INTERVAL_VALUE / 60 ), 'jetpack' ) ), |
| 237 | intval( self::DEFAULT_SYNC_CRON_INTERVAL_VALUE / 60 ) |
| 238 | ), |
| 239 | ); |
| 240 | } |
| 241 | return $schedules; |
| 242 | } |
| 243 | |
| 244 | static function do_cron_sync() { |
| 245 | self::do_cron_sync_by_type( 'sync' ); |
| 246 | } |
| 247 | |
| 248 | static function do_cron_full_sync() { |
| 249 | self::do_cron_sync_by_type( 'full_sync' ); |
| 250 | } |
| 251 | |
| 252 | /** |
| 253 | * Try to send actions until we run out of things to send, |
| 254 | * or have to wait more than 15s before sending again, |
| 255 | * or we hit a lock or some other sending issue |
| 256 | * |
| 257 | * @param string $type Sync type. Can be `sync` or `full_sync`. |
| 258 | */ |
| 259 | static function do_cron_sync_by_type( $type ) { |
| 260 | if ( ! self::sync_allowed() || ( 'sync' !== $type && 'full_sync' !== $type ) ) { |
| 261 | return; |
| 262 | } |
| 263 | |
| 264 | self::initialize_sender(); |
| 265 | |
| 266 | $time_limit = Jetpack_Sync_Settings::get_setting( 'cron_sync_time_limit' ); |
| 267 | $start_time = time(); |
| 268 | |
| 269 | do { |
| 270 | $next_sync_time = self::$sender->get_next_sync_time( $type ); |
| 271 | |
| 272 | if ( $next_sync_time ) { |
| 273 | $delay = $next_sync_time - time() + 1; |
| 274 | if ( $delay > 15 ) { |
| 275 | break; |
| 276 | } elseif ( $delay > 0 ) { |
| 277 | sleep( $delay ); |
| 278 | } |
| 279 | } |
| 280 | |
| 281 | $result = 'full_sync' === $type ? self::$sender->do_full_sync() : self::$sender->do_sync(); |
| 282 | } while ( $result && ! is_wp_error( $result ) && ( $start_time + $time_limit ) > time() ); |
| 283 | } |
| 284 | |
| 285 | static function initialize_listener() { |
| 286 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-listener.php'; |
| 287 | self::$listener = Jetpack_Sync_Listener::get_instance(); |
| 288 | } |
| 289 | |
| 290 | static function initialize_sender() { |
| 291 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-sender.php'; |
| 292 | self::$sender = Jetpack_Sync_Sender::get_instance(); |
| 293 | |
| 294 | // bind the sending process |
| 295 | add_filter( 'jetpack_sync_send_data', array( __CLASS__, 'send_data' ), 10, 6 ); |
| 296 | } |
| 297 | |
| 298 | static function initialize_woocommerce() { |
| 299 | if ( false === class_exists( 'WooCommerce' ) ) { |
| 300 | return; |
| 301 | } |
| 302 | add_filter( 'jetpack_sync_modules', array( 'Jetpack_Sync_Actions', 'add_woocommerce_sync_module' ) ); |
| 303 | } |
| 304 | |
| 305 | static function add_woocommerce_sync_module( $sync_modules ) { |
| 306 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-module-woocommerce.php'; |
| 307 | $sync_modules[] = 'Jetpack_Sync_Module_WooCommerce'; |
| 308 | return $sync_modules; |
| 309 | } |
| 310 | |
| 311 | static function initialize_wp_super_cache() { |
| 312 | if ( false === function_exists( 'wp_cache_is_enabled' ) ) { |
| 313 | return; |
| 314 | } |
| 315 | add_filter( 'jetpack_sync_modules', array( 'Jetpack_Sync_Actions', 'add_wp_super_cache_sync_module' ) ); |
| 316 | } |
| 317 | |
| 318 | static function add_wp_super_cache_sync_module( $sync_modules ) { |
| 319 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-module-wp-super-cache.php'; |
| 320 | $sync_modules[] = 'Jetpack_Sync_Module_WP_Super_Cache'; |
| 321 | return $sync_modules; |
| 322 | } |
| 323 | |
| 324 | static function sanitize_filtered_sync_cron_schedule( $schedule ) { |
| 325 | $schedule = sanitize_key( $schedule ); |
| 326 | $schedules = wp_get_schedules(); |
| 327 | |
| 328 | // Make sure that the schedule has actually been registered using the `cron_intervals` filter. |
| 329 | if ( isset( $schedules[ $schedule ] ) ) { |
| 330 | return $schedule; |
| 331 | } |
| 332 | |
| 333 | return self::DEFAULT_SYNC_CRON_INTERVAL_NAME; |
| 334 | } |
| 335 | |
| 336 | static function get_start_time_offset( $schedule = '', $hook = '' ) { |
| 337 | $start_time_offset = is_multisite() |
| 338 | ? mt_rand( 0, ( 2 * self::DEFAULT_SYNC_CRON_INTERVAL_VALUE ) ) |
| 339 | : 0; |
| 340 | |
| 341 | /** |
| 342 | * Allows overriding the offset that the sync cron jobs will first run. This can be useful when scheduling |
| 343 | * cron jobs across multiple sites in a network. |
| 344 | * |
| 345 | * @since 4.5.0 |
| 346 | * |
| 347 | * @param int $start_time_offset |
| 348 | * @param string $hook |
| 349 | * @param string $schedule |
| 350 | */ |
| 351 | return intval( |
| 352 | apply_filters( |
| 353 | 'jetpack_sync_cron_start_time_offset', |
| 354 | $start_time_offset, |
| 355 | $hook, |
| 356 | $schedule |
| 357 | ) |
| 358 | ); |
| 359 | } |
| 360 | |
| 361 | static function maybe_schedule_sync_cron( $schedule, $hook ) { |
| 362 | if ( ! $hook ) { |
| 363 | return; |
| 364 | } |
| 365 | $schedule = self::sanitize_filtered_sync_cron_schedule( $schedule ); |
| 366 | |
| 367 | $start_time = time() + self::get_start_time_offset( $schedule, $hook ); |
| 368 | if ( ! wp_next_scheduled( $hook ) ) { |
| 369 | // Schedule a job to send pending queue items once a minute |
| 370 | wp_schedule_event( $start_time, $schedule, $hook ); |
| 371 | } elseif ( $schedule != wp_get_schedule( $hook ) ) { |
| 372 | // If the schedule has changed, update the schedule |
| 373 | wp_clear_scheduled_hook( $hook ); |
| 374 | wp_schedule_event( $start_time, $schedule, $hook ); |
| 375 | } |
| 376 | } |
| 377 | |
| 378 | static function clear_sync_cron_jobs() { |
| 379 | wp_clear_scheduled_hook( 'jetpack_sync_cron' ); |
| 380 | wp_clear_scheduled_hook( 'jetpack_sync_full_cron' ); |
| 381 | } |
| 382 | |
| 383 | static function init_sync_cron_jobs() { |
| 384 | add_filter( 'cron_schedules', array( __CLASS__, 'jetpack_cron_schedule' ) ); |
| 385 | |
| 386 | add_action( 'jetpack_sync_cron', array( __CLASS__, 'do_cron_sync' ) ); |
| 387 | add_action( 'jetpack_sync_full_cron', array( __CLASS__, 'do_cron_full_sync' ) ); |
| 388 | |
| 389 | /** |
| 390 | * Allows overriding of the default incremental sync cron schedule which defaults to once every 5 minutes. |
| 391 | * |
| 392 | * @since 4.3.2 |
| 393 | * |
| 394 | * @param string self::DEFAULT_SYNC_CRON_INTERVAL_NAME |
| 395 | */ |
| 396 | $incremental_sync_cron_schedule = apply_filters( 'jetpack_sync_incremental_sync_interval', self::DEFAULT_SYNC_CRON_INTERVAL_NAME ); |
| 397 | self::maybe_schedule_sync_cron( $incremental_sync_cron_schedule, 'jetpack_sync_cron' ); |
| 398 | |
| 399 | /** |
| 400 | * Allows overriding of the full sync cron schedule which defaults to once every 5 minutes. |
| 401 | * |
| 402 | * @since 4.3.2 |
| 403 | * |
| 404 | * @param string self::DEFAULT_SYNC_CRON_INTERVAL_NAME |
| 405 | */ |
| 406 | $full_sync_cron_schedule = apply_filters( 'jetpack_sync_full_sync_interval', self::DEFAULT_SYNC_CRON_INTERVAL_NAME ); |
| 407 | self::maybe_schedule_sync_cron( $full_sync_cron_schedule, 'jetpack_sync_full_cron' ); |
| 408 | } |
| 409 | |
| 410 | static function cleanup_on_upgrade( $new_version = null, $old_version = null ) { |
| 411 | if ( wp_next_scheduled( 'jetpack_sync_send_db_checksum' ) ) { |
| 412 | wp_clear_scheduled_hook( 'jetpack_sync_send_db_checksum' ); |
| 413 | } |
| 414 | |
| 415 | $is_new_sync_upgrade = version_compare( $old_version, '4.2', '>=' ); |
| 416 | if ( ! empty( $old_version ) && $is_new_sync_upgrade && version_compare( $old_version, '4.5', '<' ) ) { |
| 417 | require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php'; |
| 418 | self::clear_sync_cron_jobs(); |
| 419 | Jetpack_Sync_Settings::update_settings( |
| 420 | array( |
| 421 | 'render_filtered_content' => Jetpack_Sync_Defaults::$default_render_filtered_content, |
| 422 | ) |
| 423 | ); |
| 424 | } |
| 425 | } |
| 426 | |
| 427 | static function get_sync_status() { |
| 428 | self::initialize_sender(); |
| 429 | |
| 430 | $sync_module = Jetpack_Sync_Modules::get_module( 'full-sync' ); |
| 431 | $queue = self::$sender->get_sync_queue(); |
| 432 | $full_queue = self::$sender->get_full_sync_queue(); |
| 433 | $cron_timestamps = array_keys( _get_cron_array() ); |
| 434 | $next_cron = $cron_timestamps[0] - time(); |
| 435 | |
| 436 | $full_sync_status = ( $sync_module ) ? $sync_module->get_status() : array(); |
| 437 | return array_merge( |
| 438 | $full_sync_status, |
| 439 | array( |
| 440 | 'cron_size' => count( $cron_timestamps ), |
| 441 | 'next_cron' => $next_cron, |
| 442 | 'queue_size' => $queue->size(), |
| 443 | 'queue_lag' => $queue->lag(), |
| 444 | 'queue_next_sync' => ( self::$sender->get_next_sync_time( 'sync' ) - microtime( true ) ), |
| 445 | 'full_queue_size' => $full_queue->size(), |
| 446 | 'full_queue_lag' => $full_queue->lag(), |
| 447 | 'full_queue_next_sync' => ( self::$sender->get_next_sync_time( 'full_sync' ) - microtime( true ) ), |
| 448 | ) |
| 449 | ); |
| 450 | } |
| 451 | } |
| 452 | |
| 453 | // Check for WooCommerce support |
| 454 | add_action( 'plugins_loaded', array( 'Jetpack_Sync_Actions', 'initialize_woocommerce' ), 5 ); |
| 455 | |
| 456 | // Check for WP Super Cache |
| 457 | add_action( 'plugins_loaded', array( 'Jetpack_Sync_Actions', 'initialize_wp_super_cache' ), 5 ); |
| 458 | |
| 459 | /* |
| 460 | * Init after plugins loaded and before the `init` action. This helps with issues where plugins init |
| 461 | * with a high priority or sites that use alternate cron. |
| 462 | */ |
| 463 | add_action( 'plugins_loaded', array( 'Jetpack_Sync_Actions', 'init' ), 90 ); |
| 464 | |
| 465 | |
| 466 | |
| 467 | // We need to define this here so that it's hooked before `updating_jetpack_version` is called |
| 468 | add_action( 'updating_jetpack_version', array( 'Jetpack_Sync_Actions', 'cleanup_on_upgrade' ), 10, 2 ); |
| 469 | add_action( 'jetpack_user_authorized', array( 'Jetpack_Sync_Actions', 'do_initial_sync' ), 10, 0 ); |
| 470 | |
| 471 |