purge_context.h

Go to the documentation of this file.

/*
 * Copyright 2013 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_KERNEL_CACHE_PURGE_CONTEXT_H_
#define PAGESPEED_KERNEL_CACHE_PURGE_CONTEXT_H_

#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/callback.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/timer.h"
#include "pagespeed/kernel/cache/purge_set.h"
#include "pagespeed/kernel/util/copy_on_write.h"

namespace net_instaweb {

class AbstractMutex;
class FileSystem;
class MessageHandler;
class NamedLock;
class NamedLockManager;
class Scheduler;
class Statistics;
class ThreadSystem;
class UpDownCounter;
class Variable;

class PurgeContext {
 public:
  typedef Callback2<bool, StringPiece> PurgeCallback;
  typedef Callback1<const CopyOnWrite<PurgeSet>&> PurgeSetCallback;

  static const int kCheckCacheIntervalMs = 5 * Timer::kSecondMs;

  static const char kCancellations[];
  static const char kContentions[];
  static const char kFileParseFailures[];
  static const char kFileStats[];
  static const char kFileWriteFailures[];
  static const char kFileWrites[];
  static const char kPurgeIndex[];
  static const char kPurgePollTimestampMs[];
  static const char kStatCalls[];

  PurgeContext(StringPiece filename,
               FileSystem* file_system,
               Timer* timer,
               int max_bytes_in_cache,
               ThreadSystem* thread_system,
               NamedLockManager* lock_manager,
               Scheduler* scheduler,
               Statistics* statistics,
               MessageHandler* handler);
  ~PurgeContext();

  static void InitStats(Statistics* statistics);

  void set_request_batching_delay_ms(int64 delay_ms) {
    request_batching_delay_ms_ = delay_ms;
  }

  void AddPurgeUrl(StringPiece url, int64 timestamp_ms,
                   PurgeCallback* callback);

  void SetCachePurgeGlobalTimestampMs(int64 timestamp_ms,
                                      PurgeCallback* callback);

  void PollFileSystem();

  void SetUpdateCallback(PurgeSetCallback* cb);

  void set_enable_purge(bool x) { enable_purge_ = x; }

 private:
  friend class PurgeContextTest;

  typedef std::vector<PurgeCallback*> PurgeCallbackVector;

  void UpdateCachePurgeFile();

  void ReadPurgeFile(PurgeSet* purges_from_file);
  void ReadFileAndCallCallbackIfChanged(bool needs_update);

  void ModifyPurgeSet(PurgeSet* purges_from_file, GoogleString* buffer,
                      PurgeCallbackVector* return_callbacks,
                      PurgeSet* return_purges,
                      int* failures);

  void HandleWriteFailure(int failures,
                          PurgeCallbackVector* callbacks,
                          PurgeSet* return_purges,
                          bool* lock_and_update);

  bool WritePurgeFile(const GoogleString& buffer);

  bool Verify(const GoogleString& expected_purge_file_contents);

  GoogleString LockName() const { return StrCat(filename_, "-lock"); }

  void WaitForTimerAndGrabLock();

  void GrabLockAndUpdate();

  void CancelCachePurgeFile();

  bool ParseAndValidateTimestamp(StringPiece time_string, int64 now_ms,
                                 int64* timestamp_ms);

  GoogleString filename_;
  scoped_ptr<NamedLock> interprocess_lock_;
  FileSystem* file_system_;
  Timer* timer_;

  Statistics* statistics_;
  scoped_ptr<AbstractMutex> mutex_;
  CopyOnWrite<PurgeSet> purge_set_; 
  PurgeSet pending_purges_; 
  PurgeCallbackVector pending_callbacks_; 
  int64 local_purge_index_; 
  int num_consecutive_failures_; 
  bool waiting_for_interprocess_lock_; 
  bool reading_; 

  bool enable_purge_; 
  int max_bytes_in_cache_;

  int64 request_batching_delay_ms_;

  Variable* cancellations_;
  Variable* contentions_;
  Variable* file_parse_failures_;
  Variable* file_stats_;
  Variable* file_write_failures_;
  Variable* file_writes_;
  Variable* purge_index_;
  scoped_ptr<UpDownCounter> purge_poll_timestamp_ms_;

  Scheduler* scheduler_;
  MessageHandler* message_handler_;

  scoped_ptr<PurgeSetCallback> update_callback_;

  
};

}  

#endif