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