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