Listener::init() - Code Metrics - Inspection of "Add change file." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — fix/nav-uni-simple-themes ( ceaeab...4fc151 )

by Kirk

created 2021-04-12 21:21 UTC

Listener::init() A

↳ Parent: Listener

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
nc	2
nop	0
dl	0
loc	19
rs	9.6333
c	0
b	0
f	0

<?php
/**
 * Jetpack's Sync Listener
 *
 * @package automattic/jetpack-sync
 */

namespace Automattic\Jetpack\Sync;

use Automattic\Jetpack\Roles;

/**
 * This class monitors actions and logs them to the queue to be sent.
 */
class Listener {
	const QUEUE_STATE_CHECK_TRANSIENT = 'jetpack_sync_last_checked_queue_state';
	const QUEUE_STATE_CHECK_TIMEOUT   = 300; // 5 minutes.

	/**
	 * Sync queue.
	 *
	 * @var object
	 */
	private $sync_queue;

	/**
	 * Full sync queue.
	 *
	 * @var object
	 */
	private $full_sync_queue;

	/**
	 * Sync queue size limit.
	 *
	 * @var int size limit.
	 */
	private $sync_queue_size_limit;

	/**
	 * Sync queue lag limit.
	 *
	 * @var int Lag limit.
	 */
	private $sync_queue_lag_limit;

	/**
	 * Singleton implementation.
	 *
	 * @var Listener
	 */
	private static $instance;

	/**
	 * Get the Listener instance.
	 *
	 * @return Listener
	 */
	public static function get_instance() {
		if ( null === self::$instance ) {
			self::$instance = new self();
		}

		return self::$instance;
	}

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

	/**
	 * Sync Listener init.
	 */
	private function init() {
		$handler           = array( $this, 'action_handler' );
		$full_sync_handler = array( $this, 'full_sync_action_handler' );

		foreach ( Modules::get_modules() as $module ) {
			$module->init_listeners( $handler );
			$module->init_full_sync_listeners( $full_sync_handler );
		}

		// Module Activation.
		add_action( 'jetpack_activate_module', $handler );
		add_action( 'jetpack_deactivate_module', $handler );

		// Jetpack Upgrade.
		add_action( 'updating_jetpack_version', $handler, 10, 2 );

		// Send periodic checksum.
		add_action( 'jetpack_sync_checksum', $handler );
	}

	/**
	 * Get incremental sync queue.
	 */
	public function get_sync_queue() {
		return $this->sync_queue;
	}

	/**
	 * Gets the full sync queue.
	 */
	public function get_full_sync_queue() {
		return $this->full_sync_queue;
	}

	/**
	 * Sets queue size limit.
	 *
	 * @param int $limit Queue size limit.
	 */
	public function set_queue_size_limit( $limit ) {
		$this->sync_queue_size_limit = $limit;
	}

	/**
	 * Get queue size limit.
	 */
	public function get_queue_size_limit() {
		return $this->sync_queue_size_limit;
	}

	/**
	 * Sets the queue lag limit.
	 *
	 * @param int $age Queue lag limit.
	 */
	public function set_queue_lag_limit( $age ) {
		$this->sync_queue_lag_limit = $age;
	}

	/**
	 * Return value of queue lag limit.
	 */
	public function get_queue_lag_limit() {
		return $this->sync_queue_lag_limit;
	}

	/**
	 * Force a recheck of the queue limit.
	 */
	public function force_recheck_queue_limit() {
		delete_transient( self::QUEUE_STATE_CHECK_TRANSIENT . '_' . $this->sync_queue->id );
		delete_transient( self::QUEUE_STATE_CHECK_TRANSIENT . '_' . $this->full_sync_queue->id );
	}

