Jetpack_Sync_Sender::next_sync_time() - Code Metrics - Inspection of "Admin Page: avoid concatenating strings in the dev..." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — fix/space-twitter-4455 ( 859b70...d25e05 )

by Jeremy

created 2016-07-25 17:31 UTC

Jetpack_Sync_Sender::next_sync_time() A

↳ Parent: Jetpack_Sync_Sender

Complexity

Conditions	3
Paths	4

Size

Total Lines	6
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
cc	3
eloc	5
c	1
b	1
f	0
nc	4
nop	0
dl	0
loc	6
rs	9.4285

<?php

require_once dirname( __FILE__ ) . '/class.jetpack-sync-queue.php';
require_once dirname( __FILE__ ) . '/class.jetpack-sync-defaults.php';
require_once dirname( __FILE__ ) . '/class.jetpack-sync-json-deflate-codec.php';
require_once dirname( __FILE__ ) . '/class.jetpack-sync-modules.php';
require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php';

/**
 * This class grabs pending actions from the queue and sends them
 */
class Jetpack_Sync_Sender {

	const SYNC_THROTTLE_OPTION_NAME = 'jetpack_sync_min_wait';
	const LAST_SYNC_TIME_OPTION_NAME = 'jetpack_last_sync_time';

	private $dequeue_max_bytes;
	private $upload_max_bytes;
	private $upload_max_rows;
	private $sync_wait_time;
	private $sync_queue;
	private $codec;

	// singleton functions
	private static $instance;

	public static function get_instance() {
		if ( null === self::$instance ) {
			self::$instance = new self();
		}

		return self::$instance;
	}

	// this is necessary because you can't use "new" when you declare instance properties >:(
	protected function __construct() {
		$this->set_defaults();
		$this->init();
	}

	private function init() {
		foreach ( Jetpack_Sync_Modules::get_modules() as $module ) {
			$module->init_before_send();
		}
	}

	public function next_sync_time() {
		$sync_wait = $this->get_sync_wait_time();
		$last_sync = $this->get_last_sync_time();
		$next_sync_time = ( $last_sync && $sync_wait ) ? $last_sync + $sync_wait : 0;
		return $next_sync_time;
	}

	public function do_sync() {
		// don't sync if importing
		if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
			return false;
		}

		// don't sync if we are throttled
		if ( $this->next_sync_time() > microtime( true ) ) {
			return false;
		}

		$this->set_last_sync_time();

		do_action( 'jetpack_sync_before_send' );

		if ( $this->sync_queue->size() === 0 ) {
			return false;
		}

		// now that we're sure we are about to sync, try to
		// ignore user abort so we can avoid getting into a
		// bad state
		if ( function_exists( 'ignore_user_abort' ) ) {
			ignore_user_abort( true );
		}

		$buffer = $this->sync_queue->checkout_with_memory_limit( $this->dequeue_max_bytes, $this->upload_max_rows );

		if ( ! $buffer ) {
			// buffer has no items
			return false;
		}

		if ( is_wp_error( $buffer ) ) {
			// another buffer is currently sending
			return false;
		}

		$upload_size   = 0;
		$items_to_send = array();
		$items         = $buffer->get_items();

		// set up current screen to avoid errors rendering content
		require_once(ABSPATH . 'wp-admin/includes/class-wp-screen.php');
		require_once(ABSPATH . 'wp-admin/includes/screen.php');
		set_current_screen( 'sync' );

		// we estimate the total encoded size as we go by encoding each item individually
		// this is expensive, but the only way to really know :/
		foreach ( $items as $key => $item ) {
			/**
			 * Modify the data within an action before it is serialized and sent to the server
			 * For example, during full sync this expands Post ID's into full Post objects,
			 * so that we don't have to serialize the whole object into the queue.
			 *
			 * @since 4.2.0
			 *
			 * @param array The action parameters
			 */
			$item[1] = apply_filters( 'jetpack_sync_before_send_' . $item[0], $item[1], $item[2] );

			$encoded_item = $this->codec->encode( $item );

			$upload_size += strlen( $encoded_item );

			if ( $upload_size > $this->upload_max_bytes && count( $items_to_send ) > 0 ) {
				break;
			}

			$items_to_send[ $key ] = $encoded_item;
		}

