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_FILE_SYSTEM_H_
#define PAGESPEED_KERNEL_BASE_FILE_SYSTEM_H_

#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

class BoolOrError {
  enum Choice {
    kIsFalse,
    kIsTrue,
    kIsError
  };

 public:
  BoolOrError() : choice_(kIsError) { }
  explicit BoolOrError(bool t_or_f) : choice_(t_or_f ? kIsTrue : kIsFalse) { }

  BoolOrError(const BoolOrError& src) : choice_(src.choice_) { }
  BoolOrError& operator=(const BoolOrError& src) {
    if (&src != this) {
      choice_ = src.choice_;
    }
    return *this;
  }

  bool is_false() const { return choice_ == kIsFalse; }
  bool is_true() const { return choice_ == kIsTrue; }
  bool is_error() const { return choice_ == kIsError; }
  void set_error() { choice_ = kIsError; }
  void set(bool t_or_f) { choice_ = t_or_f ? kIsTrue : kIsFalse; }

 private:
  Choice choice_;
};

class MessageHandler;
class Timer;
class Writer;

class FileSystem {
 public:
  static const int64 kUnlimitedSize = -1;

  virtual ~FileSystem();

  class File {
   public:
    virtual ~File();

    virtual const char* filename() = 0;

   protected:
    friend class FileSystem;
    virtual bool Close(MessageHandler* handler) = 0;
  };

  class InputFile : public File {
   public:
    virtual int Read(char* buf, int size, MessageHandler* handler) = 0;

    virtual bool ReadFile(GoogleString* buf, int64 max_file_size,
                          MessageHandler* handler) = 0;

   protected:
    friend class FileSystem;
    virtual ~InputFile();
  };

  class OutputFile : public File {
   public:
    virtual bool Write(const StringPiece& buf, MessageHandler* handler) = 0;
    virtual bool Flush(MessageHandler* handler) = 0;
    virtual bool SetWorldReadable(MessageHandler* handler) = 0;

   protected:
    friend class FileSystem;
    virtual ~OutputFile();
  };

  class ProgressNotifier {
   public:
    virtual void Notify() = 0;
    virtual ~ProgressNotifier() {}
  };

  class NullProgressNotifier : public ProgressNotifier {
   public:
    void Notify() override {}
  };

  struct FileInfo {
    FileInfo(int64 size_bytes, int64 atime_sec, const GoogleString& name)
        : size_bytes(size_bytes), atime_sec(atime_sec), name(name) {}

    int64 size_bytes;
    int64 atime_sec;
    GoogleString name;
  };

  struct DirInfo {
    DirInfo() : size_bytes(0), inode_count(0) { }

    std::vector<FileInfo> files;
    StringVector empty_dirs;
    int64 size_bytes;
    int64 inode_count;
  };

  virtual int MaxPathLength(const StringPiece& base) const;

  virtual bool ReadFile(const char* filename,
                        int64 max_file_size,
                        Writer* writer,
                        MessageHandler* handler);
  virtual bool ReadFile(InputFile* input_file,
                        int64 max_file_size,
                        Writer* writer,
                        MessageHandler* handler);
  virtual bool ReadFile(const char* filename,
                        int64 max_file_size,
                        GoogleString* buffer,
                        MessageHandler* handler);
  virtual bool ReadFile(InputFile* input_file,
                        int64 max_file_size,
                        GoogleString* buffer,
                        MessageHandler* handler);
  virtual bool ReadFile(const char* filename,
                        GoogleString* buffer,
                        MessageHandler* handler);
  virtual bool ReadFile(InputFile* input_file,
                        GoogleString* buffer,
                        MessageHandler* handler);
  virtual bool ReadFile(const char* filename,
                        Writer* writer,
                        MessageHandler* handler);
  virtual bool ReadFile(InputFile* input_file,
                        Writer* writer,
                        MessageHandler* handler);
  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);

  bool WriteFileAtomic(const StringPiece& filename,
                       const StringPiece& buffer,
                       MessageHandler* handler);

  virtual InputFile* OpenInputFile(const char* filename,
                                   MessageHandler* handler) = 0;
  OutputFile* OpenOutputFile(const char* filename,
                             MessageHandler* handler) {
    SetupFileDir(filename, handler);
    return OpenOutputFileHelper(filename, false, handler);
  }
  OutputFile* OpenOutputFileForAppend(const char* filename,
                                      MessageHandler* handler) {
    SetupFileDir(filename, handler);
    return OpenOutputFileHelper(filename, true, handler);
  }
  OutputFile* OpenTempFile(const StringPiece& prefix_name,
                           MessageHandler* handler) {
    SetupFileDir(prefix_name, handler);
    return OpenTempFileHelper(prefix_name, handler);
  }

  virtual bool Close(File* file, MessageHandler* handler);


  virtual bool RemoveFile(const char* filename, MessageHandler* handler) = 0;

  bool RenameFile(const char* old_filename, const char* new_filename,
                  MessageHandler* handler) {
    SetupFileDir(new_filename, handler);
    return RenameFileHelper(old_filename, new_filename, handler);
  }

  virtual bool MakeDir(const char* directory_path, MessageHandler* handler) = 0;

  virtual bool RemoveDir(const char* directory_path,
                         MessageHandler* handler) = 0;

  virtual BoolOrError Exists(const char* path, MessageHandler* handler) = 0;

  virtual BoolOrError IsDir(const char* path, MessageHandler* handler) = 0;

  virtual bool RecursivelyMakeDir(const StringPiece& directory_path,
                                  MessageHandler* handler);

  virtual bool ListContents(const StringPiece& dir, StringVector* files,
                            MessageHandler* handler) = 0;

  virtual bool Atime(const StringPiece& path, int64* timestamp_sec,
                     MessageHandler* handler) = 0;

  virtual bool Mtime(const StringPiece& path, int64* timestamp_sec,
                     MessageHandler* handler) = 0;

  void GetDirInfo(const StringPiece& path, DirInfo* dirinfo,
                  MessageHandler* handler);

  virtual void GetDirInfoWithProgress(
      const StringPiece& path, DirInfo* dirinfo,
      ProgressNotifier* notifier, MessageHandler* handler);

  virtual bool Size(const StringPiece& path, int64* size,
                    MessageHandler* handler) const = 0;

  virtual BoolOrError TryLock(const StringPiece& lock_name,
                              MessageHandler* handler) = 0;

  virtual BoolOrError TryLockWithTimeout(const StringPiece& lock_name,
                                         int64 timeout_millis,
                                         const Timer* timer,
                                         MessageHandler* handler) {
    return TryLock(lock_name, handler);
  }

  virtual bool BumpLockTimeout(const StringPiece& lock_name,
                               MessageHandler* handler) {
    return true;
  }

  virtual bool Unlock(const StringPiece& lock_name,
                      MessageHandler* handler) = 0;

 protected:
  virtual OutputFile* OpenOutputFileHelper(const char* filename,
                                           bool append,
                                           MessageHandler* handler) = 0;
  virtual OutputFile* OpenTempFileHelper(const StringPiece& filename,
                                         MessageHandler* handler) = 0;
  virtual bool RenameFileHelper(const char* old_filename,
                                const char* new_filename,
                                MessageHandler* handler) = 0;

 private:
  void SetupFileDir(const StringPiece& filename, MessageHandler* handler);
};

}  

#endif