struct RGWCacheNotifyInfo {
uint32_t op;
- rgw_obj obj;
+ rgw_raw_obj obj;
ObjectCacheInfo obj_info;
off_t ofs;
string ns;
{
ObjectCache cache;
- int list_objects_raw_init(rgw_bucket& bucket, RGWAccessHandle *handle) {
- return T::list_objects_raw_init(bucket, handle);
+ int list_objects_raw_init(rgw_pool& pool, RGWAccessHandle *handle) {
+ return T::list_objects_raw_init(pool, handle);
}
int list_objects_raw_next(RGWObjEnt& obj, RGWAccessHandle *handle) {
return T::list_objects_raw_next(obj, handle);
}
- string normal_name(rgw_bucket& bucket, const std::string& oid) {
- string& bucket_name = bucket.name;
- char buf[bucket_name.size() + 1 + oid.size() + 1];
- const char *bucket_str = bucket_name.c_str();
+ string normal_name(rgw_pool& pool, const std::string& oid) {
+ string& pool_name = pool.name;
+ char buf[pool_name.size() + 1 + oid.size() + 1];
+ const char *pool_str = pool_name.c_str();
const char *oid_str = oid.c_str();
- sprintf(buf, "%s+%s", bucket_str, oid_str);
+ sprintf(buf, "%s+%s", pool_str, oid_str);
return string(buf);
}
- void normalize_bucket_and_obj(rgw_bucket& src_bucket, const string& src_obj, rgw_bucket& dst_bucket, string& dst_obj);
- string normal_name(rgw_obj& obj) {
- return normal_name(obj.bucket, obj.get_object());
+ void normalize_pool_and_obj(rgw_pool& src_pool, const string& src_obj, rgw_pool& dst_pool, string& dst_obj);
+ string normal_name(rgw_raw_obj& obj) {
+ return normal_name(obj.pool, obj.oid);
}
int init_rados() {
return true;
}
- int distribute_cache(const string& normal_name, rgw_obj& obj, ObjectCacheInfo& obj_info, int op);
+ int distribute_cache(const string& normal_name, rgw_raw_obj& obj, ObjectCacheInfo& obj_info, int op);
int watch_cb(uint64_t notify_id,
uint64_t cookie,
uint64_t notifier_id,
cache.chain_cache(cc);
}
- int system_obj_set_attrs(void *ctx, rgw_obj& obj,
+ int system_obj_set_attrs(void *ctx, rgw_raw_obj& obj,
map<string, bufferlist>& attrs,
map<string, bufferlist>* rmattrs,
RGWObjVersionTracker *objv_tracker);
- int put_system_obj_impl(rgw_obj& obj, uint64_t size, real_time *mtime,
+ int put_system_obj_impl(rgw_raw_obj& obj, uint64_t size, real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
real_time set_mtime);
- int put_system_obj_data(void *ctx, rgw_obj& obj, bufferlist& bl, off_t ofs, bool exclusive);
+ int put_system_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& bl, off_t ofs, bool exclusive);
int get_system_obj(RGWObjectCtx& obj_ctx, RGWRados::SystemObject::Read::GetObjState& read_state,
- RGWObjVersionTracker *objv_tracker, rgw_obj& obj,
+ RGWObjVersionTracker *objv_tracker, rgw_raw_obj& obj,
bufferlist& bl, off_t ofs, off_t end,
map<string, bufferlist> *attrs,
rgw_cache_entry_info *cache_info);
- int raw_obj_stat(rgw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs,
+ int raw_obj_stat(rgw_raw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch, map<string, bufferlist> *attrs,
bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker);
- int delete_system_obj(rgw_obj& obj, RGWObjVersionTracker *objv_tracker);
+ int delete_system_obj(rgw_raw_obj& obj, RGWObjVersionTracker *objv_tracker);
bool chain_cache_entry(list<rgw_cache_entry_info *>& cache_info_entries, RGWChainedCache::Entry *chained_entry) {
return cache.chain_cache_entry(cache_info_entries, chained_entry);
};
template <class T>
-void RGWCache<T>::normalize_bucket_and_obj(rgw_bucket& src_bucket, const string& src_obj, rgw_bucket& dst_bucket, string& dst_obj)
+void RGWCache<T>::normalize_pool_and_obj(rgw_pool& src_pool, const string& src_obj, rgw_pool& dst_pool, string& dst_obj)
{
if (src_obj.size()) {
- dst_bucket = src_bucket;
+ dst_pool = src_pool;
dst_obj = src_obj;
} else {
- dst_bucket = T::get_zone_params().domain_root;
- dst_obj = src_bucket.name;
+ dst_pool = T::get_zone_params().domain_root;
+ dst_obj = src_pool.name;
}
}
template <class T>
-int RGWCache<T>::delete_system_obj(rgw_obj& obj, RGWObjVersionTracker *objv_tracker)
+int RGWCache<T>::delete_system_obj(rgw_raw_obj& obj, RGWObjVersionTracker *objv_tracker)
{
- rgw_bucket bucket;
+ rgw_pool pool;
string oid;
- normalize_bucket_and_obj(obj.bucket, obj.get_object(), bucket, oid);
+ normalize_pool_and_obj(obj.pool, obj.oid, pool, oid);
string name = normal_name(obj);
cache.remove(name);
template <class T>
int RGWCache<T>::get_system_obj(RGWObjectCtx& obj_ctx, RGWRados::SystemObject::Read::GetObjState& read_state,
- RGWObjVersionTracker *objv_tracker, rgw_obj& obj,
+ RGWObjVersionTracker *objv_tracker, rgw_raw_obj& obj,
bufferlist& obl, off_t ofs, off_t end,
map<string, bufferlist> *attrs,
rgw_cache_entry_info *cache_info)
{
- rgw_bucket bucket;
+ rgw_pool pool;
string oid;
- normalize_bucket_and_obj(obj.bucket, obj.get_object(), bucket, oid);
+ normalize_pool_and_obj(obj.pool, obj.oid, pool, oid);
if (ofs != 0)
return T::get_system_obj(obj_ctx, read_state, objv_tracker, obj, obl, ofs, end, attrs, cache_info);
- string name = normal_name(obj.bucket, oid);
+ string name = normal_name(obj.pool, oid);
ObjectCacheInfo info;
}
template <class T>
-int RGWCache<T>::system_obj_set_attrs(void *ctx, rgw_obj& obj,
+int RGWCache<T>::system_obj_set_attrs(void *ctx, rgw_raw_obj& obj,
map<string, bufferlist>& attrs,
map<string, bufferlist>* rmattrs,
RGWObjVersionTracker *objv_tracker)
{
- rgw_bucket bucket;
+ rgw_pool pool;
string oid;
- normalize_bucket_and_obj(obj.bucket, obj.get_object(), bucket, oid);
+ normalize_pool_and_obj(obj.pool, obj.oid, pool, oid);
ObjectCacheInfo info;
info.xattrs = attrs;
if (rmattrs)
info.flags |= CACHE_FLAG_OBJV;
}
int ret = T::system_obj_set_attrs(ctx, obj, attrs, rmattrs, objv_tracker);
- string name = normal_name(bucket, oid);
+ string name = normal_name(pool, oid);
if (ret >= 0) {
cache.put(name, info, NULL);
int r = distribute_cache(name, obj, info, UPDATE_OBJ);
}
template <class T>
-int RGWCache<T>::put_system_obj_impl(rgw_obj& obj, uint64_t size, real_time *mtime,
+int RGWCache<T>::put_system_obj_impl(rgw_raw_obj& obj, uint64_t size, real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
real_time set_mtime)
{
- rgw_bucket bucket;
+ rgw_pool pool;
string oid;
- normalize_bucket_and_obj(obj.bucket, obj.get_object(), bucket, oid);
+ normalize_pool_and_obj(obj.pool, obj.oid, pool, oid);
ObjectCacheInfo info;
info.xattrs = attrs;
info.status = 0;
}
info.meta.mtime = result_mtime;
info.meta.size = size;
- string name = normal_name(bucket, oid);
+ string name = normal_name(pool, oid);
if (ret >= 0) {
cache.put(name, info, NULL);
int r = distribute_cache(name, obj, info, UPDATE_OBJ);
}
template <class T>
-int RGWCache<T>::put_system_obj_data(void *ctx, rgw_obj& obj, bufferlist& data, off_t ofs, bool exclusive)
+int RGWCache<T>::put_system_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& data, off_t ofs, bool exclusive)
{
- rgw_bucket bucket;
+ rgw_pool pool;
string oid;
- normalize_bucket_and_obj(obj.bucket, obj.get_object(), bucket, oid);
+ normalize_pool_and_obj(obj.pool, obj.oid, pool, oid);
ObjectCacheInfo info;
bool cacheable = false;
if ((ofs == 0) || (ofs == -1)) {
}
int ret = T::put_system_obj_data(ctx, obj, data, ofs, exclusive);
if (cacheable) {
- string name = normal_name(bucket, oid);
+ string name = normal_name(pool, oid);
if (ret >= 0) {
cache.put(name, info, NULL);
int r = distribute_cache(name, obj, info, UPDATE_OBJ);
}
template <class T>
-int RGWCache<T>::raw_obj_stat(rgw_obj& obj, uint64_t *psize, real_time *pmtime,
+int RGWCache<T>::raw_obj_stat(rgw_raw_obj& obj, uint64_t *psize, real_time *pmtime,
uint64_t *pepoch, map<string, bufferlist> *attrs,
bufferlist *first_chunk, RGWObjVersionTracker *objv_tracker)
{
- rgw_bucket bucket;
+ rgw_pool pool;
string oid;
- normalize_bucket_and_obj(obj.bucket, obj.get_object(), bucket, oid);
+ normalize_pool_and_obj(obj.pool, obj.oid, pool, oid);
- string name = normal_name(bucket, oid);
+ string name = normal_name(pool, oid);
uint64_t size;
real_time mtime;
}
template <class T>
-int RGWCache<T>::distribute_cache(const string& normal_name, rgw_obj& obj, ObjectCacheInfo& obj_info, int op)
+int RGWCache<T>::distribute_cache(const string& normal_name, rgw_raw_obj& obj, ObjectCacheInfo& obj_info, int op)
{
RGWCacheNotifyInfo info;
return -EIO;
}
- rgw_bucket bucket;
+ rgw_pool pool;
string oid;
- normalize_bucket_and_obj(info.obj.bucket, info.obj.get_object(), bucket, oid);
- string name = normal_name(bucket, oid);
+ normalize_pool_and_obj(info.obj.pool, info.obj.oid, pool, oid);
+ string name = normal_name(pool, oid);
switch (info.op) {
case UPDATE_OBJ:
int RGWSystemMetaObj::read_default(RGWDefaultSystemMetaObjInfo& default_info, const string& oid)
{
- string pool_name = get_pool_name(cct);
-
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
bufferlist bl;
RGWObjectCtx obj_ctx(store);
int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
int RGWSystemMetaObj::set_as_default(bool exclusive)
{
- string pool_name = get_pool_name(cct);
string oid = get_default_oid();
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
bufferlist bl;
RGWDefaultSystemMetaObjInfo default_info;
int RGWSystemMetaObj::read_id(const string& obj_name, string& object_id)
{
- string pool_name = get_pool_name(cct);
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
bufferlist bl;
string oid = get_names_oid_prefix() + obj_name;
int RGWSystemMetaObj::delete_obj(bool old_format)
{
- string pool_name = get_pool_name(cct);
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
/* check to see if obj is the default */
RGWDefaultSystemMetaObjInfo default_info;
return ret;
if (default_info.default_id == id || (old_format && default_info.default_id == name)) {
string oid = get_default_oid(old_format);
- rgw_obj default_named_obj(pool, oid);
+ rgw_raw_obj default_named_obj(pool, oid);
ret = store->delete_system_obj(default_named_obj);
if (ret < 0) {
ldout(cct, 0) << "Error delete default obj name " << name << ": " << cpp_strerror(-ret) << dendl;
}
if (!old_format) {
string oid = get_names_oid_prefix() + name;
- rgw_obj object_name(pool, oid);
+ rgw_raw_obj object_name(pool, oid);
ret = store->delete_system_obj(object_name);
if (ret < 0) {
ldout(cct, 0) << "Error delete obj name " << name << ": " << cpp_strerror(-ret) << dendl;
oid += id;
}
- rgw_obj object_id(pool, oid);
+ rgw_raw_obj object_id(pool, oid);
ret = store->delete_system_obj(object_id);
if (ret < 0) {
ldout(cct, 0) << "Error delete object id " << id << ": " << cpp_strerror(-ret) << dendl;
int RGWSystemMetaObj::store_name(bool exclusive)
{
- string pool_name = get_pool_name(cct);
-
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
string oid = get_names_oid_prefix() + name;
RGWNameToId nameToId;
return ret;
}
/* delete old name */
- string pool_name = get_pool_name(cct);
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
string oid = get_names_oid_prefix() + old_name;
- rgw_obj old_name_obj(pool, oid);
+ rgw_raw_obj old_name_obj(pool, oid);
ret = store->delete_system_obj(old_name_obj);
if (ret < 0) {
ldout(cct, 0) << "Error delete old obj name " << old_name << ": " << cpp_strerror(-ret) << dendl;
int RGWSystemMetaObj::read_info(const string& obj_id, bool old_format)
{
- string pool_name = get_pool_name(cct);
+ rgw_pool pool(get_pool_name(cct));
- rgw_bucket pool(pool_name.c_str());
bufferlist bl;
string oid = get_info_oid_prefix(old_format) + obj_id;
int RGWSystemMetaObj::store_info(bool exclusive)
{
- string pool_name = get_pool_name(cct);
-
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
string oid = get_info_oid_prefix() + id;
int RGWRealm::create_control(bool exclusive)
{
- auto pool_name = get_pool_name(cct);
- auto pool = rgw_bucket{pool_name.c_str()};
+ auto pool = rgw_pool{get_pool_name(cct)};
auto oid = get_control_oid();
return rgw_put_system_obj(store, pool, oid, nullptr, 0, exclusive,
nullptr, real_time(), nullptr);
int RGWRealm::delete_control()
{
- auto pool_name = get_pool_name(cct);
- auto pool = rgw_bucket{pool_name.c_str()};
- auto obj = rgw_obj{pool, get_control_oid()};
+ auto pool = rgw_pool{get_pool_name(cct)};
+ auto obj = rgw_raw_obj{pool, get_control_oid()};
return store->delete_system_obj(obj);
}
int RGWPeriod::read_latest_epoch(RGWPeriodLatestEpochInfo& info)
{
- string pool_name = get_pool_name(cct);
string oid = get_period_oid_prefix() + get_latest_epoch_oid();
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
bufferlist bl;
RGWObjectCtx obj_ctx(store);
int ret = rgw_get_system_obj(store, obj_ctx, pool, oid, bl, NULL, NULL);
int RGWPeriod::set_latest_epoch(epoch_t epoch, bool exclusive)
{
- string pool_name = get_pool_name(cct);
string oid = get_period_oid_prefix() + get_latest_epoch_oid();
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
bufferlist bl;
RGWPeriodLatestEpochInfo info;
int RGWPeriod::delete_obj()
{
- rgw_bucket pool(get_pool_name(cct));
+ rgw_pool pool(get_pool_name(cct));
// delete the object for each period epoch
for (epoch_t e = 1; e <= epoch; e++) {
RGWPeriod p{get_id(), e};
- rgw_obj oid{pool, p.get_period_oid()};
+ rgw_raw_obj oid{pool, p.get_period_oid()};
int ret = store->delete_system_obj(oid);
if (ret < 0) {
ldout(cct, 0) << "WARNING: failed to delete period object " << oid
}
// delete the .latest_epoch object
- rgw_obj oid{pool, get_period_oid_prefix() + get_latest_epoch_oid()};
+ rgw_raw_obj oid{pool, get_period_oid_prefix() + get_latest_epoch_oid()};
int ret = store->delete_system_obj(oid);
if (ret < 0) {
ldout(cct, 0) << "WARNING: failed to delete period object " << oid
int RGWPeriod::read_info()
{
- string pool_name = get_pool_name(cct);
+ rgw_pool pool(get_pool_name(cct));
- rgw_bucket pool(pool_name.c_str());
bufferlist bl;
RGWObjectCtx obj_ctx(store);
ldout(cct, 0) << "ERROR: RGWPeriod::get_latest_epoch() returned " << cpp_strerror(-ret) << dendl;
return ret;
}
- string pool_name = get_pool_name(cct);
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(get_pool_name(cct));
string oid = get_period_oid();
bufferlist bl;
int RGWZoneParams::create(bool exclusive)
{
/* check for old pools config */
- rgw_obj obj(domain_root, avail_pools);
+ rgw_raw_obj obj(domain_root, avail_pools);
int r = store->raw_obj_stat(obj, NULL, NULL, NULL, NULL, NULL, NULL);
if (r < 0) {
ldout(store->ctx(), 10) << "couldn't find old data placement pools config, setting up new ones for the zone" << dendl;
RGWObjState *result;
map<rgw_obj, RGWObjState>::iterator iter;
lock.get_read();
- if (!obj.get_object().empty()) {
- iter = objs_state.find(obj);
- if (iter != objs_state.end()) {
- result = &iter->second;
- lock.unlock();
- } else {
- lock.unlock();
- lock.get_write();
- result = &objs_state[obj];
- lock.unlock();
- }
- return result;
+ assert (!obj.get_object().empty());
+ iter = objs_state.find(obj);
+ if (iter != objs_state.end()) {
+ result = &iter->second;
+ lock.unlock();
} else {
- rgw_obj new_obj(store->get_zone_params().domain_root, obj.bucket.name);
- iter = objs_state.find(new_obj);
- if (iter != objs_state.end()) {
- result = &iter->second;
- lock.unlock();
- } else {
- lock.unlock();
- lock.get_write();
- result = &objs_state[new_obj];
- lock.unlock();
- }
- return result;
+ lock.unlock();
+ lock.get_write();
+ result = &objs_state[obj];
+ lock.unlock();
}
+ return result;
}
void RGWObjectCtx::invalidate(rgw_obj& obj)
void RGWObjectCtx::set_atomic(rgw_obj& obj) {
RWLock::WLocker wl(lock);
- if (!obj.get_object().empty()) {
- objs_state[obj].is_atomic = true;
- } else {
- rgw_obj new_obj(store->get_zone_params().domain_root, obj.bucket.name);
- objs_state[new_obj].is_atomic = true;
- }
+ assert (!obj.get_object().empty());
+ objs_state[obj].is_atomic = true;
}
void RGWObjectCtx::set_prefetch_data(rgw_obj& obj) {
RWLock::WLocker wl(lock);
- if (!obj.get_object().empty()) {
- objs_state[obj].prefetch_data = true;
- } else {
- rgw_obj new_obj(store->get_zone_params().domain_root, obj.bucket.name);
- objs_state[new_obj].prefetch_data = true;
- }
+ assert (!obj.get_object().empty());
+ objs_state[obj].prefetch_data = true;
}
class RGWMetaNotifierManager : public RGWCoroutinesManager {
int RGWRados::get_required_alignment(rgw_bucket& bucket, uint64_t *alignment)
{
IoCtx ioctx;
- int r = open_bucket_data_ctx(bucket, ioctx);
+ int r = open_pool_ctx(bucket.placement.data_pool, ioctx);
if (r < 0) {
- ldout(cct, 0) << "ERROR: open_bucket_data_ctx() returned " << r << dendl;
+ ldout(cct, 0) << "ERROR: open_pool_ctx() returned " << r << dendl;
return r;
}
}
string oid = region_map_oid;
- rgw_bucket pool(pool_name.c_str());
+ rgw_pool pool(pool_name);
bufferlist bl;
RGWObjectCtx obj_ctx(this);
int ret = rgw_get_system_obj(this, obj_ctx, pool, oid, bl, NULL, NULL);
current_period.set_bucket_quota(zonegroupmap.bucket_quota);
// remove the region_map so we don't try to convert again
- rgw_obj obj(pool, oid);
+ rgw_raw_obj obj(pool, oid);
ret = delete_system_obj(obj);
if (ret < 0) {
ldout(cct, 0) << "Error could not remove " << obj
finisher->queue(c);
}
-int RGWRados::list_raw_prefixed_objs(const string& pool_name, const string& prefix, list<string>& result)
+int RGWRados::list_raw_prefixed_objs(const rgw_pool& pool, const string& prefix, list<string>& result)
{
- rgw_bucket pool(pool_name.c_str());
bool is_truncated;
RGWListRawObjsCtx ctx;
do {
int RGWRados::list_zones(list<string>& zones)
{
RGWZoneParams zoneparams;
- string pool_name = zoneparams.get_pool_name(cct);
+ rgw_pool pool(zoneparams.get_pool_name(cct));
- return list_raw_prefixed_objs(pool_name, zone_names_oid_prefix, zones);
+ return list_raw_prefixed_objs(pool, zone_names_oid_prefix, zones);
}
int RGWRados::list_realms(list<string>& realms)
{
RGWRealm realm(cct, this);
- string pool_name = realm.get_pool_name(cct);
- return list_raw_prefixed_objs(pool_name, realm_names_oid_prefix, realms);
+ rgw_pool pool(realm.get_pool_name(cct));
+ return list_raw_prefixed_objs(pool, realm_names_oid_prefix, realms);
}
int RGWRados::list_periods(list<string>& periods)
{
RGWPeriod period;
list<string> raw_periods;
- int ret = list_raw_prefixed_objs(period.get_pool_name(cct), period.get_info_oid_prefix(), raw_periods);
+ rgw_pool pool(period.get_pool_name(cct));
+ int ret = list_raw_prefixed_objs(pool, period.get_info_oid_prefix(), raw_periods);
if (ret < 0) {
return ret;
}
notify_oid.append(buf);
}
-int RGWRados::open_pool_ctx(const string& pool, librados::IoCtx& io_ctx)
+int RGWRados::open_pool_ctx(const rgw_pool& pool, librados::IoCtx& io_ctx)
{
librados::Rados *rad = get_rados_handle();
- int r = rad->ioctx_create(pool.c_str(), io_ctx);
+ int r = rad->ioctx_create(pool.name.c_str(), io_ctx);
if (r != -ENOENT)
return r;
if (!pools_initialized)
return r;
- r = rad->pool_create(pool.c_str());
+ r = rad->pool_create(pool.name.c_str());
if (r < 0 && r != -EEXIST)
return r;
- return rad->ioctx_create(pool.c_str(), io_ctx);
-}
-
-int RGWRados::open_bucket_data_ctx(rgw_bucket& bucket, librados::IoCtx& data_ctx)
-{
- int r = open_pool_ctx(bucket.data_pool, data_ctx);
- if (r < 0)
- return r;
-
- return 0;
-}
-
-int RGWRados::open_bucket_data_extra_ctx(rgw_bucket& bucket, librados::IoCtx& data_ctx)
-{
- string& pool = (!bucket.data_extra_pool.empty() ? bucket.data_extra_pool : bucket.data_pool);
- int r = open_pool_ctx(pool, data_ctx);
- if (r < 0)
- return r;
-
- return 0;
+ return rad->ioctx_create(pool.name.c_str(), io_ctx);
}
void RGWRados::build_bucket_index_marker(const string& shard_id_str, const string& shard_marker,
int RGWRados::open_bucket_index_ctx(rgw_bucket& bucket, librados::IoCtx& index_ctx)
{
- int r = open_pool_ctx(bucket.index_pool, index_ctx);
+ int r = open_pool_ctx(bucket.placement.index_pool, index_ctx);
if (r < 0)
return r;
librados::Rados *rad = get_rados_handle();
int r = rad->ioctx_create(log_pool, io_ctx);
if (r == -ENOENT) {
- rgw_bucket pool(log_pool);
+ rgw_pool pool(log_pool);
r = create_pool(pool);
if (r < 0)
return r;
return 0;
}
-int RGWRados::lock_exclusive(rgw_bucket& pool, const string& oid, timespan& duration,
+int RGWRados::lock_exclusive(rgw_pool& pool, const string& oid, timespan& duration,
string& zone_id, string& owner_id) {
librados::IoCtx io_ctx;
return l.lock_exclusive(&io_ctx, oid);
}
-int RGWRados::unlock(rgw_bucket& pool, const string& oid, string& zone_id, string& owner_id) {
+int RGWRados::unlock(rgw_pool& pool, const string& oid, string& zone_id, string& owner_id) {
librados::IoCtx io_ctx;
const char *pool_name = pool.name.c_str();
* create a rados pool, associated meta info
* returns 0 on success, -ERR# otherwise.
*/
-int RGWRados::create_pool(rgw_bucket& bucket)
+int RGWRados::create_pool(rgw_pool& pool)
{
int ret = 0;
- string pool = bucket.index_pool;
-
librados::Rados *rad = get_rados_handle();
- ret = rad->pool_create(pool.c_str(), 0);
+ ret = rad->pool_create(pool.name.c_str(), 0);
if (ret == -EEXIST)
ret = 0;
if (ret < 0)
return ret;
- if (bucket.data_pool != pool) {
- ret = rad->pool_create(bucket.data_pool.c_str(), 0);
- if (ret == -EEXIST)
- ret = 0;
- if (ret < 0)
- return ret;
- }
-
return 0;
}
RGWZonePlacementInfo& placement_info = piter->second;
- bucket.data_pool = placement_info.data_pool;
- bucket.data_extra_pool = placement_info.data_extra_pool;
- bucket.index_pool = placement_info.index_pool;
+ bucket.placement.data_pool = placement_info.data_pool;
+ bucket.placement.data_extra_pool = placement_info.data_extra_pool;
+ bucket.placement.index_pool = placement_info.index_pool;
if (rule_info) {
*rule_info = placement_info;
string pool_name;
bool write_map = false;
- rgw_obj obj(get_zone_params().domain_root, avail_pools);
+ rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
RGWObjectCtx obj_ctx(this);
int ret = rgw_get_system_obj(this, obj_ctx, get_zone_params().domain_root, avail_pools, map_bl, NULL, NULL);
miter = m.begin();
pool_name = miter->first;
}
- bucket.data_pool = pool_name;
- bucket.index_pool = pool_name;
+ bucket.placement.data_pool = pool_name;
+ bucket.placement.index_pool = pool_name;
rule_info->data_pool = pool_name;
rule_info->data_extra_pool = pool_name;
{
bufferlist header;
map<string, bufferlist> m;
- rgw_obj obj(get_zone_params().domain_root, avail_pools);
+ rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
int ret = omap_get_all(obj, header, m);
if (ret < 0)
return ret;
if (ret < 0) // DNE, or something
return ret;
- rgw_obj obj(get_zone_params().domain_root, avail_pools);
+ rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
bufferlist empty_bl;
ret = omap_set(obj, new_pool, empty_bl);
int RGWRados::remove_bucket_placement(std::string& old_pool)
{
- rgw_obj obj(get_zone_params().domain_root, avail_pools);
+ rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
int ret = omap_del(obj, old_pool);
// don't care about return value
bufferlist header;
map<string, bufferlist> m;
- rgw_obj obj(get_zone_params().domain_root, avail_pools);
+ rgw_raw_obj obj(get_zone_params().domain_root, avail_pools);
int ret = omap_get_all(obj, header, m);
if (ret < 0)
return ret;
int RGWRados::get_obj_ioctx(const rgw_obj& obj, librados::IoCtx *ioctx)
{
- rgw_bucket bucket;
+ const rgw_bucket& bucket = obj.bucket;
string oid, key;
- get_obj_bucket_and_oid_loc(obj, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(obj, oid, key);
int r;
if (!obj.is_in_extra_data()) {
- r = open_bucket_data_ctx(bucket, *ioctx);
+ r = open_pool_ctx(bucket.placement.data_pool, *ioctx);
} else {
- r = open_bucket_data_extra_ctx(bucket, *ioctx);
+ r = open_pool_ctx(bucket.placement.get_data_extra_pool(), *ioctx);
}
if (r < 0)
return r;
return 0;
}
-int RGWRados::get_obj_ref(const rgw_obj& obj, rgw_rados_ref *ref, rgw_bucket *bucket)
+int RGWRados::get_raw_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref, rgw_pool *pool)
{
- get_obj_bucket_and_oid_loc(obj, *bucket, ref->oid, ref->key);
+ *pool = obj.pool;
+ ref->oid = obj.oid;
+ ref->key.clear();
int r;
- if (!obj.is_in_extra_data()) {
- r = open_bucket_data_ctx(*bucket, ref->ioctx);
- } else {
- r = open_bucket_data_extra_ctx(*bucket, ref->ioctx);
+ if (ref->oid.empty()) {
+ ref->oid = pool->name;
+ *pool = get_zone_params().domain_root;
}
+ r = open_pool_ctx(pool->name, ref->ioctx);
if (r < 0)
return r;
- ref->ioctx.locator_set_key(ref->key);
-
return 0;
}
-int RGWRados::get_system_obj_ref(const rgw_obj& obj, rgw_rados_ref *ref, rgw_bucket *bucket)
+int RGWRados::get_system_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref, rgw_pool *pool)
{
- get_obj_bucket_and_oid_loc(obj, *bucket, ref->oid, ref->key);
-
- int r;
-
- if (ref->oid.empty()) {
- ref->oid = bucket->name;
- *bucket = get_zone_params().domain_root;
- }
- r = open_pool_ctx(bucket->name, ref->ioctx);
- if (r < 0)
- return r;
-
- ref->ioctx.locator_set_key(ref->key);
-
- return 0;
+ return get_raw_obj_ref(obj, ref, pool);
}
/*
rgw_obj obj(bucket, key);
- get_obj_bucket_and_oid_loc(obj, bucket, oid, locator);
+ get_obj_bucket_and_oid_loc(obj, oid, locator);
if (locator.empty()) {
ldout(cct, 20) << "object does not have a locator, nothing to fix" << dendl;
}
rgw_rados_ref ref;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
continue;
}
- get_obj_bucket_and_oid_loc(loc, bucket, oid, locator);
+ get_obj_bucket_and_oid_loc(loc, oid, locator);
ref.ioctx.locator_set_key(locator);
ldout(cct, 20) << __func__ << ": key=" << key << " oid=" << oid << " locator=" << locator << dendl;
void *_index_op)
{
RGWRados::Bucket::UpdateIndex *index_op = static_cast<RGWRados::Bucket::UpdateIndex *>(_index_op);
- rgw_bucket bucket;
+ rgw_pool pool;
rgw_rados_ref ref;
RGWRados *store = target->get_store();
return -EIO;
}
- r = store->get_obj_ref(obj, &ref, &bucket);
+ r = store->get_obj_ref(obj, &ref, &pool);
if (r < 0)
return r;
obj.get_index_key(&obj_key);
r = store->objexp_hint_add(meta.delete_at,
- bucket.tenant, bucket.name, bucket.bucket_id, obj_key);
+ obj.bucket.tenant, obj.bucket.name, obj.bucket.bucket_id, obj_key);
if (r < 0) {
ldout(store->ctx(), 0) << "ERROR: objexp_hint_add() returned r=" << r << ", object will not get removed" << dendl;
/* ignoring error, nothing we can do at this point */
meta.canceled = false;
/* update quota cache */
- store->quota_handler->update_stats(meta.owner, bucket, (orig_exists ? 0 : 1),
+ store->quota_handler->update_stats(meta.owner, obj.bucket, (orig_exists ? 0 : 1),
accounted_size, orig_size);
return 0;
}
/** Write/overwrite a system object. */
-int RGWRados::put_system_obj_impl(rgw_obj& obj, uint64_t size, real_time *mtime,
+int RGWRados::put_system_obj_impl(rgw_raw_obj& obj, uint64_t size, real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
real_time set_mtime /* 0 for don't set */)
{
- rgw_bucket bucket;
+ rgw_pool pool;
rgw_rados_ref ref;
- int r = get_system_obj_ref(obj, &ref, &bucket);
+ int r = get_system_obj_ref(obj, &ref, &pool);
if (r < 0)
return r;
return 0;
}
-int RGWRados::put_system_obj_data(void *ctx, rgw_obj& obj, bufferlist& bl,
+int RGWRados::put_system_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& bl,
off_t ofs, bool exclusive)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_system_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_system_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
void **handle)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return ret;
}
- bool copy_data = !astate->has_manifest || (src_obj.bucket.data_pool != dest_obj.bucket.data_pool);
+ bool copy_data = !astate->has_manifest || (src_obj.bucket.placement.data_pool != dest_obj.bucket.placement.data_pool);
bool copy_first = false;
if (astate->has_manifest) {
if (!astate->manifest.has_tail()) {
}
rgw_rados_ref ref;
- rgw_bucket bucket;
- ret = get_obj_ref(miter.get_location(), &ref, &bucket);
+ rgw_pool pool;
+ ret = get_obj_ref(miter.get_location(), &ref, &pool);
if (ret < 0) {
return ret;
}
ObjectWriteOperation op;
cls_refcount_get(op, tag, true);
const rgw_obj& loc = miter.get_location();
- get_obj_bucket_and_oid_loc(loc, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(loc, oid, key);
ref.ioctx.locator_set_key(key);
ret = ref.ioctx.operate(oid, &op);
ObjectWriteOperation op;
cls_refcount_put(op, tag, true);
- get_obj_bucket_and_oid_loc(*riter, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(*riter, oid, key);
ref.ioctx.locator_set_key(key);
int r = ref.ioctx.operate(oid, &op);
if (mobj == head_obj)
continue;
string oid, loc;
- rgw_bucket bucket;
- get_obj_bucket_and_oid_loc(mobj, bucket, oid, loc);
+ get_obj_bucket_and_oid_loc(mobj, oid, loc);
cls_rgw_obj_key key(oid);
- chain->push_obj(bucket.data_pool, key, loc);
+ chain->push_obj(mobj.bucket.placement.data_pool, key, loc);
}
}
int RGWRados::defer_gc(void *ctx, rgw_obj& obj)
{
RGWObjectCtx *rctx = static_cast<RGWObjectCtx *>(ctx);
- rgw_bucket bucket;
std::string oid, key;
- get_obj_bucket_and_oid_loc(obj, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(obj, oid, key);
if (!rctx)
return 0;
}
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = store->get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = store->get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return r;
/* update quota cache */
- store->quota_handler->update_stats(params.bucket_owner, bucket, -1, 0, obj_size);
+ store->quota_handler->update_stats(params.bucket_owner, obj.bucket, -1, 0, obj_size);
return 0;
}
return del_op.delete_obj();
}
-int RGWRados::delete_system_obj(rgw_obj& obj, RGWObjVersionTracker *objv_tracker)
+int RGWRados::delete_system_obj(rgw_raw_obj& obj, RGWObjVersionTracker *objv_tracker)
{
if (obj.get_object().empty()) {
ldout(cct, 1) << "delete_system_obj got empty object name "
return -EINVAL;
}
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
int RGWRados::delete_obj_index(rgw_obj& obj)
{
- rgw_bucket bucket;
std::string oid, key;
- get_obj_bucket_and_oid_loc(obj, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(obj, oid, key);
RGWObjectCtx obj_ctx(this);
RGWBucketInfo bucket_info;
- int ret = get_bucket_instance_info(obj_ctx, bucket, bucket_info, NULL, NULL);
+ int ret = get_bucket_instance_info(obj_ctx, obj.bucket, bucket_info, NULL, NULL);
if (ret < 0) {
- ldout(cct, 0) << "ERROR: " << __func__ << "() get_bucket_instance_info(bucket=" << bucket << ") returned ret=" << ret << dendl;
+ ldout(cct, 0) << "ERROR: " << __func__ << "() get_bucket_instance_info(bucket=" << obj.bucket << ") returned ret=" << ret << dendl;
return ret;
}
return 0;
}
-int RGWRados::get_system_obj_state_impl(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker)
+int RGWRados::get_system_obj_state_impl(RGWObjectCtx *rctx, rgw_raw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker)
{
RGWObjState *s = rctx->get_state(obj);
ldout(cct, 20) << "get_system_obj_state: rctx=" << (void *)rctx << " obj=" << obj << " state=" << (void *)s << " s->prefetch_data=" << s->prefetch_data << dendl;
return 0;
}
-int RGWRados::get_system_obj_state(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker)
+int RGWRados::get_system_obj_state(RGWObjectCtx *rctx, rgw_raw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker)
{
int ret;
string oid;
string loc;
- rgw_bucket bucket;
- get_obj_bucket_and_oid_loc(obj, bucket, oid, loc);
+ get_obj_bucket_and_oid_loc(obj, oid, loc);
int r = store->get_obj_ioctx(obj, &state.io_ctx);
if (r < 0) {
* dest: bufferlist to store the result in
* Returns: 0 on success, -ERR# otherwise.
*/
-int RGWRados::system_obj_get_attr(rgw_obj& obj, const char *name, bufferlist& dest)
+int RGWRados::system_obj_get_attr(rgw_raw_obj& obj, const char *name, bufferlist& dest)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_system_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_system_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return 0;
}
-int RGWRados::system_obj_set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl,
+int RGWRados::system_obj_set_attr(void *ctx, rgw_raw_obj& obj, const char *name, bufferlist& bl,
RGWObjVersionTracker *objv_tracker)
{
map<string, bufferlist> attrs;
return system_obj_set_attrs(ctx, obj, attrs, NULL, objv_tracker);
}
-int RGWRados::system_obj_set_attrs(void *ctx, rgw_obj& obj,
+int RGWRados::system_obj_set_attrs(void *ctx, rgw_raw_obj& obj,
map<string, bufferlist>& attrs,
map<string, bufferlist>* rmattrs,
RGWObjVersionTracker *objv_tracker)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_system_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_system_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
map<string, bufferlist>* rmattrs)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
}
}
+ const rgw_bucket& bucket = obj.bucket;
+
for (iter = attrs.begin(); iter != attrs.end(); ++iter) {
const string& name = iter->first;
bufferlist& bl = iter->second;
int RGWRados::stat_system_obj(RGWObjectCtx& obj_ctx,
RGWRados::SystemObject::Read::GetObjState& state,
- rgw_obj& obj,
+ rgw_raw_obj& obj,
map<string, bufferlist> *attrs,
real_time *lastmod,
uint64_t *obj_size,
int RGWRados::SystemObject::Read::stat(RGWObjVersionTracker *objv_tracker)
{
RGWRados *store = source->get_store();
- rgw_obj& obj = source->get_obj();
+ rgw_raw_obj& obj = source->get_obj();
return store->stat_system_obj(source->get_ctx(), state, obj, stat_params.attrs,
stat_params.lastmod, stat_params.obj_size, objv_tracker);
RGWRados *store = source->get_store();
CephContext *cct = store->ctx();
- rgw_bucket bucket;
std::string oid, key;
rgw_obj read_obj = state.obj;
uint64_t read_ofs = ofs;
uint64_t max_chunk_size;
- get_obj_bucket_and_oid_loc(state.obj, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(state.obj, oid, key);
RGWObjState *astate;
int r = source->get_state(&astate, true);
reading_from_head = (read_obj == state.obj);
if (!reading_from_head) {
- get_obj_bucket_and_oid_loc(read_obj, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(read_obj, oid, key);
}
}
- r = store->get_max_chunk_size(bucket, &max_chunk_size);
+ r = store->get_max_chunk_size(read_obj.bucket, &max_chunk_size);
if (r < 0) {
- ldout(cct, 0) << "ERROR: failed to get max_chunk_size() for bucket " << bucket << dendl;
+ ldout(cct, 0) << "ERROR: failed to get max_chunk_size() for bucket " << read_obj.bucket << dendl;
return r;
}
return bl.length();
}
-int RGWRados::SystemObject::Read::GetObjState::get_ioctx(RGWRados *store, rgw_obj& obj, librados::IoCtx **ioctx)
+int RGWRados::SystemObject::Read::GetObjState::get_ref(RGWRados *store, rgw_raw_obj& obj, rgw_rados_ref **pref)
{
- if (!has_ioctx) {
- int r = store->get_obj_ioctx(obj, &io_ctx);
+ if (!has_ref) {
+ rgw_pool pool;
+ int r = store->get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
- has_ioctx = true;
+ has_ref = true;
}
- *ioctx = &io_ctx;
+ *pref = &ref;
return 0;
}
int RGWRados::get_system_obj(RGWObjectCtx& obj_ctx, RGWRados::SystemObject::Read::GetObjState& read_state,
- RGWObjVersionTracker *objv_tracker, rgw_obj& obj,
+ RGWObjVersionTracker *objv_tracker, rgw_raw_obj& obj,
bufferlist& bl, off_t ofs, off_t end,
map<string, bufferlist> *attrs,
rgw_cache_entry_info *cache_info)
{
- rgw_bucket bucket;
- std::string oid, key;
uint64_t len;
ObjectReadOperation op;
- get_obj_bucket_and_oid_loc(obj, bucket, oid, key);
-
if (end < 0)
len = 0;
else
op.getxattrs(attrs, NULL);
}
- librados::IoCtx *io_ctx;
- int r = read_state.get_ioctx(this, obj, &io_ctx);
+ rgw_rados_ref *ref;
+ int r = read_state.get_ref(this, obj, &ref);
if (r < 0) {
- ldout(cct, 20) << "get_ioctx() on obj=" << obj << " returned " << r << dendl;
+ ldout(cct, 20) << "read_state.get_ref() on obj=" << obj << " returned " << r << dendl;
return r;
}
- r = io_ctx->operate(oid, &op, NULL);
+ r = ref->ioctx.operate(ref->oid, &op, NULL);
if (r < 0) {
ldout(cct, 20) << "rados->read r=" << r << " bl.length=" << bl.length() << dendl;
return r;
}
ldout(cct, 20) << "rados->read r=" << r << " bl.length=" << bl.length() << dendl;
- uint64_t op_ver = io_ctx->get_last_version();
+ uint64_t op_ver = ref->ioctx.get_last_version();
if (read_state.last_ver > 0 &&
read_state.last_ver != op_ver) {
int RGWRados::SystemObject::Read::read(int64_t ofs, int64_t end, bufferlist& bl, RGWObjVersionTracker *objv_tracker)
{
RGWRados *store = source->get_store();
- rgw_obj& obj = source->get_obj();
+ rgw_raw_obj& obj = source->get_obj();
return store->get_system_obj(source->get_ctx(), state, objv_tracker, obj, bl, ofs, end, read_params.attrs, read_params.cache_info);
}
int RGWRados::SystemObject::Read::get_attr(const char *name, bufferlist& dest)
{
RGWRados *store = source->get_store();
- rgw_obj& obj = source->get_obj();
+ rgw_raw_obj& obj = source->get_obj();
return store->system_obj_get_attr(obj, name, dest);
}
ObjectReadOperation op;
struct get_obj_data *d = (struct get_obj_data *)arg;
string oid, key;
- rgw_bucket bucket;
bufferlist *pbl;
AioCompletion *c;
}
}
- get_obj_bucket_and_oid_loc(obj, bucket, oid, key);
+ get_obj_bucket_and_oid_loc(obj, oid, key);
d->throttle.get(len);
if (d->is_cancelled()) {
int (*iterate_obj_cb)(rgw_obj&, off_t, off_t, off_t, bool, RGWObjState *, void *),
void *arg)
{
- rgw_bucket bucket;
rgw_obj read_obj = obj;
uint64_t read_ofs = ofs;
uint64_t len;
int RGWRados::obj_operate(rgw_obj& obj, ObjectWriteOperation *op)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
int RGWRados::obj_operate(rgw_obj& obj, ObjectReadOperation *op)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
real_time unmod_since, bool high_precision_time)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj_instance, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj_instance, &ref, &pool);
if (r < 0) {
return r;
}
BucketShard bs(this);
- int ret = bs.init(bucket, obj_instance);
+ int ret = bs.init(obj_instance.bucket, obj_instance);
if (ret < 0) {
ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
return ret;
int RGWRados::bucket_index_unlink_instance(rgw_obj& obj_instance, const string& op_tag, const string& olh_tag, uint64_t olh_epoch)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj_instance, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj_instance, &ref, &pool);
if (r < 0) {
return r;
}
BucketShard bs(this);
- int ret = bs.init(bucket, obj_instance);
+ int ret = bs.init(obj_instance.bucket, obj_instance);
if (ret < 0) {
ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
return ret;
bool *is_truncated)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj_instance, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj_instance, &ref, &pool);
if (r < 0) {
return r;
}
BucketShard bs(this);
- int ret = bs.init(bucket, obj_instance);
+ int ret = bs.init(obj_instance.bucket, obj_instance);
if (ret < 0) {
ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
return ret;
int RGWRados::bucket_index_trim_olh_log(RGWObjState& state, rgw_obj& obj_instance, uint64_t ver)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj_instance, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj_instance, &ref, &pool);
if (r < 0) {
return r;
}
BucketShard bs(this);
- int ret = bs.init(bucket, obj_instance);
+ int ret = bs.init(obj_instance.bucket, obj_instance);
if (ret < 0) {
ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
return ret;
int RGWRados::bucket_index_clear_olh(RGWObjState& state, rgw_obj& obj_instance)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj_instance, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj_instance, &ref, &pool);
if (r < 0) {
return r;
}
BucketShard bs(this);
- int ret = bs.init(bucket, obj_instance);
+ int ret = bs.init(obj_instance.bucket, obj_instance);
if (ret < 0) {
ldout(cct, 5) << "bs.init() returned ret=" << ret << dendl;
return ret;
}
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
+ const rgw_bucket& bucket = obj.bucket;
+
if (need_to_link) {
rgw_obj target(bucket, key);
RGWOLHInfo info;
}
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(olh_obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_obj_ref(olh_obj, &ref, &pool);
if (r < 0) {
return r;
}
return 0;
}
-int RGWRados::raw_obj_stat(rgw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch,
+int RGWRados::raw_obj_stat(rgw_raw_obj& obj, uint64_t *psize, real_time *pmtime, uint64_t *epoch,
map<string, bufferlist> *attrs, bufferlist *first_chunk,
RGWObjVersionTracker *objv_tracker)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
oid = RGW_BUCKET_INSTANCE_MD_PREFIX + bucket.get_key(':');
}
-void RGWRados::get_bucket_instance_obj(const rgw_bucket& bucket, rgw_obj& obj)
+void RGWRados::get_bucket_instance_obj(const rgw_bucket& bucket, rgw_raw_obj& obj)
{
if (!bucket.oid.empty()) {
obj.init(get_zone_params().domain_root, bucket.oid);
return get_bucket_instance_from_oid(obj_ctx, oid, info, pmtime, pattrs);
}
-int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, rgw_bucket& bucket, RGWBucketInfo& info,
+int RGWRados::get_bucket_instance_info(RGWObjectCtx& obj_ctx, const rgw_bucket& bucket, RGWBucketInfo& info,
real_time *pmtime, map<string, bufferlist> *pattrs)
{
string oid;
return 0;
}
-int RGWRados::omap_get_vals(rgw_obj& obj, bufferlist& header, const string& marker, uint64_t count, std::map<string, bufferlist>& m)
+int RGWRados::omap_get_vals(rgw_raw_obj& obj, bufferlist& header, const string& marker, uint64_t count, std::map<string, bufferlist>& m)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
}
-int RGWRados::omap_get_all(rgw_obj& obj, bufferlist& header,
+int RGWRados::omap_get_all(rgw_raw_obj& obj, bufferlist& header,
std::map<string, bufferlist>& m)
{
rgw_rados_ref ref;
return 0;
}
-int RGWRados::omap_set(rgw_obj& obj, std::string& key, bufferlist& bl)
+int RGWRados::omap_set(rgw_raw_obj& obj, std::string& key, bufferlist& bl)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
- ldout(cct, 15) << "omap_set bucket=" << bucket << " oid=" << ref.oid << " key=" << key << dendl;
+ ldout(cct, 15) << "omap_set pool=" << pool << " oid=" << ref.oid << " key=" << key << dendl;
map<string, bufferlist> m;
m[key] = bl;
return r;
}
-int RGWRados::omap_set(rgw_obj& obj, std::map<std::string, bufferlist>& m)
+int RGWRados::omap_set(rgw_raw_obj& obj, std::map<std::string, bufferlist>& m)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return r;
}
-int RGWRados::omap_del(rgw_obj& obj, const std::string& key)
+int RGWRados::omap_del(rgw_raw_obj& obj, const std::string& key)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return m.size();
}
-int RGWRados::append_async(rgw_obj& obj, size_t size, bufferlist& bl)
+int RGWRados::append_async(rgw_raw_obj& obj, size_t size, bufferlist& bl)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return control_pool_ctx.notify2(notify_oid, bl, 0, NULL);
}
-int RGWRados::pool_iterate_begin(rgw_bucket& bucket, RGWPoolIterCtx& ctx)
+int RGWRados::pool_iterate_begin(const rgw_pool& pool, RGWPoolIterCtx& ctx)
{
librados::IoCtx& io_ctx = ctx.io_ctx;
librados::NObjectIterator& iter = ctx.iter;
- int r = open_bucket_data_ctx(bucket, io_ctx);
+ int r = open_pool_ctx(pool, io_ctx);
if (r < 0)
return r;
}
};
-int RGWRados::list_raw_objects(rgw_bucket& pool, const string& prefix_filter,
+int RGWRados::list_raw_objects(const rgw_pool& pool, const string& prefix_filter,
int max, RGWListRawObjsCtx& ctx, list<string>& oids,
bool *is_truncated)
{
int RGWRados::bi_get_instance(rgw_obj& obj, rgw_bucket_dir_entry *dirent)
{
- rgw_bucket bucket;
+ rgw_pool pool;
rgw_rados_ref ref;
- int r = get_obj_ref(obj, &ref, &bucket);
+ int r = get_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
rgw_cls_bi_entry bi_entry;
- r = bi_get(bucket, obj, InstanceIdx, &bi_entry);
+ r = bi_get(obj.bucket, obj, InstanceIdx, &bi_entry);
if (r < 0 && r != -ENOENT) {
ldout(cct, 0) << "ERROR: bi_get() returned r=" << r << dendl;
}
int RGWRados::cls_obj_usage_log_add(const string& oid, rgw_usage_log_info& info)
{
- librados::IoCtx io_ctx;
+ rgw_raw_obj obj(get_zone_params().usage_log_pool, oid);
- const char *usage_log_pool = get_zone_params().usage_log_pool.name.c_str();
- librados::Rados *rad = get_rados_handle();
- int r = rad->ioctx_create(usage_log_pool, io_ctx);
- if (r == -ENOENT) {
- rgw_bucket pool(usage_log_pool);
- r = create_pool(pool);
- if (r < 0)
- return r;
-
- // retry
- r = rad->ioctx_create(usage_log_pool, io_ctx);
- }
- if (r < 0)
+ rgw_rados_ref ref;
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
+ if (r < 0) {
return r;
+ }
ObjectWriteOperation op;
cls_rgw_usage_log_add(op, info);
- r = io_ctx.operate(oid, &op);
+ r = ref.ioctx.operate(ref.oid, &op);
return r;
}
int RGWRados::cls_obj_usage_log_read(string& oid, string& user, uint64_t start_epoch, uint64_t end_epoch, uint32_t max_entries,
string& read_iter, map<rgw_user_bucket, rgw_usage_log_entry>& usage, bool *is_truncated)
{
- librados::IoCtx io_ctx;
+ rgw_raw_obj obj(get_zone_params().usage_log_pool, oid);
- *is_truncated = false;
-
- const char *usage_log_pool = get_zone_params().usage_log_pool.name.c_str();
- librados::Rados *rad = get_rados_handle();
- int r = rad->ioctx_create(usage_log_pool, io_ctx);
- if (r < 0)
+ rgw_rados_ref ref;
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
+ if (r < 0) {
return r;
+ }
- r = cls_rgw_usage_log_read(io_ctx, oid, user, start_epoch, end_epoch,
+ *is_truncated = false;
+
+ r = cls_rgw_usage_log_read(ref.ioctx, ref.oid, user, start_epoch, end_epoch,
max_entries, read_iter, usage, is_truncated);
return r;
int RGWRados::cls_obj_usage_log_trim(string& oid, string& user, uint64_t start_epoch, uint64_t end_epoch)
{
- librados::IoCtx io_ctx;
+ rgw_raw_obj obj(get_zone_params().usage_log_pool, oid);
- const char *usage_log_pool = get_zone_params().usage_log_pool.name.c_str();
- librados::Rados *rad = get_rados_handle();
- int r = rad->ioctx_create(usage_log_pool, io_ctx);
- if (r < 0)
+ rgw_rados_ref ref;
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
+ if (r < 0) {
return r;
+ }
ObjectWriteOperation op;
cls_rgw_usage_log_trim(op, user, start_epoch, end_epoch);
- r = io_ctx.operate(oid, &op);
+ r = ref.ioctx.operate(ref.oid, &op);
return r;
}
obj.set_loc(list_state.locator);
obj.set_ns(ns);
obj.set_instance(key.instance);
- get_obj_bucket_and_oid_loc(obj, bucket, oid, loc);
+ get_obj_bucket_and_oid_loc(obj, oid, loc);
io_ctx.locator_set_key(loc);
RGWObjState *astate = NULL;
{
string buckets_obj_id;
rgw_get_buckets_obj(user_id, buckets_obj_id);
- rgw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
+ rgw_raw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
{
string buckets_obj_id;
rgw_get_buckets_obj(user_id, buckets_obj_id);
- rgw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
+ rgw_raw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return 0;
}
-int RGWRados::cls_user_sync_bucket_stats(rgw_obj& user_obj, rgw_bucket& bucket)
+int RGWRados::cls_user_sync_bucket_stats(rgw_raw_obj& user_obj, rgw_bucket& bucket)
{
map<string, struct rgw_bucket_dir_header> headers;
int r = cls_bucket_head(bucket, RGW_NO_SHARD, headers);
string buckets_obj_id;
rgw_get_buckets_obj(user_id, buckets_obj_id);
- rgw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
+ rgw_raw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
int r = cls_user_update_buckets(obj, entries, false);
if (r < 0) {
return 0;
}
-int RGWRados::cls_user_list_buckets(rgw_obj& obj,
+int RGWRados::cls_user_list_buckets(rgw_raw_obj& obj,
const string& in_marker,
const string& end_marker,
const int max_entries,
bool * const truncated)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return 0;
}
-int RGWRados::cls_user_update_buckets(rgw_obj& obj, list<cls_user_bucket_entry>& entries, bool add)
+int RGWRados::cls_user_update_buckets(rgw_raw_obj& obj, list<cls_user_bucket_entry>& entries, bool add)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
{
string buckets_obj_id;
rgw_get_buckets_obj(user_id, buckets_obj_id);
- rgw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
+ rgw_raw_obj obj(get_zone_params().user_uid_pool, buckets_obj_id);
return cls_user_complete_stats_sync(obj);
}
-int RGWRados::cls_user_complete_stats_sync(rgw_obj& obj)
+int RGWRados::cls_user_complete_stats_sync(rgw_raw_obj& obj)
{
rgw_rados_ref ref;
- rgw_bucket bucket;
- int r = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int r = get_raw_obj_ref(obj, &ref, &pool);
if (r < 0) {
return r;
}
return 0;
}
-int RGWRados::cls_user_add_bucket(rgw_obj& obj, const cls_user_bucket_entry& entry)
+int RGWRados::cls_user_add_bucket(rgw_raw_obj& obj, const cls_user_bucket_entry& entry)
{
list<cls_user_bucket_entry> l;
l.push_back(entry);
return cls_user_update_buckets(obj, l, true);
}
-int RGWRados::cls_user_remove_bucket(rgw_obj& obj, const cls_user_bucket& bucket)
+int RGWRados::cls_user_remove_bucket(rgw_raw_obj& obj, const cls_user_bucket& bucket)
{
- rgw_bucket b;
+ rgw_pool p;
rgw_rados_ref ref;
- int r = get_obj_ref(obj, &ref, &b);
+ int r = get_system_obj_ref(obj, &ref, &p);
if (r < 0) {
return r;
}
list<librados::AioCompletion *>& handles, bool keep_index_consistent)
{
rgw_rados_ref ref;
- int ret = get_obj_ref(obj, &ref, &bucket);
+ rgw_pool pool;
+ int ret = get_obj_ref(obj, &ref, &pool);
if (ret < 0) {
lderr(cct) << "ERROR: failed to get obj ref with ret=" << ret << dendl;
return ret;
#define MAX_BUCKET_INDEX_SHARDS_PRIME 7877
-static inline void prepend_bucket_marker(rgw_bucket& bucket, const string& orig_oid, string& oid)
+static inline void prepend_bucket_marker(const rgw_bucket& bucket, const string& orig_oid, string& oid)
{
if (bucket.marker.empty() || orig_oid.empty()) {
oid = orig_oid;
}
}
-static inline void get_obj_bucket_and_oid_loc(const rgw_obj& obj, rgw_bucket& bucket, string& oid, string& locator)
+static inline void get_obj_bucket_and_oid_loc(const rgw_obj& obj, string& oid, string& locator)
{
- bucket = obj.bucket;
+ const rgw_bucket& bucket = obj.bucket;
prepend_bucket_marker(bucket, obj.get_object(), oid);
const string& loc = obj.get_loc();
if (!loc.empty()) {
WRITE_CLASS_ENCODER(RGWZonePlacementInfo)
struct RGWZoneParams : RGWSystemMetaObj {
- rgw_bucket domain_root;
- rgw_bucket metadata_heap;
- rgw_bucket control_pool;
- rgw_bucket gc_pool;
- rgw_bucket lc_pool;
- rgw_bucket log_pool;
- rgw_bucket intent_log_pool;
- rgw_bucket usage_log_pool;
-
- rgw_bucket user_keys_pool;
- rgw_bucket user_email_pool;
- rgw_bucket user_swift_pool;
- rgw_bucket user_uid_pool;
- rgw_bucket roles_pool;
+ rgw_pool domain_root;
+ rgw_pool metadata_heap;
+ rgw_pool control_pool;
+ rgw_pool gc_pool;
+ rgw_pool lc_pool;
+ rgw_pool log_pool;
+ rgw_pool intent_log_pool;
+ rgw_pool usage_log_pool;
+
+ rgw_pool user_keys_pool;
+ rgw_pool user_email_pool;
+ rgw_pool user_swift_pool;
+ rgw_pool user_uid_pool;
+ rgw_pool roles_pool;
RGWAccessKey system_key;
if (struct_v >= 7) {
::decode(lc_pool, bl);
} else {
- lc_pool = name + ".rgw.lc";
+ lc_pool.init(name + ".rgw.lc");
}
if (struct_v >= 8) {
::decode(tier_config, bl);
int open_lc_pool_ctx();
int open_objexp_pool_ctx();
- int open_pool_ctx(const string& pool, librados::IoCtx& io_ctx);
+ int open_pool_ctx(const rgw_pool& pool, librados::IoCtx& io_ctx);
int open_bucket_index_ctx(rgw_bucket& bucket, librados::IoCtx& index_ctx);
- int open_bucket_data_ctx(rgw_bucket& bucket, librados::IoCtx& io_ctx);
- int open_bucket_data_extra_ctx(rgw_bucket& bucket, librados::IoCtx& io_ctx);
int open_bucket_index(rgw_bucket& bucket, librados::IoCtx& index_ctx, string& bucket_oid);
int open_bucket_index_base(rgw_bucket& bucket, librados::IoCtx& index_ctx,
string& bucket_oid_base);
uint32_t bucket_index_max_shards;
int get_obj_ioctx(const rgw_obj& obj, librados::IoCtx *ioctx);
- int get_obj_ref(const rgw_obj& obj, rgw_rados_ref *ref, rgw_bucket *bucket);
- int get_system_obj_ref(const rgw_obj& obj, rgw_rados_ref *ref, rgw_bucket *bucket);
+ int get_obj_ref(const rgw_obj& obj, rgw_rados_ref *ref, rgw_pool *pool);
+ int get_raw_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref, rgw_pool *pool);
+ int get_system_obj_ref(const rgw_raw_obj& obj, rgw_rados_ref *ref, rgw_pool *pool);
uint64_t max_bucket_id;
int get_olh_target_state(RGWObjectCtx& rctx, rgw_obj& obj, RGWObjState *olh_state,
RGWObjState **target_state);
- int get_system_obj_state_impl(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker);
+ int get_system_obj_state_impl(RGWObjectCtx *rctx, rgw_raw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker);
int get_obj_state_impl(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState **state, bool follow_olh, bool assume_noent = false);
int append_atomic_test(RGWObjectCtx *rctx, rgw_obj& obj,
librados::ObjectOperation& op, RGWObjState **state);
return MAX_BUCKET_INDEX_SHARDS_PRIME;
}
- int list_raw_objects(rgw_bucket& pool, const string& prefix_filter, int max,
+ int list_raw_objects(const rgw_pool& pool, const string& prefix_filter, int max,
RGWListRawObjsCtx& ctx, list<string>& oids,
bool *is_truncated);
- int list_raw_prefixed_objs(const string& pool_name, const string& prefix, list<string>& result);
+ int list_raw_prefixed_objs(const rgw_pool& pool, const string& prefix, list<string>& result);
int list_zonegroups(list<string>& zonegroups);
int list_regions(list<string>& regions);
int list_zones(list<string>& zones);
bool *is_truncated, RGWUsageIter& read_iter, map<rgw_user_bucket, rgw_usage_log_entry>& usage);
int trim_usage(rgw_user& user, uint64_t start_epoch, uint64_t end_epoch);
- virtual int create_pool(rgw_bucket& bucket);
+ int create_pool(rgw_pool& bucket);
/**
* create a bucket with name bucket and the given list of attrs
class SystemObject {
RGWRados *store;
RGWObjectCtx& ctx;
- rgw_obj obj;
+ rgw_raw_obj obj;
RGWObjState *state;
int get_state(RGWObjState **pstate, RGWObjVersionTracker *objv_tracker);
public:
- SystemObject(RGWRados *_store, RGWObjectCtx& _ctx, rgw_obj& _obj) : store(_store), ctx(_ctx), obj(_obj), state(NULL) {}
+ SystemObject(RGWRados *_store, RGWObjectCtx& _ctx, rgw_raw_obj& _obj) : store(_store), ctx(_ctx), obj(_obj), state(NULL) {}
RGWRados *get_store() { return store; }
- rgw_obj& get_obj() { return obj; }
+ rgw_raw_obj& get_obj() { return obj; }
RGWObjectCtx& get_ctx() { return ctx; }
struct Read {
RGWRados::SystemObject *source;
struct GetObjState {
- librados::IoCtx io_ctx;
- bool has_ioctx;
- uint64_t last_ver;
+ rgw_rados_ref ref;
+ bool has_ref{false};
+ uint64_t last_ver{0};
- GetObjState() : has_ioctx(false), last_ver(0) {}
+ GetObjState() {}
- int get_ioctx(RGWRados *store, rgw_obj& obj, librados::IoCtx **ioctx);
+ int get_ref(RGWRados *store, rgw_raw_obj& obj, rgw_rados_ref **pref);
} state;
struct StatParams {
};
/** Write/overwrite an object to the bucket storage. */
- virtual int put_system_obj_impl(rgw_obj& obj, uint64_t size, ceph::real_time *mtime,
+ virtual int put_system_obj_impl(rgw_raw_obj& obj, uint64_t size, ceph::real_time *mtime,
map<std::string, bufferlist>& attrs, int flags,
bufferlist& data,
RGWObjVersionTracker *objv_tracker,
ceph::real_time set_mtime /* 0 for don't set */);
- virtual int put_system_obj_data(void *ctx, rgw_obj& obj, bufferlist& bl,
+ virtual int put_system_obj_data(void *ctx, rgw_raw_obj& obj, bufferlist& bl,
off_t ofs, bool exclusive);
virtual int put_obj_data(void *ctx, rgw_obj& obj, const char *data,
off_t ofs, size_t len, bool exclusive);
virtual int aio_put_obj_data(void *ctx, rgw_obj& obj, bufferlist& bl,
off_t ofs, bool exclusive, void **handle);
- int put_system_obj(void *ctx, rgw_obj& obj, const char *data, size_t len, bool exclusive,
+ int put_system_obj(void *ctx, rgw_raw_obj& obj, const char *data, size_t len, bool exclusive,
ceph::real_time *mtime, map<std::string, bufferlist>& attrs, RGWObjVersionTracker *objv_tracker,
ceph::real_time set_mtime) {
bufferlist bl;
const ceph::real_time& expiration_time = ceph::real_time());
/* Delete a system object */
- virtual int delete_system_obj(rgw_obj& src_obj, RGWObjVersionTracker *objv_tracker = NULL);
+ virtual int delete_system_obj(rgw_raw_obj& src_obj, RGWObjVersionTracker *objv_tracker = NULL);
/** Remove an object from the bucket index */
int delete_obj_index(rgw_obj& obj);
* dest: bufferlist to store the result in
* Returns: 0 on success, -ERR# otherwise.
*/
- virtual int system_obj_get_attr(rgw_obj& obj, const char *name, bufferlist& dest);
+ virtual int system_obj_get_attr(rgw_raw_obj& obj, const char *name, bufferlist& dest);
- int system_obj_set_attr(void *ctx, rgw_obj& obj, const char *name, bufferlist& bl,
+ int system_obj_set_attr(void *ctx, rgw_raw_obj& obj, const char *name, bufferlist& bl,
RGWObjVersionTracker *objv_tracker);
- virtual int system_obj_set_attrs(void *ctx, rgw_obj& obj,
+ virtual int system_obj_set_attrs(void *ctx, rgw_raw_obj& obj,
map<string, bufferlist>& attrs,
map<string, bufferlist>* rmattrs,
RGWObjVersionTracker *objv_tracker);
map<string, bufferlist>& attrs,
map<string, bufferlist>* rmattrs);
- int get_system_obj_state(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker);
+ int get_system_obj_state(RGWObjectCtx *rctx, rgw_raw_obj& obj, RGWObjState **state, RGWObjVersionTracker *objv_tracker);
int get_obj_state(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState **state, bool follow_olh, bool assume_noent = false);
int get_obj_state(RGWObjectCtx *rctx, rgw_obj& obj, RGWObjState **state) {
return get_obj_state(rctx, obj, state, true);
virtual int stat_system_obj(RGWObjectCtx& obj_ctx,
RGWRados::SystemObject::Read::GetObjState& state,
- rgw_obj& obj,
+ rgw_raw_obj& obj,
map<string, bufferlist> *attrs,
ceph::real_time *lastmod,
uint64_t *obj_size,
RGWObjVersionTracker *objv_tracker);
virtual int get_system_obj(RGWObjectCtx& obj_ctx, RGWRados::SystemObject::Read::GetObjState& read_state,
- RGWObjVersionTracker *objv_tracker, rgw_obj& obj,
+ RGWObjVersionTracker *objv_tracker, rgw_raw_obj& obj,
bufferlist& bl, off_t ofs, off_t end,
map<string, bufferlist> *attrs,
rgw_cache_entry_info *cache_info);
* a simple object read without keeping state
*/
- virtual int raw_obj_stat(rgw_obj& obj, uint64_t *psize, ceph::real_time *pmtime, uint64_t *epoch,
+ virtual int raw_obj_stat(rgw_raw_obj& obj, uint64_t *psize, ceph::real_time *pmtime, uint64_t *epoch,
map<string, bufferlist> *attrs, bufferlist *first_chunk,
RGWObjVersionTracker *objv_tracker);
void gen_rand_obj_instance_name(rgw_obj *target);
- int omap_get_vals(rgw_obj& obj, bufferlist& header, const std::string& marker, uint64_t count, std::map<string, bufferlist>& m);
- virtual int omap_get_all(rgw_obj& obj, bufferlist& header, std::map<string, bufferlist>& m);
- virtual int omap_set(rgw_obj& obj, std::string& key, bufferlist& bl);
- virtual int omap_set(rgw_obj& obj, map<std::string, bufferlist>& m);
- virtual int omap_del(rgw_obj& obj, const std::string& key);
+ int omap_get_vals(rgw_raw_obj& obj, bufferlist& header, const std::string& marker, uint64_t count, std::map<string, bufferlist>& m);
+ virtual int omap_get_all(rgw_raw_obj& obj, bufferlist& header, std::map<string, bufferlist>& m);
+ virtual int omap_set(rgw_raw_obj& obj, std::string& key, bufferlist& bl);
+ virtual int omap_set(rgw_raw_obj& obj, map<std::string, bufferlist>& m);
+ virtual int omap_del(rgw_raw_obj& obj, const std::string& key);
virtual int update_containers_stats(map<string, RGWBucketEnt>& m);
- virtual int append_async(rgw_obj& obj, size_t size, bufferlist& bl);
+ virtual int append_async(rgw_raw_obj& obj, size_t size, bufferlist& bl);
int watch(const string& oid, uint64_t *watch_handle, librados::WatchCtx2 *ctx);
int unwatch(uint64_t watch_handle);
int get_bucket_stats_async(rgw_bucket& bucket, int shard_id, RGWGetBucketStats_CB *cb);
int get_user_stats(const rgw_user& user, RGWStorageStats& stats);
int get_user_stats_async(const rgw_user& user, RGWGetUserStats_CB *cb);
- void get_bucket_instance_obj(const rgw_bucket& bucket, rgw_obj& obj);
+ void get_bucket_instance_obj(const rgw_bucket& bucket, rgw_raw_obj& obj);
void get_bucket_meta_oid(const rgw_bucket& bucket, string& oid);
int put_bucket_entrypoint_info(const string& tenant_name, const string& bucket_name, RGWBucketEntryPoint& entry_point,
RGWBucketEntryPoint& entry_point, RGWObjVersionTracker *objv_tracker,
ceph::real_time *pmtime, map<string, bufferlist> *pattrs, rgw_cache_entry_info *cache_info = NULL);
int get_bucket_instance_info(RGWObjectCtx& obj_ctx, const string& meta_key, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs);
- int get_bucket_instance_info(RGWObjectCtx& obj_ctx, rgw_bucket& bucket, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs);
+ int get_bucket_instance_info(RGWObjectCtx& obj_ctx, const rgw_bucket& bucket, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs);
int get_bucket_instance_from_oid(RGWObjectCtx& obj_ctx, string& oid, RGWBucketInfo& info, ceph::real_time *pmtime, map<string, bufferlist> *pattrs,
rgw_cache_entry_info *cache_info = NULL);
const string& from_marker = std::string(),
const string& to_marker = std::string());
- int lock_exclusive(rgw_bucket& pool, const string& oid, ceph::timespan& duration, string& zone_id, string& owner_id);
- int unlock(rgw_bucket& pool, const string& oid, string& zone_id, string& owner_id);
+ int lock_exclusive(rgw_pool& pool, const string& oid, ceph::timespan& duration, string& zone_id, string& owner_id);
+ int unlock(rgw_pool& pool, const string& oid, string& zone_id, string& owner_id);
void update_gc_chain(rgw_obj& head_obj, RGWObjManifest& manifest, cls_rgw_obj_chain *chain);
int send_chain_to_gc(cls_rgw_obj_chain& chain, const string& tag, bool sync);
int cls_user_get_header(const string& user_id, cls_user_header *header);
int cls_user_get_header_async(const string& user_id, RGWGetUserHeader_CB *ctx);
- int cls_user_sync_bucket_stats(rgw_obj& user_obj, rgw_bucket& bucket);
+ int cls_user_sync_bucket_stats(rgw_raw_obj& user_obj, rgw_bucket& bucket);
int update_user_bucket_stats(const string& user_id, rgw_bucket& bucket, RGWStorageStats& stats);
- int cls_user_list_buckets(rgw_obj& obj,
+ int cls_user_list_buckets(rgw_raw_obj& obj,
const string& in_marker,
const string& end_marker,
int max_entries,
list<cls_user_bucket_entry>& entries,
string *out_marker,
bool *truncated);
- int cls_user_add_bucket(rgw_obj& obj, const cls_user_bucket_entry& entry);
- int cls_user_update_buckets(rgw_obj& obj, list<cls_user_bucket_entry>& entries, bool add);
- int cls_user_complete_stats_sync(rgw_obj& obj);
+ int cls_user_add_bucket(rgw_raw_obj& obj, const cls_user_bucket_entry& entry);
+ int cls_user_update_buckets(rgw_raw_obj& obj, list<cls_user_bucket_entry>& entries, bool add);
+ int cls_user_complete_stats_sync(rgw_raw_obj& obj);
int complete_sync_user_stats(const rgw_user& user_id);
- int cls_user_add_bucket(rgw_obj& obj, list<cls_user_bucket_entry>& entries);
- int cls_user_remove_bucket(rgw_obj& obj, const cls_user_bucket& bucket);
+ int cls_user_add_bucket(rgw_raw_obj& obj, list<cls_user_bucket_entry>& entries);
+ int cls_user_remove_bucket(rgw_raw_obj& obj, const cls_user_bucket& bucket);
int check_quota(const rgw_user& bucket_owner, rgw_bucket& bucket,
RGWQuotaInfo& user_quota, RGWQuotaInfo& bucket_quota, uint64_t obj_size);
* ctx: context object to use for the iteration
* Returns: 0 on success, -ERR# otherwise.
*/
- int pool_iterate_begin(rgw_bucket& bucket, RGWPoolIterCtx& ctx);
+ int pool_iterate_begin(const rgw_pool& pool, RGWPoolIterCtx& ctx);
/**
* Iterate over pool return object names, use optional filter
* ctx: iteration context, initialized with pool_iterate_begin()
projects / ceph-ci.git / commitdiff