ceph/src/test/librados_test_stub/LibradosTestStub.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/LibradosTestStub.h"
   5 #include "include/rados/librados.hpp"
   6 #include "include/stringify.h"
   7 #include "common/ceph_argparse.h"
   8 #include "common/ceph_context.h"
   9 #include "common/common_init.h"
  10 #include "common/config.h"
  11 #include "common/debug.h"
  12 #include "common/snap_types.h"
  13 #include "librados/AioCompletionImpl.h"
  14 #include "log/Log.h"
  15 #include "test/librados_test_stub/TestClassHandler.h"
  16 #include "test/librados_test_stub/TestIoCtxImpl.h"
  17 #include "test/librados_test_stub/TestRadosClient.h"
  18 #include "test/librados_test_stub/TestMemCluster.h"
  19 #include "test/librados_test_stub/TestMemRadosClient.h"
  20 #include "objclass/objclass.h"
  21 #include "osd/osd_types.h"
  22 #include <arpa/inet.h>
  23 #include <boost/bind.hpp>
  24 #include <boost/shared_ptr.hpp>
  25 #include <deque>
  26 #include <list>
  27 #include <vector>
  28 #include "include/ceph_assert.h"
  29 #include "include/compat.h"
  30
  31 #define dout_context g_ceph_context
  32 #define dout_subsys ceph_subsys_rados
  33
  34 namespace librados {
  35
  36 MockTestMemIoCtxImpl &get_mock_io_ctx(IoCtx &ioctx) {
  37   MockTestMemIoCtxImpl **mock =
  38     reinterpret_cast<MockTestMemIoCtxImpl **>(&ioctx);
  39   return **mock;
  40 }
  41
  42 } // namespace librados
  43
  44 namespace librados_test_stub {
  45
  46 TestClusterRef &cluster() {
  47   static TestClusterRef s_cluster;
  48   return s_cluster;
  49 }
  50
  51 void set_cluster(TestClusterRef cluster_ref) {
  52   cluster() = cluster_ref;
  53 }
  54
  55 TestClusterRef get_cluster() {
  56   auto &cluster_ref = cluster();
  57   if (cluster_ref.get() == nullptr) {
  58     cluster_ref.reset(new librados::TestMemCluster());
  59   }
  60   return cluster_ref;
  61 }
  62
  63 } // namespace librados_test_stub
  64
  65 namespace {
  66
  67 librados::TestClassHandler *get_class_handler() {
  68   static boost::shared_ptr<librados::TestClassHandler> s_class_handler;
  69   if (!s_class_handler) {
  70     s_class_handler.reset(new librados::TestClassHandler());
  71     s_class_handler->open_all_classes();
  72   }
  73   return s_class_handler.get();
  74 }
  75
  76 void do_out_buffer(bufferlist& outbl, char **outbuf, size_t *outbuflen) {
  77   if (outbuf) {
  78     if (outbl.length() > 0) {
  79       *outbuf = (char *)malloc(outbl.length());
  80       memcpy(*outbuf, outbl.c_str(), outbl.length());
  81     } else {
  82       *outbuf = NULL;
  83     }
  84   }
  85   if (outbuflen) {
  86     *outbuflen = outbl.length();
  87   }
  88 }
  89
  90 void do_out_buffer(string& outbl, char **outbuf, size_t *outbuflen) {
  91   if (outbuf) {
  92     if (outbl.length() > 0) {
  93       *outbuf = (char *)malloc(outbl.length());
  94       memcpy(*outbuf, outbl.c_str(), outbl.length());
  95     } else {
  96       *outbuf = NULL;
  97     }
  98   }
  99   if (outbuflen) {
 100     *outbuflen = outbl.length();
 101   }
 102 }
 103
 104 librados::TestRadosClient *create_rados_client() {
 105   CephInitParameters iparams(CEPH_ENTITY_TYPE_CLIENT);
 106   CephContext *cct = common_preinit(iparams, CODE_ENVIRONMENT_LIBRARY, 0);
 107   cct->_conf.parse_env(cct->get_module_type());
 108   cct->_conf.apply_changes(nullptr);
 109   cct->_log->start();
 110
 111   auto rados_client =
 112     librados_test_stub::get_cluster()->create_rados_client(cct);
 113   cct->put();
 114   return rados_client;
 115 }
 116
 117 } // anonymous namespace
 118
 119 extern "C" int rados_aio_create_completion(void *cb_arg,
 120                                            rados_callback_t cb_complete,
 121                                            rados_callback_t cb_safe,
 122                                            rados_completion_t *pc)
 123 {
 124   librados::AioCompletionImpl *c = new librados::AioCompletionImpl;
 125   if (cb_complete) {
 126     c->set_complete_callback(cb_arg, cb_complete);
 127   }
 128   if (cb_safe) {
 129     c->set_safe_callback(cb_arg, cb_safe);
 130   }
 131   *pc = c;
 132   return 0;
 133 }
 134
 135 extern "C" int rados_aio_get_return_value(rados_completion_t c) {
 136   return reinterpret_cast<librados::AioCompletionImpl*>(c)->get_return_value();
 137 }
 138
 139 extern "C" rados_config_t rados_cct(rados_t cluster)
 140 {
 141   librados::TestRadosClient *client =
 142     reinterpret_cast<librados::TestRadosClient*>(cluster);
 143   return reinterpret_cast<rados_config_t>(client->cct());
 144 }
 145
 146 extern "C" int rados_conf_set(rados_t cluster, const char *option,
 147                               const char *value) {
 148   librados::TestRadosClient *impl =
 149     reinterpret_cast<librados::TestRadosClient*>(cluster);
 150   CephContext *cct = impl->cct();
 151   return cct->_conf.set_val(option, value);
 152 }
 153
 154 extern "C" int rados_conf_parse_env(rados_t cluster, const char *var) {
 155   librados::TestRadosClient *client =
 156     reinterpret_cast<librados::TestRadosClient*>(cluster);
 157   auto& conf = client->cct()->_conf;
 158   conf.parse_env(client->cct()->get_module_type(), var);
 159   conf.apply_changes(NULL);
 160   return 0;
 161 }
 162
 163 extern "C" int rados_conf_read_file(rados_t cluster, const char *path) {
 164   librados::TestRadosClient *client =
 165     reinterpret_cast<librados::TestRadosClient*>(cluster);
 166   auto& conf = client->cct()->_conf;
 167   int ret = conf.parse_config_files(path, NULL, 0);
 168   if (ret == 0) {
 169     conf.parse_env(client->cct()->get_module_type());
 170     conf.apply_changes(NULL);
 171     conf.complain_about_parse_errors(client->cct());
 172   } else if (ret == -ENOENT) {
 173     // ignore missing client config
 174     return 0;
 175   }
 176   return ret;
 177 }
 178
 179 extern "C" int rados_connect(rados_t cluster) {
 180   librados::TestRadosClient *client =
 181     reinterpret_cast<librados::TestRadosClient*>(cluster);
 182   return client->connect();
 183 }
 184
 185 extern "C" int rados_create(rados_t *cluster, const char * const id) {
 186   *cluster = create_rados_client();
 187   return 0;
 188 }
 189
 190 extern "C" int rados_create_with_context(rados_t *cluster,
 191                                          rados_config_t cct_) {
 192   auto cct = reinterpret_cast<CephContext*>(cct_);
 193   *cluster = librados_test_stub::get_cluster()->create_rados_client(cct);
 194   return 0;
 195 }
 196
 197 extern "C" rados_config_t rados_ioctx_cct(rados_ioctx_t ioctx)
 198 {
 199   librados::TestIoCtxImpl *ctx =
 200     reinterpret_cast<librados::TestIoCtxImpl*>(ioctx);
 201   return reinterpret_cast<rados_config_t>(ctx->get_rados_client()->cct());
 202 }
 203
 204 extern "C" int rados_ioctx_create(rados_t cluster, const char *pool_name,
 205                                   rados_ioctx_t *ioctx) {
 206   librados::TestRadosClient *client =
 207     reinterpret_cast<librados::TestRadosClient*>(cluster);
 208
 209   int64_t pool_id = client->pool_lookup(pool_name);
 210   if (pool_id < 0) {
 211     return static_cast<int>(pool_id);
 212   }
 213
 214   *ioctx = reinterpret_cast<rados_ioctx_t>(
 215       client->create_ioctx(pool_id, pool_name));
 216   return 0;
 217 }
 218
 219 extern "C" int rados_ioctx_create2(rados_t cluster, int64_t pool_id,
 220                                    rados_ioctx_t *ioctx)
 221 {
 222   librados::TestRadosClient *client =
 223     reinterpret_cast<librados::TestRadosClient*>(cluster);
 224
 225   std::list<std::pair<int64_t, std::string> > pools;
 226   int r = client->pool_list(pools);
 227   if (r < 0) {
 228     return r;
 229   }
 230
 231   for (std::list<std::pair<int64_t, std::string> >::iterator it =
 232        pools.begin(); it != pools.end(); ++it) {
 233     if (it->first == pool_id) {
 234       *ioctx = reinterpret_cast<rados_ioctx_t>(
 235         client->create_ioctx(pool_id, it->second));
 236       return 0;
 237     }
 238   }
 239   return -ENOENT;
 240 }
 241
 242 extern "C" void rados_ioctx_destroy(rados_ioctx_t io) {
 243   librados::TestIoCtxImpl *ctx =
 244     reinterpret_cast<librados::TestIoCtxImpl*>(io);
 245   ctx->put();
 246 }
 247
 248 extern "C" rados_t rados_ioctx_get_cluster(rados_ioctx_t io) {
 249   librados::TestIoCtxImpl *ctx =
 250     reinterpret_cast<librados::TestIoCtxImpl*>(io);
 251   return reinterpret_cast<rados_t>(ctx->get_rados_client());
 252 }
 253
 254 extern "C" int rados_mon_command(rados_t cluster, const char **cmd,
 255                                  size_t cmdlen, const char *inbuf,
 256                                  size_t inbuflen, char **outbuf,
 257                                  size_t *outbuflen, char **outs,
 258                                  size_t *outslen) {
 259   librados::TestRadosClient *client =
 260     reinterpret_cast<librados::TestRadosClient*>(cluster);
 261
 262   vector<string> cmdvec;
 263   for (size_t i = 0; i < cmdlen; i++) {
 264     cmdvec.push_back(cmd[i]);
 265   }
 266
 267   bufferlist inbl;
 268   inbl.append(inbuf, inbuflen);
 269
 270   bufferlist outbl;
 271   string outstring;
 272   int ret = client->mon_command(cmdvec, inbl, &outbl, &outstring);
 273
 274   do_out_buffer(outbl, outbuf, outbuflen);
 275   do_out_buffer(outstring, outs, outslen);
 276   return ret;
 277 }
 278
 279 extern "C" int rados_nobjects_list_open(rados_ioctx_t io,
 280                                         rados_list_ctx_t *ctx) {
 281   librados::TestIoCtxImpl *io_ctx =
 282     reinterpret_cast<librados::TestIoCtxImpl*>(io);
 283   librados::TestRadosClient *client = io_ctx->get_rados_client();
 284
 285   std::list<librados::TestRadosClient::Object> *list =
 286     new std::list<librados::TestRadosClient::Object>();
 287
 288   client->object_list(io_ctx->get_id(), list);
 289   list->push_front(librados::TestRadosClient::Object());
 290   *ctx = reinterpret_cast<rados_list_ctx_t>(list);
 291   return 0;
 292 }
 293
 294 extern "C" int rados_nobjects_list_next(rados_list_ctx_t ctx,
 295                                         const char **entry,
 296                                         const char **key,
 297                                         const char **nspace) {
 298   std::list<librados::TestRadosClient::Object> *list =
 299     reinterpret_cast<std::list<librados::TestRadosClient::Object> *>(ctx);
 300   if (!list->empty()) {
 301     list->pop_front();
 302   }
 303   if (list->empty()) {
 304     return -ENOENT;
 305   }
 306
 307   librados::TestRadosClient::Object &obj = list->front();
 308   if (entry != NULL) {
 309     *entry = obj.oid.c_str();
 310   }
 311   if (key != NULL) {
 312     *key = obj.locator.c_str();
 313   }
 314   if (nspace != NULL) {
 315     *nspace = obj.nspace.c_str();
 316   }
 317   return 0;
 318 }
 319
 320 extern "C" void rados_nobjects_list_close(rados_list_ctx_t ctx) {
 321   std::list<librados::TestRadosClient::Object> *list =
 322     reinterpret_cast<std::list<librados::TestRadosClient::Object> *>(ctx);
 323   delete list;
 324 }
 325
 326 extern "C" int rados_pool_create(rados_t cluster, const char *pool_name) {
 327   librados::TestRadosClient *client =
 328     reinterpret_cast<librados::TestRadosClient*>(cluster);
 329   return client->pool_create(pool_name);
 330 }
 331
 332 extern "C" int rados_pool_delete(rados_t cluster, const char *pool_name) {
 333   librados::TestRadosClient *client =
 334     reinterpret_cast<librados::TestRadosClient*>(cluster);
 335   return client->pool_delete(pool_name);
 336 }
 337
 338 extern "C" void rados_shutdown(rados_t cluster) {
 339   librados::TestRadosClient *client =
 340     reinterpret_cast<librados::TestRadosClient*>(cluster);
 341   client->put();
 342 }
 343
 344 extern "C" int rados_wait_for_latest_osdmap(rados_t cluster) {
 345   librados::TestRadosClient *client =
 346     reinterpret_cast<librados::TestRadosClient*>(cluster);
 347   return client->wait_for_latest_osdmap();
 348 }
 349
 350 namespace librados {
 351
 352 void AioCompletion::release() {
 353   AioCompletionImpl *c = reinterpret_cast<AioCompletionImpl *>(pc);
 354   c->release();
 355   delete this;
 356 }
 357
 358 IoCtx::IoCtx() : io_ctx_impl(NULL) {
 359 }
 360
 361 IoCtx::~IoCtx() {
 362   close();
 363 }
 364
 365 IoCtx::IoCtx(const IoCtx& rhs) {
 366   io_ctx_impl = rhs.io_ctx_impl;
 367   if (io_ctx_impl) {
 368     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 369     ctx->get();
 370   }
 371 }
 372
 373 IoCtx::IoCtx(IoCtx&& rhs) noexcept : io_ctx_impl(std::exchange(rhs.io_ctx_impl, nullptr))
 374 {
 375 }
 376
 377 IoCtx& IoCtx::operator=(const IoCtx& rhs) {
 378   if (io_ctx_impl) {
 379     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 380     ctx->put();
 381   }
 382
 383   io_ctx_impl = rhs.io_ctx_impl;
 384   if (io_ctx_impl) {
 385     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 386     ctx->get();
 387   }
 388   return *this;
 389 }
 390
 391 librados::IoCtx& librados::IoCtx::operator=(IoCtx&& rhs) noexcept
 392 {
 393   if (io_ctx_impl) {
 394     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 395     ctx->put();
 396   }
 397
 398   io_ctx_impl = std::exchange(rhs.io_ctx_impl, nullptr);
 399   return *this;
 400 }
 401
 402 int IoCtx::aio_flush() {
 403   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 404   ctx->aio_flush();
 405   return 0;
 406 }
 407
 408 int IoCtx::aio_flush_async(AioCompletion *c) {
 409   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 410   ctx->aio_flush_async(c->pc);
 411   return 0;
 412 }
 413
 414 int IoCtx::aio_notify(const std::string& oid, AioCompletion *c, bufferlist& bl,
 415                       uint64_t timeout_ms, bufferlist *pbl) {
 416   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 417   ctx->aio_notify(oid, c->pc, bl, timeout_ms, pbl);
 418   return 0;
 419 }
 420
 421 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 422                        ObjectReadOperation *op, bufferlist *pbl) {
 423   return aio_operate(oid, c, op, 0, pbl);
 424 }
 425
 426 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 427                        ObjectReadOperation *op, int flags,
 428                        bufferlist *pbl) {
 429   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 430   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 431   return ctx->aio_operate_read(oid, *ops, c->pc, flags, pbl);
 432 }
 433
 434 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 435                        ObjectReadOperation *op, int flags,
 436                        bufferlist *pbl, const blkin_trace_info *trace_info) {
 437   return aio_operate(oid, c, op, flags, pbl);
 438 }
 439
 440 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 441                        ObjectWriteOperation *op) {
 442   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 443   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 444   return ctx->aio_operate(oid, *ops, c->pc, NULL, 0);
 445 }
 446
 447 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 448                        ObjectWriteOperation *op, snap_t seq,
 449                        std::vector<snap_t>& snaps, int flags,
 450                        const blkin_trace_info *trace_info) {
 451   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 452   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 453
 454   std::vector<snapid_t> snv;
 455   snv.resize(snaps.size());
 456   for (size_t i = 0; i < snaps.size(); ++i)
 457     snv[i] = snaps[i];
 458   SnapContext snapc(seq, snv);
 459
 460   return ctx->aio_operate(oid, *ops, c->pc, &snapc, flags);
 461 }
 462
 463 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 464                        ObjectWriteOperation *op, snap_t seq,
 465                        std::vector<snap_t>& snaps) {
 466   return aio_operate(oid, c, op, seq, snaps, 0, nullptr);
 467 }
 468
 469 int IoCtx::aio_operate(const std::string& oid, AioCompletion *c,
 470                        ObjectWriteOperation *op, snap_t seq,
 471                        std::vector<snap_t>& snaps,
 472                        const blkin_trace_info *trace_info) {
 473   return aio_operate(oid, c, op, seq, snaps, 0, trace_info);
 474 }
 475
 476 int IoCtx::aio_remove(const std::string& oid, AioCompletion *c) {
 477   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 478   return ctx->aio_remove(oid, c->pc);
 479 }
 480
 481 int IoCtx::aio_remove(const std::string& oid, AioCompletion *c, int flags) {
 482   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 483   return ctx->aio_remove(oid, c->pc, flags);
 484 }
 485
 486 int IoCtx::aio_watch(const std::string& o, AioCompletion *c, uint64_t *handle,
 487                      librados::WatchCtx2 *watch_ctx) {
 488   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 489   return ctx->aio_watch(o, c->pc, handle, watch_ctx);
 490 }
 491
 492 int IoCtx::aio_unwatch(uint64_t handle, AioCompletion *c) {
 493   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 494   return ctx->aio_unwatch(handle, c->pc);
 495 }
 496
 497 config_t IoCtx::cct() {
 498   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 499   return reinterpret_cast<config_t>(ctx->get_rados_client()->cct());
 500 }
 501
 502 void IoCtx::close() {
 503   if (io_ctx_impl) {
 504     TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 505     ctx->put();
 506   }
 507   io_ctx_impl = NULL;
 508 }
 509
 510 int IoCtx::create(const std::string& oid, bool exclusive) {
 511   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 512   return ctx->execute_operation(
 513     oid, boost::bind(&TestIoCtxImpl::create, _1, _2, exclusive));
 514 }
 515
 516 void IoCtx::dup(const IoCtx& rhs) {
 517   close();
 518   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(rhs.io_ctx_impl);
 519   io_ctx_impl = reinterpret_cast<IoCtxImpl*>(ctx->clone());
 520 }
 521
 522 int IoCtx::exec(const std::string& oid, const char *cls, const char *method,
 523                 bufferlist& inbl, bufferlist& outbl) {
 524   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 525   return ctx->execute_operation(
 526     oid, boost::bind(&TestIoCtxImpl::exec, _1, _2, get_class_handler(), cls,
 527                      method, inbl, &outbl, ctx->get_snap_context()));
 528 }
 529
 530 void IoCtx::from_rados_ioctx_t(rados_ioctx_t p, IoCtx &io) {
 531   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(p);
 532   ctx->get();
 533
 534   io.close();
 535   io.io_ctx_impl = reinterpret_cast<IoCtxImpl*>(ctx);
 536 }
 537
 538 uint64_t IoCtx::get_instance_id() const {
 539   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 540   return ctx->get_instance_id();
 541 }
 542
 543 int64_t IoCtx::get_id() {
 544   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 545   return ctx->get_id();
 546 }
 547
 548 uint64_t IoCtx::get_last_version() {
 549   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 550   return ctx->get_last_version();
 551 }
 552
 553 std::string IoCtx::get_pool_name() {
 554   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 555   return ctx->get_pool_name();
 556 }
 557
 558 int IoCtx::list_snaps(const std::string& o, snap_set_t *out_snaps) {
 559   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 560   return ctx->execute_operation(
 561     o, boost::bind(&TestIoCtxImpl::list_snaps, _1, _2, out_snaps));
 562 }
 563
 564 int IoCtx::list_watchers(const std::string& o,
 565                          std::list<obj_watch_t> *out_watchers) {
 566   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 567   return ctx->execute_operation(
 568     o, boost::bind(&TestIoCtxImpl::list_watchers, _1, _2, out_watchers));
 569 }
 570
 571 int IoCtx::notify(const std::string& o, uint64_t ver, bufferlist& bl) {
 572   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 573   return ctx->notify(o, bl, 0, NULL);
 574 }
 575
 576 int IoCtx::notify2(const std::string& o, bufferlist& bl,
 577                    uint64_t timeout_ms, bufferlist *pbl) {
 578   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 579   return ctx->notify(o, bl, timeout_ms, pbl);
 580 }
 581
 582 void IoCtx::notify_ack(const std::string& o, uint64_t notify_id,
 583                        uint64_t handle, bufferlist& bl) {
 584   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 585   ctx->notify_ack(o, notify_id, handle, bl);
 586 }
 587
 588 int IoCtx::omap_get_vals(const std::string& oid,
 589                          const std::string& start_after,
 590                          uint64_t max_return,
 591                          std::map<std::string, bufferlist> *out_vals) {
 592   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 593   return ctx->execute_operation(
 594     oid, boost::bind(&TestIoCtxImpl::omap_get_vals, _1, _2, start_after, "",
 595                      max_return, out_vals));
 596 }
 597
 598 int IoCtx::operate(const std::string& oid, ObjectWriteOperation *op) {
 599   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 600   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 601   return ctx->operate(oid, *ops);
 602 }
 603
 604 int IoCtx::operate(const std::string& oid, ObjectReadOperation *op,
 605                    bufferlist *pbl) {
 606   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 607   TestObjectOperationImpl *ops = reinterpret_cast<TestObjectOperationImpl*>(op->impl);
 608   return ctx->operate_read(oid, *ops, pbl);
 609 }
 610
 611 int IoCtx::read(const std::string& oid, bufferlist& bl, size_t len,
 612                 uint64_t off) {
 613   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 614   return ctx->execute_operation(
 615     oid, boost::bind(&TestIoCtxImpl::read, _1, _2, len, off, &bl));
 616 }
 617
 618 int IoCtx::remove(const std::string& oid) {
 619   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 620   return ctx->execute_operation(
 621     oid, boost::bind(&TestIoCtxImpl::remove, _1, _2, ctx->get_snap_context()));
 622 }
 623
 624 int IoCtx::selfmanaged_snap_create(uint64_t *snapid) {
 625   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 626   return ctx->selfmanaged_snap_create(snapid);
 627 }
 628
 629 void IoCtx::aio_selfmanaged_snap_create(uint64_t *snapid, AioCompletion* c) {
 630   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 631   return ctx->aio_selfmanaged_snap_create(snapid, c->pc);
 632 }
 633
 634 int IoCtx::selfmanaged_snap_remove(uint64_t snapid) {
 635   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 636   return ctx->selfmanaged_snap_remove(snapid);
 637 }
 638
 639 void IoCtx::aio_selfmanaged_snap_remove(uint64_t snapid, AioCompletion* c) {
 640   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 641   ctx->aio_selfmanaged_snap_remove(snapid, c->pc);
 642 }
 643
 644 int IoCtx::selfmanaged_snap_rollback(const std::string& oid,
 645                                      uint64_t snapid) {
 646   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 647   return ctx->selfmanaged_snap_rollback(oid, snapid);
 648 }
 649
 650 int IoCtx::selfmanaged_snap_set_write_ctx(snap_t seq,
 651                                           std::vector<snap_t>& snaps) {
 652   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 653   return ctx->selfmanaged_snap_set_write_ctx(seq, snaps);
 654 }
 655
 656 void IoCtx::snap_set_read(snap_t seq) {
 657   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 658   ctx->set_snap_read(seq);
 659 }
 660
 661 int IoCtx::sparse_read(const std::string& oid, std::map<uint64_t,uint64_t>& m,
 662                        bufferlist& bl, size_t len, uint64_t off) {
 663   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 664   return ctx->execute_operation(
 665     oid, boost::bind(&TestIoCtxImpl::sparse_read, _1, _2, off, len, &m, &bl));
 666 }
 667
 668 int IoCtx::stat(const std::string& oid, uint64_t *psize, time_t *pmtime) {
 669   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 670   return ctx->execute_operation(
 671     oid, boost::bind(&TestIoCtxImpl::stat, _1, _2, psize, pmtime));
 672 }
 673
 674 int IoCtx::tmap_update(const std::string& oid, bufferlist& cmdbl) {
 675   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 676   return ctx->execute_operation(
 677     oid, boost::bind(&TestIoCtxImpl::tmap_update, _1, _2, cmdbl));
 678 }
 679
 680 int IoCtx::trunc(const std::string& oid, uint64_t off) {
 681   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 682   return ctx->execute_operation(
 683     oid, boost::bind(&TestIoCtxImpl::truncate, _1, _2, off,
 684                      ctx->get_snap_context()));
 685 }
 686
 687 int IoCtx::unwatch2(uint64_t handle) {
 688   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 689   return ctx->unwatch(handle);
 690 }
 691
 692 int IoCtx::unwatch(const std::string& o, uint64_t handle) {
 693   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 694   return ctx->unwatch(handle);
 695 }
 696
 697 int IoCtx::watch(const std::string& o, uint64_t ver, uint64_t *handle,
 698                  librados::WatchCtx *wctx) {
 699   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 700   return ctx->watch(o, handle, wctx, NULL);
 701 }
 702
 703 int IoCtx::watch2(const std::string& o, uint64_t *handle,
 704                   librados::WatchCtx2 *wctx) {
 705   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 706   return ctx->watch(o, handle, NULL, wctx);
 707 }
 708
 709 int IoCtx::write(const std::string& oid, bufferlist& bl, size_t len,
 710                  uint64_t off) {
 711   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 712   return ctx->execute_operation(
 713     oid, boost::bind(&TestIoCtxImpl::write, _1, _2, bl, len, off,
 714                      ctx->get_snap_context()));
 715 }
 716
 717 int IoCtx::write_full(const std::string& oid, bufferlist& bl) {
 718   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 719   return ctx->execute_operation(
 720     oid, boost::bind(&TestIoCtxImpl::write_full, _1, _2, bl,
 721                      ctx->get_snap_context()));
 722 }
 723
 724 int IoCtx::writesame(const std::string& oid, bufferlist& bl, size_t len,
 725                      uint64_t off) {
 726   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 727   return ctx->execute_operation(
 728     oid, boost::bind(&TestIoCtxImpl::writesame, _1, _2, bl, len, off,
 729                      ctx->get_snap_context()));
 730 }
 731
 732 int IoCtx::cmpext(const std::string& oid, uint64_t off, bufferlist& cmp_bl) {
 733   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 734   return ctx->execute_operation(
 735     oid, boost::bind(&TestIoCtxImpl::cmpext, _1, _2, off, cmp_bl));
 736 }
 737
 738 int IoCtx::application_enable(const std::string& app_name, bool force) {
 739   return 0;
 740 }
 741
 742 int IoCtx::application_enable_async(const std::string& app_name,
 743                                     bool force, PoolAsyncCompletion *c) {
 744   return -EOPNOTSUPP;
 745 }
 746
 747 int IoCtx::application_list(std::set<std::string> *app_names) {
 748   return -EOPNOTSUPP;
 749 }
 750
 751 int IoCtx::application_metadata_get(const std::string& app_name,
 752                                     const std::string &key,
 753                                     std::string *value) {
 754   return -EOPNOTSUPP;
 755 }
 756
 757 int IoCtx::application_metadata_set(const std::string& app_name,
 758                                     const std::string &key,
 759                                     const std::string& value) {
 760   return -EOPNOTSUPP;
 761 }
 762
 763 int IoCtx::application_metadata_remove(const std::string& app_name,
 764                                        const std::string &key) {
 765   return -EOPNOTSUPP;
 766 }
 767
 768 int IoCtx::application_metadata_list(const std::string& app_name,
 769                                      std::map<std::string, std::string> *values) {
 770   return -EOPNOTSUPP;
 771 }
 772
 773 void IoCtx::set_namespace(const std::string& nspace) {
 774   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 775   ctx->set_namespace(nspace);
 776 }
 777
 778 std::string IoCtx::get_namespace() const {
 779   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(io_ctx_impl);
 780   return ctx->get_namespace();
 781 }
 782
 783 static int save_operation_result(int result, int *pval) {
 784   if (pval != NULL) {
 785     *pval = result;
 786   }
 787   return result;
 788 }
 789
 790 ObjectOperation::ObjectOperation() {
 791   TestObjectOperationImpl *o = new TestObjectOperationImpl();
 792   o->get();
 793   impl = reinterpret_cast<ObjectOperationImpl*>(o);
 794 }
 795
 796 ObjectOperation::~ObjectOperation() {
 797   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 798   if (o) {
 799     o->put();
 800     o = NULL;
 801   }
 802 }
 803
 804 void ObjectOperation::assert_exists() {
 805   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 806   o->ops.push_back(boost::bind(&TestIoCtxImpl::assert_exists, _1, _2));
 807 }
 808
 809 void ObjectOperation::exec(const char *cls, const char *method,
 810                            bufferlist& inbl) {
 811   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 812   o->ops.push_back(boost::bind(&TestIoCtxImpl::exec, _1, _2,
 813                                get_class_handler(), cls, method, inbl, _3, _4));
 814 }
 815
 816 void ObjectOperation::set_op_flags2(int flags) {
 817 }
 818
 819 size_t ObjectOperation::size() {
 820   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 821   return o->ops.size();
 822 }
 823
 824 void ObjectOperation::cmpext(uint64_t off, const bufferlist& cmp_bl,
 825                              int *prval) {
 826   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 827   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::cmpext, _1, _2, off, cmp_bl);
 828   if (prval != NULL) {
 829     op = boost::bind(save_operation_result,
 830                      boost::bind(op, _1, _2, _3, _4), prval);
 831   }
 832   o->ops.push_back(op);
 833 }
 834
 835 void ObjectReadOperation::list_snaps(snap_set_t *out_snaps, int *prval) {
 836   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 837
 838   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::list_snaps, _1, _2,
 839                                            out_snaps);
 840   if (prval != NULL) {
 841     op = boost::bind(save_operation_result,
 842                      boost::bind(op, _1, _2, _3, _4), prval);
 843   }
 844   o->ops.push_back(op);
 845 }
 846
 847 void ObjectReadOperation::list_watchers(std::list<obj_watch_t> *out_watchers,
 848                                         int *prval) {
 849   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 850
 851   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::list_watchers, _1,
 852                                            _2, out_watchers);
 853   if (prval != NULL) {
 854     op = boost::bind(save_operation_result,
 855                      boost::bind(op, _1, _2, _3, _4), prval);
 856   }
 857   o->ops.push_back(op);
 858 }
 859
 860 void ObjectReadOperation::read(size_t off, uint64_t len, bufferlist *pbl,
 861                                int *prval) {
 862   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 863
 864   ObjectOperationTestImpl op;
 865   if (pbl != NULL) {
 866     op = boost::bind(&TestIoCtxImpl::read, _1, _2, len, off, pbl);
 867   } else {
 868     op = boost::bind(&TestIoCtxImpl::read, _1, _2, len, off, _3);
 869   }
 870
 871   if (prval != NULL) {
 872     op = boost::bind(save_operation_result,
 873                      boost::bind(op, _1, _2, _3, _4), prval);
 874   }
 875   o->ops.push_back(op);
 876 }
 877
 878 void ObjectReadOperation::sparse_read(uint64_t off, uint64_t len,
 879                                       std::map<uint64_t,uint64_t> *m,
 880                                       bufferlist *pbl, int *prval) {
 881   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 882
 883   ObjectOperationTestImpl op;
 884   if (pbl != NULL) {
 885     op = boost::bind(&TestIoCtxImpl::sparse_read, _1, _2, off, len, m, pbl);
 886   } else {
 887     op = boost::bind(&TestIoCtxImpl::sparse_read, _1, _2, off, len, m, _3);
 888   }
 889
 890   if (prval != NULL) {
 891     op = boost::bind(save_operation_result,
 892                      boost::bind(op, _1, _2, _3, _4), prval);
 893   }
 894   o->ops.push_back(op);
 895 }
 896
 897 void ObjectReadOperation::stat(uint64_t *psize, time_t *pmtime, int *prval) {
 898   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 899
 900   ObjectOperationTestImpl op = boost::bind(&TestIoCtxImpl::stat, _1, _2,
 901                                            psize, pmtime);
 902
 903   if (prval != NULL) {
 904     op = boost::bind(save_operation_result,
 905                      boost::bind(op, _1, _2, _3, _4), prval);
 906   }
 907   o->ops.push_back(op);
 908 }
 909
 910 void ObjectWriteOperation::append(const bufferlist &bl) {
 911   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 912   o->ops.push_back(boost::bind(&TestIoCtxImpl::append, _1, _2, bl, _4));
 913 }
 914
 915 void ObjectWriteOperation::create(bool exclusive) {
 916   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 917   o->ops.push_back(boost::bind(&TestIoCtxImpl::create, _1, _2, exclusive));
 918 }
 919
 920 void ObjectWriteOperation::omap_set(const std::map<std::string, bufferlist> &map) {
 921   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 922   o->ops.push_back(boost::bind(&TestIoCtxImpl::omap_set, _1, _2, boost::ref(map)));
 923 }
 924
 925 void ObjectWriteOperation::remove() {
 926   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 927   o->ops.push_back(boost::bind(&TestIoCtxImpl::remove, _1, _2, _4));
 928 }
 929
 930 void ObjectWriteOperation::selfmanaged_snap_rollback(uint64_t snapid) {
 931   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 932   o->ops.push_back(boost::bind(&TestIoCtxImpl::selfmanaged_snap_rollback,
 933                                _1, _2, snapid));
 934 }
 935
 936 void ObjectWriteOperation::set_alloc_hint(uint64_t expected_object_size,
 937                                           uint64_t expected_write_size) {
 938   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 939   o->ops.push_back(boost::bind(&TestIoCtxImpl::set_alloc_hint, _1, _2,
 940                                expected_object_size, expected_write_size, 0,
 941                                _4));
 942 }
 943
 944 void ObjectWriteOperation::set_alloc_hint2(uint64_t expected_object_size,
 945                                            uint64_t expected_write_size,
 946                                            uint32_t flags) {
 947   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 948   o->ops.push_back(boost::bind(&TestIoCtxImpl::set_alloc_hint, _1, _2,
 949                                expected_object_size, expected_write_size, flags,
 950                                _4));
 951 }
 952
 953 void ObjectWriteOperation::tmap_update(const bufferlist& cmdbl) {
 954   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 955   o->ops.push_back(boost::bind(&TestIoCtxImpl::tmap_update, _1, _2,
 956                                cmdbl));
 957 }
 958
 959 void ObjectWriteOperation::truncate(uint64_t off) {
 960   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 961   o->ops.push_back(boost::bind(&TestIoCtxImpl::truncate, _1, _2, off, _4));
 962 }
 963
 964 void ObjectWriteOperation::write(uint64_t off, const bufferlist& bl) {
 965   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 966   o->ops.push_back(boost::bind(&TestIoCtxImpl::write, _1, _2, bl, bl.length(),
 967                                off, _4));
 968 }
 969
 970 void ObjectWriteOperation::write_full(const bufferlist& bl) {
 971   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 972   o->ops.push_back(boost::bind(&TestIoCtxImpl::write_full, _1, _2, bl, _4));
 973 }
 974
 975 void ObjectWriteOperation::writesame(uint64_t off, uint64_t len, const bufferlist& bl) {
 976   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 977   o->ops.push_back(boost::bind(&TestIoCtxImpl::writesame, _1, _2, bl, len,
 978                                off, _4));
 979 }
 980
 981 void ObjectWriteOperation::zero(uint64_t off, uint64_t len) {
 982   TestObjectOperationImpl *o = reinterpret_cast<TestObjectOperationImpl*>(impl);
 983   o->ops.push_back(boost::bind(&TestIoCtxImpl::zero, _1, _2, off, len, _4));
 984 }
 985
 986 Rados::Rados() : client(NULL) {
 987 }
 988
 989 Rados::Rados(IoCtx& ioctx) {
 990   TestIoCtxImpl *ctx = reinterpret_cast<TestIoCtxImpl*>(ioctx.io_ctx_impl);
 991   TestRadosClient *impl = ctx->get_rados_client();
 992   impl->get();
 993
 994   client = reinterpret_cast<RadosClient*>(impl);
 995   ceph_assert(client != NULL);
 996 }
 997
 998 Rados::~Rados() {
 999   shutdown();
1000 }
1001
1002 void Rados::from_rados_t(rados_t p, Rados &rados) {
1003   if (rados.client != nullptr) {
1004     reinterpret_cast<TestRadosClient*>(rados.client)->put();
1005     rados.client = nullptr;
1006   }
1007
1008   auto impl = reinterpret_cast<TestRadosClient*>(p);
1009   if (impl) {
1010     impl->get();
1011     rados.client = reinterpret_cast<RadosClient*>(impl);
1012   }
1013 }
1014
1015 AioCompletion *Rados::aio_create_completion(void *cb_arg,
1016                                             callback_t cb_complete,
1017                                             callback_t cb_safe) {
1018   AioCompletionImpl *c;
1019   int r = rados_aio_create_completion(cb_arg, cb_complete, cb_safe,
1020       reinterpret_cast<void**>(&c));
1021   ceph_assert(r == 0);
1022   return new AioCompletion(c);
1023 }
1024
1025 int Rados::aio_watch_flush(AioCompletion* c) {
1026   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1027   return impl->aio_watch_flush(c->pc);
1028 }
1029
1030 int Rados::blacklist_add(const std::string& client_address,
1031                          uint32_t expire_seconds) {
1032   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1033   return impl->blacklist_add(client_address, expire_seconds);
1034 }
1035
1036 config_t Rados::cct() {
1037   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1038   return reinterpret_cast<config_t>(impl->cct());
1039 }
1040
1041 int Rados::cluster_fsid(std::string* fsid) {
1042   *fsid = "00000000-1111-2222-3333-444444444444";
1043   return 0;
1044 }
1045
1046 int Rados::conf_set(const char *option, const char *value) {
1047   return rados_conf_set(reinterpret_cast<rados_t>(client), option, value);
1048 }
1049
1050 int Rados::conf_get(const char *option, std::string &val) {
1051   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1052   CephContext *cct = impl->cct();
1053
1054   char *str = NULL;
1055   int ret = cct->_conf.get_val(option, &str, -1);
1056   if (ret != 0) {
1057     free(str);
1058     return ret;
1059   }
1060
1061   val = str;
1062   free(str);
1063   return 0;
1064 }
1065
1066 int Rados::conf_parse_env(const char *env) const {
1067   return rados_conf_parse_env(reinterpret_cast<rados_t>(client), env);
1068 }
1069
1070 int Rados::conf_read_file(const char * const path) const {
1071   return rados_conf_read_file(reinterpret_cast<rados_t>(client), path);
1072 }
1073
1074 int Rados::connect() {
1075   return rados_connect(reinterpret_cast<rados_t>(client));
1076 }
1077
1078 uint64_t Rados::get_instance_id() {
1079   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1080   return impl->get_instance_id();
1081 }
1082
1083 int Rados::get_min_compatible_osd(int8_t* require_osd_release) {
1084   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1085   return impl->get_min_compatible_osd(require_osd_release);
1086 }
1087
1088 int Rados::get_min_compatible_client(int8_t* min_compat_client,
1089                                      int8_t* require_min_compat_client) {
1090   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1091   return impl->get_min_compatible_client(min_compat_client,
1092                                          require_min_compat_client);
1093 }
1094
1095 int Rados::init(const char * const id) {
1096   return rados_create(reinterpret_cast<rados_t *>(&client), id);
1097 }
1098
1099 int Rados::init_with_context(config_t cct_) {
1100   return rados_create_with_context(reinterpret_cast<rados_t *>(&client), cct_);
1101 }
1102
1103 int Rados::ioctx_create(const char *name, IoCtx &io) {
1104   rados_ioctx_t p;
1105   int ret = rados_ioctx_create(reinterpret_cast<rados_t>(client), name, &p);
1106   if (ret) {
1107     return ret;
1108   }
1109
1110   io.close();
1111   io.io_ctx_impl = reinterpret_cast<IoCtxImpl*>(p);
1112   return 0;
1113 }
1114
1115 int Rados::ioctx_create2(int64_t pool_id, IoCtx &io)
1116 {
1117   rados_ioctx_t p;
1118   int ret = rados_ioctx_create2(reinterpret_cast<rados_t>(client), pool_id, &p);
1119   if (ret) {
1120     return ret;
1121   }
1122
1123   io.close();
1124   io.io_ctx_impl = reinterpret_cast<IoCtxImpl*>(p);
1125   return 0;
1126 }
1127
1128 int Rados::mon_command(std::string cmd, const bufferlist& inbl,
1129                        bufferlist *outbl, std::string *outs) {
1130   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1131
1132   std::vector<std::string> cmds;
1133   cmds.push_back(cmd);
1134   return impl->mon_command(cmds, inbl, outbl, outs);
1135 }
1136
1137 int Rados::service_daemon_register(const std::string& service,
1138                                    const std::string& name,
1139                                    const std::map<std::string,std::string>& metadata) {
1140   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1141   return impl->service_daemon_register(service, name, metadata);
1142 }
1143
1144 int Rados::service_daemon_update_status(std::map<std::string,std::string>&& status) {
1145   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1146   return impl->service_daemon_update_status(std::move(status));
1147 }
1148
1149 int Rados::pool_create(const char *name) {
1150   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1151   return impl->pool_create(name);
1152 }
1153
1154 int Rados::pool_delete(const char *name) {
1155   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1156   return impl->pool_delete(name);
1157 }
1158
1159 int Rados::pool_get_base_tier(int64_t pool, int64_t* base_tier) {
1160   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1161   return impl->pool_get_base_tier(pool, base_tier);
1162 }
1163
1164 int Rados::pool_list(std::list<std::string>& v) {
1165   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1166   std::list<std::pair<int64_t, std::string> > pools;
1167   int r = impl->pool_list(pools);
1168   if (r < 0) {
1169     return r;
1170   }
1171
1172   v.clear();
1173   for (std::list<std::pair<int64_t, std::string> >::iterator it = pools.begin();
1174        it != pools.end(); ++it) {
1175     v.push_back(it->second);
1176   }
1177   return 0;
1178 }
1179
1180 int Rados::pool_list2(std::list<std::pair<int64_t, std::string> >& v)
1181 {
1182   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1183   return impl->pool_list(v);
1184 }
1185
1186 int64_t Rados::pool_lookup(const char *name) {
1187   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1188   return impl->pool_lookup(name);
1189 }
1190
1191 int Rados::pool_reverse_lookup(int64_t id, std::string *name) {
1192   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1193   return impl->pool_reverse_lookup(id, name);
1194 }
1195
1196 void Rados::shutdown() {
1197   if (client == NULL) {
1198     return;
1199   }
1200   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1201   impl->put();
1202   client = NULL;
1203 }
1204
1205 void Rados::test_blacklist_self(bool set) {
1206 }
1207
1208 int Rados::wait_for_latest_osdmap() {
1209   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1210   return impl->wait_for_latest_osdmap();
1211 }
1212
1213 int Rados::watch_flush() {
1214   TestRadosClient *impl = reinterpret_cast<TestRadosClient*>(client);
1215   return impl->watch_flush();
1216 }
1217
1218 WatchCtx::~WatchCtx() {
1219 }
1220
1221 WatchCtx2::~WatchCtx2() {
1222 }
1223
1224 } // namespace librados
1225
1226 int cls_cxx_create(cls_method_context_t hctx, bool exclusive) {
1227   librados::TestClassHandler::MethodContext *ctx =
1228     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1229   return ctx->io_ctx_impl->create(ctx->oid, exclusive);
1230 }
1231
1232 int cls_cxx_remove(cls_method_context_t hctx) {
1233   librados::TestClassHandler::MethodContext *ctx =
1234     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1235   return ctx->io_ctx_impl->remove(ctx->oid, ctx->io_ctx_impl->get_snap_context());
1236 }
1237
1238 int cls_get_request_origin(cls_method_context_t hctx, entity_inst_t *origin) {
1239   librados::TestClassHandler::MethodContext *ctx =
1240     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1241
1242   librados::TestRadosClient *rados_client =
1243     ctx->io_ctx_impl->get_rados_client();
1244
1245   struct sockaddr_in sin;
1246   memset(&sin, 0, sizeof(sin));
1247   sin.sin_family = AF_INET;
1248   sin.sin_port = 0;
1249   inet_pton(AF_INET, "127.0.0.1", &sin.sin_addr);
1250
1251   entity_addr_t entity_addr(entity_addr_t::TYPE_DEFAULT,
1252                             rados_client->get_nonce());
1253   entity_addr.in4_addr() = sin;
1254
1255   *origin = entity_inst_t(
1256     entity_name_t::CLIENT(rados_client->get_instance_id()),
1257     entity_addr);
1258   return 0;
1259 }
1260
1261 int cls_cxx_getxattr(cls_method_context_t hctx, const char *name,
1262                      bufferlist *outbl) {
1263   std::map<string, bufferlist> attrs;
1264   int r = cls_cxx_getxattrs(hctx, &attrs);
1265   if (r < 0) {
1266     return r;
1267   }
1268
1269   std::map<string, bufferlist>::iterator it = attrs.find(name);
1270   if (it == attrs.end()) {
1271     return -ENODATA;
1272   }
1273   *outbl = it->second;
1274   return 0;
1275 }
1276
1277 int cls_cxx_getxattrs(cls_method_context_t hctx, std::map<string, bufferlist> *attrset) {
1278   librados::TestClassHandler::MethodContext *ctx =
1279     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1280   return ctx->io_ctx_impl->xattr_get(ctx->oid, attrset);
1281 }
1282
1283 int cls_cxx_map_get_keys(cls_method_context_t hctx, const string &start_obj,
1284                          uint64_t max_to_get, std::set<string> *keys, bool *more) {
1285   librados::TestClassHandler::MethodContext *ctx =
1286     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1287
1288   keys->clear();
1289   std::map<string, bufferlist> vals;
1290   int r = ctx->io_ctx_impl->omap_get_vals2(ctx->oid, start_obj, "", max_to_get,
1291                                            &vals, more);
1292   if (r < 0) {
1293     return r;
1294   }
1295
1296   for (std::map<string, bufferlist>::iterator it = vals.begin();
1297        it != vals.end(); ++it) {
1298     keys->insert(it->first);
1299   }
1300   return keys->size();
1301 }
1302
1303 int cls_cxx_map_get_val(cls_method_context_t hctx, const string &key,
1304                         bufferlist *outbl) {
1305   librados::TestClassHandler::MethodContext *ctx =
1306     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1307
1308   std::map<string, bufferlist> vals;
1309   int r = ctx->io_ctx_impl->omap_get_vals(ctx->oid, "", key, 1024, &vals);
1310   if (r < 0) {
1311     return r;
1312   }
1313
1314   std::map<string, bufferlist>::iterator it = vals.find(key);
1315   if (it == vals.end()) {
1316     return -ENOENT;
1317   }
1318
1319   *outbl = it->second;
1320   return 0;
1321 }
1322
1323 int cls_cxx_map_get_vals(cls_method_context_t hctx, const string &start_obj,
1324                          const string &filter_prefix, uint64_t max_to_get,
1325                          std::map<string, bufferlist> *vals, bool *more) {
1326   librados::TestClassHandler::MethodContext *ctx =
1327     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1328   int r = ctx->io_ctx_impl->omap_get_vals2(ctx->oid, start_obj, filter_prefix,
1329                                           max_to_get, vals, more);
1330   if (r < 0) {
1331     return r;
1332   }
1333   return vals->size();
1334 }
1335
1336 int cls_cxx_map_remove_key(cls_method_context_t hctx, const string &key) {
1337   std::set<std::string> keys;
1338   keys.insert(key);
1339
1340   librados::TestClassHandler::MethodContext *ctx =
1341     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1342   return ctx->io_ctx_impl->omap_rm_keys(ctx->oid, keys);
1343 }
1344
1345 int cls_cxx_map_set_val(cls_method_context_t hctx, const string &key,
1346                         bufferlist *inbl) {
1347   std::map<std::string, bufferlist> m;
1348   m[key] = *inbl;
1349   return cls_cxx_map_set_vals(hctx, &m);
1350 }
1351
1352 int cls_cxx_map_set_vals(cls_method_context_t hctx,
1353                          const std::map<string, bufferlist> *map) {
1354   librados::TestClassHandler::MethodContext *ctx =
1355     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1356   return ctx->io_ctx_impl->omap_set(ctx->oid, *map);
1357 }
1358
1359 int cls_cxx_read(cls_method_context_t hctx, int ofs, int len,
1360                  bufferlist *outbl) {
1361   return cls_cxx_read2(hctx, ofs, len, outbl, 0);
1362 }
1363
1364 int cls_cxx_read2(cls_method_context_t hctx, int ofs, int len,
1365                   bufferlist *outbl, uint32_t op_flags) {
1366   librados::TestClassHandler::MethodContext *ctx =
1367     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1368   return ctx->io_ctx_impl->read(ctx->oid, len, ofs, outbl);
1369 }
1370
1371 int cls_cxx_setxattr(cls_method_context_t hctx, const char *name,
1372                      bufferlist *inbl) {
1373   librados::TestClassHandler::MethodContext *ctx =
1374     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1375   return ctx->io_ctx_impl->xattr_set(ctx->oid, name, *inbl);
1376 }
1377
1378 int cls_cxx_stat(cls_method_context_t hctx, uint64_t *size, time_t *mtime) {
1379   librados::TestClassHandler::MethodContext *ctx =
1380     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1381   return ctx->io_ctx_impl->stat(ctx->oid, size, mtime);
1382 }
1383
1384 int cls_cxx_write(cls_method_context_t hctx, int ofs, int len,
1385                   bufferlist *inbl) {
1386   return cls_cxx_write2(hctx, ofs, len, inbl, 0);
1387 }
1388
1389 int cls_cxx_write2(cls_method_context_t hctx, int ofs, int len,
1390                    bufferlist *inbl, uint32_t op_flags) {
1391   librados::TestClassHandler::MethodContext *ctx =
1392     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1393   return ctx->io_ctx_impl->write(ctx->oid, *inbl, len, ofs, ctx->snapc);
1394 }
1395
1396 int cls_cxx_write_full(cls_method_context_t hctx, bufferlist *inbl) {
1397   librados::TestClassHandler::MethodContext *ctx =
1398     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1399   return ctx->io_ctx_impl->write_full(ctx->oid, *inbl, ctx->snapc);
1400 }
1401
1402 int cls_cxx_replace(cls_method_context_t hctx, int ofs, int len,
1403                     bufferlist *inbl) {
1404   librados::TestClassHandler::MethodContext *ctx =
1405     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1406   int r = ctx->io_ctx_impl->truncate(ctx->oid, 0, ctx->snapc);
1407   if (r < 0) {
1408     return r;
1409   }
1410   return ctx->io_ctx_impl->write(ctx->oid, *inbl, len, ofs, ctx->snapc);
1411 }
1412
1413 int cls_cxx_list_watchers(cls_method_context_t hctx,
1414                           obj_list_watch_response_t *watchers) {
1415   librados::TestClassHandler::MethodContext *ctx =
1416     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1417
1418   std::list<obj_watch_t> obj_watchers;
1419   int r = ctx->io_ctx_impl->list_watchers(ctx->oid, &obj_watchers);
1420   if (r < 0) {
1421     return r;
1422   }
1423
1424   for (auto &w : obj_watchers) {
1425     watch_item_t watcher;
1426     watcher.name = entity_name_t::CLIENT(w.watcher_id);
1427     watcher.cookie = w.cookie;
1428     watcher.timeout_seconds = w.timeout_seconds;
1429     watcher.addr.parse(w.addr, 0);
1430     watchers->entries.push_back(watcher);
1431   }
1432
1433   return 0;
1434 }
1435
1436 uint64_t cls_get_features(cls_method_context_t hctx) {
1437   return CEPH_FEATURES_SUPPORTED_DEFAULT;
1438 }
1439
1440 uint64_t cls_get_client_features(cls_method_context_t hctx) {
1441   return CEPH_FEATURES_SUPPORTED_DEFAULT;
1442 }
1443
1444 int cls_get_snapset_seq(cls_method_context_t hctx, uint64_t *snap_seq) {
1445   librados::TestClassHandler::MethodContext *ctx =
1446     reinterpret_cast<librados::TestClassHandler::MethodContext*>(hctx);
1447   librados::snap_set_t snapset;
1448   int r = ctx->io_ctx_impl->list_snaps(ctx->oid, &snapset);
1449   if (r < 0) {
1450     return r;
1451   }
1452
1453   *snap_seq = snapset.seq;
1454   return 0;
1455 }
1456
1457 int cls_log(int level, const char *format, ...) {
1458   int size = 256;
1459   va_list ap;
1460   while (1) {
1461     char buf[size];
1462     va_start(ap, format);
1463     int n = vsnprintf(buf, size, format, ap);
1464     va_end(ap);
1465     if ((n > -1 && n < size) || size > 8196) {
1466       dout(ceph::dout::need_dynamic(level)) << buf << dendl;
1467       return n;
1468     }
1469     size *= 2;
1470   }
1471   return 0;
1472 }
1473
1474 int cls_register(const char *name, cls_handle_t *handle) {
1475   librados::TestClassHandler *cls = get_class_handler();
1476   return cls->create(name, handle);
1477 }
1478
1479 int cls_register_cxx_method(cls_handle_t hclass, const char *method,
1480     int flags,
1481     cls_method_cxx_call_t class_call,
1482     cls_method_handle_t *handle) {
1483   librados::TestClassHandler *cls = get_class_handler();
1484   return cls->create_method(hclass, method, class_call, handle);
1485 }
1486
1487 int cls_register_cxx_filter(cls_handle_t hclass,
1488                             const std::string &filter_name,
1489                             cls_cxx_filter_factory_t fn,
1490                             cls_filter_handle_t *)
1491 {
1492   librados::TestClassHandler *cls = get_class_handler();
1493   return cls->create_filter(hclass, filter_name, fn);
1494 }
1495
1496 int8_t cls_get_required_osd_release(cls_handle_t hclass) {
1497   return CEPH_FEATURE_SERVER_NAUTILUS;
1498 }