[ceph.git] / ceph / src / test / librados_test_stub / TestIoCtxImpl.h

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#ifndef CEPH_TEST_IO_CTX_IMPL_H
#define CEPH_TEST_IO_CTX_IMPL_H

#include <list>
#include <atomic>

#include <boost/function.hpp>

#include "include/rados/librados.hpp"
#include "include/Context.h"
#include "common/snap_types.h"

namespace librados {

class TestClassHandler;
class TestIoCtxImpl;
class TestRadosClient;

typedef boost::function<int(TestIoCtxImpl*,
			    const std::string&,
			    bufferlist *,
          uint64_t,
          const SnapContext &,
          uint64_t*)> ObjectOperationTestImpl;
typedef std::list<ObjectOperationTestImpl> ObjectOperations;

struct TestObjectOperationImpl {
public:
  void get();
  void put();

  ObjectOperations ops;
private:
  std::atomic<uint64_t> m_refcount = { 0 };
};

class TestIoCtxImpl {
public:
  typedef boost::function<int(TestIoCtxImpl *, const std::string &)> Operation;


  TestIoCtxImpl();
  explicit TestIoCtxImpl(TestRadosClient *client, int64_t m_pool_id,
                         const std::string& pool_name);

  TestRadosClient *get_rados_client() {
    return m_client;
  }

  void get();
  void put();

  inline int64_t get_pool_id() const {
    return m_pool_id;
  }

  virtual TestIoCtxImpl *clone() = 0;

  virtual uint64_t get_instance_id() const;
  virtual int64_t get_id();
  virtual uint64_t get_last_version();
  virtual std::string get_pool_name();

  inline void set_namespace(const std::string& namespace_name) {
    m_namespace_name = namespace_name;
  }
  inline std::string get_namespace() const {
    return m_namespace_name;
  }

  snap_t get_snap_read() const {
    return m_snap_seq;
  }

  inline void set_snap_context(const SnapContext& snapc) {
    m_snapc = snapc;
  }
  const SnapContext &get_snap_context() const {
    return m_snapc;
  }

  virtual int aio_flush();
  virtual void aio_flush_async(AioCompletionImpl *c);
  virtual void aio_notify(const std::string& oid, AioCompletionImpl *c,
                          bufferlist& bl, uint64_t timeout_ms, bufferlist *pbl);
  virtual int aio_operate(const std::string& oid, TestObjectOperationImpl &ops,
                          AioCompletionImpl *c, SnapContext *snap_context,
                          const ceph::real_time *pmtime, int flags);
  virtual int aio_operate_read(const std::string& oid, TestObjectOperationImpl &ops,
                               AioCompletionImpl *c, int flags,
                               bufferlist *pbl, uint64_t snap_id,
                               uint64_t* objver);
  virtual int aio_remove(const std::string& oid, AioCompletionImpl *c,
                         int flags = 0) = 0;
  virtual int aio_watch(const std::string& o, AioCompletionImpl *c,
                        uint64_t *handle, librados::WatchCtx2 *ctx);
  virtual int aio_unwatch(uint64_t handle, AioCompletionImpl *c);
  virtual int append(const std::string& oid, const bufferlist &bl,
                     const SnapContext &snapc) = 0;
  virtual int assert_exists(const std::string &oid, uint64_t snap_id) = 0;
  virtual int assert_version(const std::string &oid, uint64_t ver) = 0;

