ceph/src/rgw/services/svc_meta_be.cc

   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
   5 #include "svc_meta_be.h"
   6
   7 #include "rgw_mdlog.h"
   8
   9 #define dout_subsys ceph_subsys_rgw
  10
  11 using namespace std;
  12
  13 RGWSI_MetaBackend::Context::~Context() {} // needed, even though destructor is pure virtual
  14 RGWSI_MetaBackend::Module::~Module() {} // ditto
  15 RGWSI_MetaBackend::PutParams::~PutParams() {} // ...
  16 RGWSI_MetaBackend::GetParams::~GetParams() {} // ...
  17 RGWSI_MetaBackend::RemoveParams::~RemoveParams() {} // ...
  18
  19 int RGWSI_MetaBackend::pre_modify(const DoutPrefixProvider *dpp,
  20                                   RGWSI_MetaBackend::Context *ctx,
  21                                   const string& key,
  22                                   RGWMetadataLogData& log_data,
  23                                   RGWObjVersionTracker *objv_tracker,
  24                                   RGWMDLogStatus op_type,
  25                                   optional_yield y)
  26 {
  27   /* if write version has not been set, and there's a read version, set it so that we can
  28    * log it
  29    */
  30   if (objv_tracker &&
  31       objv_tracker->read_version.ver && !objv_tracker->write_version.ver) {
  32     objv_tracker->write_version = objv_tracker->read_version;
  33     objv_tracker->write_version.ver++;
  34   }
  35
  36   return 0;
  37 }
  38
  39 int RGWSI_MetaBackend::post_modify(const DoutPrefixProvider *dpp,
  40                                    RGWSI_MetaBackend::Context *ctx,
  41                                    const string& key,
  42                                    RGWMetadataLogData& log_data,
  43                                    RGWObjVersionTracker *objv_tracker, int ret,
  44                                    optional_yield y)
  45 {
  46   return ret;
  47 }
  48
  49 int RGWSI_MetaBackend::prepare_mutate(RGWSI_MetaBackend::Context *ctx,
  50                                       const string& key,
  51                                       const real_time& mtime,
  52                                       RGWObjVersionTracker *objv_tracker,
  53                                       optional_yield y,
  54                                       const DoutPrefixProvider *dpp)
  55 {
  56   real_time orig_mtime;
  57
  58   int ret = call_with_get_params(&orig_mtime, [&](GetParams& params) {
  59     return get_entry(ctx, key, params, objv_tracker, y, dpp);
  60   });
  61   if (ret < 0 && ret != -ENOENT) {
  62     return ret;
  63   }
  64
  65   if (objv_tracker->write_version.tag.empty()) {
  66     if (objv_tracker->read_version.tag.empty()) {
  67       objv_tracker->generate_new_write_ver(cct);
  68     } else {
  69       objv_tracker->write_version = objv_tracker->read_version;
  70       objv_tracker->write_version.ver++;
  71     }
  72   }
  73   return 0;
  74 }
  75
  76 int RGWSI_MetaBackend::do_mutate(RGWSI_MetaBackend::Context *ctx,
  77                                  const string& key,
  78                                  const ceph::real_time& mtime,
  79                                  RGWObjVersionTracker *objv_tracker,
  80                                  RGWMDLogStatus op_type,
  81                                  optional_yield y,
  82                                  std::function<int()> f,
  83                                  bool generic_prepare,
  84                                  const DoutPrefixProvider *dpp)
  85 {
  86   int ret;
  87
  88   if (generic_prepare) {
  89     ret = prepare_mutate(ctx, key, mtime, objv_tracker, y, dpp);
  90     if (ret < 0 ||
  91         ret == STATUS_NO_APPLY) {
  92       return ret;
  93     }
  94   }
  95
  96   RGWMetadataLogData log_data;
  97   ret = pre_modify(dpp, ctx, key, log_data, objv_tracker, op_type, y);
  98   if (ret < 0) {
  99     return ret;
 100   }
 101
 102   ret = f();
 103
 104   /* cascading ret into post_modify() */
 105
 106   ret = post_modify(dpp, ctx, key, log_data, objv_tracker, ret, y);
 107   if (ret < 0)
 108     return ret;
 109
 110   return 0;
 111 }
 112
 113 int RGWSI_MetaBackend::get(Context *ctx,
 114                            const string& key,
 115                            GetParams& params,
 116                            RGWObjVersionTracker *objv_tracker,
 117                            optional_yield y,
 118                            const DoutPrefixProvider *dpp,
 119                            bool get_raw_attrs)
 120 {
 121   return get_entry(ctx, key, params, objv_tracker, y, dpp, get_raw_attrs);
 122 }
 123
 124 int RGWSI_MetaBackend::put(Context *ctx,
 125                            const string& key,
 126                            PutParams& params,
 127                            RGWObjVersionTracker *objv_tracker,
 128                            optional_yield y,
 129                            const DoutPrefixProvider *dpp)
 130 {
 131   std::function<int()> f = [&]() {
 132     return put_entry(dpp, ctx, key, params, objv_tracker, y);
 133   };
 134
 135   return do_mutate(ctx, key, params.mtime, objv_tracker,
 136                 MDLOG_STATUS_WRITE,
 137                 y,
 138                 f,
 139                 false,
 140                 dpp);
 141 }
 142
 143 int RGWSI_MetaBackend::remove(Context *ctx,
 144                               const string& key,
 145                               RemoveParams& params,
 146                               RGWObjVersionTracker *objv_tracker,
 147                               optional_yield y,
 148                               const DoutPrefixProvider *dpp)
 149 {
 150   std::function<int()> f = [&]() {
 151     return remove_entry(dpp, ctx, key, params, objv_tracker, y);
 152   };
 153
 154   return do_mutate(ctx, key, params.mtime, objv_tracker,
 155                 MDLOG_STATUS_REMOVE,
 156                 y,
 157                 f,
 158                 false,
 159                 dpp);
 160 }
 161
 162 int RGWSI_MetaBackend::mutate(Context *ctx,
 163                               const std::string& key,
 164                               MutateParams& params,
 165                               RGWObjVersionTracker *objv_tracker,
 166                               optional_yield y,
 167                               std::function<int()> f,
 168                               const DoutPrefixProvider *dpp)
 169 {
 170   return do_mutate(ctx, key, params.mtime, objv_tracker,
 171                    params.op_type, y,
 172                    f,
 173                    false,
 174                    dpp);
 175 }
 176
 177 int RGWSI_MetaBackend_Handler::call(std::optional<RGWSI_MetaBackend_CtxParams> bectx_params,
 178                                     std::function<int(Op *)> f)
 179 {
 180   return be->call(bectx_params, [&](RGWSI_MetaBackend::Context *ctx) {
 181     ctx->init(this);
 182     Op op(be, ctx);
 183     return f(&op);
 184   });
 185 }
 186
 187 RGWSI_MetaBackend_Handler::Op_ManagedCtx::Op_ManagedCtx(RGWSI_MetaBackend_Handler *handler) : Op(handler->be, handler->be->alloc_ctx())
 188 {
 189   auto c = ctx();
 190   c->init(handler);
 191   pctx.reset(c);
 192 }
 193