Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
40.48%
68 / 168
21.88%
7 / 32
 CRAP
0.00%
0 / 1
Settings
40.48%
68 / 168
21.88%
7 / 32
 1327.41
0.00%
0 / 1
 get_settings
100.00%
4 / 4
100.00%
1 / 1
 2
 get_setting
88.57%
31 / 35
0.00%
0 / 1
 14.29
 update_settings
52.08%
25 / 48
0.00%
0 / 1
 87.37
 is_network_setting
100.00%
1 / 1
100.00%
1 / 1
 1
 get_blacklisted_post_types_sql
0.00%
0 / 1
0.00%
0 / 1
 2
 get_disallowed_post_types_structured
0.00%
0 / 6
0.00%
0 / 1
 2
 get_blacklisted_taxonomies_sql
0.00%
0 / 1
0.00%
0 / 1
 2
 get_whitelisted_taxonomies_sql
0.00%
0 / 3
0.00%
0 / 1
 2
 get_whitelisted_post_meta_sql
0.00%
0 / 1
0.00%
0 / 1
 2
 get_allowed_post_meta_structured
0.00%
0 / 6
0.00%
0 / 1
 2
 get_blacklisted_taxonomies_structured
0.00%
0 / 6
0.00%
0 / 1
 2
 get_allowed_taxonomies_structured
0.00%
0 / 8
0.00%
0 / 1
 2
 get_whitelisted_comment_meta_sql
0.00%
0 / 1
0.00%
0 / 1
 2
 get_allowed_comment_meta_structured
0.00%
0 / 6
0.00%
0 / 1
 2
 get_allowed_order_itemmeta_structured
0.00%
0 / 9
0.00%
0 / 1
 6
 get_allowed_comment_types_structured
0.00%
0 / 6
0.00%
0 / 1
 2
 get_comments_filter_sql
0.00%
0 / 1
0.00%
0 / 1
 2
 reset_data
0.00%
0 / 7
0.00%
0 / 1
 6
 set_importing
0.00%
0 / 1
0.00%
0 / 1
 2
 is_importing
0.00%
0 / 3
0.00%
0 / 1
 12
 is_sync_enabled
100.00%
1 / 1
100.00%
1 / 1
 2
 set_doing_cron
0.00%
0 / 1
0.00%
0 / 1
 2
 is_doing_cron
66.67%
2 / 3
0.00%
0 / 1
 3.33
 is_syncing
0.00%
0 / 1
0.00%
0 / 1
 6
 set_is_syncing
0.00%
0 / 1
0.00%
0 / 1
 2
 is_sending
100.00%
1 / 1
100.00%
1 / 1
 1
 set_is_sending
0.00%
0 / 1
0.00%
0 / 1
 2
 is_sender_enabled
0.00%
0 / 1
0.00%
0 / 1
 2
 is_checksum_enabled
0.00%
0 / 1
0.00%
0 / 1
 2
 is_dedicated_sync_enabled
100.00%
1 / 1
100.00%
1 / 1
 1
 is_custom_queue_table_enabled
100.00%
1 / 1
100.00%
1 / 1
 1
 is_wpcom_rest_api_enabled
100.00%
1 / 1
100.00%
1 / 1
 1
