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