Skip to content

Commit a0d604f

Browse files
cbodleycbodley
committed
rgw/sal: LCHead and LCEntry don't need abstraction
Signed-off-by: Casey Bodley <[email protected]> get dbstore to compile too
1 parent e174ece commit a0d604f

File tree

15 files changed

+246
-425
lines changed

15 files changed

+246
-425
lines changed

‎src/rgw/driver/dbstore/common/dbstore.cc‎

Lines changed: 15 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1973,7 +1973,7 @@ int DB::Object::Delete::create_dm(const DoutPrefixProvider *dpp,
19731973
}
19741974

19751975
int DB::get_entry(const std::string& oid, const std::string& marker,
1976-
std::unique_ptr<rgw::sal::Lifecycle::LCEntry>* entry)
1976+
rgw::sal::LCEntry& entry)
19771977
{
19781978
int ret = 0;
19791979
const DoutPrefixProvider *dpp = get_def_dpp();
@@ -1982,7 +1982,7 @@ int DB::get_entry(const std::string& oid, const std::string& marker,
19821982
InitializeParams(dpp, &params);
19831983

19841984
params.op.lc_entry.index = oid;
1985-
params.op.lc_entry.entry.set_bucket(marker);
1985+
params.op.lc_entry.entry.bucket = marker;
19861986

19871987
params.op.query_str = "get_entry";
19881988
ret = ProcessOp(dpp, "GetLCEntry", &params);
@@ -1992,22 +1992,16 @@ int DB::get_entry(const std::string& oid, const std::string& marker,
19921992
goto out;
19931993
}
19941994

1995-
if (!params.op.lc_entry.entry.get_start_time() == 0) { //ensure entry found
1996-
rgw::sal::Lifecycle::LCEntry* e;
1997-
e = new rgw::sal::StoreLifecycle::StoreLCEntry(params.op.lc_entry.entry);
1998-
if (!e) {
1999-
ret = -ENOMEM;
2000-
goto out;
2001-
}
2002-
entry->reset(e);
1995+
if (params.op.lc_entry.entry.start_time != 0) { //ensure entry found
1996+
entry = std::move(params.op.lc_entry.entry);
20031997
}
20041998

20051999
out:
20062000
return ret;
20072001
}
20082002

20092003
int DB::get_next_entry(const std::string& oid, const std::string& marker,
2010-
std::unique_ptr<rgw::sal::Lifecycle::LCEntry>* entry)
2004+
rgw::sal::LCEntry& entry)
20112005
{
20122006
int ret = 0;
20132007
const DoutPrefixProvider *dpp = get_def_dpp();
@@ -2016,7 +2010,7 @@ int DB::get_next_entry(const std::string& oid, const std::string& marker,
20162010
InitializeParams(dpp, &params);
20172011

20182012
params.op.lc_entry.index = oid;
2019-
params.op.lc_entry.entry.set_bucket(marker);
2013+
params.op.lc_entry.entry.bucket = marker;
20202014

20212015
params.op.query_str = "get_next_entry";
20222016
ret = ProcessOp(dpp, "GetLCEntry", &params);
@@ -2026,21 +2020,15 @@ int DB::get_next_entry(const std::string& oid, const std::string& marker,
20262020
goto out;
20272021
}
20282022

2029-
if (!params.op.lc_entry.entry.get_start_time() == 0) { //ensure entry found
2030-
rgw::sal::Lifecycle::LCEntry* e;
2031-
e = new rgw::sal::StoreLifecycle::StoreLCEntry(params.op.lc_entry.entry);
2032-
if (!e) {
2033-
ret = -ENOMEM;
2034-
goto out;
2035-
}
2036-
entry->reset(e);
2023+
if (params.op.lc_entry.entry.start_time != 0) { //ensure entry found
2024+
entry = std::move(params.op.lc_entry.entry);
20372025
}
20382026

20392027
out:
20402028
return ret;
20412029
}
20422030

2043-
int DB::set_entry(const std::string& oid, rgw::sal::Lifecycle::LCEntry& entry)
2031+
int DB::set_entry(const std::string& oid, const rgw::sal::LCEntry& entry)
20442032
{
20452033
int ret = 0;
20462034
const DoutPrefixProvider *dpp = get_def_dpp();
@@ -2063,7 +2051,7 @@ int DB::set_entry(const std::string& oid, rgw::sal::Lifecycle::LCEntry& entry)
20632051
}
20642052

20652053
int DB::list_entries(const std::string& oid, const std::string& marker,
2066-
uint32_t max_entries, std::vector<std::unique_ptr<rgw::sal::Lifecycle::LCEntry>>& entries)
2054+
uint32_t max_entries, std::vector<rgw::sal::LCEntry>& entries)
20672055
{
20682056
int ret = 0;
20692057
const DoutPrefixProvider *dpp = get_def_dpp();
@@ -2085,14 +2073,14 @@ int DB::list_entries(const std::string& oid, const std::string& marker,
20852073
}
20862074

20872075
for (auto& entry : params.op.lc_entry.list_entries) {
2088-
entries.push_back(std::make_unique<rgw::sal::StoreLifecycle::StoreLCEntry>(std::move(entry)));
2076+
entries.push_back(std::move(entry));
20892077
}
20902078

20912079
out:
20922080
return ret;
20932081
}
20942082

2095-
int DB::rm_entry(const std::string& oid, rgw::sal::Lifecycle::LCEntry& entry)
2083+
int DB::rm_entry(const std::string& oid, const rgw::sal::LCEntry& entry)
20962084
{
20972085
int ret = 0;
20982086
const DoutPrefixProvider *dpp = get_def_dpp();
@@ -2114,7 +2102,7 @@ int DB::rm_entry(const std::string& oid, rgw::sal::Lifecycle::LCEntry& entry)
21142102
return ret;
21152103
}
21162104

2117-
int DB::get_head(const std::string& oid, std::unique_ptr<rgw::sal::Lifecycle::LCHead>* head)
2105+
int DB::get_head(const std::string& oid, rgw::sal::LCHead& head)
21182106
{
21192107
int ret = 0;
21202108
const DoutPrefixProvider *dpp = get_def_dpp();
@@ -2131,13 +2119,13 @@ int DB::get_head(const std::string& oid, std::unique_ptr<rgw::sal::Lifecycle::LC
21312119
goto out;
21322120
}
21332121

2134-
*head = std::make_unique<rgw::sal::StoreLifecycle::StoreLCHead>(params.op.lc_head.head);
2122+
head = std::move(params.op.lc_head.head);
21352123

21362124
out:
21372125
return ret;
21382126
}
21392127

2140-
int DB::put_head(const std::string& oid, rgw::sal::Lifecycle::LCHead& head)
2128+
int DB::put_head(const std::string& oid, const rgw::sal::LCHead& head)
21412129
{
21422130
int ret = 0;
21432131
const DoutPrefixProvider *dpp = get_def_dpp();

‎src/rgw/driver/dbstore/common/dbstore.h‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -104,15 +104,15 @@ struct DBOpObjectDataInfo {
104104

105105
struct DBOpLCHeadInfo {
106106
std::string index;
107-
rgw::sal::StoreLifecycle::StoreLCHead head;
107+
rgw::sal::LCHead head;
108108
};
109109

110110
struct DBOpLCEntryInfo {
111111
std::string index;
112-
rgw::sal::StoreLifecycle::StoreLCEntry entry;
112+
rgw::sal::LCEntry entry;
113113
// used for list query
114114
std::string min_marker;
115-
std::list<rgw::sal::StoreLifecycle::StoreLCEntry> list_entries;
115+
std::list<rgw::sal::LCEntry> list_entries;
116116
};
117117

118118
struct DBOpInfo {
@@ -1979,15 +1979,15 @@ class DB {
19791979
RGWObjState *astate, void *arg);
19801980

19811981
int get_entry(const std::string& oid, const std::string& marker,
1982-
std::unique_ptr<rgw::sal::Lifecycle::LCEntry>* entry);
1982+
rgw::sal::LCEntry& entry);
19831983
int get_next_entry(const std::string& oid, const std::string& marker,
1984-
std::unique_ptr<rgw::sal::Lifecycle::LCEntry>* entry);
1985-
int set_entry(const std::string& oid, rgw::sal::Lifecycle::LCEntry& entry);
1984+
rgw::sal::LCEntry& entry);
1985+
int set_entry(const std::string& oid, const rgw::sal::LCEntry& entry);
19861986
int list_entries(const std::string& oid, const std::string& marker,
1987-
uint32_t max_entries, std::vector<std::unique_ptr<rgw::sal::Lifecycle::LCEntry>>& entries);
1988-
int rm_entry(const std::string& oid, rgw::sal::Lifecycle::LCEntry& entry);
1989-
int get_head(const std::string& oid, std::unique_ptr<rgw::sal::Lifecycle::LCHead>* head);
1990-
int put_head(const std::string& oid, rgw::sal::Lifecycle::LCHead& head);
1987+
uint32_t max_entries, std::vector<rgw::sal::LCEntry>& entries);
1988+
int rm_entry(const std::string& oid, const rgw::sal::LCEntry& entry);
1989+
int get_head(const std::string& oid, rgw::sal::LCHead& head);
1990+
int put_head(const std::string& oid, const rgw::sal::LCHead& head);
19911991
int delete_stale_objs(const DoutPrefixProvider *dpp, const std::string& bucket,
19921992
uint32_t min_wait);
19931993
int createGC(const DoutPrefixProvider *_dpp);

‎src/rgw/driver/dbstore/sqlite/sqliteDB.cc‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -561,9 +561,9 @@ static int list_lc_entry(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_st
561561
return -1;
562562

563563
op.lc_entry.index = (const char*)sqlite3_column_text(stmt, LCEntryIndex);
564-
op.lc_entry.entry.set_bucket((const char*)sqlite3_column_text(stmt, LCEntryBucketName));
565-
op.lc_entry.entry.set_start_time(sqlite3_column_int(stmt, LCEntryStartTime));
566-
op.lc_entry.entry.set_status(sqlite3_column_int(stmt, LCEntryStatus));
564+
op.lc_entry.entry.bucket = (const char*)sqlite3_column_text(stmt, LCEntryBucketName);
565+
op.lc_entry.entry.start_time = sqlite3_column_int(stmt, LCEntryStartTime);
566+
op.lc_entry.entry.status = sqlite3_column_int(stmt, LCEntryStatus);
567567

568568
op.lc_entry.list_entries.push_back(op.lc_entry.entry);
569569

@@ -577,10 +577,10 @@ static int list_lc_head(const DoutPrefixProvider *dpp, DBOpInfo &op, sqlite3_stm
577577
int64_t start_date;
578578

579579
op.lc_head.index = (const char*)sqlite3_column_text(stmt, LCHeadIndex);
580-
op.lc_head.head.set_marker((const char*)sqlite3_column_text(stmt, LCHeadMarker));
580+
op.lc_head.head.marker = (const char*)sqlite3_column_text(stmt, LCHeadMarker);
581581

582582
SQL_DECODE_BLOB_PARAM(dpp, stmt, LCHeadStartDate, start_date, sdb);
583-
op.lc_head.head.get_start_date() = start_date;
583+
op.lc_head.head.start_date = start_date;
584584

585585
return 0;
586586
}
@@ -2692,13 +2692,13 @@ int SQLInsertLCEntry::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *par
26922692
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_entry.index.c_str(), sdb);
26932693

26942694
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.lc_entry.bucket_name, sdb);
2695-
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_entry.entry.get_bucket().c_str(), sdb);
2695+
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_entry.entry.bucket.c_str(), sdb);
26962696