1<?php
2/**
3 * Sync settings.
4 *
5 * @package automattic/jetpack-sync
6 */
7
8namespace Automattic\Jetpack\Sync;
9
10use Automattic\Jetpack\Constants;
11use Automattic\Jetpack\Sync\Queue\Queue_Storage_Table;
12
13/**
14 * Class to manage the sync settings.
15 */
16class Settings {
17    /**
18     * Prefix, used for the sync settings option names.
19     *
20     * @access public
21     *
22     * @var string
23     */
24    const SETTINGS_OPTION_PREFIX = 'jetpack_sync_settings_';
25
26    /**
27     * A whitelist of valid settings.
28     *
29     * @access public
30     * @static
31     *
32     * @var array
33     */
34    public static $valid_settings = array(
35        'dequeue_max_bytes'                      => true,
36        'upload_max_bytes'                       => true,
37        'upload_max_rows'                        => true,
38        'sync_wait_time'                         => true,
39        'sync_wait_threshold'                    => true,
40        'enqueue_wait_time'                      => true,
41        'max_queue_size'                         => true,
42        'max_queue_lag'                          => true,
43        'queue_max_writes_sec'                   => true,
44        'post_types_blacklist'                   => true,
45        'taxonomies_blacklist'                   => true,
46        'disable'                                => true,
47        'network_disable'                        => true,
48        'render_filtered_content'                => true,
49        'post_meta_whitelist'                    => true,
50        'comment_meta_whitelist'                 => true,
51        'max_enqueue_full_sync'                  => true,
52        'max_queue_size_full_sync'               => true,
53        'sync_via_cron'                          => true,
54        'cron_sync_time_limit'                   => true,
55        'known_importers'                        => true,
56        'term_relationships_full_sync_item_size' => true,
57        'sync_sender_enabled'                    => true,
58        'full_sync_sender_enabled'               => true,
59        'full_sync_send_duration'                => true,
60        'full_sync_limits'                       => true,
61        'checksum_disable'                       => true,
62        'dedicated_sync_enabled'                 => true,
63        'custom_queue_table_enabled'             => true,
64        'wpcom_rest_api_enabled'                 => true,
65        'sync_actions_blacklist'                 => true,
66    );
67
68    /**
69     * Whether WordPress is currently running an import.
70     *
71     * @access public
72     * @static
73     *
74     * @var null|boolean
75     */
76    public static $is_importing;
77
78    /**
79     * Whether WordPress is currently running a WP cron request.
80     *
81     * @access public
82     * @static
83     *
84     * @var null|boolean
85     */
86    public static $is_doing_cron;
87
88    /**
89     * Whether we're currently syncing.
90     *
91     * @access public
92     * @static
93     *
94     * @var null|boolean
95     */
96    public static $is_syncing;
97
98    /**
99     * Whether we're currently sending sync items.
100     *
101     * @access public
102     * @static
103     *
104     * @var null|boolean
105     */
106    public static $is_sending;
107
108    /**
109     * Retrieve all settings with their current values.
110     *
111     * @access public
112     * @static
113     *
114     * @return array All current settings.
115     */
116    public static function get_settings() {
117        $settings = array();
118        foreach ( array_keys( self::$valid_settings ) as $setting ) {
119            $settings[ $setting ] = static::get_setting( $setting );
120        }
121
122        return $settings;
123    }
124
125    /**
126     * Fetches the setting. It saves it if the setting doesn't exist, so that it gets
127     * autoloaded on page load rather than re-queried every time.
128     *
129     * @access public
130     * @static
131     *
132     * @param string $setting The setting name.
133     * @return mixed The setting value.
134     */
135    public static function get_setting( $setting ) {
136        if ( ! isset( self::$valid_settings[ $setting ] ) ) {
137            return false;
138        }
139
140        if ( self::is_network_setting( $setting ) ) {
141            if ( is_multisite() ) {
142                $value = get_site_option( self::SETTINGS_OPTION_PREFIX . $setting );
143            } else {
144                // On single sites just return the default setting.
145                return Defaults::get_default_setting( $setting );
146            }
147        } else {
148            $value = get_option( self::SETTINGS_OPTION_PREFIX . $setting );
149        }
150
151        if ( false === $value ) { // No default value is set.
152            $value = Defaults::get_default_setting( $setting );
153            if ( self::is_network_setting( $setting ) ) {
154                update_site_option( self::SETTINGS_OPTION_PREFIX . $setting, $value );
155            } else {
156                // We set one so that it gets autoloaded.
157                update_option( self::SETTINGS_OPTION_PREFIX . $setting, $value, true );
158            }
159        }
160
161        if ( is_numeric( $value ) ) {
162            $value = (int) $value;
163        }
164        $default_array_value = null;
165        switch ( $setting ) {
166            case 'post_types_blacklist':
167                $default_array_value = Defaults::$blacklisted_post_types;
168                break;
169            case 'taxonomies_blacklist':
170                $default_array_value = Defaults::$blacklisted_taxonomies;
171                break;
172            case 'post_meta_whitelist':
173                $default_array_value = Defaults::get_post_meta_whitelist();
174                break;
175            case 'comment_meta_whitelist':
176                $default_array_value = Defaults::get_comment_meta_whitelist();
177                break;
178            case 'known_importers':
179                $default_array_value = Defaults::get_known_importers();
180                break;
181        }
182
183        if ( $default_array_value ) {
184            if ( is_array( $value ) ) {
185                $value = array_unique( array_merge( $value, $default_array_value ) );
186            } else {
187                $value = $default_array_value;
188            }
189        }
190
191        return $value;
192    }
193
194    /**
195     * Change multiple settings in the same time.
196     *
197     * @access public
198     * @static
199     *
200     * @param array $new_settings The new settings.
201     */
202    public static function update_settings( $new_settings ) {
203        $validated_settings = array_intersect_key( $new_settings, self::$valid_settings );
204        foreach ( $validated_settings as $setting => $value ) {
205
206            /**
207             * Custom table migration logic.
208             *
209             * This needs to happen before the option is updated, to avoid race conditions where we update the option,
210             * but haven't yet created the table or can't create it.
211             *
212             * On high-traffic sites this can lead to Sync trying to write in a non-existent table.
213             *
214             * So to avoid this, we're going to first try to initialize everything and then update the option.
215             */
216            if ( 'custom_queue_table_enabled' === $setting ) {
217                // Need to check the current value in the database to make sure we're not doing anything weird.
218                $old_value = get_option( self::SETTINGS_OPTION_PREFIX . $setting, null );
219
220                if ( ! $old_value && $value ) {
221                    /**
222                     * The custom table has been enabled.
223                     *
224                     * - Initialize the custom table
225                     * - Migrate the data
226                     *
227                     * If something fails, migrate back to the options table and clean up everything about the custom table.
228                     */
229                    $init_result = Queue_Storage_Table::initialize_custom_sync_table();
230
231                    /**
232                     * Check if there was a problem when initializing the table.
233                     */
234                    if ( is_wp_error( $init_result ) ) {
235                        /**
236                         * Unable to initialize the table properly. Set the value to `false` as we can't enable it.
237                         */
238                        $value = false;
239
240                        /**
241                         * Send error to WPCOM, so we can track and take an appropriate action.
242                         */
243                        $data = array(
244                            'timestamp'     => microtime( true ),
245                            'error_code'    => $init_result->get_error_code(),
246                            'response_body' => $init_result->get_error_message(),
247                        );
248
249                        $sender = Sender::get_instance();
250                        $sender->send_action( 'jetpack_sync_storage_error_custom_init', $data );
251
252                    } elseif ( ! Queue_Storage_Table::migrate_from_options_table_to_custom_table() ) {
253                        /**
254                         * If the migration fails, do a reverse migration and set the value to `false` as we can't
255                         * safely enable the table.
256                         */
257                        Queue_Storage_Table::migrate_from_custom_table_to_options_table();
258
259                        // Set $value to `false` as we couldn't do the migration, and we can't continue enabling the table.
260                        $value = false;
261
262                        /**
263                         * Send error to WPCOM, so we can track and take an appropriate action.
264                         */
265                        $data = array(
266                            'timestamp' => microtime( true ),
267                            // TODO: Maybe add more details here for the migration, i.e. how many items where in the queue?
268                        );
269
270                        $sender = Sender::get_instance();
271                        $sender->send_action( 'jetpack_sync_storage_error_custom_migrate', $data );
272                    }
273                } elseif ( $old_value && ! $value ) {
274                    if ( ! get_transient( Queue_Storage_Table::CUSTOM_QUEUE_TABLE_DISABLE_WPDB_ERROR_NOT_EXIST_FLAG ) ) {
275                        /**
276                         * The custom table has been disabled, migrate what we can from the custom table to the options table unless
277                         * the custom table doesn't exist in the DB.
278                         */
279                        Queue_Storage_Table::migrate_from_custom_table_to_options_table();
280                    }
281                }
282            }
283
284            /**
285             * Regular option update and handling
286             */
287            $updated = false;
288            if ( self::is_network_setting( $setting ) ) {
289                if ( is_multisite() && is_main_site() ) {
290                    $updated = update_site_option( self::SETTINGS_OPTION_PREFIX . $setting, $value );
291                }
292            } else {
293                $updated = update_option( self::SETTINGS_OPTION_PREFIX . $setting, $value, true );
294            }
295
296            // If we set the disabled option to true, clear the queues.
297            if ( ( 'disable' === $setting || 'network_disable' === $setting ) && (bool) $value ) {
298                $listener = Listener::get_instance();
299                $listener->get_sync_queue()->reset();
300                $listener->get_full_sync_queue()->reset();
301            }
302
303            // Do not enable Dedicated Sync if we cannot spawn a Dedicated Sync request.
304            if ( 'dedicated_sync_enabled' === $setting && $updated && (bool) $value ) {
305                if ( ! Dedicated_Sender::can_spawn_dedicated_sync_request() ) {
306                    update_option( self::SETTINGS_OPTION_PREFIX . $setting, 0, true );
307                    $listener = Listener::get_instance();
308                    // Remove the last two actions from the queue since we failed to enable Dedicated Sync.
309                    // Those would be `updated_option` with `jetpack_sync_settings_dedicated_sync_enabled` set to 1 and then 0 again.
310                    $queue = $listener->get_sync_queue();
311                    $items = $queue->peek_newest( 2 );
312                    $key   = 'jetpack_sync_settings_dedicated_sync_enabled';
313
314                    if (
315                        isset( $items[0][1][0] )
316                        && isset( $items[1][1][0] )
317                        && $items[0][1][0] === $key
318                        && $items[1][1][0] === $key
319                    ) {
320                        $queue->pop_newest( 2 );
321                    }
322                }
323            }
324        }
325    }
326
327    /**
328     * Whether the specified setting is a network setting.
329     *
330     * @access public
331     * @static
332     *
333     * @param string $setting Setting name.
334     * @return boolean Whether the setting is a network setting.
335     */
336    public static function is_network_setting( $setting ) {
337        return str_starts_with( $setting, 'network_' );
338    }
339
340    /**
341     * Returns escaped SQL for blacklisted post types.
342     * Can be injected directly into a WHERE clause.
343     *
344     * @access public
345     * @static
346     *
347     * @return string SQL WHERE clause.
348     */
349    public static function get_blacklisted_post_types_sql() {
350        return 'post_type NOT IN (\'' . implode( '\', \'', array_map( 'esc_sql', static::get_setting( 'post_types_blacklist' ) ) ) . '\')';
351    }
352
353    /**
354     * Returns escaped values for disallowed post types.
355     *
356     * @access public
357     * @static
358     *
359     * @return array Post type filter values
360     */
361    public static function get_disallowed_post_types_structured() {
362        return array(
363            'post_type' => array(
364                'operator' => 'NOT IN',
365                'values'   => array_map( 'esc_sql', static::get_setting( 'post_types_blacklist' ) ),
366            ),
367        );
368    }
369
370    /**
371     * Returns escaped SQL for blacklisted taxonomies.
372     * Can be injected directly into a WHERE clause.
373     *
374     * @access public
375     * @static
376     *
377     * @return string SQL WHERE clause.
378     */
379    public static function get_blacklisted_taxonomies_sql() {
380        return "taxonomy NOT IN ('" . implode( "', '", array_map( 'esc_sql', static::get_setting( 'taxonomies_blacklist' ) ) ) . "')";
381    }
382
383    /**
384     * Returns escaped SQL for whitelisted taxonomies.
385     * Can be injected directly into a WHERE clause.
386     *
387     * @access public
388     * @static
389     *
390     * @return string SQL WHERE clause.
391     */
392    public static function get_whitelisted_taxonomies_sql() {
393        global $wp_taxonomies;
394
395        $allowed_taxonomies = array_keys( $wp_taxonomies );
396        $allowed_taxonomies = array_diff( $allowed_taxonomies, static::get_setting( 'taxonomies_blacklist' ) );
397
398        return "taxonomy IN ('" . implode( "', '", array_map( 'esc_sql', $allowed_taxonomies ) ) . "')";
399    }
400
401    /**
402     * Returns escaped SQL for blacklisted post meta.
403     * Can be injected directly into a WHERE clause.
404     *
405     * @access public
406     * @static
407     *
408     * @return string SQL WHERE clause.
409     */
410    public static function get_whitelisted_post_meta_sql() {
411        return 'meta_key IN (\'' . implode( '\', \'', array_map( 'esc_sql', static::get_setting( 'post_meta_whitelist' ) ) ) . '\')';
412    }
413
414    /**
415     * Returns escaped SQL for allowed post meta keys.
416     *
417     * @access public
418     * @static
419     *
420     * @return array Meta keys filter values
421     */
422    public static function get_allowed_post_meta_structured() {
423        return array(
424            'meta_key' => array(
425                'operator' => 'IN',
426                'values'   => array_map( 'esc_sql', static::get_setting( 'post_meta_whitelist' ) ),
427            ),
428        );
429    }
430
431    /**
432     * Returns structured SQL clause for blacklisted taxonomies.
433     *
434     * @access public
435     * @static
436     *
437     * @return array taxonomies filter values
438     */
439    public static function get_blacklisted_taxonomies_structured() {
440        return array(
441            'taxonomy' => array(
442                'operator' => 'NOT IN',
443                'values'   => array_map( 'esc_sql', static::get_setting( 'taxonomies_blacklist' ) ),
444            ),
445        );
446    }
447
448    /**
449     * Returns structured SQL clause for allowed taxonomies.
450     *
451     * @access public
452     * @static
453     *
454     * @return array taxonomies filter values
455     */
456    public static function get_allowed_taxonomies_structured() {
457        global $wp_taxonomies;
458
459        $allowed_taxonomies = array_keys( $wp_taxonomies );
460        $allowed_taxonomies = array_diff( $allowed_taxonomies, static::get_setting( 'taxonomies_blacklist' ) );
461        return array(
462            'taxonomy' => array(
463                'operator' => 'IN',
464                'values'   => array_map( 'esc_sql', $allowed_taxonomies ),
465            ),
466        );
467    }
468
469    /**
470     * Returns escaped SQL for blacklisted comment meta.
471     * Can be injected directly into a WHERE clause.
472     *
473     * @access public
474     * @static
475     *
476     * @return string SQL WHERE clause.
477     */
478    public static function get_whitelisted_comment_meta_sql() {
479        return 'meta_key IN (\'' . implode( '\', \'', array_map( 'esc_sql', static::get_setting( 'comment_meta_whitelist' ) ) ) . '\')';
480    }
481
482    /**
483     * Returns SQL-escaped values for allowed post meta keys.
484     *
485     * @access public
486     * @static
487     *
488     * @return array Meta keys filter values
489     */
490    public static function get_allowed_comment_meta_structured() {
491        return array(
492            'meta_key' => array(
493                'operator' => 'IN',
494                'values'   => array_map( 'esc_sql', static::get_setting( 'comment_meta_whitelist' ) ),
495            ),
496        );
497    }
498
499    /**
500     * Returns SQL-escaped values for allowed order_item meta keys.
501     *
502     * @access public
503     * @static
504     *
505     * @return array Meta keys filter values
506     */
507    public static function get_allowed_order_itemmeta_structured() {
508        // Make sure that we only try to add the properties when the class exists.
509        if ( ! class_exists( '\Automattic\Jetpack\Sync\Modules\WooCommerce' ) ) {
510            return array();
511        }
512
513        $values = \Automattic\Jetpack\Sync\Modules\WooCommerce::$order_item_meta_whitelist;
514
515        return array(
516            'meta_key' => array(
517                'operator' => 'IN',
518                'values'   => array_map( 'esc_sql', $values ),
519            ),
520        );
521    }
522
523    /**
524     * Returns structured filter values for allowed comment types.
525     *
526     * @access public
527     * @static
528     *
529     * @return array Comment type filter values.
530     */
531    public static function get_allowed_comment_types_structured() {
532        return array(
533            'comment_type' => array(
534                'operator' => 'IN',
535                'values'   => array_map( 'esc_sql', Defaults::get_comment_types_whitelist() ),
536            ),
537        );
538    }
539
540    /**
541     * Returns escaped SQL for comments, excluding any spam comments.
542     * Can be injected directly into a WHERE clause.
543     *
544     * @access public
545     * @static
546     *
547     * @return string SQL WHERE clause.
548     */
549    public static function get_comments_filter_sql() {
550        return "comment_approved <> 'spam'";
551    }
552
553    /**
554     * Delete any settings options and clean up the current settings state.
555     *
556     * @access public
557     * @static
558     */
559    public static function reset_data() {
560        $valid_settings = self::$valid_settings;
561        foreach ( $valid_settings as $option => $value ) {
562            delete_option( self::SETTINGS_OPTION_PREFIX . $option );
563        }
564        self::set_importing( null );
565        self::set_doing_cron( null );
566        self::set_is_syncing( null );
567        self::set_is_sending( null );
568    }
569
570    /**
571     * Set the importing state.
572     *
573     * @access public
574     * @static
575     *
576     * @param boolean $is_importing Whether WordPress is currently importing.
577     */
578    public static function set_importing( $is_importing ) {
579        // Set to NULL to revert to WP_IMPORTING, the standard behavior.
580        self::$is_importing = $is_importing;
581    }
582
583    /**
584     * Whether WordPress is currently importing.
585     *
586     * @access public
587     * @static
588     *
589     * @return boolean Whether WordPress is currently importing.
590     */
591    public static function is_importing() {
592        if ( self::$is_importing !== null ) {
593            return self::$is_importing;
594        }
595
596        return defined( 'WP_IMPORTING' ) && WP_IMPORTING;
597    }
598
599    /**
600     * Whether sync is enabled.
601     *
602     * @access public
603     * @static
604     *
605     * @return boolean Whether sync is enabled.
606     */
607    public static function is_sync_enabled() {
608        return ! ( static::get_setting( 'disable' ) || static::get_setting( 'network_disable' ) );
609    }
610
611    /**
612     * Set the WP cron state.
613     *
614     * @access public
615     * @static
616     *
617     * @param boolean $is_doing_cron Whether WordPress is currently doing WP cron.
618     */
619    public static function set_doing_cron( $is_doing_cron ) {
620        // Set to NULL to revert to WP_IMPORTING, the standard behavior.
621        self::$is_doing_cron = $is_doing_cron;
622    }
623
624    /**
625     * Whether WordPress is currently doing WP cron.
626     *
627     * @access public
628     * @static
629     *
630     * @return boolean Whether WordPress is currently doing WP cron.
631     */
632    public static function is_doing_cron() {
633        if ( self::$is_doing_cron !== null ) {
634            return self::$is_doing_cron;
635        }
636
637        return defined( 'DOING_CRON' ) && DOING_CRON;
638    }
639
640    /**
641     * Whether we are currently syncing.
642     *
643     * @access public
644     * @static
645     *
646     * @return boolean Whether we are currently syncing.
647     */
648    public static function is_syncing() {
649        return (bool) self::$is_syncing || Constants::is_true( 'REST_API_REQUEST' );
650    }
651
652    /**
653     * Set the syncing state.
654     *
655     * @access public
656     * @static
657     *
658     * @param boolean $is_syncing Whether we are currently syncing.
659     */
660    public static function set_is_syncing( $is_syncing ) {
661        self::$is_syncing = $is_syncing;
662    }
663
664    /**
665     * Whether we are currently sending sync items.
666     *
667     * @access public
668     * @static
669     *
670     * @return boolean Whether we are currently sending sync items.
671     */
672    public static function is_sending() {
673        return (bool) self::$is_sending;
674    }
675
676    /**
677     * Set the sending state.
678     *
679     * @access public
680     * @static
681     *
682     * @param boolean $is_sending Whether we are currently sending sync items.
683     */
684    public static function set_is_sending( $is_sending ) {
685        self::$is_sending = $is_sending;
686    }
687
688    /**
689     * Whether should send from the queue
690     *
691     * @access public
692     * @static
693     *
694     * @param string $queue_id The queue identifier.
695     *
696     * @return boolean Whether sync is enabled.
697     */
698    public static function is_sender_enabled( $queue_id ) {
699        return (bool) static::get_setting( $queue_id . '_sender_enabled' );
700    }
701
702    /**
703     * Whether checksums are enabled.
704     *
705     * @access public
706     * @static
707     *
708     * @return boolean Whether sync is enabled.
709     */
710    public static function is_checksum_enabled() {
711        return ! (bool) static::get_setting( 'checksum_disable' );
712    }
713
714    /**
715     * Whether dedicated Sync flow is enabled.
716     *
717     * @access public
718     * @static
719     *
720     * @return boolean Whether dedicated Sync flow is enabled.
721     */
722    public static function is_dedicated_sync_enabled() {
723        return (bool) static::get_setting( 'dedicated_sync_enabled' );
724    }
725
726    /**
727     * Whether custom queue table is enabled.
728     *
729     * @access public
730     * @static
731     *
732     * @return boolean Whether custom queue table is enabled.
733     */
734    public static function is_custom_queue_table_enabled() {
735        return (bool) static::get_setting( 'custom_queue_table_enabled' );
736    }
737
738    /**
739     * Whether wpcom rest api is enabled.
740     *
741     * @access public
742     * @static
743     *
744     * @return boolean Whether wpcom rest api is enabled.
745     */
746    public static function is_wpcom_rest_api_enabled() {
747        return (bool) static::get_setting( 'wpcom_rest_api_enabled' );
748    }
749}