catalog_mgr_client.h

Go to the documentation of this file.

#ifndef CVMFS_CATALOG_MGR_CLIENT_H_
#define CVMFS_CATALOG_MGR_CLIENT_H_

#include "catalog_mgr.h"

#include <inttypes.h>

#include <map>
#include <string>

#include "backoff.h"
#include "crypto/hash.h"
#include "manifest_fetch.h"
#include "shortstring.h"

class CacheManager;
namespace cvmfs {
class Fetcher;
}
class MountPoint;
namespace perf {
class Counter;
class Statistics;
}
namespace signature {
class SignatureManager;
}

namespace catalog {

class ClientCatalogManager : public AbstractCatalogManager<Catalog> {
  // Maintains certificate hit/miss counters
  friend class CachedManifestEnsemble;

 public:
  explicit ClientCatalogManager(MountPoint *mountpoint);
  virtual ~ClientCatalogManager();

  bool InitFixed(const shash::Any &root_hash, bool alternative_path);

  shash::Any GetRootHash();

  bool IsRevisionBlacklisted();

  bool offline_mode() const { return offline_mode_; }
  uint64_t all_inodes() const { return all_inodes_; }
  uint64_t loaded_inodes() const { return loaded_inodes_; }
  std::string repo_name() const { return repo_name_; }
  manifest::Manifest *manifest() const { return manifest_.weak_ref(); }
  int root_fd() const { return root_fd_; }

 protected:
  LoadError LoadCatalog(const PathString  &mountpoint,
                        const shash::Any  &hash,
                        std::string       *catalog_path,
                        shash::Any        *catalog_hash);
  void UnloadCatalog(const catalog::Catalog *catalog);
  catalog::Catalog* CreateCatalog(const PathString &mountpoint,
                                  const shash::Any  &catalog_hash,
                                  catalog::Catalog *parent_catalog);
  void ActivateCatalog(catalog::Catalog *catalog);

 private:
  LoadError LoadCatalogCas(const shash::Any &hash,
                           const std::string &name,
                           const std::string &alt_catalog_path,
                           std::string *catalog_path);

  std::map<PathString, shash::Any> loaded_catalogs_;
  std::map<PathString, shash::Any> mounted_catalogs_;

  UniquePtr<manifest::Manifest> manifest_;

  std::string repo_name_;
  cvmfs::Fetcher *fetcher_;
  signature::SignatureManager *signature_mgr_;
  std::string workspace_;
  bool offline_mode_;  
  uint64_t all_inodes_;
  uint64_t loaded_inodes_;
  bool fixed_alt_root_catalog_;  
  BackoffThrottle backoff_throttle_;
  perf::Counter *n_certificate_hits_;
  perf::Counter *n_certificate_misses_;

  int root_fd_;
};


class CachedManifestEnsemble : public manifest::ManifestEnsemble {
 public:
  CachedManifestEnsemble(
    CacheManager *cache_mgr,
    ClientCatalogManager *catalog_mgr)
    : cache_mgr_(cache_mgr)
    , catalog_mgr_(catalog_mgr)
  { }
  void FetchCertificate(const shash::Any &hash);

 private:
  CacheManager *cache_mgr_;
  ClientCatalogManager *catalog_mgr_;
};

}  // namespace catalog

#endif  // CVMFS_CATALOG_MGR_CLIENT_H_