extern "C" {
extern rgw::sal::Store* newStore(void);
#ifdef WITH_RADOSGW_DBSTORE
-extern rgw::sal::Store* newRGWDBStore(CephContext *cct);
+extern rgw::sal::Store* newDBStore(CephContext *cct);
#endif
}
if (svc.compare("dbstore") == 0) {
#ifdef WITH_RADOSGW_DBSTORE
- rgw::sal::Store* store = newRGWDBStore(cct);
+ rgw::sal::Store* store = newDBStore(cct);
/* Initialize the dbstore with cct & dpp */
- DBStore *db = static_cast<rgw::sal::RGWDBStore *>(store)->getDBStore();
+ DB *db = static_cast<rgw::sal::DBStore *>(store)->getDB();
db->set_context(cct);
return store;
#endif
if (svc.compare("dbstore") == 0) {
#ifdef WITH_RADOSGW_DBSTORE
- store = newRGWDBStore(cct);
+ store = newDBStore(cct);
#else
store = nullptr;
#endif
int ret;
buckets.clear();
- ret = store->getDBStore()->list_buckets(dpp, info.user_id, marker, end_marker, max,
+ ret = store->getDB()->list_buckets(dpp, info.user_id, marker, end_marker, max,
need_stats, &ulist, &is_truncated);
if (ret < 0)
return ret;
int DBUser::read_attrs(const DoutPrefixProvider* dpp, optional_yield y)
{
int ret;
- ret = store->getDBStore()->get_user(dpp, string("user_id"), "", info, &attrs,
+ ret = store->getDB()->get_user(dpp, string("user_id"), "", info, &attrs,
&objv_tracker);
return ret;
}
{
int ret = 0;
- ret = store->getDBStore()->get_user(dpp, string("user_id"), "", info, &attrs,
+ ret = store->getDB()->get_user(dpp, string("user_id"), "", info, &attrs,
&objv_tracker);
return ret;
{
int ret = 0;
- ret = store->getDBStore()->store_user(dpp, info, exclusive, &attrs, &objv_tracker, old_info);
+ ret = store->getDB()->store_user(dpp, info, exclusive, &attrs, &objv_tracker, old_info);
return ret;
}
{
int ret = 0;
- ret = store->getDBStore()->remove_user(dpp, info, &objv_tracker);
+ ret = store->getDB()->remove_user(dpp, info, &objv_tracker);
return ret;
}
/* XXX: handle delete_children */
- ret = store->getDBStore()->remove_bucket(dpp, info);
+ ret = store->getDB()->remove_bucket(dpp, info);
return ret;
}
{
int ret = 0;
- ret = store->getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
+ ret = store->getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
&mtime, &bucket_version);
return ret;
{
int ret;
- ret = store->getDBStore()->update_bucket(dpp, "owner", info, false, &(new_user->get_id()), nullptr, nullptr, nullptr);
+ ret = store->getDB()->update_bucket(dpp, "owner", info, false, &(new_user->get_id()), nullptr, nullptr, nullptr);
/* XXX: Update policies of all the bucket->objects with new user */
return ret;
{
int ret;
- ret = store->getDBStore()->update_bucket(dpp, "info", info, exclusive, nullptr, nullptr, &_mtime, &info.objv_tracker);
+ ret = store->getDB()->update_bucket(dpp, "info", info, exclusive, nullptr, nullptr, &_mtime, &info.objv_tracker);
return ret;
/* XXX: same as DBBUcket::remove_bucket() but should return error if there are objects
* in that bucket. */
- int ret = store->getDBStore()->remove_bucket(dpp, info);
+ int ret = store->getDB()->remove_bucket(dpp, info);
return ret;
}
/* XXX: handle has_instance_obj like in set_bucket_instance_attrs() */
- ret = store->getDBStore()->update_bucket(dpp, "attrs", info, false, nullptr, &attrs, nullptr, &get_info().objv_tracker);
+ ret = store->getDB()->update_bucket(dpp, "attrs", info, false, nullptr, &attrs, nullptr, &get_info().objv_tracker);
return ret;
}
{
int ret = 0;
- ret = store->getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
+ ret = store->getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
pmtime, &bucket_version);
return ret;
Attrs attrs = get_attrs();
attrs[RGW_ATTR_ACL] = aclbl;
- ret = store->getDBStore()->update_bucket(dpp, "attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
+ ret = store->getDB()->update_bucket(dpp, "attrs", info, false, &(acl.get_owner().get_id()), &attrs, nullptr, nullptr);
return ret;
}
return 0;
}
- void RGWDBStore::finalize(void)
+ void DBStore::finalize(void)
{
if (dbsm)
dbsm->destroyAllHandles();
return current_period->get_id();
}
- std::unique_ptr<LuaScriptManager> RGWDBStore::get_lua_script_manager()
+ std::unique_ptr<LuaScriptManager> DBStore::get_lua_script_manager()
{
return std::unique_ptr<LuaScriptManager>(new DBLuaScriptManager(this));
}
- std::unique_ptr<RGWRole> RGWDBStore::get_role(std::string name,
+ std::unique_ptr<RGWRole> DBStore::get_role(std::string name,
std::string tenant,
std::string path,
std::string trust_policy,
return std::unique_ptr<RGWRole>(p);
}
- std::unique_ptr<RGWRole> RGWDBStore::get_role(std::string id)
+ std::unique_ptr<RGWRole> DBStore::get_role(std::string id)
{
RGWRole* p = nullptr;
return std::unique_ptr<RGWRole>(p);
}
- int RGWDBStore::get_roles(const DoutPrefixProvider *dpp,
+ int DBStore::get_roles(const DoutPrefixProvider *dpp,
optional_yield y,
const std::string& path_prefix,
const std::string& tenant,
return 0;
}
- std::unique_ptr<RGWOIDCProvider> RGWDBStore::get_oidc_provider()
+ std::unique_ptr<RGWOIDCProvider> DBStore::get_oidc_provider()
{
RGWOIDCProvider* p = nullptr;
return std::unique_ptr<RGWOIDCProvider>(p);
}
- int RGWDBStore::get_oidc_providers(const DoutPrefixProvider *dpp,
+ int DBStore::get_oidc_providers(const DoutPrefixProvider *dpp,
const std::string& tenant,
vector<std::unique_ptr<RGWOIDCProvider>>& providers)
{
return 0;
}
- std::unique_ptr<User> RGWDBStore::get_user(const rgw_user &u)
+ std::unique_ptr<User> DBStore::get_user(const rgw_user &u)
{
return std::unique_ptr<User>(new DBUser(this, u));
}
- int RGWDBStore::get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user)
+ int DBStore::get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user)
{
RGWUserInfo uinfo;
User *u;
int ret = 0;
RGWObjVersionTracker objv_tracker;
- ret = getDBStore()->get_user(dpp, string("access_key"), key, uinfo, nullptr,
+ ret = getDB()->get_user(dpp, string("access_key"), key, uinfo, nullptr,
&objv_tracker);
if (ret < 0)
return 0;
}
- int RGWDBStore::get_user_by_email(const DoutPrefixProvider *dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user)
+ int DBStore::get_user_by_email(const DoutPrefixProvider *dpp, const std::string& email, optional_yield y, std::unique_ptr<User>* user)
{
RGWUserInfo uinfo;
User *u;
int ret = 0;
RGWObjVersionTracker objv_tracker;
- ret = getDBStore()->get_user(dpp, string("email"), email, uinfo, nullptr,
+ ret = getDB()->get_user(dpp, string("email"), email, uinfo, nullptr,
&objv_tracker);
if (ret < 0)
return ret;
}
- int RGWDBStore::get_user_by_swift(const DoutPrefixProvider *dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user)
+ int DBStore::get_user_by_swift(const DoutPrefixProvider *dpp, const std::string& user_str, optional_yield y, std::unique_ptr<User>* user)
{
/* Swift keys and subusers are not supported for now */
return 0;
}
- std::unique_ptr<Object> RGWDBStore::get_object(const rgw_obj_key& k)
+ std::unique_ptr<Object> DBStore::get_object(const rgw_obj_key& k)
{
return NULL;
}
- int RGWDBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
+ int DBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const rgw_bucket& b, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
int ret;
Bucket* bp;
return 0;
}
- int RGWDBStore::get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket)
+ int DBStore::get_bucket(User* u, const RGWBucketInfo& i, std::unique_ptr<Bucket>* bucket)
{
Bucket* bp;
return 0;
}
- int RGWDBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y)
+ int DBStore::get_bucket(const DoutPrefixProvider *dpp, User* u, const std::string& tenant, const std::string& name, std::unique_ptr<Bucket>* bucket, optional_yield y)
{
rgw_bucket b;
return get_bucket(dpp, u, b, bucket, y);
}
- int RGWDBStore::create_bucket(const DoutPrefixProvider *dpp,
+ int DBStore::create_bucket(const DoutPrefixProvider *dpp,
User* u, const rgw_bucket& b,
const string& zonegroup_id,
rgw_placement_rule& placement_rule,
} else {
/* XXX: We may not need to send all these params. Cleanup the unused ones */
- ret = getDBStore()->create_bucket(dpp, u->get_info(), bucket->get_key(),
+ ret = getDB()->create_bucket(dpp, u->get_info(), bucket->get_key(),
zid, placement_rule, swift_ver_location, pquota_info,
attrs, info, pobjv, &ep_objv, creation_time,
pmaster_bucket, pmaster_num_shards, y, exclusive);
return ret;
}
- bool RGWDBStore::is_meta_master()
+ bool DBStore::is_meta_master()
{
return true;
}
- int RGWDBStore::forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version *objv,
+ int DBStore::forward_request_to_master(const DoutPrefixProvider *dpp, User* user, obj_version *objv,
bufferlist& in_data,
JSONParser *jp, req_info& info,
optional_yield y)
return 0;
}
- int RGWDBStore::defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, Bucket* bucket, Object* obj, optional_yield y)
+ int DBStore::defer_gc(const DoutPrefixProvider *dpp, RGWObjectCtx *rctx, Bucket* bucket, Object* obj, optional_yield y)
{
return 0;
}
- std::string RGWDBStore::zone_unique_id(uint64_t unique_num)
+ std::string DBStore::zone_unique_id(uint64_t unique_num)
{
return "";
}
- std::string RGWDBStore::zone_unique_trans_id(const uint64_t unique_num)
+ std::string DBStore::zone_unique_trans_id(const uint64_t unique_num)
{
return "";
}
- int RGWDBStore::cluster_stat(RGWClusterStat& stats)
+ int DBStore::cluster_stat(RGWClusterStat& stats)
{
return 0;
}
- std::unique_ptr<Lifecycle> RGWDBStore::get_lifecycle(void)
+ std::unique_ptr<Lifecycle> DBStore::get_lifecycle(void)
{
return 0;
}
- std::unique_ptr<Completions> RGWDBStore::get_completions(void)
+ std::unique_ptr<Completions> DBStore::get_completions(void)
{
return 0;
}
- std::unique_ptr<Notification> RGWDBStore::get_notification(rgw::sal::Object* obj,
+ std::unique_ptr<Notification> DBStore::get_notification(rgw::sal::Object* obj,
struct req_state* s,
rgw::notify::EventType event_type, const std::string* object_name)
{
return 0;
}
- std::unique_ptr<GCChain> RGWDBStore::get_gc_chain(rgw::sal::Object* obj)
+ std::unique_ptr<GCChain> DBStore::get_gc_chain(rgw::sal::Object* obj)
{
return 0;
}
- std::unique_ptr<Writer> RGWDBStore::get_writer(Aio *aio, rgw::sal::Bucket* bucket,
+ std::unique_ptr<Writer> DBStore::get_writer(Aio *aio, rgw::sal::Bucket* bucket,
RGWObjectCtx& obj_ctx, std::unique_ptr<rgw::sal::Object> _head_obj,
const DoutPrefixProvider *dpp, optional_yield y)
{
return 0;
}
- int RGWDBStore::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj)
+ int DBStore::delete_raw_obj(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj)
{
return 0;
}
- int RGWDBStore::delete_raw_obj_aio(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, Completions* aio)
+ int DBStore::delete_raw_obj_aio(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, Completions* aio)
{
return 0;
}
- void RGWDBStore::get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj)
+ void DBStore::get_raw_obj(const rgw_placement_rule& placement_rule, const rgw_obj& obj, rgw_raw_obj* raw_obj)
{
return;
}
- int RGWDBStore::get_raw_chunk_size(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, uint64_t* chunk_size)
+ int DBStore::get_raw_chunk_size(const DoutPrefixProvider *dpp, const rgw_raw_obj& obj, uint64_t* chunk_size)
{
return 0;
}
- int RGWDBStore::log_usage(const DoutPrefixProvider *dpp, map<rgw_user_bucket, RGWUsageBatch>& usage_info)
+ int DBStore::log_usage(const DoutPrefixProvider *dpp, map<rgw_user_bucket, RGWUsageBatch>& usage_info)
{
return 0;
}
- int RGWDBStore::log_op(const DoutPrefixProvider *dpp, string& oid, bufferlist& bl)
+ int DBStore::log_op(const DoutPrefixProvider *dpp, string& oid, bufferlist& bl)
{
return 0;
}
- int RGWDBStore::register_to_service_map(const DoutPrefixProvider *dpp, const string& daemon_type,
+ int DBStore::register_to_service_map(const DoutPrefixProvider *dpp, const string& daemon_type,
const map<string, string>& meta)
{
return 0;
}
- void RGWDBStore::get_quota(RGWQuotaInfo& bucket_quota, RGWQuotaInfo& user_quota)
+ void DBStore::get_quota(RGWQuotaInfo& bucket_quota, RGWQuotaInfo& user_quota)
{
// XXX: Not handled for the first pass
return;
}
- int RGWDBStore::set_buckets_enabled(const DoutPrefixProvider *dpp, vector<rgw_bucket>& buckets, bool enabled)
+ int DBStore::set_buckets_enabled(const DoutPrefixProvider *dpp, vector<rgw_bucket>& buckets, bool enabled)
{
int ret = 0;
RGWBucketInfo info;
map<string, bufferlist> attrs;
- int r = getDBStore()->get_bucket_info(dpp, string("name"), "", info, &attrs,
+ int r = getDB()->get_bucket_info(dpp, string("name"), "", info, &attrs,
nullptr, nullptr);
if (r < 0) {
ldpp_dout(dpp, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
info.flags |= BUCKET_SUSPENDED;
}
- r = getDBStore()->update_bucket(dpp, "info", info, false, nullptr, &attrs, nullptr, &info.objv_tracker);
+ r = getDB()->update_bucket(dpp, "info", info, false, nullptr, &attrs, nullptr, &info.objv_tracker);
if (r < 0) {
ldpp_dout(dpp, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
ret = r;
return ret;
}
- int RGWDBStore::get_sync_policy_handler(const DoutPrefixProvider *dpp,
+ int DBStore::get_sync_policy_handler(const DoutPrefixProvider *dpp,
std::optional<rgw_zone_id> zone,
std::optional<rgw_bucket> bucket,
RGWBucketSyncPolicyHandlerRef *phandler,
return 0;
}
- RGWDataSyncStatusManager* RGWDBStore::get_data_sync_manager(const rgw_zone_id& source_zone)
+ RGWDataSyncStatusManager* DBStore::get_data_sync_manager(const rgw_zone_id& source_zone)
{
return 0;
}
- int RGWDBStore::read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
+ int DBStore::read_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch,
uint32_t max_entries, bool *is_truncated,
RGWUsageIter& usage_iter,
map<rgw_user_bucket, rgw_usage_log_entry>& usage)
return 0;
}
- int RGWDBStore::trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch)
+ int DBStore::trim_all_usage(const DoutPrefixProvider *dpp, uint64_t start_epoch, uint64_t end_epoch)
{
return 0;
}
- int RGWDBStore::get_config_key_val(string name, bufferlist *bl)
+ int DBStore::get_config_key_val(string name, bufferlist *bl)
{
return 0;
}
- int RGWDBStore::meta_list_keys_init(const DoutPrefixProvider *dpp, const string& section, const string& marker, void** phandle)
+ int DBStore::meta_list_keys_init(const DoutPrefixProvider *dpp, const string& section, const string& marker, void** phandle)
{
return 0;
}
- int RGWDBStore::meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, list<string>& keys, bool* truncated)
+ int DBStore::meta_list_keys_next(const DoutPrefixProvider *dpp, void* handle, int max, list<string>& keys, bool* truncated)
{
return 0;
}
- void RGWDBStore::meta_list_keys_complete(void* handle)
+ void DBStore::meta_list_keys_complete(void* handle)
{
return;
}
- std::string RGWDBStore::meta_get_marker(void* handle)
+ std::string DBStore::meta_get_marker(void* handle)
{
return "";
}
- int RGWDBStore::meta_remove(const DoutPrefixProvider *dpp, string& metadata_key, optional_yield y)
+ int DBStore::meta_remove(const DoutPrefixProvider *dpp, string& metadata_key, optional_yield y)
{
return 0;
}
extern "C" {
- void *newRGWDBStore(CephContext *cct)
+ void *newDBStore(CephContext *cct)
{
- rgw::sal::RGWDBStore *store = new rgw::sal::RGWDBStore();
+ rgw::sal::DBStore *store = new rgw::sal::DBStore();
if (store) {
DBStoreManager *dbsm = new DBStoreManager(cct);
delete store; store = nullptr;
}
- DBStore *dbstore = dbsm->getDBStore();
- if (!dbstore ) {
+ DB *db = dbsm->getDB();
+ if (!db) {
delete dbsm;
delete store; store = nullptr;
}
store->setDBStoreManager(dbsm);
- store->setDBStore(dbstore);
+ store->setDB(db);
}
return store;
namespace rgw { namespace sal {
- class RGWDBStore;
+ class DBStore;
class DBUser : public User {
private:
- RGWDBStore *store;
+ DBStore *store;
public:
- DBUser(RGWDBStore *_st, const rgw_user& _u) : User(_u), store(_st) { }
- DBUser(RGWDBStore *_st, const RGWUserInfo& _i) : User(_i), store(_st) { }
- DBUser(RGWDBStore *_st) : store(_st) { }
+ DBUser(DBStore *_st, const rgw_user& _u) : User(_u), store(_st) { }
+ DBUser(DBStore *_st, const RGWUserInfo& _i) : User(_i), store(_st) { }
+ DBUser(DBStore *_st) : store(_st) { }
DBUser(DBUser& _o) = default;
DBUser() {}
class DBBucket : public Bucket {
private:
- RGWDBStore *store;
+ DBStore *store;
RGWAccessControlPolicy acls;
public:
- DBBucket(RGWDBStore *_st)
+ DBBucket(DBStore *_st)
: store(_st),
acls() {
}
- DBBucket(RGWDBStore *_st, User* _u)
+ DBBucket(DBStore *_st, User* _u)
: Bucket(_u),
store(_st),
acls() {
}
- DBBucket(RGWDBStore *_st, const rgw_bucket& _b)
+ DBBucket(DBStore *_st, const rgw_bucket& _b)
: Bucket(_b),
store(_st),
acls() {
}
- DBBucket(RGWDBStore *_st, const RGWBucketEnt& _e)
+ DBBucket(DBStore *_st, const RGWBucketEnt& _e)
: Bucket(_e),
store(_st),
acls() {
}
- DBBucket(RGWDBStore *_st, const RGWBucketInfo& _i)
+ DBBucket(DBStore *_st, const RGWBucketInfo& _i)
: Bucket(_i),
store(_st),
acls() {
}
- DBBucket(RGWDBStore *_st, const rgw_bucket& _b, User* _u)
+ DBBucket(DBStore *_st, const rgw_bucket& _b, User* _u)
: Bucket(_b, _u),
store(_st),
acls() {
}
- DBBucket(RGWDBStore *_st, const RGWBucketEnt& _e, User* _u)
+ DBBucket(DBStore *_st, const RGWBucketEnt& _e, User* _u)
: Bucket(_e, _u),
store(_st),
acls() {
}
- DBBucket(RGWDBStore *_st, const RGWBucketInfo& _i, User* _u)
+ DBBucket(DBStore *_st, const RGWBucketInfo& _i, User* _u)
: Bucket(_i, _u),
store(_st),
acls() {
return std::make_unique<DBBucket>(*this);
}
- friend class RGWDBStore;
+ friend class DBStore;
};
class DBZone : public Zone {
protected:
- RGWDBStore* store;
+ DBStore* store;
RGWRealm *realm{nullptr};
RGWZoneGroup *zonegroup{nullptr};
RGWZone *zone_public_config{nullptr}; /* external zone params, e.g., entrypoints, log flags, etc. */
rgw_zone_id cur_zone_id;
public:
- DBZone(RGWDBStore* _store) : store(_store) {
+ DBZone(DBStore* _store) : store(_store) {
realm = new RGWRealm();
zonegroup = new RGWZoneGroup();
zone_public_config = new RGWZone();
};
class DBLuaScriptManager : public LuaScriptManager {
- RGWDBStore* store;
+ DBStore* store;
public:
- DBLuaScriptManager(RGWDBStore* _s) : store(_s)
+ DBLuaScriptManager(DBStore* _s) : store(_s)
{
}
virtual ~DBLuaScriptManager() = default;
};
class DBOIDCProvider : public RGWOIDCProvider {
- RGWDBStore* store;
+ DBStore* store;
public:
- DBOIDCProvider(RGWDBStore* _store) : store(_store) {}
+ DBOIDCProvider(DBStore* _store) : store(_store) {}
~DBOIDCProvider() = default;
virtual int store_url(const DoutPrefixProvider *dpp, const std::string& url, bool exclusive, optional_yield y) override { return 0; }
}
};
- class RGWDBStore : public Store {
+ class DBStore : public Store {
private:
/* DBStoreManager is used in case multiple
* connections are needed one for each tenant.
*/
DBStoreManager *dbsm;
- /* default dbstore (single connection). If needed
+ /* default db (single connection). If needed
* multiple db handles (for eg., one for each tenant),
- * use dbsm->getDBStore(tenant) */
- DBStore *dbstore;
+ * use dbsm->getDB(tenant) */
+ DB *db;
string luarocks_path;
DBZone zone;
RGWSyncModuleInstanceRef sync_module;
public:
- RGWDBStore(): dbsm(nullptr), zone(this) {}
- ~RGWDBStore() { delete dbsm; }
+ DBStore(): dbsm(nullptr), zone(this) {}
+ ~DBStore() { delete dbsm; }
virtual std::unique_ptr<User> get_user(const rgw_user& u) override;
virtual int get_user_by_access_key(const DoutPrefixProvider *dpp, const std::string& key, optional_yield y, std::unique_ptr<User>* user) override;
virtual void finalize(void) override;
virtual CephContext *ctx(void) override {
- return dbstore->ctx();
+ return db->ctx();
}
virtual const std::string& get_luarocks_path() const override {
void setDBStoreManager(DBStoreManager *stm) { dbsm = stm; }
DBStoreManager *getDBStoreManager(void) { return dbsm; }
- void setDBStore(DBStore * st) { dbstore = st; }
- DBStore *getDBStore(void) { return dbstore; }
+ void setDB(DB * st) { db = st; }
+ DB *getDB(void) { return db; }
- DBStore *getDBStore(string tenant) { return dbsm->getDBStore(tenant, false); }
+ DB *getDB(string tenant) { return dbsm->getDB(tenant, false); }
};
} } // namespace rgw::sal
using namespace std;
-map<string, class ObjectOp*> DBStore::objectmap = {};
+namespace rgw { namespace store {
-map<string, class ObjectOp*> DBStore::getObjectMap() {
- return DBStore::objectmap;
+map<string, class ObjectOp*> DB::objectmap = {};
+
+map<string, class ObjectOp*> DB::getObjectMap() {
+ return DB::objectmap;
}
-int DBStore::Initialize(string logfile, int loglevel)
+int DB::Initialize(string logfile, int loglevel)
{
int ret = -1;
const DoutPrefixProvider *dpp = get_def_dpp();
return ret;
}
- ldpp_dout(dpp, 0) << "DBStore successfully initialized - name:" \
+ ldpp_dout(dpp, 0) << "DB successfully initialized - name:" \
<< db_name << "" << dendl;
return ret;
}
-int DBStore::Destroy(const DoutPrefixProvider *dpp)
+int DB::Destroy(const DoutPrefixProvider *dpp)
{
if (!db)
return 0;
FreeDBOps(dpp);
- ldpp_dout(dpp, 20)<<"DBStore successfully destroyed - name:" \
+ ldpp_dout(dpp, 20)<<"DB successfully destroyed - name:" \
<<db_name << dendl;
return 0;
}
-int DBStore::LockInit(const DoutPrefixProvider *dpp) {
+int DB::LockInit(const DoutPrefixProvider *dpp) {
int ret;
ret = pthread_mutex_init(&mutex, NULL);
return ret;
}
-int DBStore::LockDestroy(const DoutPrefixProvider *dpp) {
+int DB::LockDestroy(const DoutPrefixProvider *dpp) {
int ret;
ret = pthread_mutex_destroy(&mutex);
return ret;
}
-int DBStore::Lock(const DoutPrefixProvider *dpp) {
+int DB::Lock(const DoutPrefixProvider *dpp) {
int ret;
ret = pthread_mutex_lock(&mutex);
return ret;
}
-int DBStore::Unlock(const DoutPrefixProvider *dpp) {
+int DB::Unlock(const DoutPrefixProvider *dpp) {
int ret;
ret = pthread_mutex_unlock(&mutex);
return ret;
}
-DBOp *DBStore::getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params)
+DBOp *DB::getDBOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params)
{
if (!Op.compare("InsertUser"))
return dbops.InsertUser;
map<string, class ObjectOp*>::iterator iter;
class ObjectOp* Ob;
- iter = DBStore::objectmap.find(params->op.bucket.info.bucket.name);
+ iter = DB::objectmap.find(params->op.bucket.info.bucket.name);
- if (iter == DBStore::objectmap.end()) {
+ if (iter == DB::objectmap.end()) {
ldpp_dout(dpp, 30)<<"No objectmap found for bucket: " \
<<params->op.bucket.info.bucket.name << dendl;
/* not found */
return NULL;
}
-int DBStore::objectmapInsert(const DoutPrefixProvider *dpp, string bucket, void *ptr)
+int DB::objectmapInsert(const DoutPrefixProvider *dpp, string bucket, void *ptr)
{
map<string, class ObjectOp*>::iterator iter;
class ObjectOp *Ob;
- iter = DBStore::objectmap.find(bucket);
+ iter = DB::objectmap.find(bucket);
- if (iter != DBStore::objectmap.end()) {
+ if (iter != DB::objectmap.end()) {
// entry already exists
// return success or replace it or
// return error ?
Ob = (class ObjectOp*) ptr;
Ob->InitializeObjectOps(dpp);
- DBStore::objectmap.insert(pair<string, class ObjectOp*>(bucket, Ob));
+ DB::objectmap.insert(pair<string, class ObjectOp*>(bucket, Ob));
return 0;
}
-int DBStore::objectmapDelete(const DoutPrefixProvider *dpp, string bucket)
+int DB::objectmapDelete(const DoutPrefixProvider *dpp, string bucket)
{
map<string, class ObjectOp*>::iterator iter;
class ObjectOp *Ob;
- iter = DBStore::objectmap.find(bucket);
+ iter = DB::objectmap.find(bucket);
- if (iter == DBStore::objectmap.end()) {
+ if (iter == DB::objectmap.end()) {
// entry doesn't exist
// return success or return error ?
// return success for now
Ob = (class ObjectOp*) (iter->second);
Ob->FreeObjectOps(dpp);
- DBStore::objectmap.erase(iter);
+ DB::objectmap.erase(iter);
return 0;
}
-int DBStore::InitializeParams(const DoutPrefixProvider *dpp, string Op, DBOpParams *params)
+int DB::InitializeParams(const DoutPrefixProvider *dpp, string Op, DBOpParams *params)
{
int ret = -1;
return ret;
}
-int DBStore::ProcessOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params) {
+int DB::ProcessOp(const DoutPrefixProvider *dpp, string Op, struct DBOpParams *params) {
int ret = -1;
class DBOp *db_op;
return ret;
}
-int DBStore::get_user(const DoutPrefixProvider *dpp,
+int DB::get_user(const DoutPrefixProvider *dpp,
const std::string& query_str, const std::string& query_str_val,
RGWUserInfo& uinfo, map<string, bufferlist> *pattrs,
RGWObjVersionTracker *pobjv_tracker) {
return ret;
}
-int DBStore::store_user(const DoutPrefixProvider *dpp,
+int DB::store_user(const DoutPrefixProvider *dpp,
RGWUserInfo& uinfo, bool exclusive, map<string, bufferlist> *pattrs,
RGWObjVersionTracker *pobjv, RGWUserInfo* pold_info)
{
return ret;
}
-int DBStore::remove_user(const DoutPrefixProvider *dpp,
+int DB::remove_user(const DoutPrefixProvider *dpp,
RGWUserInfo& uinfo, RGWObjVersionTracker *pobjv)
{
DBOpParams params = {};
return ret;
}
-int DBStore::get_bucket_info(const DoutPrefixProvider *dpp, const std::string& query_str,
+int DB::get_bucket_info(const DoutPrefixProvider *dpp, const std::string& query_str,
const std::string& query_str_val,
RGWBucketInfo& info,
rgw::sal::Attrs* pattrs, ceph::real_time* pmtime,
return ret;
}
-int DBStore::create_bucket(const DoutPrefixProvider *dpp,
+int DB::create_bucket(const DoutPrefixProvider *dpp,
const RGWUserInfo& owner, rgw_bucket& bucket,
const string& zonegroup_id,
const rgw_placement_rule& placement_rule,
return ret;
}
-int DBStore::remove_bucket(const DoutPrefixProvider *dpp, const RGWBucketInfo info) {
+int DB::remove_bucket(const DoutPrefixProvider *dpp, const RGWBucketInfo info) {
int ret = 0;
DBOpParams params = {};
return ret;
}
-int DBStore::list_buckets(const DoutPrefixProvider *dpp, const rgw_user& user,
+int DB::list_buckets(const DoutPrefixProvider *dpp, const rgw_user& user,
const string& marker,
const string& end_marker,
uint64_t max,
return ret;
}
-int DBStore::update_bucket(const DoutPrefixProvider *dpp, const std::string& query_str,
+int DB::update_bucket(const DoutPrefixProvider *dpp, const std::string& query_str,
RGWBucketInfo& info,
bool exclusive,
const rgw_user* powner_id,
out:
return ret;
}
+
+} } // namespace rgw::store
+
#include <map>
#include "dbstore_log.h"
#include "rgw/rgw_sal.h"
+#include "rgw/rgw_common.h"
#include "rgw/rgw_bucket.h"
#include "global/global_context.h"
#include "global/global_init.h"
using namespace std;
-class DBStore;
+namespace rgw { namespace store {
+
+class DB;
struct DBOpUserInfo {
RGWUserInfo uinfo = {};
}
};
-class DBStore {
+class DB {
private:
const string db_name;
const string user_table;
uint64_t max_bucket_id = 0;
public:
- DBStore(string db_name, CephContext *_cct) : db_name(db_name),
+ DB(string db_name, CephContext *_cct) : db_name(db_name),
user_table(db_name+".user.table"),
bucket_table(db_name+".bucket.table"),
quota_table(db_name+".quota.table"),
cct(_cct),
dp(_cct, dout_subsys, "rgw DBStore backend: ")
{}
- /* DBStore() {}*/
+ /* DB() {}*/
- DBStore(CephContext *_cct) : db_name("default_db"),
+ DB(CephContext *_cct) : db_name("default_db"),
user_table("user.table"),
bucket_table("bucket.table"),
quota_table("quota.table"),
cct(_cct),
dp(_cct, dout_subsys, "rgw DBStore backend: ")
{}
- virtual ~DBStore() {}
+ virtual ~DB() {}
const string getDBname() { return db_name + ".db"; }
const string getUserTable() { return user_table; }
const rgw_user* powner_id, map<std::string, bufferlist>* pattrs,
ceph::real_time* pmtime, RGWObjVersionTracker* pobjv);
};
+
+} } // namespace rgw::store
+
#endif
#include <dbstore.h>
#include <dbstore_log.h>
+using namespace rgw::store;
+using DB = rgw::store::DB;
+
struct thr_args {
- class DBStore *dbs;
+ DB *dbs;
int thr_id;
};
{
struct thr_args *t_args = (struct thr_args*)arg;
- class DBStore *db = t_args->dbs;
+ DB *db = t_args->dbs;
int thr_id = t_args->thr_id;
int ret = -1;
string objectc1 = "rhhi";
string objectc2 = "cns";
- struct DBOpParams params = {};
+ DBOpParams params = {};
const DoutPrefixProvider *dpp = db->get_def_dpp();
db->InitializeParams(dpp, "InsertUser", ¶ms);
ret = db->ProcessOp(dpp, "InsertUser", ¶ms);
cout << "InsertUser return value: " << ret << "\n";
- struct DBOpParams params2 = {};
+ DBOpParams params2 = {};
params.op.user.uinfo.user_id.tenant = "tenant2";
db->InitializeParams(dpp, "GetUser", ¶ms2);
string logfile = "rgw_dbstore_bin.log";
int loglevel = 20;
- class DBStoreManager *dbsm;
- class DBStore *dbs;
+ DBStoreManager *dbsm;
+ DB *dbs;
int rc = 0, tnum = 0;
void *res;
}
dbsm = new DBStoreManager(logfile, loglevel);
- dbs = dbsm->getDBStore(tenant, true);
+ dbs = dbsm->getDB(tenant, true);
cout<<"No. of threads being created = "<<num_thr<<"\n";
* If not found and 'create' set to true, create one
* and return
*/
-DBStore* DBStoreManager::getDBStore (string tenant, bool create)
+DB *DBStoreManager::getDB (string tenant, bool create)
{
- map<string, DBStore*>::iterator iter;
- DBStore *dbs = nullptr;
- pair<map<string, DBStore*>::iterator,bool> ret;
+ map<string, DB*>::iterator iter;
+ DB *dbs = nullptr;
+ pair<map<string, DB*>::iterator,bool> ret;
if (tenant.empty())
- return default_dbstore;
+ return default_db;
if (DBStoreHandles.empty())
goto not_found;
if (!create)
return NULL;
- dbs = createDBStore(tenant);
+ dbs = createDB(tenant);
return dbs;
}
/* Create DBStore instance */
-DBStore* DBStoreManager::createDBStore(string tenant) {
- DBStore *dbs = nullptr;
- pair<map<string, DBStore*>::iterator,bool> ret;
+DB *DBStoreManager::createDB(string tenant) {
+ DB *dbs = nullptr;
+ pair<map<string, DB*>::iterator,bool> ret;
/* Create the handle */
#ifdef SQLITE_ENABLED
dbs = new SQLiteDB(tenant, cct);
#else
- dbs = new DBStore(tenant, cct);
+ dbs = new DB(tenant, cct);
#endif
- /* API is DBStore::Initialize(string logfile, int loglevel);
+ /* API is DB::Initialize(string logfile, int loglevel);
* If none provided, by default write in to dbstore.log file
* created in current working directory with loglevel L_EVENT.
* XXX: need to align these logs to ceph location
*/
if (dbs->Initialize("", -1) < 0) {
- cout<<"^^^^^^^^^^^^DB initialization failed for tenant("<<tenant<<")^^^^^^^^^^^^^^^^^^^^^^^^^^ \n";
+ ldout(cct, 0) << "DB initialization failed for tenant("<<tenant<<")" << dendl;
delete dbs;
return NULL;
/* XXX: Do we need lock to protect this map?
*/
- ret = DBStoreHandles.insert(pair<string, DBStore*>(tenant, dbs));
+ ret = DBStoreHandles.insert(pair<string, DB*>(tenant, dbs));
/*
* Its safe to check for already existing entry (just
return dbs;
}
-void DBStoreManager::deleteDBStore(string tenant) {
- map<string, DBStore*>::iterator iter;
- DBStore *dbs = nullptr;
+void DBStoreManager::deleteDB(string tenant) {
+ map<string, DB*>::iterator iter;
+ DB *dbs = nullptr;
if (tenant.empty() || DBStoreHandles.empty())
return;
return;
}
-void DBStoreManager::deleteDBStore(DBStore *dbs) {
+void DBStoreManager::deleteDB(DB *dbs) {
if (!dbs)
return;
- (void)deleteDBStore(dbs->getDBname());
+ (void)deleteDB(dbs->getDBname());
}
void DBStoreManager::destroyAllHandles(){
- map<string, DBStore*>::iterator iter;
- DBStore *dbs = nullptr;
+ map<string, DB*>::iterator iter;
+ DB *dbs = nullptr;
if (DBStoreHandles.empty())
return;
#include "sqlite/sqliteDB.h"
using namespace std;
+using namespace rgw::store;
+using DB = rgw::store::DB;
/* XXX: Should be a dbstore config option */
const static string default_tenant = "default_ns";
using namespace std;
-class DBStore;
class DBStoreManager {
private:
- map<string, DBStore*> DBStoreHandles;
- DBStore *default_dbstore = NULL;
+ map<string, DB*> DBStoreHandles;
+ DB *default_db = NULL;
CephContext *cct;
public:
DBStoreManager(CephContext *_cct): DBStoreHandles() {
cct = _cct;
- default_dbstore = createDBStore(default_tenant);
+ default_db = createDB(default_tenant);
};
DBStoreManager(string logfile, int loglevel): DBStoreHandles() {
/* No ceph context. Create one with log args provided */
* 2) Refcount of each DBStore to protect from
* being deleted while using it.
*/
- DBStore* getDBStore () { return default_dbstore; };
- DBStore* getDBStore (string tenant, bool create);
- DBStore* createDBStore (string tenant);
- void deleteDBStore (string tenant);
- void deleteDBStore (DBStore* db);
+ DB* getDB () { return default_db; };
+ DB* getDB (string tenant, bool create);
+ DB* createDB (string tenant);
+ void deleteDB (string tenant);
+ void deleteDB (DB* db);
void destroyAllHandles();
};
int i;
for(i=0; i<argc; i++) {
string arg = argv[i] ? argv[i] : "NULL";
- // cout<<aname[i]<<" = "<<arg<<"\n";
}
return 0;
}
if (!stmt)
return -1;
- //cout<<sqlite3_column_text(stmt, 0) << dendl;
- /* Ensure the column names match with the user table defined in dbstore.h
- UserID TEXT , \ - 0
- Tenant TEXT , \ - 1
- NS TEXT , \ - 2
- DisplayName TEXT , \ - 3
- UserEmail TEXT , \ - 4
- AccessKeysID TEXT , \ - 5
- AccessKeysSecret TEXT , \ - 6
- AccessKeys BLOB , \ - 7
- SwiftKeys BLOB , \ - 8
- SubUsers BLOB , \ - 9
- Suspended INTEGER , \ - 10
- MaxBuckets INTEGER , \ - 11
- OpMask INTEGER , \ - 12
- UserCaps BLOB , \ - 13
- Admin INTEGER , \ - 14
- System INTEGER , \ - 15
- PlacementName TEXT , \ - 16
- PlacementStorageClass TEXT , \ - 17
- PlacementTags BLOB , \ - 18
- BucketQuota BLOB , \ - 19
- TempURLKeys BLOB , \ - 20
- UserQuota BLOB , \ - 21
- TYPE INTEGER , \ - 22
- MfaIDs INTEGER , \ - 23
- AssumedRoleARN TEXT \n);"; - 24
- */
-
op.user.uinfo.user_id.tenant = (const char*)sqlite3_column_text(stmt, Tenant);
op.user.uinfo.user_id.id = (const char*)sqlite3_column_text(stmt, UserID);
op.user.uinfo.user_id.ns = (const char*)sqlite3_column_text(stmt, NS);
if (!stmt)
return -1;
- // cout<<sqlite3_column_text(stmt, 0)<<", ";
- // cout<<sqlite3_column_text(stmt, 1) << dendl;
-
op.bucket.ent.bucket.name = (const char*)sqlite3_column_text(stmt, BucketName);
op.bucket.ent.bucket.tenant = (const char*)sqlite3_column_text(stmt, Bucket_Tenant);
op.bucket.ent.bucket.marker = (const char*)sqlite3_column_text(stmt, Marker);
if (!stmt)
return -1;
- // cout<<sqlite3_column_text(stmt, 0)<<", ";
- // cout<<sqlite3_column_text(stmt, 1) << dendl;
-
return 0;
}
blob = sqlite3_column_blob(stmt, 3);
datalen = sqlite3_column_bytes(stmt, 3);
- /* cout<<sqlite3_column_text(stmt, 0)<<", ";
- cout<<sqlite3_column_text(stmt, 1)<<",";
- cout<<sqlite3_column_int(stmt, 2)<<",";*/
char data[datalen+1] = {};
if (blob)
strncpy(data, (const char *)blob, datalen);
-// cout<<data<<","<<datalen << dendl;
-
return 0;
}
string schema;
schema = ListTableSchema(params->user_table);
- // cout<<"########### Listing all Users #############" << dendl;
ret = exec(dpp, schema.c_str(), &list_callback);
if (ret)
ldpp_dout(dpp, 0)<<"GetUsertable failed " << dendl;
schema = ListTableSchema(params->bucket_table);
-// cout<<"########### Listing all Buckets #############" << dendl;
ret = exec(dpp, schema.c_str(), &list_callback);
if (ret)
ldpp_dout(dpp, 0)<<"Listbuckettable failed " << dendl;
map<string, class ObjectOp*> objectmap;
string bucket;
- //cout<<"########### Listing all Objects #############" << dendl;
-
objectmap = getObjectMap();
if (objectmap.empty())
#include "rgw/store/dbstore/common/dbstore.h"
using namespace std;
+using namespace rgw::store;
-class SQLiteDB : public DBStore, public DBOp{
+class SQLiteDB : public DB, public DBOp{
private:
sqlite3_mutex *mutex = NULL;
sqlite3_stmt *stmt = NULL;
DBOpPrepareParams PrepareParams;
- SQLiteDB(string db_name, CephContext *_cct) : DBStore(db_name, _cct), cct(_cct) {
+ SQLiteDB(string db_name, CephContext *_cct) : DB(db_name, _cct), cct(_cct) {
InitPrepareParams(get_def_dpp(), PrepareParams);
}
- SQLiteDB(sqlite3 *dbi, CephContext *_cct) : DBStore(_cct), cct(_cct) {
+ SQLiteDB(sqlite3 *dbi, CephContext *_cct) : DB(_cct), cct(_cct) {
db = (void*)dbi;
InitPrepareParams(get_def_dpp(), PrepareParams);
}
#include "rgw_common.h"
using namespace std;
+using DB = rgw::store::DB;
vector<const char*> args;
}
string tenant;
- class DBStore *db;
+ DB *db;
string db_type;
int ret;
string logfile = "rgw_dbstore_tests.log";
namespace {
- class DBStoreBaseTest : public ::testing::Test {
+ class DBStoreTest : public ::testing::Test {
protected:
int ret;
- DBStore *db = nullptr;
+ DB *db = nullptr;
string user1 = "user1";
string user_id1 = "user_id1";
string bucket1 = "bucket1";
DBOpParams GlobalParams = {};
const DoutPrefixProvider *dpp;
- DBStoreBaseTest() {}
+ DBStoreTest() {}
void SetUp() {
db = gtest::env->db;
ASSERT_TRUE(db != nullptr);
};
}
-TEST_F(DBStoreBaseTest, InsertUser) {
+TEST_F(DBStoreTest, InsertUser) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, GetUser) {
+TEST_F(DBStoreTest, GetUser) {
struct DBOpParams params = GlobalParams;
int ret = -1;
}
-TEST_F(DBStoreBaseTest, GetUserQuery) {
+TEST_F(DBStoreTest, GetUserQuery) {
struct DBOpParams params = GlobalParams;
int ret = -1;
}
-TEST_F(DBStoreBaseTest, GetUserQueryByEmail) {
+TEST_F(DBStoreTest, GetUserQueryByEmail) {
int ret = -1;
RGWUserInfo uinfo;
string email = "user1@dbstore.com";
ASSERT_EQ(objv.read_version.ver, 1);
}
-TEST_F(DBStoreBaseTest, GetUserQueryByAccessKey) {
+TEST_F(DBStoreTest, GetUserQueryByAccessKey) {
int ret = -1;
RGWUserInfo uinfo;
string key = "id1";
ASSERT_EQ(k.key, "key2");
}
-TEST_F(DBStoreBaseTest, StoreUser) {
+TEST_F(DBStoreTest, StoreUser) {
struct DBOpParams params = GlobalParams;
int ret = -1;
RGWUserInfo uinfo, old_uinfo;
ASSERT_EQ(objv_tracker.read_version.tag, "UserTAG");
}
-TEST_F(DBStoreBaseTest, GetUserQueryByUserID) {
+TEST_F(DBStoreTest, GetUserQueryByUserID) {
int ret = -1;
RGWUserInfo uinfo;
map<std::string, bufferlist> attrs;
ASSERT_EQ(attr, "attrs2");
}
-TEST_F(DBStoreBaseTest, ListAllUsers) {
+TEST_F(DBStoreTest, ListAllUsers) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, InsertBucket) {
+TEST_F(DBStoreTest, InsertBucket) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, UpdateBucketAttrs) {
+TEST_F(DBStoreTest, UpdateBucketAttrs) {
int ret = -1;
RGWBucketInfo info;
map<std::string, bufferlist> attrs;
ASSERT_EQ(objv.read_version.ver, 2);
}
-TEST_F(DBStoreBaseTest, BucketChown) {
+TEST_F(DBStoreTest, BucketChown) {
int ret = -1;
RGWBucketInfo info;
rgw_user user;
ASSERT_EQ(info.objv_tracker.read_version.ver, 3);
}
-TEST_F(DBStoreBaseTest, UpdateBucketInfo) {
+TEST_F(DBStoreTest, UpdateBucketInfo) {
struct DBOpParams params = GlobalParams;
int ret = -1;
RGWBucketInfo info;
ASSERT_EQ(info.objv_tracker.read_version.ver, 4);
}
-TEST_F(DBStoreBaseTest, GetBucket) {
+TEST_F(DBStoreTest, GetBucket) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(acl, "attrs2");
}
-TEST_F(DBStoreBaseTest, RemoveBucketAPI) {
+TEST_F(DBStoreTest, RemoveBucketAPI) {
int ret = -1;
RGWBucketInfo info;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, RemoveUserAPI) {
+TEST_F(DBStoreTest, RemoveUserAPI) {
int ret = -1;
RGWUserInfo uinfo;
RGWObjVersionTracker objv;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, CreateBucket) {
+TEST_F(DBStoreTest, CreateBucket) {
struct DBOpParams params = GlobalParams;
int ret = -1;
RGWBucketInfo info;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, GetBucketQueryByName) {
+TEST_F(DBStoreTest, GetBucketQueryByName) {
int ret = -1;
RGWBucketInfo binfo;
binfo.bucket.name = "bucket2";
marker1 = binfo.bucket.marker;
}
-TEST_F(DBStoreBaseTest, ListUserBuckets) {
+TEST_F(DBStoreTest, ListUserBuckets) {
struct DBOpParams params = GlobalParams;
int ret = -1;
rgw_user owner;
} while(is_truncated);
}
-TEST_F(DBStoreBaseTest, ListAllBuckets) {
+TEST_F(DBStoreTest, ListAllBuckets) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, InsertObject) {
+TEST_F(DBStoreTest, InsertObject) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, ListObject) {
+TEST_F(DBStoreTest, ListObject) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, ListAllObjects) {
+TEST_F(DBStoreTest, ListAllObjects) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, PutObjectData) {
+TEST_F(DBStoreTest, PutObjectData) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, GetObjectData) {
+TEST_F(DBStoreTest, GetObjectData) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, DeleteObjectData) {
+TEST_F(DBStoreTest, DeleteObjectData) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, RemoveObject) {
+TEST_F(DBStoreTest, RemoveObject) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, RemoveBucket) {
+TEST_F(DBStoreTest, RemoveBucket) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, RemoveUser) {
+TEST_F(DBStoreTest, RemoveUser) {
struct DBOpParams params = GlobalParams;
int ret = -1;
ASSERT_EQ(ret, 0);
}
-TEST_F(DBStoreBaseTest, InsertTestIDUser) {
+TEST_F(DBStoreTest, InsertTestIDUser) {
struct DBOpParams params = GlobalParams;
int ret = -1;
projects / ceph.git / commitdiff