Jetpack_Sync_Module_Full_Sync::expand_options() - Code Metrics - Inspection of "Refactor full sync code into modules" - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — fix/refactor-full-sync-status-... ( d41df7 )

unknown

created 2016-07-08 21:47 UTC

Jetpack_Sync_Module_Full_Sync::expand_options() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	4
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	7
rs	9.4285

<?php

/**
 * This class does a full resync of the database by
 * enqueuing an outbound action for every single object
 * that we care about.
 *
 * This class contains a few non-obvious optimisations that should be explained:
 * - we fire an action called jetpack_full_sync_start so that WPCOM can erase the contents of the cached database
 * - for each object type, we obtain a full list of object IDs to sync via a single API call (hoping that since they're ints, they can all fit in RAM)
 * - we load the full objects for those IDs in chunks of Jetpack_Sync_Full::ARRAY_CHUNK_SIZE (to reduce the number of MySQL calls)
 * - we fire a trigger for the entire array which the Jetpack_Sync_Sender then serializes and queues.
 */

require_once 'class.jetpack-sync-wp-replicastore.php';

class Jetpack_Sync_Module_Full_Sync extends Jetpack_Sync_Module {
	static $status_option = 'jetpack_full_sync_status';
class A {
    var $property;
}
	static $transient_timeout = 3600; // an hour
class A {
    var $property;
}
	static $modules = array(
class A {
    var $property;
}
		'wp_version',
		'constants',
		'functions',
		'options',
		'posts',
		'comments',
		'themes',
		'updates',
		'users',
		'terms',
		'network_options',
	);

	private $sender;

	public function name() {
		return 'full-sync';
	}

	function init_listeners( $callable ) {
		// synthetic actions for full sync
		add_action( 'jetpack_full_sync_start', $callable );
		add_action( 'jetpack_full_sync_end', $callable );
	}

	function init_before_send() {
		// this is triggered after actions have been processed on the server
		add_action( 'jetpack_sync_processed_actions', array( $this, 'update_sent_progress_action' ) );
	}

	function start() {
		if( ! $this->should_start_full_sync() ) {
			return false;
		}
		/**
		 * Fires when a full sync begins. This action is serialized
		 * and sent to the server so that it can clear the replica storage,
		 * and/or reset other data.
		 *
		 * @since 4.2.0
		 */
		do_action( 'jetpack_full_sync_start' );
		$this->set_status_queuing_started();

		foreach( Jetpack_Sync_Modules::get_modules() as $module ) {
			$module->full_sync();
		}
		if ( is_multisite() ) {
			$this->enqueue_all_network_options();
		}

		$this->set_status_queuing_finished();

		$store = new Jetpack_Sync_WP_Replicastore();
		do_action( 'jetpack_full_sync_end', $store->checksum_all() );
		return true;
	}

	private function should_start_full_sync() {
		$status = $this->get_status();
		// We should try sync if we haven't started it yet or if we have finished it.
		if( is_null( $status['started'] ) || is_integer( $status['finished'] ) ) {
			return true;
		}
		return false;
	}

	private function get_sender() {

		if ( ! $this->sender ) {
			$this->sender = Jetpack_Sync_Sender::getInstance();
		}

		return $this->sender;
	}

	private function enqueue_all_network_options() {
		$total = Jetpack_Sync_Modules::get_module( "options" )->full_sync_network();
		$this->update_queue_progress( 'network_options', $total );
	}

	function update_sent_progress_action( $actions_sent ) {
		$modules_count = array();
		$status = $this->get_status();
		if ( is_null( $status['started'] ) || $status['finished'] ) {
			return;
		}

		if ( in_array( 'jetpack_full_sync_start', $actions_sent ) ) {
			$this->set_status_sending_started();
			$status['sent_started'] = time();
		}

		foreach( $actions_sent as $action ) {
			$module_key = $this->action_to_modules( $action );
			if ( $module_key ) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
				$modules_count[ $module_key ] = isset( $modules_count[ $module_key ] ) ?  $modules_count[ $module_key ] + 1 : 1;
			}
		}

