Jetpack_Sync_Sender::set_full_sync_client() - Code Metrics - Inspection of "include options into test_all_checksums_match" - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — add/sync-options-checksums ( fe9c0b...b8783d )

unknown

created 2016-07-06 12:39 UTC

Jetpack_Sync_Sender::set_full_sync_client() A

↳ Parent: Jetpack_Sync_Sender

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	5
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	12
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-full.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 $full_sync_client;
	private $codec;

	// singleton functions
	private static $instance;

	public static function getInstance() {
		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();
		}

		/**
		 * Sync all pending actions with server
		 */
		add_action( 'jetpack_sync_actions', array( $this, 'do_sync' ) );
	}

	public function do_sync() {
		// don't sync if importing
		if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
			$this->schedule_sync( "+1 minute" );

			return false;
		}

		// don't sync if we are throttled
		$sync_wait = $this->get_sync_wait_time();
		$last_sync = $this->get_last_sync_time();

		if ( $last_sync && $sync_wait && $last_sync + $sync_wait > 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();
		$actions_to_send = array();
		// 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 ( $buffer->get_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;
			$actions_to_send[ $key ] = $item[0];
		}

		/**
		 * 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
		 */
		$result = apply_filters( 'jetpack_sync_send_data', $items_to_send, $this->codec->name() );

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

			if ( is_wp_error( $result ) ) {
				error_log( "Error checking in buffer: " . $result->get_error_message() );
				$this->sync_queue->force_checkin();
			}
			// try again in 1 minute
			$this->schedule_sync( "+1 minute" );
		} else {
			$processed_actions = array();
			foreach( $result as $result_id ) {
				if ( isset( $actions_to_send[ $result_id ] ) ) {
					$processed_actions[] =  $actions_to_send[ $result_id ];
				}
			}

			/**
			 * 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_actions );


			$this->sync_queue->close( $buffer, $result );
			// check if there are any more events in the buffer
			// if so, schedule a cron job to happen soon
			if ( $this->sync_queue->has_any_items() ) {
				$this->schedule_sync( "+1 minute" );
			}
		}
	}

	private function schedule_sync( $when ) {
		wp_schedule_single_event( strtotime( $when ), 'jetpack_sync_actions' );
	}

	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() {
		$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 get_full_sync_client() {
		return $this->full_sync_client;
	}

	function set_full_sync_client( $full_sync_client ) {
		if ( $this->full_sync_client ) {
			remove_action( 'jetpack_sync_full', array( $this->full_sync_client, 'start' ) );
		}

		$this->full_sync_client = $full_sync_client;

		/**
		 * Sync all objects in the database with the server
		 */
		add_action( 'jetpack_sync_full', array( $this->full_sync_client, 'start' ) );
	}

	function set_defaults() {
		$this->sync_queue = new Jetpack_Sync_Queue( 'sync' );
		$this->set_full_sync_client( Jetpack_Sync_Full::getInstance() );
		$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_actions' );

		// 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-full.php';
7			require_once dirname( __FILE__ ) . '/class.jetpack-sync-modules.php';
8			require_once dirname( __FILE__ ) . '/class.jetpack-sync-settings.php';
9
10			/**
11			* This class grabs pending actions from the queue and sends them
12			*/
13			class Jetpack_Sync_Sender {
14
15			const SYNC_THROTTLE_OPTION_NAME = 'jetpack_sync_min_wait';
16			const LAST_SYNC_TIME_OPTION_NAME = 'jetpack_last_sync_time';
17
18			private $dequeue_max_bytes;
19			private $upload_max_bytes;
20			private $upload_max_rows;
21			private $sync_wait_time;
22			private $sync_queue;
23			private $full_sync_client;
24			private $codec;
25
26			// singleton functions
27			private static $instance;
28
29			public static function getInstance() {
30			if ( null === self::$instance ) {
31			self::$instance = new self();
32			}
33
34			return self::$instance;
35			}
36
37			// this is necessary because you can't use "new" when you declare instance properties >:(
38			protected function __construct() {
39			$this->set_defaults();
40			$this->init();
41			}
42
43			private function init() {
44
45			foreach( Jetpack_Sync_Modules::get_modules() as $module ) {
46			$module->init_before_send();
47			}
48
49			/**
50			* Sync all pending actions with server
51			*/
52			add_action( 'jetpack_sync_actions', array( $this, 'do_sync' ) );
53			}
54
55			public function do_sync() {
56			// don't sync if importing
57			if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
58			$this->schedule_sync( "+1 minute" );
59
60			return false;
61			}
62
63			// don't sync if we are throttled
64			$sync_wait = $this->get_sync_wait_time();
65			$last_sync = $this->get_last_sync_time();
66
67			if ( $last_sync && $sync_wait && $last_sync + $sync_wait > microtime( true ) ) {
68			return false;
69			}
70
71			$this->set_last_sync_time();
72
73			do_action( 'jetpack_sync_before_send' );
74
75			if ( $this->sync_queue->size() === 0 ) {
76			return false;
77			}
78
79			// now that we're sure we are about to sync, try to
80			// ignore user abort so we can avoid getting into a
81			// bad state
82			if ( function_exists( 'ignore_user_abort' ) ) {
83			ignore_user_abort( true );
84			}
85
86			$buffer = $this->sync_queue->checkout_with_memory_limit( $this->dequeue_max_bytes, $this->upload_max_rows );
87
88			if ( ! $buffer ) {
89			// buffer has no items
90			return false;
91			}
92
93			if ( is_wp_error( $buffer ) ) {
94			// another buffer is currently sending
95			return false;
96			}
97
98			$upload_size = 0;
99			$items_to_send = array();
100			$actions_to_send = array();
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 ( $buffer->get_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			$actions_to_send[ $key ] = $item[0];
125			}
126
127			/**
128			* Fires when data is ready to send to the server.
129			* Return false or WP_Error to abort the sync (e.g. if there's an error)
130			* The items will be automatically re-sent later
131			*
132			* @since 4.2.0
133			*
134			* @param array $data The action buffer
135			*/
136			$result = apply_filters( 'jetpack_sync_send_data', $items_to_send, $this->codec->name() );
137
138			if ( ! $result \|\| is_wp_error( $result ) ) {
139			$result = $this->sync_queue->checkin( $buffer );
140
141			if ( is_wp_error( $result ) ) {
142			error_log( "Error checking in buffer: " . $result->get_error_message() );
143			$this->sync_queue->force_checkin();
144			}
145			// try again in 1 minute
146			$this->schedule_sync( "+1 minute" );
147			} else {
148			$processed_actions = array();
149			foreach( $result as $result_id ) {
150			if ( isset( $actions_to_send[ $result_id ] ) ) {
151			$processed_actions[] = $actions_to_send[ $result_id ];
152			}
153			}
154
155			/**
156			* Allows us to keep track of all the actions that have been sent.
157			* Allows us to calculate the progress of specific actions.
158			*
159			* @since 4.2.0
160			*
161			* @param array $processed_actions The actions that we send successfully.
162			*/
163			do_action( 'jetpack_sync_processed_actions', $processed_actions );
164
165
166			$this->sync_queue->close( $buffer, $result );
167			// check if there are any more events in the buffer
168			// if so, schedule a cron job to happen soon
169			if ( $this->sync_queue->has_any_items() ) {
170			$this->schedule_sync( "+1 minute" );
171			}
172			}
173			}
174
175			private function schedule_sync( $when ) {
176			wp_schedule_single_event( strtotime( $when ), 'jetpack_sync_actions' );
177			}
178
179			function get_sync_queue() {
180			return $this->sync_queue;
181			}
182
183			function get_codec() {
184			return $this->codec;
185			}
186
187			function send_checksum() {
188			require_once 'class.jetpack-sync-wp-replicastore.php';
189			$store = new Jetpack_Sync_WP_Replicastore();
190			do_action( 'jetpack_sync_checksum', $store->checksum_all() );
191			}
192
193			function reset_sync_queue() {
194			$this->sync_queue->reset();
195			}
196
197			function set_dequeue_max_bytes( $size ) {
198			$this->dequeue_max_bytes = $size;
199			}
200
201			// in bytes
202			function set_upload_max_bytes( $max_bytes ) {
203			$this->upload_max_bytes = $max_bytes;
204			}
205
206			// in rows
207			function set_upload_max_rows( $max_rows ) {
208			$this->upload_max_rows = $max_rows;
209			}
210
211			// in seconds
212			function set_sync_wait_time( $seconds ) {
213			$this->sync_wait_time = $seconds;
214			}
215
216			function get_sync_wait_time() {
217			return $this->sync_wait_time;
218			}
219
220			private function get_last_sync_time() {
221			return (double) get_option( self::LAST_SYNC_TIME_OPTION_NAME );
222			}
223
224			private function set_last_sync_time() {
225			return update_option( self::LAST_SYNC_TIME_OPTION_NAME, microtime( true ), true );
226			}
227
228			function get_full_sync_client() {
229			return $this->full_sync_client;
230			}
231
232			function set_full_sync_client( $full_sync_client ) {
233			if ( $this->full_sync_client ) {
234			remove_action( 'jetpack_sync_full', array( $this->full_sync_client, 'start' ) );
235			}
236
237			$this->full_sync_client = $full_sync_client;
238
239			/**
240			* Sync all objects in the database with the server
241			*/
242			add_action( 'jetpack_sync_full', array( $this->full_sync_client, 'start' ) );
243			}
244
245			function set_defaults() {
246			$this->sync_queue = new Jetpack_Sync_Queue( 'sync' );
247			$this->set_full_sync_client( Jetpack_Sync_Full::getInstance() );
248			$this->codec = new Jetpack_Sync_JSON_Deflate_Codec();
249
250			// saved settings
251			$settings = Jetpack_Sync_Settings::get_settings();
252			$this->set_dequeue_max_bytes( $settings['dequeue_max_bytes'] );
253			$this->set_upload_max_bytes( $settings['upload_max_bytes'] );
254			$this->set_upload_max_rows( $settings['upload_max_rows'] );
255			$this->set_sync_wait_time( $settings['sync_wait_time'] );
256			}
257
258			function reset_data() {
259			$this->reset_sync_queue();
260
261			foreach( Jetpack_Sync_Modules::get_modules() as $module ) {
262			$module->reset_data();
263			}
264
265			delete_option( self::SYNC_THROTTLE_OPTION_NAME );
266			delete_option( self::LAST_SYNC_TIME_OPTION_NAME );
267
268			Jetpack_Sync_Settings::reset_data();
269			}
270
271			function uninstall() {
272			// Lets delete all the other fun stuff like transient and option and the sync queue
273			$this->reset_data();
274
275			// delete the full sync status
276			delete_option( 'jetpack_full_sync_status' );
277
278			// clear the sync cron.
279			wp_clear_scheduled_hook( 'jetpack_sync_actions' );
280
281			// clear the checksum cron
282			wp_clear_scheduled_hook( 'jetpack_send_db_checksum' );
283			}
284			}
285

Automattic / jetpack

Push — add/sync-options-checksums ( fe9c0b...b8783d )

Jetpack_Sync_Sender::set_full_sync_client() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like