		/**
		 * Fires when data is ready to send to the server.
		 * Return false or WP_Error to abort the sync (e.g. if there's an error)
		 * The items will be automatically re-sent later
		 *
		 * @since 4.2.0
		 *
		 * @param array $data The action buffer
		 */
		$processed_item_ids = apply_filters( 'jetpack_sync_send_data', $items_to_send, $this->codec->name(), microtime( true ) );

		if ( ! $processed_item_ids || is_wp_error( $processed_item_ids ) ) {
			$processed_item_ids = $this->sync_queue->checkin( $buffer );

			if ( is_wp_error( $processed_item_ids ) ) {
				error_log( 'Error checking in buffer: ' . $processed_item_ids->get_error_message() );
				$this->sync_queue->force_checkin();
			}
		} else {
			$processed_items = array_intersect_key( $items, array_flip( $processed_item_ids ) );

			/**
			 * Allows us to keep track of all the actions that have been sent.
			 * Allows us to calculate the progress of specific actions.
			 *
			 * @since 4.2.0
			 *
			 * @param array $processed_actions The actions that we send successfully.
			 */
			do_action( 'jetpack_sync_processed_actions', $processed_items );

			$this->sync_queue->close( $buffer, $processed_item_ids );
		}
		
		return true;
	}

	function get_sync_queue() {
		return $this->sync_queue;
	}

	function get_codec() {
		return $this->codec;
	}

	function send_checksum() {
		require_once 'class.jetpack-sync-wp-replicastore.php';
		$store = new Jetpack_Sync_WP_Replicastore();
		do_action( 'jetpack_sync_checksum', $store->checksum_all() );
	}

	function reset_sync_queue() {
		Jetpack_Sync_Modules::get_module( 'full-sync' )->clear_status();
		$this->sync_queue->reset();
	}

	function set_dequeue_max_bytes( $size ) {
		$this->dequeue_max_bytes = $size;
	}

	// in bytes
	function set_upload_max_bytes( $max_bytes ) {
		$this->upload_max_bytes = $max_bytes;
	}

	// in rows
	function set_upload_max_rows( $max_rows ) {
		$this->upload_max_rows = $max_rows;
	}

	// in seconds
	function set_sync_wait_time( $seconds ) {
		$this->sync_wait_time = $seconds;
	}

	function get_sync_wait_time() {
		return $this->sync_wait_time;
	}

	private function get_last_sync_time() {
		return (double) get_option( self::LAST_SYNC_TIME_OPTION_NAME );
	}

	private function set_last_sync_time() {
		return update_option( self::LAST_SYNC_TIME_OPTION_NAME, microtime( true ), true );
	}

	function set_defaults() {
		$this->sync_queue = new Jetpack_Sync_Queue( 'sync' );
		$this->codec      = new Jetpack_Sync_JSON_Deflate_Codec();

		// saved settings
		$settings = Jetpack_Sync_Settings::get_settings();
		$this->set_dequeue_max_bytes( $settings['dequeue_max_bytes'] );
		$this->set_upload_max_bytes( $settings['upload_max_bytes'] );
		$this->set_upload_max_rows( $settings['upload_max_rows'] );
		$this->set_sync_wait_time( $settings['sync_wait_time'] );
	}

	function reset_data() {
		$this->reset_sync_queue();

		foreach ( Jetpack_Sync_Modules::get_modules() as $module ) {
			$module->reset_data();
		}

		delete_option( self::SYNC_THROTTLE_OPTION_NAME );
		delete_option( self::LAST_SYNC_TIME_OPTION_NAME );

		Jetpack_Sync_Settings::reset_data();
	}

	function uninstall() {
		// Lets delete all the other fun stuff like transient and option and the sync queue
		$this->reset_data();

		// delete the full sync status
		delete_option( 'jetpack_full_sync_status' );

		// clear the sync cron.
		wp_clear_scheduled_hook( 'jetpack_sync_cron' );

		// clear the checksum cron
		wp_clear_scheduled_hook( 'jetpack_send_db_checksum' );
	}
}