	/**
	 * Determine if an item can be added to the queue.
	 *
	 * Prevent adding items to the queue if it hasn't sent an item for 15 mins
	 * AND the queue is over 1000 items long (by default).
	 *
	 * @param object $queue Sync queue.
	 * @return bool
	 */
	public function can_add_to_queue( $queue ) {
		if ( ! Settings::is_sync_enabled() ) {
			return false;
		}

		$state_transient_name = self::QUEUE_STATE_CHECK_TRANSIENT . '_' . $queue->id;

		$queue_state = get_transient( $state_transient_name );

		if ( false === $queue_state ) {
			$queue_state = array( $queue->size(), $queue->lag() );
			set_transient( $state_transient_name, $queue_state, self::QUEUE_STATE_CHECK_TIMEOUT );
		}

		list( $queue_size, $queue_age ) = $queue_state;

		return ( $queue_age < $this->sync_queue_lag_limit )
			||
			( ( $queue_size + 1 ) < $this->sync_queue_size_limit );
	}

	/**
	 * Full sync action handler.
	 *
	 * @param mixed ...$args Args passed to the action.
	 */
	public function full_sync_action_handler( ...$args ) {
		$this->enqueue_action( current_filter(), $args, $this->full_sync_queue );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	/**
	 * Action handler.
	 *
	 * @param mixed ...$args Args passed to the action.
	 */
	public function action_handler( ...$args ) {
		$this->enqueue_action( current_filter(), $args, $this->sync_queue );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
	}

	// add many actions to the queue directly, without invoking them.

	/**
	 * Bulk add action to the queue.
	 *
	 * @param string $action_name The name the full sync action.
	 * @param array  $args_array Array of chunked arguments.
	 */
	public function bulk_enqueue_full_sync_actions( $action_name, $args_array ) {
		$queue = $this->get_full_sync_queue();

		/*
		 * If we add any items to the queue, we should try to ensure that our script
		 * can't be killed before they are sent.
		 */
		if ( function_exists( 'ignore_user_abort' ) ) {
			ignore_user_abort( true );
		}

		$data_to_enqueue = array();
		$user_id         = get_current_user_id();
		$currtime        = microtime( true );
		$is_importing    = Settings::is_importing();

		foreach ( $args_array as $args ) {
			$previous_end = isset( $args['previous_end'] ) ? $args['previous_end'] : null;
			$args         = isset( $args['ids'] ) ? $args['ids'] : $args;

			/**
			 * Modify or reject the data within an action before it is enqueued locally.
			 *
			 * @since 4.2.0
			 *
			 * @module sync
			 *
			 * @param array The action parameters
			 */
			$args        = apply_filters( "jetpack_sync_before_enqueue_$action_name", $args );
			$action_data = array( $args );
			if ( ! is_null( $previous_end ) ) {
				$action_data[] = $previous_end;
			}
			// allow listeners to abort.
			if ( false === $args ) {
				continue;
			}

			$data_to_enqueue[] = array(
				$action_name,
				$action_data,
				$user_id,
				$currtime,
				$is_importing,
			);
		}

		$queue->add_all( $data_to_enqueue );
	}

	/**
	 * Enqueue the action.
	 *
	 * @param string $current_filter Current WordPress filter.
	 * @param object $args Sync args.
	 * @param string $queue Sync queue.
	 */
	public function enqueue_action( $current_filter, $args, $queue ) {
		// don't enqueue an action during the outbound http request - this prevents recursion.
		if ( Settings::is_sending() ) {
			return;
		}

		/**
		 * Add an action hook to execute when anything on the whitelist gets sent to the queue to sync.
		 *
		 * @module sync
		 *
		 * @since 5.9.0
		 */
		do_action( 'jetpack_sync_action_before_enqueue' );

		/**
		 * Modify or reject the data within an action before it is enqueued locally.
		 *
		 * @since 4.2.0
		 *
		 * @param array The action parameters
		 */
		$args = apply_filters( "jetpack_sync_before_enqueue_$current_filter", $args );

		// allow listeners to abort.
		if ( false === $args ) {
			return;
		}

		/*
		 * Periodically check the size of the queue, and disable adding to it if
		 * it exceeds some limit AND the oldest item exceeds the age limit (i.e. sending has stopped).
		 */
		if ( ! $this->can_add_to_queue( $queue ) ) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
			if ( 'sync' === $queue->id ) {
				$this->sync_data_loss( $queue );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
			}
			return;
		}

		/*
		 * If we add any items to the queue, we should try to ensure that our script
		 * can't be killed before they are sent.
		 */
		if ( function_exists( 'ignore_user_abort' ) ) {
			ignore_user_abort( true );
		}

		if (
			'sync' === $queue->id ||
			in_array(
				$current_filter,
				array(
					'jetpack_full_sync_start',
					'jetpack_full_sync_end',
					'jetpack_full_sync_cancel',
				),
				true
			)
		) {
			$queue->add(

				array(
					$current_filter,
					$args,
					get_current_user_id(),
					microtime( true ),
					Settings::is_importing(),
					$this->get_actor( $current_filter, $args ),
				)
			);
		} else {
			$queue->add(

				array(
					$current_filter,
					$args,
					get_current_user_id(),
					microtime( true ),
					Settings::is_importing(),
				)
			);
		}

		// since we've added some items, let's try to load the sender so we can send them as quickly as possible.
		if ( ! Actions::$sender ) {
			add_filter( 'jetpack_sync_sender_should_load', __NAMESPACE__ . '\Actions::should_initialize_sender_enqueue', 10, 1 );
			if ( did_action( 'init' ) ) {
				Actions::add_sender_shutdown();
			}
		}
	}

