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 "gtest/gtest_prod.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> {
  FRIEND_TEST(T_CatalogManagerClient, MountLatest);
  FRIEND_TEST(T_CatalogManagerClient, LoadByHash);
  FRIEND_TEST(T_CatalogManagerClient, LoadByHashNetworkFailure);
  FRIEND_TEST(T_CatalogManagerClient, LoadRootCatalog);

  // 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();
  std::string GetCatalogDescription(const PathString &mountpoint,
                                    const shash::Any &hash);

  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:
  virtual LoadReturn GetNewRootCatalogContext(CatalogContext *result);
  virtual LoadReturn LoadCatalogByHash(CatalogContext *ctlg_context);
  virtual void StageNestedCatalogByHash(const shash::Any &hash,
                                        const PathString &mountpoint);
  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:
  LoadReturn FetchCatalogByHash(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_;
  shash::Any fixed_root_catalog_;      
  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_