cache.h

Go to the documentation of this file.

#ifndef CVMFS_CACHE_H_
#define CVMFS_CACHE_H_

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

#include <stdint.h>

#include <string>

#include "crypto/hash.h"
#include "manifest.h"
#include "util/pointer.h"


class QuotaManager;

enum CacheManagerIds {
  kUnknownCacheManager = 0,
  kPosixCacheManager,
  kRamCacheManager,
  kTieredCacheManager,
  kExternalCacheManager,
};

enum CacheModes {
  kCacheReadWrite = 0,
  kCacheReadOnly,
};


class CacheManager : SingleCopy {
 public:
  static const uint64_t kSizeUnknown;

  enum ObjectType {
    kTypeRegular = 0,
    kTypeCatalog,  // implies pinned
    kTypePinned,
    kTypeVolatile,
  };

  struct ObjectInfo {
    ObjectInfo() : type(kTypeRegular), description() { }
    ObjectInfo(ObjectType t, const std::string &d) : type(t), description(d) { }

    ObjectType type;
    std::string description;
  };

  struct BlessedObject {
    explicit BlessedObject(const shash::Any &id) : id(id), info() { }
    BlessedObject(const shash::Any &id, const ObjectInfo info)
      : id(id)
      , info(info) { }
    BlessedObject(const shash::Any &id, ObjectType type)
      : id(id)
      , info(type, "") { }
    BlessedObject(const shash::Any &id, const std::string &description)
      : id(id)
      , info(kTypeRegular, description) { }
    BlessedObject(
      const shash::Any &id,
      ObjectType type,
      const std::string &description)
      : id(id)
      , info(type, description) { }

    shash::Any id;
    ObjectInfo info;
  };
  // Convenience constructors, users can call Open(CacheManager::Bless(my_hash))
  static inline BlessedObject Bless(const shash::Any &id) {
    return BlessedObject(id);
  }
  static inline BlessedObject Bless(
    const shash::Any &id,
    const ObjectInfo &info)
  {
    return BlessedObject(id, info);
  }
  static inline BlessedObject Bless(const shash::Any &id, ObjectType type) {
    return BlessedObject(id, type);
  }
  static inline BlessedObject Bless(
    const shash::Any &id,
    const std::string &description)
  {
    return BlessedObject(id, description);
  }
  static inline BlessedObject Bless(
    const shash::Any &id,
    ObjectType type,
    const std::string &description)
  {
    return BlessedObject(id, type, description);
  }

  virtual CacheManagerIds id() = 0;
  virtual std::string Describe() = 0;

  virtual bool AcquireQuotaManager(QuotaManager *quota_mgr) = 0;

  virtual ~CacheManager();
  virtual int Open(const BlessedObject &object) = 0;
  virtual int64_t GetSize(int fd) = 0;
  virtual int Close(int fd) = 0;
  virtual int64_t Pread(int fd, void *buf, uint64_t size, uint64_t offset) = 0;
  virtual int Dup(int fd) = 0;
  virtual int Readahead(int fd) = 0;

  virtual uint32_t SizeOfTxn() = 0;
  virtual int StartTxn(const shash::Any &id, uint64_t size, void *txn) = 0;
  virtual void CtrlTxn(const ObjectInfo &object_info,
                       const int flags,  // reserved for future use
                       void *txn) = 0;
  virtual int64_t Write(const void *buf, uint64_t sz, void *txn) = 0;
  virtual int Reset(void *txn) = 0;
  virtual int AbortTxn(void *txn) = 0;
  virtual int OpenFromTxn(void *txn) = 0;
  virtual int CommitTxn(void *txn) = 0;

  virtual void Spawn() = 0;

  int OpenPinned(const shash::Any &id,
                 const std::string &description,
                 bool is_catalog);
  int ChecksumFd(int fd, shash::Any *id);
  bool Open2Mem(const shash::Any &id, const std::string &description,
                unsigned char **buffer, uint64_t *size);
  bool CommitFromMem(const shash::Any &id,
                     const unsigned char *buffer,
                     const uint64_t size,
                     const std::string &description);

  QuotaManager *quota_mgr() { return quota_mgr_; }

  // Rescue the open file table during reload of the fuse module.  For the
  // POSIX cache, nothing needs to be done because the table is keep in the
  // kernel for the process.  Other cache managers need to do it manually.
  void *SaveState(const int fd_progress);
  int RestoreState(const int fd_progress, void *state);
  void FreeState(const int fd_progress, void *state);

  virtual manifest::Breadcrumb LoadBreadcrumb(const std::string & /*fqrn*/) {
    return manifest::Breadcrumb();
  }
  virtual bool StoreBreadcrumb(const manifest::Manifest &/*manifest*/) {
    return false;
  }

 protected:
  CacheManager();

  // Unless overwritten, Saving/Restoring states will crash the Fuse module
  virtual void *DoSaveState() { return NULL; }
  virtual int DoRestoreState(void *data) { return false; }
  virtual bool DoFreeState(void *data) { return false; }

  QuotaManager *quota_mgr_;

 private:
  static const unsigned kStateVersion = 0;

  struct State : SingleCopy {
    State()
      : version(kStateVersion)
      , manager_type(kUnknownCacheManager)
      , concrete_state(NULL)
    { }

    unsigned version;
    CacheManagerIds manager_type;
    void *concrete_state;
  };
};  // class CacheManager

#endif  // CVMFS_CACHE_H_