history.h

Go to the documentation of this file.

#ifndef CVMFS_HISTORY_H_
#define CVMFS_HISTORY_H_

#include <stdint.h>
#include <time.h>

#include <string>
#include <vector>

#include "crypto/hash.h"

namespace history {

class History {
 public:
  struct Branch {
    Branch() : initial_revision(0) { }
    Branch(const std::string &b, const std::string &p, uint64_t r)
        : branch(b), parent(p), initial_revision(r) { }
    std::string branch;
    std::string parent;
    uint64_t initial_revision;

    bool operator==(const Branch &other) const {
      return (this->branch == other.branch) && (this->parent == other.parent)
             && (this->initial_revision == other.initial_revision);
    }

    // Used for sorting in unit tests
    bool operator<(const Branch &other) const {
      return (this->branch < other.branch);
    }
  };

  struct Tag {
    Tag() : size(0), revision(0), timestamp(0) { }

    Tag(const std::string &n, const shash::Any &h, const uint64_t s,
        const uint64_t r, const time_t t, const std::string &d,
        const std::string &b)
        : name(n)
        , root_hash(h)
        , size(s)
        , revision(r)
        , timestamp(t)
        , description(d)
        , branch(b) { }

    bool operator==(const Tag &other) const {
      return (this->branch == other.branch)
             && (this->revision == other.revision);
    }

    bool operator<(const Tag &other) const {
      if (this->timestamp == other.timestamp)
        return this->revision < other.revision;
      return this->timestamp < other.timestamp;
    }

    bool operator>(const Tag &other) const {
      if (this->timestamp == other.timestamp)
        return this->revision > other.revision;
      return this->timestamp > other.timestamp;
    }

    std::string name;
    shash::Any root_hash;
    uint64_t size;
    uint64_t revision;
    time_t timestamp;
    std::string description;
    std::string branch;
  };  // struct Tag


 public:
  virtual ~History() { }

  virtual bool IsWritable() const = 0;
  virtual unsigned GetNumberOfTags() const = 0;

  virtual bool BeginTransaction() const = 0;

  virtual bool CommitTransaction() const = 0;

  virtual bool SetPreviousRevision(const shash::Any &history_hash) = 0;
  virtual shash::Any previous_revision() const = 0;

  virtual bool Insert(const Tag &tag) = 0;
  virtual bool Remove(const std::string &name) = 0;
  virtual bool Exists(const std::string &name) const = 0;
  virtual bool GetByName(const std::string &name, Tag *tag) const = 0;
  virtual bool GetByDate(const time_t timestamp, Tag *tag) const = 0;
  virtual bool List(std::vector<Tag> *tags) const = 0;

  virtual bool GetBranchHead(const std::string &branch_name,
                             Tag *tag) const = 0;
  virtual bool ExistsBranch(const std::string &branch_name) const = 0;
  virtual bool InsertBranch(const Branch &branch) = 0;
  virtual bool PruneBranches() = 0;
  virtual bool ListBranches(std::vector<Branch> *branches) const = 0;

  virtual bool ListRecycleBin(std::vector<shash::Any> *hashes) const = 0;
  virtual bool EmptyRecycleBin() = 0;

  virtual bool Rollback(const Tag &updated_target_tag) = 0;

  virtual bool ListTagsAffectedByRollback(const std::string &target_tag_name,
                                          std::vector<Tag> *tags) const = 0;

  virtual bool GetHashes(std::vector<shash::Any> *hashes) const = 0;

  // database file management controls
  virtual void TakeDatabaseFileOwnership() = 0;
  virtual void DropDatabaseFileOwnership() = 0;
  virtual bool OwnsDatabaseFile() const = 0;

  virtual bool Vacuum() = 0;

  const std::string &fqrn() const { return fqrn_; }

 protected:
  void set_fqrn(const std::string &fqrn) { fqrn_ = fqrn; }

 private:
  std::string fqrn_;
};

}  // namespace history

#endif  // CVMFS_HISTORY_H_