cache_posix.h

Go to the documentation of this file.

#ifndef CVMFS_CACHE_POSIX_H_
#define CVMFS_CACHE_POSIX_H_

#include <stdint.h>
#include <sys/types.h>

#include <map>
#include <string>
#include <vector>

#include "backoff.h"
#include "cache.h"
#include "catalog_mgr.h"
#include "crypto/signature.h"
#include "file_chunk.h"
#include "gtest/gtest_prod.h"
#include "manifest_fetch.h"
#include "shortstring.h"
#include "statistics.h"
#include "util/atomic.h"

namespace catalog {
class DirectoryEntry;
class Catalog;
}

namespace download {
class DownloadManager;
}

class PosixCacheManager : public CacheManager {
  FRIEND_TEST(T_CacheManager, CommitTxnQuotaNotifications);
  FRIEND_TEST(T_CacheManager, CommitTxnRenameFail);
  FRIEND_TEST(T_CacheManager, Open);
  FRIEND_TEST(T_CacheManager, OpenFromTxn);
  FRIEND_TEST(T_CacheManager, OpenPinned);
  FRIEND_TEST(T_CacheManager, Rename);
  FRIEND_TEST(T_CacheManager, StartTxn);
  FRIEND_TEST(T_CacheManager, TearDown2ReadOnly);

 public:
  enum CacheModes {
    kCacheReadWrite = 0,
    kCacheReadOnly,
  };

  enum RenameWorkarounds {
    kRenameNormal = 0,
    kRenameLink,
    kRenameSamedir
  };

  static const uint64_t kBigFile;

  virtual CacheManagerIds id() { return kPosixCacheManager; }
  virtual std::string Describe();

  static PosixCacheManager *Create(
    const std::string &cache_path,
    const bool alien_cache,
    const RenameWorkarounds rename_workaround = kRenameNormal);
  virtual ~PosixCacheManager() { }
  virtual bool AcquireQuotaManager(QuotaManager *quota_mgr);

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

  virtual uint32_t SizeOfTxn() { return sizeof(Transaction); }
  virtual int StartTxn(const shash::Any &id, uint64_t size, void *txn);
  virtual void CtrlTxn(const ObjectInfo &object_info,
                       const int flags,
                       void *txn);
  virtual int64_t Write(const void *buf, uint64_t size, void *txn);
  virtual int Reset(void *txn);
  virtual int OpenFromTxn(void *txn);
  virtual int AbortTxn(void *txn);
  virtual int CommitTxn(void *txn);

  virtual void Spawn() { }

  virtual manifest::Breadcrumb LoadBreadcrumb(const std::string &fqrn);
  virtual bool StoreBreadcrumb(const manifest::Manifest &manifest);
  bool StoreBreadcrumb(std::string fqrn, manifest::Breadcrumb breadcrumb);

  void TearDown2ReadOnly();
  CacheModes cache_mode() { return cache_mode_; }
  bool alien_cache() { return alien_cache_; }
  std::string cache_path() { return cache_path_; }

 protected:
  virtual void *DoSaveState();
  virtual int DoRestoreState(void *data);
  virtual bool DoFreeState(void *data);

 private:
  struct Transaction {
    Transaction(const shash::Any &id, const std::string &final_path)
      : buf_pos(0)
      , size(0)
      , expected_size(kSizeUnknown)
      , fd(-1)
      , object_info(kTypeRegular, "")
      , tmp_path()
      , final_path(final_path)
      , id(id)
    { }

    unsigned char buffer[4096];
    unsigned buf_pos;
    uint64_t size;
    uint64_t expected_size;
    int fd;
    ObjectInfo object_info;
    std::string tmp_path;
    std::string final_path;
    shash::Any id;
  };

  PosixCacheManager(const std::string &cache_path, const bool alien_cache)
    : cache_path_(cache_path)
    , txn_template_path_(cache_path_ + "/txn/fetchXXXXXX")
    , alien_cache_(alien_cache)
    , rename_workaround_(kRenameNormal)
    , cache_mode_(kCacheReadWrite)
    , reports_correct_filesize_(true)
  {
    atomic_init32(&no_inflight_txns_);
  }

  std::string GetPathInCache(const shash::Any &id);
  int Rename(const char *oldpath, const char *newpath);
  int Flush(Transaction *transaction);

  std::string cache_path_;
  std::string txn_template_path_;
  bool alien_cache_;
  RenameWorkarounds rename_workaround_;
  CacheModes cache_mode_;

  atomic_int32 no_inflight_txns_;

  bool reports_correct_filesize_;
};  // class PosixCacheManager

#endif  // CVMFS_CACHE_POSIX_H_