src/ceph/src/kv/KineticStore.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 #ifndef KINETIC_STORE_H
   4 #define KINETIC_STORE_H
   5
   6 #include "include/types.h"
   7 #include "include/buffer_fwd.h"
   8 #include "KeyValueDB.h"
   9 #include <set>
  10 #include <map>
  11 #include <string>
  12 #include "include/memory.h"
  13 #include <kinetic/kinetic.h>
  14
  15 #include <errno.h>
  16 #include "common/errno.h"
  17 #include "common/dout.h"
  18 #include "include/assert.h"
  19 #include "common/Formatter.h"
  20
  21 #include "common/ceph_context.h"
  22
  23 class PerfCounters;
  24
  25 enum {
  26   l_kinetic_first = 34400,
  27   l_kinetic_gets,
  28   l_kinetic_txns,
  29   l_kinetic_last,
  30 };
  31
  32 /**
  33  * Uses Kinetic to implement the KeyValueDB interface
  34  */
  35 class KineticStore : public KeyValueDB {
  36   CephContext *cct;
  37   PerfCounters *logger;
  38   string host;
  39   int port;
  40   int user_id;
  41   string hmac_key;
  42   bool use_ssl;
  43   std::unique_ptr<kinetic::BlockingKineticConnection> kinetic_conn;
  44
  45   int do_open(ostream &out, bool create_if_missing);
  46
  47 public:
  48   explicit KineticStore(CephContext *c);
  49   ~KineticStore();
  50
  51   static int _test_init(CephContext *c);
  52   int init();
  53
  54   /// Opens underlying db
  55   int open(ostream &out) {
  56     return do_open(out, false);
  57   }
  58   /// Creates underlying db if missing and opens it
  59   int create_and_open(ostream &out) {
  60     return do_open(out, true);
  61   }
  62
  63   void close();
  64
  65   enum KineticOpType {
  66     KINETIC_OP_WRITE,
  67     KINETIC_OP_DELETE,
  68   };
  69
  70   struct KineticOp {
  71     KineticOpType type;
  72     std::string key;
  73     bufferlist data;
  74     KineticOp(KineticOpType type, const string &key) : type(type), key(key) {}
  75     KineticOp(KineticOpType type, const string &key, const bufferlist &data)
  76       : type(type), key(key), data(data) {}
  77   };
  78
  79   class KineticTransactionImpl : public KeyValueDB::TransactionImpl {
  80   public:
  81     vector<KineticOp> ops;
  82     KineticStore *db;
  83
  84     explicit KineticTransactionImpl(KineticStore *db) : db(db) {}
  85     void set(
  86       const string &prefix,
  87       const string &k,
  88       const bufferlist &bl);
  89     void rmkey(
  90       const string &prefix,
  91       const string &k);
  92     void rmkeys_by_prefix(
  93       const string &prefix
  94       );
  95     void rm_range_keys(
  96         const string &prefix,
  97         const string &start,
  98         const string &end);
  99   };
 100
 101   KeyValueDB::Transaction get_transaction() {
 102     return std::make_shared<KineticTransactionImpl>(this);
 103   }
 104
 105   int submit_transaction(KeyValueDB::Transaction t);
 106   int submit_transaction_sync(KeyValueDB::Transaction t);
 107   int get(
 108     const string &prefix,
 109     const std::set<string> &key,
 110     std::map<string, bufferlist> *out
 111     );
 112   using KeyValueDB::get;
 113
 114   class KineticWholeSpaceIteratorImpl :
 115     public KeyValueDB::WholeSpaceIteratorImpl {
 116     std::set<std::string> keys;
 117     std::set<std::string>::iterator keys_iter;
 118     kinetic::BlockingKineticConnection *kinetic_conn;
 119     kinetic::KineticStatus kinetic_status;
 120   public:
 121     explicit KineticWholeSpaceIteratorImpl(kinetic::BlockingKineticConnection *conn);
 122     virtual ~KineticWholeSpaceIteratorImpl() { }
 123
 124     int seek_to_first() {
 125       return seek_to_first("");
 126     }
 127     int seek_to_first(const string &prefix);
 128     int seek_to_last();
 129     int seek_to_last(const string &prefix);
 130     int upper_bound(const string &prefix, const string &after);
 131     int lower_bound(const string &prefix, const string &to);
 132     bool valid();
 133     int next();
 134     int prev();
 135     string key();
 136     pair<string,string> raw_key();
 137     bool raw_key_is_prefixed(const string &prefix);
 138     bufferlist value();
 139     int status();
 140   };
 141
 142   /// Utility
 143   static string combine_strings(const string &prefix, const string &value);
 144   static int split_key(string &in_prefix, string *prefix, string *key);
 145   static bufferlist to_bufferlist(const kinetic::KineticRecord &record);
 146   virtual uint64_t get_estimated_size(map<string,uint64_t> &extra) {
 147     // not used by the osd
 148     return 0;
 149   }
 150
 151
 152 protected:
 153   WholeSpaceIterator _get_iterator() {
 154     return std::make_shared<KineticWholeSpaceIteratorImpl>(kinetic_conn.get());
 155   }
 156 };
 157
 158 #endif