src/ceph/src/test/librados_test_stub/TestMemCluster.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #include "test/librados_test_stub/TestMemCluster.h"
   5 #include "test/librados_test_stub/TestMemRadosClient.h"
   6
   7 namespace librados {
   8
   9 TestMemCluster::File::File()
  10   : snap_id(), exists(true), lock("TestMemCluster::File::lock") {
  11 }
  12
  13 TestMemCluster::File::File(const File &rhs)
  14   : data(rhs.data),
  15     mtime(rhs.mtime),
  16     snap_id(rhs.snap_id),
  17     exists(rhs.exists),
  18     lock("TestMemCluster::File::lock") {
  19 }
  20
  21 TestMemCluster::Pool::Pool()
  22   : file_lock("TestMemCluster::Pool::file_lock") {
  23 }
  24
  25 TestMemCluster::TestMemCluster()
  26   : m_lock("TestMemCluster::m_lock"),
  27     m_next_nonce(static_cast<uint32_t>(reinterpret_cast<uint64_t>(this))) {
  28 }
  29
  30 TestMemCluster::~TestMemCluster() {
  31   for (auto pool_pair : m_pools) {
  32     pool_pair.second->put();
  33   }
  34 }
  35
  36 TestRadosClient *TestMemCluster::create_rados_client(CephContext *cct) {
  37   return new TestMemRadosClient(cct, this);
  38 }
  39
  40 int TestMemCluster::pool_create(const std::string &pool_name) {
  41   Mutex::Locker locker(m_lock);
  42   if (m_pools.find(pool_name) != m_pools.end()) {
  43     return -EEXIST;
  44   }
  45   Pool *pool = new Pool();
  46   pool->pool_id = ++m_pool_id;
  47   m_pools[pool_name] = pool;
  48   return 0;
  49 }
  50
  51 int TestMemCluster::pool_delete(const std::string &pool_name) {
  52   Mutex::Locker locker(m_lock);
  53   Pools::iterator iter = m_pools.find(pool_name);
  54   if (iter == m_pools.end()) {
  55     return -ENOENT;
  56   }
  57   iter->second->put();
  58   m_pools.erase(iter);
  59   return 0;
  60 }
  61
  62 int TestMemCluster::pool_get_base_tier(int64_t pool_id, int64_t* base_tier) {
  63   // TODO
  64   *base_tier = pool_id;
  65   return 0;
  66 }
  67
  68 int TestMemCluster::pool_list(std::list<std::pair<int64_t, std::string> >& v) {
  69   Mutex::Locker locker(m_lock);
  70   v.clear();
  71   for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
  72     v.push_back(std::make_pair(iter->second->pool_id, iter->first));
  73   }
  74   return 0;
  75 }
  76
  77 int64_t TestMemCluster::pool_lookup(const std::string &pool_name) {
  78   Mutex::Locker locker(m_lock);
  79   Pools::iterator iter = m_pools.find(pool_name);
  80   if (iter == m_pools.end()) {
  81     return -ENOENT;
  82   }
  83   return iter->second->pool_id;
  84 }
  85
  86 int TestMemCluster::pool_reverse_lookup(int64_t id, std::string *name) {
  87   Mutex::Locker locker(m_lock);
  88   for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
  89     if (iter->second->pool_id == id) {
  90       *name = iter->first;
  91       return 0;
  92     }
  93   }
  94   return -ENOENT;
  95 }
  96
  97 TestMemCluster::Pool *TestMemCluster::get_pool(int64_t pool_id) {
  98   Mutex::Locker locker(m_lock);
  99   for (auto &pool_pair : m_pools) {
 100     if (pool_pair.second->pool_id == pool_id) {
 101       return pool_pair.second;
 102     }
 103   }
 104   return nullptr;
 105 }
 106
 107 TestMemCluster::Pool *TestMemCluster::get_pool(const std::string &pool_name) {
 108   Mutex::Locker locker(m_lock);
 109   Pools::iterator iter = m_pools.find(pool_name);
 110   if (iter != m_pools.end()) {
 111     return iter->second;
 112   }
 113   return nullptr;
 114 }
 115
 116 void TestMemCluster::allocate_client(uint32_t *nonce, uint64_t *global_id) {
 117   Mutex::Locker locker(m_lock);
 118   *nonce = m_next_nonce++;
 119   *global_id = m_next_global_id++;
 120 }
 121
 122 void TestMemCluster::deallocate_client(uint32_t nonce) {
 123   Mutex::Locker locker(m_lock);
 124   m_blacklist.erase(nonce);
 125 }
 126
 127 bool TestMemCluster::is_blacklisted(uint32_t nonce) const {
 128   Mutex::Locker locker(m_lock);
 129   return (m_blacklist.find(nonce) != m_blacklist.end());
 130 }
 131
 132 void TestMemCluster::blacklist(uint32_t nonce) {
 133   m_watch_notify.blacklist(nonce);
 134
 135   Mutex::Locker locker(m_lock);
 136   m_blacklist.insert(nonce);
 137 }
 138
 139 void TestMemCluster::transaction_start(const std::string &oid) {
 140   Mutex::Locker locker(m_lock);
 141   while (m_transactions.count(oid)) {
 142     m_transaction_cond.Wait(m_lock);
 143   }
 144   std::pair<std::set<std::string>::iterator, bool> result =
 145     m_transactions.insert(oid);
 146   assert(result.second);
 147 }
 148
 149 void TestMemCluster::transaction_finish(const std::string &oid) {
 150   Mutex::Locker locker(m_lock);
 151   size_t count = m_transactions.erase(oid);
 152   assert(count == 1);
 153   m_transaction_cond.Signal();
 154 }
 155
 156 } // namespace librados
 157