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::register_object_handler(int64_t pool_id,
  41                                             const ObjectLocator& locator,
  42                                             ObjectHandler* object_handler) {
  43   Mutex::Locker locker(m_lock);
  44   auto pool = get_pool(m_lock, pool_id);
  45   if (pool == nullptr) {
  46     return -ENOENT;
  47   }
  48
  49   RWLock::WLocker pool_locker(pool->file_lock);
  50   auto file_it = pool->files.find(locator);
  51   if (file_it == pool->files.end()) {
  52     return -ENOENT;
  53   }
  54
  55   auto& object_handlers = pool->file_handlers[locator];
  56   auto it = object_handlers.find(object_handler);
  57   ceph_assert(it == object_handlers.end());
  58
  59   object_handlers.insert(object_handler);
  60   return 0;
  61 }
  62
  63 void TestMemCluster::unregister_object_handler(int64_t pool_id,
  64                                                const ObjectLocator& locator,
  65                                                ObjectHandler* object_handler) {
  66   Mutex::Locker locker(m_lock);
  67   auto pool = get_pool(m_lock, pool_id);
  68   if (pool == nullptr) {
  69     return;
  70   }
  71
  72   RWLock::WLocker pool_locker(pool->file_lock);
  73   auto handlers_it = pool->file_handlers.find(locator);
  74   if (handlers_it == pool->file_handlers.end()) {
  75     return;
  76   }
  77
  78   auto& object_handlers = handlers_it->second;
  79   object_handlers.erase(object_handler);
  80 }
  81
  82 int TestMemCluster::pool_create(const std::string &pool_name) {
  83   Mutex::Locker locker(m_lock);
  84   if (m_pools.find(pool_name) != m_pools.end()) {
  85     return -EEXIST;
  86   }
  87   Pool *pool = new Pool();
  88   pool->pool_id = ++m_pool_id;
  89   m_pools[pool_name] = pool;
  90   return 0;
  91 }
  92
  93 int TestMemCluster::pool_delete(const std::string &pool_name) {
  94   Mutex::Locker locker(m_lock);
  95   Pools::iterator iter = m_pools.find(pool_name);
  96   if (iter == m_pools.end()) {
  97     return -ENOENT;
  98   }
  99   iter->second->put();
 100   m_pools.erase(iter);
 101   return 0;
 102 }
 103
 104 int TestMemCluster::pool_get_base_tier(int64_t pool_id, int64_t* base_tier) {
 105   // TODO
 106   *base_tier = pool_id;
 107   return 0;
 108 }
 109
 110 int TestMemCluster::pool_list(std::list<std::pair<int64_t, std::string> >& v) {
 111   Mutex::Locker locker(m_lock);
 112   v.clear();
 113   for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
 114     v.push_back(std::make_pair(iter->second->pool_id, iter->first));
 115   }
 116   return 0;
 117 }
 118
 119 int64_t TestMemCluster::pool_lookup(const std::string &pool_name) {
 120   Mutex::Locker locker(m_lock);
 121   Pools::iterator iter = m_pools.find(pool_name);
 122   if (iter == m_pools.end()) {
 123     return -ENOENT;
 124   }
 125   return iter->second->pool_id;
 126 }
 127
 128 int TestMemCluster::pool_reverse_lookup(int64_t id, std::string *name) {
 129   Mutex::Locker locker(m_lock);
 130   for (Pools::iterator iter = m_pools.begin(); iter != m_pools.end(); ++iter) {
 131     if (iter->second->pool_id == id) {
 132       *name = iter->first;
 133       return 0;
 134     }
 135   }
 136   return -ENOENT;
 137 }
 138
 139 TestMemCluster::Pool *TestMemCluster::get_pool(int64_t pool_id) {
 140   Mutex::Locker locker(m_lock);
 141   return get_pool(m_lock, pool_id);
 142 }
 143
 144 TestMemCluster::Pool *TestMemCluster::get_pool(const Mutex& lock,
 145                                                int64_t pool_id) {
 146   for (auto &pool_pair : m_pools) {
 147     if (pool_pair.second->pool_id == pool_id) {
 148       return pool_pair.second;
 149     }
 150   }
 151   return nullptr;
 152 }
 153
 154 TestMemCluster::Pool *TestMemCluster::get_pool(const std::string &pool_name) {
 155   Mutex::Locker locker(m_lock);
 156   Pools::iterator iter = m_pools.find(pool_name);
 157   if (iter != m_pools.end()) {
 158     return iter->second;
 159   }
 160   return nullptr;
 161 }
 162
 163 void TestMemCluster::allocate_client(uint32_t *nonce, uint64_t *global_id) {
 164   Mutex::Locker locker(m_lock);
 165   *nonce = m_next_nonce++;
 166   *global_id = m_next_global_id++;
 167 }
 168
 169 void TestMemCluster::deallocate_client(uint32_t nonce) {
 170   Mutex::Locker locker(m_lock);
 171   m_blacklist.erase(nonce);
 172 }
 173
 174 bool TestMemCluster::is_blacklisted(uint32_t nonce) const {
 175   Mutex::Locker locker(m_lock);
 176   return (m_blacklist.find(nonce) != m_blacklist.end());
 177 }
 178
 179 void TestMemCluster::blacklist(uint32_t nonce) {
 180   m_watch_notify.blacklist(nonce);
 181
 182   Mutex::Locker locker(m_lock);
 183   m_blacklist.insert(nonce);
 184 }
 185
 186 void TestMemCluster::transaction_start(const ObjectLocator& locator) {
 187   Mutex::Locker locker(m_lock);
 188   while (m_transactions.count(locator)) {
 189     m_transaction_cond.Wait(m_lock);
 190   }
 191   auto result = m_transactions.insert(locator);
 192   ceph_assert(result.second);
 193 }
 194
 195 void TestMemCluster::transaction_finish(const ObjectLocator& locator) {
 196   Mutex::Locker locker(m_lock);
 197   size_t count = m_transactions.erase(locator);
 198   ceph_assert(count == 1);
 199   m_transaction_cond.Signal();
 200 }
 201
 202 } // namespace librados
 203