		foreach( $modules_count as $module => $count ) {
			$status[ 'sent' ][ $module ] = $this->update_sent_progress( $module, $count );
		}

		if ( in_array( 'jetpack_full_sync_end', $actions_sent ) ) {
			$this->set_status_sending_finished();
			$status['finished'] = time();
		}

		$this->update_status( $status );
	}

	function action_to_modules( $action ) {
		switch( $action ) {
			case 'jetpack_full_sync_constants':
				return 'constants';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_callables':
				return 'functions';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_options':
				return 'options';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_network_options':
				return 'network_options';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_terms':
				return 'terms';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_sync_current_theme_support':
				return 'themes';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_users':
				return 'users';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_posts':
				return 'posts';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_comments':
				return 'comments';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

			case 'jetpack_full_sync_updates':
				return 'updates';
				break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

		}
		return null;
	}

	private function set_status_queuing_started() {
		$status = $this->initial_status;
		$status[ 'started' ] = time();
		$this->update_status( $status );
	}

	private function set_status_queuing_finished() {
		$this->update_status( array( 'queue_finished' => time() ) );
	}

	// these are called by the Sync Client when it sees that the full sync start/end actions have actually been transmitted
	public function set_status_sending_started() {
		/**
		 * Fires when the full_sync_start action is actually transmitted.
		 * This is useful for telling the user the status of full synchronization.
		 *
		 * @since 4.2.0
		 */

		do_action( 'jetpack_full_sync_start_sent' );

	}

	public function set_status_sending_finished() {
		/**
		 * Fires when the full_sync_end action is actually transmitted.
		 * This is useful for telling the user the status of full synchronization.
		 *
		 * @since 4.2.0
		 */
		do_action( 'jetpack_full_sync_end_sent' );
	}

	private $initial_status = array(
		'started' => null,
		'queue_finished' => null,
		'sent_started' => null,
		'finished' => null,
		'sent' => array(),
		'queue' => array(),
	);

	public function get_status() {
		return get_option( self::$status_option, $this->initial_status );
	}


	public function update_status( $status ) {
		return update_option(
			self::$status_option,
			array_merge( $this->get_status(), $status )
		);
	}

	private function clear_status() {

		delete_option( self::$status_option );
	}

	public function update_sent_progress( $module, $data ) {
		$status = $this->get_status();
		if ( isset( $status['sent'][ $module ] ) )  {
			return $data + $status['sent'][ $module ];
		} else {
			return $data;
		}
	}

}


