WPSEO_Sitemaps_Cache

Handles sitemaps caching and invalidation.

Defined (1)

The class is defined in the following location(s).

/inc/sitemaps/class-sitemaps-cache.php  
  1. class WPSEO_Sitemaps_Cache { 
  2.  
  3.     /** @var array $cache_clear Holds the options that, when updated, should cause the cache to clear. */ 
  4.     protected static $cache_clear = array(); 
  5.  
  6.     /** @var bool $is_enabled Mirror of enabled status for static calls. */ 
  7.     protected static $is_enabled = true; 
  8.  
  9.     /** @var bool $clear_all Holds the flag to clear all cache. */ 
  10.     protected static $clear_all = false; 
  11.  
  12.     /** @var array $clear_types Holds the array of types to clear. */ 
  13.     protected static $clear_types = array(); 
  14.  
  15.     /** 
  16.      * Hook methods for invalidation on necessary events. 
  17.      */ 
  18.     public function __construct() { 
  19.  
  20.         add_action( 'init', array( $this, 'init' ) ); 
  21.  
  22.         add_action( 'deleted_term_relationships', array( __CLASS__, 'invalidate' ) ); 
  23.  
  24.         add_action( 'update_option', array( __CLASS__, 'clear_on_option_update' ) ); 
  25.  
  26.         add_action( 'edited_terms', array( __CLASS__, 'invalidate_helper' ), 10, 2 ); 
  27.         add_action( 'clean_term_cache', array( __CLASS__, 'invalidate_helper' ), 10, 2 ); 
  28.         add_action( 'clean_object_term_cache', array( __CLASS__, 'invalidate_helper' ), 10, 2 ); 
  29.  
  30.         add_action( 'user_register', array( __CLASS__, 'invalidate_author' ) ); 
  31.         add_action( 'delete_user', array( __CLASS__, 'invalidate_author' ) ); 
  32.  
  33.         add_action( 'shutdown', array( __CLASS__, 'clear_queued' ) ); 
  34.     } 
  35.  
  36.     /** 
  37.      * Setup context for static calls. 
  38.      */ 
  39.     public function init() { 
  40.  
  41.         self::$is_enabled = $this->is_enabled(); 
  42.     } 
  43.  
  44.     /** 
  45.      * If cache is enabled. 
  46.      * 
  47.      * @since 3.2 
  48.      * 
  49.      * @return boolean 
  50.      */ 
  51.     public function is_enabled() { 
  52.  
  53.         /** 
  54.          * Filter if XML sitemap transient cache is enabled. 
  55.          * 
  56.          * @param bool $unsigned Enable cache or not, defaults to true 
  57.          */ 
  58.         return apply_filters( 'wpseo_enable_xml_sitemap_transient_caching', true ); 
  59.     } 
  60.  
  61.  
  62.     /** 
  63.      * Retrieve the sitemap page from cache. 
  64.      * 
  65.      * @since 3.2 
  66.      * 
  67.      * @param string $type Sitemap type. 
  68.      * @param int    $page Page number to retrieve. 
  69.      * 
  70.      * @return string|boolean 
  71.      */ 
  72.     public function get_sitemap( $type, $page ) { 
  73.  
  74.         $transient_key = WPSEO_Sitemaps_Cache_Validator::get_storage_key( $type, $page ); 
  75.         if ( false === $transient_key ) { 
  76.             return false; 
  77.         } 
  78.  
  79.         return get_transient( $transient_key ); 
  80.     } 
  81.  
  82.     /** 
  83.      * Get the sitemap that is cached 
  84.      * 
  85.      * @param string $type Sitemap type. 
  86.      * @param int    $page Page number to retrieve. 
  87.      * 
  88.      * @return null|WPSEO_Sitemap_Cache_Data Null on no cache found otherwise object containing sitemap and meta data. 
  89.      */ 
  90.     public function get_sitemap_data( $type, $page ) { 
  91.  
  92.         $sitemap = $this->get_sitemap( $type, $page ); 
  93.  
  94.         if ( empty( $sitemap ) ) { 
  95.             return null; 
  96.         } 
  97.  
  98.         // Unserialize Cache Data object (is_serialized doesn't recognize classes). 
  99.         if ( is_string( $sitemap ) && 0 === strpos( $sitemap, 'C:24:"WPSEO_Sitemap_Cache_Data"' ) ) { 
  100.  
  101.             $sitemap = unserialize( $sitemap ); 
  102.         } 
  103.  
  104.         // What we expect it to be if it is set. 
  105.         if ( $sitemap instanceof WPSEO_Sitemap_Cache_Data_Interface ) { 
  106.             return $sitemap; 
  107.         } 
  108.  
  109.         return null; 
  110.     } 
  111.  
  112.     /** 
  113.      * Store the sitemap page from cache. 
  114.      * 
  115.      * @since 3.2 
  116.      * 
  117.      * @param string $type    Sitemap type. 
  118.      * @param int    $page    Page number to store. 
  119.      * @param string $sitemap Sitemap body to store. 
  120.      * @param bool   $usable  Is this a valid sitemap or a cache of an invalid sitemap. 
  121.      * 
  122.      * @return bool 
  123.      */ 
  124.     public function store_sitemap( $type, $page, $sitemap, $usable = true ) { 
  125.  
  126.         $transient_key = WPSEO_Sitemaps_Cache_Validator::get_storage_key( $type, $page ); 
  127.  
  128.         if ( false === $transient_key ) { 
  129.             return false; 
  130.         } 
  131.  
  132.         $status = ( $usable ) ? WPSEO_Sitemap_Cache_Data::OK : WPSEO_Sitemap_Cache_Data::ERROR; 
  133.  
  134.         $sitemap_data = new WPSEO_Sitemap_Cache_Data(); 
  135.         $sitemap_data->set_sitemap( $sitemap ); 
  136.         $sitemap_data->set_status( $status ); 
  137.  
  138.         return set_transient( $transient_key, $sitemap_data, DAY_IN_SECONDS ); 
  139.     } 
  140.  
  141.     /** 
  142.      * Delete cache transients for index and specific type. 
  143.      * 
  144.      * Always deletes the main index sitemaps cache, as that's always invalidated by any other change. 
  145.      * 
  146.      * @since 1.5.4 
  147.      * @since 3.2   Changed from function wpseo_invalidate_sitemap_cache() to method in this class. 
  148.      * 
  149.      * @param string $type Sitemap type to invalidate. 
  150.      * 
  151.      * @return void 
  152.      */ 
  153.     public static function invalidate( $type ) { 
  154.  
  155.         self::clear( array( $type ) ); 
  156.     } 
  157.  
  158.     /** 
  159.      * Helper to invalidate in hooks where type is passed as second argument. 
  160.      * 
  161.      * @since 3.2 
  162.      * 
  163.      * @param int    $unused Unused term ID value. 
  164.      * @param string $type   Taxonomy to invalidate. 
  165.      * 
  166.      * @return void 
  167.      */ 
  168.     public static function invalidate_helper( $unused, $type ) { 
  169.  
  170.         $sitemap_options = WPSEO_Options::get_option( 'wpseo_xml' ); 
  171.  
  172.         $taxonomy_not_in_sitemap = 'taxonomies-' . $type . '-not_in_sitemap'; 
  173.         if ( isset( $sitemap_options[ $taxonomy_not_in_sitemap ] ) && $sitemap_options[ $taxonomy_not_in_sitemap ] === false ) { 
  174.             self::invalidate( $type ); 
  175.         } 
  176.     } 
  177.  
  178.     /** 
  179.      * Invalidate sitemap cache for authors. 
  180.      * 
  181.      * @param int $user_id User ID. 
  182.      */ 
  183.     public static function invalidate_author( $user_id ) { 
  184.  
  185.         $user = get_user_by( 'id', $user_id ); 
  186.  
  187.         if ( 'user_register' === current_action() ) { 
  188.             update_user_meta( $user_id, '_yoast_wpseo_profile_updated', time() ); 
  189.         } 
  190.  
  191.         if ( ! in_array( 'subscriber', $user->roles ) ) { 
  192.             self::invalidate( 'author' ); 
  193.         } 
  194.     } 
  195.  
  196.     /** 
  197.      * Invalidate sitemap cache for the post type of a post. 
  198.      * 
  199.      * Don't invalidate for revisions. 
  200.      * 
  201.      * @since 1.5.4 
  202.      * @since 3.2   Changed from function wpseo_invalidate_sitemap_cache_on_save_post() to method in this class. 
  203.      * 
  204.      * @param int $post_id Post ID to invalidate type for. 
  205.      * 
  206.      * @return void 
  207.      */ 
  208.     public static function invalidate_post( $post_id ) { 
  209.  
  210.         if ( wp_is_post_revision( $post_id ) ) { 
  211.             return; 
  212.         } 
  213.  
  214.         self::invalidate( get_post_type( $post_id ) ); 
  215.     } 
  216.  
  217.     /** 
  218.      * Delete cache transients for given sitemaps types or all by default. 
  219.      * 
  220.      * @since 1.8.0 
  221.      * @since 3.2   Moved from WPSEO_Utils to this class. 
  222.      * 
  223.      * @param array $types Set of sitemap types to delete cache transients for. 
  224.      * 
  225.      * @return void 
  226.      */ 
  227.     public static function clear( $types = array() ) { 
  228.  
  229.         if ( ! self::$is_enabled ) { 
  230.             return; 
  231.         } 
  232.  
  233.         // No types provided, clear all. 
  234.         if ( empty( $types ) ) { 
  235.             self::$clear_all = true; 
  236.  
  237.             return; 
  238.         } 
  239.  
  240.         // Always invalidate the index sitemap as well. 
  241.         if ( ! in_array( WPSEO_Sitemaps::SITEMAP_INDEX_TYPE, $types ) ) { 
  242.             array_unshift( $types, WPSEO_Sitemaps::SITEMAP_INDEX_TYPE ); 
  243.         } 
  244.  
  245.         foreach ( $types as $type ) { 
  246.             if ( ! in_array( $type, self::$clear_types ) ) { 
  247.                 self::$clear_types[] = $type; 
  248.             } 
  249.         } 
  250.     } 
  251.  
  252.     /** 
  253.      * Invalidate storage for cache types queued to clear. 
  254.      */ 
  255.     public static function clear_queued() { 
  256.  
  257.         if ( self::$clear_all ) { 
  258.  
  259.             WPSEO_Sitemaps_Cache_Validator::invalidate_storage(); 
  260.             self::$clear_all = false; 
  261.             self::$clear_types = array(); 
  262.  
  263.             return; 
  264.         } 
  265.  
  266.         foreach ( self::$clear_types as $type ) { 
  267.             WPSEO_Sitemaps_Cache_Validator::invalidate_storage( $type ); 
  268.         } 
  269.  
  270.         self::$clear_types = array(); 
  271.     } 
  272.  
  273.     /** 
  274.      * Adds a hook that when given option is updated, the cache is cleared 
  275.      * 
  276.      * @since 3.2 
  277.      * 
  278.      * @param string $option Option name. 
  279.      * @param string $type   Sitemap type. 
  280.      */ 
  281.     public static function register_clear_on_option_update( $option, $type = '' ) { 
  282.  
  283.         self::$cache_clear[ $option ] = $type; 
  284.     } 
  285.  
  286.     /** 
  287.      * Clears the transient cache when a given option is updated, if that option has been registered before 
  288.      * 
  289.      * @since 3.2 
  290.      * 
  291.      * @param string $option The option name that's being updated. 
  292.      * 
  293.      * @return void 
  294.      */ 
  295.     public static function clear_on_option_update( $option ) { 
  296.  
  297.         if ( array_key_exists( $option, self::$cache_clear ) ) { 
  298.  
  299.             if ( empty( self::$cache_clear[ $option ] ) ) { 
  300.                 // Clear all caches. 
  301.                 self::clear(); 
  302.             } 
  303.             else { 
  304.                 // Clear specific provided type(s). 
  305.                 $types = (array) self::$cache_clear[ $option ]; 
  306.                 self::clear( $types ); 
  307.             } 
  308.         } 
  309.     } 
  310. }