From 0d1868805b1cd8241a8b04c1064832f1350f5d69 Mon Sep 17 00:00:00 2001 From: Soumya Koduri Date: Sat, 3 Jul 2021 00:36:16 +0530 Subject: [PATCH] rgw/dbstore: Use CEPH RGW logging in ceph context When running dbstore as RGW backend, use the logging mechanism and config values provided by default by RGW. For other tests, set logfile and loglevel to the input values provided. Signed-off-by: Soumya Koduri --- CMakeLists.txt | 2 +- src/rgw/CMakeLists.txt | 9 +- src/rgw/rgw_sal.cc | 17 +- src/rgw/rgw_sal_dbstore.cc | 4 +- src/rgw/store/dbstore/README.md | 20 +- src/rgw/store/dbstore/common/dbstore.cc | 123 +- src/rgw/store/dbstore/common/dbstore.h | 18 +- src/rgw/store/dbstore/common/dbstore_log.h | 19 +- src/rgw/store/dbstore/dbstore_main.cc | 39 +- src/rgw/store/dbstore/dbstore_mgr.cc | 7 +- src/rgw/store/dbstore/dbstore_mgr.h | 15 +- src/rgw/store/dbstore/sqlite/sqliteDB.cc | 752 ++++++------- src/rgw/store/dbstore/sqlite/sqliteDB.h | 55 +- src/rgw/store/dbstore/tests/dbstore_tests.cc | 1061 +++++++++--------- 14 files changed, 1081 insertions(+), 1060 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 35ec581876054..75b54b1418002 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -403,7 +403,7 @@ option(WITH_RADOSGW_BEAST_OPENSSL "Rados Gateway's Beast frontend uses OpenSSL" option(WITH_RADOSGW_AMQP_ENDPOINT "Rados Gateway's pubsub support for AMQP push endpoint" ON) option(WITH_RADOSGW_KAFKA_ENDPOINT "Rados Gateway's pubsub support for Kafka push endpoint" ON) option(WITH_RADOSGW_LUA_PACKAGES "Rados Gateway's support for dynamically adding lua packagess" ON) -option(WITH_RADOSGW_DBSTORE "DBStore backend for Rados Gateway" ON) +option(WITH_RADOSGW_DBSTORE "DBStore backend for Rados Gateway" OFF) if(WITH_RADOSGW) find_package(EXPAT REQUIRED) diff --git a/src/rgw/CMakeLists.txt b/src/rgw/CMakeLists.txt index 62e95bcba1095..de7859e904a28 100644 --- a/src/rgw/CMakeLists.txt +++ b/src/rgw/CMakeLists.txt @@ -126,7 +126,6 @@ set(librgw_common_srcs rgw_role.cc rgw_sal.cc rgw_sal_rados.cc - rgw_sal_dbstore.cc rgw_string.cc rgw_tag.cc rgw_tag_s3.cc @@ -165,6 +164,10 @@ endif() if(WITH_RADOSGW_KAFKA_ENDPOINT) list(APPEND librgw_common_srcs rgw_kafka.cc) endif() +if(WITH_RADOSGW_DBSTORE) + add_subdirectory(store/dbstore) + list(APPEND librgw_common_srcs rgw_sal_dbstore.cc) +endif() add_library(rgw_common STATIC ${librgw_common_srcs}) target_link_libraries(rgw_common @@ -229,10 +232,6 @@ if(WITH_JAEGER) add_dependencies(rgw_common jaegertracing::libjaegertracing) endif() -if(WITH_RADOSGW_DBSTORE) - add_subdirectory(store/dbstore) -endif() - set(rgw_a_srcs rgw_auth_keystone.cc rgw_client_io.cc diff --git a/src/rgw/rgw_sal.cc b/src/rgw/rgw_sal.cc index d05a4a1b8261f..5559ae9dc21e2 100644 --- a/src/rgw/rgw_sal.cc +++ b/src/rgw/rgw_sal.cc @@ -24,13 +24,18 @@ #include "rgw_sal.h" #include "rgw_sal_rados.h" #include "rgw_d3n_datacache.h" + +#ifdef WITH_RADOSGW_DBSTORE #include "rgw_sal_dbstore.h" +#endif #define dout_subsys ceph_subsys_rgw extern "C" { extern rgw::sal::Store* newStore(void); -extern rgw::sal::Store* newRGWDBStore(void); +#ifdef WITH_RADOSGW_DBSTORE +extern rgw::sal::Store* newRGWDBStore(CephContext *cct); +#endif } rgw::sal::Store* StoreManager::init_storage_provider(const DoutPrefixProvider* dpp, CephContext* cct, const std::string svc, bool use_gc_thread, bool use_lc_thread, bool quota_threads, bool run_sync_thread, bool run_reshard_thread, bool use_cache, bool use_gc) @@ -72,12 +77,14 @@ rgw::sal::Store* StoreManager::init_storage_provider(const DoutPrefixProvider* d } if (svc.compare("dbstore") == 0) { - store = newRGWDBStore(); +#ifdef WITH_RADOSGW_DBSTORE + store = newRGWDBStore(cct); /* Initialize the dbstore with cct & dpp */ DBStore *db = static_cast(store)->getDBStore(); db->set_context(cct); return store; +#endif } return nullptr; @@ -105,7 +112,11 @@ rgw::sal::Store* StoreManager::init_raw_storage_provider(const DoutPrefixProvide } if (svc.compare("dbstore") == 0) { - store = newRGWDBStore(); +#ifdef WITH_RADOSGW_DBSTORE + store = newRGWDBStore(cct); +#else + store = nullptr; +#endif } return store; } diff --git a/src/rgw/rgw_sal_dbstore.cc b/src/rgw/rgw_sal_dbstore.cc index 1fa3231b28120..3d5ad098aac4a 100644 --- a/src/rgw/rgw_sal_dbstore.cc +++ b/src/rgw/rgw_sal_dbstore.cc @@ -843,11 +843,11 @@ namespace rgw::sal { extern "C" { - void *newRGWDBStore(void) + void *newRGWDBStore(CephContext *cct) { rgw::sal::RGWDBStore *store = new rgw::sal::RGWDBStore(); if (store) { - DBStoreManager *dbsm = new DBStoreManager(); + DBStoreManager *dbsm = new DBStoreManager(cct); if (!dbsm ) { delete store; store = nullptr; diff --git a/src/rgw/store/dbstore/README.md b/src/rgw/store/dbstore/README.md index b84ec727d7a28..15e214d036596 100644 --- a/src/rgw/store/dbstore/README.md +++ b/src/rgw/store/dbstore/README.md @@ -5,6 +5,9 @@ DBStore for Rados Gateway (RGW) fmt(-devel) and gtest(-devel) packages need to be installed ## Build +Add below options to cmake - +-DWITH_RADOSGW_DBSTORE=ON -DWITH_RADOSGW_LUA_PACKAGES=OFF + cd build ninja src/rgw/store/dbstore/install @@ -13,25 +16,18 @@ ninja src/rgw/store/dbstore/install To execute Gtest cases, from build directory ./bin/dbstore-tests +(default logfile: rgw_dbstore_tests.log, loglevel: 20) ## Execute Sample test file ./bin/dbstore-bin +(default logfile: rgw_dbstore_bin.log, loglevel: 20) ## Logging -Different loglevels are supported - -ERROR - 0 - -EVENT - 1 - -DEBUG - 2 - -FULLDEBUG - 3 - -By default log level is set to EVENT and logs are stored in dbstore.log - [To provide custom log file and change log level] +./dbstore-tests log_file log_level ./dbstore-bin log_file log_level +When run as RADOSGW process, logfile and loglevel are set to the +ones provided to the radosgw cmd args. diff --git a/src/rgw/store/dbstore/common/dbstore.cc b/src/rgw/store/dbstore/common/dbstore.cc index 6d55617edfed6..0587c6fdbb2d2 100644 --- a/src/rgw/store/dbstore/common/dbstore.cc +++ b/src/rgw/store/dbstore/common/dbstore.cc @@ -11,49 +11,35 @@ map DBStore::getObjectMap() { return DBStore::objectmap; } -/* Custom Logging initialization */ -ofstream fileout; -ostream *dbout; -int LogLevel = L_FULLDEBUG; -string LogFile = "dbstore.log"; +int DBStore::Initialize(string logfile, int loglevel) +{ + int ret = -1; -static void LogInit(string logfile, int loglevel) { - if (loglevel >= L_ERR && loglevel <= L_FULLDEBUG) - LogLevel = loglevel; + if (!cct) { + cout << "Failed to Initialize. No ceph Context \n"; + return -1; + } + if (loglevel > 0) { + cct->_conf->subsys.set_log_level(dout_subsys, loglevel); + } if (!logfile.empty()) { - LogFile = logfile; + cct->_log->set_log_file(logfile); + cct->_log->reopen_log_file(); } - fileout.open(LogFile); - dbout = &fileout; - - return; -} - -static void LogDestroy() { - if(dbout && (dbout != &cout)) - fileout.close(); - return; -} - -int DBStore::Initialize(string logfile, int loglevel) -{ - int ret = -1; - - LogInit(logfile, loglevel); db = openDB(); if (!db) { - dbout(L_ERR)<<"Failed to open database \n"; + dbout(cct, 0) <<"Failed to open database " << dbendl; return ret; } ret = LockInit(); if (ret) { - dbout(L_ERR)<<"Error: mutex is NULL \n"; + dbout(cct, 0) <<"Error: mutex is NULL " << dbendl; closeDB(); db = NULL; return ret; @@ -62,15 +48,15 @@ int DBStore::Initialize(string logfile, int loglevel) ret = InitializeDBOps(); if (ret) { - dbout(L_ERR)<<"InitializeDBOps failed \n"; + dbout(cct, 0) <<"InitializeDBOps failed " << dbendl; LockDestroy(); closeDB(); db = NULL; return ret; } - dbout(L_FULLDEBUG)<< "DBStore successfully initialized - name:" \ - << db_name << "\n"; + dbout(cct, 0) << "DBStore successfully initialized - name:" \ + << db_name << "" << dbendl; return ret; } @@ -86,10 +72,8 @@ int DBStore::Destroy() FreeDBOps(); - dbout(L_FULLDEBUG)<<"DBStore successfully destroyed - name:" \ - <op.bucket.info.bucket.name); if (iter == DBStore::objectmap.end()) { - dbout(L_EVENT)<<"No objectmap found for bucket: " \ - <op.bucket.info.bucket.name<<"\n"; + dbout(cct, 30)<<"No objectmap found for bucket: " \ + <op.bucket.info.bucket.name << dbendl; /* not found */ return NULL; } @@ -200,8 +184,8 @@ int DBStore::objectmapInsert(string bucket, void *ptr) // return success or replace it or // return error ? // return success for now - dbout(L_DEBUG)<<"Objectmap entry already exists for bucket("\ - <cct = cct; + //reset params here params->user_table = user_table; params->bucket_table = bucket_table; @@ -261,7 +247,7 @@ int DBStore::ProcessOp(string Op, struct DBOpParams *params) { db_op = getDBOp(Op, params); if (!db_op) { - dbout(L_ERR)<<"No db_op found for Op("<read_version.ver != obj_ver.ver)) { /* Object version mismatch.. return ECANCELED */ ret = -ECANCELED; - dbout(L_ERR)<<"User Read version mismatch err:(" <read_version.ver != objv_tracker.read_version.ver)) { /* Object version mismatch.. return ECANCELED */ ret = -ECANCELED; - dbout(L_ERR)<<"User Read version mismatch err:(" <add(std::move(entry)); - /* cout << "entry.bucket.marker: " << entry.bucket.marker << " min_marker: " << marker; - - if (entry.bucket.marker < marker) { - cout << " lesser" << "\n"; - } else if (entry.bucket.marker > marker) { - cout << " greater" << "\n"; - } else { - cout << " equal" << "\n"; - } */ } out: return ret; @@ -660,7 +637,7 @@ int DBStore::update_bucket(const std::string& query_str, &bucket_version); if (ret) { - dbout(L_ERR)<<"Failed to read bucket info err:(" <read_version.ver != bucket_version.ver) { - dbout(L_ERR)<<"Read version mismatch err:(" <quota_table.c_str()); - dbout(L_ERR)<<"Incorrect table type("<cct, 0) << "Incorrect table type("< #include #include +#include "common/dout.h" using namespace std; -#define L_ERR 0 -#define L_EVENT 1 // Default LogLevel -#define L_DEBUG 2 -#define L_FULLDEBUG 3 +#define dout_subsys ceph_subsys_rgw +#undef dout_prefix +#define dout_prefix *_dout << "rgw dbstore: " -extern int LogLevel; -extern string LogFile; -extern ofstream fileout; -extern ostream *dbout; +#define dbout_prefix(cct, v) dout_impl(cct, dout_subsys, v) dout_prefix +#define dbendl_impl dendl -#define dbout_prefix *dbout<<__PRETTY_FUNCTION__<<":-" - -#define dbout(n) if (n <= LogLevel) dbout_prefix +#define dbout(cct, v) dbout_prefix(cct, v) +#define dbendl dbendl_impl #endif diff --git a/src/rgw/store/dbstore/dbstore_main.cc b/src/rgw/store/dbstore/dbstore_main.cc index ad9801bfc5fb2..c2f09f16dd992 100644 --- a/src/rgw/store/dbstore/dbstore_main.cc +++ b/src/rgw/store/dbstore/dbstore_main.cc @@ -13,8 +13,6 @@ struct thr_args { int thr_id; }; -int loglevel = L_FULLDEBUG; - void* process(void *arg) { struct thr_args *t_args = (struct thr_args*)arg; @@ -23,7 +21,7 @@ void* process(void *arg) int thr_id = t_args->thr_id; int ret = -1; - dbout(L_EVENT)<<"Entered thread:"<ListAllUsers(¶ms); db->ListAllBuckets(¶ms); - dbout(L_EVENT)<<"Exiting thread:"<getDBStore(tenant, true); - dbout(L_EVENT)<<"No. of threads being created = "<destroyAllHandles(); return 0; } diff --git a/src/rgw/store/dbstore/dbstore_mgr.cc b/src/rgw/store/dbstore/dbstore_mgr.cc index 26c4240817213..9a96c5c3faa5a 100644 --- a/src/rgw/store/dbstore/dbstore_mgr.cc +++ b/src/rgw/store/dbstore/dbstore_mgr.cc @@ -2,9 +2,6 @@ // vim: ts=8 sw=2 smarttab #include "dbstore_mgr.h" -#include "common/dbstore.h" -#include "sqlite/sqliteDB.h" - /* Given a tenant, find and return the DBStore handle. * If not found and 'create' set to true, create one @@ -43,9 +40,9 @@ DBStore* DBStoreManager::createDBStore(string tenant) { /* Create the handle */ #ifdef SQLITE_ENABLED - dbs = new SQLiteDB(tenant); + dbs = new SQLiteDB(tenant, cct); #else - dbs = new DBStore(tenant); + dbs = new DBStore(tenant, cct); #endif /* API is DBStore::Initialize(string logfile, int loglevel); diff --git a/src/rgw/store/dbstore/dbstore_mgr.h b/src/rgw/store/dbstore/dbstore_mgr.h index 780de2dd5851b..307efd8ba9e12 100644 --- a/src/rgw/store/dbstore/dbstore_mgr.h +++ b/src/rgw/store/dbstore/dbstore_mgr.h @@ -9,6 +9,9 @@ #include #include #include +#include "common/ceph_context.h" +#include "common/dbstore.h" +#include "sqlite/sqliteDB.h" using namespace std; @@ -22,11 +25,21 @@ class DBStoreManager { private: map DBStoreHandles; DBStore *default_dbstore = NULL; + CephContext *cct; public: - DBStoreManager(): DBStoreHandles() { + DBStoreManager(CephContext *_cct): DBStoreHandles() { + cct = _cct; default_dbstore = createDBStore(default_tenant); }; + DBStoreManager(string logfile, int loglevel): DBStoreHandles() { + vector args; + cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, + CODE_ENVIRONMENT_UTILITY, 1)->get(); + cct->_log->set_log_file(logfile); + cct->_log->reopen_log_file(); + cct->_conf->subsys.set_log_level(dout_subsys, loglevel); + }; ~DBStoreManager() { destroyAllHandles(); }; /* XXX: TBD based on testing diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.cc b/src/rgw/store/dbstore/sqlite/sqliteDB.cc index f3daf12972a44..136aa17f78f4f 100644 --- a/src/rgw/store/dbstore/sqlite/sqliteDB.cc +++ b/src/rgw/store/dbstore/sqlite/sqliteDB.cc @@ -3,109 +3,109 @@ #include "sqliteDB.h" -#define SQL_PREPARE(params, sdb, stmt, ret, Op) \ +#define SQL_PREPARE(cct, params, sdb, stmt, ret, Op) \ do { \ string schema; \ schema = Schema(params); \ sqlite3_prepare_v2 (*sdb, schema.c_str(), \ -1, &stmt , NULL); \ if (!stmt) { \ - cout<<"failed to prepare statement " \ + dbout(cct, 0) <<"failed to prepare statement " \ <<"for Op("<(blob), blob_len); \ \ @@ -119,13 +119,13 @@ } \ \ if (!stmt) { \ - cout<<"No prepared statement \n"; \ + dbout(cct, 0) <<"No prepared statement "<< dbendl; \ goto out; \ } \ \ ret = Bind(params); \ if (ret) { \ - cout<<"Bind parameters failed for stmt(" <db); - dbops.RemoveUser = new SQLRemoveUser(&this->db); - dbops.GetUser = new SQLGetUser(&this->db); - dbops.InsertBucket = new SQLInsertBucket(&this->db); - dbops.UpdateBucket = new SQLUpdateBucket(&this->db); - dbops.RemoveBucket = new SQLRemoveBucket(&this->db); - dbops.GetBucket = new SQLGetBucket(&this->db); - dbops.ListUserBuckets = new SQLListUserBuckets(&this->db); + dbops.InsertUser = new SQLInsertUser(&this->db, cct); + dbops.RemoveUser = new SQLRemoveUser(&this->db, cct); + dbops.GetUser = new SQLGetUser(&this->db, cct); + dbops.InsertBucket = new SQLInsertBucket(&this->db, cct); + dbops.UpdateBucket = new SQLUpdateBucket(&this->db, cct); + dbops.RemoveBucket = new SQLRemoveBucket(&this->db, cct); + dbops.GetBucket = new SQLGetBucket(&this->db, cct); + dbops.ListUserBuckets = new SQLListUserBuckets(&this->db, cct); return 0; } @@ -413,9 +413,9 @@ void *SQLiteDB::openDB() string dbname; int rc = 0; - dbname = getDBname(); + dbname = getDBname(); if (dbname.empty()) { - dbout(L_ERR)<<"dbname is NULL\n"; + dbout(cct, 0)<<"dbname is NULL" << dbendl; goto out; } @@ -426,10 +426,10 @@ void *SQLiteDB::openDB() NULL); if (rc) { - dbout(L_ERR)<<"Cant open "<user_table); - cout<<"########### Listing all Users #############\n"; + // cout<<"########### Listing all Users #############" << dbendl; ret = exec(schema.c_str(), &list_callback); if (ret) - dbout(L_ERR)<<"GetUsertable failed \n"; + dbout(cct, 0)<<"GetUsertable failed " << dbendl; - dbout(L_FULLDEBUG)<<"GetUserTable suceeded \n"; + dbout(cct, 20)<<"GetUserTable suceeded " << dbendl; return ret; } @@ -712,12 +712,12 @@ int SQLiteDB::ListAllBuckets(DBOpParams *params) schema = ListTableSchema(params->bucket_table); - cout<<"########### Listing all Buckets #############\n"; +// cout<<"########### Listing all Buckets #############" << dbendl; ret = exec(schema.c_str(), &list_callback); if (ret) - dbout(L_ERR)<<"Listbuckettable failed \n"; + dbout(cct, 0)<<"Listbuckettable failed " << dbendl; - dbout(L_FULLDEBUG)<<"ListbucketTable suceeded \n"; + dbout(cct, 20)<<"ListbucketTable suceeded " << dbendl; return ret; } @@ -730,12 +730,12 @@ int SQLiteDB::ListAllObjects(DBOpParams *params) map objectmap; string bucket; - cout<<"########### Listing all Objects #############\n"; + //cout<<"########### Listing all Objects #############" << dbendl; objectmap = getObjectMap(); if (objectmap.empty()) - dbout(L_DEBUG)<<"objectmap empty \n"; + dbout(cct, 20)<<"objectmap empty " << dbendl; for (iter = objectmap.begin(); iter != objectmap.end(); ++iter) { bucket = iter->first; @@ -745,9 +745,9 @@ int SQLiteDB::ListAllObjects(DBOpParams *params) ret = exec(schema.c_str(), &list_callback); if (ret) - dbout(L_ERR)<<"ListObjecttable failed \n"; + dbout(cct, 0)<<"ListObjecttable failed " << dbendl; - dbout(L_FULLDEBUG)<<"ListObjectTable suceeded \n"; + dbout(cct, 20)<<"ListObjectTable suceeded " << dbendl; } return ret; @@ -755,12 +755,12 @@ int SQLiteDB::ListAllObjects(DBOpParams *params) int SQLObjectOp::InitializeObjectOps() { - InsertObject = new SQLInsertObject(sdb); - RemoveObject = new SQLRemoveObject(sdb); - ListObject = new SQLListObject(sdb); - PutObjectData = new SQLPutObjectData(sdb); - GetObjectData = new SQLGetObjectData(sdb); - DeleteObjectData = new SQLDeleteObjectData(sdb); + InsertObject = new SQLInsertObject(sdb, cct); + RemoveObject = new SQLRemoveObject(sdb, cct); + ListObject = new SQLListObject(sdb, cct); + PutObjectData = new SQLPutObjectData(sdb, cct); + GetObjectData = new SQLGetObjectData(sdb, cct); + DeleteObjectData = new SQLDeleteObjectData(sdb, cct); return 0; } @@ -783,13 +783,13 @@ int SQLInsertUser::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLInsertUser - no db\n"; + dbout(cct, 0)<<"In SQLInsertUser - no db" << dbendl; goto out; } p_params.user_table = params->user_table; - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareInsertUser"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareInsertUser"); out: return ret; } @@ -800,20 +800,20 @@ int SQLInsertUser::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.op.user.tenant.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.tenant.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.ns.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.ns.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.display_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.display_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.display_name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.display_name.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_email.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_email.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_email.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_email.c_str(), sdb); if (!params->op.user.uinfo.access_keys.empty()) { string access_key; @@ -824,75 +824,75 @@ int SQLInsertUser::Bind(struct DBOpParams *params) access_key = k.id; key = k.key; - SQL_BIND_INDEX(stmt, index, p_params.op.user.access_keys_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, access_key.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.access_keys_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, access_key.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.access_keys_secret.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, key.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.access_keys_secret.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, key.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.access_keys.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.access_keys, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.access_keys.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.access_keys, sdb); } - SQL_BIND_INDEX(stmt, index, p_params.op.user.swift_keys.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.swift_keys, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.swift_keys.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.swift_keys, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.subusers.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.subusers, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.subusers.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.subusers, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.suspended.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.user.uinfo.suspended, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.suspended.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.suspended, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.max_buckets.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.user.uinfo.max_buckets, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.max_buckets.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.max_buckets, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.op_mask.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.user.uinfo.op_mask, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.op_mask.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.op_mask, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_caps.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.caps, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_caps.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.caps, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.admin.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.user.uinfo.admin, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.admin.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.admin, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.system.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.user.uinfo.system, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.system.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.system, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.placement_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.default_placement.name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.placement_name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.default_placement.name.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.placement_storage_class.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.default_placement.storage_class.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.placement_storage_class.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.default_placement.storage_class.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.placement_tags.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.placement_tags, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.placement_tags.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.placement_tags, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.bucket_quota.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.bucket_quota, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.bucket_quota.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.bucket_quota, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.temp_url_keys.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.temp_url_keys, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.temp_url_keys.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.temp_url_keys, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_quota.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.user_quota, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_quota.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.user_quota, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.type.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.user.uinfo.type, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.type.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.user.uinfo.type, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.mfa_ids.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.uinfo.mfa_ids, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.mfa_ids.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.uinfo.mfa_ids, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.assumed_role_arn.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.assumed_role_arn.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.assumed_role_arn.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.assumed_role_arn.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_attrs.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.user.user_attrs, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_attrs.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.user.user_attrs, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_ver.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.user.user_version.ver, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_ver.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.user.user_version.ver, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_ver_tag.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.user_version.tag.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_ver_tag.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.user_version.tag.c_str(), sdb); out: return rc; @@ -913,13 +913,13 @@ int SQLRemoveUser::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLRemoveUser - no db\n"; + dbout(cct, 0)<<"In SQLRemoveUser - no db" << dbendl; goto out; } p_params.user_table = params->user_table; - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareRemoveUser"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareRemoveUser"); out: return ret; } @@ -930,8 +930,8 @@ int SQLRemoveUser::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); out: return rc; @@ -952,7 +952,7 @@ int SQLGetUser::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLGetUser - no db\n"; + dbout(cct, 0)<<"In SQLGetUser - no db" << dbendl; goto out; } @@ -960,13 +960,13 @@ int SQLGetUser::Prepare(struct DBOpParams *params) p_params.op.query_str = params->op.query_str; if (params->op.query_str == "email") { - SQL_PREPARE(p_params, sdb, email_stmt, ret, "PrepareGetUser"); + SQL_PREPARE(ctx(), p_params, sdb, email_stmt, ret, "PrepareGetUser"); } else if (params->op.query_str == "access_key") { - SQL_PREPARE(p_params, sdb, ak_stmt, ret, "PrepareGetUser"); + SQL_PREPARE(ctx(), p_params, sdb, ak_stmt, ret, "PrepareGetUser"); } else if (params->op.query_str == "user_id") { - SQL_PREPARE(p_params, sdb, userid_stmt, ret, "PrepareGetUser"); + SQL_PREPARE(ctx(), p_params, sdb, userid_stmt, ret, "PrepareGetUser"); } else { // by default by userid - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareGetUser"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareGetUser"); } out: return ret; @@ -979,8 +979,8 @@ int SQLGetUser::Bind(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (params->op.query_str == "email") { - SQL_BIND_INDEX(email_stmt, index, p_params.op.user.user_email.c_str(), sdb); - SQL_BIND_TEXT(email_stmt, index, params->op.user.uinfo.user_email.c_str(), sdb); + SQL_BIND_INDEX(ctx(), email_stmt, index, p_params.op.user.user_email.c_str(), sdb); + SQL_BIND_TEXT(ctx(), email_stmt, index, params->op.user.uinfo.user_email.c_str(), sdb); } else if (params->op.query_str == "access_key") { if (!params->op.user.uinfo.access_keys.empty()) { string access_key; @@ -989,21 +989,21 @@ int SQLGetUser::Bind(struct DBOpParams *params) const RGWAccessKey& k = it->second; access_key = k.id; - SQL_BIND_INDEX(ak_stmt, index, p_params.op.user.access_keys_id.c_str(), sdb); - SQL_BIND_TEXT(ak_stmt, index, access_key.c_str(), sdb); + SQL_BIND_INDEX(ctx(), ak_stmt, index, p_params.op.user.access_keys_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), ak_stmt, index, access_key.c_str(), sdb); } } else if (params->op.query_str == "user_id") { - SQL_BIND_INDEX(userid_stmt, index, p_params.op.user.tenant.c_str(), sdb); - SQL_BIND_TEXT(userid_stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb); + SQL_BIND_INDEX(ctx(), userid_stmt, index, p_params.op.user.tenant.c_str(), sdb); + SQL_BIND_TEXT(ctx(), userid_stmt, index, params->op.user.uinfo.user_id.tenant.c_str(), sdb); - SQL_BIND_INDEX(userid_stmt, index, p_params.op.user.user_id.c_str(), sdb); - SQL_BIND_TEXT(userid_stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), userid_stmt, index, p_params.op.user.user_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), userid_stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); - SQL_BIND_INDEX(userid_stmt, index, p_params.op.user.ns.c_str(), sdb); - SQL_BIND_TEXT(userid_stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb); + SQL_BIND_INDEX(ctx(), userid_stmt, index, p_params.op.user.ns.c_str(), sdb); + SQL_BIND_TEXT(ctx(), userid_stmt, index, params->op.user.uinfo.user_id.ns.c_str(), sdb); } else { // by default by userid - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); } out: @@ -1034,13 +1034,13 @@ int SQLInsertBucket::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLInsertBucket - no db\n"; + dbout(cct, 0)<<"In SQLInsertBucket - no db" << dbendl; goto out; } p_params.bucket_table = params->bucket_table; - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareInsertBucket"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareInsertBucket"); out: return ret; @@ -1052,89 +1052,89 @@ int SQLInsertBucket::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.tenant.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.tenant.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.marker.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.marker.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.size.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.ent.size, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.size.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.ent.size, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.size_rounded.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.ent.size_rounded, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.size_rounded.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.ent.size_rounded, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.creation_time.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.info.creation_time, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.creation_time.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.creation_time, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.count.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.ent.count, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.count.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.ent.count, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.placement_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.placement_name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.flags.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.info.flags, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.flags.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.flags, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.info.has_instance_obj, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.has_instance_obj, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.quota.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.info.quota, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.quota.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.quota, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.info.requester_pays, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.requester_pays, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.has_website.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.info.has_website, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.has_website.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.has_website, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.website_conf.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.info.website_conf, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.website_conf.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.website_conf, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.info.swift_versioning, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.info.swift_versioning, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.info.mdsearch_config, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.mdsearch_config, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.info.obj_lock, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.obj_lock, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.info.sync_policy, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.info.sync_policy, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.bucket_attrs, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.bucket_attrs, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.bucket.bucket_version.ver, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.bucket.bucket_version.ver, sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_ver_tag.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.bucket_version.tag.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_ver_tag.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.bucket_version.tag.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.mtime.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(stmt, index, params->op.bucket.mtime, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.mtime.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), stmt, index, params->op.bucket.mtime, sdb); out: return rc; @@ -1146,7 +1146,7 @@ int SQLInsertBucket::Execute(struct DBOpParams *params) class SQLObjectOp *ObPtr = NULL; string bucket_name = params->op.bucket.info.bucket.name; - ObPtr = new SQLObjectOp(sdb); + ObPtr = new SQLObjectOp(sdb, ctx()); objectmapInsert(bucket_name, ObPtr); @@ -1165,7 +1165,7 @@ int SQLUpdateBucket::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLUpdateBucket - no db\n"; + dbout(cct, 0)<<"In SQLUpdateBucket - no db" << dbendl; goto out; } @@ -1173,14 +1173,14 @@ int SQLUpdateBucket::Prepare(struct DBOpParams *params) p_params.bucket_table = params->bucket_table; if (params->op.query_str == "attrs") { - SQL_PREPARE(p_params, sdb, attrs_stmt, ret, "PrepareUpdateBucket"); + SQL_PREPARE(ctx(), p_params, sdb, attrs_stmt, ret, "PrepareUpdateBucket"); } else if (params->op.query_str == "owner") { - SQL_PREPARE(p_params, sdb, owner_stmt, ret, "PrepareUpdateBucket"); + SQL_PREPARE(ctx(), p_params, sdb, owner_stmt, ret, "PrepareUpdateBucket"); } else if (params->op.query_str == "info") { - SQL_PREPARE(p_params, sdb, info_stmt, ret, "PrepareUpdateBucket"); + SQL_PREPARE(ctx(), p_params, sdb, info_stmt, ret, "PrepareUpdateBucket"); } else { - dbout(L_ERR)<<"In SQLUpdateBucket invalid query_str:" << - params->op.query_str << "\n"; + dbout(cct, 0)<<"In SQLUpdateBucket invalid query_str:" << + params->op.query_str << "" << dbendl; goto out; } @@ -1203,90 +1203,90 @@ int SQLUpdateBucket::Bind(struct DBOpParams *params) } else if (params->op.query_str == "info") { stmt = &info_stmt; } else { - dbout(L_ERR)<<"In SQLUpdateBucket invalid query_str:" << - params->op.query_str << "\n"; + dbout(cct, 0)<<"In SQLUpdateBucket invalid query_str:" << + params->op.query_str << "" << dbendl; goto out; } if (params->op.query_str == "attrs") { - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.bucket_attrs, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_attrs.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.bucket_attrs, sdb); } else if (params->op.query_str == "owner") { - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.creation_time.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.info.creation_time, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.creation_time.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.creation_time, sdb); } else if (params->op.query_str == "info") { - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.tenant.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.tenant.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.tenant.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.marker.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.marker.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.marker.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.bucket_id.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.creation_time.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.info.creation_time, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.creation_time.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.creation_time, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.count.c_str(), sdb); - SQL_BIND_INT(*stmt, index, params->op.bucket.ent.count, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.count.c_str(), sdb); + SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.ent.count, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.placement_name.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.placement_name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.placement_rule.name.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.placement_storage_class.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.placement_rule.storage_class.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.flags.c_str(), sdb); - SQL_BIND_INT(*stmt, index, params->op.bucket.info.flags, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.flags.c_str(), sdb); + SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.flags, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.zonegroup.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.zonegroup.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb); - SQL_BIND_INT(*stmt, index, params->op.bucket.info.has_instance_obj, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.has_instance_obj.c_str(), sdb); + SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.has_instance_obj, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.quota.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.info.quota, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.quota.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.quota, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb); - SQL_BIND_INT(*stmt, index, params->op.bucket.info.requester_pays, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.requester_pays.c_str(), sdb); + SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.requester_pays, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.has_website.c_str(), sdb); - SQL_BIND_INT(*stmt, index, params->op.bucket.info.has_website, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.has_website.c_str(), sdb); + SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.has_website, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.website_conf.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.info.website_conf, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.website_conf.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.website_conf, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb); - SQL_BIND_INT(*stmt, index, params->op.bucket.info.swift_versioning, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.swift_versioning.c_str(), sdb); + SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.info.swift_versioning, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.swift_ver_location.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.swift_ver_location.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.info.mdsearch_config, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.mdsearch_config.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.mdsearch_config, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.new_bucket_instance_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.new_bucket_instance_id.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.info.obj_lock, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.obj_lock.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.obj_lock, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.info.sync_policy, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.sync_policy_info_groups.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.info.sync_policy, sdb); } - SQL_BIND_INDEX(*stmt, index, p_params.op.user.user_id.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.user.user_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(*stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), *stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb); - SQL_BIND_INT(*stmt, index, params->op.bucket.bucket_version.ver, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.bucket_ver.c_str(), sdb); + SQL_BIND_INT(ctx(), *stmt, index, params->op.bucket.bucket_version.ver, sdb); - SQL_BIND_INDEX(*stmt, index, p_params.op.bucket.mtime.c_str(), sdb); - SQL_ENCODE_BLOB_PARAM(*stmt, index, params->op.bucket.mtime, sdb); + SQL_BIND_INDEX(ctx(), *stmt, index, p_params.op.bucket.mtime.c_str(), sdb); + SQL_ENCODE_BLOB_PARAM(ctx(), *stmt, index, params->op.bucket.mtime, sdb); out: return rc; @@ -1304,8 +1304,8 @@ int SQLUpdateBucket::Execute(struct DBOpParams *params) } else if (params->op.query_str == "info") { stmt = &info_stmt; } else { - dbout(L_ERR)<<"In SQLUpdateBucket invalid query_str:" << - params->op.query_str << "\n"; + dbout(cct, 0)<<"In SQLUpdateBucket invalid query_str:" << + params->op.query_str << "" << dbendl; goto out; } @@ -1320,13 +1320,13 @@ int SQLRemoveBucket::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLRemoveBucket - no db\n"; + dbout(cct, 0)<<"In SQLRemoveBucket - no db" << dbendl; goto out; } p_params.bucket_table = params->bucket_table; - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareRemoveBucket"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareRemoveBucket"); out: return ret; @@ -1338,9 +1338,9 @@ int SQLRemoveBucket::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); out: return rc; @@ -1363,14 +1363,14 @@ int SQLGetBucket::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLGetBucket - no db\n"; + dbout(cct, 0)<<"In SQLGetBucket - no db" << dbendl; goto out; } p_params.bucket_table = params->bucket_table; p_params.user_table = params->user_table; - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareGetBucket"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareGetBucket"); out: return ret; @@ -1382,9 +1382,9 @@ int SQLGetBucket::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); out: return rc; @@ -1406,13 +1406,13 @@ int SQLListUserBuckets::Prepare(struct DBOpParams *params) struct DBOpPrepareParams p_params = PrepareParams; if (!*sdb) { - dbout(L_ERR)<<"In SQLListUserBuckets - no db\n"; + dbout(cct, 0)<<"In SQLListUserBuckets - no db" << dbendl; goto out; } p_params.bucket_table = params->bucket_table; - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareListUserBuckets"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareListUserBuckets"); out: return ret; @@ -1424,14 +1424,14 @@ int SQLListUserBuckets::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.op.user.user_id.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.user.user_id.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.user.uinfo.user_id.id.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.min_marker.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.min_marker.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.min_marker.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.min_marker.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.list_max_count.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->op.list_max_count, sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.list_max_count.c_str(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->op.list_max_count, sdb); out: return rc; @@ -1454,14 +1454,14 @@ int SQLInsertObject::Prepare(struct DBOpParams *params) string bucket_name; if (!*sdb) { - dbout(L_ERR)<<"In SQLInsertObject - no db\n"; + dbout(cct, 0)<<"In SQLInsertObject - no db" << dbendl; goto out; } bucket_name = params->op.bucket.info.bucket.name; p_params.object_table = bucket_name + ".object.table"; - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareInsertObject"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareInsertObject"); out: return ret; @@ -1473,13 +1473,13 @@ int SQLInsertObject::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.object.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->object.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); out: return rc; @@ -1502,7 +1502,7 @@ int SQLRemoveObject::Prepare(struct DBOpParams *params) string bucket_name; if (!*sdb) { - dbout(L_ERR)<<"In SQLRemoveObject - no db\n"; + dbout(cct, 0)<<"In SQLRemoveObject - no db" << dbendl; goto out; } @@ -1512,7 +1512,7 @@ int SQLRemoveObject::Prepare(struct DBOpParams *params) (void)createObjectTable(©); - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareRemoveObject"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareRemoveObject"); out: return ret; @@ -1524,13 +1524,13 @@ int SQLRemoveObject::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.object.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->object.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); out: return rc; @@ -1553,7 +1553,7 @@ int SQLListObject::Prepare(struct DBOpParams *params) string bucket_name; if (!*sdb) { - dbout(L_ERR)<<"In SQLListObject - no db\n"; + dbout(cct, 0)<<"In SQLListObject - no db" << dbendl; goto out; } @@ -1564,7 +1564,7 @@ int SQLListObject::Prepare(struct DBOpParams *params) (void)createObjectTable(©); - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareListObject"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareListObject"); out: return ret; @@ -1576,13 +1576,13 @@ int SQLListObject::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.object.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->object.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); out: return rc; @@ -1605,7 +1605,7 @@ int SQLPutObjectData::Prepare(struct DBOpParams *params) string bucket_name; if (!*sdb) { - dbout(L_ERR)<<"In SQLPutObjectData - no db\n"; + dbout(cct, 0)<<"In SQLPutObjectData - no db" << dbendl; goto out; } @@ -1617,7 +1617,7 @@ int SQLPutObjectData::Prepare(struct DBOpParams *params) (void)createObjectDataTable(©); - SQL_PREPARE(p_params, sdb, stmt, ret, "PreparePutObjectData"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PreparePutObjectData"); out: return ret; @@ -1629,25 +1629,25 @@ int SQLPutObjectData::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.object.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->object.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.offset.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.offset.c_str(), sdb); - SQL_BIND_INT(stmt, 3, params->offset, sdb); + SQL_BIND_INT(ctx(), stmt, 3, params->offset, sdb); - SQL_BIND_INDEX(stmt, index, p_params.data.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.data.c_str(), sdb); - SQL_BIND_BLOB(stmt, index, params->data.c_str(), params->data.length(), sdb); + SQL_BIND_BLOB(ctx(), stmt, index, params->data.c_str(), params->data.length(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.datalen.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.datalen.c_str(), sdb); - SQL_BIND_INT(stmt, index, params->data.length(), sdb); + SQL_BIND_INT(ctx(), stmt, index, params->data.length(), sdb); out: return rc; @@ -1670,7 +1670,7 @@ int SQLGetObjectData::Prepare(struct DBOpParams *params) string bucket_name; if (!*sdb) { - dbout(L_ERR)<<"In SQLGetObjectData - no db\n"; + dbout(cct, 0)<<"In SQLGetObjectData - no db" << dbendl; goto out; } @@ -1682,7 +1682,7 @@ int SQLGetObjectData::Prepare(struct DBOpParams *params) (void)createObjectDataTable(©); - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareGetObjectData"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareGetObjectData"); out: return ret; @@ -1694,13 +1694,13 @@ int SQLGetObjectData::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.object.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->object.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); out: return rc; } @@ -1722,7 +1722,7 @@ int SQLDeleteObjectData::Prepare(struct DBOpParams *params) string bucket_name; if (!*sdb) { - dbout(L_ERR)<<"In SQLDeleteObjectData - no db\n"; + dbout(cct, 0)<<"In SQLDeleteObjectData - no db" << dbendl; goto out; } @@ -1734,7 +1734,7 @@ int SQLDeleteObjectData::Prepare(struct DBOpParams *params) (void)createObjectDataTable(©); - SQL_PREPARE(p_params, sdb, stmt, ret, "PrepareDeleteObjectData"); + SQL_PREPARE(ctx(), p_params, sdb, stmt, ret, "PrepareDeleteObjectData"); out: return ret; @@ -1746,13 +1746,13 @@ int SQLDeleteObjectData::Bind(struct DBOpParams *params) int rc = 0; struct DBOpPrepareParams p_params = PrepareParams; - SQL_BIND_INDEX(stmt, index, p_params.object.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.object.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->object.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->object.c_str(), sdb); - SQL_BIND_INDEX(stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); + SQL_BIND_INDEX(ctx(), stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb); - SQL_BIND_TEXT(stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); + SQL_BIND_TEXT(ctx(), stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb); out: return rc; } diff --git a/src/rgw/store/dbstore/sqlite/sqliteDB.h b/src/rgw/store/dbstore/sqlite/sqliteDB.h index 70408d80e7483..828595ce0b4f3 100644 --- a/src/rgw/store/dbstore/sqlite/sqliteDB.h +++ b/src/rgw/store/dbstore/sqlite/sqliteDB.h @@ -16,15 +16,20 @@ class SQLiteDB : public DBStore, public DBOp{ private: sqlite3_mutex *mutex = NULL; + protected: + CephContext *cct; + public: sqlite3_stmt *stmt = NULL; DBOpPrepareParams PrepareParams; - SQLiteDB(string db_name) : DBStore(db_name) { + SQLiteDB(string db_name, CephContext *_cct) : DBStore(db_name, _cct) { + cct = _cct; InitPrepareParams(PrepareParams); } - SQLiteDB(sqlite3 *dbi) : DBStore() { + SQLiteDB(sqlite3 *dbi, CephContext *_cct) : DBStore(_cct) { db = (void*)dbi; + cct = _cct; InitPrepareParams(PrepareParams); } ~SQLiteDB() {} @@ -34,14 +39,13 @@ class SQLiteDB : public DBStore, public DBOp{ void *openDB(); int closeDB(); int Step(DBOpInfo &op, sqlite3_stmt *stmt, - int (*cbk)(DBOpInfo &op, sqlite3_stmt *stmt)); + int (*cbk)(CephContext *cct, DBOpInfo &op, sqlite3_stmt *stmt)); int Reset(sqlite3_stmt *stmt); int InitializeDBOps(); int FreeDBOps(); /* default value matches with sqliteDB style */ int InitPrepareParams(DBOpPrepareParams ¶ms) { return 0; } - int createTables(); int createBucketTable(DBOpParams *params); int createUserTable(DBOpParams *params); @@ -62,9 +66,10 @@ class SQLiteDB : public DBStore, public DBOp{ class SQLObjectOp : public ObjectOp { private: sqlite3 **sdb = NULL; + CephContext *cct; public: - SQLObjectOp(sqlite3 **sdbi) : sdb(sdbi) {}; + SQLObjectOp(sqlite3 **sdbi, CephContext *_cct) : sdb(sdbi), cct(_cct) {}; ~SQLObjectOp() {} int InitializeObjectOps(); @@ -77,7 +82,7 @@ class SQLInsertUser : public SQLiteDB, public InsertUserOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLInsertUser(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLInsertUser(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLInsertUser() { if (stmt) sqlite3_finalize(stmt); @@ -93,7 +98,7 @@ class SQLRemoveUser : public SQLiteDB, public RemoveUserOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLRemoveUser(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLRemoveUser(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLRemoveUser() { if (stmt) sqlite3_finalize(stmt); @@ -112,7 +117,7 @@ class SQLGetUser : public SQLiteDB, public GetUserOp { sqlite3_stmt *userid_stmt = NULL; // Prepared statement to query by user_id public: - SQLGetUser(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLGetUser(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLGetUser() { if (stmt) sqlite3_finalize(stmt); @@ -134,7 +139,7 @@ class SQLInsertBucket : public SQLiteDB, public InsertBucketOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLInsertBucket(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLInsertBucket(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLInsertBucket() { if (stmt) sqlite3_finalize(stmt); @@ -152,7 +157,7 @@ class SQLUpdateBucket : public SQLiteDB, public UpdateBucketOp { sqlite3_stmt *owner_stmt = NULL; // Prepared statement public: - SQLUpdateBucket(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLUpdateBucket(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLUpdateBucket() { if (info_stmt) sqlite3_finalize(info_stmt); @@ -172,7 +177,7 @@ class SQLRemoveBucket : public SQLiteDB, public RemoveBucketOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLRemoveBucket(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLRemoveBucket(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLRemoveBucket() { if (stmt) sqlite3_finalize(stmt); @@ -188,7 +193,7 @@ class SQLGetBucket : public SQLiteDB, public GetBucketOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLGetBucket(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLGetBucket(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLGetBucket() { if (stmt) sqlite3_finalize(stmt); @@ -204,7 +209,7 @@ class SQLListUserBuckets : public SQLiteDB, public ListUserBucketsOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLListUserBuckets(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} + SQLListUserBuckets(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} ~SQLListUserBuckets() { if (stmt) sqlite3_finalize(stmt); @@ -220,8 +225,8 @@ class SQLInsertObject : public SQLiteDB, public InsertObjectOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLInsertObject(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} - SQLInsertObject(sqlite3 **sdbi) : SQLiteDB(*sdbi), sdb(sdbi) {} + SQLInsertObject(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} + SQLInsertObject(sqlite3 **sdbi, CephContext *cct) : SQLiteDB(*sdbi, cct), sdb(sdbi) {} ~SQLInsertObject() { if (stmt) @@ -238,8 +243,8 @@ class SQLRemoveObject : public SQLiteDB, public RemoveObjectOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLRemoveObject(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} - SQLRemoveObject(sqlite3 **sdbi) : SQLiteDB(*sdbi), sdb(sdbi) {} + SQLRemoveObject(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} + SQLRemoveObject(sqlite3 **sdbi, CephContext *cct) : SQLiteDB(*sdbi, cct), sdb(sdbi) {} ~SQLRemoveObject() { if (stmt) @@ -256,8 +261,8 @@ class SQLListObject : public SQLiteDB, public ListObjectOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLListObject(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} - SQLListObject(sqlite3 **sdbi) : SQLiteDB(*sdbi), sdb(sdbi) {} + SQLListObject(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} + SQLListObject(sqlite3 **sdbi, CephContext *cct) : SQLiteDB(*sdbi, cct), sdb(sdbi) {} ~SQLListObject() { if (stmt) @@ -274,8 +279,8 @@ class SQLPutObjectData : public SQLiteDB, public PutObjectDataOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLPutObjectData(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} - SQLPutObjectData(sqlite3 **sdbi) : SQLiteDB(*sdbi), sdb(sdbi) {} + SQLPutObjectData(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} + SQLPutObjectData(sqlite3 **sdbi, CephContext *cct) : SQLiteDB(*sdbi, cct), sdb(sdbi) {} ~SQLPutObjectData() { if (stmt) @@ -292,8 +297,8 @@ class SQLGetObjectData : public SQLiteDB, public GetObjectDataOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLGetObjectData(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} - SQLGetObjectData(sqlite3 **sdbi) : SQLiteDB(*sdbi), sdb(sdbi) {} + SQLGetObjectData(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} + SQLGetObjectData(sqlite3 **sdbi, CephContext *cct) : SQLiteDB(*sdbi, cct), sdb(sdbi) {} ~SQLGetObjectData() { if (stmt) @@ -310,8 +315,8 @@ class SQLDeleteObjectData : public SQLiteDB, public DeleteObjectDataOp { sqlite3_stmt *stmt = NULL; // Prepared statement public: - SQLDeleteObjectData(void **db) : SQLiteDB((sqlite3 *)(*db)), sdb((sqlite3 **)db) {} - SQLDeleteObjectData(sqlite3 **sdbi) : SQLiteDB(*sdbi), sdb(sdbi) {} + SQLDeleteObjectData(void **db, CephContext *cct) : SQLiteDB((sqlite3 *)(*db), cct), sdb((sqlite3 **)db) {} + SQLDeleteObjectData(sqlite3 **sdbi, CephContext *cct) : SQLiteDB(*sdbi, cct), sdb(sdbi) {} ~SQLDeleteObjectData() { if (stmt) diff --git a/src/rgw/store/dbstore/tests/dbstore_tests.cc b/src/rgw/store/dbstore/tests/dbstore_tests.cc index f99c8addb3c75..187d364fca0fa 100644 --- a/src/rgw/store/dbstore/tests/dbstore_tests.cc +++ b/src/rgw/store/dbstore/tests/dbstore_tests.cc @@ -6,45 +6,53 @@ #include #include #include +#include "rgw_common.h" using namespace std; -namespace gtest { - class Environment* env; - - class Environment : public ::testing::Environment { - public: - Environment(): tenant("default_ns"), db(nullptr), - db_type("SQLite"), ret(-1) {} - - Environment(string tenantname, string db_typename): - tenant("tenantname"), db(nullptr), - db_type("db_typename"), ret(-1) {} - - virtual ~Environment() {} +vector args; - void SetUp() override { - if (!db_type.compare("SQLite")) { - db = new SQLiteDB(tenant); - ASSERT_TRUE(db != nullptr); +CephContext *cct; - ret = db->Initialize("", -1); - ASSERT_GE(ret, 0); - } - } +namespace gtest { + class Environment* env; + + class Environment : public ::testing::Environment { + public: + Environment(): tenant("default_ns"), db(nullptr), + db_type("SQLite"), ret(-1) {} + + Environment(string tenantname, string db_typename): + tenant("tenantname"), db(nullptr), + db_type("db_typename"), ret(-1) {} + + virtual ~Environment() {} + + void SetUp() override { + cct = global_init(NULL, args, CEPH_ENTITY_TYPE_CLIENT, + CODE_ENVIRONMENT_UTILITY, 1)->get(); + if (!db_type.compare("SQLite")) { + db = new SQLiteDB(tenant, cct); + ASSERT_TRUE(db != nullptr); + ret = db->Initialize(logfile, loglevel); + ASSERT_GE(ret, 0); + } + } - void TearDown() override { - if (!db) - return; - db->Destroy(); - delete db; - } + void TearDown() override { + if (!db) + return; + db->Destroy(); + delete db; + } - string tenant; - class DBStore *db; - string db_type; - int ret; - }; + string tenant; + class DBStore *db; + string db_type; + int ret; + string logfile = "rgw_dbstore_tests.log"; + int loglevel = 30; + }; } ceph::real_time bucket_mtime = real_clock::now(); @@ -52,623 +60,634 @@ string marker1; namespace { - class DBStoreBaseTest : public ::testing::Test { - protected: - int ret; - DBStore *db = nullptr; - string user1 = "user1"; - string user_id1 = "user_id1"; - string bucket1 = "bucket1"; - string object1 = "object1"; - string data = "Hello World"; - DBOpParams GlobalParams = {}; - - DBStoreBaseTest() {} - void SetUp() { - db = gtest::env->db; - ASSERT_TRUE(db != nullptr); - - GlobalParams.op.user.uinfo.display_name = user1; - GlobalParams.op.user.uinfo.user_id.id = user_id1; - GlobalParams.op.bucket.info.bucket.name = bucket1; - GlobalParams.object = object1; - GlobalParams.offset = 0; - GlobalParams.data = data; - GlobalParams.datalen = data.length(); - - /* As of now InitializeParams doesnt do anything - * special based on fop. Hence its okay to do - * global initialization once. - */ - ret = db->InitializeParams("", &GlobalParams); - ASSERT_EQ(ret, 0); - } - - void TearDown() { - } - }; + class DBStoreBaseTest : public ::testing::Test { + protected: + int ret; + DBStore *db = nullptr; + string user1 = "user1"; + string user_id1 = "user_id1"; + string bucket1 = "bucket1"; + string object1 = "object1"; + string data = "Hello World"; + DBOpParams GlobalParams = {}; + + DBStoreBaseTest() {} + void SetUp() { + db = gtest::env->db; + ASSERT_TRUE(db != nullptr); + + GlobalParams.op.user.uinfo.display_name = user1; + GlobalParams.op.user.uinfo.user_id.id = user_id1; + GlobalParams.op.bucket.info.bucket.name = bucket1; + GlobalParams.object = object1; + GlobalParams.offset = 0; + GlobalParams.data = data; + GlobalParams.datalen = data.length(); + + /* As of now InitializeParams doesnt do anything + * special based on fop. Hence its okay to do + * global initialization once. + */ + ret = db->InitializeParams("", &GlobalParams); + ASSERT_EQ(ret, 0); + } + + void TearDown() { + } + }; } TEST_F(DBStoreBaseTest, InsertUser) { - struct DBOpParams params = GlobalParams; - int ret = -1; - - params.op.user.uinfo.user_id.tenant = "tenant"; - params.op.user.uinfo.user_email = "user1@dbstore.com"; - params.op.user.uinfo.suspended = 123; - params.op.user.uinfo.max_buckets = 456; - params.op.user.uinfo.assumed_role_arn = "role"; - params.op.user.uinfo.placement_tags.push_back("tags"); - RGWAccessKey k1("id1", "key1"); - RGWAccessKey k2("id2", "key2"); - params.op.user.uinfo.access_keys["id1"] = k1; - params.op.user.uinfo.access_keys["id2"] = k2; - params.op.user.user_version.ver = 1; - params.op.user.user_version.tag = "UserTAG"; - - ret = db->ProcessOp("InsertUser", ¶ms); - ASSERT_EQ(ret, 0); + struct DBOpParams params = GlobalParams; + int ret = -1; + + params.op.user.uinfo.user_id.tenant = "tenant"; + params.op.user.uinfo.user_email = "user1@dbstore.com"; + params.op.user.uinfo.suspended = 123; + params.op.user.uinfo.max_buckets = 456; + params.op.user.uinfo.assumed_role_arn = "role"; + params.op.user.uinfo.placement_tags.push_back("tags"); + RGWAccessKey k1("id1", "key1"); + RGWAccessKey k2("id2", "key2"); + params.op.user.uinfo.access_keys["id1"] = k1; + params.op.user.uinfo.access_keys["id2"] = k2; + params.op.user.user_version.ver = 1; + params.op.user.user_version.tag = "UserTAG"; + + ret = db->ProcessOp("InsertUser", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, GetUser) { - struct DBOpParams params = GlobalParams; - int ret = -1; - - ret = db->ProcessOp("GetUser", ¶ms); - ASSERT_EQ(ret, 0); - ASSERT_EQ(params.op.user.uinfo.user_id.tenant, "tenant"); - ASSERT_EQ(params.op.user.uinfo.user_email, "user1@dbstore.com"); - ASSERT_EQ(params.op.user.uinfo.user_id.id, "user_id1"); - ASSERT_EQ(params.op.user.uinfo.suspended, 123); - ASSERT_EQ(params.op.user.uinfo.max_buckets, 456); - ASSERT_EQ(params.op.user.uinfo.assumed_role_arn, "role"); - ASSERT_EQ(params.op.user.uinfo.placement_tags.back(), "tags"); - RGWAccessKey k; - map::iterator it2 = params.op.user.uinfo.access_keys.begin(); - k = it2->second; - ASSERT_EQ(k.id, "id1"); - ASSERT_EQ(k.key, "key1"); - it2++; - k = it2->second; - ASSERT_EQ(k.id, "id2"); - ASSERT_EQ(k.key, "key2"); + struct DBOpParams params = GlobalParams; + int ret = -1; + + ret = db->ProcessOp("GetUser", ¶ms); + ASSERT_EQ(ret, 0); + ASSERT_EQ(params.op.user.uinfo.user_id.tenant, "tenant"); + ASSERT_EQ(params.op.user.uinfo.user_email, "user1@dbstore.com"); + ASSERT_EQ(params.op.user.uinfo.user_id.id, "user_id1"); + ASSERT_EQ(params.op.user.uinfo.suspended, 123); + ASSERT_EQ(params.op.user.uinfo.max_buckets, 456); + ASSERT_EQ(params.op.user.uinfo.assumed_role_arn, "role"); + ASSERT_EQ(params.op.user.uinfo.placement_tags.back(), "tags"); + RGWAccessKey k; + map::iterator it2 = params.op.user.uinfo.access_keys.begin(); + k = it2->second; + ASSERT_EQ(k.id, "id1"); + ASSERT_EQ(k.key, "key1"); + it2++; + k = it2->second; + ASSERT_EQ(k.id, "id2"); + ASSERT_EQ(k.key, "key2"); } TEST_F(DBStoreBaseTest, GetUserQuery) { - struct DBOpParams params = GlobalParams; - int ret = -1; - - params.op.query_str = "email"; - params.op.user.uinfo.user_email = "user1@dbstore.com"; - - ret = db->ProcessOp("GetUser", ¶ms); - ASSERT_EQ(ret, 0); - ASSERT_EQ(params.op.user.uinfo.user_id.tenant, "tenant"); - ASSERT_EQ(params.op.user.uinfo.user_email, "user1@dbstore.com"); - ASSERT_EQ(params.op.user.uinfo.user_id.id, "user_id1"); - ASSERT_EQ(params.op.user.uinfo.suspended, 123); - ASSERT_EQ(params.op.user.uinfo.max_buckets, 456); - ASSERT_EQ(params.op.user.uinfo.assumed_role_arn, "role"); - ASSERT_EQ(params.op.user.uinfo.placement_tags.back(), "tags"); - RGWAccessKey k; - map::iterator it2 = params.op.user.uinfo.access_keys.begin(); - k = it2->second; - ASSERT_EQ(k.id, "id1"); - ASSERT_EQ(k.key, "key1"); - it2++; - k = it2->second; - ASSERT_EQ(k.id, "id2"); - ASSERT_EQ(k.key, "key2"); + struct DBOpParams params = GlobalParams; + int ret = -1; + + params.op.query_str = "email"; + params.op.user.uinfo.user_email = "user1@dbstore.com"; + + ret = db->ProcessOp("GetUser", ¶ms); + ASSERT_EQ(ret, 0); + ASSERT_EQ(params.op.user.uinfo.user_id.tenant, "tenant"); + ASSERT_EQ(params.op.user.uinfo.user_email, "user1@dbstore.com"); + ASSERT_EQ(params.op.user.uinfo.user_id.id, "user_id1"); + ASSERT_EQ(params.op.user.uinfo.suspended, 123); + ASSERT_EQ(params.op.user.uinfo.max_buckets, 456); + ASSERT_EQ(params.op.user.uinfo.assumed_role_arn, "role"); + ASSERT_EQ(params.op.user.uinfo.placement_tags.back(), "tags"); + RGWAccessKey k; + map::iterator it2 = params.op.user.uinfo.access_keys.begin(); + k = it2->second; + ASSERT_EQ(k.id, "id1"); + ASSERT_EQ(k.key, "key1"); + it2++; + k = it2->second; + ASSERT_EQ(k.id, "id2"); + ASSERT_EQ(k.key, "key2"); } TEST_F(DBStoreBaseTest, GetUserQueryByEmail) { - int ret = -1; - RGWUserInfo uinfo; - string email = "user1@dbstore.com"; - map attrs; - RGWObjVersionTracker objv; - - ret = db->get_user("email", email, uinfo, &attrs, &objv); - ASSERT_EQ(ret, 0); - ASSERT_EQ(uinfo.user_id.tenant, "tenant"); - ASSERT_EQ(uinfo.user_email, "user1@dbstore.com"); - ASSERT_EQ(uinfo.user_id.id, "user_id1"); - ASSERT_EQ(uinfo.suspended, 123); - ASSERT_EQ(uinfo.max_buckets, 456); - ASSERT_EQ(uinfo.assumed_role_arn, "role"); - ASSERT_EQ(uinfo.placement_tags.back(), "tags"); - RGWAccessKey k; - map::iterator it2 = uinfo.access_keys.begin(); - k = it2->second; - ASSERT_EQ(k.id, "id1"); - ASSERT_EQ(k.key, "key1"); - it2++; - k = it2->second; - ASSERT_EQ(k.id, "id2"); - ASSERT_EQ(k.key, "key2"); - ASSERT_EQ(objv.read_version.ver, 1); + int ret = -1; + RGWUserInfo uinfo; + string email = "user1@dbstore.com"; + map attrs; + RGWObjVersionTracker objv; + + ret = db->get_user("email", email, uinfo, &attrs, &objv); + ASSERT_EQ(ret, 0); + ASSERT_EQ(uinfo.user_id.tenant, "tenant"); + ASSERT_EQ(uinfo.user_email, "user1@dbstore.com"); + ASSERT_EQ(uinfo.user_id.id, "user_id1"); + ASSERT_EQ(uinfo.suspended, 123); + ASSERT_EQ(uinfo.max_buckets, 456); + ASSERT_EQ(uinfo.assumed_role_arn, "role"); + ASSERT_EQ(uinfo.placement_tags.back(), "tags"); + RGWAccessKey k; + map::iterator it2 = uinfo.access_keys.begin(); + k = it2->second; + ASSERT_EQ(k.id, "id1"); + ASSERT_EQ(k.key, "key1"); + it2++; + k = it2->second; + ASSERT_EQ(k.id, "id2"); + ASSERT_EQ(k.key, "key2"); + ASSERT_EQ(objv.read_version.ver, 1); } TEST_F(DBStoreBaseTest, GetUserQueryByAccessKey) { - int ret = -1; - RGWUserInfo uinfo; - string key = "id1"; - - ret = db->get_user("access_key", key, uinfo, nullptr, nullptr); - ASSERT_EQ(ret, 0); - ASSERT_EQ(uinfo.user_id.tenant, "tenant"); - ASSERT_EQ(uinfo.user_email, "user1@dbstore.com"); - ASSERT_EQ(uinfo.user_id.id, "user_id1"); - ASSERT_EQ(uinfo.suspended, 123); - ASSERT_EQ(uinfo.max_buckets, 456); - ASSERT_EQ(uinfo.assumed_role_arn, "role"); - ASSERT_EQ(uinfo.placement_tags.back(), "tags"); - RGWAccessKey k; - map::iterator it2 = uinfo.access_keys.begin(); - k = it2->second; - ASSERT_EQ(k.id, "id1"); - ASSERT_EQ(k.key, "key1"); - it2++; - k = it2->second; - ASSERT_EQ(k.id, "id2"); - ASSERT_EQ(k.key, "key2"); + int ret = -1; + RGWUserInfo uinfo; + string key = "id1"; + + ret = db->get_user("access_key", key, uinfo, nullptr, nullptr); + ASSERT_EQ(ret, 0); + ASSERT_EQ(uinfo.user_id.tenant, "tenant"); + ASSERT_EQ(uinfo.user_email, "user1@dbstore.com"); + ASSERT_EQ(uinfo.user_id.id, "user_id1"); + ASSERT_EQ(uinfo.suspended, 123); + ASSERT_EQ(uinfo.max_buckets, 456); + ASSERT_EQ(uinfo.assumed_role_arn, "role"); + ASSERT_EQ(uinfo.placement_tags.back(), "tags"); + RGWAccessKey k; + map::iterator it2 = uinfo.access_keys.begin(); + k = it2->second; + ASSERT_EQ(k.id, "id1"); + ASSERT_EQ(k.key, "key1"); + it2++; + k = it2->second; + ASSERT_EQ(k.id, "id2"); + ASSERT_EQ(k.key, "key2"); } TEST_F(DBStoreBaseTest, StoreUser) { - struct DBOpParams params = GlobalParams; - int ret = -1; - RGWUserInfo uinfo, old_uinfo; - map attrs; - RGWObjVersionTracker objv_tracker; - - bufferlist attr1, attr2; - encode("attrs1", attr1); - attrs["attr1"] = attr1; - encode("attrs2", attr2); - attrs["attr2"] = attr2; - - uinfo.user_id.id = "user_id2"; - uinfo.user_id.tenant = "tenant"; - uinfo.user_email = "user2@dbstore.com"; - uinfo.suspended = 123; - uinfo.max_buckets = 456; - uinfo.assumed_role_arn = "role"; - uinfo.placement_tags.push_back("tags"); - RGWAccessKey k1("id1", "key1"); - RGWAccessKey k2("id2", "key2"); - uinfo.access_keys["id1"] = k1; - uinfo.access_keys["id2"] = k2; - - /* non exclusive create..should create new one */ - ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo); - ASSERT_EQ(ret, 0); - ASSERT_EQ(old_uinfo.user_email, ""); - ASSERT_EQ(objv_tracker.read_version.ver, 1); - ASSERT_EQ(objv_tracker.read_version.tag, "UserTAG"); - - /* invalid version number */ - objv_tracker.read_version.ver = 4; - ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo); - ASSERT_EQ(ret, -125); /* returns ECANCELED */ - ASSERT_EQ(old_uinfo.user_id.id, uinfo.user_id.id); - ASSERT_EQ(old_uinfo.user_email, uinfo.user_email); - - /* exclusive create..should not create new one */ - uinfo.user_email = "user2_new@dbstore.com"; - objv_tracker.read_version.ver = 1; - ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo); - ASSERT_EQ(ret, 0); - ASSERT_EQ(old_uinfo.user_email, "user2@dbstore.com"); - ASSERT_EQ(objv_tracker.read_version.ver, 1); - - ret = db->store_user(uinfo, false, &attrs, &objv_tracker, &old_uinfo); - ASSERT_EQ(ret, 0); - ASSERT_EQ(old_uinfo.user_email, "user2@dbstore.com"); - ASSERT_EQ(objv_tracker.read_version.ver, 2); - ASSERT_EQ(objv_tracker.read_version.tag, "UserTAG"); + struct DBOpParams params = GlobalParams; + int ret = -1; + RGWUserInfo uinfo, old_uinfo; + map attrs; + RGWObjVersionTracker objv_tracker; + + bufferlist attr1, attr2; + encode("attrs1", attr1); + attrs["attr1"] = attr1; + encode("attrs2", attr2); + attrs["attr2"] = attr2; + + uinfo.user_id.id = "user_id2"; + uinfo.user_id.tenant = "tenant"; + uinfo.user_email = "user2@dbstore.com"; + uinfo.suspended = 123; + uinfo.max_buckets = 456; + uinfo.assumed_role_arn = "role"; + uinfo.placement_tags.push_back("tags"); + RGWAccessKey k1("id1", "key1"); + RGWAccessKey k2("id2", "key2"); + uinfo.access_keys["id1"] = k1; + uinfo.access_keys["id2"] = k2; + + /* non exclusive create..should create new one */ + ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo); + ASSERT_EQ(ret, 0); + ASSERT_EQ(old_uinfo.user_email, ""); + ASSERT_EQ(objv_tracker.read_version.ver, 1); + ASSERT_EQ(objv_tracker.read_version.tag, "UserTAG"); + + /* invalid version number */ + objv_tracker.read_version.ver = 4; + ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo); + ASSERT_EQ(ret, -125); /* returns ECANCELED */ + ASSERT_EQ(old_uinfo.user_id.id, uinfo.user_id.id); + ASSERT_EQ(old_uinfo.user_email, uinfo.user_email); + + /* exclusive create..should not create new one */ + uinfo.user_email = "user2_new@dbstore.com"; + objv_tracker.read_version.ver = 1; + ret = db->store_user(uinfo, true, &attrs, &objv_tracker, &old_uinfo); + ASSERT_EQ(ret, 0); + ASSERT_EQ(old_uinfo.user_email, "user2@dbstore.com"); + ASSERT_EQ(objv_tracker.read_version.ver, 1); + + ret = db->store_user(uinfo, false, &attrs, &objv_tracker, &old_uinfo); + ASSERT_EQ(ret, 0); + ASSERT_EQ(old_uinfo.user_email, "user2@dbstore.com"); + ASSERT_EQ(objv_tracker.read_version.ver, 2); + ASSERT_EQ(objv_tracker.read_version.tag, "UserTAG"); } TEST_F(DBStoreBaseTest, GetUserQueryByUserID) { - int ret = -1; - RGWUserInfo uinfo; - map attrs; - RGWObjVersionTracker objv; - - uinfo.user_id.tenant = "tenant"; - uinfo.user_id.id = "user_id2"; - - ret = db->get_user("user_id", "", uinfo, &attrs, &objv); - ASSERT_EQ(ret, 0); - ASSERT_EQ(uinfo.user_id.tenant, "tenant"); - ASSERT_EQ(uinfo.user_email, "user2_new@dbstore.com"); - ASSERT_EQ(uinfo.user_id.id, "user_id2"); - ASSERT_EQ(uinfo.suspended, 123); - ASSERT_EQ(uinfo.max_buckets, 456); - ASSERT_EQ(uinfo.assumed_role_arn, "role"); - ASSERT_EQ(uinfo.placement_tags.back(), "tags"); - RGWAccessKey k; - map::iterator it = uinfo.access_keys.begin(); - k = it->second; - ASSERT_EQ(k.id, "id1"); - ASSERT_EQ(k.key, "key1"); - it++; - k = it->second; - ASSERT_EQ(k.id, "id2"); - ASSERT_EQ(k.key, "key2"); - - ASSERT_EQ(objv.read_version.ver, 2); - - bufferlist k1, k2; - string attr; - map::iterator it2 = attrs.begin(); - k1 = it2->second; - decode(attr, k1); - ASSERT_EQ(attr, "attrs1"); - it2++; - k2 = it2->second; - decode(attr, k2); - ASSERT_EQ(attr, "attrs2"); + int ret = -1; + RGWUserInfo uinfo; + map attrs; + RGWObjVersionTracker objv; + + uinfo.user_id.tenant = "tenant"; + uinfo.user_id.id = "user_id2"; + + ret = db->get_user("user_id", "", uinfo, &attrs, &objv); + ASSERT_EQ(ret, 0); + ASSERT_EQ(uinfo.user_id.tenant, "tenant"); + ASSERT_EQ(uinfo.user_email, "user2_new@dbstore.com"); + ASSERT_EQ(uinfo.user_id.id, "user_id2"); + ASSERT_EQ(uinfo.suspended, 123); + ASSERT_EQ(uinfo.max_buckets, 456); + ASSERT_EQ(uinfo.assumed_role_arn, "role"); + ASSERT_EQ(uinfo.placement_tags.back(), "tags"); + RGWAccessKey k; + map::iterator it = uinfo.access_keys.begin(); + k = it->second; + ASSERT_EQ(k.id, "id1"); + ASSERT_EQ(k.key, "key1"); + it++; + k = it->second; + ASSERT_EQ(k.id, "id2"); + ASSERT_EQ(k.key, "key2"); + + ASSERT_EQ(objv.read_version.ver, 2); + + bufferlist k1, k2; + string attr; + map::iterator it2 = attrs.begin(); + k1 = it2->second; + decode(attr, k1); + ASSERT_EQ(attr, "attrs1"); + it2++; + k2 = it2->second; + decode(attr, k2); + ASSERT_EQ(attr, "attrs2"); } TEST_F(DBStoreBaseTest, ListAllUsers) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ListAllUsers(¶ms); - ASSERT_EQ(ret, 0); + ret = db->ListAllUsers(¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, InsertBucket) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - params.op.bucket.info.bucket.name = "bucket1"; - params.op.bucket.info.bucket.tenant = "tenant"; - params.op.bucket.info.bucket.marker = "marker1"; + params.op.bucket.info.bucket.name = "bucket1"; + params.op.bucket.info.bucket.tenant = "tenant"; + params.op.bucket.info.bucket.marker = "marker1"; - params.op.bucket.ent.size = 1024; + params.op.bucket.ent.size = 1024; - params.op.bucket.info.has_instance_obj = false; - params.op.bucket.bucket_version.ver = 1; - params.op.bucket.bucket_version.tag = "read_tag"; + params.op.bucket.info.has_instance_obj = false; + params.op.bucket.bucket_version.ver = 1; + params.op.bucket.bucket_version.tag = "read_tag"; - params.op.bucket.mtime = bucket_mtime; + params.op.bucket.mtime = bucket_mtime; - ret = db->ProcessOp("InsertBucket", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("InsertBucket", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, UpdateBucketAttrs) { - int ret = -1; - RGWBucketInfo info; - map attrs; - RGWObjVersionTracker objv; + int ret = -1; + RGWBucketInfo info; + map attrs; + RGWObjVersionTracker objv; - bufferlist aclbl, aclbl2; - encode("attrs1", aclbl); - attrs["attr1"] = aclbl; - encode("attrs2", aclbl2); - attrs["attr2"] = aclbl2; + bufferlist aclbl, aclbl2; + encode("attrs1", aclbl); + attrs["attr1"] = aclbl; + encode("attrs2", aclbl2); + attrs["attr2"] = aclbl2; - info.bucket.name = "bucket1"; + info.bucket.name = "bucket1"; - /* invalid version number */ - objv.read_version.ver = 4; - ret = db->update_bucket("attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv); - ASSERT_EQ(ret, -125); /* returns ECANCELED */ + /* invalid version number */ + objv.read_version.ver = 4; + ret = db->update_bucket("attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv); + ASSERT_EQ(ret, -125); /* returns ECANCELED */ - /* right version number */ - objv.read_version.ver = 1; - ret = db->update_bucket("attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv); - ASSERT_EQ(ret, 0); - ASSERT_EQ(objv.read_version.ver, 2); + /* right version number */ + objv.read_version.ver = 1; + ret = db->update_bucket("attrs", info, false, nullptr, &attrs, &bucket_mtime, &objv); + ASSERT_EQ(ret, 0); + ASSERT_EQ(objv.read_version.ver, 2); } TEST_F(DBStoreBaseTest, BucketChown) { - int ret = -1; - RGWBucketInfo info; - rgw_user user; - user.id = "user_id2"; + int ret = -1; + RGWBucketInfo info; + rgw_user user; + user.id = "user_id2"; - info.bucket.name = "bucket1"; + info.bucket.name = "bucket1"; - ret = db->update_bucket("owner", info, false, &user, nullptr, &bucket_mtime, nullptr); - ASSERT_EQ(ret, 0); - ASSERT_EQ(info.objv_tracker.read_version.ver, 3); + ret = db->update_bucket("owner", info, false, &user, nullptr, &bucket_mtime, nullptr); + ASSERT_EQ(ret, 0); + ASSERT_EQ(info.objv_tracker.read_version.ver, 3); } TEST_F(DBStoreBaseTest, UpdateBucketInfo) { - struct DBOpParams params = GlobalParams; - int ret = -1; - RGWBucketInfo info; + struct DBOpParams params = GlobalParams; + int ret = -1; + RGWBucketInfo info; - params.op.bucket.info.bucket.name = "bucket1"; + params.op.bucket.info.bucket.name = "bucket1"; - ret = db->ProcessOp("GetBucket", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("GetBucket", ¶ms); + ASSERT_EQ(ret, 0); - info = params.op.bucket.info; + info = params.op.bucket.info; - info.bucket.marker = "marker2"; - ret = db->update_bucket("info", info, false, nullptr, nullptr, &bucket_mtime, nullptr); - ASSERT_EQ(ret, 0); - ASSERT_EQ(info.objv_tracker.read_version.ver, 4); + info.bucket.marker = "marker2"; + ret = db->update_bucket("info", info, false, nullptr, nullptr, &bucket_mtime, nullptr); + ASSERT_EQ(ret, 0); + ASSERT_EQ(info.objv_tracker.read_version.ver, 4); } TEST_F(DBStoreBaseTest, GetBucket) { - struct DBOpParams params = GlobalParams; - int ret = -1; - - ret = db->ProcessOp("GetBucket", ¶ms); - ASSERT_EQ(ret, 0); - ASSERT_EQ(params.op.bucket.info.bucket.name, "bucket1"); - ASSERT_EQ(params.op.bucket.info.bucket.tenant, "tenant"); - ASSERT_EQ(params.op.bucket.info.bucket.marker, "marker2"); - ASSERT_EQ(params.op.bucket.ent.size, 1024); - ASSERT_EQ(params.op.bucket.ent.bucket.name, "bucket1"); - ASSERT_EQ(params.op.bucket.ent.bucket.tenant, "tenant"); - ASSERT_EQ(params.op.bucket.info.has_instance_obj, false); - ASSERT_EQ(params.op.bucket.info.objv_tracker.read_version.ver, 4); - ASSERT_EQ(params.op.bucket.info.objv_tracker.read_version.tag, "read_tag"); - ASSERT_EQ(params.op.bucket.mtime, bucket_mtime); - ASSERT_EQ(params.op.bucket.info.owner.id, "user_id2"); - bufferlist k, k2; - string acl; - map::iterator it2 = params.op.bucket.bucket_attrs.begin(); - k = it2->second; - decode(acl, k); - ASSERT_EQ(acl, "attrs1"); - it2++; - k2 = it2->second; - decode(acl, k2); - ASSERT_EQ(acl, "attrs2"); + struct DBOpParams params = GlobalParams; + int ret = -1; + + ret = db->ProcessOp("GetBucket", ¶ms); + ASSERT_EQ(ret, 0); + ASSERT_EQ(params.op.bucket.info.bucket.name, "bucket1"); + ASSERT_EQ(params.op.bucket.info.bucket.tenant, "tenant"); + ASSERT_EQ(params.op.bucket.info.bucket.marker, "marker2"); + ASSERT_EQ(params.op.bucket.ent.size, 1024); + ASSERT_EQ(params.op.bucket.ent.bucket.name, "bucket1"); + ASSERT_EQ(params.op.bucket.ent.bucket.tenant, "tenant"); + ASSERT_EQ(params.op.bucket.info.has_instance_obj, false); + ASSERT_EQ(params.op.bucket.info.objv_tracker.read_version.ver, 4); + ASSERT_EQ(params.op.bucket.info.objv_tracker.read_version.tag, "read_tag"); + ASSERT_EQ(params.op.bucket.mtime, bucket_mtime); + ASSERT_EQ(params.op.bucket.info.owner.id, "user_id2"); + bufferlist k, k2; + string acl; + map::iterator it2 = params.op.bucket.bucket_attrs.begin(); + k = it2->second; + decode(acl, k); + ASSERT_EQ(acl, "attrs1"); + it2++; + k2 = it2->second; + decode(acl, k2); + ASSERT_EQ(acl, "attrs2"); } TEST_F(DBStoreBaseTest, RemoveBucketAPI) { - int ret = -1; - RGWBucketInfo info; + int ret = -1; + RGWBucketInfo info; - info.bucket.name = "bucket1"; + info.bucket.name = "bucket1"; - ret = db->remove_bucket(info); - ASSERT_EQ(ret, 0); + ret = db->remove_bucket(info); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, RemoveUserAPI) { - int ret = -1; - RGWUserInfo uinfo; - RGWObjVersionTracker objv; + int ret = -1; + RGWUserInfo uinfo; + RGWObjVersionTracker objv; - uinfo.user_id.tenant = "tenant"; - uinfo.user_id.id = "user_id2"; + uinfo.user_id.tenant = "tenant"; + uinfo.user_id.id = "user_id2"; - /* invalid version number...should fail */ - objv.read_version.ver = 4; - ret = db->remove_user(uinfo, &objv); - ASSERT_EQ(ret, -125); + /* invalid version number...should fail */ + objv.read_version.ver = 4; + ret = db->remove_user(uinfo, &objv); + ASSERT_EQ(ret, -125); - /* invalid version number...should fail */ - objv.read_version.ver = 2; - ret = db->remove_user(uinfo, &objv); - ASSERT_EQ(ret, 0); + /* invalid version number...should fail */ + objv.read_version.ver = 2; + ret = db->remove_user(uinfo, &objv); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, CreateBucket) { - struct DBOpParams params = GlobalParams; - int ret = -1; - RGWBucketInfo info; - RGWUserInfo owner; - rgw_bucket bucket; - obj_version objv; - rgw_placement_rule rule; - map attrs; - - owner.user_id.id = "user_id1"; - bucket.name = "bucket1"; - bucket.tenant = "tenant"; - - objv.ver = 2; - objv.tag = "write_tag"; - - rule.name = "rule1"; - rule.storage_class = "sc1"; - - ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, - attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, - null_yield, NULL, false); - ASSERT_EQ(ret, 0); - bucket.name = "bucket2"; - ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, - attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, - null_yield, NULL, false); - ASSERT_EQ(ret, 0); - bucket.name = "bucket3"; - ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, - attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, - null_yield, NULL, false); - ASSERT_EQ(ret, 0); - bucket.name = "bucket4"; - ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, - attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, - null_yield, NULL, false); - ASSERT_EQ(ret, 0); - bucket.name = "bucket5"; - ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, - attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, - null_yield, NULL, false); - ASSERT_EQ(ret, 0); + struct DBOpParams params = GlobalParams; + int ret = -1; + RGWBucketInfo info; + RGWUserInfo owner; + rgw_bucket bucket; + obj_version objv; + rgw_placement_rule rule; + map attrs; + + owner.user_id.id = "user_id1"; + bucket.name = "bucket1"; + bucket.tenant = "tenant"; + + objv.ver = 2; + objv.tag = "write_tag"; + + rule.name = "rule1"; + rule.storage_class = "sc1"; + + ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, + attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, + null_yield, NULL, false); + ASSERT_EQ(ret, 0); + bucket.name = "bucket2"; + ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, + attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, + null_yield, NULL, false); + ASSERT_EQ(ret, 0); + bucket.name = "bucket3"; + ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, + attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, + null_yield, NULL, false); + ASSERT_EQ(ret, 0); + bucket.name = "bucket4"; + ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, + attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, + null_yield, NULL, false); + ASSERT_EQ(ret, 0); + bucket.name = "bucket5"; + ret = db->create_bucket(owner, bucket, "zid", rule, "swift_ver", NULL, + attrs, info, &objv, NULL, bucket_mtime, NULL, NULL, + null_yield, NULL, false); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, GetBucketQueryByName) { - int ret = -1; - RGWBucketInfo binfo; - binfo.bucket.name = "bucket2"; - rgw::sal::Attrs attrs; - ceph::real_time mtime; - obj_version objv; - - ret = db->get_bucket_info("name", "", binfo, &attrs, &mtime, &objv); - ASSERT_EQ(ret, 0); - ASSERT_EQ(binfo.bucket.name, "bucket2"); - ASSERT_EQ(binfo.bucket.tenant, "tenant"); - ASSERT_EQ(binfo.owner.id, "user_id1"); - ASSERT_EQ(binfo.objv_tracker.read_version.ver, 2); - ASSERT_EQ(binfo.objv_tracker.read_version.tag, "write_tag"); - ASSERT_EQ(binfo.zonegroup, "zid"); - ASSERT_EQ(binfo.creation_time, bucket_mtime); - ASSERT_EQ(binfo.placement_rule.name, "rule1"); - ASSERT_EQ(binfo.placement_rule.storage_class, "sc1"); - ASSERT_EQ(objv.ver, 2); - ASSERT_EQ(objv.tag, "write_tag"); - - marker1 = binfo.bucket.marker; + int ret = -1; + RGWBucketInfo binfo; + binfo.bucket.name = "bucket2"; + rgw::sal::Attrs attrs; + ceph::real_time mtime; + obj_version objv; + + ret = db->get_bucket_info("name", "", binfo, &attrs, &mtime, &objv); + ASSERT_EQ(ret, 0); + ASSERT_EQ(binfo.bucket.name, "bucket2"); + ASSERT_EQ(binfo.bucket.tenant, "tenant"); + ASSERT_EQ(binfo.owner.id, "user_id1"); + ASSERT_EQ(binfo.objv_tracker.read_version.ver, 2); + ASSERT_EQ(binfo.objv_tracker.read_version.tag, "write_tag"); + ASSERT_EQ(binfo.zonegroup, "zid"); + ASSERT_EQ(binfo.creation_time, bucket_mtime); + ASSERT_EQ(binfo.placement_rule.name, "rule1"); + ASSERT_EQ(binfo.placement_rule.storage_class, "sc1"); + ASSERT_EQ(objv.ver, 2); + ASSERT_EQ(objv.tag, "write_tag"); + + marker1 = binfo.bucket.marker; } TEST_F(DBStoreBaseTest, ListUserBuckets) { - struct DBOpParams params = GlobalParams; - int ret = -1; - rgw_user owner; - int max = 2; - bool need_stats = true; - bool is_truncated = false; - RGWUserBuckets ulist; - - owner.id = "user_id1"; - - marker1 = ""; - do { - is_truncated = false; - ret = db->list_buckets(owner, marker1, "", max, need_stats, &ulist, &is_truncated); - ASSERT_EQ(ret, 0); - - cout << "marker1 :" << marker1 << "\n"; - - cout << "is_truncated :" << is_truncated << "\n"; - - for (const auto& ent: ulist.get_buckets()) { - RGWBucketEnt e = ent.second; - cout << "###################### \n"; - cout << "ent.bucket.id : " << e.bucket.name << "\n"; - cout << "ent.bucket.marker : " << e.bucket.marker << "\n"; - cout << "ent.bucket.bucket_id : " << e.bucket.bucket_id << "\n"; - cout << "ent.size : " << e.size << "\n"; - cout << "ent.rule.name : " << e.placement_rule.name << "\n"; - - marker1 = e.bucket.name; - } - ulist.clear(); - } while(is_truncated); + struct DBOpParams params = GlobalParams; + int ret = -1; + rgw_user owner; + int max = 2; + bool need_stats = true; + bool is_truncated = false; + RGWUserBuckets ulist; + + owner.id = "user_id1"; + + marker1 = ""; + do { + is_truncated = false; + ret = db->list_buckets(owner, marker1, "", max, need_stats, &ulist, &is_truncated); + ASSERT_EQ(ret, 0); + + cout << "marker1 :" << marker1 << "\n"; + + cout << "is_truncated :" << is_truncated << "\n"; + + for (const auto& ent: ulist.get_buckets()) { + RGWBucketEnt e = ent.second; + cout << "###################### \n"; + cout << "ent.bucket.id : " << e.bucket.name << "\n"; + cout << "ent.bucket.marker : " << e.bucket.marker << "\n"; + cout << "ent.bucket.bucket_id : " << e.bucket.bucket_id << "\n"; + cout << "ent.size : " << e.size << "\n"; + cout << "ent.rule.name : " << e.placement_rule.name << "\n"; + + marker1 = e.bucket.name; + } + ulist.clear(); + } while(is_truncated); } TEST_F(DBStoreBaseTest, ListAllBuckets) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ListAllBuckets(¶ms); - ASSERT_EQ(ret, 0); + ret = db->ListAllBuckets(¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, InsertObject) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("InsertObject", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("InsertObject", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, ListObject) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("ListObject", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("ListObject", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, ListAllObjects) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ListAllObjects(¶ms); - ASSERT_EQ(ret, 0); + ret = db->ListAllObjects(¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, PutObjectData) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("PutObjectData", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("PutObjectData", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, GetObjectData) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("GetObjectData", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("GetObjectData", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, DeleteObjectData) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("DeleteObjectData", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("DeleteObjectData", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, RemoveObject) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("RemoveObject", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("RemoveObject", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, RemoveBucket) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("RemoveBucket", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("RemoveBucket", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, RemoveUser) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - ret = db->ProcessOp("RemoveUser", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("RemoveUser", ¶ms); + ASSERT_EQ(ret, 0); } TEST_F(DBStoreBaseTest, InsertTestIDUser) { - struct DBOpParams params = GlobalParams; - int ret = -1; + struct DBOpParams params = GlobalParams; + int ret = -1; - params.op.user.uinfo.user_id.id = "testid"; - params.op.user.uinfo.display_name = "M. Tester"; - params.op.user.uinfo.user_id.tenant = "tenant"; - params.op.user.uinfo.user_email = "tester@ceph.com"; - RGWAccessKey k1("0555b35654ad1656d804", "h7GhxuBLTrlhVUyxSPUKUV8r/2EI4ngqJxD7iBdBYLhwluN30JaT3Q=="); - params.op.user.uinfo.access_keys["0555b35654ad1656d804"] = k1; - params.op.user.user_version.ver = 1; - params.op.user.user_version.tag = "UserTAG"; + params.op.user.uinfo.user_id.id = "testid"; + params.op.user.uinfo.display_name = "M. Tester"; + params.op.user.uinfo.user_id.tenant = "tenant"; + params.op.user.uinfo.user_email = "tester@ceph.com"; + RGWAccessKey k1("0555b35654ad1656d804", "h7GhxuBLTrlhVUyxSPUKUV8r/2EI4ngqJxD7iBdBYLhwluN30JaT3Q=="); + params.op.user.uinfo.access_keys["0555b35654ad1656d804"] = k1; + params.op.user.user_version.ver = 1; + params.op.user.user_version.tag = "UserTAG"; - ret = db->ProcessOp("InsertUser", ¶ms); - ASSERT_EQ(ret, 0); + ret = db->ProcessOp("InsertUser", ¶ms); + ASSERT_EQ(ret, 0); } int main(int argc, char **argv) { - int ret = -1; + int ret = -1; + string c_logfile = "rgw_dbstore_tests.log"; + int c_loglevel = 20; + + // format: ./dbstore-tests logfile loglevel + if (argc == 3) { + c_logfile = argv[1]; + c_loglevel = (atoi)(argv[2]); + cout << "logfile:" << c_logfile << ", loglevel set to " << c_loglevel << "\n"; + } - ::testing::InitGoogleTest(&argc, argv); + ::testing::InitGoogleTest(&argc, argv); - gtest::env = new gtest::Environment(); - ::testing::AddGlobalTestEnvironment(gtest::env); + gtest::env = new gtest::Environment(); + gtest::env->logfile = c_logfile; + gtest::env->loglevel = c_loglevel; + ::testing::AddGlobalTestEnvironment(gtest::env); - ret = RUN_ALL_TESTS(); + ret = RUN_ALL_TESTS(); - return ret; + return ret; } -- 2.39.5