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