← All changes | jetpack_vendor/automattic/jetpack-sync/src/class-rest-endpoints.php +997 -0 16.2-beta → 16.3 View file →

		@@ -1,0 +1,997 @@
	1	+<?php
	2	+/**
	3	+ * Sync package.
	4	+ *
	5	+ * @package automattic/jetpack-sync
	6	+ */
	7	+
	8	+namespace Automattic\Jetpack\Sync;
	9	+
	10	+use Automattic\Jetpack\Connection\Rest_Authentication;
	11	+use WP_Error;
	12	+use WP_REST_Server;
	13	+
	14	+/**
	15	+ * This class will handle Sync v4 REST Endpoints.
	16	+ *
	17	+ * @since 1.23.1
	18	+ */
	19	+class REST_Endpoints {
	20	+
	21	+ /**
	22	+ * Items pending send.
	23	+ *
	24	+ * @var array
	25	+ */
	26	+ public $items = array();
	27	+
	28	+ /**
	29	+ * Initialize REST routes.
	30	+ */
	31	+ public static function initialize_rest_api() {
	32	+
	33	+ // Request a Full Sync.
	34	+ register_rest_route(
	35	+ 'jetpack/v4',
	36	+ '/sync/full-sync',
	37	+ array(
	38	+ 'methods' => WP_REST_Server::EDITABLE,
	39	+ 'callback' => __CLASS__ . '::full_sync_start',
	40	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	41	+ 'args' => array(
	42	+ 'modules' => array(
	43	+ 'description' => __( 'Data Modules that should be included in Full Sync', 'jetpack-sync' ),
	44	+ 'type' => 'array',
	45	+ 'required' => false,
	46	+ ),
	47	+ 'users' => array(
	48	+ 'description' => __( 'User IDs to include in Full Sync or "initial"', 'jetpack-sync' ),
	49	+ 'required' => false,
	50	+ ),
	51	+ 'posts' => array(
	52	+ 'description' => __( 'Post IDs to include in Full Sync', 'jetpack-sync' ),
	53	+ 'type' => 'array',
	54	+ 'required' => false,
	55	+ ),
	56	+ 'comments' => array(
	57	+ 'description' => __( 'Comment IDs to include in Full Sync', 'jetpack-sync' ),
	58	+ 'type' => 'array',
	59	+ 'required' => false,
	60	+ ),
	61	+ 'context' => array(
	62	+ 'description' => __( 'Context for the Full Sync', 'jetpack-sync' ),
	63	+ 'type' => 'string',
	64	+ 'required' => false,
	65	+ ),
	66	+ ),
	67	+ )
	68	+ );
	69	+
	70	+ // Obtain Sync status.
	71	+ register_rest_route(
	72	+ 'jetpack/v4',
	73	+ '/sync/status',
	74	+ array(
	75	+ 'methods' => WP_REST_Server::READABLE,
	76	+ 'callback' => __CLASS__ . '::sync_status',
	77	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	78	+ 'args' => array(
	79	+ 'fields' => array(
	80	+ 'description' => __( 'Comma-separated list of additional fields that should be included in status.', 'jetpack-sync' ),
	81	+ 'type' => 'string',
	82	+ 'required' => false,
	83	+ ),
	84	+ ),
	85	+ )
	86	+ );
	87	+
	88	+ // Update Sync health status.
	89	+ register_rest_route(
	90	+ 'jetpack/v4',
	91	+ '/sync/health',
	92	+ array(
	93	+ 'methods' => WP_REST_Server::EDITABLE,
	94	+ 'callback' => __CLASS__ . '::sync_health',
	95	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	96	+ 'args' => array(
	97	+ 'status' => array(
	98	+ 'description' => __( 'New Sync health status', 'jetpack-sync' ),
	99	+ 'type' => 'string',
	100	+ 'required' => true,
	101	+ ),
	102	+ ),
	103	+ )
	104	+ );
	105	+
	106	+ // Obtain Sync settings.
	107	+ register_rest_route(
	108	+ 'jetpack/v4',
	109	+ '/sync/settings',
	110	+ array(
	111	+ array(
	112	+ 'methods' => WP_REST_Server::READABLE,
	113	+ 'callback' => __CLASS__ . '::get_sync_settings',
	114	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	115	+ ),
	116	+ array(
	117	+ 'methods' => WP_REST_Server::EDITABLE,
	118	+ 'callback' => __CLASS__ . '::update_sync_settings',
	119	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	120	+ ),
	121	+ )
	122	+ );
	123	+
	124	+ // Retrieve Sync Object(s).
	125	+ register_rest_route(
	126	+ 'jetpack/v4',
	127	+ '/sync/object',
	128	+ array(
	129	+ 'methods' => WP_REST_Server::ALLMETHODS,
	130	+ 'callback' => __CLASS__ . '::get_sync_objects',
	131	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	132	+ 'args' => array(
	133	+ 'module_name' => array(
	134	+ 'description' => __( 'Name of Sync module', 'jetpack-sync' ),
	135	+ 'type' => 'string',
	136	+ 'required' => false,
	137	+ ),
	138	+ 'object_type' => array(
	139	+ 'description' => __( 'Object Type', 'jetpack-sync' ),
	140	+ 'type' => 'string',
	141	+ 'required' => false,
	142	+ ),
	143	+ 'object_ids' => array(
	144	+ 'description' => __( 'Objects Identifiers', 'jetpack-sync' ),
	145	+ 'type' => 'array',
	146	+ 'required' => false,
	147	+ ),
	148	+ ),
	149	+ )
	150	+ );
	151	+
	152	+ // Retrieve Sync Object(s).
	153	+ register_rest_route(
	154	+ 'jetpack/v4',
	155	+ '/sync/now',
	156	+ array(
	157	+ 'methods' => WP_REST_Server::EDITABLE,
	158	+ 'callback' => __CLASS__ . '::do_sync',
	159	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	160	+ 'args' => array(
	161	+ 'queue' => array(
	162	+ 'description' => __( 'Name of Sync queue.', 'jetpack-sync' ),
	163	+ 'type' => 'string',
	164	+ 'required' => true,
	165	+ ),
	166	+ ),
	167	+ )
	168	+ );
	169	+
	170	+ // Checkout Sync Objects.
	171	+ register_rest_route(
	172	+ 'jetpack/v4',
	173	+ '/sync/checkout',
	174	+ array(
	175	+ 'methods' => WP_REST_Server::EDITABLE,
	176	+ 'callback' => __CLASS__ . '::checkout',
	177	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	178	+ 'args' => array(
	179	+ 'queue' => array(
	180	+ 'description' => __( 'Name of Sync queue.', 'jetpack-sync' ),
	181	+ 'type' => 'string',
	182	+ 'required' => false,
	183	+ ),
	184	+ 'number_of_items' => array(
	185	+ 'description' => __( 'Number of items to checkout from the queue.', 'jetpack-sync' ),
	186	+ 'type' => 'integer',
	187	+ 'required' => false,
	188	+ ),
	189	+ 'pop' => array(
	190	+ 'description' => __( 'Pop items from the queue instead of checking out.', 'jetpack-sync' ),
	191	+ 'type' => 'boolean',
	192	+ 'required' => false,
	193	+ 'sanitize_callback' => 'rest_sanitize_boolean',
	194	+ ),
	195	+ 'force' => array(
	196	+ 'description' => __( 'Force unlock the queue before checkout.', 'jetpack-sync' ),
	197	+ 'type' => 'boolean',
	198	+ 'required' => false,
	199	+ 'sanitize_callback' => 'rest_sanitize_boolean',
	200	+ ),
	201	+ 'encode' => array(
	202	+ 'description' => __( 'Encode the items before sending.', 'jetpack-sync' ),
	203	+ 'type' => 'boolean',
	204	+ 'required' => false,
	205	+ 'default' => true,
	206	+ 'sanitize_callback' => 'rest_sanitize_boolean',
	207	+ ),
	208	+ 'use_memory_limit' => array(
	209	+ 'description' => __( 'Use memory-based checkout instead of fixed item count.', 'jetpack-sync' ),
	210	+ 'type' => 'boolean',
	211	+ 'required' => false,
	212	+ 'sanitize_callback' => 'rest_sanitize_boolean',
	213	+ ),
	214	+ ),
	215	+ )
	216	+ );
	217	+
	218	+ // Checkin Sync Objects.
	219	+ register_rest_route(
	220	+ 'jetpack/v4',
	221	+ '/sync/close',
	222	+ array(
	223	+ 'methods' => WP_REST_Server::EDITABLE,
	224	+ 'callback' => __CLASS__ . '::close',
	225	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	226	+ )
	227	+ );
	228	+
	229	+ // Unlock Sync Queue.
	230	+ register_rest_route(
	231	+ 'jetpack/v4',
	232	+ '/sync/unlock',
	233	+ array(
	234	+ 'methods' => WP_REST_Server::EDITABLE,
	235	+ 'callback' => __CLASS__ . '::unlock_queue',
	236	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	237	+ 'args' => array(
	238	+ 'queue' => array(
	239	+ 'description' => __( 'Name of Sync queue.', 'jetpack-sync' ),
	240	+ 'type' => 'string',
	241	+ 'required' => true,
	242	+ ),
	243	+ ),
	244	+ )
	245	+ );
	246	+
	247	+ // Retrieve range of Object Ids.
	248	+ register_rest_route(
	249	+ 'jetpack/v4',
	250	+ '/sync/object-id-range',
	251	+ array(
	252	+ 'methods' => WP_REST_Server::READABLE,
	253	+ 'callback' => __CLASS__ . '::get_object_id_range',
	254	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	255	+ 'args' => array(
	256	+ 'sync_module' => array(
	257	+ 'description' => __( 'Name of Sync module.', 'jetpack-sync' ),
	258	+ 'type' => 'string',
	259	+ 'required' => true,
	260	+ ),
	261	+ 'batch_size' => array(
	262	+ 'description' => __( 'Size of batches', 'jetpack-sync' ),
	263	+ 'type' => 'int',
	264	+ 'required' => true,
	265	+ ),
	266	+ ),
	267	+ )
	268	+ );
	269	+
	270	+ // Obtain table checksums.
	271	+ register_rest_route(
	272	+ 'jetpack/v4',
	273	+ '/sync/data-check',
	274	+ array(
	275	+ 'methods' => WP_REST_Server::READABLE,
	276	+ 'callback' => __CLASS__ . '::data_check',
	277	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	278	+ 'args' => array(
	279	+ 'perform_text_conversion' => array(
	280	+ 'description' => __( 'If text fields should be converted to latin1 in checksum calculation.', 'jetpack-sync' ),
	281	+ 'type' => 'boolean',
	282	+ 'required' => false,
	283	+ ),
	284	+ ),
	285	+ )
	286	+ );
	287	+
	288	+ // Obtain histogram.
	289	+ register_rest_route(
	290	+ 'jetpack/v4',
	291	+ '/sync/data-histogram',
	292	+ array(
	293	+ 'methods' => WP_REST_Server::EDITABLE,
	294	+ 'callback' => __CLASS__ . '::data_histogram',
	295	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	296	+ 'args' => array(
	297	+ 'columns' => array(
	298	+ 'description' => __( 'Column mappings', 'jetpack-sync' ),
	299	+ 'type' => 'array',
	300	+ 'required' => false,
	301	+ ),
	302	+ 'object_type' => array(
	303	+ 'description' => __( 'Object Type', 'jetpack-sync' ),
	304	+ 'type' => 'string',
	305	+ 'required' => false,
	306	+ ),
	307	+ 'buckets' => array(
	308	+ 'description' => __( 'Number of histogram buckets.', 'jetpack-sync' ),
	309	+ 'type' => 'int',
	310	+ 'required' => false,
	311	+ ),
	312	+ 'start_id' => array(
	313	+ 'description' => __( 'Start ID for the histogram', 'jetpack-sync' ),
	314	+ 'type' => 'int',
	315	+ 'required' => false,
	316	+ ),
	317	+ 'end_id' => array(
	318	+ 'description' => __( 'End ID for the histogram', 'jetpack-sync' ),
	319	+ 'type' => 'int',
	320	+ 'required' => false,
	321	+ ),
	322	+ 'strip_non_ascii' => array(
	323	+ 'description' => __( 'Strip non-ascii characters?', 'jetpack-sync' ),
	324	+ 'type' => 'boolean',
	325	+ 'required' => false,
	326	+ ),
	327	+ 'shared_salt' => array(
	328	+ 'description' => __( 'Shared Salt to use when generating checksum', 'jetpack-sync' ),
	329	+ 'type' => 'string',
	330	+ 'required' => false,
	331	+ ),
	332	+ 'only_range_edges' => array(
	333	+ 'description' => __( 'Should only range edges be returned', 'jetpack-sync' ),
	334	+ 'type' => 'boolean',
	335	+ 'required' => false,
	336	+ ),
	337	+ 'detailed_drilldown' => array(
	338	+ 'description' => __( 'Do we want the checksum or object ids.', 'jetpack-sync' ),
	339	+ 'type' => 'boolean',
	340	+ 'required' => false,
	341	+ ),
	342	+ 'perform_text_conversion' => array(
	343	+ 'description' => __( 'If text fields should be converted to latin1 in checksum calculation.', 'jetpack-sync' ),
	344	+ 'type' => 'boolean',
	345	+ 'required' => false,
	346	+ ),
	347	+ ),
	348	+ )
	349	+ );
	350	+
	351	+ // Trigger Dedicated Sync request.
	352	+ register_rest_route(
	353	+ 'jetpack/v4',
	354	+ '/sync/spawn-sync',
	355	+ array(
	356	+ 'methods' => WP_REST_Server::READABLE,
	357	+ 'callback' => __CLASS__ . '::spawn_sync',
	358	+ 'permission_callback' => '__return_true',
	359	+ )
	360	+ );
	361	+
	362	+ // Reset Sync locks.
	363	+ register_rest_route(
	364	+ 'jetpack/v4',
	365	+ '/sync/locks',
	366	+ array(
	367	+ 'methods' => WP_REST_Server::DELETABLE,
	368	+ 'callback' => __CLASS__ . '::reset_locks',
	369	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	370	+ )
	371	+ );
	372	+
	373	+ // Clear Sync queue.
	374	+ register_rest_route(
	375	+ 'jetpack/v4',
	376	+ '/sync/clear-queue',
	377	+ array(
	378	+ 'methods' => WP_REST_Server::EDITABLE,
	379	+ 'callback' => __CLASS__ . '::clear_queue',
	380	+ 'permission_callback' => __CLASS__ . '::verify_default_permissions',
	381	+ )
	382	+ );
	383	+ }
	384	+
	385	+ /**
	386	+ * Trigger a Full Sync of specified modules.
	387	+ *
	388	+ * @since 1.23.1
	389	+ *
	390	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	391	+ *
	392	+ * @return \WP_REST_Response|WP_Error
	393	+ */
	394	+ public static function full_sync_start( $request ) {
	395	+
	396	+ $modules = $request->get_param( 'modules' );
	397	+
	398	+ // convert list of modules into array format of "$modulename => true".
	399	+ if ( ! empty( $modules ) ) {
	400	+ $modules = array_map( '__return_true', array_flip( $modules ) );
	401	+ }
	402	+
	403	+ // Process additional options.
	404	+ foreach ( array( 'posts', 'comments', 'users' ) as $module_name ) {
	405	+ if ( 'users' === $module_name && 'initial' === $request->get_param( 'users' ) ) {
	406	+ $modules['users'] = 'initial';
	407	+ } elseif ( is_array( $request->get_param( $module_name ) ) ) {
	408	+ $ids = $request->get_param( $module_name );
	409	+ if ( array() !== $ids ) {
	410	+ $modules[ $module_name ] = $ids;
	411	+ }
	412	+ }
	413	+ }
	414	+
	415	+ if ( empty( $modules ) ) {
	416	+ $modules = null;
	417	+ }
	418	+
	419	+ $context = $request->get_param( 'context' );
	420	+
	421	+ return rest_ensure_response(
	422	+ array(
	423	+ 'scheduled' => Actions::do_full_sync( $modules, $context ),
	424	+ )
	425	+ );
	426	+ }
	427	+
	428	+ /**
	429	+ * Return Sync's status.
	430	+ *
	431	+ * @since 1.23.1
	432	+ *
	433	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	434	+ *
	435	+ * @return \WP_REST_Response
	436	+ */
	437	+ public static function sync_status( $request ) {
	438	+ $fields = $request->get_param( 'fields' );
	439	+ return rest_ensure_response( Actions::get_sync_status( $fields ) );
	440	+ }
	441	+
	442	+ /**
	443	+ * Return table checksums.
	444	+ *
	445	+ * @since 1.23.1
	446	+ *
	447	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	448	+ *
	449	+ * @return \WP_REST_Response
	450	+ */
	451	+ public static function data_check( $request ) {
	452	+ // Disable Sync during this call, so we can resolve faster.
	453	+ Actions::mark_sync_read_only();
	454	+ $store = new Replicastore();
	455	+
	456	+ $perform_text_conversion = false;
	457	+ if ( true === $request->get_param( 'perform_text_conversion' ) ) {
	458	+ $perform_text_conversion = true;
	459	+ }
	460	+
	461	+ return rest_ensure_response( $store->checksum_all( $perform_text_conversion ) );
	462	+ }
	463	+
	464	+ /**
	465	+ * Return Histogram.
	466	+ *
	467	+ * @since 1.23.1
	468	+ *
	469	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	470	+ *
	471	+ * @return \WP_REST_Response
	472	+ */
	473	+ public static function data_histogram( $request ) {
	474	+
	475	+ // Disable Sync during this call, so we can resolve faster.
	476	+ Actions::mark_sync_read_only();
	477	+
	478	+ $args = $request->get_params();
	479	+
	480	+ if ( empty( $args['columns'] ) ) {
	481	+ $args['columns'] = null; // go with defaults.
	482	+ }
	483	+
	484	+ if ( false !== $args['strip_non_ascii'] ) {
	485	+ $args['strip_non_ascii'] = true;
	486	+ }
	487	+
	488	+ if ( true !== $args['perform_text_conversion'] ) {
	489	+ $args['perform_text_conversion'] = false;
	490	+ }
	491	+
	492	+ /**
	493	+ * Hack: nullify the values of `start_id` and `end_id` if we're only requesting ranges.
	494	+ *
	495	+ * The endpoint doesn't support nullable values :(
	496	+ */
	497	+ if ( true === $args['only_range_edges'] ) {
	498	+ if ( 0 === $args['start_id'] ) {
	499	+ $args['start_id'] = null;
	500	+ }
	501	+
	502	+ if ( 0 === $args['end_id'] ) {
	503	+ $args['end_id'] = null;
	504	+ }
	505	+ }
	506	+
	507	+ $store = new Replicastore();
	508	+ $histogram = $store->checksum_histogram( $args['object_type'], $args['buckets'], $args['start_id'], $args['end_id'], $args['columns'], $args['strip_non_ascii'], $args['shared_salt'], $args['only_range_edges'], $args['detailed_drilldown'], $args['perform_text_conversion'] );
	509	+
	510	+ return rest_ensure_response(
	511	+ array(
	512	+ 'histogram' => $histogram,
	513	+ 'type' => $store->get_checksum_type(),
	514	+ )
	515	+ );
	516	+ }
	517	+
	518	+ /**
	519	+ * Update Sync health.
	520	+ *
	521	+ * IN_SYNC is only set if the incremental queue is within size and lag limits.
	522	+ *
	523	+ * @since 1.23.1
	524	+ *
	525	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	526	+ *
	527	+ * @return \WP_REST_Response|WP_Error
	528	+ */
	529	+ public static function sync_health( $request ) {
	530	+ $requested_status = $request->get_param( 'status' );
	531	+
	532	+ switch ( $requested_status ) {
	533	+ case Health::STATUS_IN_SYNC:
	534	+ // Only allow setting IN_SYNC if the incremental queue is healthy.
	535	+ $sync_queue = Listener::get_instance()->get_sync_queue();
	536	+ $queue_size = $sync_queue->size();
	537	+ $queue_lag = $sync_queue->lag();
	538	+ $queue_healthy = Health::is_queue_healthy(
	539	+ $queue_size,
	540	+ $queue_lag,
	541	+ Settings::get_setting( 'max_queue_size' ),
	542	+ Settings::get_setting( 'max_queue_lag' )
	543	+ );
	544	+ if ( ! $queue_healthy ) {
	545	+ Health::update_status( Health::STATUS_OUT_OF_SYNC );
	546	+ return rest_ensure_response(
	547	+ array(
	548	+ 'success' => Health::get_status(),
	549	+ 'message' => 'Sync queue is not healthy (size and lag over limit). Status not set to in_sync.',
	550	+ 'queue_size' => $queue_size,
	551	+ 'queue_lag' => $queue_lag,
	552	+ )
	553	+ );
	554	+ }
	555	+ Health::update_status( $requested_status );
	556	+ break;
	557	+ case Health::STATUS_OUT_OF_SYNC:
	558	+ Health::update_status( $requested_status );
	559	+ break;
	560	+ default:
	561	+ return new WP_Error(
	562	+ 'invalid_status',
	563	+ 'Invalid Sync Status Provided.',
	564	+ array(
	565	+ 'status' => 400,
	566	+ )
	567	+ );
	568	+ }
	569	+
	570	+ // re-fetch so we see what's really being stored.
	571	+ return rest_ensure_response(
	572	+ array(
	573	+ 'success' => Health::get_status(),
	574	+ )
	575	+ );
	576	+ }
	577	+
	578	+ /**
	579	+ * Obtain Sync settings.
	580	+ *
	581	+ * @since 1.23.1
	582	+ *
	583	+ * @return \WP_REST_Response
	584	+ */
	585	+ public static function get_sync_settings() {
	586	+ return rest_ensure_response( Settings::get_settings() );
	587	+ }
	588	+
	589	+ /**
	590	+ * Update Sync settings.
	591	+ *
	592	+ * @since 1.23.1
	593	+ *
	594	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	595	+ *
	596	+ * @return \WP_REST_Response
	597	+ */
	598	+ public static function update_sync_settings( $request ) {
	599	+ $args = $request->get_params();
	600	+ $sync_settings = Settings::get_settings();
	601	+
	602	+ foreach ( $args as $key => $value ) {
	603	+ if ( false !== $value ) {
	604	+ if ( is_numeric( $value ) ) {
	605	+ $value = (int) $value;
	606	+ }
	607	+
	608	+ // special case for sending empty arrays - a string with value 'empty'.
	609	+ if ( 'empty' === $value ) {
	610	+ $value = array();
	611	+ }
	612	+
	613	+ $sync_settings[ $key ] = $value;
	614	+ }
	615	+ }
	616	+
	617	+ Settings::update_settings( $sync_settings );
	618	+
	619	+ // re-fetch so we see what's really being stored.
	620	+ return rest_ensure_response( Settings::get_settings() );
	621	+ }
	622	+
	623	+ /**
	624	+ * Retrieve Sync Objects.
	625	+ *
	626	+ * @since 1.23.1
	627	+ *
	628	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	629	+ *
	630	+ * @return \WP_REST_Response
	631	+ */
	632	+ public static function get_sync_objects( $request ) {
	633	+ $args = $request->get_params();
	634	+
	635	+ $module_name = $args['module_name'];
	636	+ // Verify valid Sync Module.
	637	+ $sync_module = Modules::get_module( $module_name );
	638	+ if ( ! $sync_module ) {
	639	+ return new WP_Error( 'invalid_module', 'You specified an invalid sync module' );
	640	+ }
	641	+
	642	+ Actions::mark_sync_read_only();
	643	+
	644	+ $codec = Sender::get_instance()->get_codec();
	645	+ Settings::set_is_syncing( true );
	646	+ $objects = $codec->encode( $sync_module->get_objects_by_id( $args['object_type'], $args['object_ids'] ) );
	647	+ Settings::set_is_syncing( false );
	648	+
	649	+ return rest_ensure_response(
	650	+ array(
	651	+ 'objects' => $objects,
	652	+ 'codec' => $codec->name(),
	653	+ )
	654	+ );
	655	+ }
	656	+
	657	+ /**
	658	+ * Request Sync processing.
	659	+ *
	660	+ * @since 1.23.1
	661	+ *
	662	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	663	+ *
	664	+ * @return \WP_REST_Response
	665	+ */
	666	+ public static function do_sync( $request ) {
	667	+
	668	+ $queue_name = self::validate_queue( $request->get_param( 'queue' ) );
	669	+ if ( is_wp_error( $queue_name ) ) {
	670	+ return $queue_name;
	671	+ }
	672	+
	673	+ $sender = Sender::get_instance();
	674	+ $response = $sender->do_sync_for_queue( new Queue( $queue_name ) );
	675	+
	676	+ return rest_ensure_response(
	677	+ array(
	678	+ 'response' => $response,
	679	+ )
	680	+ );
	681	+ }
	682	+
	683	+ /**
	684	+ * Request sync data from specified queue.
	685	+ *
	686	+ * @since 1.23.1
	687	+ *
	688	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	689	+ *
	690	+ * @return \WP_REST_Response
	691	+ */
	692	+ public static function checkout( $request ) {
	693	+ $args = $request->get_params();
	694	+ $queue_name = self::validate_queue( $args['queue'] );
	695	+
	696	+ if ( is_wp_error( $queue_name ) ) {
	697	+ return $queue_name;
	698	+ }
	699	+
	700	+ $use_memory_limit = ! empty( $args['use_memory_limit'] );
	701	+
	702	+ if ( $use_memory_limit && ! empty( $args['pop'] ) ) {
	703	+ return new WP_Error( 'invalid_args', 'pop cannot be used with use_memory_limit', 400 );
	704	+ }
	705	+
	706	+ if ( ! $use_memory_limit ) {
	707	+ if ( empty( $args['number_of_items'] ) || $args['number_of_items'] < 1 || $args['number_of_items'] > 100 ) {
	708	+ return new WP_Error( 'invalid_number_of_items', 'Number of items needs to be an integer that is larger than 0 and up to 100', 400 );
	709	+ }
	710	+ }
	711	+
	712	+ // REST Sender.
	713	+ $sender = new REST_Sender();
	714	+
	715	+ if ( 'immediate' === $queue_name ) {
	716	+ return rest_ensure_response( $sender->immediate_full_sync_pull() );
	717	+ }
	718	+
	719	+ $number_of_items = $use_memory_limit ? null : $args['number_of_items'];
	720	+ $response = $sender->queue_pull( $queue_name, $number_of_items, $args );
	721	+ // Disable sending while pulling.
	722	+ if ( ! is_wp_error( $response ) ) {
	723	+ set_transient( Sender::TEMP_SYNC_DISABLE_TRANSIENT_NAME, time(), Sender::TEMP_SYNC_DISABLE_TRANSIENT_EXPIRY );
	724	+ } elseif ( 'queue_size' === $response->get_error_code() ) {
	725	+ // Re-enable sending if the queue is empty.
	726	+ delete_transient( Sender::TEMP_SYNC_DISABLE_TRANSIENT_NAME );
	727	+ }
	728	+
	729	+ return rest_ensure_response( $response );
	730	+ }
	731	+
	732	+ /**
	733	+ * Unlock a Sync queue.
	734	+ *
	735	+ * @since 1.23.1
	736	+ *
	737	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	738	+ *
	739	+ * @return \WP_REST_Response
	740	+ */
	741	+ public static function unlock_queue( $request ) {
	742	+
	743	+ $queue_name = $request->get_param( 'queue' );
	744	+
	745	+ if ( ! in_array( $queue_name, array( 'sync', 'full_sync' ), true ) ) {
	746	+ return new WP_Error( 'invalid_queue', 'Queue name should be sync or full_sync', 400 );
	747	+ }
	748	+ $queue = new Queue( $queue_name );
	749	+
	750	+ // False means that there was no lock to delete.
	751	+ $response = $queue->unlock();
	752	+ return rest_ensure_response(
	753	+ array(
	754	+ 'success' => $response,
	755	+ )
	756	+ );
	757	+ }
	758	+
	759	+ /**
	760	+ * Checkin Sync actions.
	761	+ *
	762	+ * @since 1.23.1
	763	+ *
	764	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	765	+ *
	766	+ * @return \WP_REST_Response
	767	+ */
	768	+ public static function close( $request ) {
	769	+
	770	+ $request_body = $request->get_params();
	771	+ $queue_name = self::validate_queue( $request_body['queue'] );
	772	+
	773	+ if ( is_wp_error( $queue_name ) ) {
	774	+ return $queue_name;
	775	+ }
	776	+
	777	+ if ( empty( $request_body['buffer_id'] ) ) {
	778	+ return new WP_Error( 'missing_buffer_id', 'Please provide a buffer id', 400 );
	779	+ }
	780	+
	781	+ if ( ! is_array( $request_body['item_ids'] ) ) {
	782	+ return new WP_Error( 'missing_item_ids', 'Please provide a list of item ids in the item_ids argument', 400 );
	783	+ }
	784	+
	785	+ // Limit to A-Z,a-z,0-9,_,- .
	786	+ $request_body['buffer_id'] = preg_replace( '/[^A-Za-z0-9\-_\.]/', '', $request_body['buffer_id'] );
	787	+ $request_body['item_ids'] = array_filter( array_map( array( 'Automattic\Jetpack\Sync\REST_Endpoints', 'sanitize_item_ids' ), $request_body['item_ids'] ) );
	788	+
	789	+ $queue = new Queue( $queue_name );
	790	+
	791	+ $items = $queue->peek_by_id( $request_body['item_ids'] );
	792	+
	793	+ // Update Full Sync Status if queue is "full_sync".
	794	+ if ( 'full_sync' === $queue_name ) {
	795	+ $full_sync_module = Modules::get_module( 'full-sync' );
	796	+ '@phan-var Modules\Full_Sync_Immediately|Modules\Full_Sync $full_sync_module';
	797	+ $full_sync_module->update_sent_progress_action( $items );
	798	+ }
	799	+
	800	+ $buffer = new Queue_Buffer( $request_body['buffer_id'], $request_body['item_ids'] );
	801	+ $response = $queue->close( $buffer, $request_body['item_ids'] );
	802	+
	803	+ // Perform another checkout?
	804	+ if ( isset( $request_body['continue'] ) && $request_body['continue'] ) {
	805	+ if ( in_array( $queue_name, array( 'full_sync', 'immediate' ), true ) ) {
	806	+ // Send Full Sync Actions.
	807	+ Sender::get_instance()->do_full_sync();
	808	+ } elseif ( $queue->has_any_items() ) {
	809	+ // Send Incremental Sync Actions.
	810	+ Sender::get_instance()->do_sync();
	811	+ }
	812	+ }
	813	+
	814	+ if ( is_wp_error( $response ) ) {
	815	+ return $response;
	816	+ }
	817	+
	818	+ return rest_ensure_response(
	819	+ array(
	820	+ 'success' => $response,
	821	+ 'status' => Actions::get_sync_status(),
	822	+ )
	823	+ );
	824	+ }
	825	+
	826	+ /**
	827	+ * Retrieve range of Object Ids for a specified Sync module.
	828	+ *
	829	+ * @since 1.23.1
	830	+ *
	831	+ * @param \WP_REST_Request $request The request sent to the WP REST API.
	832	+ *
	833	+ * @return \WP_REST_Response
	834	+ */
	835	+ public static function get_object_id_range( $request ) {
	836	+
	837	+ $module_name = $request->get_param( 'sync_module' );
	838	+ $batch_size = $request->get_param( 'batch_size' );
	839	+
	840	+ if ( ! self::is_valid_sync_module( $module_name ) ) {
	841	+ return new WP_Error( 'invalid_module', 'This sync module cannot be used to calculate a range.', 400 );
	842	+ }
	843	+ $module = Modules::get_module( $module_name );
	844	+
	845	+ return rest_ensure_response(
	846	+ array(
	847	+ 'ranges' => $module->get_min_max_object_ids_for_batches( $batch_size ),
	848	+ )
	849	+ );
	850	+ }
	851	+
	852	+ /**
	853	+ * This endpoint is used by Sync to spawn a
	854	+ * dedicated Sync request which will trigger Sync to run.
	855	+ *
	856	+ * If Dedicated Sync is enabled, this callback should never run as
	857	+ * processing of Sync actions will occur earlier and exit.
	858	+ *
	859	+ * @see Actions::init
	860	+ * @see Sender::do_dedicated_sync_and_exit
	861	+ *
	862	+ * @since 1.34.0
	863	+ *
	864	+ * @return \WP_REST_Response
	865	+ */
	866	+ public static function spawn_sync() {
	867	+ nocache_headers();
	868	+
	869	+ if ( ! Settings::is_dedicated_sync_enabled() ) {
	870	+ return new WP_Error(
	871	+ 'dedicated_sync_disabled',
	872	+ 'Dedicated Sync flow is disabled.',
	873	+ array( 'status' => 422 )
	874	+ );
	875	+ }
	876	+
	877	+ return new WP_Error(
	878	+ 'dedicated_sync_failed',
	879	+ 'Failed to process Dedicated Sync request',
	880	+ array( 'status' => 500 )
	881	+ );
	882	+ }
	883	+
	884	+ /**
	885	+ * Reset Sync locks.
	886	+ *
	887	+ * @since 1.43.0
	888	+ *
	889	+ * @return \WP_REST_Response
	890	+ */
	891	+ public static function reset_locks() {
	892	+ Actions::reset_sync_locks();
	893	+
	894	+ return rest_ensure_response(
	895	+ array(
	896	+ 'success' => true,
	897	+ )
	898	+ );
	899	+ }
	900	+
	901	+ /**
	902	+ * Clear the Sync queue.
	903	+ *
	904	+ * @since 4.30.0
	905	+ *
	906	+ * @return \WP_REST_Response
	907	+ */
	908	+ public static function clear_queue() {
	909	+ $queue = new Queue( 'sync' );
	910	+ $queue->reset();
	911	+
	912	+ // Re-enable sending in case it was temporarily disabled during a pull.
	913	+ delete_transient( Sender::TEMP_SYNC_DISABLE_TRANSIENT_NAME );
	914	+
	915	+ return rest_ensure_response(
	916	+ array(
	917	+ 'success' => true,
	918	+ )
	919	+ );
	920	+ }
	921	+
	922	+ /**
	923	+ * Verify that request has default permissions to perform sync actions.
	924	+ *
	925	+ * @since 1.23.1
	926	+ *
	927	+ * @return bool Whether user has capability 'manage_options' or a blog token is used.
	928	+ */
	929	+ public static function verify_default_permissions() {
	930	+ if ( current_user_can( 'manage_options' ) || Rest_Authentication::is_signed_with_blog_token() ) {
	931	+ return true;
	932	+ }
	933	+
	934	+ $error_msg = esc_html__(
	935	+ 'You do not have the correct user permissions to perform this action.
	936	+ Please contact your site admin if you think this is a mistake.',
	937	+ 'jetpack-sync'
	938	+ );
	939	+
	940	+ return new WP_Error( 'invalid_user_permission_sync', $error_msg, array( 'status' => rest_authorization_required_code() ) );
	941	+ }
	942	+
	943	+ /**
	944	+ * Validate Queue name.
	945	+ *
	946	+ * @param string $value Queue Name.
	947	+ *
	948	+ * @return WP_Error
	949	+ */
	950	+ protected static function validate_queue( $value ) {
	951	+ if ( ! isset( $value ) ) {
	952	+ return new WP_Error( 'invalid_queue', 'Queue name is required', 400 );
	953	+ }
	954	+
	955	+ if ( ! in_array( $value, array( 'sync', 'full_sync', 'immediate' ), true ) ) {
	956	+ return new WP_Error( 'invalid_queue', 'Queue name should be sync, full_sync or immediate', 400 );
	957	+ }
	958	+ return $value;
	959	+ }
	960	+
	961	+ /**
	962	+ * Validate name is a valid Sync module.
	963	+ *
	964	+ * @param string $module_name Name of Sync Module.
	965	+ *
	966	+ * @return bool
	967	+ */
	968	+ protected static function is_valid_sync_module( $module_name ) {
	969	+ return in_array(
	970	+ $module_name,
	971	+ array(
	972	+ 'comments',
	973	+ 'posts',
	974	+ 'terms',
	975	+ 'term_relationships',
	976	+ 'users',
	977	+ ),
	978	+ true
	979	+ );
	980	+ }
	981	+
	982	+ /**
	983	+ * Sanitize Item Ids.
	984	+ *
	985	+ * @param string $item Sync item identifier.
	986	+ *
	987	+ * @return string|string[]|null
	988	+ */
	989	+ protected static function sanitize_item_ids( $item ) {
	990	+ // lets not delete any options that don't start with jpsq_sync- .
	991	+ if ( ! is_string( $item ) || ! str_starts_with( $item, 'jpsq_' ) ) {
	992	+ return null;
	993	+ }
	994	+ // Limit to A-Z,a-z,0-9,_,-,. .
	995	+ return preg_replace( '/[^A-Za-z0-9-_.]/', '', $item );
	996	+ }
	997	+}