← All changes | cache/class-wp-optimize-page-cache-preloader.php +205 -54 3.2.9 → 4.7.0 View file →

		@@ -1,16 +1,35 @@
1	1	<?php
2	2
3	3	if (!defined('ABSPATH')) die('No direct access allowed');
4	4
	5	+if (!class_exists('WP_Optimize_Load_Url_Task')) {
	6	+ require_once(WPO_PLUGIN_MAIN_PATH . 'cache/class-wpo-load-url-task.php');
	7	+}
5	8
6	9	class WP_Optimize_Page_Cache_Preloader extends WP_Optimize_Preloader {
7		-
	10	+
	11	+ /**
	12	+ * @var string
	13	+ */
8	14	protected $preload_type = 'page_cache';
9		-
	15	+
	16	+ /**
	17	+ * @var string
	18	+ */
10	19	protected $task_type = 'load-url-task';
	20	+
	21	+ /**
	22	+ * @var null | WP_Optimize_Page_Cache_Preloader
	23	+ */
	24	+ static protected $_instance = null;
11	25
12		- 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();
13	32
14	33	/**
15	34	* WP_Optimize_Page_Cache_Preloader constructor.
16	35	*/
		@@ -17,8 +36,9 @@
17	36	public function __construct() {
18	37	parent::__construct();
19	38
20	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'));
21	41	add_filter('wpo_preload_headers', array($this, 'preload_headers'));
22	42	}
23	43
24	44	/**
		@@ -38,8 +58,9 @@
38	58	*/
39	59	public function cache_settings_updated($new_settings, $previous_settings) {
40	60	if (!$new_settings['enable_page_caching']) {
41	61	wp_clear_scheduled_hook('wpo_page_cache_schedule_preload');
	62	+ wp_clear_scheduled_hook('wpo_page_cache_run_preload');
42	63	$this->delete_preload_continue_action();
43	64	return;
44	65	}
45	66
		@@ -46,15 +67,21 @@
46	67	if (!empty($new_settings['enable_schedule_preload'])) {
47	68
48	69	$last_schedule_type = $previous_settings['preload_schedule_type'];
49	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	+
50	77	if (wp_next_scheduled('wpo_page_cache_schedule_preload')) {
51	78	// if already scheduled this schedule type
52		- if ($new_settings['preload_schedule_type'] == $last_schedule_type) {
	79	+ if ($new_settings['preload_schedule_type'] === $last_schedule_type && ($last_use_nighttime === $use_nighttime)) {
53	80	// If the schedule type is cache lifespan, check if the cache lifespan changed.
54		- if ('wpo_use_cache_lifespan' == $new_settings['preload_schedule_type']) {
	81	+ if ('wpo_use_cache_lifespan' === $new_settings['preload_schedule_type']) {
55	82	// Else, if the settings cache lifespan settings haven't changed, returns
56		- 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']) {
57	84	return;
58	85	}
59	86	} else {
60	87	return;
		@@ -62,10 +89,17 @@
62	89	}
63	90	// clear currently scheduled preload action.
64	91	wp_clear_scheduled_hook('wpo_page_cache_schedule_preload');
65	92	}
	93	+
66	94	// schedule preload action.
67		- 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');
68	102	} else {
69	103	wp_clear_scheduled_hook('wpo_page_cache_schedule_preload');
70	104	}
71	105
		@@ -82,13 +116,32 @@
82	116
83	117	// schedule preload action if need.
84	118	if ($this->is_scheduled_preload_enabled()) {
85	119	$preload_schedule_type = $this->get_cache_config('preload_schedule_type');
86		- 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');
87	129	}
88	130	}
89	131
90	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	+ /**
91	144	* Check if scheduled preload enabled.
92	145	*
93	146	* @return bool
94	147	*/
		@@ -105,17 +158,19 @@
105	158	$schedule_type = WPO_Cache_Config::instance()->get_option('preload_schedule_type');
106	159	if (!$schedule_type) return;
107	160
108	161	// Don't run preload if cache lifespan option enabled and cache not expired yet.
109		- if ('wpo_use_cache_lifespan' == $schedule_type) {
	162	+ if ('wpo_use_cache_lifespan' === $schedule_type) {
110	163
111	164	/**
112	165	* Filters the allowed time difference between the cache exiry and the current time, in seconds.
113	166	* If the cache expires in less than $allowed_time_difference, preload. Otherwise leave it.
114	167	*
115		- * @param integer $allowed_time_difference The time difference, in seconds (default = 600)
	168	+ * @param integer $allowed_time_difference The time difference, in seconds (default is same as changed time limit)
116	169	*/
117		- $allowed_time_difference = apply_filters('wpo_preload_allowed_time_difference', 600);
	170	+ $time_limit = (defined('WP_OPTIMIZE_SET_TIME_LIMIT') && WP_OPTIMIZE_SET_TIME_LIMIT > 15) ? WP_OPTIMIZE_SET_TIME_LIMIT : 1800;
	171	+
	172	+ $allowed_time_difference = apply_filters('wpo_preload_allowed_time_difference', $time_limit);
118	173	$page_cache_lifespan = WPO_Cache_Config::instance()->get_option('page_cache_length', 0);
119	174	$last_preload_time = $this->options->get_option('wpo_last_page_cache_preload', 0);
120	175	$time_since_last_preload = time() - $last_preload_time;
121	176	$minimum_time_to_next_schedule_preload = $page_cache_lifespan - $allowed_time_difference;
		@@ -125,12 +180,30 @@
125	180
126	181	$this->run();
127	182	}
128	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();
129	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	+
130	201	/**
131	202	* Get cache config option value.
132	203	*
	204	+ * @param string $option
	205	+ *
133	206	* @return mixed
134	207	*/
135	208	public function get_cache_config($option) {
136	209	static $config = null;
		@@ -156,10 +229,12 @@
156	229	if (!empty($urls)) {
157	230
158	231	$this->log(__('Creating tasks for preload site urls.', 'wp-optimize'));
159	232
	233	+ $wpo_cache_specific_urls_only = wpo_cache_specific_urls_only();
	234	+
160	235	foreach ($urls as $url) {
161		- if (wpo_url_in_exceptions($url)) continue;
	236	+ if (!$wpo_cache_specific_urls_only && wpo_url_in_exceptions($url)) continue;
162	237
163	238	if ($this->url_is_already_cached($url, $type)) {
164	239	continue;
165	240	}
		@@ -167,11 +242,8 @@
167	242	// this description is being used for internal purposes.
168	243	$description = 'Preload - '.$url;
169	244	$options = array('url' => $url, 'preload_type' => $type, 'anonymous_user_allowed' => (defined('DOING_CRON') && DOING_CRON) || (defined('WP_CLI') && WP_CLI));
170	245
171		- if (!class_exists('WP_Optimize_Load_Url_Task')) {
172		- require_once WPO_PLUGIN_MAIN_PATH . 'cache/class-wpo-load-url-task.php';
173		- }
174	246	WP_Optimize_Load_Url_Task::create_task($this->task_type, $description, $options, 'WP_Optimize_Load_Url_Task');
175	247	}
176	248
177	249	$this->log(__('Tasks for preload site urls created.', 'wp-optimize'));
		@@ -195,9 +267,9 @@
195	267	if (!$is_mobile_caching_enabled) return;
196	268
197	269	$mobile_args = array(
198	270	'httpversion' => '1.1',
199		- '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'),
200	272	'timeout' => 10,
201	273	'headers' => apply_filters('wpo_preload_headers', array()),
202	274	);
203	275
		@@ -219,9 +291,9 @@
219	291	if (!apply_filters('wpo_should_preload_amp', false, $url)) return;
220	292
221	293	$amp_args = array(
222	294	'httpversion' => '1.1',
223		- '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(),
224	296	'timeout' => 10,
225	297	'headers' => array(
226	298	'X-WP-Optimize-Cache-Preload' => 'Yes',
227	299	),
		@@ -251,8 +323,9 @@
251	323	$urls = $this->get_post_urls();
252	324	$this->options->update_option('wpo_last_page_cache_preload_type', 'posts');
253	325	}
254	326
	327	+ // translators: %d: Number of URLs found
255	328	$this->log(sprintf(_n('%d url found.', '%d urls found.', count($urls), 'wp-optimize'), count($urls)));
256	329
257	330	/**
258	331	* Filter the URLs which will be preloaded
		@@ -259,9 +332,10 @@
259	332	*
260	333	* @param array $urls
261	334	* @return array
262	335	*/
263		- 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;
264	338	}
265	339
266	340	/**
267	341	* Loads sitemap file and returns list of urls.
		@@ -285,24 +359,27 @@
285	359	// load sitemap file.
286	360	$response = wp_remote_get($sitemap_url, array('timeout' => 30));
287	361
288	362	// if we get error then
	363	+ // sometimes returns error due to timeout
289	364	if (is_wp_error($response)) {
290		- $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
291	366
292	367	// if response is empty then try load from file.
293		- if (empty($response) && '' == $sitemap_url) {
	368	+ if (empty($response)) {
294	369	$sitemap_file = $this->get_local_sitemap_file();
295	370
296		- $response = file_get_contents($sitemap_file);
	371	+ if (is_file($sitemap_file)) {
	372	+ $response = file_get_contents($sitemap_file);
	373	+ }
297	374	}
298	375
299	376	if (empty($response)) return $urls;
300	377
301		- $xml = @simplexml_load_string($response); // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
	378	+ $xml = @simplexml_load_string($response); // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- suppress warnings when error found in XML data
302	379	} else {
303	380	// parse xml answer.
304		- $xml = @simplexml_load_string(wp_remote_retrieve_body($response)); // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged
	381	+ $xml = @simplexml_load_string(wp_remote_retrieve_body($response)); // phpcs:ignore Generic.PHP.NoSilencedErrors.Discouraged -- suppress warnings when error found in XML data
305	382	}
306	383
307	384	// xml file has not valid xml content then return false.
308	385	if (false === $xml) return false;
		@@ -329,20 +406,8 @@
329	406	return $urls;
330	407	}
331	408
332	409	/**
333		- * Get the path to a local sitemap file
334		- *
335		- * @return string
336		- */
337		- private function get_local_sitemap_file() {
338		- if (!function_exists('get_home_path')) {
339		- include_once ABSPATH . '/wp-admin/includes/file.php';
340		- }
341		- return trailingslashit(get_home_path()) . $this->get_sitemap_filename();
342		- }
343		-
344		- /**
345	410	* Get all posts of any post type and returns urls for them.
346	411	*
347	412	* @return array
348	413	*/
		@@ -378,9 +443,9 @@
378	443	// if there any separators add urls for each page
379	444	if (count($matches[0])) {
380	445	$prefix = strpos($permalink, '?') ? '&page=' : '';
381	446	for ($page = 0; $page < count($matches[0]); $page++) {
382		- if ('' != $prefix) {
	447	+ if ('' !== $prefix) {
383	448	$urls[] = $permalink . $prefix . ($page+2);
384	449	} else {
385	450	$urls[] = trailingslashit($permalink) . ($page+2);
386	451	}
		@@ -418,9 +483,9 @@
418	483	* @return bool
419	484	*/
420	485	public function is_domain_mapping_enabled() {
421	486	// SUNRISE constant is defined with installation WordPress MU Domain Mapping plugin.
422		- $enabled = is_multisite() && defined('SUNRISE') && 'on' == strtolower(SUNRISE);
	487	+ $enabled = is_multisite() && defined('SUNRISE') && 'on' === strtolower(SUNRISE);
423	488
424	489	/**
425	490	* Filters if Multisite Domain mapping is enabled.
426	491	* Currently, we can only detect if the WordPress MU Domain Mapping plugin is in use.
		@@ -441,11 +506,11 @@
441	506
442	507	$domain = '';
443	508	$multisite_plugin_table_name = $wpdb->base_prefix.'domain_mapping';
444	509	// Check if table exists
445		- 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) {
446	511	// This table created in WordPress MU Domain Mapping plugin.
447		- $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);
448	513	if (!empty($row)) {
449	514	$domain = $row['domain'];
450	515	}
451	516	} else {
		@@ -462,12 +527,41 @@
462	527	return apply_filters('wpo_get_mapped_domain', $domain, $blog_id);
463	528	}
464	529
465	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	+ /**
466	560	* Captures and logs any interesting messages
467	561	*
468		- * @param String $message - the error message
469		- * @param String $error_type - the error type
	562	+ * @param string $message - the error message
	563	+ * @param string $error_type - the error type
470	564	*/
471	565	public function log($message, $error_type = 'info') {
472	566
473	567	if (isset($this->loggers)) {
		@@ -522,16 +616,16 @@
522	616	continue;
523	617	}
524	618
525	619	if ($this->should_regenerate_file($file_path, $preload_type)) {
526		- // delefe the expired cache file
527		- unlink($file_path);
	620	+ // delete the expired cache file
	621	+ wp_delete_file($file_path);
528	622	$regenerate_count++;
529	623	}
530	624	}
531	625
532	626	// if 0 == $regenerate_count, nothing all the expected files exist, and none were deleted.
533		- return 0 == $regenerate_count;
	627	+ return 0 === $regenerate_count;
534	628	}
535	629
536	630	/**
537	631	* Determine if a file should be regenerated
		@@ -555,9 +649,9 @@
555	649	// Sets the variables once per request:
556	650	if (null === $is_preloader_scheduled) {
557	651	$is_preloader_scheduled = WPO_Cache_Config::instance()->get_option('enable_schedule_preload');
558	652	$schedule_type = WPO_Cache_Config::instance()->get_option('preload_schedule_type');
559		- $lifespan = WPO_Cache_Config::instance()->get_option('page_cache_length');
	653	+ $lifespan = (int) WPO_Cache_Config::instance()->get_option('page_cache_length');
560	654	$schedule_interval = $this->get_schedule_interval($schedule_type);
561	655
562	656	/**
563	657	* Expiry threshold: the current file will be considered stale if within the threshold. Default: 600s (10min)
		@@ -579,9 +673,9 @@
579	673	*/
580	674	$regenerate_file_when_no_expiry_date = apply_filters('wpo_regenerate_file_when_no_expiry_date', true);
581	675	}
582	676
583		- 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)) {
584	678	$result = true;
585	679	} else {
586	680
587	681	$modified_time = (int) filemtime($path);
		@@ -586,9 +680,9 @@
586	680
587	681	$modified_time = (int) filemtime($path);
588	682
589	683	// cache lifespan is set.
590		- if (0 != $lifespan) {
	684	+ if (0 !== $lifespan) {
591	685	$expiry_time = $modified_time + $lifespan - $lifespan_expiry_threshold;
592	686	$result = time() > $expiry_time;
593	687	} elseif ($is_preloader_scheduled) {
594	688	$expiry_time = $modified_time + $schedule_interval - $lifespan_expiry_threshold;
		@@ -603,8 +697,10 @@
603	697	}
604	698
605	699	/**
606	700	* Add preloader headers
	701	+ *
	702	+ * @param array $headers Preload headers
607	703	*/
608	704	public function preload_headers($headers) {
609	705	$headers['X-WP-Optimize-Cache-Preload'] = 'Yes';
610	706	return $headers;
		@@ -632,13 +728,25 @@
632	728	'success' => false,
633	729	'error' => __('Probably page cache preload is running already.', 'wp-optimize')
634	730	);
635	731	}
636		-
	732	+
	733	+ /**
	734	+ * Returns preload data
	735	+ *
	736	+ * @return array
	737	+ */
637	738	protected function get_preload_data() {
638	739	return WP_Optimize()->get_page_cache()->get_cache_size();
639	740	}
640		-
	741	+
	742	+ /**
	743	+ * Returns preloading message
	744	+ *
	745	+ * @param array $cache_size
	746	+ *
	747	+ * @return array
	748	+ */
641	749	protected function get_preloading_message($cache_size) {
642	750	return array(
643	751	'done' => false,
644	752	'message' => __('Loading URLs...', 'wp-optimize'),
		@@ -645,18 +753,34 @@
645	753	'size' => WP_Optimize()->format_size($cache_size['size']),
646	754	'file_count' => $cache_size['file_count']
647	755	);
648	756	}
649		-
	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	+ */
650	766	protected function get_last_preload_message($cache_size, $last_preload_time_str) {
651	767	return array(
652	768	'done' => true,
	769	+ // translators: %s is the last preload time
653	770	'message' => sprintf(__('Last preload finished at %s', 'wp-optimize'), $last_preload_time_str),
654	771	'size' => WP_Optimize()->format_size($cache_size['size']),
655	772	'file_count' => $cache_size['file_count']
656	773	);
657	774	}
658		-
	775	+
	776	+ /**
	777	+ * Returns preload success message
	778	+ *
	779	+ * @param array $cache_size
	780	+ *
	781	+ * @return array
	782	+ */
659	783	protected function get_preload_success_message($cache_size) {
660	784	return array(
661	785	'done' => true,
662	786	'size' => WP_Optimize()->format_size($cache_size['size']),
		@@ -662,9 +786,18 @@
662	786	'size' => WP_Optimize()->format_size($cache_size['size']),
663	787	'file_count' => $cache_size['file_count']
664	788	);
665	789	}
666		-
	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	+ */
667	800	protected function get_preload_progress_message($cache_size, $preloaded_message, $preload_resuming_in) {
668	801	return array(
669	802	'done' => false,
670	803	'message' => $preloaded_message,
		@@ -672,7 +805,25 @@
672	805	'file_count' => $cache_size['file_count'],
673	806	'resume_in' => $preload_resuming_in
674	807	);
675	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	+ }
676	829	}
677		-
678		-WP_Optimize_Page_Cache_Preloader::instance();