26972697
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.lc_entry.status, sdb);
2698-
SQL_BIND_INT(dpp, stmt, index, params->op.lc_entry.entry.get_status(), sdb);
2698+
SQL_BIND_INT(dpp, stmt, index, params->op.lc_entry.entry.status, sdb);
26992699

27002700
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.lc_entry.start_time, sdb);
2701-
SQL_BIND_INT(dpp, stmt, index, params->op.lc_entry.entry.get_start_time(), sdb);
2701+
SQL_BIND_INT(dpp, stmt, index, params->op.lc_entry.entry.start_time, sdb);
27022702

27032703
out:
27042704
return rc;
@@ -2741,7 +2741,7 @@ int SQLRemoveLCEntry::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *par
27412741
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_entry.index.c_str(), sdb);
27422742

27432743
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.lc_entry.bucket_name, sdb);
2744-
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_entry.entry.get_bucket().c_str(), sdb);
2744+
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_entry.entry.bucket.c_str(), sdb);
27452745

27462746
out:
27472747
return rc;
@@ -2796,7 +2796,7 @@ int SQLGetLCEntry::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *params
27962796
SQL_BIND_TEXT(dpp, *pstmt, index, params->op.lc_entry.index.c_str(), sdb);
27972797

27982798
SQL_BIND_INDEX(dpp, *pstmt, index, p_params.op.lc_entry.bucket_name, sdb);
2799-
SQL_BIND_TEXT(dpp, *pstmt, index, params->op.lc_entry.entry.get_bucket().c_str(), sdb);
2799+
SQL_BIND_TEXT(dpp, *pstmt, index, params->op.lc_entry.entry.bucket.c_str(), sdb);
28002800

