mem_file_system.h

Go to the documentation of this file.

/*
 * Copyright 2010 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_BASE_MEM_FILE_SYSTEM_H_
#define PAGESPEED_KERNEL_BASE_MEM_FILE_SYSTEM_H_

#include <map>

#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/callback.h"
#include "pagespeed/kernel/base/file_system.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/thread_annotations.h"

namespace net_instaweb {

class MessageHandler;
class MockTimer;
class ThreadSystem;
class Timer;

class MemFileSystem : public FileSystem {
 public:
  typedef Callback1<const GoogleString&> FileCallback;

  explicit MemFileSystem(ThreadSystem* threads, Timer* timer);
  virtual ~MemFileSystem();

  virtual InputFile* OpenInputFile(const char* filename,
                                   MessageHandler* message_handler);
  virtual OutputFile* OpenOutputFileHelper(const char* filename,
                                           bool append,
                                           MessageHandler* message_handler);
  virtual OutputFile* OpenTempFileHelper(const StringPiece& prefix_name,
                                        MessageHandler* message_handle);

  virtual bool ListContents(const StringPiece& dir, StringVector* files,
                            MessageHandler* handler);
  virtual bool MakeDir(const char* directory_path, MessageHandler* handler);
  virtual bool RecursivelyMakeDir(const StringPiece& directory_path,
                                  MessageHandler* handler);
  virtual bool RemoveDir(const char* path, MessageHandler* handler);
  virtual bool RemoveFile(const char* filename, MessageHandler* handler);
  virtual bool RenameFileHelper(const char* old_file, const char* new_file,
                               MessageHandler* handler);

  virtual bool Atime(const StringPiece& path, int64* timestamp_sec,
                     MessageHandler* handler);
  virtual bool Mtime(const StringPiece& path, int64* timestamp_sec,
                     MessageHandler* handler);
  virtual bool Size(const StringPiece& path, int64* size,
                    MessageHandler* handler) const;
  virtual BoolOrError Exists(const char* path, MessageHandler* handler);
  virtual BoolOrError IsDir(const char* path, MessageHandler* handler);

  virtual BoolOrError TryLock(const StringPiece& lock_name,
                              MessageHandler* handler);
  virtual BoolOrError TryLockWithTimeout(const StringPiece& lock_name,
                                         int64 timeout_ms,
                                         const Timer* timer,
                                         MessageHandler* handler);
  virtual bool BumpLockTimeout(const StringPiece& lock_name,
                               MessageHandler* handler);
  virtual bool Unlock(const StringPiece& lock_name, MessageHandler* handler);

  void set_atime_enabled(bool enabled) {
    ScopedMutex lock(all_else_mutex_.get());
    atime_enabled_ = enabled;
  }

  bool advance_time_on_update() {
    ScopedMutex lock(all_else_mutex_.get());
    return advance_time_on_update_;
  }
  void set_advance_time_on_update(bool x, MockTimer* mock_timer) {
    ScopedMutex lock(all_else_mutex_.get());
    advance_time_on_update_ = x;
    mock_timer_ = mock_timer;
  }

  void Clear();

  void Disable() {
    ScopedMutex lock(all_else_mutex_.get());
    enabled_ = false;
  }
  void Enable() {
    ScopedMutex lock(all_else_mutex_.get());
    enabled_ = true;
  }

  void ClearStats() {
    ScopedMutex lock(all_else_mutex_.get());
    num_input_file_opens_ = 0;
    num_input_file_stats_ = 0;
    num_output_file_opens_ = 0;
    num_temp_file_opens_ = 0;
  }
  int num_input_file_opens() const {
    ScopedMutex lock(all_else_mutex_.get());
    return num_input_file_opens_;
  }

  int num_input_file_stats() const {
    ScopedMutex lock(all_else_mutex_.get());
    return num_input_file_stats_;
  }
  int num_output_file_opens() const {
    ScopedMutex lock(all_else_mutex_.get());
    return num_output_file_opens_;
  }
  int num_temp_file_opens() const {
    ScopedMutex lock(all_else_mutex_.get());
    return num_temp_file_opens_;
  }

  void set_write_callback(FileCallback* x) { write_callback_.reset(x); }

  virtual bool WriteFile(const char* filename,
                         const StringPiece& buffer,
                         MessageHandler* handler);
  virtual bool WriteTempFile(const StringPiece& prefix_name,
                             const StringPiece& buffer,
                             GoogleString* filename,
                             MessageHandler* handler);


 private:
  inline void UpdateAtime(const StringPiece& path)
      SHARED_LOCKS_REQUIRED(all_else_mutex_);
  inline void UpdateMtime(const StringPiece& path)
      SHARED_LOCKS_REQUIRED(all_else_mutex_);

  scoped_ptr<AbstractMutex> lock_map_mutex_; 
  scoped_ptr<AbstractMutex> all_else_mutex_; 

  bool enabled_ GUARDED_BY(all_else_mutex_);
  StringStringMap string_map_ GUARDED_BY(all_else_mutex_);
  Timer* timer_;
  MockTimer* mock_timer_ GUARDED_BY(all_else_mutex_);

  std::map<GoogleString, int64> atime_map_ GUARDED_BY(all_else_mutex_);
  std::map<GoogleString, int64> mtime_map_ GUARDED_BY(all_else_mutex_);
  int temp_file_index_ GUARDED_BY(all_else_mutex_);
  std::map<GoogleString, int64> lock_map_ GUARDED_BY(lock_map_mutex_);
  bool atime_enabled_ GUARDED_BY(all_else_mutex_);

  bool advance_time_on_update_ GUARDED_BY(all_else_mutex_);

  int num_input_file_opens_ GUARDED_BY(all_else_mutex_);
  int num_input_file_stats_ GUARDED_BY(all_else_mutex_);
  int num_output_file_opens_ GUARDED_BY(all_else_mutex_);
  int num_temp_file_opens_ GUARDED_BY(all_else_mutex_);

  scoped_ptr<FileCallback> write_callback_;

  
};

}  

#endif