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 "compression/compression.h"
#include "crypto/hash.h"
#include "manifest.h"
#include "util/pointer.h"


class QuotaManager;

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

enum CacheModes {
  kCacheReadWrite = 0,
  kCacheReadOnly,
};


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

  static const int kLabelCatalog     = 0x01;
  static const int kLabelPinned      = 0x02;
  static const int kLabelVolatile    = 0x04;
  static const int kLabelExternal    = 0x08;
  static const int kLabelChunked     = 0x10;
  static const int kLabelCertificate = 0x20;
  static const int kLabelMetainfo    = 0x40;
  static const int kLabelHistory     = 0x80;

  struct Label {
    Label() : flags(0)
            , size(kSizeUnknown)
            , zip_algorithm(zlib::kZlibDefault)
            , range_offset(-1)
    {}

    bool IsCatalog() const { return flags & kLabelCatalog; }
    bool IsPinned() const { return flags & kLabelPinned; }
    bool IsExternal() const { return flags & kLabelExternal; }
    bool IsCertificate() const { return flags & kLabelCertificate; }

    std::string GetDescription() const {
      if (flags & kLabelCatalog)
        return "file catalog at " + path;
      if (flags & kLabelCertificate)
        return "certificate for " + path;
      if (flags & kLabelMetainfo)
        return "metainfo for " + path;
      if (flags & kLabelHistory)
        return "tag database for " + path;
      if (flags & kLabelChunked)
        return "Part of " + path;
      return path;
    }

    int flags;
    uint64_t size;  
    zlib::Algorithms zip_algorithm;
    off_t range_offset;
    std::string path;
  };

  struct LabeledObject {
    explicit LabeledObject(const shash::Any &id) : id(id), label() { }
    LabeledObject(const shash::Any &id, const Label &l)
      : id(id)
      , label(l) { }

    shash::Any id;
    Label label;
  };

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

  virtual bool AcquireQuotaManager(QuotaManager *quota_mgr) = 0;

  virtual ~CacheManager();
  virtual int Open(const LabeledObject &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 Label &label,
                       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 ChecksumFd(int fd, shash::Any *id);
  int OpenPinned(const LabeledObject &object);
  bool Open2Mem(const LabeledObject &object,
                unsigned char **buffer, uint64_t *size);
  bool CommitFromMem(const LabeledObject &object,
                     const unsigned char *buffer,
                     const uint64_t size);

  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);
  CacheManagerIds PeekState(void *state) {
    return static_cast<State *>(state)->manager_type;
  }

  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_