28012801
out:
28022802
return rc;
@@ -2892,7 +2892,7 @@ int SQLInsertLCHead::Bind(const DoutPrefixProvider *dpp, struct DBOpParams *para
28922892
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_head.index.c_str(), sdb);
28932893

28942894
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.lc_head.marker, sdb);
2895-
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_head.head.get_marker().c_str(), sdb);
2895+
SQL_BIND_TEXT(dpp, stmt, index, params->op.lc_head.head.marker.c_str(), sdb);
28962896

28972897
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.lc_head.start_date, sdb);
28982898
SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, static_cast<int64_t>(params->op.lc_head.head.start_date), sdb);

‎src/rgw/driver/dbstore/tests/dbstore_tests.cc‎

Lines changed: 31 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -1255,31 +1255,30 @@ TEST_F(DBStoreTest, LCHead) {
12551255
std::string index1 = "bucket1";
12561256
std::string index2 = "bucket2";
12571257
time_t lc_time = ceph_clock_now();
1258-
std::unique_ptr<rgw::sal::Lifecycle::LCHead> head;
1259-
std::string ents[] = {"entry1", "entry2", "entry3"};
1260-
rgw::sal::StoreLifecycle::StoreLCHead head1(lc_time, 0, ents[0]);
1261-
rgw::sal::StoreLifecycle::StoreLCHead head2(lc_time, 0, ents[1]);
1262-
rgw::sal::StoreLifecycle::StoreLCHead head3(lc_time, 0, ents[2]);
1258+
rgw::sal::LCHead head;
1259+
rgw::sal::LCHead head1{lc_time, "entry1"};
1260+
rgw::sal::LCHead head2{lc_time, "entry2"};
1261+
rgw::sal::LCHead head3{lc_time, "entry3"};
12631262

12641263
ret = db->put_head(index1, head1);
12651264
ASSERT_EQ(ret, 0);
12661265
ret = db->put_head(index2, head2);
12671266
ASSERT_EQ(ret, 0);
12681267

1269-
ret = db->get_head(index1, &head);
1268+
ret = db->get_head(index1, head);
12701269
ASSERT_EQ(ret, 0);
1271-
ASSERT_EQ(head->get_marker(), "entry1");
1270+
ASSERT_EQ(head.marker, "entry1");
12721271

1273-
ret = db->get_head(index2, &head);
1272+
ret = db->get_head(index2, head);
12741273
ASSERT_EQ(ret, 0);
1275-
ASSERT_EQ(head->get_marker(), "entry2");
1274+
ASSERT_EQ(head.marker, "entry2");
12761275

12771276
// update index1
12781277
ret = db->put_head(index1, head3);
12791278
ASSERT_EQ(ret, 0);
1280-
ret = db->get_head(index1, &head);
1279+
ret = db->get_head(index1, head);
12811280
ASSERT_EQ(ret, 0);
1282-
ASSERT_EQ(head->get_marker(), "entry3");
1281+
ASSERT_EQ(head.marker, "entry3");
12831282

12841283
}
12851284
TEST_F(DBStoreTest, LCEntry) {
@@ -1290,13 +1289,13 @@ TEST_F(DBStoreTest, LCEntry) {
12901289
std::string index2 = "lcindex2";
12911290
typedef enum {lc_uninitial = 1, lc_complete} status;
12921291
std::string ents[] = {"bucket1", "bucket2", "bucket3", "bucket4"};
1293-
std::unique_ptr<rgw::sal::Lifecycle::LCEntry> entry;
1294-
rgw::sal::StoreLifecycle::StoreLCEntry entry1(ents[0], lc_time, lc_uninitial);
1295-
rgw::sal::StoreLifecycle::StoreLCEntry entry2(ents[1], lc_time, lc_uninitial);
1296-
rgw::sal::StoreLifecycle::StoreLCEntry entry3(ents[2], lc_time, lc_uninitial);
1297-
rgw::sal::StoreLifecycle::StoreLCEntry entry4(ents[3], lc_time, lc_uninitial);
1292+
rgw::sal::LCEntry entry;
1293+
rgw::sal::LCEntry entry1{ents[0], lc_time, lc_uninitial};
1294+
rgw::sal::LCEntry entry2{ents[1], lc_time, lc_uninitial};
1295+
rgw::sal::LCEntry entry3{ents[2], lc_time, lc_uninitial};
1296+
rgw::sal::LCEntry entry4{ents[3], lc_time, lc_uninitial};
12981297

1299-
vector<std::unique_ptr<rgw::sal::Lifecycle::LCEntry>> lc_entries;
1298+
vector<rgw::sal::LCEntry> lc_entries;
13001299

13011300
ret = db->set_entry(index1, entry1);
13021301
ASSERT_EQ(ret, 0);
@@ -1308,44 +1307,44 @@ TEST_F(DBStoreTest, LCEntry) {
13081307
ASSERT_EQ(ret, 0);
13091308

13101309
// get entry index1, entry1
1311-
ret = db->get_entry(index1, ents[0], &entry);
1310+
ret = db->get_entry(index1, ents[0], entry);
13121311
ASSERT_EQ(ret, 0);
1313-
ASSERT_EQ(entry->get_status(), lc_uninitial);
1314-
ASSERT_EQ(entry->get_start_time(), lc_time);
1312+
ASSERT_EQ(entry.status, lc_uninitial);
1313+
ASSERT_EQ(entry.start_time, lc_time);
13151314

13161315
// get next entry index1, entry2
1317-
ret = db->get_next_entry(index1, ents[1], &entry);
1316+
ret = db->get_next_entry(index1, ents[1], entry);
13181317
ASSERT_EQ(ret, 0);
1319-
ASSERT_EQ(entry->get_bucket(), ents[2]);
1320-
ASSERT_EQ(entry->get_status(), lc_uninitial);
1321-
ASSERT_EQ(entry->get_start_time(), lc_time);
1318+
ASSERT_EQ(entry.bucket, ents[2]);
1319+
ASSERT_EQ(entry.status, lc_uninitial);
1320+
ASSERT_EQ(entry.start_time, lc_time);
13221321

13231322
// update entry4 to entry5
13241323
entry4.status = lc_complete;
13251324
ret = db->set_entry(index2, entry4);
13261325
ASSERT_EQ(ret, 0);
1327-
ret = db->get_entry(index2, ents[3], &entry);
1326+
ret = db->get_entry(index2, ents[3], entry);
13281327
ASSERT_EQ(ret, 0);
1329-
ASSERT_EQ(entry->get_status(), lc_complete);
1328+
ASSERT_EQ(entry.status, lc_complete);
13301329

13311330
// list entries
13321331
ret = db->list_entries(index1, "", 5, lc_entries);
13331332
ASSERT_EQ(ret, 0);
13341333
for (const auto& ent: lc_entries) {
13351334
cout << "###################### \n";
1336-
cout << "lc entry.bucket : " << ent->get_bucket() << "\n";
1337-
cout << "lc entry.status : " << ent->get_status() << "\n";
1335+
cout << "lc entry.bucket : " << ent.bucket << "\n";
1336+
cout << "lc entry.status : " << ent.status << "\n";
13381337
}
13391338

13401339
// remove index1, entry3
13411340
ret = db->rm_entry(index1, entry3);
13421341
ASSERT_EQ(ret, 0);
13431342

1344-
// get next entry index1, entry2.. should be null
1345-
entry.release();
1346-
ret = db->get_next_entry(index1, ents[1], &entry);
1343+
// get next entry index1, entry2.. should be empty
1344+
entry = rgw::sal::LCEntry{};
1345+
ret = db->get_next_entry(index1, ents[1], entry);
13471346
ASSERT_EQ(ret, 0);
1348-
ASSERT_EQ(entry.get(), nullptr);
1347+
ASSERT_TRUE(entry.bucket.empty());
13491348
}
13501349

13511350
TEST_F(DBStoreTest, RemoveBucket) {

0 commit comments

Comments
 (0)