property_cache.h

Go to the documentation of this file.

/*
 * Copyright 2012 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef PAGESPEED_OPT_HTTP_PROPERTY_CACHE_H_
#define PAGESPEED_OPT_HTTP_PROPERTY_CACHE_H_

#include <map>
#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/ref_counted_ptr.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/cache/cache_interface.h"
#include "pagespeed/opt/http/request_context.h"

namespace net_instaweb {

class AbstractLogRecord;
class AbstractMutex;
class AbstractPropertyStoreGetCallback;
class PropertyCacheValues;
class PropertyValueProtobuf;
class PropertyPage;
class PropertyStore;
class Statistics;
class ThreadSystem;
class Timer;

typedef std::vector<PropertyPage*> PropertyPageStarVector;

class PropertyValue {
 public:
  StringPiece value() const;
  bool has_value() const { return valid_; }

  int64 write_timestamp_ms() const;

  bool was_read() { return was_read_; }

  bool IsStable(int stable_hit_per_thousand_threshold) const;

  bool IsRecentlyConstant(int num_writes_unchanged) const;

  static bool IsIndexOfLeastSetBitSmaller(uint64 value, int index);

 private:
  friend class PropertyCache;
  friend class PropertyPage;

  PropertyValue();
  ~PropertyValue();

  void set_was_read(bool was_read) { was_read_ = was_read; }

  void InitFromProtobuf(const PropertyValueProtobuf& value);

  void SetValue(const StringPiece& value, int64 now_ms);

  PropertyValueProtobuf* protobuf() { return proto_.get(); }

  scoped_ptr<PropertyValueProtobuf> proto_;
  bool changed_;
  bool valid_;
  bool was_read_;

  
};

class PropertyCache {
 public:
  class Cohort {
   public:
    explicit Cohort(StringPiece name) {
      name.CopyToString(&name_);
    }
    const GoogleString& name() const { return name_; }

   private:
    GoogleString name_;

    
  };

  typedef std::vector<const Cohort*> CohortVector;

  PropertyCache(PropertyStore* property_store,
                Timer* timer,
                Statistics* stats,
                ThreadSystem* threads);
  ~PropertyCache();

  void Read(PropertyPage* property_page) const;

  void ReadWithCohorts(const CohortVector& cohort_list,
                       PropertyPage* property_page) const;

  const CohortVector& GetAllCohorts() const { return cohort_list_; }

  bool IsStable(const PropertyValue* property) const {
    return property->IsStable(mutations_per_1000_writes_threshold_);
  }

  bool IsExpired(const PropertyValue* property_value, int64 ttl_ms) const;

  void set_mutations_per_1000_writes_threshold(int x) {
    mutations_per_1000_writes_threshold_ = x;
  }

  const Cohort* AddCohort(const StringPiece& cohort_name);

  const Cohort* GetCohort(const StringPiece& cohort_name) const;

  void set_enabled(bool x) { enabled_ = x; }

  bool enabled() const { return enabled_; }

  static void InitCohortStats(const GoogleString& cohort,
                              Statistics* statistics);

  static GoogleString GetStatsPrefix(const GoogleString& cohort_name);

  Timer* timer() const { return timer_; }

  ThreadSystem* thread_system() const { return thread_system_; }

  PropertyStore* property_store() { return property_store_; }


 private:
  PropertyStore* property_store_;
  Timer* timer_;
  Statistics* stats_;
  ThreadSystem* thread_system_;

  int mutations_per_1000_writes_threshold_;
  typedef std::map<GoogleString, Cohort*> CohortMap;
  CohortMap cohorts_;
  CohortVector cohort_list_;
  bool enabled_;

  
};

class AbstractPropertyPage {
 public:
  virtual ~AbstractPropertyPage();
  virtual PropertyValue* GetProperty(
      const PropertyCache::Cohort* cohort,
      const StringPiece& property_name) = 0;

  virtual void UpdateValue(
     const PropertyCache::Cohort* cohort, const StringPiece& property_name,
     const StringPiece& value) = 0;

  virtual void WriteCohort(const PropertyCache::Cohort* cohort) = 0;

  virtual CacheInterface::KeyState GetCacheState(
     const PropertyCache::Cohort* cohort) = 0;

  virtual void DeleteProperty(const PropertyCache::Cohort* cohort,
                              const StringPiece& property_name) = 0;
};


class PropertyPage : public AbstractPropertyPage {
 public:
  enum PageType {
    kPropertyCachePage,
    kPropertyCacheFallbackPage,
    kPropertyCachePerOriginPage,
  };

  virtual ~PropertyPage();

  virtual PropertyValue* GetProperty(const PropertyCache::Cohort* cohort,
                                     const StringPiece& property_name);

  virtual void UpdateValue(
      const PropertyCache::Cohort* cohort, const StringPiece& property_name,
      const StringPiece& value);

  virtual void WriteCohort(const PropertyCache::Cohort* cohort);

  CacheInterface::KeyState GetCacheState(const PropertyCache::Cohort* cohort);

  void SetCacheState(const PropertyCache::Cohort* cohort,
                     CacheInterface::KeyState x);

  void DeleteProperty(const PropertyCache::Cohort* cohort,
                      const StringPiece& property_name);

  AbstractLogRecord* log_record() {
    return request_context_->log_record();
  }

  void Read(const PropertyCache::CohortVector& cohort_list);

  void Abort();

  virtual bool IsCacheValid(int64 write_timestamp_ms) const { return true; }

  void AddValueFromProtobuf(const PropertyCache::Cohort* cohort,
                            const PropertyValueProtobuf& proto);

  PageType page_type() { return page_type_; }

  bool IsCohortPresent(const PropertyCache::Cohort* cohort);

  void FastFinishLookup();

  bool EncodePropertyCacheValues(const PropertyCache::Cohort* cohort,
                                 PropertyCacheValues* values);

  static StringPiece PageTypeSuffix(PageType type);

 protected:
  PropertyPage(PageType page_type,
               StringPiece url,
               StringPiece options_signature_hash,
               StringPiece cache_key_suffix,
               const RequestContextPtr& request_context,
               AbstractMutex* mutex,
               PropertyCache* property_cache);

  virtual void Done(bool success) = 0;

 private:
  void SetupCohorts(const PropertyCache::CohortVector& cohort_list);

  bool HasPropertyValueDeleted(const PropertyCache::Cohort* cohort);

  void CallDone(bool success) {
    was_read_ = true;
    Done(success);
  }

  typedef std::map<GoogleString, PropertyValue*> PropertyMap;

  struct PropertyMapStruct {
    explicit PropertyMapStruct(AbstractLogRecord* log)
        : has_deleted_property(false),
          log_record(log),
          has_value(false) {}
    PropertyMap pmap;
    bool has_deleted_property;
    AbstractLogRecord* log_record;
    CacheInterface::KeyState cache_state;
    bool has_value;
  };
  typedef std::map<const PropertyCache::Cohort*, PropertyMapStruct*>
      CohortDataMap;
  CohortDataMap cohort_data_map_;
  scoped_ptr<AbstractMutex> mutex_;
  GoogleString url_;
  GoogleString options_signature_hash_;
  GoogleString cache_key_suffix_;
  RequestContextPtr request_context_;
  bool was_read_;
  PropertyCache* property_cache_; 
  AbstractPropertyStoreGetCallback* property_store_callback_;
  PageType page_type_;

  
};

}  

#endif