string display_name;
public:
ACLOwner() {}
+ ACLOwner(const rgw_user& _id) : id(_id) {}
~ACLOwner() {}
void encode(bufferlist& bl) const {
max_aio = concurrent_max;
}
- rgw_raw_obj last_obj = miter.get_location().get_raw_obj(store->getRados());
+ rgw_raw_obj last_obj = miter.get_location().get_raw_obj(store);
if (last_obj == raw_head_obj) {
// have the head obj deleted at the end
continue;
&state->dest_placement,
state->bucket_owner.get_id(),
*static_cast<RGWObjectCtx *>(state->obj_ctx),
- state->object->get_obj(), olh_epoch, state->req_id, this, state->yield);
+ std::move(state->object->clone()), olh_epoch, state->req_id,
+ this, state->yield);
op_ret = processor->prepare(state->yield);
if (op_ret < 0) {
RGWObjManifest::obj_iterator oiter = obj_part.manifest.obj_begin();
if (oiter != obj_part.manifest.obj_end()) {
rgw_obj head;
- rgw_raw_obj raw_head = oiter.get_location().get_raw_obj(store->getRados());
+ rgw_raw_obj raw_head = oiter.get_location().get_raw_obj(store);
RGWSI_Tier_RADOS::raw_obj_to_obj(bucket_info.bucket, raw_head, &head);
rgw_obj_index_key key;
#include "rgw_common.h"
#include "rgw_compression_types.h"
+#include "rgw_sal.h"
class RGWSI_Zone;
struct RGWZoneGroup;
}
rgw_raw_obj get_raw_obj(const RGWZoneGroup& zonegroup, const RGWZoneParams& zone_params) const;
- rgw_raw_obj get_raw_obj(RGWRados *store) const;
+ rgw_raw_obj get_raw_obj(rgw::sal::RGWStore* store) const;
rgw_obj_select& operator=(const rgw_obj& rhs) {
obj = rhs;
int create_next(uint64_t ofs);
rgw_raw_obj get_cur_obj(RGWZoneGroup& zonegroup, RGWZoneParams& zone_params) { return cur_obj.get_raw_obj(zonegroup, zone_params); }
- rgw_raw_obj get_cur_obj(RGWRados *store) const { return cur_obj.get_raw_obj(store); }
+ rgw_raw_obj get_cur_obj(rgw::sal::RGWStore* store) const { return cur_obj.get_raw_obj(store); }
/* total max size of current stripe (including head obj) */
uint64_t cur_stripe_max_size() const {
ldpp_dout(this, 20) << "dest_placement for part=" << upload_info.dest_placement << dendl;
processor.emplace<MultipartObjectProcessor>(
&*aio, store, s->bucket.get(), pdest_placement,
- s->owner.get_id(), obj_ctx, s->object->get_obj(),
+ s->owner.get_id(), obj_ctx, std::move(s->object->clone()),
multipart_upload_id, multipart_part_num, multipart_part_str,
this, s->yield);
} else if(append) {
pdest_placement = &s->dest_placement;
processor.emplace<AppendObjectProcessor>(
&*aio, store, s->bucket.get(), pdest_placement, s->bucket_owner.get_id(),
- obj_ctx, s->object->get_obj(),
+ obj_ctx, std::move(s->object->clone()),
s->req_id, position, &cur_accounted_size, this, s->yield);
} else {
if (s->bucket->versioning_enabled()) {
pdest_placement = &s->dest_placement;
processor.emplace<AtomicObjectProcessor>(
&*aio, store, s->bucket.get(), pdest_placement,
- s->bucket_owner.get_id(), obj_ctx, s->object->get_obj(), olh_epoch,
- s->req_id, this, s->yield);
+ s->bucket_owner.get_id(), obj_ctx, std::move(s->object->clone()),
+ olh_epoch, s->req_id, this, s->yield);
}
op_ret = processor->prepare(s->yield);
&s->dest_placement,
s->bucket_owner.get_id(),
*static_cast<RGWObjectCtx*>(s->obj_ctx),
- obj->get_obj(), 0, s->req_id, this, s->yield);
+ std::move(obj), 0, s->req_id, this, s->yield);
op_ret = processor.prepare(s->yield);
if (op_ret < 0) {
return;
using namespace rgw::putobj;
AtomicObjectProcessor processor(&*aio, store, bucket.get(), &s->dest_placement, bowner.get_id(),
- obj_ctx, obj->get_obj(), 0, s->req_id, this, s->yield);
+ obj_ctx, std::move(obj), 0, s->req_id, this, s->yield);
op_ret = processor.prepare(s->yield);
if (op_ret < 0) {
RGWObjManifest::obj_iterator miter;
for (miter = manifest.obj_begin(); miter != manifest.obj_end(); ++miter) {
- const rgw_raw_obj& loc = miter.get_location().get_raw_obj(store->getRados());
+ const rgw_raw_obj& loc = miter.get_location().get_raw_obj(store);
string s = loc.oid;
obj_oids.insert(obj_fingerprint(s));
}
RGWObjManifest::obj_iterator miter;
for (miter = manifest.obj_begin(); miter != manifest.obj_end(); ++miter) {
const rgw_raw_obj& loc =
- miter.get_location().get_raw_obj(store->getRados());
+ miter.get_location().get_raw_obj(store);
string s = loc.oid;
obj_oids.insert(s);
}
obj_it != manifest.obj_end();
++obj_it) {
const rgw_raw_obj& loc =
- obj_it.get_location().get_raw_obj(store->getRados());
+ obj_it.get_location().get_raw_obj(store);
std::cout << loc.oid << std::endl;
}
}
bool need_to_remove_head = false;
std::optional<rgw_raw_obj> raw_head;
- if (!head_obj.empty()) {
+ if (!rgw::sal::RGWObject::empty(head_obj.get())) {
raw_head.emplace();
- store->getRados()->obj_to_raw(bucket->get_placement_rule(), head_obj, &*raw_head);
+ head_obj->get_raw_obj(&*raw_head);
}
/**
continue;
}
- int r = store->getRados()->delete_raw_obj(obj);
+ int r = store->delete_raw_obj(obj);
if (r < 0 && r != -ENOENT) {
ldpp_dout(dpp, 0) << "WARNING: failed to remove obj (" << obj << "), leaked" << dendl;
}
}
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 = store->getRados()->delete_obj(obj_ctx, bucket->get_info(), head_obj, 0, 0);
+ int r = head_obj->delete_object(&obj_ctx, ACLOwner(), bucket->get_acl_owner(), ceph::real_time(),
+ false, 0, version_id, null_yield);
if (r < 0 && r != -ENOENT) {
ldpp_dout(dpp, 0) << "WARNING: failed to remove obj (" << *raw_head << "), leaked" << dendl;
}
return r;
}
- rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store->getRados());
+ rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store);
uint64_t chunk_size = 0;
- r = store->getRados()->get_max_chunk_size(stripe_obj.pool, &chunk_size);
+ r = store->get_raw_chunk_size(stripe_obj, &chunk_size);
if (r < 0) {
return r;
}
uint64_t head_max_size;
uint64_t chunk_size = 0;
uint64_t alignment;
- rgw_pool head_pool;
- if (!store->getRados()->get_obj_data_pool(bucket->get_placement_rule(), head_obj, &head_pool)) {
- return -EIO;
- }
-
- int r = store->getRados()->get_max_chunk_size(head_pool, &max_head_chunk_size, &alignment);
+ int r = head_obj->get_max_chunk_size(bucket->get_placement_rule(),
+ &max_head_chunk_size, &alignment);
if (r < 0) {
return r;
}
bool same_pool = true;
-
if (bucket->get_placement_rule() != tail_placement_rule) {
- rgw_pool tail_pool;
- if (!store->getRados()->get_obj_data_pool(tail_placement_rule, head_obj, &tail_pool)) {
- return -EIO;
- }
-
- if (tail_pool != head_pool) {
+ if (!head_obj->placement_rules_match(bucket->get_placement_rule(), tail_placement_rule)) {
same_pool = false;
-
- r = store->getRados()->get_max_chunk_size(tail_pool, &chunk_size);
+ r = head_obj->get_max_chunk_size(tail_placement_rule, &chunk_size);
if (r < 0) {
return r;
}
-
head_max_size = 0;
}
}
uint64_t stripe_size;
const uint64_t default_stripe_size = store->ctx()->_conf->rgw_obj_stripe_size;
- store->getRados()->get_max_aligned_size(default_stripe_size, alignment, &stripe_size);
+ head_obj->get_max_aligned_size(default_stripe_size, alignment, &stripe_size);
manifest.set_trivial_rule(head_max_size, stripe_size);
+ rgw_obj obj = head_obj->get_obj();
+
r = manifest_gen.create_begin(store->ctx(), &manifest,
bucket->get_placement_rule(),
&tail_placement_rule,
- head_obj.bucket, head_obj);
+ obj.bucket, obj);
if (r < 0) {
return r;
}
- rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store->getRados());
+ rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store);
r = writer.set_stripe_obj(stripe_obj);
if (r < 0) {
const std::string& etag,
ceph::real_time *mtime,
ceph::real_time set_mtime,
- std::map<std::string, bufferlist>& attrs,
+ rgw::sal::RGWAttrs& attrs,
ceph::real_time delete_at,
const char *if_match,
const char *if_nomatch,
return r;
}
- obj_ctx.set_atomic(head_obj);
+ head_obj->set_atomic(&obj_ctx);
- RGWRados::Object op_target(store->getRados(), bucket->get_info(), obj_ctx, head_obj);
+ std::unique_ptr<rgw::sal::RGWObject::WriteOp> obj_op = head_obj->get_write_op(&obj_ctx);
/* some object types shouldn't be versioned, e.g., multipart parts */
- op_target.set_versioning_disabled(!bucket->versioning_enabled());
-
- RGWRados::Object::Write obj_op(&op_target);
-
- obj_op.meta.data = &first_chunk;
- obj_op.meta.manifest = &manifest;
- obj_op.meta.ptag = &unique_tag; /* use req_id as operation tag */
- obj_op.meta.if_match = if_match;
- obj_op.meta.if_nomatch = if_nomatch;
- obj_op.meta.mtime = mtime;
- obj_op.meta.set_mtime = set_mtime;
- obj_op.meta.owner = owner;
- obj_op.meta.flags = PUT_OBJ_CREATE;
- obj_op.meta.olh_epoch = olh_epoch;
- obj_op.meta.delete_at = delete_at;
- obj_op.meta.user_data = user_data;
- obj_op.meta.zones_trace = zones_trace;
- obj_op.meta.modify_tail = true;
-
- r = obj_op.write_meta(actual_size, accounted_size, attrs, y);
+ obj_op->params.versioning_disabled = !bucket->versioning_enabled();
+ obj_op->params.data = &first_chunk;
+ obj_op->params.manifest = &manifest;
+ obj_op->params.ptag = &unique_tag; /* use req_id as operation tag */
+ obj_op->params.if_match = if_match;
+ obj_op->params.if_nomatch = if_nomatch;
+ obj_op->params.mtime = mtime;
+ obj_op->params.set_mtime = set_mtime;
+ obj_op->params.owner = ACLOwner(owner);
+ obj_op->params.flags = PUT_OBJ_CREATE;
+ obj_op->params.olh_epoch = olh_epoch;
+ obj_op->params.delete_at = delete_at;
+ obj_op->params.user_data = user_data;
+ obj_op->params.zones_trace = zones_trace;
+ obj_op->params.modify_tail = true;
+ obj_op->params.attrs = &attrs;
+
+ r = obj_op->prepare(y);
+ if (r < 0) {
+ return r;
+ }
+
+ r = obj_op->write_meta(actual_size, accounted_size, y);
if (r < 0) {
return r;
}
- if (!obj_op.meta.canceled) {
+ if (!obj_op->params.canceled) {
// on success, clear the set of objects for deletion
writer.clear_written();
}
if (pcanceled) {
- *pcanceled = obj_op.meta.canceled;
+ *pcanceled = obj_op->params.canceled;
}
return 0;
}
std::string oid_rand(32, 0);
gen_rand_alphanumeric(store->ctx(), oid_rand.data(), oid_rand.size());
- mp.init(target_obj.key.name, upload_id, oid_rand);
- manifest.set_prefix(target_obj.key.name + "." + oid_rand);
+ mp.init(target_obj->get_name(), upload_id, oid_rand);
+ manifest.set_prefix(target_obj->get_name() + "." + oid_rand);
r = prepare_head();
if (r < 0) {
uint64_t stripe_size;
uint64_t alignment;
- int r = store->getRados()->get_max_chunk_size(tail_placement_rule, target_obj, &chunk_size, &alignment);
+ int r = target_obj->get_max_chunk_size(tail_placement_rule, &chunk_size, &alignment);
if (r < 0) {
ldpp_dout(dpp, 0) << "ERROR: unexpected: get_max_chunk_size(): placement_rule=" << tail_placement_rule.to_str() << " obj=" << target_obj << " returned r=" << r << dendl;
return r;
}
- store->getRados()->get_max_aligned_size(default_stripe_size, alignment, &stripe_size);
+ target_obj->get_max_aligned_size(default_stripe_size, alignment, &stripe_size);
manifest.set_multipart_part_rule(stripe_size, part_num);
r = manifest_gen.create_begin(store->ctx(), &manifest,
- bucket->get_placement_rule(),
- &tail_placement_rule,
- target_obj.bucket, target_obj);
+ bucket->get_placement_rule(),
+ &tail_placement_rule,
+ target_obj->get_bucket()->get_key(),
+ target_obj->get_obj());
if (r < 0) {
return r;
}
- rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store->getRados());
- RGWSI_Tier_RADOS::raw_obj_to_obj(head_obj.bucket, stripe_obj, &head_obj);
- head_obj.index_hash_source = target_obj.key.name;
+ rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store);
+ head_obj->raw_obj_to_obj(stripe_obj);
+ head_obj->set_hash_source(target_obj->get_name());
r = writer.set_stripe_obj(stripe_obj);
if (r < 0) {
int MultipartObjectProcessor::prepare(optional_yield y)
{
- manifest.set_prefix(target_obj.key.name + "." + upload_id);
+ manifest.set_prefix(target_obj->get_name() + "." + upload_id);
return prepare_head();
}
return r;
}
- RGWRados::Object op_target(store->getRados(), bucket->get_info(), obj_ctx, head_obj);
- op_target.set_versioning_disabled(true);
- RGWRados::Object::Write obj_op(&op_target);
+ std::unique_ptr<rgw::sal::RGWObject::WriteOp> obj_op = head_obj->get_write_op(&obj_ctx);
- obj_op.meta.set_mtime = set_mtime;
- obj_op.meta.mtime = mtime;
- obj_op.meta.owner = owner;
- obj_op.meta.delete_at = delete_at;
- obj_op.meta.zones_trace = zones_trace;
- obj_op.meta.modify_tail = true;
+ obj_op->params.versioning_disabled = true;
+ obj_op->params.set_mtime = set_mtime;
+ obj_op->params.mtime = mtime;
+ obj_op->params.owner = ACLOwner(owner);
+ obj_op->params.delete_at = delete_at;
+ obj_op->params.zones_trace = zones_trace;
+ obj_op->params.modify_tail = true;
+ obj_op->params.attrs = &attrs;
+ r = obj_op->prepare(y);
+ if (r < 0) {
+ return r;
+ }
- r = obj_op.write_meta(actual_size, accounted_size, attrs, y);
+ r = obj_op->write_meta(actual_size, accounted_size, y);
if (r < 0)
return r;
encode(info, bl);
- rgw_obj meta_obj;
- meta_obj.init_ns(bucket->get_key(), mp.get_meta(), RGW_OBJ_NS_MULTIPART);
- meta_obj.set_in_extra_data(true);
-
- rgw_raw_obj raw_meta_obj;
+ std::unique_ptr<rgw::sal::RGWObject> meta_obj =
+ bucket->get_object(rgw_obj_key(mp.get_meta(), std::string(), RGW_OBJ_NS_MULTIPART));
+ meta_obj->set_in_extra_data(true);
- store->getRados()->obj_to_raw(bucket->get_placement_rule(), meta_obj, &raw_meta_obj);
-
- auto obj_ctx = store->svc()->sysobj->init_obj_ctx();
- auto sysobj = obj_ctx.get_obj(raw_meta_obj);
-
- r = sysobj.omap()
- .set_must_exist(true)
- .set(p, bl, null_yield);
+ r = meta_obj->omap_set_val_by_key(p, bl, true, null_yield);
if (r < 0) {
return r == -ENOENT ? -ERR_NO_SUCH_UPLOAD : r;
}
- if (!obj_op.meta.canceled) {
+ if (!obj_op->params.canceled) {
// on success, clear the set of objects for deletion
writer.clear_written();
}
if (pcanceled) {
- *pcanceled = obj_op.meta.canceled;
+ *pcanceled = obj_op->params.canceled;
}
return 0;
}
int AppendObjectProcessor::prepare(optional_yield y)
{
RGWObjState *astate;
- int r = store->getRados()->get_obj_state(&obj_ctx, bucket->get_info(), head_obj, &astate, y);
+ int r = head_obj->get_obj_state(&obj_ctx, *bucket, &astate, y);
if (r < 0) {
return r;
}
//set the prefix
char buf[33];
gen_rand_alphanumeric(store->ctx(), buf, sizeof(buf) - 1);
- string oid_prefix = head_obj.key.name;
+ string oid_prefix = head_obj->get_name();
oid_prefix.append(".");
oid_prefix.append(buf);
oid_prefix.append("_");
}
manifest.set_multipart_part_rule(store->ctx()->_conf->rgw_obj_stripe_size, cur_part_num);
- r = manifest_gen.create_begin(store->ctx(), &manifest, bucket->get_placement_rule(), &tail_placement_rule, head_obj.bucket, head_obj);
+ rgw_obj obj = head_obj->get_obj();
+
+ r = manifest_gen.create_begin(store->ctx(), &manifest, bucket->get_placement_rule(), &tail_placement_rule, obj.bucket, obj);
if (r < 0) {
return r;
}
- rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store->getRados());
+ rgw_raw_obj stripe_obj = manifest_gen.get_cur_obj(store);
uint64_t chunk_size = 0;
- r = store->getRados()->get_max_chunk_size(stripe_obj.pool, &chunk_size);
+ r = store->get_raw_chunk_size(stripe_obj, &chunk_size);
if (r < 0) {
return r;
}
}
int AppendObjectProcessor::complete(size_t accounted_size, const string &etag, ceph::real_time *mtime,
- ceph::real_time set_mtime, map <string, bufferlist> &attrs,
+ ceph::real_time set_mtime, rgw::sal::RGWAttrs& attrs,
ceph::real_time delete_at, const char *if_match, const char *if_nomatch,
const string *user_data, rgw_zone_set *zones_trace, bool *pcanceled,
optional_yield y)
if (r < 0) {
return r;
}
- obj_ctx.set_atomic(head_obj);
- RGWRados::Object op_target(store->getRados(), bucket->get_info(), obj_ctx, head_obj);
+ head_obj->set_atomic(&obj_ctx);
+ std::unique_ptr<rgw::sal::RGWObject::WriteOp> obj_op = head_obj->get_write_op(&obj_ctx);
//For Append obj, disable versioning
- op_target.set_versioning_disabled(true);
- RGWRados::Object::Write obj_op(&op_target);
+ obj_op->params.versioning_disabled = true;
if (cur_manifest) {
cur_manifest->append(manifest, store->svc()->zone);
- obj_op.meta.manifest = cur_manifest;
+ obj_op->params.manifest = cur_manifest;
} else {
- obj_op.meta.manifest = &manifest;
- }
- obj_op.meta.ptag = &unique_tag; /* use req_id as operation tag */
- obj_op.meta.mtime = mtime;
- obj_op.meta.set_mtime = set_mtime;
- obj_op.meta.owner = owner;
- obj_op.meta.flags = PUT_OBJ_CREATE;
- obj_op.meta.delete_at = delete_at;
- obj_op.meta.user_data = user_data;
- obj_op.meta.zones_trace = zones_trace;
- obj_op.meta.modify_tail = true;
- obj_op.meta.appendable = true;
+ obj_op->params.manifest = &manifest;
+ }
+ obj_op->params.ptag = &unique_tag; /* use req_id as operation tag */
+ obj_op->params.mtime = mtime;
+ obj_op->params.set_mtime = set_mtime;
+ obj_op->params.owner = ACLOwner(owner);
+ obj_op->params.flags = PUT_OBJ_CREATE;
+ obj_op->params.delete_at = delete_at;
+ obj_op->params.user_data = user_data;
+ obj_op->params.zones_trace = zones_trace;
+ obj_op->params.modify_tail = true;
+ obj_op->params.appendable = true;
+ obj_op->params.attrs = &attrs;
//Add the append part number
bufferlist cur_part_num_bl;
using ceph::encode;
etag_bl.append(final_etag_str, strlen(final_etag_str) + 1);
attrs[RGW_ATTR_ETAG] = etag_bl;
}
- r = obj_op.write_meta(actual_size + cur_size, accounted_size + *cur_accounted_size, attrs, y);
+ r = obj_op->prepare(y);
+ if (r < 0) {
+ return r;
+ }
+ r = obj_op->write_meta(actual_size + cur_size, accounted_size + *cur_accounted_size, y);
if (r < 0) {
return r;
}
- if (!obj_op.meta.canceled) {
+ if (!obj_op->params.canceled) {
// on success, clear the set of objects for deletion
writer.clear_written();
}
if (pcanceled) {
- *pcanceled = obj_op.meta.canceled;
+ *pcanceled = obj_op->params.canceled;
}
*cur_accounted_size += accounted_size;
#include "services/svc_rados.h"
#include "services/svc_tier_rados.h"
#include "rgw_sal.h"
+#include "rgw_obj_manifest.h"
namespace rgw {
rgw::sal::RGWRadosStore *const store;
rgw::sal::RGWBucket* bucket;
RGWObjectCtx& obj_ctx;
- const rgw_obj head_obj;
+ std::unique_ptr<rgw::sal::RGWObject> head_obj;
RGWSI_RADOS::Obj stripe_obj; // current stripe object
RawObjSet written; // set of written objects for deletion
const DoutPrefixProvider *dpp;
public:
RadosWriter(Aio *aio, rgw::sal::RGWRadosStore *store,
rgw::sal::RGWBucket* bucket,
- RGWObjectCtx& obj_ctx, const rgw_obj& head_obj,
+ RGWObjectCtx& obj_ctx, std::unique_ptr<rgw::sal::RGWObject> _head_obj,
const DoutPrefixProvider *dpp, optional_yield y)
: aio(aio), store(store), bucket(bucket),
- obj_ctx(obj_ctx), head_obj(head_obj), dpp(dpp), y(y)
+ obj_ctx(obj_ctx), head_obj(std::move(_head_obj)), dpp(dpp), y(y)
{}
+ RadosWriter(RadosWriter&& r)
+ : aio(r.aio), store(r.store), bucket(r.bucket),
+ obj_ctx(r.obj_ctx), head_obj(std::move(r.head_obj)), dpp(r.dpp), y(r.y)
+ {}
+
~RadosWriter();
// change the current stripe object
rgw_placement_rule tail_placement_rule;
rgw_user owner;
RGWObjectCtx& obj_ctx;
- rgw_obj head_obj;
+ std::unique_ptr<rgw::sal::RGWObject> head_obj;
RadosWriter writer;
RGWObjManifest manifest;
rgw::sal::RGWBucket* bucket,
const rgw_placement_rule *ptail_placement_rule,
const rgw_user& owner, RGWObjectCtx& obj_ctx,
- rgw_obj& head_obj,
+ std::unique_ptr<rgw::sal::RGWObject> _head_obj,
const DoutPrefixProvider* dpp, optional_yield y)
: HeadObjectProcessor(0),
store(store), bucket(bucket),
owner(owner),
- obj_ctx(obj_ctx), head_obj(head_obj),
- writer(aio, store, bucket, obj_ctx, head_obj, dpp, y),
+ obj_ctx(obj_ctx), head_obj(std::move(_head_obj)),
+ writer(aio, store, bucket, obj_ctx, std::move(head_obj->clone()), dpp, y),
chunk(&writer, 0), stripe(&chunk, this, 0), dpp(dpp) {
if (ptail_placement_rule) {
tail_placement_rule = *ptail_placement_rule;
rgw::sal::RGWBucket* bucket,
const rgw_placement_rule *ptail_placement_rule,
const rgw_user& owner,
- RGWObjectCtx& obj_ctx, rgw_obj head_obj,
+ RGWObjectCtx& obj_ctx,
+ std::unique_ptr<rgw::sal::RGWObject> _head_obj,
std::optional<uint64_t> olh_epoch,
const std::string& unique_tag,
const DoutPrefixProvider *dpp, optional_yield y)
: ManifestObjectProcessor(aio, store, bucket, ptail_placement_rule,
- owner, obj_ctx, head_obj, dpp, y),
+ owner, obj_ctx, std::move(_head_obj), dpp, y),
olh_epoch(olh_epoch), unique_tag(unique_tag)
{}
// part's head is written with an exclusive create to detect racing uploads of
// the same part/upload id, which are restarted with a random oid prefix
class MultipartObjectProcessor : public ManifestObjectProcessor {
- const rgw_obj target_obj; // target multipart object
+ std::unique_ptr<rgw::sal::RGWObject> target_obj; // target multipart object
const std::string upload_id;
const int part_num;
const std::string part_num_str;
rgw::sal::RGWBucket* bucket,
const rgw_placement_rule *ptail_placement_rule,
const rgw_user& owner, RGWObjectCtx& obj_ctx,
- rgw_obj head_obj,
+ std::unique_ptr<rgw::sal::RGWObject> _head_obj,
const std::string& upload_id, uint64_t part_num,
const std::string& part_num_str,
const DoutPrefixProvider *dpp, optional_yield y)
: ManifestObjectProcessor(aio, store, bucket, ptail_placement_rule,
- owner, obj_ctx, head_obj, dpp, y),
- target_obj(head_obj), upload_id(upload_id),
+ owner, obj_ctx, std::move(_head_obj), dpp, y),
+ target_obj(std::move(head_obj->clone())), upload_id(upload_id),
part_num(part_num), part_num_str(part_num_str),
- mp(head_obj.key.name, upload_id)
+ mp(head_obj->get_name(), upload_id)
{}
// prepare a multipart manifest
rgw::sal::RGWBucket* bucket,
const rgw_placement_rule *ptail_placement_rule,
const rgw_user& owner, RGWObjectCtx& obj_ctx,
- rgw_obj head_obj,
+ std::unique_ptr<rgw::sal::RGWObject> _head_obj,
const std::string& unique_tag, uint64_t position,
uint64_t *cur_accounted_size,
const DoutPrefixProvider *dpp, optional_yield y)
: ManifestObjectProcessor(aio, store, bucket, ptail_placement_rule,
- owner, obj_ctx, head_obj, dpp, y),
+ owner, obj_ctx, std::move(_head_obj), dpp, y),
position(position), cur_size(0), cur_accounted_size(cur_accounted_size),
unique_tag(unique_tag), cur_manifest(nullptr)
{}
return raw_obj;
}
-rgw_raw_obj rgw_obj_select::get_raw_obj(RGWRados *store) const
+rgw_raw_obj rgw_obj_select::get_raw_obj(rgw::sal::RGWStore* store) const
{
if (!is_raw) {
rgw_raw_obj r;
- store->obj_to_raw(placement_rule, obj, &r);
+ store->get_raw_obj(placement_rule, obj, &r);
return r;
}
return raw_obj;
RGWObjManifest::obj_iterator miter;
RGWObjManifest& manifest = *astate->manifest;
for (miter = manifest.obj_begin(); miter != manifest.obj_end(); ++miter) {
- rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(this);
+ rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(store);
rgw_obj loc;
string oid;
string locator;
rgw::BlockingAioThrottle aio(cct->_conf->rgw_put_obj_min_window_size);
using namespace rgw::putobj;
AtomicObjectProcessor processor(&aio, this->store, dest_bucket, nullptr, user_id,
- obj_ctx, dest_obj->get_obj(), olh_epoch, tag, dpp, null_yield);
+ obj_ctx, std::move(dest_obj->clone()), olh_epoch,
+ tag, dpp, null_yield);
RGWRESTConn *conn;
auto& zone_conn_map = svc.zone->get_zone_conn_map();
auto& zonegroup_conn_map = svc.zone->get_zonegroup_conn_map();
}
rgw_rados_ref ref;
- ret = get_raw_obj_ref(miter.get_location().get_raw_obj(this), &ref);
+ ret = get_raw_obj_ref(miter.get_location().get_raw_obj(store), &ref);
if (ret < 0) {
return ret;
}
ObjectWriteOperation op;
ref_tag = tag + '\0';
cls_refcount_get(op, ref_tag, true);
- const rgw_raw_obj& loc = miter.get_location().get_raw_obj(this);
+ const rgw_raw_obj& loc = miter.get_location().get_raw_obj(store);
auto& ioctx = ref.pool.ioctx();
ioctx.locator_set_key(loc.loc);
// it causes crashes in the ragweed tests
AtomicObjectProcessor processor(&aio, this->store, bucket, &dest_placement,
bucket->get_info().owner, obj_ctx,
- dest_obj->get_obj(), olh_epoch, tag, dpp, null_yield);
+ std::move(dest_obj->clone()), olh_epoch, tag,
+ dpp, null_yield);
int ret = processor.prepare(y);
if (ret < 0)
return ret;
rgw_raw_obj raw_head;
obj_to_raw(manifest.get_head_placement_rule(), head_obj, &raw_head);
for (iter = manifest.obj_begin(); iter != manifest.obj_end(); ++iter) {
- const rgw_raw_obj& mobj = iter.get_location().get_raw_obj(this);
+ const rgw_raw_obj& mobj = iter.get_location().get_raw_obj(store);
if (mobj == raw_head)
continue;
cls_rgw_obj_key key(mobj.oid);
return index_op.complete_del(-1 /* pool */, 0, mtime, NULL);
}
-static void generate_fake_tag(RGWRados *store, map<string, bufferlist>& attrset, RGWObjManifest& manifest, bufferlist& manifest_bl, bufferlist& tag_bl)
+static void generate_fake_tag(rgw::sal::RGWStore* store, map<string, bufferlist>& attrset, RGWObjManifest& manifest, bufferlist& manifest_bl, bufferlist& tag_bl)
{
string tag;
s->manifest->has_explicit_objs()) {
RGWObjManifest::obj_iterator mi;
for (mi = s->manifest->obj_begin(); mi != s->manifest->obj_end(); ++mi) {
- ldout(cct, 20) << "manifest: ofs=" << mi.get_ofs() << " loc=" << mi.get_location().get_raw_obj(this) << dendl;
+ ldout(cct, 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(this, s->attrset, *s->manifest, manifest_bl, s->obj_tag);
+ generate_fake_tag(store, s->attrset, *s->manifest, manifest_bl, s->obj_tag);
s->fake_tag = true;
}
}
RGWObjManifest::obj_iterator iter = astate->manifest->obj_find(ofs);
uint64_t stripe_ofs = iter.get_stripe_ofs();
- read_obj = iter.get_location().get_raw_obj(store);
+ read_obj = iter.get_location().get_raw_obj(store->store);
len = std::min(len, iter.get_stripe_size() - (ofs - stripe_ofs));
read_ofs = iter.location_ofs() + (ofs - stripe_ofs);
reading_from_head = (read_obj == state.head_obj);
off_t next_stripe_ofs = stripe_ofs + iter.get_stripe_size();
while (ofs < next_stripe_ofs && ofs <= end) {
- read_obj = iter.get_location().get_raw_obj(this);
+ read_obj = iter.get_location().get_raw_obj(store);
uint64_t read_len = std::min(len, iter.get_stripe_size() - (ofs - stripe_ofs));
read_ofs = iter.location_ofs() + (ofs - stripe_ofs);
RGWObjManifest::obj_iterator miter;
RGWObjManifest& manifest = *astate->manifest;
for (miter = manifest.obj_begin(); miter != manifest.obj_end(); ++miter) {
- const rgw_raw_obj& raw_loc = miter.get_location().get_raw_obj(this);
+ 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);
f.open_array_section("data_location");
for (auto miter = manifest->obj_begin(); miter != manifest->obj_end(); ++miter) {
f.open_object_section("obj");
- rgw_raw_obj raw_loc = miter.get_location().get_raw_obj(store->getRados());
+ 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;
::encode_json("ofs", miter.get_ofs(), &f);
#pragma once
#include "rgw_user.h"
-#include "rgw_obj_manifest.h"
class RGWGetDataCB;
struct RGWObjState;
class RGWAccessListFilter;
class RGWLC;
+class RGWObjManifest;
+struct RGWZoneGroup;
struct RGWUsageIter {
string read_iter;
virtual int cluster_stat(RGWClusterStat& stats) = 0;
virtual std::unique_ptr<Lifecycle> get_lifecycle(void) = 0;
virtual RGWLC* get_rgwlc(void) = 0;
+ virtual int delete_raw_obj(const rgw_raw_obj& obj) = 0;
+ virtual void get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj) = 0;
+ virtual int get_raw_chunk_size(const rgw_raw_obj& obj, uint64_t* chunk_size) = 0;
virtual void finalize(void)=0;
virtual int put_instance_info(bool exclusive, ceph::real_time mtime) = 0;
virtual bool is_owner(RGWUser* user) = 0;
virtual RGWUser* get_owner(void) { return owner; };
+ virtual ACLOwner get_acl_owner(void) { return ACLOwner(info.owner); };
virtual int check_empty(optional_yield y) = 0;
virtual int check_quota(RGWQuotaInfo& user_quota, RGWQuotaInfo& bucket_quota, uint64_t obj_size, optional_yield y, bool check_size_only = false) = 0;
virtual int set_instance_attrs(RGWAttrs& attrs, optional_yield y) = 0;
virtual int delete_object(RGWObjectCtx* obj_ctx, ACLOwner obj_owner,
ACLOwner bucket_owner, ceph::real_time unmod_since,
bool high_precision_time, uint64_t epoch,
- std::string& version_id,optional_yield y) = 0;
+ std::string& version_id, optional_yield y) = 0;
virtual int copy_object(RGWObjectCtx& obj_ctx, RGWUser* user,
req_info *info, const rgw_zone_id& source_zone,
rgw::sal::RGWObject* dest_object, rgw::sal::RGWBucket* dest_bucket,
virtual int delete_obj_attrs(RGWObjectCtx *rctx, const char *attr_name, optional_yield y) = 0;
virtual int copy_obj_data(RGWObjectCtx& rctx, RGWBucket* dest_bucket, RGWObject* dest_obj, uint16_t olh_epoch, std::string* petag, const DoutPrefixProvider *dpp, optional_yield y) = 0;
virtual bool is_expired() = 0;
+ virtual void gen_rand_obj_instance_name() = 0;
+ virtual void raw_obj_to_obj(const rgw_raw_obj& raw_obj) = 0;
+ virtual void get_raw_obj(rgw_raw_obj* raw_obj) = 0;
virtual MPSerializer* get_serializer(const std::string& lock_name) = 0;
+ virtual int transition(RGWObjectCtx& rctx,
+ RGWBucket* bucket,
+ const rgw_placement_rule& placement_rule,
+ const real_time& mtime,
+ uint64_t olh_epoch,
+ const DoutPrefixProvider *dpp,
+ optional_yield y) = 0;
+ virtual int get_max_chunk_size(rgw_placement_rule placement_rule,
+ uint64_t* max_chunk_size,
+ uint64_t* alignment = nullptr) = 0;
+ virtual void get_max_aligned_size(uint64_t size, uint64_t alignment, uint64_t *max_size) = 0;
+ virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) = 0;
RGWAttrs& get_attrs(void) { return attrs; }
ceph::real_time get_mtime(void) const { return mtime; }
bool get_in_extra_data(void) { return in_extra_data; }
void set_in_extra_data(bool i) { in_extra_data = i; }
int range_to_ofs(uint64_t obj_size, int64_t &ofs, int64_t &end);
+ void set_obj_size(uint64_t s) { obj_size = s; }
+ virtual void set_name(const std::string& n) { key = n; }
+ virtual void set_key(const rgw_obj_key& k) { key = k; }
+ 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;
+ }
/* Swift versioning */
virtual int swift_versioning_restore(RGWObjectCtx* obj_ctx,
virtual int omap_get_vals_by_keys(const std::string& oid,
const std::set<std::string>& keys,
RGWAttrs *vals) = 0;
+ virtual int omap_set_val_by_key(const std::string& key, bufferlist& val,
+ bool must_exist, optional_yield y) = 0;
static bool empty(RGWObject* o) { return (!o || o->empty()); }
virtual std::unique_ptr<RGWObject> clone() = 0;
/* dang - Not sure if we want this, but it simplifies things a lot */
- void set_obj_size(uint64_t s) { obj_size = s; }
- virtual void set_name(const std::string& n) { key = n; }
- virtual void set_key(const rgw_obj_key& k) { key = k; }
- virtual rgw_obj get_obj(void) const {
- rgw_obj obj(bucket->get_key(), key);
- obj.set_in_extra_data(in_extra_data);
- return obj;
- }
- virtual void gen_rand_obj_instance_name() = 0;
- virtual void raw_obj_to_obj(const rgw_raw_obj& raw_obj) = 0;
- virtual void get_raw_obj(rgw_raw_obj* raw_obj) = 0;
- virtual int transition(RGWObjectCtx& rctx,
- RGWBucket* bucket,
- const rgw_placement_rule& placement_rule,
- const real_time& mtime,
- uint64_t olh_epoch,
- const DoutPrefixProvider *dpp,
- optional_yield y) = 0;
/* dang - This is temporary, until the API is completed */
rgw_obj_key& get_key() { return key; }
bool have_instance(void) { return key.have_instance(); }
friend inline ostream& operator<<(ostream& out, const RGWObject& o) {
+ if (o.bucket)
+ out << o.bucket << ":";
out << o.key;
return out;
}
if (!o)
out << "<NULL>";
else
- out << o->key;
+ out << *o;
return out;
}
friend inline ostream& operator<<(ostream& out, const std::unique_ptr<RGWObject>& p) {
return cur_ioctx.omap_get_vals_by_keys(oid, keys, vals);
}
+int RGWRadosObject::omap_set_val_by_key(const std::string& key, bufferlist& val,
+ bool must_exist, optional_yield y)
+{
+ rgw_raw_obj raw_meta_obj;
+ rgw_obj obj = get_obj();
+
+ store->getRados()->obj_to_raw(bucket->get_placement_rule(), obj, &raw_meta_obj);
+
+ auto obj_ctx = store->svc()->sysobj->init_obj_ctx();
+ auto sysobj = obj_ctx.get_obj(raw_meta_obj);
+
+ return sysobj.omap().set_must_exist(must_exist).set(key, val, y);
+}
+
MPSerializer* RGWRadosObject::get_serializer(const std::string& lock_name)
{
return new MPRadosSerializer(store, this, lock_name);
return store->getRados()->transition_obj(rctx, bucket, *this, placement_rule, mtime, olh_epoch, dpp, y);
}
+int RGWRadosObject::get_max_chunk_size(rgw_placement_rule placement_rule, uint64_t *max_chunk_size, uint64_t *alignment)
+{
+ return store->getRados()->get_max_chunk_size(placement_rule, get_obj(), max_chunk_size, alignment);
+}
+
+void RGWRadosObject::get_max_aligned_size(uint64_t size, uint64_t alignment,
+ uint64_t *max_size)
+{
+ store->getRados()->get_max_aligned_size(size, alignment, max_size);
+}
+
+bool RGWRadosObject::placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2)
+{
+ rgw_obj obj;
+ rgw_pool p1, p2;
+
+ obj = get_obj();
+
+ if (r1 == r2)
+ return true;
+
+ if (!store->getRados()->get_obj_data_pool(r1, obj, &p1)) {
+ return false;
+ }
+ if (!store->getRados()->get_obj_data_pool(r2, obj, &p2)) {
+ return false;
+ }
+
+ return p1 == p2;
+}
+
std::unique_ptr<RGWObject::ReadOp> RGWRadosObject::get_read_op(RGWObjectCtx *ctx)
{
return std::unique_ptr<RGWObject::ReadOp>(new RGWRadosObject::RadosReadOp(this, ctx));
return std::unique_ptr<Lifecycle>(new RadosLifecycle(this));
}
+int RGWRadosStore::delete_raw_obj(const rgw_raw_obj& obj)
+{
+ return rados->delete_raw_obj(obj);
+}
+
+void RGWRadosStore::get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj)
+{
+ rados->obj_to_raw(placement_rule, obj, raw_obj);
+}
+
+int RGWRadosStore::get_raw_chunk_size(const rgw_raw_obj& obj, uint64_t* chunk_size)
+{
+ return rados->get_max_chunk_size(obj.pool, chunk_size);
+}
MPRadosSerializer::MPRadosSerializer(RGWRadosStore* store, RGWRadosObject* obj, const std::string& lock_name) :
lock(lock_name)
uint64_t olh_epoch,
const DoutPrefixProvider *dpp,
optional_yield y) override;
+ virtual int get_max_chunk_size(rgw_placement_rule placement_rule,
+ uint64_t *max_chunk_size,
+ uint64_t *alignment = nullptr) override;
+ virtual void get_max_aligned_size(uint64_t size, uint64_t alignment, uint64_t *max_size) override;
+ virtual bool placement_rules_match(rgw_placement_rule& r1, rgw_placement_rule& r2) override;
/* Swift versioning */
virtual int swift_versioning_restore(RGWObjectCtx* obj_ctx,
virtual int omap_get_vals_by_keys(const std::string& oid,
const std::set<std::string>& keys,
RGWAttrs *vals) override;
+ virtual int omap_set_val_by_key(const std::string& key, bufferlist& val,
+ bool must_exist, optional_yield y) override;
private:
int read_attrs(RGWRados::Object::Read &read_op, optional_yield y, rgw_obj *target_obj = nullptr);
virtual int cluster_stat(RGWClusterStat& stats) override;
virtual std::unique_ptr<Lifecycle> get_lifecycle(void) override;
virtual RGWLC* get_rgwlc(void) { return rados->get_lc(); }
+ virtual int delete_raw_obj(const rgw_raw_obj& obj) override;
+ virtual void get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj) override;
+ virtual int get_raw_chunk_size(const rgw_raw_obj& obj, uint64_t* chunk_size) override;
void setRados(RGWRados * st) { rados = st; }
RGWRados *getRados(void) { return rados; }
using namespace rgw::putobj;
AtomicObjectProcessor processor(&aio, store, b.get(), nullptr,
- owner.get_id(), obj_ctx, obj->get_obj(), olh_epoch,
+ owner.get_id(), obj_ctx, std::move(obj), olh_epoch,
req_id, dpp, y);
int ret = processor.prepare(y);
projects / ceph.git / commitdiff