Jetpack_Sync_Sender::get_enqueue_wait_time() - Code Metrics - Inspection of "Admin: when routing goes to Dashboard, user is non..." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — fix/non-admin-no-ui-when-prote... ( 85feb2 )

unknown

created 2016-10-21 20:21 UTC

Jetpack_Sync_Sender::get_enqueue_wait_time() A

↳ Parent: Jetpack_Sync_Sender

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?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-array-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 NEXT_SYNC_TIME_OPTION_NAME = 'jetpack_next_sync_time';
	const WPCOM_ERROR_SYNC_DELAY = 60;
	const QUEUE_LOCKED_SYNC_DELAY = 10;

	private $dequeue_max_bytes;
	private $upload_max_bytes;
	private $upload_max_rows;
	private $max_dequeue_time;
	private $sync_wait_time;
	private $sync_wait_threshold;
	private $enqueue_wait_time;
	private $sync_queue;
	private $full_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 get_next_sync_time( $queue_name ) {
		return (double) get_option( self::NEXT_SYNC_TIME_OPTION_NAME . '_' . $queue_name, 0 );
	}

	public function set_next_sync_time( $time, $queue_name ) {
		return update_option( self::NEXT_SYNC_TIME_OPTION_NAME . '_' . $queue_name, $time, true );
	}

	public function do_full_sync() {
		$this->continue_full_sync_enqueue();
		return $this->do_sync_and_set_delays( $this->full_sync_queue );
	}

	private function continue_full_sync_enqueue() {
		if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
			return false;
		}

		if ( $this->get_next_sync_time( 'full-sync-enqueue' ) > microtime( true ) ) {
			return false;
		}

		Jetpack_Sync_Modules::get_module( 'full-sync' )->continue_enqueuing();

		$this->set_next_sync_time( time() + $this->get_enqueue_wait_time(), 'full-sync-enqueue' );
	}

	public function do_sync() {
		return $this->do_sync_and_set_delays( $this->sync_queue );
	}

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

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

		$start_time = microtime( true );

		Jetpack_Sync_Settings::set_is_syncing( true );

		$sync_result = $this->do_sync_for_queue( $queue );

		Jetpack_Sync_Settings::set_is_syncing( false );

		$exceeded_sync_wait_threshold = ( microtime( true ) - $start_time ) > (double) $this->get_sync_wait_threshold();
		
		if ( is_wp_error( $sync_result ) ) {
			if ( 'unclosed_buffer' === $sync_result->get_error_code() ) {
				$this->set_next_sync_time( time() + self::QUEUE_LOCKED_SYNC_DELAY, $queue->id );
			} else {
				$this->set_next_sync_time( time() + self::WPCOM_ERROR_SYNC_DELAY, $queue->id );
			}
			$sync_result = false;
		} elseif ( $exceeded_sync_wait_threshold ) {
			// if we actually sent data and it took a while, wait before sending again
			$this->set_next_sync_time( time() + $this->get_sync_wait_time(), $queue->id );
		}

		return $sync_result;
	}

	public function get_items_to_send( $buffer, $encode = true ) {
		// track how long we've been processing so we can avoid request timeouts
		$start_time = microtime( true );
		$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' );
		$skipped_items_ids = 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 ( $items as $key => $item ) {
			// Suspending cache addition help prevent overloading in memory cache of large sites.
			wp_suspend_cache_addition( true );
			/**
			 * 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
			 * @param int The ID of the user who triggered the action
			 */
			$item[1] = apply_filters( 'jetpack_sync_before_send_' . $item[0], $item[1], $item[2] );
			wp_suspend_cache_addition( false );
			if ( $item[1] === false ) {
				$skipped_items_ids[] = $key;
				continue;
			}
			$encoded_item = $encode ? $this->codec->encode( $item ) : $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;
			if ( microtime(true) - $start_time > $this->max_dequeue_time ) {
				break;
			}
		}

		return array( $items_to_send, $skipped_items_ids, $items );
	}

	public function do_sync_for_queue( $queue ) {

		do_action( 'jetpack_sync_before_send_queue_' . $queue->id );
		if ( $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 = $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 ) ) {
			return $buffer;
		}

		list( $items_to_send, $skipped_items_ids, $items ) = $this->get_items_to_send( $buffer, true );

		/**
		 * 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
		 * @param string $codec The codec name used to encode the data
		 * @param double $time The current time
		 * @param string $queue The queue used to send ('sync' or 'full_sync')
		 */
		Jetpack_Sync_Settings::set_is_sending( true );
		$processed_item_ids = apply_filters( 'jetpack_sync_send_data', $items_to_send, $this->codec->name(), microtime( true ), $queue->id );
		Jetpack_Sync_Settings::set_is_sending( false );
		
		if ( ! $processed_item_ids || is_wp_error( $processed_item_ids ) ) {
			$checked_in_item_ids = $queue->checkin( $buffer );
			if ( is_wp_error( $checked_in_item_ids ) ) {
				error_log( 'Error checking in buffer: ' . $checked_in_item_ids->get_error_message() );
				$queue->force_checkin();
			}
			if ( is_wp_error( $processed_item_ids ) ) {
				return $processed_item_ids;
			}
			// returning a WP_Error is a sign to the caller that we should wait a while
			// before syncing again
			return new WP_Error( 'server_error' );
		} else {
			// detect if the last item ID was an error
			$had_wp_error = is_wp_error( end( $processed_item_ids ) );
			if ( $had_wp_error ) {
				$wp_error = array_pop( $processed_item_ids );
			}
			// also checkin any items that were skipped
			if ( count( $skipped_items_ids ) > 0 ) {
				$processed_item_ids = array_merge( $processed_item_ids, $skipped_items_ids );
			}
			$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 );
			$queue->close( $buffer, $processed_item_ids );
			// returning a WP_Error is a sign to the caller that we should wait a while
			// before syncing again
			if ( $had_wp_error ) {
				return $wp_error;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
			}
		}
		return true;
	}

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

	function get_full_sync_queue() {
		return $this->full_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;
	}

	function set_enqueue_wait_time( $seconds ) {
		$this->enqueue_wait_time = $seconds;
	}

	function get_enqueue_wait_time() {
		return $this->enqueue_wait_time;
	}

	// in seconds
	function set_sync_wait_threshold( $seconds ) {
		$this->sync_wait_threshold = $seconds;
	}

	function get_sync_wait_threshold() {
		return $this->sync_wait_threshold;
	}

	// in seconds
	function set_max_dequeue_time( $seconds ) {
		$this->max_dequeue_time = $seconds;
	}

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

		// saved settings
		Jetpack_Sync_Settings::set_importing( null );
		$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'] );
		$this->set_sync_wait_time( $settings['enqueue_wait_time'] );
		$this->set_sync_wait_threshold( $settings['sync_wait_threshold'] );
		$this->set_max_dequeue_time( Jetpack_Sync_Defaults::get_max_sync_execution_time() );
	}

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

		foreach ( Jetpack_Sync_Modules::get_modules() as $module ) {
			$module->reset_data();
		}
		
		foreach ( array( 'sync', 'full_sync' ) as $queue_name ) {
			delete_option( self::NEXT_SYNC_TIME_OPTION_NAME . '_' . $queue_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' );
	}
}


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-array-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 NEXT_SYNC_TIME_OPTION_NAME = 'jetpack_next_sync_time';
15			const WPCOM_ERROR_SYNC_DELAY = 60;
16			const QUEUE_LOCKED_SYNC_DELAY = 10;
17
18			private $dequeue_max_bytes;
19			private $upload_max_bytes;
20			private $upload_max_rows;
21			private $max_dequeue_time;
22			private $sync_wait_time;
23			private $sync_wait_threshold;
24			private $enqueue_wait_time;
25			private $sync_queue;
26			private $full_sync_queue;
27			private $codec;
28
29			// singleton functions
30			private static $instance;
31
32			public static function get_instance() {
33			if ( null === self::$instance ) {
34			self::$instance = new self();
35			}
36
37			return self::$instance;
38			}
39
40			// this is necessary because you can't use "new" when you declare instance properties >:(
41			protected function __construct() {
42			$this->set_defaults();
43			$this->init();
44			}
45
46			private function init() {
47			foreach ( Jetpack_Sync_Modules::get_modules() as $module ) {
48			$module->init_before_send();
49			}
50			}
51
52			public function get_next_sync_time( $queue_name ) {
53			return (double) get_option( self::NEXT_SYNC_TIME_OPTION_NAME . '_' . $queue_name, 0 );
54			}
55
56			public function set_next_sync_time( $time, $queue_name ) {
57			return update_option( self::NEXT_SYNC_TIME_OPTION_NAME . '_' . $queue_name, $time, true );
58			}
59
60			public function do_full_sync() {
61			$this->continue_full_sync_enqueue();
62			return $this->do_sync_and_set_delays( $this->full_sync_queue );
63			}
64
65			private function continue_full_sync_enqueue() {
66			if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
67			return false;
68			}
69
70			if ( $this->get_next_sync_time( 'full-sync-enqueue' ) > microtime( true ) ) {
71			return false;
72			}
73
74			Jetpack_Sync_Modules::get_module( 'full-sync' )->continue_enqueuing();
75
76			$this->set_next_sync_time( time() + $this->get_enqueue_wait_time(), 'full-sync-enqueue' );
77			}
78
79			public function do_sync() {
80			return $this->do_sync_and_set_delays( $this->sync_queue );
81			}
82
83			public function do_sync_and_set_delays( $queue ) {
84			// don't sync if importing
85			if ( defined( 'WP_IMPORTING' ) && WP_IMPORTING ) {
86			return false;
87			}
88
89			// don't sync if we are throttled
90			if ( $this->get_next_sync_time( $queue->id ) > microtime( true ) ) {
91			return false;
92			}
93
94			$start_time = microtime( true );
95
96			Jetpack_Sync_Settings::set_is_syncing( true );
97
98			$sync_result = $this->do_sync_for_queue( $queue );
99
100			Jetpack_Sync_Settings::set_is_syncing( false );
101
102			$exceeded_sync_wait_threshold = ( microtime( true ) - $start_time ) > (double) $this->get_sync_wait_threshold();
103
104			if ( is_wp_error( $sync_result ) ) {
105			if ( 'unclosed_buffer' === $sync_result->get_error_code() ) {
106			$this->set_next_sync_time( time() + self::QUEUE_LOCKED_SYNC_DELAY, $queue->id );
107			} else {
108			$this->set_next_sync_time( time() + self::WPCOM_ERROR_SYNC_DELAY, $queue->id );
109			}
110			$sync_result = false;
111			} elseif ( $exceeded_sync_wait_threshold ) {
112			// if we actually sent data and it took a while, wait before sending again
113			$this->set_next_sync_time( time() + $this->get_sync_wait_time(), $queue->id );
114			}
115
116			return $sync_result;
117			}
118
119			public function get_items_to_send( $buffer, $encode = true ) {
120			// track how long we've been processing so we can avoid request timeouts
121			$start_time = microtime( true );
122			$upload_size = 0;
123			$items_to_send = array();
124			$items = $buffer->get_items();
125			// set up current screen to avoid errors rendering content
126			require_once( ABSPATH . 'wp-admin/includes/class-wp-screen.php' );
127			require_once( ABSPATH . 'wp-admin/includes/screen.php' );
128			set_current_screen( 'sync' );
129			$skipped_items_ids = array();
130			// we estimate the total encoded size as we go by encoding each item individually
131			// this is expensive, but the only way to really know :/
132			foreach ( $items as $key => $item ) {
133			// Suspending cache addition help prevent overloading in memory cache of large sites.
134			wp_suspend_cache_addition( true );
135			/**
136			* Modify the data within an action before it is serialized and sent to the server
137			* For example, during full sync this expands Post ID's into full Post objects,
138			* so that we don't have to serialize the whole object into the queue.
139			*
140			* @since 4.2.0
141			*
142			* @param array The action parameters
143			* @param int The ID of the user who triggered the action
144			*/
145			$item[1] = apply_filters( 'jetpack_sync_before_send_' . $item[0], $item[1], $item[2] );
146			wp_suspend_cache_addition( false );
147			if ( $item[1] === false ) {
148			$skipped_items_ids[] = $key;
149			continue;
150			}
151			$encoded_item = $encode ? $this->codec->encode( $item ) : $item;
152			$upload_size += strlen( $encoded_item );
153			if ( $upload_size > $this->upload_max_bytes && count( $items_to_send ) > 0 ) {
154			break;
155			}
156			$items_to_send[ $key ] = $encoded_item;
157			if ( microtime(true) - $start_time > $this->max_dequeue_time ) {
158			break;
159			}
160			}
161
162			return array( $items_to_send, $skipped_items_ids, $items );
163			}
164
165			public function do_sync_for_queue( $queue ) {
166
167			do_action( 'jetpack_sync_before_send_queue_' . $queue->id );
168			if ( $queue->size() === 0 ) {
169			return false;
170			}
171			// now that we're sure we are about to sync, try to
172			// ignore user abort so we can avoid getting into a
173			// bad state
174			if ( function_exists( 'ignore_user_abort' ) ) {
175			ignore_user_abort( true );
176			}
177			$buffer = $queue->checkout_with_memory_limit( $this->dequeue_max_bytes, $this->upload_max_rows );
178			if ( ! $buffer ) {
179			// buffer has no items
180			return false;
181			}
182			if ( is_wp_error( $buffer ) ) {
183			return $buffer;
184			}
185
186			list( $items_to_send, $skipped_items_ids, $items ) = $this->get_items_to_send( $buffer, true );
187
188			/**
189			* Fires when data is ready to send to the server.
190			* Return false or WP_Error to abort the sync (e.g. if there's an error)
191			* The items will be automatically re-sent later
192			*
193			* @since 4.2.0
194			*
195			* @param array $data The action buffer
196			* @param string $codec The codec name used to encode the data
197			* @param double $time The current time
198			* @param string $queue The queue used to send ('sync' or 'full_sync')
199			*/
200			Jetpack_Sync_Settings::set_is_sending( true );
201			$processed_item_ids = apply_filters( 'jetpack_sync_send_data', $items_to_send, $this->codec->name(), microtime( true ), $queue->id );
202			Jetpack_Sync_Settings::set_is_sending( false );
203
204			if ( ! $processed_item_ids \|\| is_wp_error( $processed_item_ids ) ) {
205			$checked_in_item_ids = $queue->checkin( $buffer );
206			if ( is_wp_error( $checked_in_item_ids ) ) {
207			error_log( 'Error checking in buffer: ' . $checked_in_item_ids->get_error_message() );
208			$queue->force_checkin();
209			}
210			if ( is_wp_error( $processed_item_ids ) ) {
211			return $processed_item_ids;
212			}
213			// returning a WP_Error is a sign to the caller that we should wait a while
214			// before syncing again
215			return new WP_Error( 'server_error' );
216			} else {
217			// detect if the last item ID was an error
218			$had_wp_error = is_wp_error( end( $processed_item_ids ) );
219			if ( $had_wp_error ) {
220			$wp_error = array_pop( $processed_item_ids );
221			}
222			// also checkin any items that were skipped
223			if ( count( $skipped_items_ids ) > 0 ) {
224			$processed_item_ids = array_merge( $processed_item_ids, $skipped_items_ids );
225			}
226			$processed_items = array_intersect_key( $items, array_flip( $processed_item_ids ) );
227			/**
228			* Allows us to keep track of all the actions that have been sent.
229			* Allows us to calculate the progress of specific actions.
230			*
231			* @since 4.2.0
232			*
233			* @param array $processed_actions The actions that we send successfully.
234			*/
235			do_action( 'jetpack_sync_processed_actions', $processed_items );
236			$queue->close( $buffer, $processed_item_ids );
237			// returning a WP_Error is a sign to the caller that we should wait a while
238			// before syncing again
239			if ( $had_wp_error ) {
240			return $wp_error;
			0 ignored issues – show Bug introduced 2016-07-27 15:55 UTC by Report Bug Copy Issue Report The variable `$wp_error` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
241			}
242			}
243			return true;
244			}
245
246			function get_sync_queue() {
247			return $this->sync_queue;
248			}
249
250			function get_full_sync_queue() {
251			return $this->full_sync_queue;
252			}
253
254			function get_codec() {
255			return $this->codec;
256			}
257
258			function send_checksum() {
259			require_once 'class.jetpack-sync-wp-replicastore.php';
260			$store = new Jetpack_Sync_WP_Replicastore();
261			do_action( 'jetpack_sync_checksum', $store->checksum_all() );
262			}
263
264			function reset_sync_queue() {
265			$this->sync_queue->reset();
266			}
267
268			function set_dequeue_max_bytes( $size ) {
269			$this->dequeue_max_bytes = $size;
270			}
271
272			// in bytes
273			function set_upload_max_bytes( $max_bytes ) {
274			$this->upload_max_bytes = $max_bytes;
275			}
276
277			// in rows
278			function set_upload_max_rows( $max_rows ) {
279			$this->upload_max_rows = $max_rows;
280			}
281
282			// in seconds
283			function set_sync_wait_time( $seconds ) {
284			$this->sync_wait_time = $seconds;
285			}
286
287			function get_sync_wait_time() {
288			return $this->sync_wait_time;
289			}
290
291			function set_enqueue_wait_time( $seconds ) {
292			$this->enqueue_wait_time = $seconds;
293			}
294
295			function get_enqueue_wait_time() {
296			return $this->enqueue_wait_time;
297			}
298
299			// in seconds
300			function set_sync_wait_threshold( $seconds ) {
301			$this->sync_wait_threshold = $seconds;
302			}
303
304			function get_sync_wait_threshold() {
305			return $this->sync_wait_threshold;
306			}
307
308			// in seconds
309			function set_max_dequeue_time( $seconds ) {
310			$this->max_dequeue_time = $seconds;
311			}
312
313			function set_defaults() {
314			$this->sync_queue = new Jetpack_Sync_Queue( 'sync' );
315			$this->full_sync_queue = new Jetpack_Sync_Queue( 'full_sync' );
316			$this->codec = new Jetpack_Sync_JSON_Deflate_Array_Codec();
317
318			// saved settings
319			Jetpack_Sync_Settings::set_importing( null );
320			$settings = Jetpack_Sync_Settings::get_settings();
321			$this->set_dequeue_max_bytes( $settings['dequeue_max_bytes'] );
322			$this->set_upload_max_bytes( $settings['upload_max_bytes'] );
323			$this->set_upload_max_rows( $settings['upload_max_rows'] );
324			$this->set_sync_wait_time( $settings['sync_wait_time'] );
325			$this->set_sync_wait_time( $settings['enqueue_wait_time'] );
326			$this->set_sync_wait_threshold( $settings['sync_wait_threshold'] );
327			$this->set_max_dequeue_time( Jetpack_Sync_Defaults::get_max_sync_execution_time() );
328			}
329
330			function reset_data() {
331			$this->reset_sync_queue();
332
333			foreach ( Jetpack_Sync_Modules::get_modules() as $module ) {
334			$module->reset_data();
335			}
336
337			foreach ( array( 'sync', 'full_sync' ) as $queue_name ) {
338			delete_option( self::NEXT_SYNC_TIME_OPTION_NAME . '_' . $queue_name );
339			}
340
341			Jetpack_Sync_Settings::reset_data();
342			}
343
344			function uninstall() {
345			// Lets delete all the other fun stuff like transient and option and the sync queue
346			$this->reset_data();
347
348			// delete the full sync status
349			delete_option( 'jetpack_full_sync_status' );
350
351			// clear the sync cron.
352			wp_clear_scheduled_hook( 'jetpack_sync_cron' );
353			}
354			}
355

Automattic / jetpack

Push — fix/non-admin-no-ui-when-prote... ( 85feb2 )

Jetpack_Sync_Sender::get_enqueue_wait_time() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like