swissknife_history.h

Go to the documentation of this file.

#ifndef CVMFS_SWISSKNIFE_HISTORY_H_
#define CVMFS_SWISSKNIFE_HISTORY_H_

#include <string>
#include <vector>

#include "crypto/hash.h"
#include "history_sqlite.h"
#include "swissknife.h"
#include "util/future.h"

namespace manifest {
class Manifest;
}

namespace catalog {
class Catalog;
class WritableCatalog;
}

namespace upload {
struct SpoolerDefinition;
struct SpoolerResult;
class Spooler;
}

namespace swissknife {

class CommandTag : public Command {
 public:
  static const std::string kHeadTag;
  static const std::string kHeadTagDescription;
  static const std::string kPreviousHeadTag;
  static const std::string kPreviousHeadTagDescription;

  CommandTag() { }

 protected:
  typedef std::vector<history::History::Tag> TagList;
  typedef std::vector<history::History::Branch> BranchList;

  struct Environment {
    Environment(const std::string &repository_url,
                const std::string &tmp_path) :
      repository_url(repository_url), tmp_path(tmp_path) {}

    const std::string              repository_url;
    const std::string              tmp_path;

    UnlinkGuard                    manifest_path;
    UniquePtr<manifest::Manifest>  manifest;
    UniquePtr<manifest::Manifest>  previous_manifest;
    UniquePtr<history::History>    history;
    UniquePtr<upload::Spooler>     spooler;
    UnlinkGuard                    history_path;
  };


  Environment* InitializeEnvironment(const ArgumentList &args,
                                     const bool read_write);
  bool CloseAndPublishHistory(Environment *environment);
  bool UploadCatalogAndUpdateManifest(Environment               *env,
                                      catalog::WritableCatalog  *catalog);
  void UploadClosure(const upload::SpoolerResult  &result,
                           Future<shash::Any>     *hash);

  bool UpdateUndoTags(Environment                  *env,
                      const history::History::Tag  &current_head_template,
                      const bool                    undo_rollback = false);

  // TODO(jblomer): replace by swissknife::Assistant
  bool FetchObject(const std::string    &repository_url,
                   const shash::Any     &object_hash,
                   const std::string    &destination_path) const;
  history::History* GetHistory(const manifest::Manifest  *manifest,
                               const std::string         &repository_url,
                               const std::string         &history_path,
                               const bool                 read_write) const;

  catalog::Catalog* GetCatalog(const std::string  &repository_url,
                               const shash::Any   &catalog_hash,
                               const std::string   catalog_path,
                               const bool          read_write) const;

  void PrintTagMachineReadable(const history::History::Tag &tag) const;

  std::string AddPadding(const std::string  &str,
                         const size_t        padding,
                         const bool          align_right = false,
                         const std::string  &fill_char = " ") const;

  bool IsUndoTagName(const std::string &tag_name) const;
};


//------------------------------------------------------------------------------


class CommandEditTag : public CommandTag {
 public:
  virtual std::string GetName() const { return "tag_edit"; }
  virtual std::string GetDescription() const {
    return "Create a tag and/or remove tags.";
  }

  virtual ParameterList GetParams() const;
  int Main(const ArgumentList &args);

 protected:
  int RemoveTags(const ArgumentList &args, Environment *env);
  int AddNewTag(const ArgumentList &args, Environment *env);

  shash::Any GetTagRootHash(Environment *env,
                            const std::string &root_hash_string) const;
  bool ManipulateTag(Environment                  *env,
                     const history::History::Tag  &tag_template,
                     const bool                    user_provided_hash);
  bool MoveTag(Environment                  *env,
               const history::History::Tag  &tag_template);
  bool CreateTag(Environment                  *env,
                 const history::History::Tag  &new_tag);
};


//------------------------------------------------------------------------------


class CommandListTags : public CommandTag {
 public:
  virtual std::string GetName() const { return "tag_list"; }
  virtual std::string GetDescription() const {
    return "List tags in the tag database.";
  }

  virtual ParameterList GetParams() const;
  int Main(const ArgumentList &args);

 protected:
  struct BranchLevel {
    BranchLevel() : branch(), level(0) { }
    BranchLevel(const history::History::Branch &b, unsigned l)
      : branch(b), level(l) { }
    history::History::Branch branch;
    unsigned level;
  };
  typedef std::vector<BranchLevel> BranchHierarchy;

  void SortBranchesRecursively(unsigned level,
                               const std::string &parent_branch,
                               const BranchList &branches,
                               BranchHierarchy *hierarchy) const;
  BranchHierarchy SortBranches(const BranchList &branches) const;

  void PrintHumanReadableTagList(const TagList &tags) const;
  void PrintMachineReadableTagList(const TagList &tags) const;
  void PrintHumanReadableBranchList(const BranchHierarchy &branches) const;
  void PrintMachineReadableBranchList(const BranchHierarchy &branches) const;
};


//------------------------------------------------------------------------------


class CommandInfoTag : public CommandTag {
 public:
  virtual std::string GetName() const { return "tag_info"; }
  virtual std::string GetDescription() const {
    return "Obtain detailed information about a tag.";
  }

  virtual ParameterList GetParams() const;
  int Main(const ArgumentList &args);

 protected:
  std::string HumanReadableFilesize(const size_t filesize) const;
  void PrintHumanReadableInfo(const history::History::Tag &tag) const;
};


//------------------------------------------------------------------------------


class CommandRollbackTag : public CommandTag {
 public:
  virtual std::string GetName() const { return "tag_rollback"; }
  virtual std::string GetDescription() const {
    return "Rollback repository to a given tag.";
  }

  virtual ParameterList GetParams() const;
  int Main(const ArgumentList &args);

 protected:
  void PrintDeletedTagList(const TagList &tags) const;
};


//------------------------------------------------------------------------------


class CommandEmptyRecycleBin : public CommandTag {
 public:
  virtual std::string GetName() const { return "tag_empty_bin"; }
  virtual std::string GetDescription() const {
    return "Empty the internal recycle bin of the history database.";
  }

  virtual ParameterList GetParams() const;
  int Main(const ArgumentList &args);
};

}  // namespace swissknife

#endif  // CVMFS_SWISSKNIFE_HISTORY_H_