  virtual int create(const std::string& oid, bool exclusive,
                     const SnapContext &snapc) = 0;
  virtual int exec(const std::string& oid, TestClassHandler *handler,
                   const char *cls, const char *method,
                   bufferlist& inbl, bufferlist* outbl,
                   uint64_t snap_id, const SnapContext &snapc);
  virtual int list_snaps(const std::string& o, snap_set_t *out_snaps) = 0;
  virtual int list_watchers(const std::string& o,
                            std::list<obj_watch_t> *out_watchers);
  virtual int notify(const std::string& o, bufferlist& bl,
                     uint64_t timeout_ms, bufferlist *pbl);
  virtual void notify_ack(const std::string& o, uint64_t notify_id,
                          uint64_t handle, bufferlist& bl);
  virtual int omap_get_vals(const std::string& oid,
                            const std::string& start_after,
                            const std::string &filter_prefix,
                            uint64_t max_return,
                            std::map<std::string, bufferlist> *out_vals) = 0;
  virtual int omap_get_vals2(const std::string& oid,
                            const std::string& start_after,
                            const std::string &filter_prefix,
                            uint64_t max_return,
                            std::map<std::string, bufferlist> *out_vals,
                            bool *pmore) = 0;
  virtual int omap_rm_keys(const std::string& oid,
                           const std::set<std::string>& keys) = 0;
  virtual int omap_set(const std::string& oid,
                       const std::map<std::string, bufferlist> &map) = 0;
  virtual int operate(const std::string& oid, TestObjectOperationImpl &ops);
  virtual int operate_read(const std::string& oid, TestObjectOperationImpl &ops,
                           bufferlist *pbl);
  virtual int read(const std::string& oid, size_t len, uint64_t off,
                   bufferlist *bl, uint64_t snap_id, uint64_t* objver) = 0;
  virtual int remove(const std::string& oid, const SnapContext &snapc) = 0;
  virtual int selfmanaged_snap_create(uint64_t *snapid) = 0;
  virtual void aio_selfmanaged_snap_create(uint64_t *snapid,
                                           AioCompletionImpl *c);
  virtual int selfmanaged_snap_remove(uint64_t snapid) = 0;
  virtual void aio_selfmanaged_snap_remove(uint64_t snapid,
                                           AioCompletionImpl *c);
  virtual int selfmanaged_snap_rollback(const std::string& oid,
                                        uint64_t snapid) = 0;
  virtual int selfmanaged_snap_set_write_ctx(snap_t seq,
                                             std::vector<snap_t>& snaps);
  virtual int set_alloc_hint(const std::string& oid,
                             uint64_t expected_object_size,
                             uint64_t expected_write_size,
                             uint32_t flags,
                             const SnapContext &snapc);
  virtual void set_snap_read(snap_t seq);
  virtual int sparse_read(const std::string& oid, uint64_t off, uint64_t len,
                          std::map<uint64_t,uint64_t> *m,
                          bufferlist *data_bl, uint64_t snap_id) = 0;
  virtual int stat(const std::string& oid, uint64_t *psize, time_t *pmtime) = 0;
  virtual int truncate(const std::string& oid, uint64_t size,
                       const SnapContext &snapc) = 0;
  virtual int tmap_update(const std::string& oid, bufferlist& cmdbl);
  virtual int unwatch(uint64_t handle);
  virtual int watch(const std::string& o, uint64_t *handle,
                    librados::WatchCtx *ctx, librados::WatchCtx2 *ctx2);
  virtual int write(const std::string& oid, bufferlist& bl, size_t len,
                    uint64_t off, const SnapContext &snapc) = 0;
  virtual int write_full(const std::string& oid, bufferlist& bl,
                         const SnapContext &snapc) = 0;
  virtual int writesame(const std::string& oid, bufferlist& bl, size_t len,
                        uint64_t off, const SnapContext &snapc) = 0;
  virtual int cmpext(const std::string& oid, uint64_t off, bufferlist& cmp_bl,
                     uint64_t snap_id) = 0;
  virtual int xattr_get(const std::string& oid,
                        std::map<std::string, bufferlist>* attrset) = 0;
  virtual int xattr_set(const std::string& oid, const std::string &name,
                        bufferlist& bl) = 0;
  virtual int zero(const std::string& oid, uint64_t off, uint64_t len,
                   const SnapContext &snapc) = 0;

  int execute_operation(const std::string& oid,
                        const Operation &operation);

protected:
  TestIoCtxImpl(const TestIoCtxImpl& rhs);
  virtual ~TestIoCtxImpl();

  int execute_aio_operations(const std::string& oid,
                             TestObjectOperationImpl *ops,
                             bufferlist *pbl, uint64_t,
                             const SnapContext &snapc,
                             uint64_t* objver);

private:
  struct C_AioNotify : public Context {
    TestIoCtxImpl *io_ctx;
    AioCompletionImpl *aio_comp;
    C_AioNotify(TestIoCtxImpl *_io_ctx, AioCompletionImpl *_aio_comp)
      : io_ctx(_io_ctx), aio_comp(_aio_comp) {
    }
    void finish(int r) override {
      io_ctx->handle_aio_notify_complete(aio_comp, r);
    }
  };

