ceph/src/test/librados_test_stub/TestRadosClient.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_RADOS_CLIENT_H
   5 #define CEPH_TEST_RADOS_CLIENT_H
   6
   7 #include <map>
   8 #include <list>
   9 #include <string>
  10 #include <vector>
  11 #include <atomic>
  12
  13 #include <boost/function.hpp>
  14 #include <boost/functional/hash.hpp>
  15
  16 #include "include/rados/librados.hpp"
  17 #include "common/config.h"
  18 #include "include/buffer_fwd.h"
  19 #include "test/librados_test_stub/TestWatchNotify.h"
  20
  21 class Finisher;
  22
  23 namespace librados {
  24
  25 class TestIoCtxImpl;
  26
  27 class TestRadosClient {
  28 public:
  29
  30   static void Deallocate(librados::TestRadosClient* client)
  31   {
  32     client->put();
  33   }
  34
  35   typedef boost::function<int()> AioFunction;
  36
  37   struct Object {
  38     std::string oid;
  39     std::string locator;
  40     std::string nspace;
  41   };
  42
  43   class Transaction {
  44   public:
  45     Transaction(TestRadosClient *rados_client, const std::string& nspace,
  46                 const std::string &oid)
  47       : rados_client(rados_client), nspace(nspace), oid(oid) {
  48       rados_client->transaction_start(nspace, oid);
  49     }
  50     ~Transaction() {
  51       rados_client->transaction_finish(nspace, oid);
  52     }
  53   private:
  54     TestRadosClient *rados_client;
  55     std::string nspace;
  56     std::string oid;
  57   };
  58
  59   TestRadosClient(CephContext *cct, TestWatchNotify *watch_notify);
  60
  61   void get();
  62   void put();
  63
  64   virtual CephContext *cct();
  65
  66   virtual uint32_t get_nonce() = 0;
  67   virtual uint64_t get_instance_id() = 0;
  68
  69   virtual int get_min_compatible_osd(int8_t* require_osd_release) = 0;
  70   virtual int get_min_compatible_client(int8_t* min_compat_client,
  71                                         int8_t* require_min_compat_client) = 0;
  72
  73   virtual int connect();
  74   virtual void shutdown();
  75   virtual int wait_for_latest_osdmap();
  76
  77   virtual TestIoCtxImpl *create_ioctx(int64_t pool_id,
  78                                       const std::string &pool_name) = 0;
  79
  80   virtual int mon_command(const std::vector<std::string>& cmd,
  81                           const bufferlist &inbl,
  82                           bufferlist *outbl, std::string *outs);
  83
  84   virtual void object_list(int64_t pool_id,
  85                            std::list<librados::TestRadosClient::Object> *list) = 0;
  86
  87   virtual int service_daemon_register(const std::string& service,
  88                                       const std::string& name,
  89                                       const std::map<std::string,std::string>& metadata) = 0;
  90   virtual int service_daemon_update_status(std::map<std::string,std::string>&& status) = 0;
  91
  92   virtual int pool_create(const std::string &pool_name) = 0;
  93   virtual int pool_delete(const std::string &pool_name) = 0;
  94   virtual int pool_get_base_tier(int64_t pool_id, int64_t* base_tier) = 0;
  95   virtual int pool_list(std::list<std::pair<int64_t, std::string> >& v) = 0;
  96   virtual int64_t pool_lookup(const std::string &name) = 0;
  97   virtual int pool_reverse_lookup(int64_t id, std::string *name) = 0;
  98
  99   virtual int aio_watch_flush(AioCompletionImpl *c);
 100   virtual int watch_flush() = 0;
 101
 102   virtual bool is_blacklisted() const = 0;
 103   virtual int blacklist_add(const std::string& client_address,
 104                             uint32_t expire_seconds) = 0;
 105
 106   Finisher *get_aio_finisher() {
 107     return m_aio_finisher;
 108   }
 109   TestWatchNotify *get_watch_notify() {
 110     return m_watch_notify;
 111   }
 112
 113   void add_aio_operation(const std::string& oid, bool queue_callback,
 114                          const AioFunction &aio_function, AioCompletionImpl *c);
 115   void flush_aio_operations();
 116   void flush_aio_operations(AioCompletionImpl *c);
 117
 118   void finish_aio_completion(AioCompletionImpl *c, int r);
 119
 120 protected:
 121   virtual ~TestRadosClient();
 122
 123   virtual void transaction_start(const std::string& nspace,
 124                                  const std::string &oid) = 0;
 125   virtual void transaction_finish(const std::string& nspace,
 126                                   const std::string &oid) = 0;
 127
 128 private:
 129
 130   CephContext *m_cct;
 131   std::atomic<uint64_t> m_refcount = { 0 };
 132
 133   TestWatchNotify *m_watch_notify;
 134
 135   Finisher *get_finisher(const std::string& oid);
 136
 137   Finisher *m_aio_finisher;
 138   std::vector<Finisher *> m_finishers;
 139   boost::hash<std::string> m_hash;
 140
 141 };
 142
 143 } // namespace librados
 144
 145 #endif // CEPH_TEST_RADOS_CLIENT_H