	/**
	 * Sync Data Loss Handler
	 *
	 * @param Queue $queue Sync queue.
	 * @return boolean was send successful
	 */
	public function sync_data_loss( $queue ) {
		if ( ! Settings::is_sync_enabled() ) {
			return;
		}
		$updated = Health::update_status( Health::STATUS_OUT_OF_SYNC );

		if ( ! $updated ) {
			return;
		}

		$data = array(
			'timestamp'  => microtime( true ),
			'queue_size' => $queue->size(),
			'queue_lag'  => $queue->lag(),
		);

		$sender = Sender::get_instance();
		return $sender->send_action( 'jetpack_sync_data_loss', $data );
	}

	/**
	 * Get the event's actor.
	 *
	 * @param string $current_filter Current wp-admin page.
	 * @param object $args Sync event.
	 * @return array Actor information.
	 */
	public function get_actor( $current_filter, $args ) {
		if ( 'wp_login' === $current_filter ) {
			$user = get_user_by( 'ID', $args[1]->data->ID );
		} else {
			$user = wp_get_current_user();
		}

		$roles           = new Roles();
		$translated_role = $roles->translate_user_to_role( $user );

		$actor = array(
			'wpcom_user_id'    => null,
			'external_user_id' => isset( $user->ID ) ? $user->ID : null,
			'display_name'     => isset( $user->display_name ) ? $user->display_name : null,
			'user_email'       => isset( $user->user_email ) ? $user->user_email : null,
			'user_roles'       => isset( $user->roles ) ? $user->roles : null,
			'translated_role'  => $translated_role ? $translated_role : null,
			'is_cron'          => defined( 'DOING_CRON' ) ? DOING_CRON : false,
			'is_rest'          => defined( 'REST_API_REQUEST' ) ? REST_API_REQUEST : false,
			'is_xmlrpc'        => defined( 'XMLRPC_REQUEST' ) ? XMLRPC_REQUEST : false,
			'is_wp_rest'       => defined( 'REST_REQUEST' ) ? REST_REQUEST : false,
			'is_ajax'          => defined( 'DOING_AJAX' ) ? DOING_AJAX : false,
			'is_wp_admin'      => is_admin(),
			'is_cli'           => defined( 'WP_CLI' ) ? WP_CLI : false,
			'from_url'         => $this->get_request_url(),
		);

		if ( $this->should_send_user_data_with_actor( $current_filter ) ) {
			$ip = isset( $_SERVER['REMOTE_ADDR'] ) ? $_SERVER['REMOTE_ADDR'] : '';
			if ( defined( 'JETPACK__PLUGIN_DIR' ) ) {
				if ( ! function_exists( 'jetpack_protect_get_ip' ) ) {
					require_once JETPACK__PLUGIN_DIR . 'modules/protect/shared-functions.php';
				}
				$ip = jetpack_protect_get_ip();
			}

			$actor['ip']         = $ip;
			$actor['user_agent'] = isset( $_SERVER['HTTP_USER_AGENT'] ) ? $_SERVER['HTTP_USER_AGENT'] : 'unknown';
		}

		return $actor;
	}

