ceph/src/rgw/rgw_metadata.h

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab ft=cpp
   3
   4 #ifndef CEPH_RGW_METADATA_H
   5 #define CEPH_RGW_METADATA_H
   6
   7 #include <string>
   8 #include <utility>
   9 #include <boost/optional.hpp>
  10
  11 #include "include/types.h"
  12 #include "rgw_common.h"
  13 #include "rgw_period_history.h"
  14 #include "rgw_mdlog_types.h"
  15 #include "cls/version/cls_version_types.h"
  16 #include "cls/log/cls_log_types.h"
  17 #include "common/RefCountedObj.h"
  18 #include "common/ceph_time.h"
  19 #include "services/svc_meta_be.h"
  20
  21
  22 namespace rgw { namespace sal {
  23 class Store;
  24 } }
  25 class RGWCoroutine;
  26 class JSONObj;
  27 struct RGWObjVersionTracker;
  28
  29 struct obj_version;
  30
  31
  32 class RGWMetadataObject {
  33 protected:
  34   obj_version objv;
  35   ceph::real_time mtime;
  36   std::map<std::string, bufferlist> *pattrs{nullptr};
  37
  38 public:
  39   RGWMetadataObject() {}
  40   virtual ~RGWMetadataObject() {}
  41   obj_version& get_version();
  42   real_time& get_mtime() { return mtime; }
  43   void set_pattrs(std::map<std::string, bufferlist> *_pattrs) {
  44     pattrs = _pattrs;
  45   }
  46   std::map<std::string, bufferlist> *get_pattrs() {
  47     return pattrs;
  48   }
  49
  50   virtual void dump(Formatter *f) const {}
  51 };
  52
  53 class RGWMetadataManager;
  54
  55 class RGWMetadataHandler {
  56   friend class RGWMetadataManager;
  57
  58 protected:
  59   CephContext *cct;
  60
  61 public:
  62   RGWMetadataHandler() {}
  63   virtual ~RGWMetadataHandler() {}
  64   virtual std::string get_type() = 0;
  65
  66   void base_init(CephContext *_cct) {
  67     cct = _cct;
  68   }
  69
  70   virtual RGWMetadataObject *get_meta_obj(JSONObj *jo, const obj_version& objv, const ceph::real_time& mtime) = 0;
  71
  72   virtual int get(std::string& entry, RGWMetadataObject **obj, optional_yield, const DoutPrefixProvider *dpp) = 0;
  73   virtual int put(std::string& entry,
  74                   RGWMetadataObject *obj,
  75                   RGWObjVersionTracker& objv_tracker,
  76                   optional_yield,
  77                   const DoutPrefixProvider *dpp,
  78                   RGWMDLogSyncType type,
  79                   bool from_remote_zone) = 0;
  80   virtual int remove(std::string& entry, RGWObjVersionTracker& objv_tracker, optional_yield, const DoutPrefixProvider *dpp) = 0;
  81
  82   virtual int mutate(const std::string& entry,
  83                      const ceph::real_time& mtime,
  84                      RGWObjVersionTracker *objv_tracker,
  85                      optional_yield y,
  86                      const DoutPrefixProvider *dpp,
  87                      RGWMDLogStatus op_type,
  88                      std::function<int()> f) = 0;
  89
  90   virtual int list_keys_init(const DoutPrefixProvider *dpp, const std::string& marker, void **phandle) = 0;
  91   virtual int list_keys_next(const DoutPrefixProvider *dpp, void *handle, int max, std::list<std::string>& keys, bool *truncated) = 0;
  92   virtual void list_keys_complete(void *handle) = 0;
  93
  94   virtual std::string get_marker(void *handle) = 0;
  95
  96   virtual int get_shard_id(const std::string& entry, int *shard_id) {
  97     *shard_id = 0;
  98     return 0;
  99   }
 100   virtual int attach(RGWMetadataManager *manager);
 101 };
 102
 103 class RGWMetadataHandler_GenericMetaBE : public RGWMetadataHandler {
 104   friend class RGWSI_MetaBackend;
 105   friend class RGWMetadataManager;
 106   friend class Put;
 107
 108 public:
 109   class Put;
 110
 111 protected:
 112   RGWSI_MetaBackend_Handler *be_handler;
 113
 114   virtual int do_get(RGWSI_MetaBackend_Handler::Op *op, std::string& entry, RGWMetadataObject **obj, optional_yield y, const DoutPrefixProvider *dpp) = 0;
 115   virtual int do_put(RGWSI_MetaBackend_Handler::Op *op, std::string& entry, RGWMetadataObject *obj,
 116                      RGWObjVersionTracker& objv_tracker, optional_yield y,
 117                      const DoutPrefixProvider *dpp, RGWMDLogSyncType type,
 118                      bool from_remote_zone) = 0;
 119   virtual int do_put_operate(Put *put_op, const DoutPrefixProvider *dpp);
 120   virtual int do_remove(RGWSI_MetaBackend_Handler::Op *op, std::string& entry, RGWObjVersionTracker& objv_tracker, optional_yield y, const DoutPrefixProvider *dpp) = 0;
 121
 122 public:
 123   RGWMetadataHandler_GenericMetaBE() {}
 124
 125   void base_init(CephContext *_cct,
 126             RGWSI_MetaBackend_Handler *_be_handler) {
 127     RGWMetadataHandler::base_init(_cct);
 128     be_handler = _be_handler;
 129   }
 130
 131   RGWSI_MetaBackend_Handler *get_be_handler() {
 132     return be_handler;
 133   }
 134
 135   class Put {
 136   protected:
 137     RGWMetadataHandler_GenericMetaBE *handler;
 138     RGWSI_MetaBackend_Handler::Op *op;
 139     std::string& entry;
 140     RGWMetadataObject *obj;
 141     RGWObjVersionTracker& objv_tracker;
 142     RGWMDLogSyncType apply_type;
 143     optional_yield y;
 144     bool from_remote_zone{false};
 145
 146     int get(RGWMetadataObject **obj, const DoutPrefixProvider *dpp) {
 147       return handler->do_get(op, entry, obj, y, dpp);
 148     }
 149   public:
 150     Put(RGWMetadataHandler_GenericMetaBE *_handler, RGWSI_MetaBackend_Handler::Op *_op,
 151         std::string& _entry, RGWMetadataObject *_obj,
 152         RGWObjVersionTracker& _objv_tracker, optional_yield _y,
 153         RGWMDLogSyncType _type, bool from_remote_zone);
 154
 155     virtual ~Put() {}
 156
 157     virtual int put_pre(const DoutPrefixProvider *dpp) {
 158       return 0;
 159     }
 160     virtual int put(const DoutPrefixProvider *dpp) {
 161       return 0;
 162     }
 163     virtual int put_post(const DoutPrefixProvider *dpp) {
 164       return 0;
 165     }
 166     virtual int finalize() {
 167       return 0;
 168     }
 169   };
 170
 171   int get(std::string& entry, RGWMetadataObject **obj, optional_yield, const DoutPrefixProvider *dpp) override;
 172   int put(std::string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker, optional_yield, const DoutPrefixProvider *dpp, RGWMDLogSyncType type, bool from_remote_zone) override;
 173   int remove(std::string& entry, RGWObjVersionTracker& objv_tracker, optional_yield, const DoutPrefixProvider *dpp) override;
 174
 175   int mutate(const std::string& entry,
 176              const ceph::real_time& mtime,
 177              RGWObjVersionTracker *objv_tracker,
 178              optional_yield y,
 179              const DoutPrefixProvider *dpp,
 180              RGWMDLogStatus op_type,
 181              std::function<int()> f) override;
 182
 183   int get_shard_id(const std::string& entry, int *shard_id) override;
 184
 185   int list_keys_init(const DoutPrefixProvider *dpp, const std::string& marker, void **phandle) override;
 186   int list_keys_next(const DoutPrefixProvider *dpp, void *handle, int max, std::list<std::string>& keys, bool *truncated) override;
 187   void list_keys_complete(void *handle) override;
 188
 189   std::string get_marker(void *handle) override;
 190
 191   /**
 192    * Compare an incoming versus on-disk tag/version+mtime combo against
 193    * the sync mode to see if the new one should replace the on-disk one.
 194    *
 195    * @return true if the update should proceed, false otherwise.
 196    */
 197   static bool check_versions(bool exists,
 198                              const obj_version& ondisk, const real_time& ondisk_time,
 199                              const obj_version& incoming, const real_time& incoming_time,
 200                              RGWMDLogSyncType sync_mode) {
 201     switch (sync_mode) {
 202     case APPLY_UPDATES:
 203       if ((ondisk.tag != incoming.tag) ||
 204           (ondisk.ver >= incoming.ver))
 205         return false;
 206       break;
 207     case APPLY_NEWER:
 208       if (ondisk_time >= incoming_time)
 209         return false;
 210       break;
 211     case APPLY_EXCLUSIVE:
 212       if (exists)
 213         return false;
 214       break;
 215     case APPLY_ALWAYS: //deliberate fall-thru -- we always apply!
 216     default: break;
 217     }
 218     return true;
 219   }
 220 };
 221
 222 class RGWMetadataTopHandler;
 223
 224 class RGWMetadataManager {
 225   friend class RGWMetadataHandler;
 226
 227   CephContext *cct;
 228   RGWSI_Meta *meta_svc;
 229   std::map<std::string, RGWMetadataHandler *> handlers;
 230   std::unique_ptr<RGWMetadataTopHandler> md_top_handler;
 231
 232   int find_handler(const std::string& metadata_key, RGWMetadataHandler **handler, std::string& entry);
 233   int register_handler(RGWMetadataHandler *handler);
 234
 235 public:
 236   RGWMetadataManager(RGWSI_Meta *_meta_svc);
 237   ~RGWMetadataManager();
 238
 239   RGWMetadataHandler *get_handler(const std::string& type);
 240
 241   int get(std::string& metadata_key, Formatter *f, optional_yield y, const DoutPrefixProvider *dpp);
 242   int put(std::string& metadata_key, bufferlist& bl, optional_yield y,
 243           const DoutPrefixProvider *dpp,
 244           RGWMDLogSyncType sync_mode,
 245           bool from_remote_zone,
 246           obj_version *existing_version = NULL);
 247   int remove(std::string& metadata_key, optional_yield y, const DoutPrefixProvider *dpp);
 248
 249   int mutate(const std::string& metadata_key,
 250              const ceph::real_time& mtime,
 251              RGWObjVersionTracker *objv_tracker,
 252              optional_yield y,
 253              const DoutPrefixProvider *dpp,
 254              RGWMDLogStatus op_type,
 255              std::function<int()> f);
 256
 257   int list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, void **phandle);
 258   int list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, const std::string& marker, void **phandle);
 259   int list_keys_next(const DoutPrefixProvider *dpp, void *handle, int max, std::list<std::string>& keys, bool *truncated);
 260   void list_keys_complete(void *handle);
 261
 262   std::string get_marker(void *handle);
 263
 264   void dump_log_entry(cls_log_entry& entry, Formatter *f);
 265
 266   void get_sections(std::list<std::string>& sections);
 267
 268   void parse_metadata_key(const std::string& metadata_key, std::string& type, std::string& entry);
 269
 270   int get_shard_id(const std::string& section, const std::string& key, int *shard_id);
 271 };
 272
 273 class RGWMetadataHandlerPut_SObj : public RGWMetadataHandler_GenericMetaBE::Put
 274 {
 275 protected:
 276   std::unique_ptr<RGWMetadataObject> oo;
 277   RGWMetadataObject *old_obj{nullptr};
 278   bool exists{false};
 279
 280 public:
 281   RGWMetadataHandlerPut_SObj(RGWMetadataHandler_GenericMetaBE *handler, RGWSI_MetaBackend_Handler::Op *op,
 282                              std::string& entry, RGWMetadataObject *obj, RGWObjVersionTracker& objv_tracker,
 283                              optional_yield y,
 284                              RGWMDLogSyncType type, bool from_remote_zone);
 285   ~RGWMetadataHandlerPut_SObj();
 286
 287   int put_pre(const DoutPrefixProvider *dpp) override;
 288   int put(const DoutPrefixProvider *dpp) override;
 289   virtual int put_check(const DoutPrefixProvider *dpp) {
 290     return 0;
 291   }
 292   virtual int put_checked(const DoutPrefixProvider *dpp);
 293   virtual void encode_obj(bufferlist *bl) {}
 294 };
 295
 296
 297 #endif