From 585684a93f1a55d56766601b53a529e7b47bd2dc Mon Sep 17 00:00:00 2001 From: Soumya Koduri Date: Sun, 7 Mar 2021 19:44:36 +0530 Subject: [PATCH] rgw/CloudTransition: Skip transition to cloud if the object is locked If an object is locked, skip its transition to cloud. @todo: Do we need special checks for bucket versioning too? If current, instead of deleting the data, do we need to create a delete marker? What about the case if retain_object is set to true. & misc rebase fixes Signed-off-by: Soumya Koduri --- src/rgw/rgw_cr_rest.cc | 5 +- src/rgw/rgw_cr_rest.h | 7 ++- src/rgw/rgw_lc.cc | 90 +++++++++++++++++-------------- src/rgw/rgw_lc_tier.cc | 118 +++++++++++++++++++++++------------------ src/rgw/rgw_lc_tier.h | 10 ++-- 5 files changed, 127 insertions(+), 103 deletions(-) diff --git a/src/rgw/rgw_cr_rest.cc b/src/rgw/rgw_cr_rest.cc index 2a20db0acba08..ded47b3bfd4f7 100644 --- a/src/rgw/rgw_cr_rest.cc +++ b/src/rgw/rgw_cr_rest.cc @@ -349,9 +349,8 @@ int RGWStreamSpliceCR::operate(const DoutPrefixProvider *dpp) { return 0; } -RGWStreamReadCRF::RGWStreamReadCRF(RGWRados* rados, RGWBucketInfo& bucket_info, - RGWObjectCtx& obj_ctx, rgw_obj& obj) : - op_target(rados, bucket_info, obj_ctx, obj), read_op(&op_target) {} +RGWStreamReadCRF::RGWStreamReadCRF(std::unique_ptr* obj, + RGWObjectCtx& obj_ctx) : read_op((*obj)->get_read_op(&obj_ctx)) {} RGWStreamReadCRF::~RGWStreamReadCRF() {} RGWStreamWriteCR::RGWStreamWriteCR(CephContext *_cct, RGWHTTPManager *_mgr, diff --git a/src/rgw/rgw_cr_rest.h b/src/rgw/rgw_cr_rest.h index f6df68ddc9dd7..399bc6470b31d 100644 --- a/src/rgw/rgw_cr_rest.h +++ b/src/rgw/rgw_cr_rest.h @@ -592,14 +592,13 @@ public: class RGWStreamReadCRF { public: - RGWRados::Object op_target; - RGWRados::Object::Read read_op; + std::unique_ptr read_op; off_t ofs; off_t end; rgw_rest_obj rest_obj; + std::unique_ptr* obj; - RGWStreamReadCRF(RGWRados* rados, RGWBucketInfo& bucket_info, - RGWObjectCtx& obj_ctx, rgw_obj& obj); + RGWStreamReadCRF(std::unique_ptr* obj, RGWObjectCtx& obj_ctx); virtual ~RGWStreamReadCRF(); virtual int init() {return 0; } diff --git a/src/rgw/rgw_lc.cc b/src/rgw/rgw_lc.cc index 34111476485a0..e00c88a78ea67 100644 --- a/src/rgw/rgw_lc.cc +++ b/src/rgw/rgw_lc.cc @@ -1276,27 +1276,25 @@ public: int delete_tier_obj(lc_op_ctx& oc, RGWLCCloudTierCtx& tier_ctx) { int ret = 0; - /* XXX: do we need to check for retention attributes * as done in RGWDeleteObj? + /* If bucket is versioned, create delete_marker for current version */ - ret = oc.store->getRados()->delete_obj(oc.dpp, oc.rctx, oc.bucket->get_info(), oc.obj->get_obj(), tier_ctx.bucket_info.versioning_status()); - + ret = remove_expired_obj(oc.dpp, oc, + !(oc.o.is_current() && oc.bucket->versioned())); return ret; } int update_tier_obj(lc_op_ctx& oc, RGWLCCloudTierCtx& tier_ctx) { map attrs; - RGWRados::Object op_target(tier_ctx.store->getRados(), - tier_ctx.bucket_info, - tier_ctx.rctx, tier_ctx.obj); + int r = 0; + real_time read_mtime; - RGWRados::Object::Read read_op(&op_target); + std::unique_ptr read_op(oc.obj->get_read_op(&oc.rctx)); - read_op.params.attrs = &attrs; - read_op.params.lastmod = &read_mtime; + read_op->params.lastmod = &read_mtime; - int r = read_op.prepare(null_yield, oc.dpp); + r = read_op->prepare(null_yield, oc.dpp); if (r < 0) { return r; } @@ -1306,24 +1304,25 @@ public: return -ECANCELED; } - tier_ctx.rctx.set_atomic(tier_ctx.obj); + attrs = oc.obj->get_attrs(); + (*tier_ctx.obj)->set_atomic(&tier_ctx.rctx); - RGWRados::Object::Write obj_op(&op_target); - RGWObjState *s = tier_ctx.rctx.get_state(tier_ctx.obj); + RGWObjState *s = tier_ctx.rctx.get_state((*tier_ctx.obj)->get_obj()); + std::unique_ptr obj_op(oc.obj->get_write_op(&oc.rctx)); - obj_op.meta.modify_tail = true; - obj_op.meta.flags = PUT_OBJ_CREATE; - obj_op.meta.category = RGWObjCategory::CloudTiered; - obj_op.meta.delete_at = real_time(); + obj_op->params.modify_tail = true; + obj_op->params.flags = PUT_OBJ_CREATE; + obj_op->params.category = RGWObjCategory::CloudTiered; + obj_op->params.delete_at = real_time(); bufferlist blo; blo.append(""); - obj_op.meta.data = &blo; - obj_op.meta.if_match = NULL; - obj_op.meta.if_nomatch = NULL; - obj_op.meta.user_data = NULL; - obj_op.meta.zones_trace = NULL; - obj_op.meta.delete_at = real_time(); - obj_op.meta.olh_epoch = tier_ctx.o.versioned_epoch; + obj_op->params.data = &blo; + obj_op->params.if_match = NULL; + obj_op->params.if_nomatch = NULL; + obj_op->params.user_data = NULL; + obj_op->params.zones_trace = NULL; + obj_op->params.delete_at = real_time(); + obj_op->params.olh_epoch = tier_ctx.o.versioned_epoch; RGWObjManifest *pmanifest; @@ -1340,9 +1339,9 @@ public: rgw_placement_rule target_placement; target_placement.inherit_from(tier_ctx.bucket_info.placement_rule); target_placement.storage_class = oc.tier.storage_class; - pmanifest->set_head(target_placement, tier_ctx.obj, 0); + pmanifest->set_head(target_placement, (*tier_ctx.obj)->get_obj(), 0); - pmanifest->set_tail_placement(target_placement, tier_ctx.obj.bucket); + pmanifest->set_tail_placement(target_placement, (*tier_ctx.obj)->get_obj().bucket); /* should the obj_size also be set to '0' or is it needed * to keep track of original size before transition. @@ -1353,7 +1352,7 @@ public: */ //pmanifest->set_obj_size(0); - obj_op.meta.manifest = pmanifest; + obj_op->params.manifest = pmanifest; /* update storage class */ bufferlist bl; @@ -1363,7 +1362,9 @@ public: attrs.erase(RGW_ATTR_ID_TAG); attrs.erase(RGW_ATTR_TAIL_TAG); - obj_op.write_meta(oc.dpp, tier_ctx.o.meta.size, 0, attrs, null_yield); + obj_op->params.attrs = &attrs; + + r = obj_op->write_meta(oc.dpp, tier_ctx.o.meta.size, 0, null_yield); if (r < 0) { return r; } @@ -1380,19 +1381,23 @@ public: RGWAccessKey key = oc.tier.t.s3.key; HostStyle host_style = oc.tier.t.s3.host_style; string bucket_name = oc.tier.t.s3.target_path; - const RGWZoneGroup& zonegroup = oc.store->svc()->zone->get_zonegroup(); + const RGWZoneGroup& zonegroup = oc.store->get_zone()->get_zonegroup(); + bool delete_object; + /* Option 'retain_object' is not applicable for CurrentVersionTransition */ + delete_object = (!oc.tier.retain_object || + (oc.o.is_current() && oc.bucket->versioned())); + if (bucket_name.empty()) { bucket_name = "rgwx-" + zonegroup.get_name() + "-" + oc.tier.storage_class + "-cloud-bucket"; boost::algorithm::to_lower(bucket_name); } - conn.reset(new S3RESTConn(oc.cct, oc.store->svc()->zone, - id, { endpoint }, key, host_style)); + conn.reset(new S3RESTConn(oc.cct, oc.store, id, { endpoint }, key, host_style)); /* http_mngr */ - RGWCoroutinesManager crs(oc.store->ctx(), oc.store->getRados()->get_cr_registry()); + RGWCoroutinesManager crs(oc.store->ctx(), oc.store->get_cr_registry()); RGWHTTPManager http_manager(oc.store->ctx(), crs.get_completion_mgr()); int ret = http_manager.start(); @@ -1402,7 +1407,7 @@ public: } RGWLCCloudTierCtx tier_ctx(oc.cct, oc.dpp, oc.o, oc.store, oc.bucket->get_info(), - oc.obj->get_obj(), oc.rctx, conn, bucket_name, + &oc.obj, oc.rctx, conn, bucket_name, oc.tier.t.s3.target_storage_class, &http_manager); tier_ctx.acl_mappings = oc.tier.t.s3.acl_mappings; tier_ctx.multipart_min_part_size = oc.tier.t.s3.multipart_min_part_size; @@ -1434,16 +1439,16 @@ public: return ret; } - if (oc.tier.retain_object) { - ret = update_tier_obj(oc, tier_ctx); + if (delete_object) { + ret = delete_tier_obj(oc, tier_ctx); if (ret < 0) { - ldpp_dout(oc.dpp, 0) << "ERROR: Updating tier object failed ret=" << ret << dendl; + ldpp_dout(oc.dpp, 0) << "ERROR: Deleting tier object failed ret=" << ret << dendl; return ret; } } else { - ret = delete_tier_obj(oc, tier_ctx); + ret = update_tier_obj(oc, tier_ctx); if (ret < 0) { - ldpp_dout(oc.dpp, 0) << "ERROR: Deleting tier object failed ret=" << ret << dendl; + ldpp_dout(oc.dpp, 0) << "ERROR: Updating tier object failed ret=" << ret << dendl; return ret; } } @@ -1455,7 +1460,7 @@ public: auto& o = oc.o; int r; std::string tier_type = ""; - const RGWZoneGroup& zonegroup = oc.store->svc()->zone->get_zonegroup(); + const RGWZoneGroup& zonegroup = oc.store->get_zone()->get_zonegroup(); rgw_placement_rule target_placement; target_placement.inherit_from(oc.bucket->get_placement_rule()); @@ -1465,6 +1470,13 @@ public: if (!r && oc.tier.tier_type == "cloud-s3") { ldpp_dout(oc.dpp, 20) << "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)) { + /* 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; + } + r = transition_obj_to_cloud(oc); if (r < 0) { ldpp_dout(oc.dpp, 0) << "ERROR: failed to transition obj to cloud (r=" << r << ")" diff --git a/src/rgw/rgw_lc_tier.cc b/src/rgw/rgw_lc_tier.cc index b6844f8c6e3a4..a57c9291a6daf 100644 --- a/src/rgw/rgw_lc_tier.cc +++ b/src/rgw/rgw_lc_tier.cc @@ -190,7 +190,7 @@ class RGWLCStreamReadCRF : public RGWStreamReadCRF const DoutPrefixProvider *dpp; map attrs; uint64_t obj_size; - rgw_obj& obj; + std::unique_ptr* obj; const real_time &mtime; bool multipart; @@ -200,9 +200,9 @@ class RGWLCStreamReadCRF : public RGWStreamReadCRF public: RGWLCStreamReadCRF(CephContext *_cct, const DoutPrefixProvider *_dpp, - RGWRados* rados, RGWBucketInfo& bucket_info, - RGWObjectCtx& obj_ctx, rgw_obj& _obj, const real_time &_mtime) : - RGWStreamReadCRF(rados, bucket_info, obj_ctx, _obj), cct(_cct), + RGWObjectCtx& obj_ctx, std::unique_ptr* _obj, + const real_time &_mtime) : + RGWStreamReadCRF(_obj, obj_ctx), cct(_cct), dpp(_dpp), obj(_obj), mtime(_mtime) {} ~RGWLCStreamReadCRF() {}; @@ -218,11 +218,9 @@ class RGWLCStreamReadCRF : public RGWStreamReadCRF optional_yield y = null_yield; real_time read_mtime; - read_op.params.attrs = &attrs; - read_op.params.lastmod = &read_mtime; - read_op.params.obj_size = &obj_size; + read_op->params.lastmod = &read_mtime; - int ret = read_op.prepare(y, dpp); + int ret = read_op->prepare(y, dpp); if (ret < 0) { ldout(cct, 0) << "ERROR: fail to prepare read_op, ret = " << ret << dendl; return ret; @@ -233,6 +231,9 @@ class RGWLCStreamReadCRF : public RGWStreamReadCRF return -ECANCELED; } + attrs = (*obj)->get_attrs(); + obj_size = (*obj)->get_obj_size(); + ret = init_rest_obj(); if (ret < 0) { ldout(cct, 0) << "ERROR: fail to initialize rest_obj, ret = " << ret << dendl; @@ -251,7 +252,7 @@ class RGWLCStreamReadCRF : public RGWStreamReadCRF /* Initialize rgw_rest_obj. * Reference: do_decode_rest_obj * Check how to copy headers content */ - rest_obj.init(obj.key); + rest_obj.init((*obj)->get_key()); if (!multipart) { rest_obj.content_len = obj_size; @@ -290,7 +291,7 @@ class RGWLCStreamReadCRF : public RGWStreamReadCRF int read(off_t ofs, off_t end, bufferlist &bl) { optional_yield y = null_yield; - return read_op.read(ofs, end, bl, y, dpp); + return read_op->read(ofs, end, bl, y, dpp); } }; @@ -516,8 +517,8 @@ class RGWLCStreamObjToCloudPlainCR : public RGWCoroutine { std::shared_ptr in_crf; std::shared_ptr out_crf; - std::shared_ptr dest_bucket; - std::shared_ptr dest_obj; + std::unique_ptr dest_bucket; + std::unique_ptr dest_obj; public: RGWLCStreamObjToCloudPlainCR(RGWLCCloudTierCtx& _tier_ctx) @@ -535,12 +536,11 @@ class RGWLCStreamObjToCloudPlainCR : public RGWCoroutine { target_bucket.name = tier_ctx.target_bucket_name; target_obj_name = tier_ctx.bucket_info.bucket.name + "/" + - tier_ctx.obj.key.name + get_key_instance(tier_ctx.obj.key); + (*tier_ctx.obj)->get_name() + get_key_instance((*tier_ctx.obj)->get_key()); - dest_bucket.reset(new rgw::sal::RGWRadosBucket(tier_ctx.store, target_bucket)); + tier_ctx.store->get_bucket(tier_ctx.dpp, nullptr, target_bucket, &dest_bucket, null_yield); - dest_obj.reset(new rgw::sal::RGWRadosObject(tier_ctx.store, rgw_obj_key(target_obj_name), - (rgw::sal::RGWRadosBucket *)(dest_bucket.get()))); + dest_obj = dest_bucket->get_object(rgw_obj_key(target_obj_name)); rgw::sal::RGWObject *o = static_cast(dest_obj.get()); @@ -549,7 +549,6 @@ class RGWLCStreamObjToCloudPlainCR : public RGWCoroutine { /* Prepare Read from source */ in_crf.reset(new RGWLCStreamReadCRF(tier_ctx.cct, tier_ctx.dpp, - tier_ctx.store->getRados(), tier_ctx.bucket_info, tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime)); out_crf.reset(new RGWLCStreamPutCRF((CephContext *)(tier_ctx.cct), get_env(), this, @@ -579,8 +578,8 @@ class RGWLCStreamObjToCloudMultipartPartCR : public RGWCoroutine { std::shared_ptr in_crf; std::shared_ptr out_crf; - std::shared_ptr dest_bucket; - std::shared_ptr dest_obj; + std::unique_ptr dest_bucket; + std::unique_ptr dest_obj; public: RGWLCStreamObjToCloudMultipartPartCR(RGWLCCloudTierCtx& _tier_ctx, const string& _upload_id, @@ -598,19 +597,17 @@ class RGWLCStreamObjToCloudMultipartPartCR : public RGWCoroutine { target_bucket.name = tier_ctx.target_bucket_name; target_obj_name = tier_ctx.bucket_info.bucket.name + "/" + - tier_ctx.obj.key.name + get_key_instance(tier_ctx.obj.key); - - dest_bucket.reset(new rgw::sal::RGWRadosBucket(tier_ctx.store, target_bucket)); + (*tier_ctx.obj)->get_name() + get_key_instance((*tier_ctx.obj)->get_key()); - dest_obj.reset(new rgw::sal::RGWRadosObject(tier_ctx.store, rgw_obj_key(target_obj_name), - (rgw::sal::RGWRadosBucket *)(dest_bucket.get()))); + tier_ctx.store->get_bucket(tier_ctx.dpp, nullptr, target_bucket, &dest_bucket, null_yield); + dest_obj = dest_bucket->get_object(rgw_obj_key(target_obj_name)); reenter(this) { // tier_ctx.obj.set_atomic(&tier_ctx.rctx); -- might need when updated to zipper SAL /* Prepare Read from source */ - in_crf.reset(new RGWLCStreamReadCRF(tier_ctx.cct, tier_ctx.dpp, tier_ctx.store->getRados(), - tier_ctx.bucket_info, tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime)); + in_crf.reset(new RGWLCStreamReadCRF(tier_ctx.cct, tier_ctx.dpp, + tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime)); end = part_info.ofs + part_info.size - 1; std::static_pointer_cast(in_crf)->set_multipart(part_info.size, part_info.ofs, end); @@ -877,6 +874,7 @@ class RGWLCStreamAbortMultipartUploadCR : public RGWCoroutine { const rgw_raw_obj status_obj; string upload_id; + int ret = -1; public: @@ -893,9 +891,10 @@ class RGWLCStreamAbortMultipartUploadCR : public RGWCoroutine { ldout(tier_ctx.cct, 0) << "ERROR: failed to abort multipart upload dest obj=" << dest_obj << " upload_id=" << upload_id << " retcode=" << retcode << dendl; /* ignore error, best effort */ } - yield call(new RGWRadosRemoveCR(tier_ctx.store, status_obj)); - if (retcode < 0) { - ldout(tier_ctx.cct, 0) << "ERROR: failed to remove sync status obj obj=" << status_obj << " retcode=" << retcode << dendl; + ret = tier_ctx.store->delete_system_obj(status_obj.pool, status_obj.oid, nullptr, null_yield); + + if (ret < 0) { + ldout(tier_ctx.cct, 0) << "ERROR: failed to remove sync status obj obj=" << status_obj << " retcode=" << ret << dendl; /* ignore error, best effort */ } return set_cr_done(); @@ -924,6 +923,7 @@ class RGWLCStreamObjToCloudMultipartCR : public RGWCoroutine { int ret_err{0}; rgw_raw_obj status_obj; + bufferlist bl; public: RGWLCStreamObjToCloudMultipartCR(RGWLCCloudTierCtx& _tier_ctx) : RGWCoroutine(_tier_ctx.cct), tier_ctx(_tier_ctx) {} @@ -935,7 +935,7 @@ class RGWLCStreamObjToCloudMultipartCR : public RGWCoroutine { tier_ctx.acl_mappings, tier_ctx.target_storage_class); - rgw_obj& obj = tier_ctx.obj; + //rgw_obj& obj = (*tier_ctx.obj)->get_obj(); obj_size = tier_ctx.o.meta.size; rgw_bucket target_bucket; @@ -943,24 +943,34 @@ class RGWLCStreamObjToCloudMultipartCR : public RGWCoroutine { string target_obj_name; target_obj_name = tier_ctx.bucket_info.bucket.name + "/" + - tier_ctx.obj.key.name + get_key_instance(tier_ctx.obj.key); + (*tier_ctx.obj)->get_name() + get_key_instance((*tier_ctx.obj)->get_key()); rgw_obj dest_obj(target_bucket, target_obj_name); std::shared_ptr in_crf; rgw_rest_obj rest_obj; - status_obj = rgw_raw_obj(tier_ctx.store->svc()->zone->get_zone_params().log_pool, - "lc_multipart_" + obj.get_oid()); + status_obj = rgw_raw_obj(tier_ctx.store->get_zone()->get_params().log_pool, + "lc_multipart_" + (*tier_ctx.obj)->get_oid()); - reenter(this) { - yield call(new RGWSimpleRadosReadCR(tier_ctx.store->svc()->rados->get_async_processor(), tier_ctx.store->svc()->sysobj, - status_obj, &status, false)); + ret_err = tier_ctx.store->get_system_obj(tier_ctx.dpp, status_obj.pool, + status_obj.oid, bl, NULL, NULL, null_yield); - if (retcode < 0 && retcode != -ENOENT) { - ldout(tier_ctx.cct, 0) << "ERROR: failed to read sync status of object " << src_obj << " retcode=" << retcode << dendl; + if (ret_err < 0 && ret_err != -ENOENT) { + ldout(tier_ctx.cct, 0) << "ERROR: failed to read sync status of object " << src_obj << " retcode=" << ret_err << dendl; return retcode; } - if (retcode >= 0) { + if (ret_err >= 0) { + auto iter = bl.cbegin(); + try { + decode(status, iter); + } catch (buffer::error& err) { + return -EIO; + } + } + + reenter(this) { + + if (ret_err >= 0) { /* check here that mtime and size did not change */ if (status.mtime != obj_properties.mtime || status.obj_size != obj_size || status.etag != obj_properties.etag) { @@ -969,8 +979,8 @@ class RGWLCStreamObjToCloudMultipartCR : public RGWCoroutine { } } - if (retcode == -ENOENT) { - in_crf.reset(new RGWLCStreamReadCRF(tier_ctx.cct, tier_ctx.dpp, tier_ctx.store->getRados(), tier_ctx.bucket_info, tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime)); + if (ret_err == -ENOENT) { + in_crf.reset(new RGWLCStreamReadCRF(tier_ctx.cct, tier_ctx.dpp, tier_ctx.rctx, tier_ctx.obj, tier_ctx.o.meta.mtime)); in_crf->init(); @@ -1024,9 +1034,11 @@ class RGWLCStreamObjToCloudMultipartCR : public RGWCoroutine { return set_cr_error(ret_err); } - yield call(new RGWSimpleRadosWriteCR(tier_ctx.store->svc()->rados->get_async_processor(), tier_ctx.store->svc()->sysobj, status_obj, status)); - if (retcode < 0) { - ldout(tier_ctx.cct, 0) << "ERROR: failed to store multipart upload state, retcode=" << retcode << dendl; + encode(status, bl); + ret_err = tier_ctx.store->put_system_obj(status_obj.pool, status_obj.oid, + bl, false, NULL, real_time(), null_yield, NULL); + if (ret_err < 0) { + ldout(tier_ctx.cct, 0) << "ERROR: failed to store multipart upload state, retcode=" << ret_err << dendl; /* continue with upload anyway */ } ldout(tier_ctx.cct, 0) << "sync of object=" << tier_ctx.obj << " via multipart upload, finished sending part #" << status.cur_part << " etag=" << pcur_part_info->etag << dendl; @@ -1041,9 +1053,10 @@ class RGWLCStreamObjToCloudMultipartCR : public RGWCoroutine { } /* remove status obj */ - yield call(new RGWRadosRemoveCR(tier_ctx.store, status_obj)); - if (retcode < 0) { - ldout(tier_ctx.cct, 0) << "ERROR: failed to abort multipart upload obj=" << tier_ctx.obj << " upload_id=" << status.upload_id << " part number " << status.cur_part << " (" << cpp_strerror(-retcode) << ")" << dendl; + ret_err = tier_ctx.store->delete_system_obj(status_obj.pool, status_obj.oid, nullptr, null_yield); + + if (ret_err < 0) { + ldout(tier_ctx.cct, 0) << "ERROR: failed to abort multipart upload obj=" << tier_ctx.obj << " upload_id=" << status.upload_id << " part number " << status.cur_part << " (" << cpp_strerror(-ret_err) << ")" << dendl; /* ignore error, best effort */ } return set_cr_done(); @@ -1063,13 +1076,14 @@ int RGWLCCloudCheckCR::operate() { target_bucket.name = tier_ctx.target_bucket_name; target_obj_name = tier_ctx.bucket_info.bucket.name + "/" + - tier_ctx.obj.key.name + get_key_instance(tier_ctx.obj.key); + (*tier_ctx.obj)->get_name() + get_key_instance((*tier_ctx.obj)->get_key()); + + std::unique_ptr dest_bucket; + std::unique_ptr dest_obj; - std::shared_ptr dest_bucket; - dest_bucket.reset(new rgw::sal::RGWRadosBucket(tier_ctx.store, target_bucket)); + tier_ctx.store->get_bucket(tier_ctx.dpp, nullptr, target_bucket, &dest_bucket, null_yield); - std::shared_ptr dest_obj; - dest_obj.reset(new rgw::sal::RGWRadosObject(tier_ctx.store, rgw_obj_key(target_obj_name), (rgw::sal::RGWRadosBucket *)(dest_bucket.get()))); + dest_obj = dest_bucket->get_object(rgw_obj_key(target_obj_name)); std::shared_ptr get_crf; diff --git a/src/rgw/rgw_lc_tier.h b/src/rgw/rgw_lc_tier.h index 6f0fb331c09a6..eb323f2a6ed32 100644 --- a/src/rgw/rgw_lc_tier.h +++ b/src/rgw/rgw_lc_tier.h @@ -21,11 +21,11 @@ struct RGWLCCloudTierCtx { /* Source */ rgw_bucket_dir_entry& o; - rgw::sal::RGWRadosStore *store; + rgw::sal::RGWStore *store; RGWBucketInfo& bucket_info; string storage_class; - rgw_obj obj; + std::unique_ptr* obj; RGWObjectCtx& rctx; /* Remote */ @@ -41,9 +41,9 @@ struct RGWLCCloudTierCtx { bool is_multipart_upload{false}; RGWLCCloudTierCtx(CephContext* _cct, const DoutPrefixProvider *_dpp, - rgw_bucket_dir_entry& _o, rgw::sal::RGWRadosStore* _store, - RGWBucketInfo &_binfo, rgw_obj _obj, RGWObjectCtx& _rctx, - std::shared_ptr _conn, string _bucket, + rgw_bucket_dir_entry& _o, rgw::sal::RGWStore* _store, + RGWBucketInfo &_binfo, std::unique_ptr* _obj, + RGWObjectCtx& _rctx, std::shared_ptr _conn, string _bucket, string _storage_class, RGWHTTPManager *_http) : cct(_cct), dpp(_dpp), o(_o), store(_store), bucket_info(_binfo), obj(_obj), rctx(_rctx), conn(_conn), target_bucket_name(_bucket), -- 2.39.5