  TestRadosClient *m_client;
  int64_t m_pool_id = 0;
  std::string m_pool_name;
  std::string m_namespace_name;

  snap_t m_snap_seq = 0;
  SnapContext m_snapc;
  std::atomic<uint64_t> m_refcount = { 0 };
  std::atomic<uint64_t> m_pending_ops = { 0 };

  void handle_aio_notify_complete(AioCompletionImpl *aio_comp, int r);
};

} // namespace librados

#endif // CEPH_TEST_IO_CTX_IMPL_H
Commit	Line	Data
7c673cae FG	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
31f18b77 FG	7	#include <list>
	8	#include <atomic>
	9
	10	#include <boost/function.hpp>
	11
7c673cae	12	#include "include/rados/librados.hpp"
7c673cae FG	13	#include "include/Context.h"
7c673cae FG	14	#include "common/snap_types.h"
7c673cae FG	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 *,
f67539c2 TL	25	uint64_t,
	26	const SnapContext &,
	27	uint64_t*)> ObjectOperationTestImpl;
7c673cae FG	28	typedef std::list<ObjectOperationTestImpl> ObjectOperations;
	29
	30	struct TestObjectOperationImpl {
	31	public:
	32	void get();
	33	void put();
	34
	35	ObjectOperations ops;
	36	private:
31f18b77	37	std::atomic<uint64_t> m_refcount = { 0 };
7c673cae FG	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();
11fdf7f2 TL	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
7c673cae FG	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,
1e59de90	91	const ceph::real_time *pmtime, int flags);
7c673cae FG	92	virtual int aio_operate_read(const std::string& oid, TestObjectOperationImpl &ops,
7c673cae FG	93	AioCompletionImpl *c, int flags,
f67539c2 TL	94	bufferlist *pbl, uint64_t snap_id,
f67539c2 TL	95	uint64_t* objver);
11fdf7f2 TL	96	virtual int aio_remove(const std::string& oid, AioCompletionImpl *c,
11fdf7f2 TL	97	int flags = 0) = 0;
7c673cae FG	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;
f67539c2 TL	103	virtual int assert_exists(const std::string &oid, uint64_t snap_id) = 0;
f67539c2 TL	104	virtual int assert_version(const std::string &oid, uint64_t ver) = 0;
7c673cae	105
9f95a23c TL	106	virtual int create(const std::string& oid, bool exclusive,
9f95a23c TL	107	const SnapContext &snapc) = 0;
7c673cae FG	108	virtual int exec(const std::string& oid, TestClassHandler *handler,
	109	const char cls, const char method,
	110	bufferlist& inbl, bufferlist* outbl,
f67539c2	111	uint64_t snap_id, const SnapContext &snapc);
7c673cae FG	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;
c07f9fc5 FG	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;
7c673cae FG	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,
f67539c2	138	bufferlist bl, uint64_t snap_id, uint64_t objver) = 0;
7c673cae FG	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,
b32b8144	152	uint64_t expected_write_size,
92f5a8d4	153	uint32_t flags,
b32b8144	154	const SnapContext &snapc);
7c673cae FG	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,
f67539c2	158	bufferlist *data_bl, uint64_t snap_id) = 0;
7c673cae FG	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;
f67539c2 TL	172	virtual int cmpext(const std::string& oid, uint64_t off, bufferlist& cmp_bl,
f67539c2 TL	173	uint64_t snap_id) = 0;
7c673cae FG	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;
b32b8144 FG	178	virtual int zero(const std::string& oid, uint64_t off, uint64_t len,
b32b8144 FG	179	const SnapContext &snapc) = 0;
7c673cae FG	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,
f67539c2 TL	190	bufferlist *pbl, uint64_t,
	191	const SnapContext &snapc,
	192	uint64_t* objver);
7c673cae FG	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;
11fdf7f2	207	int64_t m_pool_id = 0;
7c673cae	208	std::string m_pool_name;
11fdf7f2 TL	209	std::string m_namespace_name;
	210
	211	snap_t m_snap_seq = 0;
7c673cae	212	SnapContext m_snapc;
31f18b77 FG	213	std::atomic<uint64_t> m_refcount = { 0 };
31f18b77 FG	214	std::atomic<uint64_t> m_pending_ops = { 0 };
7c673cae FG	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