1			<?php
2
3			/**
4			* This class does a full resync of the database by
5			* enqueuing an outbound action for every single object
6			* that we care about.
7			*
8			* This class contains a few non-obvious optimisations that should be explained:
9			* - we fire an action called jetpack_full_sync_start so that WPCOM can erase the contents of the cached database
10			* - for each object type, we obtain a full list of object IDs to sync via a single API call (hoping that since they're ints, they can all fit in RAM)
11			* - we load the full objects for those IDs in chunks of Jetpack_Sync_Full::ARRAY_CHUNK_SIZE (to reduce the number of MySQL calls)
12			* - we fire a trigger for the entire array which the Jetpack_Sync_Sender then serializes and queues.
13			*/
14
15			require_once 'class.jetpack-sync-wp-replicastore.php';
16
17			class Jetpack_Sync_Module_Full_Sync extends Jetpack_Sync_Module {
18			static $status_option = 'jetpack_full_sync_status';
			0 ignored issues – show Coding Style introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$status_option`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
19			static $transient_timeout = 3600; // an hour
			0 ignored issues – show Coding Style introduced 2016-04-21 22:18 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$transient_timeout`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
20			static $modules = array(
			0 ignored issues – show Coding Style introduced 2016-05-04 15:49 UTC by Report Bug Copy Issue Report The visibility should be declared for property `$modules`. The PSR-2 coding standard requires that all properties in a class have their visibility explicitly declared. If you declare a property using class A { var $property; } the property is implicitly global. To learn more about the PSR-2, please see the PHP-FIG site on the PSR-2. Loading history...
21			'wp_version',
22			'constants',
23			'functions',
24			'options',
25			'posts',
26			'comments',
27			'themes',
28			'updates',
29			'users',
30			'terms',
31			'network_options',
32			);
33
34			private $sender;
35
36			public function name() {
37			return 'full-sync';
38			}
39
40			function init_listeners( $callable ) {
41			// synthetic actions for full sync
42			add_action( 'jetpack_full_sync_start', $callable );
43			add_action( 'jetpack_full_sync_end', $callable );
44			}
45
46			function init_before_send() {
47			// this is triggered after actions have been processed on the server
48			add_action( 'jetpack_sync_processed_actions', array( $this, 'update_sent_progress_action' ) );
49			}
50
51			function start() {
52			if( ! $this->should_start_full_sync() ) {
53			return false;
54			}
55			/**
56			* Fires when a full sync begins. This action is serialized
57			* and sent to the server so that it can clear the replica storage,
58			* and/or reset other data.
59			*
60			* @since 4.2.0
61			*/
62			do_action( 'jetpack_full_sync_start' );
63			$this->set_status_queuing_started();
64
65			foreach( Jetpack_Sync_Modules::get_modules() as $module ) {
66			$module->full_sync();
67			}
68			if ( is_multisite() ) {
69			$this->enqueue_all_network_options();
70			}
71
72			$this->set_status_queuing_finished();
73
74			$store = new Jetpack_Sync_WP_Replicastore();
75			do_action( 'jetpack_full_sync_end', $store->checksum_all() );
76			return true;
77			}
78
79			private function should_start_full_sync() {
80			$status = $this->get_status();
81			// We should try sync if we haven't started it yet or if we have finished it.
82			if( is_null( $status['started'] ) \|\| is_integer( $status['finished'] ) ) {
83			return true;
84			}
85			return false;
86			}
87
88			private function get_sender() {
			0 ignored issues – show Unused Code introduced 2016-06-30 04:43 UTC by Report Bug Copy Issue Report This method is not used, and could be removed. Loading history...
89			if ( ! $this->sender ) {
90			$this->sender = Jetpack_Sync_Sender::getInstance();
91			}
92
93			return $this->sender;
94			}
95
96			private function enqueue_all_network_options() {
97			$total = Jetpack_Sync_Modules::get_module( "options" )->full_sync_network();
98			$this->update_queue_progress( 'network_options', $total );
99			}
100
101			function update_sent_progress_action( $actions_sent ) {
102			$modules_count = array();
103			$status = $this->get_status();
104			if ( is_null( $status['started'] ) \|\| $status['finished'] ) {
105			return;
106			}
107
108			if ( in_array( 'jetpack_full_sync_start', $actions_sent ) ) {
109			$this->set_status_sending_started();
110			$status['sent_started'] = time();
111			}
112
113			foreach( $actions_sent as $action ) {
114			$module_key = $this->action_to_modules( $action );
115			if ( $module_key ) {
			0 ignored issues – show Bug Best Practice introduced 2016-06-15 01:28 UTC by Report Bug Copy Issue Report The expression `$module_key` of type `string\|null` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
116			$modules_count[ $module_key ] = isset( $modules_count[ $module_key ] ) ? $modules_count[ $module_key ] + 1 : 1;
117			}
118			}
119
120			foreach( $modules_count as $module => $count ) {
121			$status[ 'sent' ][ $module ] = $this->update_sent_progress( $module, $count );
122			}
123
124			if ( in_array( 'jetpack_full_sync_end', $actions_sent ) ) {
125			$this->set_status_sending_finished();
126			$status['finished'] = time();
127			}
128
129			$this->update_status( $status );
130			}
131
132			function action_to_modules( $action ) {
133			switch( $action ) {
134			case 'jetpack_full_sync_constants':
135			return 'constants';
136			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
137
138			case 'jetpack_full_sync_callables':
139			return 'functions';
140			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
141
142			case 'jetpack_full_sync_options':
143			return 'options';
144			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
145
146			case 'jetpack_full_sync_network_options':
147			return 'network_options';
148			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
149
150			case 'jetpack_full_sync_terms':
151			return 'terms';
152			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
153
154			case 'jetpack_sync_current_theme_support':
155			return 'themes';
156			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
157
158			case 'jetpack_full_sync_users':
159			return 'users';
160			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
161
162			case 'jetpack_full_sync_posts':
163			return 'posts';
164			break;
			0 ignored issues – show Unused Code introduced 2016-07-07 17:09 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
165
166			case 'jetpack_full_sync_comments':
167			return 'comments';
168			break;
			0 ignored issues – show Unused Code introduced 2016-06-30 19:10 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
169
170			case 'jetpack_full_sync_updates':
171			return 'updates';
172			break;
			0 ignored issues – show Unused Code introduced 2016-06-30 19:10 UTC by Report Bug Copy Issue Report `break` is not strictly necessary here and could be removed. The `break` statement is not necessary if it is preceded for example by a `return` statement: switch ($x) { case 1: return 'foo'; break; // This break is not necessary and can be left off. } If you would like to keep this construct to be consistent with other `case` statements, you can safely mark this issue as a false-positive. Loading history...
173
174			}
175			return null;
176			}
177
178			private function set_status_queuing_started() {
179			$status = $this->initial_status;
180			$status[ 'started' ] = time();
181			$this->update_status( $status );
182			}
183
184			private function set_status_queuing_finished() {
185			$this->update_status( array( 'queue_finished' => time() ) );
186			}
187
188			// these are called by the Sync Client when it sees that the full sync start/end actions have actually been transmitted
189			public function set_status_sending_started() {
190			/**
191			* Fires when the full_sync_start action is actually transmitted.
192			* This is useful for telling the user the status of full synchronization.
193			*
194			* @since 4.2.0
195			*/
196
197			do_action( 'jetpack_full_sync_start_sent' );
198
199			}
200
201			public function set_status_sending_finished() {
202			/**
203			* Fires when the full_sync_end action is actually transmitted.
204			* This is useful for telling the user the status of full synchronization.
205			*
206			* @since 4.2.0
207			*/
208			do_action( 'jetpack_full_sync_end_sent' );
209			}
210
211			private $initial_status = array(
212			'started' => null,
213			'queue_finished' => null,
214			'sent_started' => null,
215			'finished' => null,
216			'sent' => array(),
217			'queue' => array(),
218			);
219
220			public function get_status() {
221			return get_option( self::$status_option, $this->initial_status );
222			}
223
224
225			public function update_status( $status ) {
226			return update_option(
227			self::$status_option,
228			array_merge( $this->get_status(), $status )
229			);
230			}
231
232			private function clear_status() {
			0 ignored issues – show Unused Code introduced 2016-06-15 19:18 UTC by Report Bug Copy Issue Report This method is not used, and could be removed. Loading history...
233			delete_option( self::$status_option );
234			}
235
236			public function update_sent_progress( $module, $data ) {
237			$status = $this->get_status();
238			if ( isset( $status['sent'][ $module ] ) ) {
239			return $data + $status['sent'][ $module ];
240			} else {
241			return $data;
242			}
243			}
244
245			}
246

Automattic / jetpack

Push — fix/refactor-full-sync-status-... ( d41df7 )

Jetpack_Sync_Module_Full_Sync::expand_options() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like