1			<?php
2
3			require_once dirname( __FILE__ ) . '/class.jetpack-sync-queue.php';
4			require_once dirname( __FILE__ ) . '/class.jetpack-sync-defaults.php';
5			require_once dirname( __FILE__ ) . '/class.jetpack-sync-json-deflate-codec.php';
6			require_once dirname( __FILE__ ) . '/class.jetpack-sync-modules.php';
7			require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php';
8
9			/**
10			* This class grabs pending actions from the queue and sends them
11			*/
12			class Jetpack_Sync_Sender {
13
14			const SYNC_THROTTLE_OPTION_NAME = 'jetpack_sync_min_wait';
15			const LAST_SYNC_TIME_OPTION_NAME = 'jetpack_last_sync_time';
16
17			private $dequeue_max_bytes;
18			private $upload_max_bytes;
19			private $upload_max_rows;
20			private $sync_wait_time;
21			private $sync_queue;
22			private $codec;
23
24			// singleton functions
25			private static $instance;
26
27			public static function get_instance() {
28			if ( null === self::$instance ) {
29			self::$instance = new self();
30			}
31
32			return self::$instance;
33			}
34
35			// this is necessary because you can't use "new" when you declare instance properties >:(
36			protected function __construct() {
37			$this->set_defaults();
38			$this->init();
39			}
40
41			private function init() {
42			foreach ( Jetpack_Sync_Modules::get_modules() as $module ) {
43			$module->init_before_send();
44			}
45			}
46
47			public function next_sync_time() {
48			$sync_wait = $this->get_sync_wait_time();
49			$last_sync = $this->get_last_sync_time();
50			$next_sync_time = ( $last_sync && $sync_wait ) ? $last_sync + $sync_wait : 0;
51			return $next_sync_time;
52			}
53
54			public function do_sync() {
55			// don't sync if importing
56			if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
57			return false;
58			}
59
60			// don't sync if we are throttled
61			if ( $this->next_sync_time() > microtime( true ) ) {
62			return false;
63			}
64
65			$this->set_last_sync_time();
66
67			do_action( 'jetpack_sync_before_send' );
68
69			if ( $this->sync_queue->size() === 0 ) {
70			return false;
71			}
72
73			// now that we're sure we are about to sync, try to
74			// ignore user abort so we can avoid getting into a
75			// bad state
76			if ( function_exists( 'ignore_user_abort' ) ) {
77			ignore_user_abort( true );
78			}
79
80			$buffer = $this->sync_queue->checkout_with_memory_limit( $this->dequeue_max_bytes, $this->upload_max_rows );
81
82			if ( ! $buffer ) {
83			// buffer has no items
84			return false;
85			}
86
87			if ( is_wp_error( $buffer ) ) {
88			// another buffer is currently sending
89			return false;
90			}
91
92			$upload_size = 0;
93			$items_to_send = array();
94			$items = $buffer->get_items();
95
96			// set up current screen to avoid errors rendering content
97			require_once(ABSPATH . 'wp-admin/includes/class-wp-screen.php');
98			require_once(ABSPATH . 'wp-admin/includes/screen.php');
99			set_current_screen( 'sync' );
100
101			// we estimate the total encoded size as we go by encoding each item individually
102			// this is expensive, but the only way to really know :/
103			foreach ( $items as $key => $item ) {
104			/**
105			* Modify the data within an action before it is serialized and sent to the server
106			* For example, during full sync this expands Post ID's into full Post objects,
107			* so that we don't have to serialize the whole object into the queue.
108			*
109			* @since 4.2.0
110			*
111			* @param array The action parameters
112			*/
113			$item[1] = apply_filters( 'jetpack_sync_before_send_' . $item[0], $item[1], $item[2] );
114
115			$encoded_item = $this->codec->encode( $item );
116
117			$upload_size += strlen( $encoded_item );
118
119			if ( $upload_size > $this->upload_max_bytes && count( $items_to_send ) > 0 ) {
120			break;
121			}
122
123			$items_to_send[ $key ] = $encoded_item;
124			}
125
126			/**
127			* Fires when data is ready to send to the server.
128			* Return false or WP_Error to abort the sync (e.g. if there's an error)
129			* The items will be automatically re-sent later
130			*
131			* @since 4.2.0
132			*
133			* @param array $data The action buffer
134			*/
135			$processed_item_ids = apply_filters( 'jetpack_sync_send_data', $items_to_send, $this->codec->name(), microtime( true ) );
136
137			if ( ! $processed_item_ids \|\| is_wp_error( $processed_item_ids ) ) {
138			$processed_item_ids = $this->sync_queue->checkin( $buffer );
139
140			if ( is_wp_error( $processed_item_ids ) ) {
141			error_log( 'Error checking in buffer: ' . $processed_item_ids->get_error_message() );
142			$this->sync_queue->force_checkin();
143			}
144			} else {
145			$processed_items = array_intersect_key( $items, array_flip( $processed_item_ids ) );
146
147			/**
148			* Allows us to keep track of all the actions that have been sent.
149			* Allows us to calculate the progress of specific actions.
150			*
151			* @since 4.2.0
152			*
153			* @param array $processed_actions The actions that we send successfully.
154			*/
155			do_action( 'jetpack_sync_processed_actions', $processed_items );
156
157			$this->sync_queue->close( $buffer, $processed_item_ids );
158			}
159
160			return true;
161			}
162
163			function get_sync_queue() {
164			return $this->sync_queue;
165			}
166
167			function get_codec() {
168			return $this->codec;
169			}
170
171			function send_checksum() {
172			require_once 'class.jetpack-sync-wp-replicastore.php';
173			$store = new Jetpack_Sync_WP_Replicastore();
174			do_action( 'jetpack_sync_checksum', $store->checksum_all() );
175			}
176
177			function reset_sync_queue() {
178			Jetpack_Sync_Modules::get_module( 'full-sync' )->clear_status();
179			$this->sync_queue->reset();
180			}
181
182			function set_dequeue_max_bytes( $size ) {
183			$this->dequeue_max_bytes = $size;
184			}
185
186			// in bytes
187			function set_upload_max_bytes( $max_bytes ) {
188			$this->upload_max_bytes = $max_bytes;
189			}
190
191			// in rows
192			function set_upload_max_rows( $max_rows ) {
193			$this->upload_max_rows = $max_rows;
194			}
195
196			// in seconds
197			function set_sync_wait_time( $seconds ) {
198			$this->sync_wait_time = $seconds;
199			}
200
201			function get_sync_wait_time() {
202			return $this->sync_wait_time;
203			}
204
205			private function get_last_sync_time() {
206			return (double) get_option( self::LAST_SYNC_TIME_OPTION_NAME );
207			}
208
209			private function set_last_sync_time() {
210			return update_option( self::LAST_SYNC_TIME_OPTION_NAME, microtime( true ), true );
211			}
212
213			function set_defaults() {
214			$this->sync_queue = new Jetpack_Sync_Queue( 'sync' );
215			$this->codec = new Jetpack_Sync_JSON_Deflate_Codec();
216
217			// saved settings
218			$settings = Jetpack_Sync_Settings::get_settings();
219			$this->set_dequeue_max_bytes( $settings['dequeue_max_bytes'] );
220			$this->set_upload_max_bytes( $settings['upload_max_bytes'] );
221			$this->set_upload_max_rows( $settings['upload_max_rows'] );
222			$this->set_sync_wait_time( $settings['sync_wait_time'] );
223			}
224
225			function reset_data() {
226			$this->reset_sync_queue();
227
228			foreach ( Jetpack_Sync_Modules::get_modules() as $module ) {
229			$module->reset_data();
230			}
231
232			delete_option( self::SYNC_THROTTLE_OPTION_NAME );
233			delete_option( self::LAST_SYNC_TIME_OPTION_NAME );
234
235			Jetpack_Sync_Settings::reset_data();
236			}
237
238			function uninstall() {
239			// Lets delete all the other fun stuff like transient and option and the sync queue
240			$this->reset_data();
241
242			// delete the full sync status
243			delete_option( 'jetpack_full_sync_status' );
244
245			// clear the sync cron.
246			wp_clear_scheduled_hook( 'jetpack_sync_cron' );
247
248			// clear the checksum cron
249			wp_clear_scheduled_hook( 'jetpack_send_db_checksum' );
250			}
251			}
252

Automattic / jetpack

Push — fix/space-twitter-4455 ( 859b70...d25e05 )

Jetpack_Sync_Sender::next_sync_time() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like