PluginProbe
WP-Optimize – Cache, Compress images, Minify & Clean database to boost page speed & performance / 4.7.0
WP-Optimize – Cache, Compress images, Minify & Clean database to boost page speed & performance v4.7.0
4.7.0 4.6.1 4.6.0 4.5.5 4.5.4 4.5.3 4.5.2 3.2.20 3.2.21 3.2.22 3.2.3 3.2.5 3.2.6 3.2.7 3.2.9 3.3.0 3.3.1 3.3.2 3.4.0 3.4.1 3.4.2 3.5.0 3.6.0 3.7.0 3.7.1 All 111 releases
← All changes | cache/class-wp-optimize-page-cache-preloader.php +196 -38 3.2.20 → 4.7.0 View file →
@@ -6,14 +6,30 @@
6 6 require_once(WPO_PLUGIN_MAIN_PATH . 'cache/class-wpo-load-url-task.php');
7 7 }
8 8
9 9 class WP_Optimize_Page_Cache_Preloader extends WP_Optimize_Preloader {
10 -
10 +
11 + /**
12 + * @var string
13 + */
11 14 protected $preload_type = 'page_cache';
12 -
15 +
16 + /**
17 + * @var string
18 + */
13 19 protected $task_type = 'load-url-task';
20 +
21 + /**
22 + * @var null | WP_Optimize_Page_Cache_Preloader
23 + */
24 + static protected $_instance = null;
14 25
15 - static protected $_instance = null;
26 + /**
27 + * List of URLs for which a task will be created to preload them into cache
28 + *
29 + * @var array
30 + */
31 + private $url_preload_list = array();
16 32
17 33 /**
18 34 * WP_Optimize_Page_Cache_Preloader constructor.
19 35 */
@@ -20,8 +36,9 @@
20 36 public function __construct() {
21 37 parent::__construct();
22 38
23 39 add_action('wpo_page_cache_schedule_preload', array($this, 'run_scheduled_cache_preload'));
40 + add_action('wpo_page_cache_run_preload', array($this, 'run_preload_cron_job'));
24 41 add_filter('wpo_preload_headers', array($this, 'preload_headers'));
25 42 }
26 43
27 44 /**
@@ -41,8 +58,9 @@
41 58 */
42 59 public function cache_settings_updated($new_settings, $previous_settings) {
43 60 if (!$new_settings['enable_page_caching']) {
44 61 wp_clear_scheduled_hook('wpo_page_cache_schedule_preload');
62 + wp_clear_scheduled_hook('wpo_page_cache_run_preload');
45 63 $this->delete_preload_continue_action();
46 64 return;
47 65 }
48 66
@@ -49,15 +67,21 @@
49 67 if (!empty($new_settings['enable_schedule_preload'])) {
50 68
51 69 $last_schedule_type = $previous_settings['preload_schedule_type'];
52 70
71 + $last_use_nighttime = (int) $this->options->get_option('page_cache_schedule_preload_nighttime');
72 + // By default, we schedule preload events to the nighttime.
73 + $use_nighttime = apply_filters('wpo_page_cache_schedule_preload_use_nighttime', 1);
74 +
75 + $this->options->update_option('page_cache_schedule_preload_nighttime', $use_nighttime);
76 +
53 77 if (wp_next_scheduled('wpo_page_cache_schedule_preload')) {
54 78 // if already scheduled this schedule type
55 - if ($new_settings['preload_schedule_type'] == $last_schedule_type) {
79 + if ($new_settings['preload_schedule_type'] === $last_schedule_type && ($last_use_nighttime === $use_nighttime)) {
56 80 // If the schedule type is cache lifespan, check if the cache lifespan changed.
57 - if ('wpo_use_cache_lifespan' == $new_settings['preload_schedule_type']) {
81 + if ('wpo_use_cache_lifespan' === $new_settings['preload_schedule_type']) {
58 82 // Else, if the settings cache lifespan settings haven't changed, returns
59 - if ($new_settings['page_cache_length_value'] == $previous_settings['page_cache_length_value'] && $new_settings['page_cache_length_unit'] == $previous_settings['page_cache_length_unit']) {
83 + if ($new_settings['page_cache_length_value'] === $previous_settings['page_cache_length_value'] && $new_settings['page_cache_length_unit'] === $previous_settings['page_cache_length_unit']) {
60 84 return;
61 85 }
62 86 } else {
63 87 return;
@@ -65,10 +89,17 @@
65 89 }
66 90 // clear currently scheduled preload action.
67 91 wp_clear_scheduled_hook('wpo_page_cache_schedule_preload');
68 92 }
93 +
69 94 // schedule preload action.
70 - wp_schedule_event((time() + $this->get_schedule_interval($new_settings['preload_schedule_type'])), $new_settings['preload_schedule_type'], 'wpo_page_cache_schedule_preload');
95 + $timestamp = time() + $this->get_schedule_interval($new_settings['preload_schedule_type']);
96 +
97 + if ($use_nighttime) {
98 + $timestamp = $this->make_nighttime($timestamp);
99 + }
100 +
101 + wp_schedule_event($timestamp, $new_settings['preload_schedule_type'], 'wpo_page_cache_schedule_preload');
71 102 } else {
72 103 wp_clear_scheduled_hook('wpo_page_cache_schedule_preload');
73 104 }
74 105
@@ -85,13 +116,32 @@
85 116
86 117 // schedule preload action if need.
87 118 if ($this->is_scheduled_preload_enabled()) {
88 119 $preload_schedule_type = $this->get_cache_config('preload_schedule_type');
89 - wp_schedule_event(time() + $this->get_schedule_interval($preload_schedule_type), $preload_schedule_type, 'wpo_page_cache_schedule_preload');
120 + // By default, we schedule preload events to the nighttime.
121 + $use_nighttime = apply_filters('wpo_page_cache_schedule_preload_use_nighttime', 1);
122 +
123 + $timestamp = time() + $this->get_schedule_interval($preload_schedule_type);
124 + if ($use_nighttime) {
125 + $timestamp = $this->make_nighttime($timestamp);
126 + }
127 +
128 + wp_schedule_event($timestamp, $preload_schedule_type, 'wpo_page_cache_schedule_preload');
90 129 }
91 130 }
92 131
93 132 /**
133 + * Reschedule preload action on plugin activation if page cache enabled.
134 + *
135 + * @return void
136 + */
137 + public function maybe_reschedule_preload_on_activation() {
138 + if ($this->get_cache_config('enable_page_caching')) {
139 + $this->reschedule_preload();
140 + }
141 + }
142 +
143 + /**
94 144 * Check if scheduled preload enabled.
95 145 *
96 146 * @return bool
97 147 */
@@ -108,9 +158,9 @@
108 158 $schedule_type = WPO_Cache_Config::instance()->get_option('preload_schedule_type');
109 159 if (!$schedule_type) return;
110 160
111 161 // Don't run preload if cache lifespan option enabled and cache not expired yet.
112 - if ('wpo_use_cache_lifespan' == $schedule_type) {
162 + if ('wpo_use_cache_lifespan' === $schedule_type) {
113 163
114 164 /**
115 165 * Filters the allowed time difference between the cache exiry and the current time, in seconds.
116 166 * If the cache expires in less than $allowed_time_difference, preload. Otherwise leave it.
@@ -130,12 +180,30 @@
130 180
131 181 $this->run();
132 182 }
133 183
184 + /**
185 + * Runs manual cache preload and reschedules if scheduled preload is enabled
186 + *
187 + * @return void
188 + */
189 + public function run_preload_cron_job() {
190 + $wpo_page_cache = WP_Optimize()->get_page_cache();
134 191
192 + if ($this->is_scheduled_preload_enabled()) {
193 + $this->cancel_preload();
194 + $this->reschedule_preload();
195 + $this->run('scheduled', null, true);
196 + } elseif ($wpo_page_cache->should_auto_preload_purged_contents()) {
197 + $this->run('manual', null, true);
198 + }
199 + }
200 +
135 201 /**
136 202 * Get cache config option value.
137 203 *
204 + * @param string $option
205 + *
138 206 * @return mixed
139 207 */
140 208 public function get_cache_config($option) {
141 209 static $config = null;
@@ -161,10 +229,12 @@
161 229 if (!empty($urls)) {
162 230
163 231 $this->log(__('Creating tasks for preload site urls.', 'wp-optimize'));
164 232
233 + $wpo_cache_specific_urls_only = wpo_cache_specific_urls_only();
234 +
165 235 foreach ($urls as $url) {
166 - if (wpo_url_in_exceptions($url)) continue;
236 + if (!$wpo_cache_specific_urls_only && wpo_url_in_exceptions($url)) continue;
167 237
168 238 if ($this->url_is_already_cached($url, $type)) {
169 239 continue;
170 240 }
@@ -172,11 +242,8 @@
172 242 // this description is being used for internal purposes.
173 243 $description = 'Preload - '.$url;
174 244 $options = array('url' => $url, 'preload_type' => $type, 'anonymous_user_allowed' => (defined('DOING_CRON') && DOING_CRON) || (defined('WP_CLI') && WP_CLI));
175 245
176 - if (!class_exists('WP_Optimize_Load_Url_Task')) {
177 - require_once WPO_PLUGIN_MAIN_PATH . 'cache/class-wpo-load-url-task.php';
178 - }
179 246 WP_Optimize_Load_Url_Task::create_task($this->task_type, $description, $options, 'WP_Optimize_Load_Url_Task');
180 247 }
181 248
182 249 $this->log(__('Tasks for preload site urls created.', 'wp-optimize'));
@@ -200,9 +267,9 @@
200 267 if (!$is_mobile_caching_enabled) return;
201 268
202 269 $mobile_args = array(
203 270 'httpversion' => '1.1',
204 - 'user-agent' => 'Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1',
271 + 'user-agent' => WP_Optimize_Utils::get_user_agent('mobile'),
205 272 'timeout' => 10,
206 273 'headers' => apply_filters('wpo_preload_headers', array()),
207 274 );
208 275
@@ -224,9 +291,9 @@
224 291 if (!apply_filters('wpo_should_preload_amp', false, $url)) return;
225 292
226 293 $amp_args = array(
227 294 'httpversion' => '1.1',
228 - 'user-agent' => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/62.0.3202.89 Safari/537.36',
295 + 'user-agent' => WP_Optimize_Utils::get_user_agent(),
229 296 'timeout' => 10,
230 297 'headers' => array(
231 298 'X-WP-Optimize-Cache-Preload' => 'Yes',
232 299 ),
@@ -256,8 +323,9 @@
256 323 $urls = $this->get_post_urls();
257 324 $this->options->update_option('wpo_last_page_cache_preload_type', 'posts');
258 325 }
259 326
327 + // translators: %d: Number of URLs found
260 328 $this->log(sprintf(_n('%d url found.', '%d urls found.', count($urls), 'wp-optimize'), count($urls)));
261 329
262 330 /**
263 331 * Filter the URLs which will be preloaded
@@ -264,9 +332,10 @@
264 332 *
265 333 * @param array $urls
266 334 * @return array
267 335 */
268 - return apply_filters('wpo_preload_get_site_urls', $urls);
336 + $filtered_urls = apply_filters('wpo_preload_get_site_urls', $urls);
337 + return is_array($filtered_urls) ? $filtered_urls : $urls;
269 338 }
270 339
271 340 /**
272 341 * Loads sitemap file and returns list of urls.
@@ -290,16 +359,19 @@
290 359 // load sitemap file.
291 360 $response = wp_remote_get($sitemap_url, array('timeout' => 30));
292 361
293 362 // if we get error then
363 + // sometimes returns error due to timeout
294 364 if (is_wp_error($response)) {
295 - $response = file_get_contents($sitemap_url);
365 + $response = @file_get_contents($sitemap_url); // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- suppress warnings when there is network error
296 366
297 367 // if response is empty then try load from file.
298 - if (empty($response) && '' == $sitemap_url) {
368 + if (empty($response)) {
299 369 $sitemap_file = $this->get_local_sitemap_file();
300 370
301 - $response = file_get_contents($sitemap_file);
371 + if (is_file($sitemap_file)) {
372 + $response = file_get_contents($sitemap_file);
373 + }
302 374 }
303 375
304 376 if (empty($response)) return $urls;
305 377
@@ -371,9 +443,9 @@
371 443 // if there any separators add urls for each page
372 444 if (count($matches[0])) {
373 445 $prefix = strpos($permalink, '?') ? '&page=' : '';
374 446 for ($page = 0; $page < count($matches[0]); $page++) {
375 - if ('' != $prefix) {
447 + if ('' !== $prefix) {
376 448 $urls[] = $permalink . $prefix . ($page+2);
377 449 } else {
378 450 $urls[] = trailingslashit($permalink) . ($page+2);
379 451 }
@@ -411,9 +483,9 @@
411 483 * @return bool
412 484 */
413 485 public function is_domain_mapping_enabled() {
414 486 // SUNRISE constant is defined with installation WordPress MU Domain Mapping plugin.
415 - $enabled = is_multisite() && defined('SUNRISE') && 'on' == strtolower(SUNRISE);
487 + $enabled = is_multisite() && defined('SUNRISE') && 'on' === strtolower(SUNRISE);
416 488
417 489 /**
418 490 * Filters if Multisite Domain mapping is enabled.
419 491 * Currently, we can only detect if the WordPress MU Domain Mapping plugin is in use.
@@ -434,11 +506,11 @@
434 506
435 507 $domain = '';
436 508 $multisite_plugin_table_name = $wpdb->base_prefix.'domain_mapping';
437 509 // Check if table exists
438 - if ($wpdb->get_var("SHOW TABLES LIKE '$multisite_plugin_table_name'") != $multisite_plugin_table_name) {
510 + if ($wpdb->get_var("SHOW TABLES LIKE '" . esc_sql($multisite_plugin_table_name) . "'") !== $multisite_plugin_table_name) {
439 511 // This table created in WordPress MU Domain Mapping plugin.
440 - $row = $wpdb->get_row("SELECT `domain` FROM {$multisite_plugin_table_name} WHERE `blog_id` = {$blog_id} AND `active` = 1", ARRAY_A);
512 + $row = $wpdb->get_row($wpdb->prepare("SELECT `domain` FROM " .esc_sql($multisite_plugin_table_name) . " WHERE `blog_id` = %d AND `active` = %d", $blog_id, 1), ARRAY_A);
441 513 if (!empty($row)) {
442 514 $domain = $row['domain'];
443 515 }
444 516 } else {
@@ -455,12 +527,41 @@
455 527 return apply_filters('wpo_get_mapped_domain', $domain, $blog_id);
456 528 }
457 529
458 530 /**
531 + * Actually add the URLs to be preloaded into cache during `shutdown` hook
532 + *
533 + * @return void
534 + */
535 + public function create_tasks_for_auto_preload_urls() {
536 + $wpo_cache_specific_urls_only = wpo_cache_specific_urls_only();
537 + foreach ($this->url_preload_list as $url) {
538 + if (!$wpo_cache_specific_urls_only && wpo_url_in_exceptions($url)) continue;
539 +
540 + $description = 'Preload - '.$url;
541 + $options = array('url' => $url, 'preload_type' => 'manual', 'anonymous_user_allowed' => (defined('DOING_CRON') && DOING_CRON) || (defined('WP_CLI') && WP_CLI));
542 +
543 + WP_Optimize_Load_Url_Task::create_task($this->task_type, $description, $options, 'WP_Optimize_Load_Url_Task');
544 + }
545 +
546 + $this->run('manual', null, true);
547 + }
548 +
549 + /**
550 + * Prepare the URL list that will need to be tasked to be preloaded
551 + *
552 + * @param string $url The URL to be preloaded
553 + * @return void
554 + */
555 + public function add_url_to_preload_list($url) {
556 + $this->url_preload_list[] = $url;
557 + }
558 +
559 + /**
459 560 * Captures and logs any interesting messages
460 561 *
461 - * @param String $message - the error message
462 - * @param String $error_type - the error type
562 + * @param string $message - the error message
563 + * @param string $error_type - the error type
463 564 */
464 565 public function log($message, $error_type = 'info') {
465 566
466 567 if (isset($this->loggers)) {
@@ -515,16 +616,16 @@
515 616 continue;
516 617 }
517 618
518 619 if ($this->should_regenerate_file($file_path, $preload_type)) {
519 - // delefe the expired cache file
520 - unlink($file_path);
620 + // delete the expired cache file
621 + wp_delete_file($file_path);
521 622 $regenerate_count++;
522 623 }
523 624 }
524 625
525 626 // if 0 == $regenerate_count, nothing all the expected files exist, and none were deleted.
526 - return 0 == $regenerate_count;
627 + return 0 === $regenerate_count;
527 628 }
528 629
529 630 /**
530 631 * Determine if a file should be regenerated
@@ -548,9 +649,9 @@
548 649 // Sets the variables once per request:
549 650 if (null === $is_preloader_scheduled) {
550 651 $is_preloader_scheduled = WPO_Cache_Config::instance()->get_option('enable_schedule_preload');
551 652 $schedule_type = WPO_Cache_Config::instance()->get_option('preload_schedule_type');
552 - $lifespan = WPO_Cache_Config::instance()->get_option('page_cache_length');
653 + $lifespan = (int) WPO_Cache_Config::instance()->get_option('page_cache_length');
553 654 $schedule_interval = $this->get_schedule_interval($schedule_type);
554 655
555 656 /**
556 657 * Expiry threshold: the current file will be considered stale if within the threshold. Default: 600s (10min)
@@ -572,9 +673,9 @@
572 673 */
573 674 $regenerate_file_when_no_expiry_date = apply_filters('wpo_regenerate_file_when_no_expiry_date', true);
574 675 }
575 676
576 - if (($always_regenerate_file_if_preload_is_manual && 'manual' == $preload_type) || ($always_regenerate_file_if_preload_is_scheduled && 'scheduled' == $preload_type)) {
677 + if (($always_regenerate_file_if_preload_is_manual && 'manual' === $preload_type) || ($always_regenerate_file_if_preload_is_scheduled && 'scheduled' === $preload_type)) {
577 678 $result = true;
578 679 } else {
579 680
580 681 $modified_time = (int) filemtime($path);
@@ -579,9 +680,9 @@
579 680
580 681 $modified_time = (int) filemtime($path);
581 682
582 683 // cache lifespan is set.
583 - if (0 != $lifespan) {
684 + if (0 !== $lifespan) {
584 685 $expiry_time = $modified_time + $lifespan - $lifespan_expiry_threshold;
585 686 $result = time() > $expiry_time;
586 687 } elseif ($is_preloader_scheduled) {
587 688 $expiry_time = $modified_time + $schedule_interval - $lifespan_expiry_threshold;
@@ -596,8 +697,10 @@
596 697 }
597 698
598 699 /**
599 700 * Add preloader headers
701 + *
702 + * @param array $headers Preload headers
600 703 */
601 704 public function preload_headers($headers) {
602 705 $headers['X-WP-Optimize-Cache-Preload'] = 'Yes';
603 706 return $headers;
@@ -625,13 +728,25 @@
625 728 'success' => false,
626 729 'error' => __('Probably page cache preload is running already.', 'wp-optimize')
627 730 );
628 731 }
629 -
732 +
733 + /**
734 + * Returns preload data
735 + *
736 + * @return array
737 + */
630 738 protected function get_preload_data() {
631 739 return WP_Optimize()->get_page_cache()->get_cache_size();
632 740 }
633 -
741 +
742 + /**
743 + * Returns preloading message
744 + *
745 + * @param array $cache_size
746 + *
747 + * @return array
748 + */
634 749 protected function get_preloading_message($cache_size) {
635 750 return array(
636 751 'done' => false,
637 752 'message' => __('Loading URLs...', 'wp-optimize'),
@@ -638,18 +753,34 @@
638 753 'size' => WP_Optimize()->format_size($cache_size['size']),
639 754 'file_count' => $cache_size['file_count']
640 755 );
641 756 }
642 -
757 +
758 + /**
759 + * Returns last preload message
760 + *
761 + * @param array $cache_size
762 + * @param string $last_preload_time_str
763 + *
764 + * @return array
765 + */
643 766 protected function get_last_preload_message($cache_size, $last_preload_time_str) {
644 767 return array(
645 768 'done' => true,
769 + // translators: %s is the last preload time
646 770 'message' => sprintf(__('Last preload finished at %s', 'wp-optimize'), $last_preload_time_str),
647 771 'size' => WP_Optimize()->format_size($cache_size['size']),
648 772 'file_count' => $cache_size['file_count']
649 773 );
650 774 }
651 -
775 +
776 + /**
777 + * Returns preload success message
778 + *
779 + * @param array $cache_size
780 + *
781 + * @return array
782 + */
652 783 protected function get_preload_success_message($cache_size) {
653 784 return array(
654 785 'done' => true,
655 786 'size' => WP_Optimize()->format_size($cache_size['size']),
@@ -655,9 +786,18 @@
655 786 'size' => WP_Optimize()->format_size($cache_size['size']),
656 787 'file_count' => $cache_size['file_count']
657 788 );
658 789 }
659 -
790 +
791 + /**
792 + * Returns preload progress message
793 + *
794 + * @param array $cache_size
795 + * @param string $preloaded_message
796 + * @param int $preload_resuming_in
797 + *
798 + * @return array
799 + */
660 800 protected function get_preload_progress_message($cache_size, $preloaded_message, $preload_resuming_in) {
661 801 return array(
662 802 'done' => false,
663 803 'message' => $preloaded_message,
@@ -665,7 +805,25 @@
665 805 'file_count' => $cache_size['file_count'],
666 806 'resume_in' => $preload_resuming_in
667 807 );
668 808 }
809 +
810 + /**
811 + * Shifts the given timestamp to nighttime.
812 + *
813 + * @param int $time
814 + *
815 + * @return int
816 + */
817 + private function make_nighttime($time) {
818 +
819 + $gmt_offset = WP_Optimize_Utils::get_gmt_offset();
820 +
821 + // Set time to random time from 1 a.m. to 4:59 a.m.
822 + $random_time = sprintf('%02d:%02d', wp_rand(1, 4), wp_rand(0, 59));
823 + $nighttime = strtotime(gmdate("Y-m-d {$random_time}:00", $time)) - $gmt_offset;
824 +
825 + if ($nighttime < time()) $nighttime += 24 * 3600;
826 +
827 + return $nighttime;
828 + }
669 829 }
670 -
671 -WP_Optimize_Page_Cache_Preloader::instance();