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