RootChainWalker(const manifest::Manifest *manifest,

    , manifest_(manifest) {}

  DatabaseT* ReturnOrAbort(const ObjectFetcherFailures::Failures  failure,

ParameterList CommandReconstructReflog::GetParams() const {

  ParameterList r;

  r.push_back(Parameter::Mandatory('r', "repository url"));

  r.push_back(Parameter::Mandatory('u', "spooler definition string"));

  r.push_back(Parameter::Mandatory('n', "fully qualified repository name"));

  r.push_back(Parameter::Mandatory('t', "temporary directory"));

  r.push_back(Parameter::Mandatory('k', "repository keychain"));

  r.push_back(Parameter::Mandatory('R', "path to reflog.chksum file"));

  return r;

int CommandReconstructReflog::Main(const ArgumentList &args) {

  const std::string &repo_url           = *args.find('r')->second;

  const std::string &spooler            = *args.find('u')->second;

  const std::string &repo_name          = *args.find('n')->second;

  const std::string &tmp_dir            = *args.find('t')->second;

  const std::string &repo_keys          = *args.find('k')->second;

  const std::string &reflog_chksum_path = *args.find('R')->second;

  const bool follow_redirects = false;

  if (!this->InitDownloadManager(follow_redirects) ||

    LogCvmfs(kLogCvmfs, kLogStderr, "failed to init repo connection");

    return 1;

                               signature_manager());

  UniquePtr<manifest::Manifest> manifest;

  ObjectFetcher::Failures retval = object_fetcher.FetchManifest(&manifest);

  if (retval != ObjectFetcher::kFailOk) {

                                    retval, Code2Ascii(retval));

    return 1;

  const upload::SpoolerDefinition spooler_definition(spooler, shash::kAny);

                       upload::AbstractUploader::Construct(spooler_definition));

  if (!uploader.IsValid()) {

             spooler.c_str());

    return 1;

  UniquePtr<manifest::Reflog> reflog(CreateEmptyReflog(tmp_dir, repo_name));

  reflog->TakeDatabaseFileOwnership();

  reflog->BeginTransaction();

  AddStaticManifestObjects(reflog.weak_ref(), manifest.weak_ref());

                         reflog.weak_ref());

  walker.FindObjectsAndPopulateReflog();

  reflog->CommitTransaction();

  LogCvmfs(kLogCvmfs, kLogStdout, "found %d entries", reflog->CountEntries());

  reflog->DropDatabaseFileOwnership();

  const std::string reflog_db = reflog->database_file();

  reflog.Destroy();

  uploader->Upload(reflog_db, ".cvmfsreflog");

  shash::Any reflog_hash(manifest->GetHashAlgorithm());

  manifest::Reflog::HashDatabase(reflog_db, &reflog_hash);

  uploader->WaitForUpload();

  unlink(reflog_db.c_str());

  const int errors = uploader->GetNumberOfErrors();

  if (errors > 0) {

    LogCvmfs(kLogCvmfs, kLogStderr, "failed to upload generated Reflog");

  uploader->TearDown();

  manifest::Reflog::WriteChecksum(reflog_chksum_path, reflog_hash);

  return (errors == 0) ? 0 : 1;

void CommandReconstructReflog::AddStaticManifestObjects(

  const shash::Any certificate = manifest->certificate();

  const shash::Any meta_info   = manifest->meta_info();

  assert(!certificate.IsNull());

  bool success = reflog->AddCertificate(certificate);

  assert(success);

           certificate.ToString().c_str());

  if (!meta_info.IsNull()) {

    success = reflog->AddMetainfo(meta_info);

    assert(success);

             meta_info.ToString().c_str());

void RootChainWalker::FindObjectsAndPopulateReflog() {

  const shash::Any root_catalog = manifest_->catalog_hash();

  const shash::Any history      = manifest_->history();

  assert(!root_catalog.IsNull());

  WalkRootCatalogs(root_catalog);

  if (!history.IsNull()) {

    WalkHistories(history);

void RootChainWalker::WalkRootCatalogs(const shash::Any &root_catalog_hash) {

  shash::Any           current_hash = root_catalog_hash;

  UniquePtr<CatalogTN> current_catalog;

  while (!current_hash.IsNull()                  &&

             current_hash.ToString().c_str(), current_catalog->GetRevision());

    const bool success = reflog_->AddCatalog(current_hash);

    assert(success);

    current_hash = current_catalog->GetPreviousRevision();

void RootChainWalker::WalkHistories(const shash::Any &history_hash) {

  shash::Any           current_hash = history_hash;

  UniquePtr<HistoryTN> current_history;

  while (!current_hash.IsNull()                  &&

             current_hash.ToString().c_str());

    bool cancel = WalkCatalogsInHistory(current_history);

    const bool success = reflog_->AddHistory(current_hash);

    assert(success);

    if (cancel) {

      current_hash = shash::Any(current_hash.algorithm);

      current_hash = current_history->previous_revision();

bool RootChainWalker::WalkCatalogsInHistory(const HistoryTN *history) {

  CatalogList tag_hashes;

  const bool list_success = history->GetHashes(&tag_hashes);

  assert(list_success);

  CatalogList bin_hashes;

  const bool bin_success = history->ListRecycleBin(&bin_hashes);

  if (!bin_success) {

    LogCvmfs(kLogCvmfs, kLogStderr, "  Warning: 'recycle bin' table missing");

  WalkListedCatalogs(tag_hashes);

  WalkListedCatalogs(bin_hashes);

  return !bin_success;

void RootChainWalker::WalkListedCatalogs(

  CatalogList::const_iterator i    = catalog_list.begin();

  CatalogList::const_iterator iend = catalog_list.end();

  for (; i != iend; ++i) {

    WalkRootCatalogs(*i);

RootChainWalker::CatalogTN* RootChainWalker::FetchCatalog(

  CatalogTN *catalog = NULL;

  const char *root_path = "";

    object_fetcher_->FetchCatalog(catalog_hash, root_path, &catalog);

  return ReturnOrAbort(failure, catalog_hash, catalog);

RootChainWalker::HistoryTN* RootChainWalker::FetchHistory(

  HistoryTN *history = NULL;

    object_fetcher_->FetchHistory(&history, history_hash);

  return ReturnOrAbort(failure, history_hash, history);

  switch (failure) {

      return database;

      return NULL;

      LogCvmfs(kLogCvmfs, kLogStderr, "Failed to load object '%s' (%d - %s)",

      abort();

}  // namespace swissknife