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_