← All changes | cache/class-wp-optimize-page-cache-preloader.php +192 -37 3.3.2 → 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.
		@@ -292,12 +361,12 @@
292	361
293	362	// if we get error then
294	363	// sometimes returns error due to timeout
295	364	if (is_wp_error($response)) {
296		- $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
297	366
298	367	// if response is empty then try load from file.
299		- if (empty($response) && '' == $sitemap_url) {
	368	+ if (empty($response)) {
300	369	$sitemap_file = $this->get_local_sitemap_file();
301	370
302	371	if (is_file($sitemap_file)) {
303	372	$response = file_get_contents($sitemap_file);
		@@ -374,9 +443,9 @@
374	443	// if there any separators add urls for each page
375	444	if (count($matches[0])) {
376	445	$prefix = strpos($permalink, '?') ? '&page=' : '';
377	446	for ($page = 0; $page < count($matches[0]); $page++) {
378		- if ('' != $prefix) {
	447	+ if ('' !== $prefix) {
379	448	$urls[] = $permalink . $prefix . ($page+2);
380	449	} else {
381	450	$urls[] = trailingslashit($permalink) . ($page+2);
382	451	}
		@@ -414,9 +483,9 @@
414	483	* @return bool
415	484	*/
416	485	public function is_domain_mapping_enabled() {
417	486	// SUNRISE constant is defined with installation WordPress MU Domain Mapping plugin.
418		- $enabled = is_multisite() && defined('SUNRISE') && 'on' == strtolower(SUNRISE);
	487	+ $enabled = is_multisite() && defined('SUNRISE') && 'on' === strtolower(SUNRISE);
419	488
420	489	/**
421	490	* Filters if Multisite Domain mapping is enabled.
422	491	* Currently, we can only detect if the WordPress MU Domain Mapping plugin is in use.
		@@ -437,11 +506,11 @@
437	506
438	507	$domain = '';
439	508	$multisite_plugin_table_name = $wpdb->base_prefix.'domain_mapping';
440	509	// Check if table exists
441		- 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) {
442	511	// This table created in WordPress MU Domain Mapping plugin.
443		- $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);
444	513	if (!empty($row)) {
445	514	$domain = $row['domain'];
446	515	}
447	516	} else {
		@@ -458,12 +527,41 @@
458	527	return apply_filters('wpo_get_mapped_domain', $domain, $blog_id);
459	528	}
460	529
461	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	+ /**
462	560	* Captures and logs any interesting messages
463	561	*
464		- * @param String $message - the error message
465		- * @param String $error_type - the error type
	562	+ * @param string $message - the error message
	563	+ * @param string $error_type - the error type
466	564	*/
467	565	public function log($message, $error_type = 'info') {
468	566
469	567	if (isset($this->loggers)) {
		@@ -518,16 +616,16 @@
518	616	continue;
519	617	}
520	618
521	619	if ($this->should_regenerate_file($file_path, $preload_type)) {
522		- // delefe the expired cache file
523		- unlink($file_path);
	620	+ // delete the expired cache file
	621	+ wp_delete_file($file_path);
524	622	$regenerate_count++;
525	623	}
526	624	}
527	625
528	626	// if 0 == $regenerate_count, nothing all the expected files exist, and none were deleted.
529		- return 0 == $regenerate_count;
	627	+ return 0 === $regenerate_count;
530	628	}
531	629
532	630	/**
533	631	* Determine if a file should be regenerated
		@@ -551,9 +649,9 @@
551	649	// Sets the variables once per request:
552	650	if (null === $is_preloader_scheduled) {
553	651	$is_preloader_scheduled = WPO_Cache_Config::instance()->get_option('enable_schedule_preload');
554	652	$schedule_type = WPO_Cache_Config::instance()->get_option('preload_schedule_type');
555		- $lifespan = WPO_Cache_Config::instance()->get_option('page_cache_length');
	653	+ $lifespan = (int) WPO_Cache_Config::instance()->get_option('page_cache_length');
556	654	$schedule_interval = $this->get_schedule_interval($schedule_type);
557	655
558	656	/**
559	657	* Expiry threshold: the current file will be considered stale if within the threshold. Default: 600s (10min)
		@@ -575,9 +673,9 @@
575	673	*/
576	674	$regenerate_file_when_no_expiry_date = apply_filters('wpo_regenerate_file_when_no_expiry_date', true);
577	675	}
578	676
579		- 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)) {
580	678	$result = true;
581	679	} else {
582	680
583	681	$modified_time = (int) filemtime($path);
		@@ -582,9 +680,9 @@
582	680
583	681	$modified_time = (int) filemtime($path);
584	682
585	683	// cache lifespan is set.
586		- if (0 != $lifespan) {
	684	+ if (0 !== $lifespan) {
587	685	$expiry_time = $modified_time + $lifespan - $lifespan_expiry_threshold;
588	686	$result = time() > $expiry_time;
589	687	} elseif ($is_preloader_scheduled) {
590	688	$expiry_time = $modified_time + $schedule_interval - $lifespan_expiry_threshold;
		@@ -599,8 +697,10 @@
599	697	}
600	698
601	699	/**
602	700	* Add preloader headers
	701	+ *
	702	+ * @param array $headers Preload headers
603	703	*/
604	704	public function preload_headers($headers) {
605	705	$headers['X-WP-Optimize-Cache-Preload'] = 'Yes';
606	706	return $headers;
		@@ -628,13 +728,25 @@
628	728	'success' => false,
629	729	'error' => __('Probably page cache preload is running already.', 'wp-optimize')
630	730	);
631	731	}
632		-
	732	+
	733	+ /**
	734	+ * Returns preload data
	735	+ *
	736	+ * @return array
	737	+ */
633	738	protected function get_preload_data() {
634	739	return WP_Optimize()->get_page_cache()->get_cache_size();
635	740	}
636		-
	741	+
	742	+ /**
	743	+ * Returns preloading message
	744	+ *
	745	+ * @param array $cache_size
	746	+ *
	747	+ * @return array
	748	+ */
637	749	protected function get_preloading_message($cache_size) {
638	750	return array(
639	751	'done' => false,
640	752	'message' => __('Loading URLs...', 'wp-optimize'),
		@@ -641,18 +753,34 @@
641	753	'size' => WP_Optimize()->format_size($cache_size['size']),
642	754	'file_count' => $cache_size['file_count']
643	755	);
644	756	}
645		-
	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	+ */
646	766	protected function get_last_preload_message($cache_size, $last_preload_time_str) {
647	767	return array(
648	768	'done' => true,
	769	+ // translators: %s is the last preload time
649	770	'message' => sprintf(__('Last preload finished at %s', 'wp-optimize'), $last_preload_time_str),
650	771	'size' => WP_Optimize()->format_size($cache_size['size']),
651	772	'file_count' => $cache_size['file_count']
652	773	);
653	774	}
654		-
	775	+
	776	+ /**
	777	+ * Returns preload success message
	778	+ *
	779	+ * @param array $cache_size
	780	+ *
	781	+ * @return array
	782	+ */
655	783	protected function get_preload_success_message($cache_size) {
656	784	return array(
657	785	'done' => true,
658	786	'size' => WP_Optimize()->format_size($cache_size['size']),
		@@ -658,9 +786,18 @@
658	786	'size' => WP_Optimize()->format_size($cache_size['size']),
659	787	'file_count' => $cache_size['file_count']
660	788	);
661	789	}
662		-
	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	+ */
663	800	protected function get_preload_progress_message($cache_size, $preloaded_message, $preload_resuming_in) {
664	801	return array(
665	802	'done' => false,
666	803	'message' => $preloaded_message,
		@@ -668,7 +805,25 @@
668	805	'file_count' => $cache_size['file_count'],
669	806	'resume_in' => $preload_resuming_in
670	807	);
671	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	+ }
672	829	}
673		-
674		-WP_Optimize_Page_Cache_Preloader::instance();