// XXX fix this
s->cio = io;
- RGWObjectCtx rados_ctx(store, s); // XXX holds std::map
-
/* XXX and -then- stash req_state pointers everywhere they are needed */
- ret = req->init(rgw_env, &rados_ctx, io, s);
+ ret = req->init(rgw_env, store, io, s);
if (ret < 0) {
ldpp_dout(op, 10) << "failed to initialize request" << dendl;
abort_req(s, op, ret);
struct req_state* s = req->get_state();
RGWLibIO& io_ctx = req->get_io();
RGWEnv& rgw_env = io_ctx.get_env();
- RGWObjectCtx& rados_ctx = req->get_octx();
rgw_env.set("HTTP_HOST", "");
- int ret = req->init(rgw_env, &rados_ctx, &io_ctx, s);
+ int ret = req->init(rgw_env, store, &io_ctx, s);
if (ret < 0) {
ldpp_dout(op, 10) << "failed to initialize request" << dendl;
abort_req(s, op, ret);
int check_min_obj_stripe_size(rgw::sal::Store* store, rgw::sal::Object* obj, uint64_t min_stripe_size, bool *need_rewrite)
{
- RGWObjectCtx obj_ctx(store);
- int ret = obj->get_obj_attrs(&obj_ctx, null_yield, dpp());
+ int ret = obj->get_obj_attrs(null_yield, dpp());
if (ret < 0) {
ldpp_dout(dpp(), -1) << "ERROR: failed to stat object, returned error: " << cpp_strerror(-ret) << dendl;
return ret;
f->dump_string("oid", oid);
f->dump_string("locator", locator);
- RGWObjectCtx obj_ctx(store);
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op = obj->get_read_op(&obj_ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op = obj->get_read_op();
int ret = read_op->prepare(null_yield, dpp());
bool needs_fixing = (ret == -ENOENT);
map<uint64_t, vector<rgw_bucket_olh_log_entry> > log;
bool is_truncated;
- RGWObjectCtx rctx(store);
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(object);
RGWObjState *state;
- ret = obj->get_obj_state(dpp(), &rctx, &state, null_yield);
+ ret = obj->get_obj_state(dpp(), &state, null_yield);
if (ret < 0) {
return -ret;
}
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(object);
obj->set_instance(object_version);
- RGWObjectCtx obj_ctx(store);
-
- ret = obj->get_obj_attrs(&obj_ctx, null_yield, dpp());
+ ret = obj->get_obj_attrs(null_yield, dpp());
if (ret < 0) {
cerr << "ERROR: failed to stat object, returned error: " << cpp_strerror(-ret) << std::endl;
return 1;
int rgw_remove_object(const DoutPrefixProvider *dpp, rgw::sal::Store* store, rgw::sal::Bucket* bucket, rgw_obj_key& key)
{
- RGWObjectCtx rctx(store);
-
if (key.instance.empty()) {
key.instance = "null";
}
std::unique_ptr<rgw::sal::Object> object = bucket->get_object(key);
- return object->delete_object(dpp, &rctx, null_yield);
+ return object->delete_object(dpp, null_yield);
}
static void set_err_msg(std::string *sink, std::string msg)
rgw::sal::Store* store, rgw::sal::Object* obj,
const char* attr_name, bufferlist& out_bl, optional_yield y)
{
- RGWObjectCtx obj_ctx(store);
- std::unique_ptr<rgw::sal::Object::ReadOp> rop = obj->get_read_op(&obj_ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> rop = obj->get_read_op();
return rop->get_attr(dpp, attr_name, out_bl, y);
}
for (const auto& obj : results.objs) {
std::unique_ptr<rgw::sal::Object> r_obj = bucket->get_object(obj.key);
- ret = r_obj->get_obj_attrs(&obj_ctx, y, dpp);
+ ret = r_obj->get_obj_attrs(y, dpp);
if (ret < 0){
ldpp_dout(dpp, 0) << "ERROR: failed to read object " << obj.key.name << cpp_strerror(-ret) << dendl;
continue;
bl.clear();
encode(policy, bl);
- r_obj->set_atomic(&obj_ctx);
+ r_obj->set_atomic();
map<string, bufferlist> attrs;
attrs[RGW_ATTR_ACL] = bl;
- ret = r_obj->set_obj_attrs(dpp, &obj_ctx, &attrs, nullptr, y);
+ ret = r_obj->set_obj_attrs(dpp, &attrs, nullptr, y);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: modify attr failed " << cpp_strerror(-ret) << dendl;
return ret;
Clock::duration time_elapsed() const { return Clock::now() - time; }
- RGWObjectCtx *obj_ctx{nullptr};
std::string dialect;
std::string req_id;
std::string trans_id;
rgw_obj(const rgw_bucket& b, const rgw_obj_key& k) : bucket(b), key(k) {}
rgw_obj(const rgw_bucket& b, const rgw_obj_index_key& k) : bucket(b), key(k) {}
+ void init(const rgw_bucket& b, const rgw_obj_key& k) {
+ bucket = b;
+ key = k;
+ }
void init(const rgw_bucket& b, const std::string& name) {
bucket = b;
key.set(name);
int RGWAsyncRemoveObj::_send_request(const DoutPrefixProvider *dpp)
{
- RGWObjectCtx obj_ctx(store);
-
- rgw_obj obj(bucket_info.bucket, key);
-
ldpp_dout(dpp, 0) << __func__ << "(): deleting obj=" << obj << dendl;
- obj_ctx.set_atomic(obj);
+ obj->set_atomic();
RGWObjState *state;
- int ret = store->getRados()->get_obj_state(dpp, &obj_ctx, bucket_info, obj, &state, null_yield);
+ int ret = obj->get_obj_state(dpp, &state, null_yield);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << "(): get_obj_state() obj=" << obj << " returned ret=" << ret << dendl;
return ret;
}
}
- RGWRados::Object del_target(store->getRados(), bucket_info, obj_ctx, obj);
- RGWRados::Object::Delete del_op(&del_target);
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op();
- del_op.params.bucket_owner = bucket_info.owner;
- del_op.params.obj_owner = policy.get_owner();
+ del_op->params.bucket_owner = bucket->get_info().owner;
+ del_op->params.obj_owner = policy.get_owner();
if (del_if_older) {
- del_op.params.unmod_since = timestamp;
+ del_op->params.unmod_since = timestamp;
}
if (versioned) {
- del_op.params.versioning_status = BUCKET_VERSIONED;
+ del_op->params.versioning_status = BUCKET_VERSIONED;
}
- del_op.params.olh_epoch = versioned_epoch;
- del_op.params.marker_version_id = marker_version_id;
- del_op.params.obj_owner.set_id(rgw_user(owner));
- del_op.params.obj_owner.set_name(owner_display_name);
- del_op.params.mtime = timestamp;
- del_op.params.high_precision_time = true;
- del_op.params.zones_trace = &zones_trace;
+ del_op->params.olh_epoch = versioned_epoch;
+ del_op->params.marker_version_id = marker_version_id;
+ del_op->params.obj_owner.set_id(rgw_user(owner));
+ del_op->params.obj_owner.set_name(owner_display_name);
+ del_op->params.mtime = timestamp;
+ del_op->params.high_precision_time = true;
+ del_op->params.zones_trace = &zones_trace;
- ret = del_op.delete_obj(null_yield, dpp);
+ ret = del_op->delete_obj(dpp, null_yield);
if (ret < 0) {
ldpp_dout(dpp, 20) << __func__ << "(): delete_obj() obj=" << obj << " returned ret=" << ret << dendl;
}
rgw::sal::RadosStore* store;
rgw_zone_id source_zone;
- RGWBucketInfo bucket_info;
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ std::unique_ptr<rgw::sal::Object> obj;
- rgw_obj_key key;
std::string owner;
std::string owner_display_name;
bool versioned;
real_time& _timestamp,
rgw_zone_set* _zones_trace) : RGWAsyncRadosRequest(caller, cn), dpp(_dpp), store(_store),
source_zone(_source_zone),
- bucket_info(_bucket_info),
- key(_key),
owner(_owner),
owner_display_name(_owner_display_name),
versioned(_versioned),
del_if_older(_if_older),
timestamp(_timestamp) {
if (_delete_marker) {
- marker_version_id = key.instance;
+ marker_version_id = _key.instance;
}
if (_zones_trace) {
zones_trace = *_zones_trace;
}
+ store->get_bucket(nullptr, _bucket_info, &bucket);
+ obj = bucket->get_object(_key);
}
};
}
}
processor = get_store()->get_atomic_writer(this, state->yield, state->object->clone(),
- state->bucket_owner.get_id(), *state->obj_ctx,
+ state->bucket_owner.get_id(),
&state->dest_placement, 0, state->req_id);
op_ret = processor->prepare(state->yield);
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
int rc = valid_s3_object_name(obj_name);
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
virtual int op_init() {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
virtual int op_init() {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
int op_init() override {
// assign store, s, and dialect_handler
- RGWObjectCtx* rados_ctx
- = static_cast<RGWObjectCtx*>(get_state()->obj_ctx);
// framework promises to call op_init after parent init
- ceph_assert(rados_ctx);
- RGWOp::init(rados_ctx->get_store(), get_state(), this);
+ RGWOp::init(RGWHandler::store, get_state(), this);
op = this; // assign self as op: REQUIRED
return 0;
}
return (timediff >= cmp);
}
-static bool pass_object_lock_check(rgw::sal::Store* store, rgw::sal::Object* obj, RGWObjectCtx& ctx, const DoutPrefixProvider *dpp)
+static bool pass_object_lock_check(rgw::sal::Store* store, rgw::sal::Object* obj, const DoutPrefixProvider *dpp)
{
if (!obj->get_bucket()->get_info().obj_lock_enabled()) {
return true;
}
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op = obj->get_read_op(&ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op = obj->get_read_op();
int ret = read_op->prepare(null_yield, dpp);
if (ret < 0) {
if (ret == -ENOENT) {
obj = bucket->get_object(obj_key);
std::unique_ptr<rgw::sal::Object::DeleteOp> del_op
- = obj->get_delete_op(&oc.rctx);
+ = obj->get_delete_op();
del_op->params.versioning_status
= obj->get_bucket()->get_info().versioning_status();
del_op->params.obj_owner.set_id(rgw_user {meta.owner});
del_op->params.marker_version_id = version_id;
std::unique_ptr<rgw::sal::Notification> notify
- = store->get_notification(dpp, obj.get(), nullptr, &oc.rctx, event_type,
+ = store->get_notification(dpp, obj.get(), nullptr, event_type,
bucket.get(), lc_id,
const_cast<std::string&>(oc.bucket->get_tenant()),
lc_req_id, null_yield);
if (obj_has_expired(this, cct, obj.meta.mtime, rule.mp_expiration)) {
rgw_obj_key key(obj.key);
std::unique_ptr<rgw::sal::MultipartUpload> mpu = target->get_multipart_upload(key.name);
- RGWObjectCtx rctx(store);
- int ret = mpu->abort(this, cct, &rctx);
+ int ret = mpu->abort(this, cct);
if (ret == 0) {
if (perfcounter) {
perfcounter->inc(l_rgw_lc_abort_mpu, 1);
return 0;
}
-static int read_obj_tags(const DoutPrefixProvider *dpp, rgw::sal::Object* obj, RGWObjectCtx& ctx, bufferlist& tags_bl)
+static int read_obj_tags(const DoutPrefixProvider *dpp, rgw::sal::Object* obj, bufferlist& tags_bl)
{
- std::unique_ptr<rgw::sal::Object::ReadOp> rop = obj->get_read_op(&ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> rop = obj->get_read_op();
return rop->get_attr(dpp, RGW_ATTR_TAGS, tags_bl, null_yield);
}
*skip = true;
bufferlist tags_bl;
- int ret = read_obj_tags(dpp, oc.obj.get(), oc.rctx, tags_bl);
+ int ret = read_obj_tags(dpp, oc.obj.get(), tags_bl);
if (ret < 0) {
if (ret != -ENODATA) {
ldpp_dout(oc.dpp, 5) << "ERROR: read_obj_tags returned r="
<< oc.wq->thr_name() << dendl;
return is_expired &&
- pass_object_lock_check(oc.store, oc.obj.get(), oc.rctx, dpp);
+ pass_object_lock_check(oc.store, oc.obj.get(), dpp);
}
int process(lc_op_ctx& oc) {
real_time read_mtime;
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op(oc.obj->get_read_op(&oc.rctx));
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op(oc.obj->get_read_op());
read_op->params.lastmod = &read_mtime;
attrs = oc.obj->get_attrs();
+ /* TODO dang - need to replace this with something zipper */
rgw::sal::RadosStore *rados = static_cast<rgw::sal::RadosStore*>(oc.store);
- RGWRados::Object op_target(rados->getRados(), oc.bucket->get_info(), oc.rctx, oc.obj->get_obj());
+ RGWRados::Object op_target(rados->getRados(), oc.bucket, oc.rctx, oc.obj.get());
RGWRados::Object::Write obj_op(&op_target);
obj_op.meta.modify_tail = true;
S3RESTConn conn(oc.cct, oc.store, id, { endpoint }, key, region, host_style);
RGWLCCloudTierCtx tier_ctx(oc.cct, oc.dpp, oc.o, oc.store, oc.bucket->get_info(),
- oc.obj.get(), oc.rctx, conn, bucket_name,
+ oc.obj.get(), conn, bucket_name,
oc.tier.t.s3.target_storage_class);
tier_ctx.acl_mappings = oc.tier.t.s3.acl_mappings;
tier_ctx.multipart_min_part_size = oc.tier.t.s3.multipart_min_part_size;
if (!r && oc.tier.tier_type == "cloud-s3") {
ldpp_dout(oc.dpp, 30) << "Found cloud s3 tier: " << target_placement.storage_class << dendl;
if (!oc.o.is_current() &&
- !pass_object_lock_check(oc.store, oc.obj.get(), oc.rctx, oc.dpp)) {
+ !pass_object_lock_check(oc.store, oc.obj.get(), oc.dpp)) {
/* Skip objects which has object lock enabled. */
ldpp_dout(oc.dpp, 10) << "Object(key:" << oc.o.key << ") is locked. Skipping transition to cloud-s3 tier: " << target_placement.storage_class << dendl;
return 0;
return -EINVAL;
}
- int r = oc.obj->transition(oc.rctx, oc.bucket, target_placement, o.meta.mtime,
+ int r = oc.obj->transition(oc.bucket, target_placement, o.meta.mtime,
o.versioned_epoch, oc.dpp, null_yield);
if (r < 0) {
ldpp_dout(oc.dpp, 0) << "ERROR: failed to transition obj "
public:
RGWLCStreamRead(CephContext *_cct, const DoutPrefixProvider *_dpp,
- RGWObjectCtx& obj_ctx, rgw::sal::Object *_obj,
- const real_time &_mtime) :
+ rgw::sal::Object *_obj, const real_time &_mtime) :
cct(_cct), dpp(_dpp), obj(_obj), mtime(_mtime),
- read_op(obj->get_read_op(&obj_ctx)) {}
+ read_op(obj->get_read_op()) {}
~RGWLCStreamRead() {};
int set_range(off_t _ofs, off_t _end);
return -1;
}
- tier_ctx.obj->set_atomic(&tier_ctx.rctx);
+ tier_ctx.obj->set_atomic();
/* Prepare Read from source */
/* TODO: Define readf, writef as stack variables. For some reason,
*/
std::shared_ptr<RGWLCStreamRead> readf;
readf.reset(new RGWLCStreamRead(tier_ctx.cct, tier_ctx.dpp,
- tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime));
+ tier_ctx.obj, tier_ctx.o.meta.mtime));
std::shared_ptr<RGWLCCloudStreamPut> writef;
writef.reset(new RGWLCCloudStreamPut(tier_ctx.dpp, obj_properties, tier_ctx.conn,
return -1;
}
- tier_ctx.obj->set_atomic(&tier_ctx.rctx);
+ tier_ctx.obj->set_atomic();
/* TODO: Define readf, writef as stack variables. For some reason,
* when used as stack variables (esp., readf), the transition seems to
* be taking lot of time eventually erroring out at times. */
std::shared_ptr<RGWLCStreamRead> readf;
readf.reset(new RGWLCStreamRead(tier_ctx.cct, tier_ctx.dpp,
- tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime));
+ tier_ctx.obj, tier_ctx.o.meta.mtime));
std::shared_ptr<RGWLCCloudStreamPut> writef;
writef.reset(new RGWLCCloudStreamPut(tier_ctx.dpp, obj_properties, tier_ctx.conn,
}
if (ret == -ENOENT) {
- RGWLCStreamRead readf(tier_ctx.cct, tier_ctx.dpp, tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime);
+ RGWLCStreamRead readf(tier_ctx.cct, tier_ctx.dpp, tier_ctx.obj, tier_ctx.o.meta.mtime);
readf.init();
std::string storage_class;
rgw::sal::Object *obj;
- RGWObjectCtx& rctx;
/* Remote */
RGWRESTConn& conn;
RGWLCCloudTierCtx(CephContext* _cct, const DoutPrefixProvider *_dpp,
rgw_bucket_dir_entry& _o, rgw::sal::Store *_store,
RGWBucketInfo &_binfo, rgw::sal::Object *_obj,
- RGWObjectCtx& _rctx, RGWRESTConn& _conn, std::string& _bucket,
+ RGWRESTConn& _conn, std::string& _bucket,
std::string& _storage_class) :
cct(_cct), dpp(_dpp), o(_o), store(_store), bucket_info(_binfo),
- obj(_obj), rctx(_rctx), conn(_conn), target_bucket_name(_bucket),
+ obj(_obj), conn(_conn), target_bucket_name(_bucket),
target_storage_class(_storage_class) {}
};
using RGWHandler::init;
- int init(const RGWEnv& rgw_env, RGWObjectCtx* rados_ctx,
+ int init(const RGWEnv& rgw_env, rgw::sal::Store* _store,
RGWLibIO* io, struct req_state* _s) {
RGWRequest::init_state(_s);
- RGWHandler::init(rados_ctx->get_store(), _s, io);
+ RGWHandler::init(_store, _s, io);
- get_state()->obj_ctx = rados_ctx;
get_state()->req_id = store->zone_unique_id(id);
get_state()->trans_id = store->zone_unique_trans_id(id);
get_state()->bucket_tenant = tuser->get_tenant();
int ret = header_init();
if (ret == 0) {
- ret = init_from_header(rados_ctx->get_store(), _s);
+ ret = init_from_header(store, _s);
}
return ret;
}
class RGWLibContinuedReq : public RGWLibRequest {
RGWLibIO io_ctx;
struct req_state rstate;
- RGWObjectCtx rados_ctx;
public:
RGWLibContinuedReq(CephContext* _cct,
std::unique_ptr<rgw::sal::User> _user)
: RGWLibRequest(_cct, std::move(_user)), io_ctx(),
- rstate(_cct, &io_ctx.get_env(), id),
- rados_ctx(rgwlib.get_store(), &rstate)
+ rstate(_cct, &io_ctx.get_env(), id)
{
io_ctx.init(_cct);
RGWRequest::init_state(&rstate);
- RGWHandler::init(rados_ctx.get_store(), &rstate, &io_ctx);
+ RGWHandler::init(rgwlib.get_store(), &rstate, &io_ctx);
- get_state()->obj_ctx = &rados_ctx;
get_state()->req_id = store->zone_unique_id(id);
get_state()->trans_id = store->zone_unique_trans_id(id);
inline rgw::sal::Store* get_store() { return store; }
inline RGWLibIO& get_io() { return io_ctx; }
- inline RGWObjectCtx& get_octx() { return rados_ctx; }
virtual int execute() final { ceph_abort(); }
virtual int exec_start() = 0;
if (!src_obj->get_bucket()) {
src_obj->set_bucket(res.bucket);
}
- if (src_obj->get_obj_attrs(res.obj_ctx, res.yield, res.dpp) < 0) {
+ if (src_obj->get_obj_attrs(res.yield, res.dpp) < 0) {
return nullptr;
}
}
rgw::sal::Object* _object,
rgw::sal::Object* _src_object,
const std::string* _object_name) :
- dpp(_s), store(_store), s(_s), size(0) /* XXX */, obj_ctx(_s->obj_ctx),
+ dpp(_s), store(_store), s(_s), size(0) /* XXX */,
object(_object), src_object(_src_object), bucket(_s->bucket.get()),
object_name(_object_name),
tagset(_s->tagset),
reservation_t::reservation_t(const DoutPrefixProvider* _dpp,
rgw::sal::RadosStore* _store,
- RGWObjectCtx* _obj_ctx,
rgw::sal::Object* _object,
rgw::sal::Object* _src_object,
rgw::sal::Bucket* _bucket,
std::string& _req_id,
optional_yield y) :
dpp(_dpp), store(_store), s(nullptr), size(0) /* XXX */,
- obj_ctx(_obj_ctx),
object(_object), src_object(_src_object), bucket(_bucket),
object_name(nullptr),
user_id(_user_id),
rgw::sal::RadosStore* const store;
const req_state* const s;
size_t size;
- RGWObjectCtx* obj_ctx;
rgw::sal::Object* const object;
rgw::sal::Object* const src_object; // may differ from object
rgw::sal::Bucket* const bucket;
/* ctor for non-request caller (e.g., lifecycle) */
reservation_t(const DoutPrefixProvider* _dpp,
rgw::sal::RadosStore* _store,
- RGWObjectCtx* _obj_ctx,
rgw::sal::Object* _object,
rgw::sal::Object* _src_object,
rgw::sal::Bucket* _bucket,
};
};
WRITE_CLASS_ENCODER(RGWObjManifest)
-
-struct RGWObjState {
- rgw_obj obj;
- bool is_atomic{false};
- bool has_attrs{false};
- bool exists{false};
- uint64_t size{0}; //< size of raw object
- uint64_t accounted_size{0}; //< size before compression, encryption
- ceph::real_time mtime;
- uint64_t epoch{0};
- bufferlist obj_tag;
- bufferlist tail_tag;
- std::string write_tag;
- bool fake_tag{false};
- std::optional<RGWObjManifest> manifest;
- std::string shadow_obj;
- bool has_data{false};
- bufferlist data;
- bool prefetch_data{false};
- bool keep_tail{false};
- bool is_olh{false};
- bufferlist olh_tag;
- uint64_t pg_ver{false};
- uint32_t zone_short_id{0};
- bool compressed{false};
-
- /* important! don't forget to update copy constructor */
-
- RGWObjVersionTracker objv_tracker;
-
- std::map<std::string, bufferlist> attrset;
-
- RGWObjState();
- RGWObjState(const RGWObjState& rhs);
- ~RGWObjState();
-
- bool get_attr(std::string name, bufferlist& dest) {
- std::map<std::string, bufferlist>::iterator iter = attrset.find(name);
- if (iter != attrset.end()) {
- dest = iter->second;
- return true;
- }
- return false;
- }
-};
return ret;
}
- RGWObjectCtx rctx(store);
-
rgw_obj_key key = hint.obj_key;
if (key.instance.empty()) {
key.instance = "null";
}
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(key);
- obj->set_atomic(&rctx);
- ret = obj->delete_object(dpp, &rctx, null_yield);
+ obj->set_atomic();
+ ret = obj->delete_object(dpp, null_yield);
return ret;
}
static int get_obj_policy_from_attr(const DoutPrefixProvider *dpp,
CephContext *cct,
rgw::sal::Store* store,
- RGWObjectCtx& obj_ctx,
RGWBucketInfo& bucket_info,
map<string, bufferlist>& bucket_attrs,
RGWAccessControlPolicy *policy,
bufferlist bl;
int ret = 0;
- std::unique_ptr<rgw::sal::Object::ReadOp> rop = obj->get_read_op(&obj_ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> rop = obj->get_read_op();
ret = rop->get_attr(dpp, RGW_ATTR_ACL, bl, y);
if (ret >= 0) {
}
policy = get_iam_policy_from_attr(s->cct, bucket_attrs, bucket->get_tenant());
- RGWObjectCtx *obj_ctx = static_cast<RGWObjectCtx *>(s->obj_ctx);
- int ret = get_obj_policy_from_attr(dpp, s->cct, store, *obj_ctx,
- bucket_info, bucket_attrs, acl, storage_class, object, s->yield);
+ int ret = get_obj_policy_from_attr(dpp, s->cct, store, bucket_info,
+ bucket_attrs, acl, storage_class, object,
+ s->yield);
if (ret == -ENOENT) {
/* object does not exist checking the bucket's ACL to make sure
that we send a proper error code */
}
s->object_acl = std::make_unique<RGWAccessControlPolicy>(s->cct);
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
if (prefetch_data) {
- s->object->set_prefetch_data(s->obj_ctx);
+ s->object->set_prefetch_data();
}
ret = read_obj_policy(dpp, store, s, s->bucket->get_info(), s->bucket_attrs,
s->object_acl.get(), nullptr, s->iam_policy, s->bucket.get(),
}
static int rgw_iam_remove_objtags(const DoutPrefixProvider *dpp, struct req_state* s, rgw::sal::Object* object, bool has_existing_obj_tag, bool has_resource_tag) {
- object->set_atomic(s->obj_ctx);
- int op_ret = object->get_obj_attrs(s->obj_ctx, s->yield, dpp);
+ object->set_atomic();
+ int op_ret = object->get_obj_attrs(s->yield, dpp);
if (op_ret < 0)
return op_ret;
rgw::sal::Attrs attrs = object->get_attrs();
}
static int rgw_iam_add_objtags(const DoutPrefixProvider *dpp, struct req_state* s, rgw::sal::Object* object, bool has_existing_obj_tag, bool has_resource_tag) {
- object->set_atomic(s->obj_ctx);
- int op_ret = object->get_obj_attrs(s->obj_ctx, s->yield, dpp);
+ object->set_atomic();
+ int op_ret = object->get_obj_attrs(s->yield, dpp);
if (op_ret < 0)
return op_ret;
rgw::sal::Attrs attrs = object->get_attrs();
int RGWGetObj::verify_permission(optional_yield y)
{
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
if (prefetch_data()) {
- s->object->set_prefetch_data(s->obj_ctx);
+ s->object->set_prefetch_data();
}
auto [has_s3_existing_tag, has_s3_resource_tag] = rgw_check_policy_condition(this, s);
{
rgw::sal::Attrs attrs;
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
- op_ret = s->object->get_obj_attrs(s->obj_ctx, y, this);
+ op_ret = s->object->get_obj_attrs(y, this);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: failed to get obj attrs, obj=" << s->object
<< " ret=" << op_ret << dendl;
return;
}
- s->object->set_atomic(s->obj_ctx);
- op_ret = s->object->modify_obj_attrs(s->obj_ctx, RGW_ATTR_TAGS, tags_bl, y, this);
+ s->object->set_atomic();
+ op_ret = s->object->modify_obj_attrs(RGW_ATTR_TAGS, tags_bl, y, this);
if (op_ret == -ECANCELED){
op_ret = -ERR_TAG_CONFLICT;
}
if (rgw::sal::Object::empty(s->object.get()))
return;
- op_ret = s->object->delete_obj_attrs(this, s->obj_ctx, RGW_ATTR_TAGS, y);
+ op_ret = s->object->delete_obj_attrs(this, RGW_ATTR_TAGS, y);
}
int RGWGetBucketTags::verify_permission(optional_yield y)
std::unique_ptr<rgw::sal::Object> part = bucket->get_object(ent.key);
- RGWObjectCtx obj_ctx(store);
RGWAccessControlPolicy obj_policy(s->cct);
ldpp_dout(this, 20) << "reading obj=" << part << " ofs=" << cur_ofs
<< " end=" << cur_end << dendl;
- part->set_atomic(&obj_ctx);
- part->set_prefetch_data(&obj_ctx);
+ part->set_atomic();
+ part->set_prefetch_data();
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op = part->get_read_op(&obj_ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op = part->get_read_op();
if (!swift_slo) {
/* SLO etag is optional */
perfcounter->inc(l_rgw_get);
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op(s->object->get_read_op(s->obj_ctx));
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op(s->object->get_read_op());
op_ret = get_params(y);
if (op_ret < 0)
std::unique_ptr<rgw::sal::Object> cs_object =
cs_bucket->get_object(rgw_obj_key(copy_source_object_name, copy_source_version_id));
- cs_object->set_atomic(s->obj_ctx);
- cs_object->set_prefetch_data(s->obj_ctx);
+ cs_object->set_atomic();
+ cs_object->set_prefetch_data();
/* check source object permissions */
if (ret = read_obj_policy(this, store, s, copy_source_bucket_info, cs_attrs, &cs_acl, nullptr,
return ret;
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(rgw_obj_key(copy_source_object_name, copy_source_version_id));
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op(obj->get_read_op(s->obj_ctx));
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op(obj->get_read_op());
ret = read_op->prepare(s->yield, this);
if (ret < 0)
}
const bool multipart = !multipart_upload_id.empty();
- auto& obj_ctx = *static_cast<RGWObjectCtx*>(s->obj_ctx);
/* Handle object versioning of Swift API. */
if (! multipart) {
- op_ret = s->object->swift_versioning_copy(s->obj_ctx, this, s->yield);
+ op_ret = s->object->swift_versioning_copy(this, s->yield);
if (op_ret < 0) {
return;
}
std::unique_ptr<rgw::sal::MultipartUpload> upload;
upload = s->bucket->get_multipart_upload(s->object->get_name(),
multipart_upload_id);
- op_ret = upload->get_info(this, s->yield, s->obj_ctx, &pdest_placement);
+ op_ret = upload->get_info(this, s->yield, &pdest_placement);
s->trace->SetAttribute(tracing::rgw::UPLOAD_ID, multipart_upload_id);
multipart_trace = tracing::rgw::tracer.add_span(name(), upload->get_trace());
pdest_placement = &s->dest_placement;
ldpp_dout(this, 20) << "dest_placement for part=" << *pdest_placement << dendl;
processor = upload->get_writer(this, s->yield, s->object->clone(),
- s->user->get_id(), obj_ctx, pdest_placement,
+ s->user->get_id(), pdest_placement,
multipart_part_num, multipart_part_str);
} else if(append) {
if (s->bucket->versioned()) {
return;
}
processor = store->get_append_writer(this, s->yield, s->object->clone(),
- s->bucket_owner.get_id(), obj_ctx,
+ s->bucket_owner.get_id(),
pdest_placement, s->req_id, position,
&cur_accounted_size);
} else {
}
}
processor = store->get_atomic_writer(this, s->yield, s->object->clone(),
- s->bucket_owner.get_id(), obj_ctx,
+ s->bucket_owner.get_id(),
pdest_placement, olh_epoch, s->req_id);
}
bucket->get_object(rgw_obj_key(copy_source_object_name, copy_source_version_id));
RGWObjState *astate;
- op_ret = obj->get_obj_state(this, &obj_ctx, &astate, s->yield);
+ op_ret = obj->get_obj_state(this, &astate, s->yield);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: get copy source obj state returned with error" << op_ret << dendl;
return;
compressor.emplace(s->cct, plugin, filter);
filter = &*compressor;
// always send incompressible hint when rgw is itself doing compression
- s->object->set_compressed(s->obj_ctx);
+ s->object->set_compressed();
}
}
}
std::unique_ptr<rgw::sal::Writer> processor;
processor = store->get_atomic_writer(this, s->yield, std::move(obj),
- s->bucket_owner.get_id(), *s->obj_ctx,
+ s->bucket_owner.get_id(),
&s->dest_placement, 0, s->req_id);
op_ret = processor->prepare(s->yield);
if (op_ret < 0) {
rgw_obj target_obj;
rgw::sal::Attrs attrs, rmattrs;
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
op_ret = get_params(y);
if (op_ret < 0) {
}
/* check if obj exists, read orig attrs */
- op_ret = s->object->get_obj_attrs(s->obj_ctx, s->yield, s, &target_obj);
+ op_ret = s->object->get_obj_attrs(s->yield, s, &target_obj);
if (op_ret < 0) {
return;
}
}
}
- op_ret = s->object->set_obj_attrs(this, s->obj_ctx, &attrs, &rmattrs, s->yield, &target_obj);
+ op_ret = s->object->set_obj_attrs(this, &attrs, &rmattrs, s->yield);
}
int RGWDeleteObj::handle_slo_manifest(bufferlist& bl, optional_yield y)
if (!rgw::sal::Object::empty(s->object.get())) {
uint64_t obj_size = 0;
std::string etag;
- RGWObjectCtx* obj_ctx = static_cast<RGWObjectCtx *>(s->obj_ctx);
{
RGWObjState* astate = nullptr;
bool check_obj_lock = s->object->have_instance() && s->bucket->get_info().obj_lock_enabled();
- op_ret = s->object->get_obj_state(this, obj_ctx, &astate, s->yield, true);
+ op_ret = s->object->get_obj_state(this, &astate, s->yield, true);
if (op_ret < 0) {
if (need_object_expiration() || multipart_delete) {
return;
return;
}
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
bool ver_restored = false;
- op_ret = s->object->swift_versioning_restore(s->obj_ctx, ver_restored, this);
+ op_ret = s->object->swift_versioning_restore(ver_restored, this);
if (op_ret < 0) {
return;
}
return;
}
- std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = s->object->get_delete_op(obj_ctx);
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = s->object->get_delete_op();
del_op->params.obj_owner = s->owner;
del_op->params.bucket_owner = s->bucket_owner;
del_op->params.versioning_status = s->bucket->get_info().versioning_status();
s->src_object->set_bucket(src_bucket.get());
/* get buckets info (source and dest) */
if (s->local_source && source_zone.empty()) {
- s->src_object->set_atomic(s->obj_ctx);
- s->src_object->set_prefetch_data(s->obj_ctx);
+ s->src_object->set_atomic();
+ s->src_object->set_prefetch_data();
rgw_placement_rule src_placement;
}
dest_object = dest_bucket->get_object(rgw_obj_key(dest_obj_name));
- dest_object->set_atomic(s->obj_ctx);
+ dest_object->set_atomic();
/* check dest bucket permissions */
op_ret = read_bucket_policy(this, store, s, dest_bucket->get_info(),
dest_object->gen_rand_obj_instance_name();
}
- s->src_object->set_atomic(s->obj_ctx);
- dest_object->set_atomic(s->obj_ctx);
+ s->src_object->set_atomic();
+ dest_object->set_atomic();
encode_delete_at_attr(delete_at, attrs);
{
// get src object size (cached in obj_ctx from verify_permission())
RGWObjState* astate = nullptr;
- op_ret = s->src_object->get_obj_state(this, s->obj_ctx, &astate, s->yield, true);
+ op_ret = s->src_object->get_obj_state(this, &astate, s->yield, true);
if (op_ret < 0) {
return;
}
/* Handle object versioning of Swift API. In case of copying to remote this
* should fail gently (op_ret == 0) as the dst_obj will not exist here. */
- op_ret = dest_object->swift_versioning_copy(s->obj_ctx, this, s->yield);
+ op_ret = dest_object->swift_versioning_copy(this, s->yield);
if (op_ret < 0) {
return;
}
- RGWObjectCtx& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
- op_ret = s->src_object->copy_object(obj_ctx,
- s->user.get(),
+ op_ret = s->src_object->copy_object(s->user.get(),
&s->info,
source_zone,
dest_object.get(),
map<string, bufferlist> attrs;
if (!rgw::sal::Object::empty(s->object.get())) {
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
//if instance is empty, we should modify the latest object
- op_ret = s->object->modify_obj_attrs(s->obj_ctx, RGW_ATTR_ACL, bl, s->yield, this);
+ op_ret = s->object->modify_obj_attrs(RGW_ATTR_ACL, bl, s->yield, this);
} else {
map<string,bufferlist> attrs = s->bucket_attrs;
attrs[RGW_ATTR_ACL] = bl;
std::unique_ptr<rgw::sal::MultipartUpload> upload;
upload = s->bucket->get_multipart_upload(s->object->get_name(),
upload_id);
- op_ret = upload->init(this, s->yield, s->obj_ctx, s->owner, s->dest_placement, attrs);
+ op_ret = upload->init(this, s->yield, s->owner, s->dest_placement, attrs);
if (op_ret == 0) {
upload_id = upload->get_upload_id();
return;
}
- op_ret = meta_obj->get_obj_attrs(s->obj_ctx, s->yield, this);
+ op_ret = meta_obj->get_obj_attrs(s->yield, this);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: failed to get obj attrs, obj=" << meta_obj
<< " ret=" << op_ret << dendl;
}
target_obj->set_attrs(meta_obj->get_attrs());
- op_ret = upload->complete(this, y, s->cct, parts->parts, remove_objs, accounted_size, compressed, cs_info, ofs, s->req_id, s->owner, olh_epoch, target_obj.get(), s->obj_ctx);
+ op_ret = upload->complete(this, y, s->cct, parts->parts, remove_objs, accounted_size, compressed, cs_info, ofs, s->req_id, s->owner, olh_epoch, target_obj.get());
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: upload complete failed ret=" << op_ret << dendl;
return;
// remove the upload meta object ; the meta object is not versioned
// when the bucket is, as that would add an unneeded delete marker
- int r = meta_obj->delete_object(this, s->obj_ctx, y, true /* prevent versioning */);
+ int r = meta_obj->delete_object(this, y, true /* prevent versioning */);
if (r >= 0) {
/* serializer's exclusive lock is released */
serializer->clear_locked();
bool RGWCompleteMultipart::check_previously_completed(const RGWMultiCompleteUpload* parts)
{
// re-calculate the etag from the parts and compare to the existing object
- int ret = s->object->get_obj_attrs(s->obj_ctx, s->yield, this);
+ int ret = s->object->get_obj_attrs(s->yield, this);
if (ret < 0) {
ldpp_dout(this, 0) << __func__ << "() ERROR: get_obj_attrs() returned ret=" << ret << dendl;
return false;
return;
upload = s->bucket->get_multipart_upload(s->object->get_name(), upload_id);
- RGWObjectCtx *obj_ctx = static_cast<RGWObjectCtx *>(s->obj_ctx);
-
jspan_context trace_ctx(false, false);
if (tracing::rgw::tracer.is_enabled()) {
// read meta object attributes for trace info
meta_obj = upload->get_meta_obj();
meta_obj->set_in_extra_data(true);
- meta_obj->get_obj_attrs(obj_ctx, s->yield, this);
+ meta_obj->get_obj_attrs(s->yield, this);
extract_span_context(meta_obj->get_attrs(), trace_ctx);
}
multipart_trace = tracing::rgw::tracer.add_span(name(), trace_ctx);
- op_ret = upload->abort(this, s->cct, obj_ctx);
+ op_ret = upload->abort(this, s->cct);
}
int RGWListMultipart::verify_permission(optional_yield y)
upload = s->bucket->get_multipart_upload(s->object->get_name(), upload_id);
rgw::sal::Attrs attrs;
- op_ret = upload->get_info(this, s->yield, s->obj_ctx, &placement, &attrs);
+ op_ret = upload->get_info(this, s->yield, &placement, &attrs);
/* decode policy */
map<string, bufferlist>::iterator iter = attrs.find(RGW_ATTR_ACL);
if (iter != attrs.end()) {
RGWMultiDelDelete *multi_delete;
vector<rgw_obj_key>::iterator iter;
RGWMultiDelXMLParser parser;
- RGWObjectCtx *obj_ctx = static_cast<RGWObjectCtx *>(s->obj_ctx);
char* buf;
buf = data.c_str();
if (!rgw::sal::Object::empty(obj.get())) {
RGWObjState* astate = nullptr;
bool check_obj_lock = obj->have_instance() && bucket->get_info().obj_lock_enabled();
- const auto ret = obj->get_obj_state(this, obj_ctx, &astate, s->yield, true);
+ const auto ret = obj->get_obj_state(this, &astate, s->yield, true);
if (ret < 0) {
if (ret == -ENOENT) {
continue;
}
- obj->set_atomic(obj_ctx);
+ obj->set_atomic();
- std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op(obj_ctx);
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op();
del_op->params.versioning_status = obj->get_bucket()->get_info().versioning_status();
del_op->params.obj_owner = s->owner;
del_op->params.bucket_owner = s->bucket_owner;
bucket_owner.set_id(bucket->get_info().owner);
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(path.obj_key);
- obj->set_atomic(s->obj_ctx);
+ obj->set_atomic();
- std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op(s->obj_ctx);
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op();
del_op->params.versioning_status = obj->get_bucket()->get_info().versioning_status();
del_op->params.obj_owner = bowner;
del_op->params.bucket_owner = bucket_owner;
rgw_obj_key object;
std::tie(bucket_name, object) = *parse_path(path);
- auto& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
std::unique_ptr<rgw::sal::Bucket> bucket;
ACLOwner bowner;
std::unique_ptr<rgw::sal::Writer> processor;
processor = store->get_atomic_writer(this, s->yield, std::move(obj),
- bowner.get_id(), obj_ctx,
+ bowner.get_id(),
&s->dest_placement, 0, s->req_id);
op_ret = processor->prepare(s->yield);
if (op_ret < 0) {
int RGWGetAttrs::verify_permission(optional_yield y)
{
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
auto [has_s3_existing_tag, has_s3_resource_tag] = rgw_check_policy_condition(this, s);
if (has_s3_existing_tag || has_s3_resource_tag)
if (op_ret < 0)
return;
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
- op_ret = s->object->get_obj_attrs(s->obj_ctx, s->yield, this);
+ op_ret = s->object->get_obj_attrs(s->yield, this);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: failed to get obj attrs, obj=" << s->object
<< " ret=" << op_ret << dendl;
if (op_ret < 0)
return;
- s->object->set_atomic(s->obj_ctx);
+ s->object->set_atomic();
- op_ret = s->object->set_obj_attrs(this, s->obj_ctx, nullptr, &attrs, y);
+ op_ret = s->object->set_obj_attrs(this, nullptr, &attrs, y);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: failed to delete obj attrs, obj=" << s->object
<< " ret=" << op_ret << dendl;
if (!rgw::sal::Object::empty(s->object.get())) {
rgw::sal::Attrs a(attrs);
- op_ret = s->object->set_obj_attrs(this, s->obj_ctx, &a, nullptr, y);
+ op_ret = s->object->set_obj_attrs(this, &a, nullptr, y);
} else {
op_ret = s->bucket->merge_and_store_attrs(this, attrs, y);
}
obj_retention.encode(bl);
//check old retention
- op_ret = s->object->get_obj_attrs(s->obj_ctx, s->yield, this);
+ op_ret = s->object->get_obj_attrs(s->yield, this);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: get obj attr error"<< dendl;
return;
}
}
- op_ret = s->object->modify_obj_attrs(s->obj_ctx, RGW_ATTR_OBJECT_RETENTION, bl, s->yield, this);
+ op_ret = s->object->modify_obj_attrs(RGW_ATTR_OBJECT_RETENTION, bl, s->yield, this);
return;
}
op_ret = -ERR_INVALID_REQUEST;
return;
}
- op_ret = s->object->get_obj_attrs(s->obj_ctx, s->yield, this);
+ op_ret = s->object->get_obj_attrs(s->yield, this);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: failed to get obj attrs, obj=" << s->object
<< " ret=" << op_ret << dendl;
bufferlist bl;
obj_legal_hold.encode(bl);
//if instance is empty, we should modify the latest object
- op_ret = s->object->modify_obj_attrs(s->obj_ctx, RGW_ATTR_OBJECT_LEGAL_HOLD, bl, s->yield, this);
+ op_ret = s->object->modify_obj_attrs(RGW_ATTR_OBJECT_LEGAL_HOLD, bl, s->yield, this);
return;
}
return;
}
map<string, bufferlist> attrs;
- op_ret = s->object->get_obj_attrs(s->obj_ctx, s->yield, this);
+ op_ret = s->object->get_obj_attrs(s->yield, this);
if (op_ret < 0) {
ldpp_dout(this, 0) << "ERROR: failed to get obj attrs, obj=" << s->object
<< " ret=" << op_ret << dendl;
continue;
}
- rgw_obj obj(cur_bucket->get_key(), entry.key);
+ std::unique_ptr<rgw::sal::Object> obj = cur_bucket->get_object(entry.key);
- RGWRados::Object op_target(store->getRados(), cur_bucket->get_info(), obj_ctx, obj);
+ RGWRados::Object op_target(store->getRados(), cur_bucket.get(), obj_ctx, obj.get());
stat_ops.push_back(RGWRados::Object::Stat(&op_target));
RGWRados::Object::Stat& op = stat_ops.back();
continue;
}
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ store->get_bucket(nullptr, bucket_info, &bucket);
// we need to do this in two cases below, so use a lambda
auto do_stat_key =
[&](const rgw_obj_key& key) -> int {
int ret;
- rgw_obj obj(bucket_info.bucket, key);
- RGWRados::Object op_target(store->getRados(), bucket_info,
- obj_ctx, obj);
+ std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(key);
+ RGWRados::Object op_target(store->getRados(), bucket.get(),
+ obj_ctx, obj.get());
stat_ops.push_back(RGWRados::Object::Stat(&op_target));
RGWRados::Object::Stat& op = stat_ops.back();
std::unique_ptr<rgw::sal::User> u = store->get_user(rgw_user());
s->set_user(u);
- RGWObjectCtx rados_ctx(store, s);
- s->obj_ctx = &rados_ctx;
-
if (ret < 0) {
s->cio = client_io;
abort_early(s, nullptr, ret, nullptr, yield);
return ret;
}
- RGWBucketInfo bucket_info;
string tenant;
- ret = store->getRados()->get_bucket_info(store->svc(), tenant, sub_conf.dest.bucket_name, bucket_info, nullptr, null_yield, nullptr);
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ ret = store->get_bucket(dpp, nullptr, tenant, sub_conf.dest.bucket_name,
+ &bucket, null_yield);
if (ret < 0) {
ldpp_dout(dpp, 1) << "ERROR: failed to read bucket info for events bucket: bucket=" << sub_conf.dest.bucket_name << " ret=" << ret << dendl;
return ret;
}
+ std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(
+ sub_conf.dest.oid_prefix + event_id);
+ obj->set_atomic();
- rgw_bucket& bucket = bucket_info.bucket;
-
- RGWObjectCtx obj_ctx(store);
- rgw_obj obj(bucket, sub_conf.dest.oid_prefix + event_id);
-
- obj_ctx.set_atomic(obj);
-
- RGWRados::Object del_target(store->getRados(), bucket_info, obj_ctx, obj);
- RGWRados::Object::Delete del_op(&del_target);
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op();
- del_op.params.bucket_owner = bucket_info.owner;
- del_op.params.versioning_status = bucket_info.versioning_status();
+ del_op->params.bucket_owner = bucket->get_info().owner;
+ del_op->params.versioning_status = bucket->get_info().versioning_status();
- ret = del_op.delete_obj(null_yield, dpp);
+ ret = del_op->delete_obj(dpp, null_yield);
if (ret < 0) {
ldpp_dout(dpp, 1) << "ERROR: failed to remove event (obj=" << obj << "): ret=" << ret << dendl;
}
void RadosWriter::add_write_hint(librados::ObjectWriteOperation& op) {
const rgw_obj obj = head_obj->get_obj();
- const RGWObjState *obj_state = obj_ctx.get_state(obj);
- const bool compressed = obj_state->compressed;
+ const RGWObjStateManifest *sm = obj_ctx.get_state(obj);
+ const bool compressed = sm->state.compressed;
uint32_t alloc_hint_flags = 0;
if (compressed) {
alloc_hint_flags |= librados::ALLOC_HINT_FLAG_INCOMPRESSIBLE;
if (need_to_remove_head) {
std::string version_id;
ldpp_dout(dpp, 5) << "NOTE: we are going to process the head obj (" << *raw_head << ")" << dendl;
- int r = head_obj->delete_object(dpp, &obj_ctx, null_yield);
+ int r = head_obj->delete_object(dpp, null_yield);
if (r < 0 && r != -ENOENT) {
ldpp_dout(dpp, 0) << "WARNING: failed to remove obj (" << *raw_head << "), leaked" << dendl;
}
return r;
}
- head_obj->set_atomic(&obj_ctx);
+ head_obj->set_atomic();
RGWRados::Object op_target(store->getRados(),
- head_obj->get_bucket()->get_info(),
- obj_ctx, head_obj->get_obj());
+ head_obj->get_bucket(),
+ obj_ctx, head_obj.get());
RGWRados::Object::Write obj_op(&op_target);
/* some object types shouldn't be versioned, e.g., multipart parts */
}
RGWRados::Object op_target(store->getRados(),
- head_obj->get_bucket()->get_info(),
- obj_ctx, head_obj->get_obj());
+ head_obj->get_bucket(),
+ obj_ctx, head_obj.get());
RGWRados::Object::Write obj_op(&op_target);
op_target.set_versioning_disabled(true);
int AppendObjectProcessor::prepare(optional_yield y)
{
RGWObjState *astate;
- int r = head_obj->get_obj_state(dpp, &obj_ctx, &astate, y);
+ int r = head_obj->get_obj_state(dpp, &astate, y);
if (r < 0) {
return r;
}
if (iter != astate->attrset.end()) {
tail_placement_rule.storage_class = iter->second.to_str();
}
- cur_manifest = &(*astate->manifest);
+ cur_manifest = dynamic_cast<rgw::sal::RadosObject*>(head_obj.get())->get_manifest();
manifest.set_prefix(cur_manifest->get_prefix());
astate->keep_tail = true;
}
if (r < 0) {
return r;
}
- head_obj->set_atomic(&obj_ctx);
+ head_obj->set_atomic();
RGWRados::Object op_target(store->getRados(),
- head_obj->get_bucket()->get_info(),
- obj_ctx, head_obj->get_obj());
+ head_obj->get_bucket(),
+ obj_ctx, head_obj.get());
RGWRados::Object::Write obj_op(&op_target);
//For Append obj, disable versioning
op_target.set_versioning_disabled(true);
public:
ManifestObjectProcessor(Aio *aio, rgw::sal::RadosStore* store,
const rgw_placement_rule *ptail_placement_rule,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner, RGWObjectCtx& _obj_ctx,
std::unique_ptr<rgw::sal::Object> _head_obj,
const DoutPrefixProvider* dpp, optional_yield y)
: HeadObjectProcessor(0),
store(store),
owner(owner),
- obj_ctx(obj_ctx), head_obj(std::move(_head_obj)),
+ obj_ctx(_obj_ctx), head_obj(std::move(_head_obj)),
writer(aio, store, obj_ctx, head_obj->clone(), dpp, y),
chunk(&writer, 0), stripe(&chunk, this, 0), dpp(dpp) {
if (ptail_placement_rule) {
write_version = obj_version();
}
-RGWObjState::RGWObjState() {
-}
-
-RGWObjState::~RGWObjState() {
-}
-
-RGWObjState::RGWObjState(const RGWObjState& rhs) : obj (rhs.obj) {
- is_atomic = rhs.is_atomic;
- has_attrs = rhs.has_attrs;
- exists = rhs.exists;
- size = rhs.size;
- accounted_size = rhs.accounted_size;
- mtime = rhs.mtime;
- epoch = rhs.epoch;
- if (rhs.obj_tag.length()) {
- obj_tag = rhs.obj_tag;
- }
- if (rhs.tail_tag.length()) {
- tail_tag = rhs.tail_tag;
- }
- write_tag = rhs.write_tag;
- fake_tag = rhs.fake_tag;
- manifest = rhs.manifest;
- shadow_obj = rhs.shadow_obj;
- has_data = rhs.has_data;
- if (rhs.data.length()) {
- data = rhs.data;
- }
- prefetch_data = rhs.prefetch_data;
- keep_tail = rhs.keep_tail;
- is_olh = rhs.is_olh;
- objv_tracker = rhs.objv_tracker;
- pg_ver = rhs.pg_ver;
- compressed = rhs.compressed;
-}
-
-RGWObjState *RGWObjectCtx::get_state(const rgw_obj& obj) {
- RGWObjState *result;
- typename std::map<rgw_obj, RGWObjState>::iterator iter;
+RGWObjStateManifest *RGWObjectCtx::get_state(const rgw_obj& obj) {
+ RGWObjStateManifest *result;
+ typename std::map<rgw_obj, RGWObjStateManifest>::iterator iter;
lock.lock_shared();
assert (!obj.empty());
iter = objs_state.find(obj);
void RGWObjectCtx::set_compressed(const rgw_obj& obj) {
std::unique_lock wl{lock};
assert (!obj.empty());
- objs_state[obj].compressed = true;
+ objs_state[obj].state.compressed = true;
}
void RGWObjectCtx::set_atomic(rgw_obj& obj) {
std::unique_lock wl{lock};
assert (!obj.empty());
- objs_state[obj].is_atomic = true;
+ objs_state[obj].state.is_atomic = true;
}
void RGWObjectCtx::set_prefetch_data(const rgw_obj& obj) {
std::unique_lock wl{lock};
assert (!obj.empty());
- objs_state[obj].prefetch_data = true;
+ objs_state[obj].state.prefetch_data = true;
}
void RGWObjectCtx::invalidate(const rgw_obj& obj) {
if (iter == objs_state.end()) {
return;
}
- bool is_atomic = iter->second.is_atomic;
- bool prefetch_data = iter->second.prefetch_data;
- bool compressed = iter->second.compressed;
+ bool is_atomic = iter->second.state.is_atomic;
+ bool prefetch_data = iter->second.state.prefetch_data;
+ bool compressed = iter->second.state.compressed;
objs_state.erase(iter);
- if (is_atomic || prefetch_data || compressed) {
- auto& state = objs_state[obj];
- state.is_atomic = is_atomic;
- state.prefetch_data = prefetch_data;
- state.compressed = compressed;
+ if (is_atomic || prefetch_data) {
+ auto& sm = objs_state[obj];
+ sm.state.is_atomic = is_atomic;
+ sm.state.prefetch_data = prefetch_data;
+ sm.state.compressed = compressed;
}
}
*/
int RGWRados::fix_tail_obj_locator(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, rgw_obj_key& key, bool fix, bool *need_fix, optional_yield y)
{
- const rgw_bucket& bucket = bucket_info.bucket;
- rgw_obj obj(bucket, key);
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ store->get_bucket(nullptr, bucket_info, &bucket);
+ std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(key);
if (need_fix) {
*need_fix = false;
}
rgw_rados_ref ref;
- int r = get_obj_head_ref(dpp, bucket_info, obj, &ref);
+ int r = get_obj_head_ref(dpp, bucket_info, obj->get_obj(), &ref);
if (r < 0) {
return r;
}
- RGWObjState *astate = NULL;
+ RGWObjState *astate = nullptr;
+ RGWObjManifest* manifest = nullptr;
RGWObjectCtx rctx(this->store);
- r = get_obj_state(dpp, &rctx, bucket_info, obj, &astate, false, y);
+ r = get_obj_state(dpp, &rctx, bucket_info, obj.get(), &astate, &manifest, false, y);
if (r < 0)
return r;
- if (astate->manifest) {
+ if (manifest) {
RGWObjManifest::obj_iterator miter;
- RGWObjManifest& manifest = *astate->manifest;
- for (miter = manifest.obj_begin(dpp); miter != manifest.obj_end(dpp); ++miter) {
+ for (miter = manifest->obj_begin(dpp); miter != manifest->obj_end(dpp); ++miter) {
rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(store);
rgw_obj loc;
string oid;
string locator;
- RGWSI_Tier_RADOS::raw_obj_to_obj(manifest.get_tail_placement().bucket, raw_loc, &loc);
+ RGWSI_Tier_RADOS::raw_obj_to_obj(manifest->get_tail_placement().bucket, raw_loc, &loc);
if (loc.key.ns.empty()) {
/* continue, we're only interested in tail objects */
}
string bad_loc;
- prepend_bucket_marker(bucket, loc.key.name, bad_loc);
+ prepend_bucket_marker(bucket->get_key(), loc.key.name, bad_loc);
/* create a new ioctx with the bad locator */
librados::IoCtx src_ioctx;
return 0;
}
- obj->set_atomic(&obj_ctx);
+ obj->set_atomic();
RGWObjState * state = nullptr;
- int r = get_obj_state(dpp, &obj_ctx, bucket->get_info(), obj->get_obj(), &state, false, y);
+ RGWObjManifest *manifest = nullptr;
+ int r = get_obj_state(dpp, &obj_ctx, bucket->get_info(), obj, &state, &manifest, false, y);
if (r < 0) {
return r;
}
dest_obj.gen_rand_obj_instance_name();
}
- dest_obj.set_atomic(&obj_ctx);
+ dest_obj.set_atomic();
rgw_zone_id no_zone;
obj->gen_rand_obj_instance_name();
}
- archive_obj.set_atomic(&obj_ctx);
- obj->set_atomic(&obj_ctx);
+ archive_obj.set_atomic();
+ obj->set_atomic();
int ret = copy_obj(obj_ctx,
user,
}
/* Need to remove the archived copy. */
- ret = delete_obj(dpp, obj_ctx, archive_binfo, archive_obj.get_obj(),
+ ret = delete_obj(dpp, archive_binfo, &archive_obj,
archive_binfo.versioning_status());
return ret;
#endif
RGWObjState *state;
- int r = target->get_state(dpp, &state, false, y, assume_noent);
+ RGWObjManifest *manifest = nullptr;
+ int r = target->get_state(dpp, &state, &manifest, false, y, assume_noent);
if (r < 0)
return r;
- rgw_obj& obj = target->get_obj();
+ rgw_obj obj = target->get_obj();
if (obj.get_oid().empty()) {
ldpp_dout(dpp, 0) << "ERROR: " << __func__ << "(): cannot write object with empty name" << dendl;
meta.set_mtime = real_clock::now();
}
- if (target->bucket_info.obj_lock_enabled() && target->bucket_info.obj_lock.has_rule() && meta.flags == PUT_OBJ_CREATE) {
+ if (target->get_bucket_info().obj_lock_enabled() && target->get_bucket_info().obj_lock.has_rule() && meta.flags == PUT_OBJ_CREATE) {
auto iter = attrs.find(RGW_ATTR_OBJECT_RETENTION);
if (iter == attrs.end()) {
- real_time lock_until_date = target->bucket_info.obj_lock.get_lock_until_date(meta.set_mtime);
- string mode = target->bucket_info.obj_lock.get_mode();
+ real_time lock_until_date = target->get_bucket_info().obj_lock.get_lock_until_date(meta.set_mtime);
+ string mode = target->get_bucket_info().obj_lock.get_mode();
RGWObjectRetention obj_retention(mode, lock_until_date);
bufferlist bl;
obj_retention.encode(bl);
state = NULL;
if (versioned_op && meta.olh_epoch) {
- r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), obj, false, NULL, *meta.olh_epoch, real_time(), false, y, meta.zones_trace);
+ r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), target->get_target(), false, NULL, *meta.olh_epoch, real_time(), false, y, meta.zones_trace);
if (r < 0) {
return r;
}
rgw::sal::Attrs attrset;
uint64_t obj_size;
ceph::real_time mtime;
- RGWRados::Object op_target(this, obj->get_bucket()->get_info(), rctx, obj->get_obj());
+ RGWRados::Object op_target(this, obj->get_bucket(), rctx, obj);
RGWRados::Object::Read read_op(&op_target);
read_op.params.attrs = &attrset;
uint64_t expected_size = 0;
RGWObjState *dest_state = NULL;
+ RGWObjManifest *manifest = nullptr;
const real_time *pmod = mod_ptr;
if (copy_if_newer) {
/* need to get mtime for destination */
- ret = get_obj_state(dpp, &obj_ctx, dest_bucket->get_info(), dest_obj->get_obj(), &dest_state, false, null_yield);
+ ret = get_obj_state(dpp, &obj_ctx, dest_bucket->get_info(), dest_obj, &dest_state, &manifest, false, null_yield);
if (ret < 0)
goto set_err_state;
if (copy_if_newer && canceled) {
ldpp_dout(dpp, 20) << "raced with another write of obj: " << dest_obj << dendl;
obj_ctx.invalidate(dest_obj->get_obj()); /* object was overwritten */
- ret = get_obj_state(dpp, &obj_ctx, dest_bucket->get_info(), dest_obj->get_obj(), &dest_state, false, null_yield);
+ ret = get_obj_state(dpp, &obj_ctx, dest_bucket->get_info(), dest_obj, &dest_state, &manifest, false, null_yield);
if (ret < 0) {
ldpp_dout(dpp, 0) << "ERROR: " << __func__ << ": get_err_state() returned ret=" << ret << dendl;
goto set_err_state;
// for OP_LINK_OLH to call set_olh() with a real olh_epoch
if (olh_epoch && *olh_epoch > 0) {
constexpr bool log_data_change = true;
- ret = set_olh(dpp, obj_ctx, dest_bucket->get_info(), dest_obj->get_obj(), false, nullptr,
+ ret = set_olh(dpp, obj_ctx, dest_bucket->get_info(), dest_obj, false, nullptr,
*olh_epoch, real_time(), false, null_yield, zones_trace, log_data_change);
} else {
// we already have the latest copy
}
map<string, bufferlist> src_attrs;
- RGWRados::Object src_op_target(this, src_bucket->get_info(), obj_ctx, src_obj->get_obj());
+ RGWRados::Object src_op_target(this, src_bucket, obj_ctx, src_obj);
RGWRados::Object::Read read_op(&src_op_target);
read_op.conds.mod_ptr = mod_ptr;
RGWObjManifest manifest;
RGWObjState *astate = NULL;
+ RGWObjManifest *amanifest = nullptr;
- ret = get_obj_state(dpp, &obj_ctx, src_bucket->get_info(), src_obj->get_obj(), &astate, y);
+ ret = get_obj_state(dpp, &obj_ctx, src_bucket->get_info(), src_obj, &astate, &amanifest, y);
if (ret < 0) {
return ret;
}
const rgw_placement_rule *src_rule{nullptr};
- if (astate->manifest) {
- src_rule = &astate->manifest->get_tail_placement().placement_rule;
+ if (amanifest) {
+ src_rule = &amanifest->get_tail_placement().placement_rule;
ldpp_dout(dpp, 20) << __func__ << "(): manifest src_rule=" << src_rule->to_str() << dendl;
}
ldpp_dout(dpp, 20) << __func__ << "(): src_rule=" << src_rule->to_str() << " src_pool=" << src_pool
<< " dest_rule=" << dest_placement.to_str() << " dest_pool=" << dest_pool << dendl;
- bool copy_data = (!astate->manifest) ||
+ bool copy_data = (!amanifest) ||
(*src_rule != dest_placement) ||
(src_pool != dest_pool);
bool copy_first = false;
- if (astate->manifest) {
- if (!astate->manifest->has_tail()) {
+ if (amanifest) {
+ if (!amanifest->has_tail()) {
copy_data = true;
} else {
- uint64_t head_size = astate->manifest->get_head_size();
+ uint64_t head_size = amanifest->get_head_size();
if (head_size > 0) {
if (head_size > max_chunk_size) {
mtime, real_time(), attrs, olh_epoch, delete_at, petag, dpp, y);
}
- RGWObjManifest::obj_iterator miter = astate->manifest->obj_begin(dpp);
+ /* This has been in for 2 years, so we can safely assume amanifest is not NULL */
+ RGWObjManifest::obj_iterator miter = amanifest->obj_begin(dpp);
if (copy_first) { // we need to copy first chunk, not increase refcount
++miter;
RGWObjManifest *pmanifest;
ldpp_dout(dpp, 20) << "dest_obj=" << dest_obj << " src_obj=" << src_obj << " copy_itself=" << (int)copy_itself << dendl;
- RGWRados::Object dest_op_target(this, dest_bucket->get_info(), obj_ctx, dest_obj->get_obj());
+ RGWRados::Object dest_op_target(this, dest_bucket, obj_ctx, dest_obj);
RGWRados::Object::Write write_op(&dest_op_target);
string tag;
if (!copy_itself) {
attrs.erase(RGW_ATTR_TAIL_TAG);
- manifest = *astate->manifest;
+ manifest = *amanifest;
const rgw_bucket_placement& tail_placement = manifest.get_tail_placement();
if (tail_placement.bucket.name.empty()) {
manifest.set_tail_placement(tail_placement.placement_rule, src_obj->get_bucket()->get_key());
}
string ref_tag;
- for (; miter != astate->manifest->obj_end(dpp); ++miter) {
+ for (; miter != amanifest->obj_end(dpp); ++miter) {
ObjectWriteOperation op;
ref_tag = tag + '\0';
cls_refcount_get(op, ref_tag, true);
pmanifest = &manifest;
} else {
- pmanifest = &(*astate->manifest);
+ pmanifest = amanifest;
/* don't send the object's tail for garbage collection */
astate->keep_tail = true;
}
real_time read_mtime;
uint64_t obj_size;
- obj.set_atomic(&obj_ctx);
- RGWRados::Object op_target(this, bucket->get_info(), obj_ctx, obj.get_obj());
+ obj.set_atomic();
+ RGWRados::Object op_target(this, bucket, obj_ctx, &obj);
RGWRados::Object::Read read_op(&op_target);
read_op.params.attrs = &attrs;
int RGWRados::Object::complete_atomic_modification(const DoutPrefixProvider *dpp)
{
- if ((!state->manifest)|| state->keep_tail)
+ if ((!manifest)|| state->keep_tail)
return 0;
cls_rgw_obj_chain chain;
- store->update_gc_chain(dpp, obj, *state->manifest, &chain);
+ store->update_gc_chain(dpp, obj->get_obj(), *manifest, &chain);
if (chain.empty()) {
return 0;
return 0;
}
-void RGWRados::update_gc_chain(const DoutPrefixProvider *dpp, rgw_obj& head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain)
+void RGWRados::update_gc_chain(const DoutPrefixProvider *dpp, rgw_obj head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain)
{
RGWObjManifest::obj_iterator iter;
rgw_raw_obj raw_head;
return CLSRGWIssueSetBucketResharding(index_pool.ioctx(), bucket_objs, entry, cct->_conf->rgw_bucket_index_max_aio)();
}
-int RGWRados::defer_gc(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y)
+int RGWRados::defer_gc(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, optional_yield y)
{
RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
std::string oid, key;
- get_obj_bucket_and_oid_loc(obj, oid, key);
+ get_obj_bucket_and_oid_loc(obj->get_obj(), oid, key);
if (!rctx)
return 0;
RGWObjState *state = NULL;
+ RGWObjManifest *manifest = nullptr;
- int r = get_obj_state(dpp, rctx, bucket_info, obj, &state, false, y);
+ int r = get_obj_state(dpp, rctx, bucket_info, obj, &state, &manifest, false, y);
if (r < 0)
return r;
ldpp_dout(dpp, 0) << "defer chain tag=" << tag << dendl;
cls_rgw_obj_chain chain;
- update_gc_chain(dpp, state->obj, *state->manifest, &chain);
+ update_gc_chain(dpp, state->obj, *manifest, &chain);
return gc->async_defer_chain(tag, chain);
}
int RGWRados::Object::Delete::delete_obj(optional_yield y, const DoutPrefixProvider *dpp)
{
RGWRados *store = target->get_store();
- rgw_obj& src_obj = target->get_obj();
- const string& instance = src_obj.key.instance;
- rgw_obj obj = src_obj;
+ const string& instance = target->get_instance();
+ rgw_obj obj = target->get_obj();
if (instance == "null") {
obj.key.instance.clear();
if (params.versioning_status & BUCKET_VERSIONED || explicit_marker_version) {
if (instance.empty() || explicit_marker_version) {
- rgw_obj marker = obj;
+ std::unique_ptr<rgw::sal::Object> marker = target->get_target()->clone();
+ marker->clear_instance();
if (!params.marker_version_id.empty()) {
if (params.marker_version_id != "null") {
- marker.key.set_instance(params.marker_version_id);
+ marker->set_instance(params.marker_version_id);
}
} else if ((params.versioning_status & BUCKET_VERSIONS_SUSPENDED) == 0) {
- store->gen_rand_obj_instance_name(&marker);
+ marker->gen_rand_obj_instance_name();
}
- result.version_id = marker.key.instance;
+ result.version_id = marker->get_instance();
if (result.version_id.empty())
result.version_id = "null";
result.delete_marker = true;
meta.mtime = params.mtime;
}
- int r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), marker, true, &meta, params.olh_epoch, params.unmod_since, params.high_precision_time, y, params.zones_trace);
+ int r = store->set_olh(dpp, target->get_ctx(), target->get_bucket_info(), marker.get(), true, &meta, params.olh_epoch, params.unmod_since, params.high_precision_time, y, params.zones_trace);
if (r < 0) {
return r;
}
return r;
}
result.delete_marker = dirent.is_delete_marker();
- r = store->unlink_obj_instance(dpp, target->get_ctx(), target->get_bucket_info(), obj, params.olh_epoch, y, params.zones_trace);
+ r = store->unlink_obj_instance(dpp, target->get_bucket_info(), target->get_target(), params.olh_epoch, y, params.zones_trace);
if (r < 0) {
return r;
}
return r;
}
- r = store->svc.datalog_rados->add_entry(dpp, target->bucket_info, bs->shard_id);
+ r = store->svc.datalog_rados->add_entry(dpp, target->get_bucket_info(), bs->shard_id);
if (r < 0) {
ldpp_dout(dpp, -1) << "ERROR: failed writing data log" << dendl;
return r;
}
RGWObjState *state;
- r = target->get_state(dpp, &state, false, y);
+ RGWObjManifest *manifest = nullptr;
+ r = target->get_state(dpp, &state, &manifest, false, y);
if (r < 0)
return r;
return 0;
}
-int RGWRados::delete_obj(const DoutPrefixProvider *dpp,
- RGWObjectCtx& obj_ctx,
+int RGWRados::delete_obj(rgw::sal::Store* store,
+ const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_info,
const rgw_obj& obj,
int versioning_status, // versioning flags defined in enum RGWBucketFlags
const real_time& expiration_time,
rgw_zone_set *zones_trace)
{
- RGWRados::Object del_target(this, bucket_info, obj_ctx, obj);
- RGWRados::Object::Delete del_op(&del_target);
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ store->get_bucket(nullptr, bucket_info, &bucket);
+ std::unique_ptr<rgw::sal::Object> object = bucket->get_object(obj.key);
- del_op.params.bucket_owner = bucket_info.owner;
- del_op.params.versioning_status = versioning_status;
- del_op.params.bilog_flags = bilog_flags;
- del_op.params.expiration_time = expiration_time;
- del_op.params.zones_trace = zones_trace;
+ return delete_obj(dpp, bucket_info, object.get(), versioning_status,
+ bilog_flags, expiration_time, zones_trace);
+}
+
+int RGWRados::delete_obj(const DoutPrefixProvider *dpp,
+ const RGWBucketInfo& bucket_info,
+ rgw::sal::Object* obj,
+ int versioning_status, // versioning flags defined in enum RGWBucketFlags
+ uint16_t bilog_flags,
+ const real_time& expiration_time,
+ rgw_zone_set *zones_trace)
+{
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = obj->get_delete_op();
- return del_op.delete_obj(null_yield, dpp);
+ del_op->params.bucket_owner = bucket_info.owner;
+ del_op->params.versioning_status = versioning_status;
+ del_op->params.bilog_flags = bilog_flags;
+ del_op->params.expiration_time = expiration_time;
+ del_op->params.zones_trace = zones_trace;
+
+ return del_op->delete_obj(dpp, null_yield);
}
int RGWRados::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj)
return (iter != attrs.end());
}
-int RGWRados::get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
- RGWObjState *olh_state, RGWObjState **target_state, optional_yield y)
+int RGWRados::get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx&
+ obj_ctx, const RGWBucketInfo& bucket_info,
+ rgw::sal::Object* obj, RGWObjState *olh_state,
+ RGWObjState **target_state,
+ RGWObjManifest **target_manifest, optional_yield y)
{
ceph_assert(olh_state->is_olh);
if (r < 0) {
return r;
}
- r = get_obj_state(dpp, &obj_ctx, bucket_info, target, target_state, false, y);
+
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ store->get_bucket(nullptr, bucket_info, &bucket);
+ std::unique_ptr<rgw::sal::Object> target_obj = bucket->get_object(target.key);
+
+ r = get_obj_state(dpp, &obj_ctx, bucket_info, target_obj.get(), target_state,
+ target_manifest, false, y);
if (r < 0) {
return r;
}
return 0;
}
-int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
- RGWObjState **state, bool follow_olh, optional_yield y, bool assume_noent)
+int RGWRados::get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx,
+ const RGWBucketInfo& bucket_info, rgw::sal::Object* obj,
+ RGWObjState **state, RGWObjManifest** manifest,
+ bool follow_olh, optional_yield y, bool assume_noent)
{
- if (obj.empty()) {
+ if (obj->empty()) {
return -EINVAL;
}
- bool need_follow_olh = follow_olh && obj.key.instance.empty();
+ bool need_follow_olh = follow_olh && obj->get_obj().key.instance.empty();
+ *manifest = nullptr;
- RGWObjState *s = rctx->get_state(obj);
+ RGWObjStateManifest *sm = rctx->get_state(obj->get_obj());
+ RGWObjState *s = &(sm->state);
ldpp_dout(dpp, 20) << "get_obj_state: rctx=" << (void *)rctx << " obj=" << obj << " state=" << (void *)s << " s->prefetch_data=" << s->prefetch_data << dendl;
*state = s;
+ if (sm->manifest) {
+ *manifest = &(*sm->manifest);
+ }
if (s->has_attrs) {
if (s->is_olh && need_follow_olh) {
- return get_olh_target_state(dpp, *rctx, bucket_info, obj, s, state, y);
+ return get_olh_target_state(dpp, *rctx, bucket_info, obj, s, state, manifest, y);
}
return 0;
}
- s->obj = obj;
+ s->obj = obj->get_obj();
rgw_raw_obj raw_obj;
- obj_to_raw(bucket_info.placement_rule, obj, &raw_obj);
+ obj_to_raw(bucket_info.placement_rule, obj->get_obj(), &raw_obj);
int r = -ENOENT;
s->exists = false;
s->has_attrs = true;
tombstone_entry entry;
- if (obj_tombstone_cache && obj_tombstone_cache->find(obj, entry)) {
+ if (obj_tombstone_cache && obj_tombstone_cache->find(obj->get_obj(), entry)) {
s->mtime = entry.mtime;
s->zone_short_id = entry.zone_short_id;
s->pg_ver = entry.pg_ver;
if (manifest_bl.length()) {
auto miter = manifest_bl.cbegin();
try {
- s->manifest.emplace();
- decode(*s->manifest, miter);
- s->manifest->set_head(bucket_info.placement_rule, obj, s->size); /* patch manifest to reflect the head we just read, some manifests might be
+ sm->manifest.emplace();
+ decode(*sm->manifest, miter);
+ sm->manifest->set_head(bucket_info.placement_rule, obj->get_obj(), s->size); /* patch manifest to reflect the head we just read, some manifests might be
broken due to old bugs */
- s->size = s->manifest->get_obj_size();
+ s->size = sm->manifest->get_obj_size();
if (!compressed)
s->accounted_size = s->size;
} catch (buffer::error& err) {
ldpp_dout(dpp, 0) << "ERROR: couldn't decode manifest" << dendl;
return -EIO;
}
- ldpp_dout(dpp, 10) << "manifest: total_size = " << s->manifest->get_obj_size() << dendl;
+ *manifest = &(*sm->manifest);
+ ldpp_dout(dpp, 10) << "manifest: total_size = " << sm->manifest->get_obj_size() << dendl;
if (cct->_conf->subsys.should_gather<ceph_subsys_rgw, 20>() && \
- s->manifest->has_explicit_objs()) {
+ sm->manifest->has_explicit_objs()) {
RGWObjManifest::obj_iterator mi;
- for (mi = s->manifest->obj_begin(dpp); mi != s->manifest->obj_end(dpp); ++mi) {
+ for (mi = sm->manifest->obj_begin(dpp); mi != sm->manifest->obj_end(dpp); ++mi) {
ldpp_dout(dpp, 20) << "manifest: ofs=" << mi.get_ofs() << " loc=" << mi.get_location().get_raw_obj(store) << dendl;
}
}
* Uh oh, something's wrong, object with manifest should have tag. Let's
* create one out of the manifest, would be unique
*/
- generate_fake_tag(dpp, store, s->attrset, *s->manifest, manifest_bl, s->obj_tag);
+ generate_fake_tag(dpp, store, s->attrset, *sm->manifest, manifest_bl, s->obj_tag);
s->fake_tag = true;
}
}
ldpp_dout(dpp, 20) << __func__ << ": setting s->olh_tag to " << string(s->olh_tag.c_str(), s->olh_tag.length()) << dendl;
if (need_follow_olh) {
- return get_olh_target_state(dpp, *rctx, bucket_info, obj, s, state, y);
- } else if (obj.key.have_null_instance() && !s->manifest) {
+ return get_olh_target_state(dpp, *rctx, bucket_info, obj, s, state, manifest, y);
+ } else if (obj->get_obj().key.have_null_instance() && !sm->manifest) {
// read null version, and the head object only have olh info
s->exists = false;
return -ENOENT;
return 0;
}
-int RGWRados::get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state,
+int RGWRados::get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest,
bool follow_olh, optional_yield y, bool assume_noent)
{
int ret;
do {
- ret = get_obj_state_impl(dpp, rctx, bucket_info, obj, state, follow_olh, y, assume_noent);
+ ret = get_obj_state_impl(dpp, rctx, bucket_info, obj, state, manifest, follow_olh, y, assume_noent);
} while (ret == -EAGAIN);
return ret;
int RGWRados::Object::get_manifest(const DoutPrefixProvider *dpp, RGWObjManifest **pmanifest, optional_yield y)
{
RGWObjState *astate;
- int r = get_state(dpp, &astate, true, y);
+ int r = get_state(dpp, &astate, pmanifest, true, y);
if (r < 0) {
return r;
}
- *pmanifest = &(*astate->manifest);
-
return 0;
}
int RGWRados::Object::Read::get_attr(const DoutPrefixProvider *dpp, const char *name, bufferlist& dest, optional_yield y)
{
RGWObjState *state;
- int r = source->get_state(dpp, &state, true, y);
+ RGWObjManifest *manifest = nullptr;
+ int r = source->get_state(dpp, &state, &manifest, true, y);
if (r < 0)
return r;
if (!state->exists)
int RGWRados::Object::Stat::stat_async(const DoutPrefixProvider *dpp)
{
- RGWObjectCtx& ctx = source->get_ctx();
- rgw_obj& obj = source->get_obj();
+ rgw::sal::Object* target = source->get_target();
+ rgw_obj obj = target->get_obj();
RGWRados *store = source->get_store();
- RGWObjState *s = ctx.get_state(obj); /* calling this one directly because otherwise a sync request will be sent */
result.obj = obj;
- if (s->has_attrs) {
+ if (target->has_attrs()) {
state.ret = 0;
- result.size = s->size;
- result.mtime = ceph::real_clock::to_timespec(s->mtime);
- result.attrs = s->attrset;
- result.manifest = s->manifest;
+ result.size = target->get_obj_size();
+ result.mtime = ceph::real_clock::to_timespec(target->get_mtime());
+ result.attrs = target->get_attrs();
+ //result.manifest = sm->manifest;
return 0;
}
return 0;
}
-int RGWRados::append_atomic_test(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx,
- const RGWBucketInfo& bucket_info, const rgw_obj& obj,
- ObjectOperation& op, RGWObjState **pstate, optional_yield y)
+int RGWRados::append_atomic_test(const DoutPrefixProvider *dpp,
+ const RGWBucketInfo& bucket_info, rgw::sal::Object* obj,
+ ObjectOperation& op, RGWObjState **pstate,
+ RGWObjManifest** pmanifest, optional_yield y)
{
- if (!rctx)
- return 0;
-
- int r = get_obj_state(dpp, rctx, bucket_info, obj, pstate, false, y);
+ int r = obj->get_obj_state(dpp, pstate, y, false);
if (r < 0)
return r;
return 0;
}
-int RGWRados::Object::get_state(const DoutPrefixProvider *dpp, RGWObjState **pstate, bool follow_olh, optional_yield y, bool assume_noent)
+int RGWRados::Object::get_state(const DoutPrefixProvider *dpp, RGWObjState **pstate, RGWObjManifest **pmanifest, bool follow_olh, optional_yield y, bool assume_noent)
{
- return store->get_obj_state(dpp, &ctx, bucket_info, obj, pstate, follow_olh, y, assume_noent);
+ int r = obj->get_obj_state(dpp, pstate, y, follow_olh);
+ if (r < 0) {
+ return r;
+ }
+ *pmanifest = static_cast<rgw::sal::RadosObject*>(obj)->get_manifest();
+
+ return r;
}
void RGWRados::Object::invalidate_state()
{
- ctx.invalidate(obj);
+ obj->invalidate();
}
int RGWRados::Object::prepare_atomic_modification(const DoutPrefixProvider *dpp,
const char *if_match, const char *if_nomatch, bool removal_op,
bool modify_tail, optional_yield y)
{
- int r = get_state(dpp, &state, false, y);
+ int r = get_state(dpp, &state, &manifest, false, y);
if (r < 0)
return r;
- bool need_guard = ((state->manifest) || (state->obj_tag.length() != 0) ||
+ bool need_guard = ((manifest) || (state->obj_tag.length() != 0) ||
if_match != NULL || if_nomatch != NULL) &&
(!state->fake_tag);
* bl: the contents of the attr
* Returns: 0 on success, -ERR# otherwise.
*/
-int RGWRados::set_attr(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& obj, const char *name, bufferlist& bl)
+int RGWRados::set_attr(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, const char *name, bufferlist& bl)
{
map<string, bufferlist> attrs;
attrs[name] = bl;
return set_attrs(dpp, ctx, bucket_info, obj, attrs, NULL, null_yield);
}
-int RGWRados::set_attrs(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& src_obj,
+int RGWRados::set_attrs(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* src_obj,
map<string, bufferlist>& attrs,
map<string, bufferlist>* rmattrs,
optional_yield y)
{
- rgw_obj obj = src_obj;
- if (obj.key.instance == "null") {
- obj.key.instance.clear();
+ std::unique_ptr<rgw::sal::Object> obj = src_obj->clone();
+ if (obj->get_instance() == "null") {
+ obj->clear_instance();
}
rgw_rados_ref ref;
- int r = get_obj_head_ref(dpp, bucket_info, obj, &ref);
+ int r = get_obj_head_ref(dpp, bucket_info, obj->get_obj(), &ref);
if (r < 0) {
return r;
}
- RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
ObjectWriteOperation op;
RGWObjState *state = NULL;
+ RGWObjManifest *manifest = nullptr;
- r = append_atomic_test(dpp, rctx, bucket_info, obj, op, &state, y);
+ r = append_atomic_test(dpp, bucket_info, obj.get(), op, &state, &manifest, y);
if (r < 0)
return r;
// ensure null version object exist
- if (src_obj.key.instance == "null" && !state->manifest) {
+ if (src_obj->get_instance() == "null" && !manifest) {
return -ENOENT;
}
}
}
- const rgw_bucket& bucket = obj.bucket;
+ const rgw_bucket& bucket = obj->get_bucket()->get_key();
for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
const string& name = iter->first;
decode(ts, bl);
rgw_obj_index_key obj_key;
- obj.key.get_index_key(&obj_key);
+ obj->get_key().get_index_key(&obj_key);
obj_expirer->hint_add(dpp, ts, bucket.tenant, bucket.name, bucket.bucket_id, obj_key);
} catch (buffer::error& err) {
if (!op.size())
return 0;
- RGWObjectCtx obj_ctx(this->store);
-
bufferlist bl;
RGWRados::Bucket bop(this, bucket_info);
- RGWRados::Bucket::UpdateIndex index_op(&bop, obj);
+ RGWRados::Bucket::UpdateIndex index_op(&bop, obj->get_obj());
if (state) {
string tag;
map<string, bufferlist>::iterator iter;
RGWObjState *astate;
- int r = source->get_state(dpp, &astate, true, y);
+ RGWObjManifest *manifest = nullptr;
+ int r = source->get_state(dpp, &astate, &manifest, true, y);
if (r < 0)
return r;
uint64_t max_chunk_size;
RGWObjState *astate;
- int r = source->get_state(dpp, &astate, true, y);
+ RGWObjManifest *manifest = nullptr;
+ int r = source->get_state(dpp, &astate, &manifest, true, y);
if (r < 0)
return r;
else
len = end - ofs + 1;
- if (astate->manifest && astate->manifest->has_tail()) {
+ if (manifest && manifest->has_tail()) {
/* now get the relevant object part */
- RGWObjManifest::obj_iterator iter = astate->manifest->obj_find(dpp, ofs);
+ RGWObjManifest::obj_iterator iter = manifest->obj_find(dpp, ofs);
uint64_t stripe_ofs = iter.get_stripe_ofs();
read_obj = iter.get_location().get_raw_obj(store->store);
if (reading_from_head) {
/* only when reading from the head object do we need to do the atomic test */
- r = store->append_atomic_test(dpp, &source->get_ctx(), source->get_bucket_info(), state.obj, op, &astate, y);
+ std::unique_ptr<rgw::sal::Object> obj = source->bucket->get_object(state.obj.key);
+ r = store->append_atomic_test(dpp, source->get_bucket_info(), obj.get(), op, &astate, &manifest, y);
if (r < 0)
return r;
{
RGWRados *store = source->get_store();
CephContext *cct = store->ctx();
- RGWObjectCtx& obj_ctx = source->get_ctx();
const uint64_t chunk_size = cct->_conf->rgw_get_obj_max_req_size;
const uint64_t window_size = cct->_conf->rgw_get_obj_window_size;
auto aio = rgw::make_throttle(window_size, y);
get_obj_data data(store, cb, &*aio, ofs, y);
- int r = store->iterate_obj(dpp, obj_ctx, source->get_bucket_info(), state.obj,
+ int r = store->iterate_obj(dpp, source->get_ctx(), source->get_bucket_info(),
+ source->get_target(),
ofs, end, chunk_size, _get_obj_iterate_cb, &data, y);
if (r < 0) {
ldpp_dout(dpp, 0) << "iterate_obj() failed with " << r << dendl;
}
int RGWRados::iterate_obj(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx,
- const RGWBucketInfo& bucket_info, const rgw_obj& obj,
+ const RGWBucketInfo& bucket_info, rgw::sal::Object* obj,
off_t ofs, off_t end, uint64_t max_chunk_size,
iterate_obj_cb cb, void *arg, optional_yield y)
{
uint64_t len;
bool reading_from_head = true;
RGWObjState *astate = NULL;
+ RGWObjManifest *manifest = nullptr;
- obj_to_raw(bucket_info.placement_rule, obj, &head_obj);
+ obj_to_raw(bucket_info.placement_rule, obj->get_obj(), &head_obj);
- int r = get_obj_state(dpp, &obj_ctx, bucket_info, obj, &astate, false, y);
+ int r = get_obj_state(dpp, &obj_ctx, bucket_info, obj, &astate, &manifest, false, y);
if (r < 0) {
return r;
}
else
len = end - ofs + 1;
- if (astate->manifest) {
+ if (manifest) {
/* now get the relevant object stripe */
- RGWObjManifest::obj_iterator iter = astate->manifest->obj_find(dpp, ofs);
+ RGWObjManifest::obj_iterator iter = manifest->obj_find(dpp, ofs);
- RGWObjManifest::obj_iterator obj_end = astate->manifest->obj_end(dpp);
+ RGWObjManifest::obj_iterator obj_end = manifest->obj_end(dpp);
for (; iter != obj_end && ofs <= end; ++iter) {
off_t stripe_ofs = iter.get_stripe_ofs();
}
int RGWRados::apply_olh_log(const DoutPrefixProvider *dpp,
- RGWObjectCtx& obj_ctx,
RGWObjState& state,
const RGWBucketInfo& bucket_info,
- const rgw_obj& obj,
+ const rgw::sal::Object* obj,
bufferlist& olh_tag,
std::map<uint64_t, std::vector<rgw_bucket_olh_log_entry> >& log,
uint64_t *plast_ver,
}
rgw_rados_ref ref;
- int r = get_obj_head_ref(dpp, bucket_info, obj, &ref);
+ int r = get_obj_head_ref(dpp, bucket_info, obj->get_obj(), &ref);
if (r < 0) {
return r;
}
- const rgw_bucket& bucket = obj.bucket;
+ rgw::sal::Bucket* bucket = obj->get_bucket();
if (need_to_link) {
- rgw_obj target(bucket, key);
+ rgw_obj target(bucket->get_key(), key);
RGWOLHInfo info;
info.target = target;
info.removed = delete_marker;
for (list<cls_rgw_obj_key>::iterator liter = remove_instances.begin();
liter != remove_instances.end(); ++liter) {
cls_rgw_obj_key& key = *liter;
- rgw_obj obj_instance(bucket, key);
- int ret = delete_obj(dpp, obj_ctx, bucket_info, obj_instance, 0, RGW_BILOG_FLAG_VERSIONED_OP, ceph::real_time(), zones_trace);
+ std::unique_ptr<rgw::sal::Object> obj_instance = bucket->get_object(key);
+ int ret = delete_obj(dpp, bucket_info, obj_instance.get(), 0, RGW_BILOG_FLAG_VERSIONED_OP, ceph::real_time(), zones_trace);
if (ret < 0 && ret != -ENOENT) {
ldpp_dout(dpp, 0) << "ERROR: delete_obj() returned " << ret << " obj_instance=" << obj_instance << dendl;
return ret;
return r;
}
- r = bucket_index_trim_olh_log(dpp, bucket_info, state, obj, last_ver);
+ r = bucket_index_trim_olh_log(dpp, bucket_info, state, obj->get_obj(), last_ver);
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: could not trim olh log, r=" << r << dendl;
return r;
/*
* only clear if was successful, otherwise we might clobber pending operations on this object
*/
- r = bucket_index_clear_olh(dpp, bucket_info, state, obj);
+ r = bucket_index_clear_olh(dpp, bucket_info, state, obj->get_obj());
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: could not clear bucket index olh entries r=" << r << dendl;
return r;
/*
* read olh log and apply it
*/
-int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *state, const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_zone_set *zones_trace)
+int RGWRados::update_olh(const DoutPrefixProvider *dpp, RGWObjState *state, const RGWBucketInfo& bucket_info, const rgw::sal::Object* obj, rgw_zone_set *zones_trace)
{
map<uint64_t, vector<rgw_bucket_olh_log_entry> > log;
bool is_truncated;
uint64_t ver_marker = 0;
do {
- int ret = bucket_index_read_olh_log(dpp, bucket_info, *state, obj, ver_marker, &log, &is_truncated);
+ int ret = bucket_index_read_olh_log(dpp, bucket_info, *state, obj->get_obj(), ver_marker, &log, &is_truncated);
if (ret < 0) {
return ret;
}
- ret = apply_olh_log(dpp, obj_ctx, *state, bucket_info, obj, state->olh_tag, log, &ver_marker, zones_trace);
+ ret = apply_olh_log(dpp, *state, bucket_info, obj, state->olh_tag, log, &ver_marker, zones_trace);
if (ret < 0) {
return ret;
}
return 0;
}
-int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, const RGWBucketInfo& bucket_info, const rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta,
+int RGWRados::set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx,
+ const RGWBucketInfo& bucket_info,
+ rgw::sal::Object* target_obj, bool delete_marker,
+ rgw_bucket_dir_entry_meta *meta,
uint64_t olh_epoch, real_time unmod_since, bool high_precision_time,
optional_yield y, rgw_zone_set *zones_trace, bool log_data_change)
{
string op_tag;
- rgw_obj olh_obj = target_obj;
- olh_obj.key.instance.clear();
+ std::unique_ptr<rgw::sal::Object> olh_obj = target_obj->clone();
+ olh_obj->clear_instance();
RGWObjState *state = NULL;
+ RGWObjManifest *manifest = nullptr;
int ret = 0;
int i;
#define MAX_ECANCELED_RETRY 100
for (i = 0; i < MAX_ECANCELED_RETRY; i++) {
if (ret == -ECANCELED) {
- obj_ctx.invalidate(olh_obj);
+ olh_obj->invalidate();
}
- ret = get_obj_state(dpp, &obj_ctx, bucket_info, olh_obj, &state, false, y); /* don't follow olh */
+ ret = get_obj_state(dpp, &obj_ctx, bucket_info, olh_obj.get(), &state, &manifest, false, y); /* don't follow olh */
if (ret < 0) {
return ret;
}
- ret = olh_init_modification(dpp, bucket_info, *state, olh_obj, &op_tag);
+ ret = olh_init_modification(dpp, bucket_info, *state, olh_obj->get_obj(), &op_tag);
if (ret < 0) {
ldpp_dout(dpp, 20) << "olh_init_modification() target_obj=" << target_obj << " delete_marker=" << (int)delete_marker << " returned " << ret << dendl;
if (ret == -ECANCELED) {
}
return ret;
}
- ret = bucket_index_link_olh(dpp, bucket_info, *state, target_obj, delete_marker,
- op_tag, meta, olh_epoch, unmod_since, high_precision_time,
- zones_trace, log_data_change);
+ ret = bucket_index_link_olh(dpp, bucket_info, *state, target_obj->get_obj(),
+ delete_marker, op_tag, meta, olh_epoch, unmod_since,
+ high_precision_time, zones_trace, log_data_change);
if (ret < 0) {
ldpp_dout(dpp, 20) << "bucket_index_link_olh() target_obj=" << target_obj << " delete_marker=" << (int)delete_marker << " returned " << ret << dendl;
if (ret == -ECANCELED) {
// the bucket index rejected the link_olh() due to olh tag mismatch;
// attempt to reconstruct olh head attributes based on the bucket index
- int r2 = repair_olh(dpp, state, bucket_info, olh_obj);
+ int r2 = repair_olh(dpp, state, bucket_info, olh_obj->get_obj());
if (r2 < 0 && r2 != -ECANCELED) {
return r2;
}
return -EIO;
}
- ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj);
+ ret = update_olh(dpp, state, bucket_info, olh_obj.get());
if (ret == -ECANCELED) { /* already did what we needed, no need to retry, raced with another user */
ret = 0;
}
return 0;
}
-int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj,
+int RGWRados::unlink_obj_instance(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, rgw::sal::Object* target_obj,
uint64_t olh_epoch, optional_yield y, rgw_zone_set *zones_trace)
{
string op_tag;
- rgw_obj olh_obj = target_obj;
- olh_obj.key.instance.clear();
+ std::unique_ptr<rgw::sal::Object> olh_obj = target_obj->clone();
+ olh_obj->clear_instance();
RGWObjState *state = NULL;
for (i = 0; i < MAX_ECANCELED_RETRY; i++) {
if (ret == -ECANCELED) {
- obj_ctx.invalidate(olh_obj);
+ olh_obj->invalidate();
}
- ret = get_obj_state(dpp, &obj_ctx, bucket_info, olh_obj, &state, false, y); /* don't follow olh */
+ ret = olh_obj->get_obj_state(dpp, &state, y, false); /* don't follow olh */
if (ret < 0)
return ret;
- ret = olh_init_modification(dpp, bucket_info, *state, olh_obj, &op_tag);
+ ret = olh_init_modification(dpp, bucket_info, *state, olh_obj->get_obj(), &op_tag);
if (ret < 0) {
ldpp_dout(dpp, 20) << "olh_init_modification() target_obj=" << target_obj << " returned " << ret << dendl;
if (ret == -ECANCELED) {
string olh_tag(state->olh_tag.c_str(), state->olh_tag.length());
- ret = bucket_index_unlink_instance(dpp, bucket_info, target_obj, op_tag, olh_tag, olh_epoch, zones_trace);
+ ret = bucket_index_unlink_instance(dpp, bucket_info, target_obj->get_obj(), op_tag, olh_tag, olh_epoch, zones_trace);
if (ret < 0) {
ldpp_dout(dpp, 20) << "bucket_index_unlink_instance() target_obj=" << target_obj << " returned " << ret << dendl;
if (ret == -ECANCELED) {
return -EIO;
}
- ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj, zones_trace);
+ ret = update_olh(dpp, state, bucket_info, olh_obj.get(), zones_trace);
if (ret == -ECANCELED) { /* already did what we needed, no need to retry, raced with another user */
return 0;
}
return 0;
}
-int RGWRados::follow_olh(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjectCtx& obj_ctx, RGWObjState *state, const rgw_obj& olh_obj, rgw_obj *target)
+int RGWRados::follow_olh(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjectCtx& obj_ctx, RGWObjState *state, rgw::sal::Object* olh_obj, rgw_obj *target)
{
map<string, bufferlist> pending_entries;
rgw_filter_attrset(state->attrset, RGW_ATTR_OLH_PENDING_PREFIX, &pending_entries);
check_pending_olh_entries(dpp,pending_entries, &rm_pending_entries);
if (!rm_pending_entries.empty()) {
- int ret = remove_olh_pending_entries(dpp, bucket_info, *state, olh_obj, rm_pending_entries);
+ int ret = remove_olh_pending_entries(dpp, bucket_info, *state, olh_obj->get_obj(), rm_pending_entries);
if (ret < 0) {
ldpp_dout(dpp, 20) << "ERROR: rm_pending_entries returned ret=" << ret << dendl;
return ret;
}
}
if (!pending_entries.empty()) {
- ldpp_dout(dpp, 20) << __func__ << "(): found pending entries, need to update_olh() on bucket=" << olh_obj.bucket << dendl;
+ ldpp_dout(dpp, 20) << __func__ << "(): found pending entries, need to update_olh() on bucket=" << olh_obj->get_bucket() << dendl;
- int ret = update_olh(dpp, obj_ctx, state, bucket_info, olh_obj);
+ int ret = update_olh(dpp, state, bucket_info, olh_obj);
if (ret < 0) {
return ret;
}
bufferlist& suggested_updates,
optional_yield y)
{
- const rgw_bucket& bucket = bucket_info.bucket;
+ std::unique_ptr<rgw::sal::Bucket> bucket;
+ store->get_bucket(nullptr, bucket_info, &bucket);
uint8_t suggest_flag = (svc.zone->get_zone().log_data ? CEPH_RGW_DIR_SUGGEST_LOG_OP : 0);
std::string loc;
- rgw_obj obj(bucket, list_state.key);
+ std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(list_state.key);
string oid;
- get_obj_bucket_and_oid_loc(obj, oid, loc);
+ get_obj_bucket_and_oid_loc(obj->get_obj(), oid, loc);
if (loc != list_state.locator) {
ldpp_dout(dpp, 0) << "WARNING: generated locator (" << loc << ") is different from listed locator (" << list_state.locator << ")" << dendl;
io_ctx.locator_set_key(list_state.locator);
RGWObjState *astate = NULL;
+ RGWObjManifest *manifest = nullptr;
RGWObjectCtx rctx(this->store);
- int r = get_obj_state(dpp, &rctx, bucket_info, obj, &astate, false, y);
+ int r = get_obj_state(dpp, &rctx, bucket_info, obj.get(), &astate, &manifest, false, y);
if (r < 0)
return r;
}
}
- if (astate->manifest) {
+ if (manifest) {
RGWObjManifest::obj_iterator miter;
- RGWObjManifest& manifest = *astate->manifest;
- for (miter = manifest.obj_begin(dpp); miter != manifest.obj_end(dpp); ++miter) {
+ for (miter = manifest->obj_begin(dpp); miter != manifest->obj_end(dpp); ++miter) {
const rgw_raw_obj& raw_loc = miter.get_location().get_raw_obj(store);
rgw_obj loc;
- RGWSI_Tier_RADOS::raw_obj_to_obj(manifest.get_obj().bucket, raw_loc, &loc);
+ RGWSI_Tier_RADOS::raw_obj_to_obj(manifest->get_obj().bucket, raw_loc, &loc);
if (loc.key.ns == RGW_OBJ_NS_MULTIPART) {
ldpp_dout(dpp, 0) << "check_disk_state(): removing manifest part from index: " << loc << dendl;
list_state.meta.content_type = content_type;
librados::IoCtx head_obj_ctx; // initialize to data pool so we can get pool id
- int ret = get_obj_head_ioctx(dpp, bucket_info, obj, &head_obj_ctx);
+ int ret = get_obj_head_ioctx(dpp, bucket_info, obj->get_obj(), &head_obj_ctx);
if (ret < 0) {
ldpp_dout(dpp, 0) << __PRETTY_FUNCTION__ <<
" WARNING: unable to find head object data pool for \"" <<
const rgw_placement_rule **prule) override;
};
+struct RGWObjStateManifest {
+ RGWObjState state;
+ std::optional<RGWObjManifest> manifest;
+};
+
class RGWObjectCtx {
rgw::sal::Store* store;
ceph::shared_mutex lock = ceph::make_shared_mutex("RGWObjectCtx");
- void *s{nullptr};
- std::map<rgw_obj, RGWObjState> objs_state;
+ std::map<rgw_obj, RGWObjStateManifest> objs_state;
public:
explicit RGWObjectCtx(rgw::sal::Store* _store) : store(_store) {}
- explicit RGWObjectCtx(rgw::sal::Store* _store, void *_s) : store(_store), s(_s) {}
-
- void *get_private() {
- return s;
+ RGWObjectCtx(RGWObjectCtx& _o) {
+ std::unique_lock wl{lock};
+ this->store = _o.store;
+ this->objs_state = _o.objs_state;
}
rgw::sal::Store* get_store() {
return store;
}
- RGWObjState *get_state(const rgw_obj& obj);
+ RGWObjStateManifest *get_state(const rgw_obj& obj);
void set_compressed(const rgw_obj& obj);
void set_atomic(rgw_obj& obj);
int get_system_obj_ref(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, rgw_rados_ref *ref);
uint64_t max_bucket_id;
- int get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx& rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
- RGWObjState *olh_state, RGWObjState **target_state, optional_yield y);
- int get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state,
+ int get_olh_target_state(const DoutPrefixProvider *dpp, RGWObjectCtx& rctx,
+ const RGWBucketInfo& bucket_info, rgw::sal::Object* obj,
+ RGWObjState *olh_state, RGWObjState **target_state,
+ RGWObjManifest **target_manifest, optional_yield y);
+ int get_obj_state_impl(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest,
bool follow_olh, optional_yield y, bool assume_noent = false);
- int append_atomic_test(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
- librados::ObjectOperation& op, RGWObjState **state, optional_yield y);
+ int append_atomic_test(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj,
+ librados::ObjectOperation& op, RGWObjState **state,
+ RGWObjManifest** pmanifest, optional_yield y);
int update_placement_map();
int store_bucket_info(RGWBucketInfo& info, std::map<std::string, bufferlist> *pattrs, RGWObjVersionTracker *objv_tracker, bool exclusive);
class Object {
RGWRados *store;
- RGWBucketInfo bucket_info;
+ rgw::sal::Bucket* bucket;
RGWObjectCtx& ctx;
- rgw_obj obj;
+ rgw::sal::Object* obj;
BucketShard bs;
RGWObjState *state;
+ RGWObjManifest *manifest;
bool versioning_disabled;
const rgw_placement_rule *pmeta_placement_rule;
protected:
- int get_state(const DoutPrefixProvider *dpp, RGWObjState **pstate, bool follow_olh, optional_yield y, bool assume_noent = false);
+ int get_state(const DoutPrefixProvider *dpp, RGWObjState **pstate, RGWObjManifest **pmanifest, bool follow_olh, optional_yield y, bool assume_noent = false);
void invalidate_state();
int prepare_atomic_modification(const DoutPrefixProvider *dpp, librados::ObjectWriteOperation& op, bool reset_obj, const std::string *ptag,
int complete_atomic_modification(const DoutPrefixProvider *dpp);
public:
- Object(RGWRados *_store, const RGWBucketInfo& _bucket_info, RGWObjectCtx& _ctx, const rgw_obj& _obj) : store(_store), bucket_info(_bucket_info),
+ Object(RGWRados *_store, rgw::sal::Bucket* _bucket, RGWObjectCtx& _ctx, rgw::sal::Object* _obj) : store(_store), bucket(_bucket),
ctx(_ctx), obj(_obj), bs(store),
- state(NULL), versioning_disabled(false),
+ state(NULL), manifest(nullptr), versioning_disabled(false),
bs_initialized(false),
pmeta_placement_rule(nullptr) {}
RGWRados *get_store() { return store; }
- rgw_obj& get_obj() { return obj; }
+ rgw_obj get_obj() { return obj->get_obj(); }
RGWObjectCtx& get_ctx() { return ctx; }
- RGWBucketInfo& get_bucket_info() { return bucket_info; }
+ RGWBucketInfo& get_bucket_info() { return bucket->get_info(); }
+ const std::string& get_instance() { return obj->get_instance(); }
+ rgw::sal::Object* get_target() { return obj; }
int get_manifest(const DoutPrefixProvider *dpp, RGWObjManifest **pmanifest, optional_yield y);
int get_bucket_shard(BucketShard **pbs, const DoutPrefixProvider *dpp) {
if (!bs_initialized) {
int r =
- bs.init(bucket_info.bucket, obj, nullptr /* no RGWBucketInfo */, dpp);
+ bs.init(bucket->get_key(), obj->get_obj(), nullptr /* no RGWBucketInfo */, dpp);
if (r < 0) {
return r;
}
}
bool versioning_enabled() {
- return (!versioning_disabled && bucket_info.versioning_enabled());
+ return (!versioning_disabled && bucket->versioning_enabled());
}
void set_meta_placement_rule(const rgw_placement_rule *p) {
}
const rgw_placement_rule& get_meta_placement_rule() {
- return pmeta_placement_rule ? *pmeta_placement_rule : bucket_info.placement_rule;
+ return pmeta_placement_rule ? *pmeta_placement_rule : bucket->get_placement_rule();
}
struct Read {
std::map<std::string, bufferlist>& attrs, optional_yield y);
int write_data(const char *data, uint64_t ofs, uint64_t len, bool exclusive);
const req_state* get_req_state() {
- return (req_state *)target->get_ctx().get_private();
+ return nullptr; /* XXX dang Only used by LTTng, and it handles null anyway */
}
};
struct Result {
rgw_obj obj;
- std::optional<RGWObjManifest> manifest;
+ std::optional<RGWObjManifest> manifest;
uint64_t size{0};
struct timespec mtime {};
std::map<std::string, bufferlist> attrs;
int bucket_suspended(const DoutPrefixProvider *dpp, rgw_bucket& bucket, bool *suspended);
/** Delete an object.*/
- int delete_obj(const DoutPrefixProvider *dpp,
- RGWObjectCtx& obj_ctx,
+ int delete_obj(rgw::sal::Store* store,
+ const DoutPrefixProvider *dpp,
const RGWBucketInfo& bucket_owner,
const rgw_obj& src_obj,
int versioning_status, // versioning flags defined in enum RGWBucketFlags
uint16_t bilog_flags = 0,
const ceph::real_time& expiration_time = ceph::real_time(),
rgw_zone_set *zones_trace = nullptr);
+ int delete_obj(const DoutPrefixProvider *dpp,
+ const RGWBucketInfo& bucket_owner,
+ rgw::sal::Object* src_obj,
+ int versioning_status, // versioning flags defined in enum RGWBucketFlags
+ uint16_t bilog_flags = 0,
+ const ceph::real_time& expiration_time = ceph::real_time(),
+ rgw_zone_set *zones_trace = nullptr);
int delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj);
* bl: the contents of the attr
* Returns: 0 on success, -ERR# otherwise.
*/
- int set_attr(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& obj, const char *name, bufferlist& bl);
+ int set_attr(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, const char *name, bufferlist& bl);
- int set_attrs(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw_obj& obj,
+ int set_attrs(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj,
std::map<std::string, bufferlist>& attrs,
std::map<std::string, bufferlist>* rmattrs,
optional_yield y);
- int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state,
+ int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest,
bool follow_olh, optional_yield y, bool assume_noent = false);
- int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWObjState **state, optional_yield y) {
- return get_obj_state(dpp, rctx, bucket_info, obj, state, true, y);
+ int get_obj_state(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, RGWObjState **state, RGWObjManifest** manifest, optional_yield y) {
+ return get_obj_state(dpp, rctx, bucket_info, obj, state, manifest, true, y);
}
using iterate_obj_cb = int (*)(const DoutPrefixProvider*, const rgw_raw_obj&, off_t, off_t,
off_t, bool, RGWObjState*, void*);
int iterate_obj(const DoutPrefixProvider *dpp, RGWObjectCtx& ctx, const RGWBucketInfo& bucket_info,
- const rgw_obj& obj, off_t ofs, off_t end,
+ rgw::sal::Object* obj, off_t ofs, off_t end,
uint64_t max_chunk_size, iterate_obj_cb cb, void *arg,
optional_yield y);
std::map<uint64_t, std::vector<rgw_bucket_olh_log_entry> > *log, bool *is_truncated);
int bucket_index_trim_olh_log(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjState& obj_state, const rgw_obj& obj_instance, uint64_t ver);
int bucket_index_clear_olh(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& obj_instance);
- int apply_olh_log(const DoutPrefixProvider *dpp, RGWObjectCtx& ctx, RGWObjState& obj_state, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
+ int apply_olh_log(const DoutPrefixProvider *dpp, RGWObjState& obj_state, const RGWBucketInfo& bucket_info, const rgw::sal::Object* obj,
bufferlist& obj_tag, std::map<uint64_t, std::vector<rgw_bucket_olh_log_entry> >& log,
uint64_t *plast_ver, rgw_zone_set *zones_trace = nullptr);
- int update_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWObjState *state, const RGWBucketInfo& bucket_info, const rgw_obj& obj, rgw_zone_set *zones_trace = nullptr);
- int set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, const RGWBucketInfo& bucket_info, const rgw_obj& target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta,
+ int update_olh(const DoutPrefixProvider *dpp, RGWObjState *state, const RGWBucketInfo& bucket_info, const rgw::sal::Object* obj, rgw_zone_set *zones_trace = nullptr);
+ int set_olh(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* target_obj, bool delete_marker, rgw_bucket_dir_entry_meta *meta,
uint64_t olh_epoch, ceph::real_time unmod_since, bool high_precision_time,
optional_yield y, rgw_zone_set *zones_trace = nullptr, bool log_data_change = false);
int repair_olh(const DoutPrefixProvider *dpp, RGWObjState* state, const RGWBucketInfo& bucket_info,
const rgw_obj& obj);
- int unlink_obj_instance(const DoutPrefixProvider *dpp, RGWObjectCtx& obj_ctx, RGWBucketInfo& bucket_info, const rgw_obj& target_obj,
+ int unlink_obj_instance(const DoutPrefixProvider *dpp, RGWBucketInfo& bucket_info, rgw::sal::Object* target_obj,
uint64_t olh_epoch, optional_yield y, rgw_zone_set *zones_trace = nullptr);
void check_pending_olh_entries(const DoutPrefixProvider *dpp, std::map<std::string, bufferlist>& pending_entries, std::map<std::string, bufferlist> *rm_pending_entries);
int remove_olh_pending_entries(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjState& state, const rgw_obj& olh_obj, std::map<std::string, bufferlist>& pending_attrs);
- int follow_olh(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjectCtx& ctx, RGWObjState *state, const rgw_obj& olh_obj, rgw_obj *target);
+ int follow_olh(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, RGWObjectCtx& ctx, RGWObjState *state, rgw::sal::Object* olh_obj, rgw_obj *target);
int get_olh(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw_obj& obj, RGWOLHInfo *olh);
void gen_rand_obj_instance_name(rgw_obj_key *target_key);
int lock_exclusive(const rgw_pool& pool, const std::string& oid, ceph::timespan& duration, rgw_zone_id& zone_id, std::string& owner_id);
int unlock(const rgw_pool& pool, const std::string& oid, rgw_zone_id& zone_id, std::string& owner_id);
- void update_gc_chain(const DoutPrefixProvider *dpp, rgw_obj& head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain);
+ void update_gc_chain(const DoutPrefixProvider *dpp, rgw_obj head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain);
int send_chain_to_gc(cls_rgw_obj_chain& chain, const std::string& tag);
void delete_objs_inline(const DoutPrefixProvider *dpp, cls_rgw_obj_chain& chain, const std::string& tag);
int gc_operate(const DoutPrefixProvider *dpp, std::string& oid, librados::ObjectWriteOperation *op);
int list_gc_objs(int *index, std::string& marker, uint32_t max, bool expired_only, std::list<cls_rgw_gc_obj_info>& result, bool *truncated, bool& processing_queue);
int process_gc(bool expired_only);
bool process_expire_objects(const DoutPrefixProvider *dpp);
- int defer_gc(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, const rgw_obj& obj, optional_yield y);
+ int defer_gc(const DoutPrefixProvider *dpp, void *ctx, const RGWBucketInfo& bucket_info, rgw::sal::Object* obj, optional_yield y);
int process_lc(const std::unique_ptr<rgw::sal::Bucket>& optional_bucket);
int list_lc_progress(std::string& marker, uint32_t max_entries,
multipart_upload_id);
std::unique_ptr<rgw::sal::Object> obj = upload->get_meta_obj();
obj->set_in_extra_data(true);
- res = obj->get_obj_attrs(s->obj_ctx, s->yield, this);
+ res = obj->get_obj_attrs(s->yield, this);
if (res == 0) {
std::unique_ptr<BlockCrypt> block_crypt;
/* We are adding to existing object.
}
f.open_object_section("result");
- s->object->dump_obj_layout(this, s->yield, &f, s->obj_ctx);
+ s->object->dump_obj_layout(this, s->yield, &f);
f.close_section();
rgw_flush_formatter(s, &f);
}
std::unique_ptr<rgw::sal::Object> obj = s->bucket->get_object(rgw_obj_key(subdir_name));
- RGWObjectCtx& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
- obj->set_atomic(&obj_ctx);
- obj->set_prefetch_data(&obj_ctx);
+ obj->set_atomic();
+ obj->set_prefetch_data();
RGWObjState* state = nullptr;
- if (obj->get_obj_state(s, &obj_ctx, &state, s->yield) < 0) {
+ if (obj->get_obj_state(s, &state, s->yield) < 0) {
return false;
}
if (! state->exists) {
std::unique_ptr<rgw::sal::Object> slo_seg = bucket->get_object(rgw_obj_key(obj_name));
/* no prefetch */
- RGWObjectCtx obj_ctx(store);
- slo_seg->set_atomic(&obj_ctx);
+ slo_seg->set_atomic();
bool compressed;
RGWCompressionInfo cs_info;
uint64_t size_bytes{0};
- r = slo_seg->get_obj_attrs(&obj_ctx, s->yield, s);
+ r = slo_seg->get_obj_attrs(s->yield, s);
if (r < 0) {
return r;
}
std::unique_ptr<rgw::sal::Object> obj = s->bucket->get_object(rgw_obj_key(std::move(subdir_name)));
/* First, get attrset of the object we'll try to retrieve. */
- RGWObjectCtx& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
- obj->set_atomic(&obj_ctx);
- obj->set_prefetch_data(&obj_ctx);
+ obj->set_atomic();
+ obj->set_prefetch_data();
RGWObjState* state = nullptr;
- if (obj->get_obj_state(s, &obj_ctx, &state, s->yield, false)) {
+ if (obj->get_obj_state(s, &state, s->yield, false)) {
return false;
}
{
std::unique_ptr<rgw::sal::Object> obj = s->bucket->get_object(rgw_obj_key(index));
- RGWObjectCtx& obj_ctx = *static_cast<RGWObjectCtx *>(s->obj_ctx);
- obj->set_atomic(&obj_ctx);
- obj->set_prefetch_data(&obj_ctx);
+ obj->set_atomic();
+ obj->set_prefetch_data();
RGWObjState* state = nullptr;
- if (obj->get_obj_state(s, &obj_ctx, &state, s->yield, false)) {
+ if (obj->get_obj_state(s, &state, s->yield, false)) {
return false;
}
#endif
}
+RGWObjState::RGWObjState() {
+}
+
+RGWObjState::~RGWObjState() {
+}
+
+RGWObjState::RGWObjState(const RGWObjState& rhs) : obj (rhs.obj) {
+ is_atomic = rhs.is_atomic;
+ has_attrs = rhs.has_attrs;
+ exists = rhs.exists;
+ size = rhs.size;
+ accounted_size = rhs.accounted_size;
+ mtime = rhs.mtime;
+ epoch = rhs.epoch;
+ if (rhs.obj_tag.length()) {
+ obj_tag = rhs.obj_tag;
+ }
+ if (rhs.tail_tag.length()) {
+ tail_tag = rhs.tail_tag;
+ }
+ write_tag = rhs.write_tag;
+ fake_tag = rhs.fake_tag;
+ shadow_obj = rhs.shadow_obj;
+ has_data = rhs.has_data;
+ if (rhs.data.length()) {
+ data = rhs.data;
+ }
+ prefetch_data = rhs.prefetch_data;
+ keep_tail = rhs.keep_tail;
+ is_olh = rhs.is_olh;
+ objv_tracker = rhs.objv_tracker;
+ pg_ver = rhs.pg_ver;
+ compressed = rhs.compressed;
+}
+
rgw::sal::Store* StoreManager::init_storage_provider(const DoutPrefixProvider* dpp, CephContext* cct, const std::string svc, bool use_gc_thread, bool use_lc_thread, bool quota_threads, bool run_sync_thread, bool run_reshard_thread, bool use_cache, bool use_gc)
{
if (svc.compare("rados") == 0) {
#include "common/tracer.h"
class RGWGetDataCB;
-struct RGWObjState;
class RGWAccessListFilter;
class RGWLC;
-class RGWObjManifest;
struct RGWZoneGroup;
struct RGWZoneParams;
struct RGWRealm;
}
};
+struct RGWObjState {
+ rgw_obj obj;
+ bool is_atomic{false};
+ bool has_attrs{false};
+ bool exists{false};
+ uint64_t size{0}; //< size of raw object
+ uint64_t accounted_size{0}; //< size before compression, encryption
+ ceph::real_time mtime;
+ uint64_t epoch{0};
+ bufferlist obj_tag;
+ bufferlist tail_tag;
+ std::string write_tag;
+ bool fake_tag{false};
+ std::string shadow_obj;
+ bool has_data{false};
+ bufferlist data;
+ bool prefetch_data{false};
+ bool keep_tail{false};
+ bool is_olh{false};
+ bufferlist olh_tag;
+ uint64_t pg_ver{false};
+ uint32_t zone_short_id{0};
+ bool compressed{false};
+
+ /* important! don't forget to update copy constructor */
+
+ RGWObjVersionTracker objv_tracker;
+
+ std::map<std::string, ceph::buffer::list> attrset;
+
+ RGWObjState();
+ RGWObjState(const RGWObjState& rhs);
+ ~RGWObjState();
+
+ bool get_attr(std::string name, bufferlist& dest) {
+ auto iter = attrset.find(name);
+ if (iter != attrset.end()) {
+ dest = iter->second;
+ return true;
+ }
+ return false;
+ }
+};
+
/**
* @defgroup RGWSAL RGW Store Abstraction Layer
*
rgw::notify::EventType event_type, const std::string* object_name=nullptr) = 0;
/** No-req_state variant (e.g., rgwlc) */
virtual std::unique_ptr<Notification> get_notification(
- const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj, RGWObjectCtx* rctx,
+ const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant,
std::string& _req_id, optional_yield y) = 0;
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) = 0;
*/
class Object {
protected:
- rgw_obj_key key;
- Bucket* bucket;
- std::string index_hash_source;
- uint64_t obj_size;
- Attrs attrs;
- ceph::real_time mtime;
- bool delete_marker{false};
- bool in_extra_data{false};
+ RGWObjState state; /**< The key and primary metadata for the object */
+ Bucket* bucket; /**< @a Bucket containing this object */
+ Attrs attrs; /**< Cache of attributes for this object */
+ bool delete_marker{false}; /**< True if this object has a delete marker */
public:
};
Object()
- : key(),
+ : state(),
bucket(nullptr),
- index_hash_source(),
- obj_size(),
- attrs(),
- mtime() {}
+ attrs()
+ {}
Object(const rgw_obj_key& _k)
- : key(_k),
+ : state(),
bucket(),
- index_hash_source(),
- obj_size(),
- attrs(),
- mtime() {}
+ attrs()
+ { state.obj.key = _k; }
Object(const rgw_obj_key& _k, Bucket* _b)
- : key(_k),
+ : state(),
bucket(_b),
- index_hash_source(),
- obj_size(),
- attrs(),
- mtime() {}
+ attrs()
+ { state.obj.init(_b->get_key(), _k); }
Object(Object& _o) = default;
virtual ~Object() = default;
/** Shortcut synchronous delete call for common deletes */
virtual int delete_object(const DoutPrefixProvider* dpp,
- RGWObjectCtx* obj_ctx,
optional_yield y,
bool prevent_versioning = false) = 0;
/** Asynchronous delete call */
virtual int delete_obj_aio(const DoutPrefixProvider* dpp, RGWObjState* astate, Completions* aio,
bool keep_index_consistent, optional_yield y) = 0;
/** Copy an this object to another object. */
- virtual int copy_object(RGWObjectCtx& obj_ctx, User* user,
+ virtual int copy_object(User* user,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
/** Set the ACL for this object */
virtual int set_acl(const RGWAccessControlPolicy& acl) = 0;
/** Mark further operations on this object as being atomic */
- virtual void set_atomic(RGWObjectCtx* rctx) const = 0;
+ virtual void set_atomic() {
+ state.is_atomic = true;
+ }
+ /** Check if this object is atomic */
+ bool is_atomic() { return state.is_atomic; }
/** Pre-fetch data when reading */
- virtual void set_prefetch_data(RGWObjectCtx* rctx) = 0;
+ virtual void set_prefetch_data() {
+ state.prefetch_data = true;
+ }
+ /** Check if this object should prefetch */
+ bool is_prefetch_data() { return state.prefetch_data; }
/** Mark data as compressed */
- virtual void set_compressed(RGWObjectCtx* rctx) = 0;
+ virtual void set_compressed() {
+ state.compressed = true;
+ }
+ /** Check if this object is compressed */
+ bool is_compressed() { return state.compressed; }
+ /** Invalidate cached info about this object, except atomic, prefetch, and
+ * compressed */
+ virtual void invalidate() {
+ rgw_obj obj = state.obj;
+ bool is_atomic = state.is_atomic;
+ bool prefetch_data = state.prefetch_data;
+ bool compressed = state.compressed;
+
+ state = RGWObjState();
+ state.obj = obj;
+ state.is_atomic = is_atomic;
+ state.prefetch_data = prefetch_data;
+ state.compressed = compressed;
+ }
/** Check to see if this object has an empty key. This means it's uninitialized */
- bool empty() const { return key.empty(); }
+ bool empty() const { return state.obj.empty(); }
/** Get the name of this object */
- const std::string &get_name() const { return key.name; }
+ const std::string &get_name() const { return state.obj.key.name; }
/** Get the object state for this object. Will be removed in the future */
- virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, RGWObjState **state, optional_yield y, bool follow_olh = true) = 0;
+ virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state, optional_yield y, bool follow_olh = true) = 0;
/** Set attributes for this object from the backing store. Attrs can be set or
* deleted. @note the attribute APIs may be revisited in the future. */
- virtual int set_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, Attrs* setattrs, Attrs* delattrs, optional_yield y, rgw_obj* target_obj = NULL) = 0;
+ virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y) = 0;
/** Get attributes for this object */
- virtual int get_obj_attrs(RGWObjectCtx* rctx, optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) = 0;
+ virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) = 0;
/** Modify attributes for this object. */
- virtual int modify_obj_attrs(RGWObjectCtx* rctx, const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) = 0;
+ virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) = 0;
/** Delete attributes for this object */
- virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, const char* attr_name, optional_yield y) = 0;
+ virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y) = 0;
/** Check to see if this object has expired */
virtual bool is_expired() = 0;
/** Create a randomized instance ID for this object */
/** Get a multipart serializer for this object */
virtual MPSerializer* get_serializer(const DoutPrefixProvider *dpp, const std::string& lock_name) = 0;
/** Move the data of an object to new placement storage */
- virtual int transition(RGWObjectCtx& rctx,
- Bucket* bucket,
+ virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
/** Check to see if two placement rules match */
virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) = 0;
/** Dump store-specific object layout info in JSON */
- virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f, RGWObjectCtx* obj_ctx) = 0;
+ virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) = 0;
/** Get the cached attributes for this object */
- Attrs& get_attrs(void) { return attrs; }
+ Attrs& get_attrs(void) { return state.attrset; }
/** Get the (const) cached attributes for this object */
- const Attrs& get_attrs(void) const { return attrs; }
+ const Attrs& get_attrs(void) const { return state.attrset; }
/** Set the cached attributes for this object */
- virtual int set_attrs(Attrs a) { attrs = a; return 0; }
+ virtual int set_attrs(Attrs a) { state.attrset = a; state.has_attrs = true; return 0; }
+ /** Check to see if attributes are cached on this object */
+ bool has_attrs(void) { return state.has_attrs; }
/** Get the cached modification time for this object */
- ceph::real_time get_mtime(void) const { return mtime; }
+ ceph::real_time get_mtime(void) const { return state.mtime; }
/** Get the cached size for this object */
- uint64_t get_obj_size(void) const { return obj_size; }
+ uint64_t get_obj_size(void) const { return state.size; }
/** Get the bucket containing this object */
Bucket* get_bucket(void) const { return bucket; }
/** Set the bucket containing this object */
- void set_bucket(Bucket* b) { bucket = b; }
+ void set_bucket(Bucket* b) { bucket = b; state.obj.bucket = b->get_key(); }
/** Get the sharding hash representation of this object */
- std::string get_hash_source(void) { return index_hash_source; }
+ std::string get_hash_source(void) { return state.obj.index_hash_source; }
/** Set the sharding hash representation of this object */
- void set_hash_source(std::string s) { index_hash_source = s; }
+ void set_hash_source(std::string s) { state.obj.index_hash_source = s; }
/** Build an Object Identifier string for this object */
- std::string get_oid(void) const { return key.get_oid(); }
+ std::string get_oid(void) const { return state.obj.key.get_oid(); }
/** True if this object is a delete marker (newest version is deleted) */
bool get_delete_marker(void) { return delete_marker; }
/** True if this object is stored in the extra data pool */
- bool get_in_extra_data(void) { return in_extra_data; }
+ bool get_in_extra_data(void) { return state.obj.is_in_extra_data(); }
/** Set the in_extra_data field */
- void set_in_extra_data(bool i) { in_extra_data = i; }
+ void set_in_extra_data(bool i) { state.obj.set_in_extra_data(i); }
/** Helper to sanitize object size, offset, and end values */
int range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end);
/** Set the cached size of this object */
- void set_obj_size(uint64_t s) { obj_size = s; }
+ void set_obj_size(uint64_t s) { state.size = s; }
/** Set the cached name of this object */
- virtual void set_name(const std::string& n) { key = n; }
+ virtual void set_name(const std::string& n) { state.obj.key = n; }
/** Set the cached key of this object */
- virtual void set_key(const rgw_obj_key& k) { key = k; }
+ virtual void set_key(const rgw_obj_key& k) { state.obj.key = k; }
/** Get an rgw_obj representing this object */
- virtual rgw_obj get_obj(void) const {
- rgw_obj obj(bucket->get_key(), key);
- obj.set_in_extra_data(in_extra_data);
- obj.index_hash_source = index_hash_source;
- return obj;
- }
+ virtual rgw_obj get_obj(void) const { return state.obj; }
/** Restore the previous swift version of this object */
- virtual int swift_versioning_restore(RGWObjectCtx* obj_ctx,
- bool& restored, /* out */
+ virtual int swift_versioning_restore(bool& restored, /* out */
const DoutPrefixProvider* dpp) = 0;
/** Copy the current version of a swift object to the configured destination bucket*/
- virtual int swift_versioning_copy(RGWObjectCtx* obj_ctx,
- const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) = 0;
/** Get a new ReadOp for this object */
- virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx*) = 0;
+ virtual std::unique_ptr<ReadOp> get_read_op() = 0;
/** Get a new DeleteOp for this object */
- virtual std::unique_ptr<DeleteOp> get_delete_op(RGWObjectCtx*) = 0;
+ virtual std::unique_ptr<DeleteOp> get_delete_op() = 0;
/** Get @a count OMAP values via listing, starting at @a marker for this object */
virtual int omap_get_vals(const DoutPrefixProvider *dpp, const std::string& marker, uint64_t count,
/* dang - This is temporary, until the API is completed */
/** Get the key for this object */
- rgw_obj_key& get_key() { return key; }
+ rgw_obj_key& get_key() { return state.obj.key; }
/** Set the instance for this object */
- void set_instance(const std::string &i) { key.set_instance(i); }
+ void set_instance(const std::string &i) { state.obj.key.set_instance(i); }
/** Get the instance for this object */
- const std::string &get_instance() const { return key.instance; }
+ const std::string &get_instance() const { return state.obj.key.instance; }
/** Check to see if this object has an instance set */
- bool have_instance(void) { return key.have_instance(); }
+ bool have_instance(void) { return state.obj.key.have_instance(); }
+ /** Clear the instance on this object */
+ void clear_instance() { state.obj.key.instance.clear(); }
friend inline std::ostream& operator<<(std::ostream& out, const Object& o) {
if (o.bucket)
out << o.bucket << ":";
- out << o.key;
+ out << o.state.obj.key;
return out;
}
friend inline std::ostream& operator<<(std::ostream& out, const Object* o) {
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() = 0;
/** Initialize this upload */
- virtual int init(const DoutPrefixProvider* dpp, optional_yield y, RGWObjectCtx* obj_ctx, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) = 0;
+ virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) = 0;
/** List all the parts of this upload, filling the parts cache */
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated,
bool assume_unsorted = false) = 0;
/** Abort this upload */
- virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct,
- RGWObjectCtx* obj_ctx) = 0;
+ virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct) = 0;
/** Complete this upload, making it available as a normal object */
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
- rgw::sal::Object* target_obj,
- RGWObjectCtx* obj_ctx) = 0;
+ rgw::sal::Object* target_obj) = 0;
/** Get placement and/or attribute info for this upload */
- virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) = 0;
+ virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) = 0;
/** Get a Writer to write to a part of this upload */
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) = 0;
return std::make_unique<DBLuaScriptManager>(this);
}
- int DBObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, RGWObjState **state, optional_yield y, bool follow_olh)
+ int DBObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **pstate, optional_yield y, bool follow_olh)
{
- *state = &(this->state);
+ RGWObjState* astate;
DB::Object op_target(store->getDB(), get_bucket()->get_info(), get_obj());
- return op_target.get_obj_state(dpp, get_bucket()->get_info(), get_obj(), follow_olh, state);
+ int ret = op_target.get_obj_state(dpp, get_bucket()->get_info(), get_obj(), follow_olh, &astate);
+ if (ret < 0) {
+ return ret;
+ }
+
+ /* Don't overwrite obj, atomic, or prefetch */
+ rgw_obj obj = get_obj();
+ bool is_atomic = state.is_atomic;
+ bool prefetch_data = state.prefetch_data;
+
+ state = *astate;
+ *pstate = &state;
+
+ state.obj = obj;
+ state.is_atomic = is_atomic;
+ state.prefetch_data = prefetch_data;
+ return ret;
}
int DBObject::read_attrs(const DoutPrefixProvider* dpp, DB::Object::Read &read_op, optional_yield y, rgw_obj* target_obj)
{
read_op.params.attrs = &attrs;
read_op.params.target_obj = target_obj;
- read_op.params.obj_size = &obj_size;
- read_op.params.lastmod = &mtime;
+ read_op.params.obj_size = &state.size;
+ read_op.params.lastmod = &state.mtime;
return read_op.prepare(dpp);
}
- int DBObject::set_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, Attrs* setattrs, Attrs* delattrs, optional_yield y, rgw_obj* target_obj)
+ int DBObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y)
{
Attrs empty;
DB::Object op_target(store->getDB(),
- get_bucket()->get_info(), target_obj ? *target_obj : get_obj());
+ get_bucket()->get_info(), get_obj());
return op_target.set_attrs(dpp, setattrs ? *setattrs : empty, delattrs);
}
- int DBObject::get_obj_attrs(RGWObjectCtx* rctx, optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
+ int DBObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
{
DB::Object op_target(store->getDB(), get_bucket()->get_info(), get_obj());
DB::Object::Read read_op(&op_target);
return read_attrs(dpp, read_op, y, target_obj);
}
- int DBObject::modify_obj_attrs(RGWObjectCtx* rctx, const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
+ int DBObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
{
rgw_obj target = get_obj();
- int r = get_obj_attrs(rctx, y, dpp, &target);
+ int r = get_obj_attrs(y, dpp, &target);
if (r < 0) {
return r;
}
- set_atomic(rctx);
+ set_atomic();
attrs[attr_name] = attr_val;
- return set_obj_attrs(dpp, rctx, &attrs, nullptr, y, &target);
+ return set_obj_attrs(dpp, &attrs, nullptr, y);
}
- int DBObject::delete_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, const char* attr_name, optional_yield y)
+ int DBObject::delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y)
{
- rgw_obj target = get_obj();
Attrs rmattr;
bufferlist bl;
- set_atomic(rctx);
+ set_atomic();
rmattr[attr_name] = bl;
- return set_obj_attrs(dpp, rctx, nullptr, &rmattr, y, &target);
- }
-
- /* RGWObjectCtx will be moved out of sal */
- /* XXX: Placeholder. Should not be needed later after Dan's patch */
- void DBObject::set_atomic(RGWObjectCtx* rctx) const
- {
- return;
- }
-
- /* RGWObjectCtx will be moved out of sal */
- /* XXX: Placeholder. Should not be needed later after Dan's patch */
- void DBObject::set_prefetch_data(RGWObjectCtx* rctx)
- {
- return;
- }
-
- /* RGWObjectCtx will be moved out of sal */
- /* XXX: Placeholder. Should not be needed later after Dan's patch */
- void DBObject::set_compressed(RGWObjectCtx* rctx)
- {
- return;
+ return set_obj_attrs(dpp, nullptr, &rmattr, y);
}
bool DBObject::is_expired() {
void DBObject::gen_rand_obj_instance_name()
{
- store->getDB()->gen_rand_obj_instance_name(&key);
+ store->getDB()->gen_rand_obj_instance_name(&state.obj.key);
}
return new MPDBSerializer(dpp, store, this, lock_name);
}
- int DBObject::transition(RGWObjectCtx& rctx,
- Bucket* bucket,
+ int DBObject::transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
return true;
}
- int DBObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f, RGWObjectCtx* obj_ctx)
+ int DBObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f)
{
return 0;
}
- std::unique_ptr<Object::ReadOp> DBObject::get_read_op(RGWObjectCtx* ctx)
+ std::unique_ptr<Object::ReadOp> DBObject::get_read_op()
{
- return std::make_unique<DBObject::DBReadOp>(this, ctx);
+ return std::make_unique<DBObject::DBReadOp>(this, nullptr);
}
DBObject::DBReadOp::DBReadOp(DBObject *_source, RGWObjectCtx *_rctx) :
return parent_op.get_attr(dpp, name, dest);
}
- std::unique_ptr<Object::DeleteOp> DBObject::get_delete_op(RGWObjectCtx* ctx)
+ std::unique_ptr<Object::DeleteOp> DBObject::get_delete_op()
{
- return std::make_unique<DBObject::DBDeleteOp>(this, ctx);
+ return std::make_unique<DBObject::DBDeleteOp>(this);
}
- DBObject::DBDeleteOp::DBDeleteOp(DBObject *_source, RGWObjectCtx *_rctx) :
+ DBObject::DBDeleteOp::DBDeleteOp(DBObject *_source) :
source(_source),
- rctx(_rctx),
op_target(_source->store->getDB(),
_source->get_bucket()->get_info(),
_source->get_obj()),
return ret;
}
- int DBObject::delete_object(const DoutPrefixProvider* dpp, RGWObjectCtx* obj_ctx, optional_yield y, bool prevent_versioning)
+ int DBObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, bool prevent_versioning)
{
- DB::Object del_target(store->getDB(), bucket->get_info(), *obj_ctx, get_obj());
+ DB::Object del_target(store->getDB(), bucket->get_info(), get_obj());
DB::Object::Delete del_op(&del_target);
del_op.params.bucket_owner = bucket->get_info().owner;
return 0;
}
- int DBObject::copy_object(RGWObjectCtx& obj_ctx,
- User* user,
+ int DBObject::copy_object(User* user,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
return parent_op.iterate(dpp, ofs, end, cb);
}
- int DBObject::swift_versioning_restore(RGWObjectCtx* obj_ctx,
- bool& restored,
+ int DBObject::swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp)
{
return 0;
}
- int DBObject::swift_versioning_copy(RGWObjectCtx* obj_ctx,
- const DoutPrefixProvider* dpp,
+ int DBObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
}
- int DBMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct,
- RGWObjectCtx *obj_ctx)
+ int DBMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct)
{
std::unique_ptr<rgw::sal::Object> meta_obj = get_meta_obj();
meta_obj->set_in_extra_data(true);
meta_obj->set_hash_source(mp_obj.get_key());
int ret;
- std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = meta_obj->get_delete_op(obj_ctx);
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = meta_obj->get_delete_op();
del_op->params.bucket_owner = bucket->get_acl_owner();
del_op->params.versioning_status = 0;
return bucket->get_object(rgw_obj_key(get_meta(), string(), mp_ns));
}
- int DBMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs)
+ int DBMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs)
{
int ret;
std::string oid = mp_obj.get_key();
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
- rgw::sal::Object* target_obj,
- RGWObjectCtx* obj_ctx)
+ rgw::sal::Object* target_obj)
{
char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
return ret;
}
- int DBMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
+ int DBMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
{
if (!rule && !attrs) {
return 0;
bufferlist headbl;
/* Read the obj head which contains the multipart_upload_info */
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op = meta_obj->get_read_op(obj_ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op = meta_obj->get_read_op();
int ret = read_op->prepare(y, dpp);
if (ret < 0) {
if (ret == -ENOENT) {
const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
{
return std::make_unique<DBMultipartWriter>(dpp, y, this,
std::move(_head_obj), store, owner,
- obj_ctx, ptail_placement_rule, part_num, part_num_str);
+ ptail_placement_rule, part_num, part_num_str);
}
DBMultipartWriter::DBMultipartWriter(const DoutPrefixProvider *dpp,
MultipartUpload* upload,
std::unique_ptr<rgw::sal::Object> _head_obj,
DBStore* _store,
- const rgw_user& _owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _part_num, const std::string& _part_num_str):
Writer(dpp, y),
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
DBStore* _store,
- const rgw_user& _owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag) :
std::unique_ptr<Writer> DBStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
std::unique_ptr<Writer> DBStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) {
return std::make_unique<DBAtomicWriter>(dpp, y,
- std::move(_head_obj), this, owner, obj_ctx,
+ std::move(_head_obj), this, owner,
ptail_placement_rule, olh_epoch, unique_tag);
}
std::unique_ptr<Notification> DBStore::get_notification(
const DoutPrefixProvider* dpp, rgw::sal::Object* obj,
- rgw::sal::Object* src_obj, RGWObjectCtx* rctx,
+ rgw::sal::Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id,
optional_yield y)
virtual const ACLOwner& get_owner() const override { return owner; }
virtual ceph::real_time& get_mtime() { return mtime; }
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() override;
- virtual int init(const DoutPrefixProvider* dpp, optional_yield y, RGWObjectCtx* obj_ctx, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
+ virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated,
bool assume_unsorted = false) override;
- virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct,
- RGWObjectCtx* obj_ctx) override;
+ virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct) override;
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
- rgw::sal::Object* target_obj,
- RGWObjectCtx* obj_ctx) override;
- virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override;
+ rgw::sal::Object* target_obj) override;
+ virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override;
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
private:
DBStore* store;
RGWAccessControlPolicy acls;
- /* XXX: to be removed. Till Dan's patch comes, a placeholder
- * for RGWObjState
- */
- RGWObjState state;
public:
struct DBReadOp : public ReadOp {
struct DBDeleteOp : public DeleteOp {
private:
DBObject* source;
- RGWObjectCtx* rctx;
DB::Object op_target;
DB::Object::Delete parent_op;
public:
- DBDeleteOp(DBObject* _source, RGWObjectCtx* _rctx);
+ DBDeleteOp(DBObject* _source);
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
};
DBObject(DBObject& _o) = default;
virtual int delete_object(const DoutPrefixProvider* dpp,
- RGWObjectCtx* obj_ctx,
optional_yield y,
bool prevent_versioning = false) override;
virtual int delete_obj_aio(const DoutPrefixProvider* dpp, RGWObjState* astate, Completions* aio,
bool keep_index_consistent, optional_yield y) override;
- virtual int copy_object(RGWObjectCtx& obj_ctx, User* user,
+ virtual int copy_object(User* user,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const RGWAccessControlPolicy& acl) override { acls = acl; return 0; }
- virtual void set_atomic(RGWObjectCtx* rctx) const override;
- virtual void set_prefetch_data(RGWObjectCtx* rctx) override;
- virtual void set_compressed(RGWObjectCtx* rctx) override;
-
- virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
- virtual int set_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, Attrs* setattrs, Attrs* delattrs, optional_yield y, rgw_obj* target_obj = NULL) override;
- virtual int get_obj_attrs(RGWObjectCtx* rctx, optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
- virtual int modify_obj_attrs(RGWObjectCtx* rctx, const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
- virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, const char* attr_name, optional_yield y) override;
+
+ virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
+ virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y) override;
+ virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
+ virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
+ virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y) override;
virtual bool is_expired() override;
virtual void gen_rand_obj_instance_name() override;
virtual std::unique_ptr<Object> clone() override {
return std::unique_ptr<Object>(new DBObject(*this));
}
virtual MPSerializer* get_serializer(const DoutPrefixProvider *dpp, const std::string& lock_name) override;
- virtual int transition(RGWObjectCtx& rctx,
- Bucket* bucket,
+ virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) override;
- virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f, RGWObjectCtx* obj_ctx) override;
+ virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
/* Swift versioning */
- virtual int swift_versioning_restore(RGWObjectCtx* obj_ctx,
- bool& restored,
+ virtual int swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp) override;
- virtual int swift_versioning_copy(RGWObjectCtx* obj_ctx,
- const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
- virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx *) override;
- virtual std::unique_ptr<DeleteOp> get_delete_op(RGWObjectCtx*) override;
+ virtual std::unique_ptr<ReadOp> get_read_op() override;
+ virtual std::unique_ptr<DeleteOp> get_delete_op() override;
/* OMAP */
virtual int omap_get_vals(const DoutPrefixProvider *dpp, const std::string& marker, uint64_t count,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
DBStore* _store,
- const rgw_user& _owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag);
optional_yield y, MultipartUpload* upload,
std::unique_ptr<rgw::sal::Object> _head_obj,
DBStore* _store,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num, const std::string& part_num_str);
~DBMultipartWriter() = default;
virtual std::unique_ptr<Notification> get_notification(
const DoutPrefixProvider* dpp, rgw::sal::Object* obj,
- rgw::sal::Object* src_obj, RGWObjectCtx* rctx,
+ rgw::sal::Object* src_obj,
rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id,
optional_yield y) override;
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
return std::make_unique<MotrLuaScriptManager>(this);
}
-int MotrObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, RGWObjState **_state, optional_yield y, bool follow_olh)
+int MotrObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **_state, optional_yield y, bool follow_olh)
{
- if (state == nullptr)
- state = new RGWObjState();
- *_state = state;
-
// Get object's metadata (those stored in rgw_bucket_dir_entry).
bufferlist bl;
if (this->store->get_obj_meta_cache()->get(dpp, this->get_key().to_str(), bl)) {
this->category = ent.meta.category;
// Set object state.
- state->obj = get_obj();
- state->exists = true;
- state->size = ent.meta.size;
- state->accounted_size = ent.meta.size;
- state->mtime = ent.meta.mtime;
+ state.exists = true;
+ state.size = ent.meta.size;
+ state.accounted_size = ent.meta.size;
+ state.mtime = ent.meta.mtime;
- state->has_attrs = true;
+ state.has_attrs = true;
bufferlist etag_bl;
string& etag = ent.meta.etag;
ldpp_dout(dpp, 20) <<__func__<< ": object's etag: " << ent.meta.etag << dendl;
etag_bl.append(etag);
- state->attrset[RGW_ATTR_ETAG] = etag_bl;
+ state.attrset[RGW_ATTR_ETAG] = etag_bl;
return 0;
}
MotrObject::~MotrObject() {
- delete state;
this->close_mobj();
}
// return read_op.prepare(dpp);
// }
-int MotrObject::set_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, Attrs* setattrs, Attrs* delattrs, optional_yield y, rgw_obj* target_obj)
+int MotrObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y)
{
// TODO: implement
ldpp_dout(dpp, 20) <<__func__<< ": MotrObject::set_obj_attrs()" << dendl;
return 0;
}
-int MotrObject::get_obj_attrs(RGWObjectCtx* rctx, optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
+int MotrObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
{
if (this->category == RGWObjCategory::MultiMeta)
return 0;
return 0;
}
-int MotrObject::modify_obj_attrs(RGWObjectCtx* rctx, const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
+int MotrObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
{
rgw_obj target = get_obj();
- int r = get_obj_attrs(rctx, y, dpp, &target);
+ int r = get_obj_attrs(y, dpp, &target);
if (r < 0) {
return r;
}
- set_atomic(rctx);
+ set_atomic();
attrs[attr_name] = attr_val;
- return set_obj_attrs(dpp, rctx, &attrs, nullptr, y, &target);
+ return set_obj_attrs(dpp, &attrs, nullptr, y);
}
-int MotrObject::delete_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, const char* attr_name, optional_yield y)
+int MotrObject::delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y)
{
rgw_obj target = get_obj();
Attrs rmattr;
bufferlist bl;
- set_atomic(rctx);
+ set_atomic();
rmattr[attr_name] = bl;
- return set_obj_attrs(dpp, rctx, nullptr, &rmattr, y, &target);
-}
-
-/* RGWObjectCtx will be moved out of sal */
-/* XXX: Placeholder. Should not be needed later after Dan's patch */
-void MotrObject::set_atomic(RGWObjectCtx* rctx) const
-{
- return;
-}
-
-/* RGWObjectCtx will be moved out of sal */
-/* XXX: Placeholder. Should not be needed later after Dan's patch */
-void MotrObject::set_prefetch_data(RGWObjectCtx* rctx)
-{
- return;
-}
-
-/* RGWObjectCtx will be moved out of sal */
-/* XXX: Placeholder. Should not be needed later after Dan's patch */
-void MotrObject::set_compressed(RGWObjectCtx* rctx)
-{
- return;
+ return set_obj_attrs(dpp, nullptr, &rmattr, y);
}
bool MotrObject::is_expired() {
char buf[OBJ_INSTANCE_LEN + 1];
gen_rand_alphanumeric_no_underscore(store->ctx(), buf, OBJ_INSTANCE_LEN);
- key.set_instance(buf);
+ state.obj.key.set_instance(buf);
}
int MotrObject::omap_get_vals(const DoutPrefixProvider *dpp, const std::string& marker, uint64_t count,
return new MPMotrSerializer(dpp, store, this, lock_name);
}
-int MotrObject::transition(RGWObjectCtx& rctx,
- Bucket* bucket,
+int MotrObject::transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
return true;
}
-int MotrObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f, RGWObjectCtx* obj_ctx)
+int MotrObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f)
{
return 0;
}
-std::unique_ptr<Object::ReadOp> MotrObject::get_read_op(RGWObjectCtx* ctx)
+std::unique_ptr<Object::ReadOp> MotrObject::get_read_op()
{
- return std::make_unique<MotrObject::MotrReadOp>(this, ctx);
+ return std::make_unique<MotrObject::MotrReadOp>(this);
}
-MotrObject::MotrReadOp::MotrReadOp(MotrObject *_source, RGWObjectCtx *_rctx) :
- source(_source),
- rctx(_rctx)
+MotrObject::MotrReadOp::MotrReadOp(MotrObject *_source) :
+ source(_source)
{ }
int MotrObject::MotrReadOp::prepare(optional_yield y, const DoutPrefixProvider* dpp)
return -ENODATA;
}
-std::unique_ptr<Object::DeleteOp> MotrObject::get_delete_op(RGWObjectCtx* ctx)
+std::unique_ptr<Object::DeleteOp> MotrObject::get_delete_op()
{
- return std::make_unique<MotrObject::MotrDeleteOp>(this, ctx);
+ return std::make_unique<MotrObject::MotrDeleteOp>(this);
}
-MotrObject::MotrDeleteOp::MotrDeleteOp(MotrObject *_source, RGWObjectCtx *_rctx) :
- source(_source),
- rctx(_rctx)
+MotrObject::MotrDeleteOp::MotrDeleteOp(MotrObject *_source) :
+ source(_source)
{ }
// Implementation of DELETE OBJ also requires MotrObject::get_obj_state()
return 0;
}
-int MotrObject::delete_object(const DoutPrefixProvider* dpp, RGWObjectCtx* obj_ctx, optional_yield y, bool prevent_versioning)
+int MotrObject::delete_object(const DoutPrefixProvider* dpp, optional_yield y, bool prevent_versioning)
{
- MotrObject::MotrDeleteOp del_op(this, obj_ctx);
+ MotrObject::MotrDeleteOp del_op(this);
del_op.params.bucket_owner = bucket->get_info().owner;
del_op.params.versioning_status = bucket->get_info().versioning_status();
return 0;
}
-int MotrObject::copy_object(RGWObjectCtx& obj_ctx,
- User* user,
+int MotrObject::copy_object(User* user,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
return 0;
}
-int MotrObject::swift_versioning_restore(RGWObjectCtx* obj_ctx,
- bool& restored,
+int MotrObject::swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp)
{
return 0;
}
-int MotrObject::swift_versioning_copy(RGWObjectCtx* obj_ctx,
- const DoutPrefixProvider* dpp,
+int MotrObject::swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y)
{
return 0;
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
MotrStore* _store,
- const rgw_user& _owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag) :
return store->delete_motr_idx_by_name(obj_part_iname);
}
-int MotrMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct,
- RGWObjectCtx *obj_ctx)
+int MotrMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct)
{
int rc;
WRITE_CLASS_ENCODER(motr_multipart_upload_info)
int MotrMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y,
- RGWObjectCtx* obj_ctx, ACLOwner& _owner,
+ ACLOwner& _owner,
rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs)
{
int rc;
RGWCompressionInfo& cs_info, off_t& off,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
- rgw::sal::Object* target_obj,
- RGWObjectCtx* obj_ctx)
+ rgw::sal::Object* target_obj)
{
char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
M0_IC_DEL, meta_obj->get_key().to_str(), bl);
}
-int MotrMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
+int MotrMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
{
if (!rule && !attrs) {
return 0;
const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
{
return std::make_unique<MotrMultipartWriter>(dpp, y, this,
std::move(_head_obj), store, owner,
- obj_ctx, ptail_placement_rule, part_num, part_num_str);
+ ptail_placement_rule, part_num, part_num_str);
}
int MotrMultipartWriter::prepare(optional_yield y)
std::unique_ptr<Writer> MotrStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
std::unique_ptr<Writer> MotrStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) {
return std::make_unique<MotrAtomicWriter>(dpp, y,
- std::move(_head_obj), this, owner, obj_ctx,
+ std::move(_head_obj), this, owner,
ptail_placement_rule, olh_epoch, unique_tag);
}
}
std::unique_ptr<Notification> MotrStore::get_notification(const DoutPrefixProvider* dpp, Object* obj,
- Object* src_obj, RGWObjectCtx* rctx, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
+ Object* src_obj, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y)
{
return std::make_unique<MotrNotification>(obj, src_obj, event_type);
private:
MotrStore *store;
RGWAccessControlPolicy acls;
- /* XXX: to be removed. Till Dan's patch comes, a placeholder
- * for RGWObjState
- */
- RGWObjState *state;
-
RGWObjCategory category;
// If this object is pat of a multipart uploaded one.
struct MotrReadOp : public ReadOp {
private:
MotrObject* source;
- RGWObjectCtx* rctx;
// The set of part objects if the source is
// a multipart uploaded object.
std::map<int, std::unique_ptr<MotrObject>> part_objs;
public:
- MotrReadOp(MotrObject *_source, RGWObjectCtx *_rctx);
+ MotrReadOp(MotrObject *_source);
virtual int prepare(optional_yield y, const DoutPrefixProvider* dpp) override;
virtual int read(int64_t off, int64_t end, bufferlist& bl, optional_yield y, const DoutPrefixProvider* dpp) override;
struct MotrDeleteOp : public DeleteOp {
private:
MotrObject* source;
- RGWObjectCtx* rctx;
public:
- MotrDeleteOp(MotrObject* _source, RGWObjectCtx* _rctx);
+ MotrDeleteOp(MotrObject* _source);
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
};
MotrObject() = default;
MotrObject(MotrStore *_st, const rgw_obj_key& _k)
- : Object(_k), store(_st), acls(), state(NULL) {}
+ : Object(_k), store(_st), acls() {}
MotrObject(MotrStore *_st, const rgw_obj_key& _k, Bucket* _b)
- : Object(_k, _b), store(_st), acls(), state(NULL) {}
+ : Object(_k, _b), store(_st), acls() {}
MotrObject(MotrObject& _o) = default;
virtual ~MotrObject();
virtual int delete_object(const DoutPrefixProvider* dpp,
- RGWObjectCtx* obj_ctx,
optional_yield y,
bool prevent_versioning = false) override;
virtual int delete_obj_aio(const DoutPrefixProvider* dpp, RGWObjState* astate, Completions* aio,
bool keep_index_consistent, optional_yield y) override;
- virtual int copy_object(RGWObjectCtx& obj_ctx, User* user,
+ virtual int copy_object(User* user,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const RGWAccessControlPolicy& acl) override { acls = acl; return 0; }
- virtual void set_atomic(RGWObjectCtx* rctx) const override;
- virtual void set_prefetch_data(RGWObjectCtx* rctx) override;
- virtual void set_compressed(RGWObjectCtx* rctx) override;
-
- virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
- virtual int set_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, Attrs* setattrs, Attrs* delattrs, optional_yield y, rgw_obj* target_obj = NULL) override;
- virtual int get_obj_attrs(RGWObjectCtx* rctx, optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
- virtual int modify_obj_attrs(RGWObjectCtx* rctx, const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
- virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, const char* attr_name, optional_yield y) override;
+ virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
+ virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y) override;
+ virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
+ virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
+ virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y) override;
virtual bool is_expired() override;
virtual void gen_rand_obj_instance_name() override;
virtual std::unique_ptr<Object> clone() override {
return std::unique_ptr<Object>(new MotrObject(*this));
}
virtual MPSerializer* get_serializer(const DoutPrefixProvider *dpp, const std::string& lock_name) override;
- virtual int transition(RGWObjectCtx& rctx,
- Bucket* bucket,
+ virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) override;
- virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f, RGWObjectCtx* obj_ctx) override;
+ virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
/* Swift versioning */
- virtual int swift_versioning_restore(RGWObjectCtx* obj_ctx,
- bool& restored,
+ virtual int swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp) override;
- virtual int swift_versioning_copy(RGWObjectCtx* obj_ctx,
- const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
- virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx *) override;
- virtual std::unique_ptr<DeleteOp> get_delete_op(RGWObjectCtx*) override;
+ virtual std::unique_ptr<ReadOp> get_read_op() override;
+ virtual std::unique_ptr<DeleteOp> get_delete_op() override;
/* OMAP */
virtual int omap_get_vals(const DoutPrefixProvider *dpp, const std::string& marker, uint64_t count,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
MotrStore* _store,
- const rgw_user& _owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& _owner,
const rgw_placement_rule *_ptail_placement_rule,
uint64_t _olh_epoch,
const std::string& _unique_tag);
optional_yield y, MultipartUpload* upload,
std::unique_ptr<rgw::sal::Object> _head_obj,
MotrStore* _store,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t _part_num, const std::string& part_num_str) :
Writer(dpp, y), store(_store), head_obj(std::move(_head_obj)),
virtual const ACLOwner& get_owner() const override { return owner; }
virtual ceph::real_time& get_mtime() { return mtime; }
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() override;
- virtual int init(const DoutPrefixProvider* dpp, optional_yield y, RGWObjectCtx* obj_ctx, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
+ virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated,
bool assume_unsorted = false) override;
- virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct,
- RGWObjectCtx* obj_ctx) override;
+ virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct) override;
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
RGWCompressionInfo& cs_info, off_t& off,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
- rgw::sal::Object* target_obj,
- RGWObjectCtx* obj_ctx) override;
- virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override;
+ rgw::sal::Object* target_obj) override;
+ virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override;
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj, rgw::sal::Object* src_obj,
struct req_state* s, rgw::notify::EventType event_type, const std::string* object_name=nullptr) override;
virtual std::unique_ptr<Notification> get_notification(const DoutPrefixProvider* dpp, rgw::sal::Object* obj,
- rgw::sal::Object* src_obj, RGWObjectCtx* rctx, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
+ rgw::sal::Object* src_obj, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket,
std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y) override;
virtual RGWLC* get_rgwlc(void) override { return NULL; }
virtual RGWCoroutinesManagerRegistry* get_cr_registry() override { return NULL; }
virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) override;
std::vector<rgw_bucket_dir_entry>::iterator it = results.objs.begin();
for (; it != results.objs.end(); ++it) {
RGWObjState *astate = NULL;
+ RGWObjManifest *amanifest = nullptr;
std::unique_ptr<rgw::sal::Object> obj = get_object((*it).key);
- ret = obj->get_obj_state(dpp, &obj_ctx, &astate, y, false);
+ ret = store->getRados()->get_obj_state(dpp, &obj_ctx, obj->get_bucket()->get_info(),
+ obj.get(), &astate, &amanifest,
+ false, y);
if (ret == -ENOENT) {
ldpp_dout(dpp, 1) << "WARNING: cannot find obj state for obj " << obj << dendl;
continue;
return ret;
}
- if (astate->manifest) {
- RGWObjManifest& manifest = *astate->manifest;
+ if (amanifest) {
+ RGWObjManifest& manifest = *amanifest;
RGWObjManifest::obj_iterator miter = manifest.obj_begin(dpp);
std::unique_ptr<rgw::sal::Object> head_obj = get_object(manifest.get_obj().key);
rgw_raw_obj raw_head_obj;
constexpr int max = 1000;
int ret, num_deleted = 0;
vector<std::unique_ptr<MultipartUpload>> uploads;
- RGWObjectCtx obj_ctx(store);
string marker;
bool is_truncated;
if (!uploads.empty()) {
for (const auto& upload : uploads) {
- ret = upload->abort(dpp, cct, &obj_ctx);
+ ret = upload->abort(dpp, cct);
if (ret < 0) {
// we're doing a best-effort; if something cannot be found,
// log it and keep moving forward
return std::make_unique<RadosNotification>(s, this, obj, src_obj, s, event_type, object_name);
}
-std::unique_ptr<Notification> RadosStore::get_notification(const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj, RGWObjectCtx* rctx, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y)
+std::unique_ptr<Notification> RadosStore::get_notification(const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y)
{
- return std::make_unique<RadosNotification>(dpp, this, obj, src_obj, rctx, event_type, _bucket, _user_id, _user_tenant, _req_id, y);
+ return std::make_unique<RadosNotification>(dpp, this, obj, src_obj, event_type, _bucket, _user_id, _user_tenant, _req_id, y);
}
int RadosStore::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj)
std::unique_ptr<Writer> RadosStore::get_append_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
auto aio = rgw::make_throttle(ctx()->_conf->rgw_put_obj_min_window_size, y);
return std::make_unique<RadosAppendWriter>(dpp, y,
std::move(_head_obj),
- this, std::move(aio), owner, obj_ctx,
+ this, std::move(aio), owner,
ptail_placement_rule,
unique_tag, position,
cur_accounted_size);
std::unique_ptr<Writer> RadosStore::get_atomic_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag)
auto aio = rgw::make_throttle(ctx()->_conf->rgw_put_obj_min_window_size, y);
return std::make_unique<RadosAtomicWriter>(dpp, y,
std::move(_head_obj),
- this, std::move(aio), owner, obj_ctx,
+ this, std::move(aio), owner,
ptail_placement_rule,
olh_epoch, unique_tag);
}
return rados->get_obj_head_ioctx(dpp, bucket_info, obj, ioctx);
}
-RadosObject::~RadosObject() {}
+RadosObject::~RadosObject()
+{
+ if (rados_ctx_owned)
+ delete rados_ctx;
+}
-int RadosObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, RGWObjState **state, optional_yield y, bool follow_olh)
+int RadosObject::get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **pstate, optional_yield y, bool follow_olh)
{
- return store->getRados()->get_obj_state(dpp, rctx, bucket->get_info(), get_obj(), state, follow_olh, y);
+ int ret = store->getRados()->get_obj_state(dpp, rados_ctx, bucket->get_info(), this, pstate, &manifest, follow_olh, y);
+ if (ret < 0) {
+ return ret;
+ }
+
+ /* Don't overwrite obj, atomic, or prefetch */
+ rgw_obj obj = get_obj();
+ bool is_atomic = state.is_atomic;
+ bool prefetch_data = state.prefetch_data;
+
+ state = **pstate;
+
+ state.obj = obj;
+ state.is_atomic = is_atomic;
+ state.prefetch_data = prefetch_data;
+ return ret;
}
int RadosObject::read_attrs(const DoutPrefixProvider* dpp, RGWRados::Object::Read &read_op, optional_yield y, rgw_obj* target_obj)
{
read_op.params.attrs = &attrs;
read_op.params.target_obj = target_obj;
- read_op.params.obj_size = &obj_size;
- read_op.params.lastmod = &mtime;
+ read_op.params.obj_size = &state.size;
+ read_op.params.lastmod = &state.mtime;
return read_op.prepare(y, dpp);
}
-int RadosObject::set_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, Attrs* setattrs, Attrs* delattrs, optional_yield y, rgw_obj* target_obj)
+int RadosObject::set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y)
{
Attrs empty;
- rgw_obj target = get_obj();
-
- if (!target_obj)
- target_obj = ⌖
-
- return store->getRados()->set_attrs(dpp, rctx,
+ return store->getRados()->set_attrs(dpp, rados_ctx,
bucket->get_info(),
- *target_obj,
+ this,
setattrs ? *setattrs : empty,
delattrs ? delattrs : nullptr,
y);
}
-int RadosObject::get_obj_attrs(RGWObjectCtx* rctx, optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
+int RadosObject::get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj)
{
- RGWRados::Object op_target(store->getRados(), bucket->get_info(), *rctx, get_obj());
+ RGWRados::Object op_target(store->getRados(), bucket, *rados_ctx, this);
RGWRados::Object::Read read_op(&op_target);
return read_attrs(dpp, read_op, y, target_obj);
}
-int RadosObject::modify_obj_attrs(RGWObjectCtx* rctx, const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
+int RadosObject::modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp)
{
rgw_obj target = get_obj();
- int r = get_obj_attrs(rctx, y, dpp, &target);
+ rgw_obj save = get_obj();
+ int r = get_obj_attrs(y, dpp, &target);
if (r < 0) {
return r;
}
- set_atomic(rctx);
+
+ /* Temporarily set target */
+ state.obj = target;
+ set_atomic();
attrs[attr_name] = attr_val;
- return set_obj_attrs(dpp, rctx, &attrs, nullptr, y, &target);
+ r = set_obj_attrs(dpp, &attrs, nullptr, y);
+ /* Restore target */
+ state.obj = save;
+
+ return r;
}
-int RadosObject::delete_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, const char* attr_name, optional_yield y)
+int RadosObject::delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y)
{
Attrs rmattr;
bufferlist bl;
- set_atomic(rctx);
+ set_atomic();
rmattr[attr_name] = bl;
- return set_obj_attrs(dpp, rctx, nullptr, &rmattr, y);
-}
-
-void RadosObject::set_compressed(RGWObjectCtx* rctx) {
- rgw_obj obj = get_obj();
- store->getRados()->set_compressed(rctx, obj);
-}
-
-void RadosObject::set_atomic(RGWObjectCtx* rctx) const
-{
- rgw_obj obj = get_obj();
- store->getRados()->set_atomic(rctx, obj);
-}
-
-void RadosObject::set_prefetch_data(RGWObjectCtx* rctx)
-{
- rgw_obj obj = get_obj();
- store->getRados()->set_prefetch_data(rctx, obj);
+ return set_obj_attrs(dpp, nullptr, &rmattr, y);
}
bool RadosObject::is_expired() {
void RadosObject::gen_rand_obj_instance_name()
{
- store->getRados()->gen_rand_obj_instance_name(&key);
+ store->getRados()->gen_rand_obj_instance_name(&state.obj.key);
}
void RadosObject::raw_obj_to_obj(const rgw_raw_obj& raw_obj)
return new MPRadosSerializer(dpp, store, this, lock_name);
}
-int RadosObject::transition(RGWObjectCtx& rctx,
- Bucket* bucket,
- const rgw_placement_rule& placement_rule,
- const real_time& mtime,
- uint64_t olh_epoch,
- const DoutPrefixProvider* dpp,
- optional_yield y)
+int RadosObject::transition(Bucket* bucket,
+ const rgw_placement_rule& placement_rule,
+ const real_time& mtime,
+ uint64_t olh_epoch,
+ const DoutPrefixProvider* dpp,
+ optional_yield y)
{
- return store->getRados()->transition_obj(rctx, bucket, *this, placement_rule, mtime, olh_epoch, dpp, y);
+ return store->getRados()->transition_obj(*rados_ctx, bucket, *this, placement_rule, mtime, olh_epoch, dpp, y);
}
int RadosObject::get_max_chunk_size(const DoutPrefixProvider* dpp, rgw_placement_rule placement_rule, uint64_t* max_chunk_size, uint64_t* alignment)
return p1 == p2;
}
-int RadosObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f, RGWObjectCtx* obj_ctx)
+int RadosObject::dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f)
{
int ret;
- RGWObjManifest *manifest{nullptr};
+ RGWObjManifest *amanifest{nullptr};
rgw_raw_obj head_obj;
- RGWRados::Object op_target(store->getRados(), get_bucket()->get_info(),
- *obj_ctx, get_obj());
+ RGWRados::Object op_target(store->getRados(), get_bucket(), *rados_ctx, this);
RGWRados::Object::Read parent_op(&op_target);
uint64_t obj_size;
head_obj = parent_op.state.head_obj;
- ret = op_target.get_manifest(dpp, &manifest, y);
+ ret = op_target.get_manifest(dpp, &amanifest, y);
if (ret < 0) {
return ret;
}
::encode_json("head", head_obj, f);
- ::encode_json("manifest", *manifest, f);
+ ::encode_json("manifest", *amanifest, f);
f->open_array_section("data_location");
- for (auto miter = manifest->obj_begin(dpp); miter != manifest->obj_end(dpp); ++miter) {
+ for (auto miter = amanifest->obj_begin(dpp); miter != amanifest->obj_end(dpp); ++miter) {
f->open_object_section("obj");
rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(store);
uint64_t ofs = miter.get_ofs();
- uint64_t left = manifest->get_obj_size() - ofs;
+ uint64_t left = amanifest->get_obj_size() - ofs;
::encode_json("ofs", miter.get_ofs(), f);
::encode_json("loc", raw_loc, f);
::encode_json("loc_ofs", miter.location_ofs(), f);
return 0;
}
-std::unique_ptr<Object::ReadOp> RadosObject::get_read_op(RGWObjectCtx* ctx)
+std::unique_ptr<Object::ReadOp> RadosObject::get_read_op()
{
- return std::make_unique<RadosObject::RadosReadOp>(this, ctx);
+ return std::make_unique<RadosObject::RadosReadOp>(this, rados_ctx);
}
RadosObject::RadosReadOp::RadosReadOp(RadosObject *_source, RGWObjectCtx *_rctx) :
source(_source),
rctx(_rctx),
op_target(_source->store->getRados(),
- _source->get_bucket()->get_info(),
+ _source->get_bucket(),
*static_cast<RGWObjectCtx *>(rctx),
- _source->get_obj()),
+ _source),
parent_op(&op_target)
{ }
return parent_op.get_attr(dpp, name, dest, y);
}
-std::unique_ptr<Object::DeleteOp> RadosObject::get_delete_op(RGWObjectCtx* ctx)
+std::unique_ptr<Object::DeleteOp> RadosObject::get_delete_op()
{
- return std::make_unique<RadosObject::RadosDeleteOp>(this, ctx);
+ return std::make_unique<RadosObject::RadosDeleteOp>(this);
}
-RadosObject::RadosDeleteOp::RadosDeleteOp(RadosObject *_source, RGWObjectCtx *_rctx) :
+RadosObject::RadosDeleteOp::RadosDeleteOp(RadosObject *_source) :
source(_source),
- rctx(_rctx),
op_target(_source->store->getRados(),
- _source->get_bucket()->get_info(),
- *static_cast<RGWObjectCtx *>(rctx),
- _source->get_obj()),
+ _source->get_bucket(),
+ _source->get_ctx(),
+ _source),
parent_op(&op_target)
{ }
}
int RadosObject::delete_object(const DoutPrefixProvider* dpp,
- RGWObjectCtx* obj_ctx,
optional_yield y,
bool prevent_versioning)
{
- RGWRados::Object del_target(store->getRados(), bucket->get_info(), *obj_ctx, get_obj());
+ RGWRados::Object del_target(store->getRados(), bucket, *rados_ctx, this);
RGWRados::Object::Delete del_op(&del_target);
del_op.params.bucket_owner = bucket->get_info().owner;
raio->handles, keep_index_consistent, y);
}
-int RadosObject::copy_object(RGWObjectCtx& obj_ctx,
- User* user,
+int RadosObject::copy_object(User* user,
req_info* info,
const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object,
const DoutPrefixProvider* dpp,
optional_yield y)
{
- return store->getRados()->copy_obj(obj_ctx,
+ return store->getRados()->copy_obj(*rados_ctx,
user->get_id(),
info,
source_zone,
return parent_op.iterate(dpp, ofs, end, cb, y);
}
-int RadosObject::swift_versioning_restore(RGWObjectCtx* obj_ctx,
- bool& restored,
- const DoutPrefixProvider* dpp)
+int RadosObject::swift_versioning_restore(bool& restored,
+ const DoutPrefixProvider* dpp)
{
- return store->getRados()->swift_versioning_restore(*obj_ctx,
+ return store->getRados()->swift_versioning_restore(*rados_ctx,
bucket->get_owner()->get_id(),
bucket,
this,
dpp);
}
-int RadosObject::swift_versioning_copy(RGWObjectCtx* obj_ctx,
- const DoutPrefixProvider* dpp,
- optional_yield y)
+int RadosObject::swift_versioning_copy(const DoutPrefixProvider* dpp, optional_yield y)
{
- return store->getRados()->swift_versioning_copy(*obj_ctx,
+ return store->getRados()->swift_versioning_copy(*rados_ctx,
bucket->get_info().owner,
bucket,
this,
y);
}
-int RadosMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct,
- RGWObjectCtx *obj_ctx)
+int RadosMultipartUpload::abort(const DoutPrefixProvider *dpp, CephContext *cct)
{
std::unique_ptr<rgw::sal::Object> meta_obj = get_meta_obj();
meta_obj->set_in_extra_data(true);
std::unique_ptr<rgw::sal::Object> obj = bucket->get_object(
rgw_obj_key(obj_part->oid, std::string(), RGW_OBJ_NS_MULTIPART));
obj->set_hash_source(mp_obj.get_key());
- ret = obj->delete_object(dpp, obj_ctx, null_yield);
+ ret = obj->delete_object(dpp, null_yield);
if (ret < 0 && ret != -ENOENT)
return ret;
} else {
}
}
- std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = meta_obj->get_delete_op(obj_ctx);
+ std::unique_ptr<rgw::sal::Object::DeleteOp> del_op = meta_obj->get_delete_op();
del_op->params.bucket_owner = bucket->get_acl_owner();
del_op->params.versioning_status = 0;
if (!remove_objs.empty()) {
return bucket->get_object(rgw_obj_key(get_meta(), string(), mp_ns));
}
-int RadosMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs)
+int RadosMultipartUpload::init(const DoutPrefixProvider *dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs)
{
int ret;
std::string oid = mp_obj.get_key();
+ RGWObjectCtx obj_ctx(store);
do {
char buf[33];
obj->set_hash_source(oid);
RGWRados::Object op_target(store->getRados(),
- obj->get_bucket()->get_info(),
- *obj_ctx, obj->get_obj());
+ obj->get_bucket(),
+ obj_ctx, obj.get());
RGWRados::Object::Write obj_op(&op_target);
op_target.set_versioning_disabled(true); /* no versioning for multipart meta */
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
- rgw::sal::Object* target_obj,
- RGWObjectCtx* obj_ctx)
+ rgw::sal::Object* target_obj)
{
char final_etag[CEPH_CRYPTO_MD5_DIGESTSIZE];
char final_etag_str[CEPH_CRYPTO_MD5_DIGESTSIZE * 2 + 16];
attrs[RGW_ATTR_COMPRESSION] = tmp;
}
- target_obj->set_atomic(obj_ctx);
+ target_obj->set_atomic();
RGWRados::Object op_target(store->getRados(),
- target_obj->get_bucket()->get_info(),
- *obj_ctx, target_obj->get_obj());
+ target_obj->get_bucket(),
+ dynamic_cast<RadosObject*>(target_obj)->get_ctx(),
+ target_obj);
RGWRados::Object::Write obj_op(&op_target);
obj_op.meta.manifest = &manifest;
return ret;
}
-int RadosMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
+int RadosMultipartUpload::get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs)
{
if (!rule && !attrs) {
return 0;
bufferlist headbl;
/* Read the obj head which contains the multipart_upload_info */
- std::unique_ptr<rgw::sal::Object::ReadOp> read_op = meta_obj->get_read_op(obj_ctx);
- meta_obj->set_prefetch_data(obj_ctx);
+ std::unique_ptr<rgw::sal::Object::ReadOp> read_op = meta_obj->get_read_op();
+ meta_obj->set_prefetch_data();
int ret = read_op->prepare(y, dpp);
if (ret < 0) {
const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str)
auto aio = rgw::make_throttle(store->ctx()->_conf->rgw_put_obj_min_window_size, y);
return std::make_unique<RadosMultipartWriter>(dpp, y, this,
std::move(_head_obj), store, std::move(aio), owner,
- obj_ctx, ptail_placement_rule, part_num, part_num_str);
+ ptail_placement_rule, part_num, part_num_str);
}
MPRadosSerializer::MPRadosSerializer(const DoutPrefixProvider *dpp, RadosStore* store, RadosObject* obj, const std::string& lock_name) :
namespace rgw { namespace sal {
-class RadosStore;
class RadosMultipartUpload;
class RadosCompletions : public Completions {
virtual int drain() override;
};
+class RadosZone : public Zone {
+ protected:
+ RadosStore* store;
+ public:
+ RadosZone(RadosStore* _store) : store(_store) {}
+ ~RadosZone() = default;
+
+ virtual const RGWZoneGroup& get_zonegroup() override;
+ virtual int get_zonegroup(const std::string& id, RGWZoneGroup& zonegroup) override;
+ virtual const RGWZoneParams& get_params() override;
+ virtual const rgw_zone_id& get_id() override;
+ virtual const RGWRealm& get_realm() override;
+ virtual const std::string& get_name() const override;
+ virtual bool is_writeable() override;
+ virtual bool get_redirect_endpoint(std::string* endpoint) override;
+ virtual bool has_zonegroup_api(const std::string& api) const override;
+ virtual const std::string& get_current_period_id() override;
+};
+
+class RadosStore : public Store {
+ private:
+ RGWRados* rados;
+ RGWUserCtl* user_ctl;
+ std::string luarocks_path;
+ RadosZone zone;
+
+ public:
+ RadosStore()
+ : rados(nullptr), zone(this) {
+ }
+ ~RadosStore() {
+ delete rados;
+ }
+
+ virtual const char* get_name() const override {
+ return "rados";
+ }
+ virtual std::string get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y) override;
+ virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
+ virtual int get_user_by_access_key(const DoutPrefixProvider* dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user) override;
+ virtual int get_user_by_email(const DoutPrefixProvider* dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user) override;
+ virtual int get_user_by_swift(const DoutPrefixProvider* dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user) override;
+ virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
+ virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
+ virtual int get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket) override;
+ virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const std::string& tenant, const std::string&name, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
+ virtual bool is_meta_master() override;
+ virtual int forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version* objv,
+ bufferlist& in_data, JSONParser* jp, req_info& info,
+ optional_yield y) override;
+ virtual Zone* get_zone() { return &zone; }
+ virtual std::string zone_unique_id(uint64_t unique_num) override;
+ virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
+ virtual int cluster_stat(RGWClusterStat& stats) override;
+ virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
+ virtual std::unique_ptr<Completions> get_completions(void) override;
+ virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj, rgw::sal::Object* src_obj, struct req_state* s, rgw::notify::EventType event_type, const std::string* object_name=nullptr) override;
+ virtual std::unique_ptr<Notification> get_notification(
+ const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj,
+ rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant,
+ std::string& _req_id, optional_yield y) override;
+ virtual RGWLC* get_rgwlc(void) override { return rados->get_lc(); }
+ virtual RGWCoroutinesManagerRegistry* get_cr_registry() override { return rados->get_cr_registry(); }
+
+ virtual int log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket, RGWUsageBatch>& usage_info) override;
+ virtual int log_op(const DoutPrefixProvider *dpp, std::string& oid, bufferlist& bl) override;
+ virtual int register_to_service_map(const DoutPrefixProvider *dpp, const std::string& daemon_type,
+ const std::map<std::string, std::string>& meta) override;
+ virtual void get_quota(RGWQuotaInfo& bucket_quota, RGWQuotaInfo& user_quota) override;
+ virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit, RGWRateLimitInfo& user_ratelimit, RGWRateLimitInfo& anon_ratelimit) override;
+ virtual int set_buckets_enabled(const DoutPrefixProvider* dpp, std::vector<rgw_bucket>& buckets, bool enabled) override;
+ virtual uint64_t get_new_req_id() override { return rados->get_new_req_id(); }
+ virtual int get_sync_policy_handler(const DoutPrefixProvider* dpp,
+ std::optional<rgw_zone_id> zone,
+ std::optional<rgw_bucket> bucket,
+ RGWBucketSyncPolicyHandlerRef* phandler,
+ optional_yield y) override;
+ virtual RGWDataSyncStatusManager* get_data_sync_manager(const rgw_zone_id& source_zone) override;
+ virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) override { rados->wakeup_meta_sync_shards(shard_ids); }
+ virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp, const rgw_zone_id& source_zone, std::map<int, std::set<std::string> >& shard_ids) override { rados->wakeup_data_sync_shards(dpp, source_zone, shard_ids); }
+ virtual int clear_usage(const DoutPrefixProvider *dpp) override { return rados->clear_usage(dpp); }
+ virtual int read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
+ uint32_t max_entries, bool* is_truncated,
+ RGWUsageIter& usage_iter,
+ std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
+ virtual int trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override;
+ virtual int get_config_key_val(std::string name, bufferlist* bl) override;
+ virtual int meta_list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, const std::string& marker, void** phandle) override;
+ virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, std::list<std::string>& keys, bool* truncated) override;
+ virtual void meta_list_keys_complete(void* handle) override;
+ virtual std::string meta_get_marker(void* handle) override;
+ virtual int meta_remove(const DoutPrefixProvider* dpp, std::string& metadata_key, optional_yield y) override;
+ virtual const RGWSyncModuleInstanceRef& get_sync_module() { return rados->get_sync_module(); }
+ virtual std::string get_host_id() { return rados->host_id; }
+ virtual std::unique_ptr<LuaScriptManager> get_lua_script_manager() override;
+ virtual std::unique_ptr<RGWRole> get_role(std::string name,
+ std::string tenant,
+ std::string path="",
+ std::string trust_policy="",
+ std::string max_session_duration_str="",
+ std::multimap<std::string,std::string> tags={}) override;
+ virtual std::unique_ptr<RGWRole> get_role(std::string id) override;
+ virtual int get_roles(const DoutPrefixProvider *dpp,
+ optional_yield y,
+ const std::string& path_prefix,
+ const std::string& tenant,
+ std::vector<std::unique_ptr<RGWRole>>& roles) override;
+ virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() override;
+ virtual int get_oidc_providers(const DoutPrefixProvider *dpp,
+ const std::string& tenant,
+ std::vector<std::unique_ptr<RGWOIDCProvider>>& providers) override;
+ virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
+ optional_yield y,
+ std::unique_ptr<rgw::sal::Object> _head_obj,
+ const rgw_user& owner,
+ const rgw_placement_rule *ptail_placement_rule,
+ const std::string& unique_tag,
+ uint64_t position,
+ uint64_t *cur_accounted_size) override;
+ virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
+ optional_yield y,
+ std::unique_ptr<rgw::sal::Object> _head_obj,
+ const rgw_user& owner,
+ const rgw_placement_rule *ptail_placement_rule,
+ uint64_t olh_epoch,
+ const std::string& unique_tag) override;
+
+ virtual void finalize(void) override;
+
+ virtual CephContext* ctx(void) override { return rados->ctx(); }
+
+ virtual const std::string& get_luarocks_path() const override {
+ return luarocks_path;
+ }
+
+ virtual void set_luarocks_path(const std::string& path) override {
+ luarocks_path = path;
+ }
+
+ /* Unique to RadosStore */
+ int get_obj_head_ioctx(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
+ librados::IoCtx* ioctx);
+ int delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj);
+ int delete_raw_obj_aio(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, Completions* aio);
+ void get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj);
+ int get_raw_chunk_size(const DoutPrefixProvider* dpp, const rgw_raw_obj& obj, uint64_t* chunk_size);
+
+ void setRados(RGWRados * st) { rados = st; }
+ RGWRados* getRados(void) { return rados; }
+
+ RGWServices* svc() { return &rados->svc; }
+ const RGWServices* svc() const { return &rados->svc; }
+ RGWCtl* ctl() { return &rados->ctl; }
+ const RGWCtl* ctl() const { return &rados->ctl; }
+
+ void setUserCtl(RGWUserCtl *_ctl) { user_ctl = _ctl; }
+};
+
class RadosUser : public User {
private:
RadosStore* store;
private:
RadosStore* store;
RGWAccessControlPolicy acls;
+ RGWObjManifest *manifest{nullptr};
+ RGWObjectCtx* rados_ctx;
+ bool rados_ctx_owned;
public:
struct RadosDeleteOp : public DeleteOp {
private:
RadosObject* source;
- RGWObjectCtx* rctx;
RGWRados::Object op_target;
RGWRados::Object::Delete parent_op;
public:
- RadosDeleteOp(RadosObject* _source, RGWObjectCtx* _rctx);
+ RadosDeleteOp(RadosObject* _source);
virtual int delete_obj(const DoutPrefixProvider* dpp, optional_yield y) override;
};
RadosObject(RadosStore *_st, const rgw_obj_key& _k)
: Object(_k),
store(_st),
- acls() {
+ acls(),
+ rados_ctx(new RGWObjectCtx(dynamic_cast<Store*>(store))),
+ rados_ctx_owned(true) {
}
RadosObject(RadosStore *_st, const rgw_obj_key& _k, Bucket* _b)
: Object(_k, _b),
store(_st),
- acls() {
+ acls(),
+ rados_ctx(new RGWObjectCtx(dynamic_cast<Store*>(store))) ,
+ rados_ctx_owned(true) {
+ }
+ RadosObject(RadosObject& _o) : Object(_o) {
+ store = _o.store;
+ acls = _o.acls;
+ manifest = _o.manifest;
+ rados_ctx = _o.rados_ctx;
+ rados_ctx_owned = false;
}
- RadosObject(RadosObject& _o) = default;
virtual ~RadosObject();
- virtual int delete_object(const DoutPrefixProvider* dpp, RGWObjectCtx* obj_ctx,
+ virtual int delete_object(const DoutPrefixProvider* dpp,
optional_yield y, bool prevent_versioning) override;
virtual int delete_obj_aio(const DoutPrefixProvider* dpp, RGWObjState* astate, Completions* aio,
bool keep_index_consistent, optional_yield y) override;
- virtual int copy_object(RGWObjectCtx& obj_ctx, User* user,
+ virtual int copy_object(User* user,
req_info* info, const rgw_zone_id& source_zone,
rgw::sal::Object* dest_object, rgw::sal::Bucket* dest_bucket,
rgw::sal::Bucket* src_bucket,
const DoutPrefixProvider* dpp, optional_yield y) override;
virtual RGWAccessControlPolicy& get_acl(void) override { return acls; }
virtual int set_acl(const RGWAccessControlPolicy& acl) override { acls = acl; return 0; }
- virtual void set_atomic(RGWObjectCtx* rctx) const override;
- virtual void set_prefetch_data(RGWObjectCtx* rctx) override;
- virtual void set_compressed(RGWObjectCtx* rctx) override;
-
- virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
- virtual int set_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, Attrs* setattrs, Attrs* delattrs, optional_yield y, rgw_obj* target_obj = NULL) override;
- virtual int get_obj_attrs(RGWObjectCtx* rctx, optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
- virtual int modify_obj_attrs(RGWObjectCtx* rctx, const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
- virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, RGWObjectCtx* rctx, const char* attr_name, optional_yield y) override;
+ virtual void set_atomic() override {
+ rados_ctx->set_atomic(state.obj);
+ Object::set_atomic();
+ }
+ virtual void set_prefetch_data() override {
+ rados_ctx->set_prefetch_data(state.obj);
+ Object::set_prefetch_data();
+ }
+ virtual void set_compressed() override {
+ rados_ctx->set_compressed(state.obj);
+ Object::set_compressed();
+ }
+
+ virtual int get_obj_state(const DoutPrefixProvider* dpp, RGWObjState **state, optional_yield y, bool follow_olh = true) override;
+ virtual int set_obj_attrs(const DoutPrefixProvider* dpp, Attrs* setattrs, Attrs* delattrs, optional_yield y) override;
+ virtual int get_obj_attrs(optional_yield y, const DoutPrefixProvider* dpp, rgw_obj* target_obj = NULL) override;
+ virtual int modify_obj_attrs(const char* attr_name, bufferlist& attr_val, optional_yield y, const DoutPrefixProvider* dpp) override;
+ virtual int delete_obj_attrs(const DoutPrefixProvider* dpp, const char* attr_name, optional_yield y) override;
virtual bool is_expired() override;
virtual void gen_rand_obj_instance_name() override;
void get_raw_obj(rgw_raw_obj* raw_obj);
return std::unique_ptr<Object>(new RadosObject(*this));
}
virtual MPSerializer* get_serializer(const DoutPrefixProvider *dpp, const std::string& lock_name) override;
- virtual int transition(RGWObjectCtx& rctx,
- Bucket* bucket,
+ virtual int transition(Bucket* bucket,
const rgw_placement_rule& placement_rule,
const real_time& mtime,
uint64_t olh_epoch,
const DoutPrefixProvider* dpp,
optional_yield y) override;
virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) override;
- virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f, RGWObjectCtx* obj_ctx) override;
+ virtual int dump_obj_layout(const DoutPrefixProvider *dpp, optional_yield y, Formatter* f) override;
/* Swift versioning */
- virtual int swift_versioning_restore(RGWObjectCtx* obj_ctx,
- bool& restored,
+ virtual int swift_versioning_restore(bool& restored,
const DoutPrefixProvider* dpp) override;
- virtual int swift_versioning_copy(RGWObjectCtx* obj_ctx,
- const DoutPrefixProvider* dpp,
+ virtual int swift_versioning_copy(const DoutPrefixProvider* dpp,
optional_yield y) override;
/* OPs */
- virtual std::unique_ptr<ReadOp> get_read_op(RGWObjectCtx *) override;
- virtual std::unique_ptr<DeleteOp> get_delete_op(RGWObjectCtx*) override;
+ virtual std::unique_ptr<ReadOp> get_read_op() override;
+ virtual std::unique_ptr<DeleteOp> get_delete_op() override;
/* OMAP */
virtual int omap_get_vals(const DoutPrefixProvider *dpp, const std::string& marker, uint64_t count,
uint64_t* alignment = nullptr);
void get_max_aligned_size(uint64_t size, uint64_t alignment, uint64_t* max_size);
void raw_obj_to_obj(const rgw_raw_obj& raw_obj);
+ RGWObjManifest* get_manifest() { return manifest; }
+ RGWObjectCtx& get_ctx() { return *rados_ctx; }
private:
int read_attrs(const DoutPrefixProvider* dpp, RGWRados::Object::Read &read_op, optional_yield y, rgw_obj* target_obj = nullptr);
friend class RadosUser;
};
-class RadosZone : public Zone {
- protected:
- RadosStore* store;
- public:
- RadosZone(RadosStore* _store) : store(_store) {}
- ~RadosZone() = default;
-
- virtual const RGWZoneGroup& get_zonegroup() override;
- virtual int get_zonegroup(const std::string& id, RGWZoneGroup& zonegroup) override;
- virtual const RGWZoneParams& get_params() override;
- virtual const rgw_zone_id& get_id() override;
- virtual const RGWRealm& get_realm() override;
- virtual const std::string& get_name() const override;
- virtual bool is_writeable() override;
- virtual bool get_redirect_endpoint(std::string* endpoint) override;
- virtual bool has_zonegroup_api(const std::string& api) const override;
- virtual const std::string& get_current_period_id() override;
-};
-
-class RadosStore : public Store {
- private:
- RGWRados* rados;
- RGWUserCtl* user_ctl;
- std::string luarocks_path;
- RadosZone zone;
-
- public:
- RadosStore()
- : rados(nullptr), zone(this) {
- }
- ~RadosStore() {
- delete rados;
- }
-
- virtual const char* get_name() const override {
- return "rados";
- }
-
- virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
- virtual std::string get_cluster_id(const DoutPrefixProvider* dpp, optional_yield y) override;
- virtual int get_user_by_access_key(const DoutPrefixProvider* dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user) override;
- virtual int get_user_by_email(const DoutPrefixProvider* dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user) override;
- virtual int get_user_by_swift(const DoutPrefixProvider* dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user) override;
- virtual std::unique_ptr<Object> get_object(const rgw_obj_key& k) override;
- virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
- virtual int get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket) override;
- virtual int get_bucket(const DoutPrefixProvider* dpp, User* u, const std::string& tenant, const std::string&name, std::unique_ptr<Bucket>* bucket, optional_yield y) override;
- virtual bool is_meta_master() override;
- virtual int forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version* objv,
- bufferlist& in_data, JSONParser* jp, req_info& info,
- optional_yield y) override;
- virtual Zone* get_zone() { return &zone; }
- virtual std::string zone_unique_id(uint64_t unique_num) override;
- virtual std::string zone_unique_trans_id(const uint64_t unique_num) override;
- virtual int cluster_stat(RGWClusterStat& stats) override;
- virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
- virtual std::unique_ptr<Completions> get_completions(void) override;
-
- // op variant
- virtual std::unique_ptr<Notification> get_notification(rgw::sal::Object* obj, rgw::sal::Object* src_obj, struct req_state* s, rgw::notify::EventType event_type, const std::string* object_name=nullptr) override;
-
- // non-op variant (e.g., rgwlc)
- virtual std::unique_ptr<Notification> get_notification(const DoutPrefixProvider* dpp, rgw::sal::Object* obj, rgw::sal::Object* src_obj, RGWObjectCtx* rctx, rgw::notify::EventType event_type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y) override;
- virtual RGWLC* get_rgwlc(void) override { return rados->get_lc(); }
- virtual RGWCoroutinesManagerRegistry* get_cr_registry() override { return rados->get_cr_registry(); }
-
- virtual int log_usage(const DoutPrefixProvider *dpp, std::map<rgw_user_bucket, RGWUsageBatch>& usage_info) override;
- virtual int log_op(const DoutPrefixProvider *dpp, std::string& oid, bufferlist& bl) override;
- virtual int register_to_service_map(const DoutPrefixProvider *dpp, const std::string& daemon_type,
- const std::map<std::string, std::string>& meta) override;
- virtual void get_quota(RGWQuotaInfo& bucket_quota, RGWQuotaInfo& user_quota) override;
- virtual void get_ratelimit(RGWRateLimitInfo& bucket_ratelimit, RGWRateLimitInfo& user_ratelimit, RGWRateLimitInfo& anon_ratelimit) override;
- virtual int set_buckets_enabled(const DoutPrefixProvider* dpp, std::vector<rgw_bucket>& buckets, bool enabled) override;
- virtual uint64_t get_new_req_id() override { return rados->get_new_req_id(); }
- virtual int get_sync_policy_handler(const DoutPrefixProvider* dpp,
- std::optional<rgw_zone_id> zone,
- std::optional<rgw_bucket> bucket,
- RGWBucketSyncPolicyHandlerRef* phandler,
- optional_yield y) override;
- virtual RGWDataSyncStatusManager* get_data_sync_manager(const rgw_zone_id& source_zone) override;
- virtual void wakeup_meta_sync_shards(std::set<int>& shard_ids) override { rados->wakeup_meta_sync_shards(shard_ids); }
- virtual void wakeup_data_sync_shards(const DoutPrefixProvider *dpp, const rgw_zone_id& source_zone, std::map<int, std::set<std::string> >& shard_ids) override { rados->wakeup_data_sync_shards(dpp, source_zone, shard_ids); }
- virtual int clear_usage(const DoutPrefixProvider *dpp) override { return rados->clear_usage(dpp); }
- virtual int read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
- uint32_t max_entries, bool* is_truncated,
- RGWUsageIter& usage_iter,
- std::map<rgw_user_bucket, rgw_usage_log_entry>& usage) override;
- virtual int trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch) override;
- virtual int get_config_key_val(std::string name, bufferlist* bl) override;
- virtual int meta_list_keys_init(const DoutPrefixProvider *dpp, const std::string& section, const std::string& marker, void** phandle) override;
- virtual int meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, std::list<std::string>& keys, bool* truncated) override;
- virtual void meta_list_keys_complete(void* handle) override;
- virtual std::string meta_get_marker(void* handle) override;
- virtual int meta_remove(const DoutPrefixProvider* dpp, std::string& metadata_key, optional_yield y) override;
- virtual const RGWSyncModuleInstanceRef& get_sync_module() { return rados->get_sync_module(); }
- virtual std::string get_host_id() { return rados->host_id; }
- virtual std::unique_ptr<LuaScriptManager> get_lua_script_manager() override;
- virtual std::unique_ptr<RGWRole> get_role(std::string name,
- std::string tenant,
- std::string path="",
- std::string trust_policy="",
- std::string max_session_duration_str="",
- std::multimap<std::string,std::string> tags={}) override;
- virtual std::unique_ptr<RGWRole> get_role(std::string id) override;
- virtual int get_roles(const DoutPrefixProvider *dpp,
- optional_yield y,
- const std::string& path_prefix,
- const std::string& tenant,
- std::vector<std::unique_ptr<RGWRole>>& roles) override;
- virtual std::unique_ptr<RGWOIDCProvider> get_oidc_provider() override;
- virtual int get_oidc_providers(const DoutPrefixProvider *dpp,
- const std::string& tenant,
- std::vector<std::unique_ptr<RGWOIDCProvider>>& providers) override;
- virtual std::unique_ptr<Writer> get_append_writer(const DoutPrefixProvider *dpp,
- optional_yield y,
- std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
- const rgw_placement_rule *ptail_placement_rule,
- const std::string& unique_tag,
- uint64_t position,
- uint64_t *cur_accounted_size) override;
- virtual std::unique_ptr<Writer> get_atomic_writer(const DoutPrefixProvider *dpp,
- optional_yield y,
- std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
- const rgw_placement_rule *ptail_placement_rule,
- uint64_t olh_epoch,
- const std::string& unique_tag) override;
-
- virtual void finalize(void) override;
-
- virtual CephContext* ctx(void) override { return rados->ctx(); }
-
- virtual const std::string& get_luarocks_path() const override {
- return luarocks_path;
- }
-
- virtual void set_luarocks_path(const std::string& path) override {
- luarocks_path = path;
- }
-
- /* Unique to RadosStore */
- int get_obj_head_ioctx(const DoutPrefixProvider *dpp, const RGWBucketInfo& bucket_info, const rgw_obj& obj,
- librados::IoCtx* ioctx);
- int delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj);
- int delete_raw_obj_aio(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, Completions* aio);
- void get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj);
- int get_raw_chunk_size(const DoutPrefixProvider* dpp, const rgw_raw_obj& obj, uint64_t* chunk_size);
-
- void setRados(RGWRados * st) { rados = st; }
- RGWRados* getRados(void) { return rados; }
-
- RGWServices* svc() { return &rados->svc; }
- const RGWServices* svc() const { return &rados->svc; }
- RGWCtl* ctl() { return &rados->ctl; }
- const RGWCtl* ctl() const { return &rados->ctl; }
-
- void setUserCtl(RGWUserCtl *_ctl) { user_ctl = _ctl; }
-};
-
class RadosMultipartPart : public MultipartPart {
protected:
RGWUploadPartInfo info;
virtual const ACLOwner& get_owner() const override { return owner; }
virtual ceph::real_time& get_mtime() override { return mtime; }
virtual std::unique_ptr<rgw::sal::Object> get_meta_obj() override;
- virtual int init(const DoutPrefixProvider* dpp, optional_yield y, RGWObjectCtx* obj_ctx, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
+ virtual int init(const DoutPrefixProvider* dpp, optional_yield y, ACLOwner& owner, rgw_placement_rule& dest_placement, rgw::sal::Attrs& attrs) override;
virtual int list_parts(const DoutPrefixProvider* dpp, CephContext* cct,
int num_parts, int marker,
int* next_marker, bool* truncated,
bool assume_unsorted = false) override;
- virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct,
- RGWObjectCtx* obj_ctx) override;
+ virtual int abort(const DoutPrefixProvider* dpp, CephContext* cct) override;
virtual int complete(const DoutPrefixProvider* dpp,
optional_yield y, CephContext* cct,
std::map<int, std::string>& part_etags,
RGWCompressionInfo& cs_info, off_t& ofs,
std::string& tag, ACLOwner& owner,
uint64_t olh_epoch,
- rgw::sal::Object* target_obj,
- RGWObjectCtx* obj_ctx) override;
- virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, RGWObjectCtx* obj_ctx, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override;
+ rgw::sal::Object* target_obj) override;
+ virtual int get_info(const DoutPrefixProvider *dpp, optional_yield y, rgw_placement_rule** rule, rgw::sal::Attrs* attrs = nullptr) override;
virtual std::unique_ptr<Writer> get_writer(const DoutPrefixProvider *dpp,
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num,
const std::string& part_num_str) override;
RadosNotification(const DoutPrefixProvider* _dpp, RadosStore* _store, Object* _obj, Object* _src_obj, req_state* _s, rgw::notify::EventType _type, const std::string* object_name=nullptr) :
Notification(_obj, _src_obj, _type), store(_store), res(_dpp, _store, _s, _obj, _src_obj, object_name) { }
- RadosNotification(const DoutPrefixProvider* _dpp, RadosStore* _store, Object* _obj, Object* _src_obj, RGWObjectCtx* rctx, rgw::notify::EventType _type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y) :
- Notification(_obj, _src_obj, _type), store(_store), res(_dpp, _store, rctx, _obj, _src_obj, _bucket, _user_id, _user_tenant, _req_id, y) {}
+ RadosNotification(const DoutPrefixProvider* _dpp, RadosStore* _store, Object* _obj, Object* _src_obj, rgw::notify::EventType _type, rgw::sal::Bucket* _bucket, std::string& _user_id, std::string& _user_tenant, std::string& _req_id, optional_yield y) :
+ Notification(_obj, _src_obj, _type), store(_store), res(_dpp, _store, _obj, _src_obj, _bucket, _user_id, _user_tenant, _req_id, y) {}
~RadosNotification() = default;
protected:
rgw::sal::RadosStore* store;
std::unique_ptr<Aio> aio;
+ RGWObjectCtx* obj_ctx;
rgw::putobj::AtomicObjectProcessor processor;
public:
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
RadosStore* _store, std::unique_ptr<Aio> _aio,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t olh_epoch,
const std::string& unique_tag) :
Writer(dpp, y),
store(_store),
aio(std::move(_aio)),
+ obj_ctx(&dynamic_cast<RadosObject*>(_head_obj.get())->get_ctx()),
processor(&*aio, store,
- ptail_placement_rule, owner, obj_ctx,
+ ptail_placement_rule, owner,
+ *obj_ctx,
std::move(_head_obj), olh_epoch, unique_tag,
dpp, y)
{}
protected:
rgw::sal::RadosStore* store;
std::unique_ptr<Aio> aio;
+ RGWObjectCtx* obj_ctx;
rgw::putobj::AppendObjectProcessor processor;
public:
optional_yield y,
std::unique_ptr<rgw::sal::Object> _head_obj,
RadosStore* _store, std::unique_ptr<Aio> _aio,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
const std::string& unique_tag,
uint64_t position,
uint64_t *cur_accounted_size) :
- Writer(dpp, y),
- store(_store),
- aio(std::move(_aio)),
- processor(&*aio, store,
- ptail_placement_rule, owner, obj_ctx,
- std::move(_head_obj), unique_tag, position,
- cur_accounted_size, dpp, y)
+ Writer(dpp, y),
+ store(_store),
+ aio(std::move(_aio)),
+ obj_ctx(&dynamic_cast<RadosObject*>(_head_obj.get())->get_ctx()),
+ processor(&*aio, store,
+ ptail_placement_rule, owner,
+ *obj_ctx,
+ std::move(_head_obj), unique_tag, position,
+ cur_accounted_size, dpp, y)
{}
~RadosAppendWriter() = default;
protected:
rgw::sal::RadosStore* store;
std::unique_ptr<Aio> aio;
+ RGWObjectCtx* obj_ctx;
rgw::putobj::MultipartObjectProcessor processor;
public:
optional_yield y, MultipartUpload* upload,
std::unique_ptr<rgw::sal::Object> _head_obj,
RadosStore* _store, std::unique_ptr<Aio> _aio,
- const rgw_user& owner, RGWObjectCtx& obj_ctx,
+ const rgw_user& owner,
const rgw_placement_rule *ptail_placement_rule,
uint64_t part_num, const std::string& part_num_str) :
- Writer(dpp, y),
- store(_store),
- aio(std::move(_aio)),
- processor(&*aio, store,
- ptail_placement_rule, owner, obj_ctx,
- std::move(_head_obj), upload->get_upload_id(),
- part_num, part_num_str, dpp, y)
+ Writer(dpp, y),
+ store(_store),
+ aio(std::move(_aio)),
+ obj_ctx(&dynamic_cast<RadosObject*>(_head_obj.get())->get_ctx()),
+ processor(&*aio, store,
+ ptail_placement_rule, owner,
+ *obj_ctx,
+ std::move(_head_obj), upload->get_upload_id(),
+ part_num, part_num_str, dpp, y)
{}
~RadosMultipartWriter() = default;
rgw::BlockingAioThrottle aio(store->ctx()->_conf->rgw_put_obj_min_window_size);
- RGWObjectCtx obj_ctx(store);
std::unique_ptr<rgw::sal::Bucket> b;
store->get_bucket(NULL, bucket_info, &b);
std::unique_ptr<rgw::sal::Object> obj = b->get_object(key);
std::unique_ptr<rgw::sal::Writer> processor;
processor = store->get_atomic_writer(dpp, y, std::move(obj),
- owner.get_id(), obj_ctx,
+ owner.get_id(),
nullptr, olh_epoch, req_id);
int ret = processor->prepare(y);
return get_obj_state(dpp, bucket_info, obj, follow_olh, pstate);
}
-int DB::Object::get_manifest(const DoutPrefixProvider *dpp, RGWObjManifest **pmanifest)
-{
- RGWObjState base_state;
- RGWObjState *astate = &base_state;
- int r = get_state(dpp, &astate, true);
- if (r < 0) {
- return r;
- }
-
- *pmanifest = &(*astate->manifest);
-
- return 0;
-}
-
int DB::Object::Read::get_attr(const DoutPrefixProvider *dpp, const char *name, bufferlist& dest)
{
RGWObjState base_state;
bool bs_initialized;
public:
- Object(DB *_store, const RGWBucketInfo& _bucket_info, RGWObjectCtx& _ctx, const rgw_obj& _obj) : store(_store), bucket_info(_bucket_info),
+ Object(DB *_store, const RGWBucketInfo& _bucket_info, const rgw_obj& _obj) : store(_store), bucket_info(_bucket_info),
obj(_obj),
state(NULL), versioning_disabled(false),
bs_initialized(false) {}
- Object(DB *_store, const RGWBucketInfo& _bucket_info, const rgw_obj& _obj) : store(_store), bucket_info(_bucket_info), obj(_obj) {}
-
Object(DB *_store, const RGWBucketInfo& _bucket_info, const rgw_obj& _obj, const std::string& _obj_id) : store(_store), bucket_info(_bucket_info), obj(_obj), obj_id(_obj_id) {}
struct Read {
const rgw_obj& olh_obj, rgw_obj *target);
int get_state(const DoutPrefixProvider *dpp, RGWObjState **pstate, bool follow_olh);
- int get_manifest(const DoutPrefixProvider *dpp, RGWObjManifest **pmanifest);
DB *get_store() { return store; }
rgw_obj& get_obj() { return obj; }
projects / ceph.git / commitdiff