sync_item_dummy.h

Go to the documentation of this file.

#ifndef CVMFS_SYNC_ITEM_DUMMY_H_
#define CVMFS_SYNC_ITEM_DUMMY_H_

#include "sync_item.h"

#include <ctime>
#include <string>

#include "ingestion/ingestion_source.h"
#include "sync_union_tarball.h"

namespace publish {

class SyncItemDummyCatalog : public SyncItem {
  friend class SyncUnionTarball;

 protected:
  SyncItemDummyCatalog(const std::string &relative_parent_path,
                       const SyncUnion *union_engine)
      : SyncItem(relative_parent_path, ".cvmfscatalog", union_engine,
                 kItemFile) {}

 public:
  bool IsType(const SyncItemType expected_type) const {
    return expected_type == kItemFile;
  }

  catalog::DirectoryEntryBase CreateBasicCatalogDirent() const {
    catalog::DirectoryEntryBase dirent;
    std::string name(".cvmfscatalog");
    dirent.inode_ = catalog::DirectoryEntry::kInvalidInode;
    dirent.linkcount_ = 1;
    dirent.mode_ =
        S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
    dirent.uid_ = getuid();
    dirent.gid_ = getgid();
    dirent.size_ = 0;
    dirent.mtime_ = time(NULL);
    dirent.checksum_ = this->GetContentHash();
    dirent.is_external_file_ = false;
    dirent.compression_algorithm_ = this->GetCompressionAlgorithm();

    dirent.name_.Assign(name.data(), name.length());

    return dirent;
  }

  IngestionSource *CreateIngestionSource() const {
    return new StringIngestionSource("", GetUnionPath());
  }

  void StatScratch(const bool /* refresh */) const { return; }

  SyncItemType GetScratchFiletype() const { return kItemFile; }

  void MakePlaceholderDirectory() const {}
};

/*
 * This class represents dummy directories that we know are going to be there
 * but we still haven't found yet. This is possible in the extraction of
 * tarball, where the files are not extracted in order (root to leaves) but in a
 * random fashion.
 */
class SyncItemDummyDir : public SyncItemNative {
  friend class SyncUnionTarball;

 public:
  catalog::DirectoryEntryBase CreateBasicCatalogDirent() const;
  SyncItemType GetScratchFiletype() const;
  virtual void MakePlaceholderDirectory() const { rdonly_type_ = kItemDir; }

 protected:
  SyncItemDummyDir(const std::string &relative_parent_path,
                   const std::string &filename, const SyncUnion *union_engine,
                   const SyncItemType entry_type)
      : SyncItemNative(relative_parent_path, filename, union_engine,
                       entry_type) {
    assert(kItemDir == entry_type);

    scratch_stat_.obtained = true;
    scratch_stat_.stat.st_mode = kPermision;
    scratch_stat_.stat.st_nlink = 1;
    scratch_stat_.stat.st_uid = getuid();
    scratch_stat_.stat.st_gid = getgid();
  }

 private:
  static const mode_t kPermision = S_IFDIR | S_IRUSR | S_IWUSR | S_IXUSR |
                                   S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
};

catalog::DirectoryEntryBase SyncItemDummyDir::CreateBasicCatalogDirent() const {
  catalog::DirectoryEntryBase dirent;

  dirent.inode_ = catalog::DirectoryEntry::kInvalidInode;

  dirent.linkcount_ = 1;

  dirent.mode_ = kPermision;

  dirent.uid_ = scratch_stat_.stat.st_uid;
  dirent.gid_ = scratch_stat_.stat.st_gid;
  dirent.size_ = 4096;
  dirent.mtime_ = time(NULL);
  dirent.checksum_ = this->GetContentHash();
  dirent.is_external_file_ = this->IsExternalData();
  dirent.compression_algorithm_ = this->GetCompressionAlgorithm();

  dirent.name_.Assign(this->filename().data(), this->filename().length());

  assert(dirent.IsDirectory());

  return dirent;
}


SyncItemType SyncItemDummyDir::GetScratchFiletype() const {
  return kItemDir;
}

}  // namespace publish

#endif  // CVMFS_SYNC_ITEM_DUMMY_H_