	/**
	 * Should user data be sent as the actor?
	 *
	 * @param string $current_filter The current WordPress filter being executed.
	 * @return bool
	 */
	public function should_send_user_data_with_actor( $current_filter ) {
		$should_send = in_array( $current_filter, array( 'jetpack_wp_login', 'wp_logout', 'jetpack_valid_failed_login_attempt' ), true );
		/**
		 * Allow or deny sending actor's user data ( IP and UA ) during a sync event
		 *
		 * @since 5.8.0
		 *
		 * @module sync
		 *
		 * @param bool True if we should send user data
		 * @param string The current filter that is performing the sync action
		 */
		return apply_filters( 'jetpack_sync_actor_user_data', $should_send, $current_filter );

	}

	/**
	 * Sets Listener defaults.
	 */
	public function set_defaults() {
		$this->sync_queue      = new Queue( 'sync' );
		$this->full_sync_queue = new Queue( 'full_sync' );
		$this->set_queue_size_limit( Settings::get_setting( 'max_queue_size' ) );
		$this->set_queue_lag_limit( Settings::get_setting( 'max_queue_lag' ) );
	}

	/**
	 * Get the request URL.
	 *
	 * @return string Request URL, if known. Otherwise, wp-admin or home_url.
	 */
	public function get_request_url() {
		if ( isset( $_SERVER['HTTP_HOST'], $_SERVER['REQUEST_URI'] ) ) {
			return 'http' . ( isset( $_SERVER['HTTPS'] ) ? 's' : '' ) . '://' . "{$_SERVER['HTTP_HOST']}{$_SERVER['REQUEST_URI']}";
		}
		return is_admin() ? get_admin_url( get_current_blog_id() ) : home_url();
	}
}


