ceph/src/test/librados_test_stub/TestIoCtxImpl.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3
   4 #ifndef CEPH_TEST_IO_CTX_IMPL_H
   5 #define CEPH_TEST_IO_CTX_IMPL_H
   6
   7 #include <list>
   8 #include <atomic>
   9
  10 #include <boost/function.hpp>
  11
  12 #include "include/rados/librados.hpp"
  13 #include "include/Context.h"
  14 #include "common/snap_types.h"
  15
  16 namespace librados {
  17
  18 class TestClassHandler;
  19 class TestIoCtxImpl;
  20 class TestRadosClient;
  21
  22 typedef boost::function<int(TestIoCtxImpl*,
  23                             const std::string&,
  24                             bufferlist *,
  25           uint64_t,
  26           const SnapContext &,
  27           uint64_t*)> ObjectOperationTestImpl;
  28 typedef std::list<ObjectOperationTestImpl> ObjectOperations;
  29
  30 struct TestObjectOperationImpl {
  31 public:
  32   void get();
  33   void put();
  34
  35   ObjectOperations ops;
  36 private:
  37   std::atomic<uint64_t> m_refcount = { 0 };
  38 };
  39
  40 class TestIoCtxImpl {
  41 public:
  42   typedef boost::function<int(TestIoCtxImpl *, const std::string &)> Operation;
  43
  44
  45   TestIoCtxImpl();
  46   explicit TestIoCtxImpl(TestRadosClient *client, int64_t m_pool_id,
  47                          const std::string& pool_name);
  48
  49   TestRadosClient *get_rados_client() {
  50     return m_client;
  51   }
  52
  53   void get();
  54   void put();
  55
  56   inline int64_t get_pool_id() const {
  57     return m_pool_id;
  58   }
  59
  60   virtual TestIoCtxImpl *clone() = 0;
  61
  62   virtual uint64_t get_instance_id() const;
  63   virtual int64_t get_id();
  64   virtual uint64_t get_last_version();
  65   virtual std::string get_pool_name();
  66
  67   inline void set_namespace(const std::string& namespace_name) {
  68     m_namespace_name = namespace_name;
  69   }
  70   inline std::string get_namespace() const {
  71     return m_namespace_name;
  72   }
  73
  74   snap_t get_snap_read() const {
  75     return m_snap_seq;
  76   }
  77
  78   inline void set_snap_context(const SnapContext& snapc) {
  79     m_snapc = snapc;
  80   }
  81   const SnapContext &get_snap_context() const {
  82     return m_snapc;
  83   }
  84
  85   virtual int aio_flush();
  86   virtual void aio_flush_async(AioCompletionImpl *c);
  87   virtual void aio_notify(const std::string& oid, AioCompletionImpl *c,
  88                           bufferlist& bl, uint64_t timeout_ms, bufferlist *pbl);
  89   virtual int aio_operate(const std::string& oid, TestObjectOperationImpl &ops,
  90                           AioCompletionImpl *c, SnapContext *snap_context,
  91                           const ceph::real_time *pmtime, int flags);
  92   virtual int aio_operate_read(const std::string& oid, TestObjectOperationImpl &ops,
  93                                AioCompletionImpl *c, int flags,
  94                                bufferlist *pbl, uint64_t snap_id,
  95                                uint64_t* objver);
  96   virtual int aio_remove(const std::string& oid, AioCompletionImpl *c,
  97                          int flags = 0) = 0;
  98   virtual int aio_watch(const std::string& o, AioCompletionImpl *c,
  99                         uint64_t *handle, librados::WatchCtx2 *ctx);
 100   virtual int aio_unwatch(uint64_t handle, AioCompletionImpl *c);
 101   virtual int append(const std::string& oid, const bufferlist &bl,
 102                      const SnapContext &snapc) = 0;
 103   virtual int assert_exists(const std::string &oid, uint64_t snap_id) = 0;
 104   virtual int assert_version(const std::string &oid, uint64_t ver) = 0;
 105
 106   virtual int create(const std::string& oid, bool exclusive,
 107                      const SnapContext &snapc) = 0;
 108   virtual int exec(const std::string& oid, TestClassHandler *handler,
 109                    const char *cls, const char *method,
 110                    bufferlist& inbl, bufferlist* outbl,
 111                    uint64_t snap_id, const SnapContext &snapc);
 112   virtual int list_snaps(const std::string& o, snap_set_t *out_snaps) = 0;
 113   virtual int list_watchers(const std::string& o,
 114                             std::list<obj_watch_t> *out_watchers);
 115   virtual int notify(const std::string& o, bufferlist& bl,
 116                      uint64_t timeout_ms, bufferlist *pbl);
 117   virtual void notify_ack(const std::string& o, uint64_t notify_id,
 118                           uint64_t handle, bufferlist& bl);
 119   virtual int omap_get_vals(const std::string& oid,
 120                             const std::string& start_after,
 121                             const std::string &filter_prefix,
 122                             uint64_t max_return,
 123                             std::map<std::string, bufferlist> *out_vals) = 0;
 124   virtual int omap_get_vals2(const std::string& oid,
 125                             const std::string& start_after,
 126                             const std::string &filter_prefix,
 127                             uint64_t max_return,
 128                             std::map<std::string, bufferlist> *out_vals,
 129                             bool *pmore) = 0;
 130   virtual int omap_rm_keys(const std::string& oid,
 131                            const std::set<std::string>& keys) = 0;
 132   virtual int omap_set(const std::string& oid,
 133                        const std::map<std::string, bufferlist> &map) = 0;
 134   virtual int operate(const std::string& oid, TestObjectOperationImpl &ops);
 135   virtual int operate_read(const std::string& oid, TestObjectOperationImpl &ops,
 136                            bufferlist *pbl);
 137   virtual int read(const std::string& oid, size_t len, uint64_t off,
 138                    bufferlist *bl, uint64_t snap_id, uint64_t* objver) = 0;
 139   virtual int remove(const std::string& oid, const SnapContext &snapc) = 0;
 140   virtual int selfmanaged_snap_create(uint64_t *snapid) = 0;
 141   virtual void aio_selfmanaged_snap_create(uint64_t *snapid,
 142                                            AioCompletionImpl *c);
 143   virtual int selfmanaged_snap_remove(uint64_t snapid) = 0;
 144   virtual void aio_selfmanaged_snap_remove(uint64_t snapid,
 145                                            AioCompletionImpl *c);
 146   virtual int selfmanaged_snap_rollback(const std::string& oid,
 147                                         uint64_t snapid) = 0;
 148   virtual int selfmanaged_snap_set_write_ctx(snap_t seq,
 149                                              std::vector<snap_t>& snaps);
 150   virtual int set_alloc_hint(const std::string& oid,
 151                              uint64_t expected_object_size,
 152                              uint64_t expected_write_size,
 153                              uint32_t flags,
 154                              const SnapContext &snapc);
 155   virtual void set_snap_read(snap_t seq);
 156   virtual int sparse_read(const std::string& oid, uint64_t off, uint64_t len,
 157                           std::map<uint64_t,uint64_t> *m,
 158                           bufferlist *data_bl, uint64_t snap_id) = 0;
 159   virtual int stat(const std::string& oid, uint64_t *psize, time_t *pmtime) = 0;
 160   virtual int truncate(const std::string& oid, uint64_t size,
 161                        const SnapContext &snapc) = 0;
 162   virtual int tmap_update(const std::string& oid, bufferlist& cmdbl);
 163   virtual int unwatch(uint64_t handle);
 164   virtual int watch(const std::string& o, uint64_t *handle,
 165                     librados::WatchCtx *ctx, librados::WatchCtx2 *ctx2);
 166   virtual int write(const std::string& oid, bufferlist& bl, size_t len,
 167                     uint64_t off, const SnapContext &snapc) = 0;
 168   virtual int write_full(const std::string& oid, bufferlist& bl,
 169                          const SnapContext &snapc) = 0;
 170   virtual int writesame(const std::string& oid, bufferlist& bl, size_t len,
 171                         uint64_t off, const SnapContext &snapc) = 0;
 172   virtual int cmpext(const std::string& oid, uint64_t off, bufferlist& cmp_bl,
 173                      uint64_t snap_id) = 0;
 174   virtual int xattr_get(const std::string& oid,
 175                         std::map<std::string, bufferlist>* attrset) = 0;
 176   virtual int xattr_set(const std::string& oid, const std::string &name,
 177                         bufferlist& bl) = 0;
 178   virtual int zero(const std::string& oid, uint64_t off, uint64_t len,
 179                    const SnapContext &snapc) = 0;
 180
 181   int execute_operation(const std::string& oid,
 182                         const Operation &operation);
 183
 184 protected:
 185   TestIoCtxImpl(const TestIoCtxImpl& rhs);
 186   virtual ~TestIoCtxImpl();
 187
 188   int execute_aio_operations(const std::string& oid,
 189                              TestObjectOperationImpl *ops,
 190                              bufferlist *pbl, uint64_t,
 191                              const SnapContext &snapc,
 192                              uint64_t* objver);
 193
 194 private:
 195   struct C_AioNotify : public Context {
 196     TestIoCtxImpl *io_ctx;
 197     AioCompletionImpl *aio_comp;
 198     C_AioNotify(TestIoCtxImpl *_io_ctx, AioCompletionImpl *_aio_comp)
 199       : io_ctx(_io_ctx), aio_comp(_aio_comp) {
 200     }
 201     void finish(int r) override {
 202       io_ctx->handle_aio_notify_complete(aio_comp, r);
 203     }
 204   };
 205
 206   TestRadosClient *m_client;
 207   int64_t m_pool_id = 0;
 208   std::string m_pool_name;
 209   std::string m_namespace_name;
 210
 211   snap_t m_snap_seq = 0;
 212   SnapContext m_snapc;
 213   std::atomic<uint64_t> m_refcount = { 0 };
 214   std::atomic<uint64_t> m_pending_ops = { 0 };
 215
 216   void handle_aio_notify_complete(AioCompletionImpl *aio_comp, int r);
 217 };
 218
 219 } // namespace librados
 220
 221 #endif // CEPH_TEST_IO_CTX_IMPL_H