system_caches.h

Go to the documentation of this file.

// Copyright 2013 Google Inc.

#ifndef PAGESPEED_SYSTEM_SYSTEM_CACHES_H_
#define PAGESPEED_SYSTEM_SYSTEM_CACHES_H_

#include <map>
#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/cache_interface.h"
#include "pagespeed/kernel/base/message_handler.h"
#include "pagespeed/kernel/base/md5_hasher.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/sharedmem/shared_mem_cache.h"
#include "pagespeed/system/redis_cache.h"
#include "pagespeed/system/system_rewrite_options.h"

namespace net_instaweb {

class AbstractSharedMem;
class AprMemCache;
class NamedLockManager;
class QueuedWorkerPool;
class RewriteDriverFactory;
class ServerContext;
class SlowWorker;
class Statistics;
class SystemCachePath;

class SystemCaches {
 public:
  static const char kMemcachedAsync[];
  static const char kMemcachedBlocking[];
  static const char kRedisAsync[];
  static const char kRedisBlocking[];
  static const char kShmCache[];

  static const char kDefaultSharedMemoryPath[];

  enum StatFlags {
    kDefaultStatFlags = 0,
    kGlobalView = 1,
    kIncludeMemcached = 2,
    kIncludeRedis = 4
  };

  static void InitStats(Statistics* statistics);

  SystemCaches(RewriteDriverFactory* factory,
               AbstractSharedMem* shm_runtime,
               int thread_limit);

  ~SystemCaches();

  bool is_root_process() const { return is_root_process_; }

  void RegisterConfig(SystemRewriteOptions* config);
  void RootInit();
  void ChildInit();

  void StopCacheActivity();

  void ShutDown(MessageHandler* message_handler);

  void SetupCaches(ServerContext* server_context, bool enable_property_cache);

  bool CreateShmMetadataCache(
      StringPiece name, int64 size_kb, GoogleString* error_msg);

  NamedLockManager* GetLockManager(SystemRewriteOptions* config);

  void PrintCacheStats(StatFlags flags, GoogleString* out);

  void set_thread_limit(int thread_limit) { thread_limit_ = thread_limit; }

  SystemCachePath* GetCache(SystemRewriteOptions* config);

 private:
  typedef SharedMemCache<64> MetadataShmCache;
  struct MetadataShmCacheInfo {
    MetadataShmCacheInfo()
        : cache_to_use(NULL), cache_backend(NULL), initialized(false) {}

    CacheInterface* cache_to_use; 
    GoogleString segment;
    MetadataShmCache* cache_backend;
    bool initialized; 
  };

  struct ExternalCacheInterfaces {
    ExternalCacheInterfaces() : async(NULL), blocking(NULL) {}
    CacheInterface* async;
    CacheInterface* blocking;
  };

  ExternalCacheInterfaces ConstructExternalCacheInterfacesFromBlocking(
      CacheInterface* backend, QueuedWorkerPool* pool,
      int batcher_max_parallel_lookups, const char* async_stats_name,
      const char* blocking_stats_name);

  ExternalCacheInterfaces NewMemcached(SystemRewriteOptions* config);
  ExternalCacheInterfaces NewRedis(SystemRewriteOptions* config);

  ExternalCacheInterfaces NewExternalCache(SystemRewriteOptions* config);

  MetadataShmCacheInfo* LookupShmMetadataCache(const GoogleString& name);

  MetadataShmCacheInfo* GetShmMetadataCacheOrDefault(
      SystemRewriteOptions* config);

  void SetupPcacheCohorts(ServerContext* server_context,
                          bool enable_property_cache);

  scoped_ptr<SlowWorker> slow_worker_;

  RewriteDriverFactory* factory_;
  AbstractSharedMem* shared_mem_runtime_;
  int thread_limit_;
  bool is_root_process_;
  bool was_shut_down_;

  typedef std::map<GoogleString, SystemCachePath*> PathCacheMap;
  PathCacheMap path_cache_map_;

  scoped_ptr<QueuedWorkerPool> memcached_pool_;
  scoped_ptr<QueuedWorkerPool> redis_pool_;

  std::vector<AprMemCache*> memcache_servers_;
  std::vector<RedisCache*> redis_servers_;

  typedef std::map<GoogleString, ExternalCacheInterfaces> ExternalCachesMap;
  ExternalCachesMap external_caches_map_;

  typedef std::map<GoogleString, MetadataShmCacheInfo*> MetadataShmCacheMap;

  MetadataShmCacheMap metadata_shm_caches_;

  MD5Hasher cache_hasher_;

  bool default_shm_metadata_cache_creation_failed_;

  
};

}  

#endif