1			<?php
2			/**
3			* Jetpack's Sync Listener
4			*
5			* @package automattic/jetpack-sync
6			*/
7
8			namespace Automattic\Jetpack\Sync;
9
10			use Automattic\Jetpack\Roles;
11
12			/**
13			* This class monitors actions and logs them to the queue to be sent.
14			*/
15			class Listener {
16			const QUEUE_STATE_CHECK_TRANSIENT = 'jetpack_sync_last_checked_queue_state';
17			const QUEUE_STATE_CHECK_TIMEOUT = 300; // 5 minutes.
18
19			/**
20			* Sync queue.
21			*
22			* @var object
23			*/
24			private $sync_queue;
25
26			/**
27			* Full sync queue.
28			*
29			* @var object
30			*/
31			private $full_sync_queue;
32
33			/**
34			* Sync queue size limit.
35			*
36			* @var int size limit.
37			*/
38			private $sync_queue_size_limit;
39
40			/**
41			* Sync queue lag limit.
42			*
43			* @var int Lag limit.
44			*/
45			private $sync_queue_lag_limit;
46
47			/**
48			* Singleton implementation.
49			*
50			* @var Listener
51			*/
52			private static $instance;
53
54			/**
55			* Get the Listener instance.
56			*
57			* @return Listener
58			*/
59			public static function get_instance() {
60			if ( null === self::$instance ) {
61			self::$instance = new self();
62			}
63
64			return self::$instance;
65			}
66
67			/**
68			* Listener constructor.
69			*
70			* This is necessary because you can't use "new" when you declare instance properties >:(
71			*/
72			protected function __construct() {
73			$this->set_defaults();
74			$this->init();
75			}
76
77			/**
78			* Sync Listener init.
79			*/
80			private function init() {
81			$handler = array( $this, 'action_handler' );
82			$full_sync_handler = array( $this, 'full_sync_action_handler' );
83
84			foreach ( Modules::get_modules() as $module ) {
85			$module->init_listeners( $handler );
86			$module->init_full_sync_listeners( $full_sync_handler );
87			}
88
89			// Module Activation.
90			add_action( 'jetpack_activate_module', $handler );
91			add_action( 'jetpack_deactivate_module', $handler );
92
93			// Jetpack Upgrade.
94			add_action( 'updating_jetpack_version', $handler, 10, 2 );
95
96			// Send periodic checksum.
97			add_action( 'jetpack_sync_checksum', $handler );
98			}
99
100			/**
101			* Get incremental sync queue.
102			*/
103			public function get_sync_queue() {
104			return $this->sync_queue;
105			}
106
107			/**
108			* Gets the full sync queue.
109			*/
110			public function get_full_sync_queue() {
111			return $this->full_sync_queue;
112			}
113
114			/**
115			* Sets queue size limit.
116			*
117			* @param int $limit Queue size limit.
118			*/
119			public function set_queue_size_limit( $limit ) {
120			$this->sync_queue_size_limit = $limit;
121			}
122
123			/**
124			* Get queue size limit.
125			*/
126			public function get_queue_size_limit() {
127			return $this->sync_queue_size_limit;
128			}
129
130			/**
131			* Sets the queue lag limit.
132			*
133			* @param int $age Queue lag limit.
134			*/
135			public function set_queue_lag_limit( $age ) {
136			$this->sync_queue_lag_limit = $age;
137			}
138
139			/**
140			* Return value of queue lag limit.
141			*/
142			public function get_queue_lag_limit() {
143			return $this->sync_queue_lag_limit;
144			}
145
146			/**
147			* Force a recheck of the queue limit.
148			*/
149			public function force_recheck_queue_limit() {
150			delete_transient( self::QUEUE_STATE_CHECK_TRANSIENT . '_' . $this->sync_queue->id );
151			delete_transient( self::QUEUE_STATE_CHECK_TRANSIENT . '_' . $this->full_sync_queue->id );
152			}
153
154			/**
155			* Determine if an item can be added to the queue.
156			*
157			* Prevent adding items to the queue if it hasn't sent an item for 15 mins
158			* AND the queue is over 1000 items long (by default).
159			*
160			* @param object $queue Sync queue.
161			* @return bool
162			*/
163			public function can_add_to_queue( $queue ) {
164			if ( ! Settings::is_sync_enabled() ) {
165			return false;
166			}
167
168			$state_transient_name = self::QUEUE_STATE_CHECK_TRANSIENT . '_' . $queue->id;
169
170			$queue_state = get_transient( $state_transient_name );
171
172			if ( false === $queue_state ) {
173			$queue_state = array( $queue->size(), $queue->lag() );
174			set_transient( $state_transient_name, $queue_state, self::QUEUE_STATE_CHECK_TIMEOUT );
175			}
176
177			list( $queue_size, $queue_age ) = $queue_state;
178
179			return ( $queue_age < $this->sync_queue_lag_limit )
180			\|\|
181			( ( $queue_size + 1 ) < $this->sync_queue_size_limit );
182			}
183
184			/**
185			* Full sync action handler.
186			*
187			* @param mixed ...$args Args passed to the action.
188			*/
189			public function full_sync_action_handler( ...$args ) {
190			$this->enqueue_action( current_filter(), $args, $this->full_sync_queue );
			0 ignored issues – show Documentation introduced 2019-10-29 05:35 UTC by Report Bug Copy Issue Report `$args` is of type `array<integer,*>`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history... Documentation introduced 2019-10-29 05:35 UTC by Report Bug Copy Issue Report `$this->full_sync_queue` is of type `object`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
191			}
192
193			/**
194			* Action handler.
195			*
196			* @param mixed ...$args Args passed to the action.
197			*/
198			public function action_handler( ...$args ) {
199			$this->enqueue_action( current_filter(), $args, $this->sync_queue );
			0 ignored issues – show Documentation introduced 2019-10-29 05:35 UTC by Report Bug Copy Issue Report `$args` is of type `array<integer,*>`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history... Documentation introduced 2019-10-29 05:35 UTC by Report Bug Copy Issue Report `$this->sync_queue` is of type `object`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
200			}
201
202			// add many actions to the queue directly, without invoking them.
203
204			/**
205			* Bulk add action to the queue.
206			*
207			* @param string $action_name The name the full sync action.
208			* @param array $args_array Array of chunked arguments.
209			*/
210			public function bulk_enqueue_full_sync_actions( $action_name, $args_array ) {
211			$queue = $this->get_full_sync_queue();
212
213			/*
214			* If we add any items to the queue, we should try to ensure that our script
215			* can't be killed before they are sent.
216			*/
217			if ( function_exists( 'ignore_user_abort' ) ) {
218			ignore_user_abort( true );
219			}
220
221			$data_to_enqueue = array();
222			$user_id = get_current_user_id();
223			$currtime = microtime( true );
224			$is_importing = Settings::is_importing();
225
226			foreach ( $args_array as $args ) {
227			$previous_end = isset( $args['previous_end'] ) ? $args['previous_end'] : null;
228			$args = isset( $args['ids'] ) ? $args['ids'] : $args;
229
230			/**
231			* Modify or reject the data within an action before it is enqueued locally.
232			*
233			* @since 4.2.0
234			*
235			* @module sync
236			*
237			* @param array The action parameters
238			*/
239			$args = apply_filters( "jetpack_sync_before_enqueue_$action_name", $args );
240			$action_data = array( $args );
241			if ( ! is_null( $previous_end ) ) {
242			$action_data[] = $previous_end;
243			}
244			// allow listeners to abort.
245			if ( false === $args ) {
246			continue;
247			}
248
249			$data_to_enqueue[] = array(
250			$action_name,
251			$action_data,
252			$user_id,
253			$currtime,
254			$is_importing,
255			);
256			}
257
258			$queue->add_all( $data_to_enqueue );
259			}
260
261			/**
262			* Enqueue the action.
263			*
264			* @param string $current_filter Current WordPress filter.
265			* @param object $args Sync args.
266			* @param string $queue Sync queue.
267			*/
268			public function enqueue_action( $current_filter, $args, $queue ) {
269			// don't enqueue an action during the outbound http request - this prevents recursion.
270			if ( Settings::is_sending() ) {
271			return;
272			}
273
274			/**
275			* Add an action hook to execute when anything on the whitelist gets sent to the queue to sync.
276			*
277			* @module sync
278			*
279			* @since 5.9.0
280			*/
281			do_action( 'jetpack_sync_action_before_enqueue' );
282
283			/**
284			* Modify or reject the data within an action before it is enqueued locally.
285			*
286			* @since 4.2.0
287			*
288			* @param array The action parameters
289			*/
290			$args = apply_filters( "jetpack_sync_before_enqueue_$current_filter", $args );
291
292			// allow listeners to abort.
293			if ( false === $args ) {
294			return;
295			}
296
297			/*
298			* Periodically check the size of the queue, and disable adding to it if
299			* it exceeds some limit AND the oldest item exceeds the age limit (i.e. sending has stopped).
300			*/
301			if ( ! $this->can_add_to_queue( $queue ) ) {
			0 ignored issues – show Documentation introduced 2019-10-29 05:35 UTC by Report Bug Copy Issue Report `$queue` is of type `string`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
302			if ( 'sync' === $queue->id ) {
303			$this->sync_data_loss( $queue );
			0 ignored issues – show Documentation introduced 2020-01-31 16:19 UTC by Report Bug Copy Issue Report `$queue` is of type `string`, but the function expects a `object<Automattic\Jetpack\Sync\Queue>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
304			}
305			return;
306			}
307
308			/*
309			* If we add any items to the queue, we should try to ensure that our script
310			* can't be killed before they are sent.
311			*/
312			if ( function_exists( 'ignore_user_abort' ) ) {
313			ignore_user_abort( true );
314			}
315
316			if (
317			'sync' === $queue->id \|\|
318			in_array(
319			$current_filter,
320			array(
321			'jetpack_full_sync_start',
322			'jetpack_full_sync_end',
323			'jetpack_full_sync_cancel',
324			),
325			true
326			)
327			) {
328			$queue->add(
			0 ignored issues – show Bug introduced 2019-10-29 05:35 UTC by Report Bug Copy Issue Report The method `add` cannot be called on `$queue` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
329			array(
330			$current_filter,
331			$args,
332			get_current_user_id(),
333			microtime( true ),
334			Settings::is_importing(),
335			$this->get_actor( $current_filter, $args ),
336			)
337			);
338			} else {
339			$queue->add(
			0 ignored issues – show Bug introduced 2019-10-29 05:35 UTC by Report Bug Copy Issue Report The method `add` cannot be called on `$queue` (of type `string`). Methods can only be called on objects. This check looks for methods being called on variables that have been inferred to never be objects. Loading history...
340			array(
341			$current_filter,
342			$args,
343			get_current_user_id(),
344			microtime( true ),
345			Settings::is_importing(),
346			)
347			);
348			}
349
350			// since we've added some items, let's try to load the sender so we can send them as quickly as possible.
351			if ( ! Actions::$sender ) {
352			add_filter( 'jetpack_sync_sender_should_load', __NAMESPACE__ . '\Actions::should_initialize_sender_enqueue', 10, 1 );
353			if ( did_action( 'init' ) ) {
354			Actions::add_sender_shutdown();
355			}
356			}
357			}
358
359			/**
360			* Sync Data Loss Handler
361			*
362			* @param Queue $queue Sync queue.
363			* @return boolean was send successful
364			*/
365			public function sync_data_loss( $queue ) {
366			if ( ! Settings::is_sync_enabled() ) {
367			return;
368			}
369			$updated = Health::update_status( Health::STATUS_OUT_OF_SYNC );
370
371			if ( ! $updated ) {
372			return;
373			}
374
375			$data = array(
376			'timestamp' => microtime( true ),
377			'queue_size' => $queue->size(),
378			'queue_lag' => $queue->lag(),
379			);
380
381			$sender = Sender::get_instance();
382			return $sender->send_action( 'jetpack_sync_data_loss', $data );
383			}
384
385			/**
386			* Get the event's actor.
387			*
388			* @param string $current_filter Current wp-admin page.
389			* @param object $args Sync event.
390			* @return array Actor information.
391			*/
392			public function get_actor( $current_filter, $args ) {
393			if ( 'wp_login' === $current_filter ) {
394			$user = get_user_by( 'ID', $args[1]->data->ID );
395			} else {
396			$user = wp_get_current_user();
397			}
398
399			$roles = new Roles();
400			$translated_role = $roles->translate_user_to_role( $user );
401
402			$actor = array(
403			'wpcom_user_id' => null,
404			'external_user_id' => isset( $user->ID ) ? $user->ID : null,
405			'display_name' => isset( $user->display_name ) ? $user->display_name : null,
406			'user_email' => isset( $user->user_email ) ? $user->user_email : null,
407			'user_roles' => isset( $user->roles ) ? $user->roles : null,
408			'translated_role' => $translated_role ? $translated_role : null,
409			'is_cron' => defined( 'DOING_CRON' ) ? DOING_CRON : false,
410			'is_rest' => defined( 'REST_API_REQUEST' ) ? REST_API_REQUEST : false,
411			'is_xmlrpc' => defined( 'XMLRPC_REQUEST' ) ? XMLRPC_REQUEST : false,
412			'is_wp_rest' => defined( 'REST_REQUEST' ) ? REST_REQUEST : false,
413			'is_ajax' => defined( 'DOING_AJAX' ) ? DOING_AJAX : false,
414			'is_wp_admin' => is_admin(),
415			'is_cli' => defined( 'WP_CLI' ) ? WP_CLI : false,
416			'from_url' => $this->get_request_url(),
417			);
418
419			if ( $this->should_send_user_data_with_actor( $current_filter ) ) {
420			$ip = isset( $_SERVER['REMOTE_ADDR'] ) ? $_SERVER['REMOTE_ADDR'] : '';
421			if ( defined( 'JETPACK__PLUGIN_DIR' ) ) {
422			if ( ! function_exists( 'jetpack_protect_get_ip' ) ) {
423			require_once JETPACK__PLUGIN_DIR . 'modules/protect/shared-functions.php';
424			}
425			$ip = jetpack_protect_get_ip();
426			}
427
428			$actor['ip'] = $ip;
429			$actor['user_agent'] = isset( $_SERVER['HTTP_USER_AGENT'] ) ? $_SERVER['HTTP_USER_AGENT'] : 'unknown';
430			}
431
432			return $actor;
433			}
434
435			/**
436			* Should user data be sent as the actor?
437			*
438			* @param string $current_filter The current WordPress filter being executed.
439			* @return bool
440			*/
441			public function should_send_user_data_with_actor( $current_filter ) {
442			$should_send = in_array( $current_filter, array( 'jetpack_wp_login', 'wp_logout', 'jetpack_valid_failed_login_attempt' ), true );
443			/**
444			* Allow or deny sending actor's user data ( IP and UA ) during a sync event
445			*
446			* @since 5.8.0
447			*
448			* @module sync
449			*
450			* @param bool True if we should send user data
451			* @param string The current filter that is performing the sync action
452			*/
453			return apply_filters( 'jetpack_sync_actor_user_data', $should_send, $current_filter );
			0 ignored issues – show Unused Code introduced 2020-05-15 22:01 UTC by Report Bug Copy Issue Report The call to `apply_filters()` has too many arguments starting with `$current_filter`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
454			}
455
456			/**
457			* Sets Listener defaults.
458			*/
459			public function set_defaults() {
460			$this->sync_queue = new Queue( 'sync' );
461			$this->full_sync_queue = new Queue( 'full_sync' );
462			$this->set_queue_size_limit( Settings::get_setting( 'max_queue_size' ) );
463			$this->set_queue_lag_limit( Settings::get_setting( 'max_queue_lag' ) );
464			}
465
466			/**
467			* Get the request URL.
468			*
469			* @return string Request URL, if known. Otherwise, wp-admin or home_url.
470			*/
471			public function get_request_url() {
472			if ( isset( $_SERVER['HTTP_HOST'], $_SERVER['REQUEST_URI'] ) ) {
473			return 'http' . ( isset( $_SERVER['HTTPS'] ) ? 's' : '' ) . '://' . "{$_SERVER['HTTP_HOST']}{$_SERVER['REQUEST_URI']}";
474			}
475			return is_admin() ? get_admin_url( get_current_blog_id() ) : home_url();
476			}
477			}
478

Automattic / jetpack

Push — fix/nav-uni-simple-themes ( ceaeab...4fc151 )

Listener::init() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like