From 5b118ca7b9daf3e1031d68fdd3e7812ed6aa646f Mon Sep 17 00:00:00 2001 From: Samuel Just Date: Tue, 3 May 2016 12:03:22 -0700 Subject: [PATCH] osd_types: make pg_missing_t::[r]missing private We want to ensure that nothing is mutating these outside of the interface. Signed-off-by: Samuel Just --- src/osd/OSD.cc | 4 +-- src/osd/PG.cc | 5 +-- src/osd/PG.h | 12 +++---- src/osd/PGLog.cc | 22 ++++++------- src/osd/PGLog.h | 11 ++++--- src/osd/ReplicatedBackend.cc | 10 +++--- src/osd/ReplicatedPG.cc | 56 ++++++++++++++++---------------- src/osd/osd_types.cc | 4 +-- src/osd/osd_types.h | 18 ++++++++--- src/test/osd/TestPGLog.cc | 33 ++++++++++--------- src/test/osd/types.cc | 62 ++++++++++++++++++------------------ 11 files changed, 125 insertions(+), 112 deletions(-) diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc index f8942ef7b98..015e6beedf7 100644 --- a/src/osd/OSD.cc +++ b/src/osd/OSD.cc @@ -5703,9 +5703,9 @@ void OSD::do_command(Connection *con, ceph_tid_t tid, vector& cmd, buffe fout << *pg << std::endl; std::map::const_iterator mend = - pg->pg_log.get_missing().missing.end(); + pg->pg_log.get_missing().get_items().end(); std::map::const_iterator mi = - pg->pg_log.get_missing().missing.begin(); + pg->pg_log.get_missing().get_items().begin(); for (; mi != mend; ++mi) { fout << mi->first << " -> " << mi->second << std::endl; if (!pg->missing_loc.needs_recovery(mi->first)) diff --git a/src/osd/PG.cc b/src/osd/PG.cc index 765955ca88e..aa94b74c8f5 100644 --- a/src/osd/PG.cc +++ b/src/osd/PG.cc @@ -337,8 +337,9 @@ void PG::proc_replica_log( dout(10) << " peer osd." << from << " now " << oinfo << " " << omissing << dendl; might_have_unfound.insert(from); - for (map::iterator i = omissing.missing.begin(); - i != omissing.missing.end(); + for (map::const_iterator i = + omissing.get_items().begin(); + i != omissing.get_items().end(); ++i) { dout(20) << " after missing " << i->first << " need " << i->second.need << " have " << i->second.have << dendl; diff --git a/src/osd/PG.h b/src/osd/PG.h index 3e77fb94688..cc196430e38 100644 --- a/src/osd/PG.h +++ b/src/osd/PG.h @@ -383,8 +383,8 @@ public: } void add_active_missing(const pg_missing_t &missing) { for (map::const_iterator i = - missing.missing.begin(); - i != missing.missing.end(); + missing.get_items().begin(); + i != missing.get_items().end(); ++i) { map::const_iterator j = needs_recovery_map.find(i->first); @@ -440,8 +440,8 @@ public: const map &pinfo) { recovered(hoid); boost::optional item; - auto miter = missing.missing.find(hoid); - if (miter != missing.missing.end()) { + auto miter = missing.get_items().find(hoid); + if (miter != missing.get_items().end()) { item = miter->second; } else { for (auto &&i: to_recover) { @@ -449,8 +449,8 @@ public: continue; auto pmiter = pmissing.find(i); assert(pmiter != pmissing.end()); - miter = pmiter->second.missing.find(hoid); - if (miter != pmiter->second.missing.end()) { + miter = pmiter->second.get_items().find(hoid); + if (miter != pmiter->second.get_items().end()) { item = miter->second; break; } diff --git a/src/osd/PGLog.cc b/src/osd/PGLog.cc index c8e30d1f713..bda3e76b200 100644 --- a/src/osd/PGLog.cc +++ b/src/osd/PGLog.cc @@ -216,8 +216,8 @@ void PGLog::proc_replica_log( we will send the peer enough log to arrive at the same state. */ - for (map::iterator i = omissing.missing.begin(); - i != omissing.missing.end(); + for (map::const_iterator i = omissing.get_items().begin(); + i != omissing.get_items().end(); ++i) { dout(20) << " before missing " << i->first << " need " << i->second.need << " have " << i->second.have << dendl; @@ -293,7 +293,7 @@ void PGLog::proc_replica_log( if (omissing.have_missing()) { eversion_t first_missing = - omissing.missing[omissing.rmissing.begin()->second].need; + omissing.get_items().at(omissing.get_rmissing().begin()->second).need; oinfo.last_complete = eversion_t(); list::const_iterator i = olog.log.begin(); for (; @@ -395,7 +395,7 @@ void PGLog::_merge_object_divergent_entries( // ensure missing has been updated appropriately if (objiter->second->is_update()) { assert(missing.is_missing(hoid) && - missing.missing[hoid].need == objiter->second->version); + missing.get_items().at(hoid).need == objiter->second->version); } else { assert(!missing.is_missing(hoid)); } @@ -414,7 +414,7 @@ void PGLog::_merge_object_divergent_entries( << " deleting" << dendl; if (missing.is_missing(hoid)) - missing.rm(missing.missing.find(hoid)); + missing.rm(missing.get_items().find(hoid)); if (rollbacker && !object_not_in_store) rollbacker->remove(hoid); return; @@ -423,17 +423,17 @@ void PGLog::_merge_object_divergent_entries( if (missing.is_missing(hoid)) { /// Case 3) ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid - << " missing, " << missing.missing[hoid] + << " missing, " << missing.get_items().at(hoid) << " adjusting" << dendl; - if (missing.missing[hoid].have == prior_version) { + if (missing.get_items().at(hoid).have == prior_version) { ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid << " missing.have is prior_version " << prior_version << " removing from missing" << dendl; - missing.rm(missing.missing.find(hoid)); + missing.rm(missing.get_items().find(hoid)); } else { ldpp_dout(dpp, 10) << __func__ << ": hoid " << hoid - << " missing.have is " << missing.missing[hoid].have + << " missing.have is " << missing.get_items().at(hoid).have << ", adjusting" << dendl; missing.revise_need(hoid, prior_version); if (prior_version <= info.log_tail) { @@ -624,8 +624,8 @@ void PGLog::merge_log(ObjectStore::Transaction& t, // The logs must overlap. assert(log.head >= olog.tail && olog.head >= log.tail); - for (map::iterator i = missing.missing.begin(); - i != missing.missing.end(); + for (map::const_iterator i = missing.get_items().begin(); + i != missing.get_items().end(); ++i) { dout(20) << "pg_missing_t sobject: " << i->first << dendl; } diff --git a/src/osd/PGLog.h b/src/osd/PGLog.h index 167934fe342..f53f05d4f19 100644 --- a/src/osd/PGLog.h +++ b/src/osd/PGLog.h @@ -631,13 +631,14 @@ public: missing.got(oid, v); // raise last_complete? - if (missing.missing.empty()) { + if (missing.get_items().empty()) { log.complete_to = log.log.end(); info.last_complete = info.last_update; } while (log.complete_to != log.log.end()) { - if (missing.missing[missing.rmissing.begin()->second].need <= - log.complete_to->version) + if (missing.get_items().at( + missing.get_rmissing().begin()->second + ).need <= log.complete_to->version) break; if (info.last_complete < log.complete_to->version) info.last_complete = log.complete_to->version; @@ -652,7 +653,9 @@ public: void activate_not_complete(pg_info_t &info) { log.complete_to = log.log.begin(); while (log.complete_to->version < - missing.missing[missing.rmissing.begin()->second].need) + missing.get_items().at( + missing.get_rmissing().begin()->second + ).need) ++log.complete_to; assert(log.complete_to != log.log.end()); if (log.complete_to == log.log.begin()) { diff --git a/src/osd/ReplicatedBackend.cc b/src/osd/ReplicatedBackend.cc index d9610f5d4af..c72ad925696 100644 --- a/src/osd/ReplicatedBackend.cc +++ b/src/osd/ReplicatedBackend.cc @@ -1416,8 +1416,8 @@ void ReplicatedBackend::prepare_pull( ObjectContextRef headctx, RPGHandle *h) { - assert(get_parent()->get_local_missing().missing.count(soid)); - eversion_t _v = get_parent()->get_local_missing().missing.find( + assert(get_parent()->get_local_missing().get_items().count(soid)); + eversion_t _v = get_parent()->get_local_missing().get_items().find( soid)->second.need; assert(_v == v); const map, hobject_t::BitwiseComparator> &missing_loc( @@ -1444,11 +1444,11 @@ void ReplicatedBackend::prepare_pull( assert(peer_missing.count(fromshard)); const pg_missing_t &pmissing = peer_missing.find(fromshard)->second; if (pmissing.is_missing(soid, v)) { - assert(pmissing.missing.find(soid)->second.have != v); + assert(pmissing.get_items().find(soid)->second.have != v); dout(10) << "pulling soid " << soid << " from osd " << fromshard - << " at version " << pmissing.missing.find(soid)->second.have + << " at version " << pmissing.get_items().find(soid)->second.have << " rather than at version " << v << dendl; - v = pmissing.missing.find(soid)->second.have; + v = pmissing.get_items().find(soid)->second.have; assert(get_parent()->get_log().get_log().objects.count(soid) && (get_parent()->get_log().get_log().objects.find(soid)->second->op == pg_log_entry_t::LOST_REVERT) && diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc index 2fd435e0f7f..478da38c622 100644 --- a/src/osd/ReplicatedPG.cc +++ b/src/osd/ReplicatedPG.cc @@ -186,7 +186,7 @@ void ReplicatedPG::on_local_recover( } if (pg_log.get_missing().is_missing(recovery_info.soid) && - pg_log.get_missing().missing.find(recovery_info.soid)->second.need > recovery_info.version) { + pg_log.get_missing().get_items().find(recovery_info.soid)->second.need > recovery_info.version) { assert(is_primary()); const pg_log_entry_t *latest = pg_log.get_log().objects.find(recovery_info.soid)->second; if (latest->op == pg_log_entry_t::LOST_REVERT && @@ -236,7 +236,7 @@ void ReplicatedPG::on_local_recover( requeue_ops(waiting_for_unreadable_object[hoid]); waiting_for_unreadable_object.erase(hoid); } - if (pg_log.get_missing().missing.size() == 0) { + if (pg_log.get_missing().get_items().size() == 0) { requeue_ops(waiting_for_all_missing); waiting_for_all_missing.clear(); } @@ -354,7 +354,7 @@ PerfCounters *ReplicatedPG::get_logger() bool ReplicatedPG::is_missing_object(const hobject_t& soid) const { - return pg_log.get_missing().missing.count(soid); + return pg_log.get_missing().get_items().count(soid); } void ReplicatedPG::maybe_kick_recovery( @@ -405,7 +405,7 @@ bool ReplicatedPG::is_degraded_or_backfilling_object(const hobject_t& soid) */ if (waiting_for_degraded_object.count(soid)) return true; - if (pg_log.get_missing().missing.count(soid)) + if (pg_log.get_missing().get_items().count(soid)) return true; assert(!actingbackfill.empty()); for (set::iterator i = actingbackfill.begin(); @@ -414,7 +414,7 @@ bool ReplicatedPG::is_degraded_or_backfilling_object(const hobject_t& soid) if (*i == get_primary()) continue; pg_shard_t peer = *i; if (peer_missing.count(peer) && - peer_missing[peer].missing.count(soid)) + peer_missing[peer].get_items().count(soid)) return true; // Object is degraded if after last_backfill AND @@ -848,7 +848,7 @@ int ReplicatedPG::do_command( bool ReplicatedPG::pg_op_must_wait(MOSDOp *op) { - if (pg_log.get_missing().missing.empty()) + if (pg_log.get_missing().get_items().empty()) return false; for (vector::iterator p = op->ops.begin(); p != op->ops.end(); ++p) { if (p->op.op == CEPH_OSD_OP_PGLS || p->op.op == CEPH_OSD_OP_PGNLS || @@ -957,18 +957,18 @@ void ReplicatedPG::do_pg_op(OpRequestRef op) break; } - assert(snapid == CEPH_NOSNAP || pg_log.get_missing().missing.empty()); + assert(snapid == CEPH_NOSNAP || pg_log.get_missing().get_items().empty()); // ensure sort order is correct pg_log.resort_missing(get_sort_bitwise()); map::const_iterator missing_iter = - pg_log.get_missing().missing.lower_bound(current); + pg_log.get_missing().get_items().lower_bound(current); vector::iterator ls_iter = sentries.begin(); hobject_t _max = hobject_t::get_max(); while (1) { const hobject_t &mcand = - missing_iter == pg_log.get_missing().missing.end() ? + missing_iter == pg_log.get_missing().get_items().end() ? _max : missing_iter->first; const hobject_t &lcand = @@ -1061,7 +1061,7 @@ void ReplicatedPG::do_pg_op(OpRequestRef op) } if (next.is_max() && - missing_iter == pg_log.get_missing().missing.end() && + missing_iter == pg_log.get_missing().get_items().end() && ls_iter == sentries.end()) { result = 1; @@ -1144,18 +1144,18 @@ void ReplicatedPG::do_pg_op(OpRequestRef op) break; } - assert(snapid == CEPH_NOSNAP || pg_log.get_missing().missing.empty()); + assert(snapid == CEPH_NOSNAP || pg_log.get_missing().get_items().empty()); // ensure sort order is correct pg_log.resort_missing(get_sort_bitwise()); map::const_iterator missing_iter = - pg_log.get_missing().missing.lower_bound(current); + pg_log.get_missing().get_items().lower_bound(current); vector::iterator ls_iter = sentries.begin(); hobject_t _max = hobject_t::get_max(); while (1) { const hobject_t &mcand = - missing_iter == pg_log.get_missing().missing.end() ? + missing_iter == pg_log.get_missing().get_items().end() ? _max : missing_iter->first; const hobject_t &lcand = @@ -1230,7 +1230,7 @@ void ReplicatedPG::do_pg_op(OpRequestRef op) candidate.get_key())); } if (next.is_max() && - missing_iter == pg_log.get_missing().missing.end() && + missing_iter == pg_log.get_missing().get_items().end() && ls_iter == sentries.end()) { result = 1; } @@ -9490,7 +9490,7 @@ int ReplicatedPG::recover_missing( return PULL_NONE; } else { int r = recover_missing( - head, pg_log.get_missing().missing.find(head)->second.need, priority, + head, pg_log.get_missing().get_items().find(head)->second.need, priority, h); if (r != PULL_NONE) return PULL_OTHER; @@ -9504,7 +9504,7 @@ int ReplicatedPG::recover_missing( return PULL_NONE; } else { int r = recover_missing( - head, pg_log.get_missing().missing.find(head)->second.need, priority, + head, pg_log.get_missing().get_items().find(head)->second.need, priority, h); if (r != PULL_NONE) return PULL_OTHER; @@ -9705,7 +9705,7 @@ eversion_t ReplicatedPG::pick_newest_available(const hobject_t& oid) eversion_t v; assert(pg_log.get_missing().is_missing(oid)); - v = pg_log.get_missing().missing.find(oid)->second.have; + v = pg_log.get_missing().get_items().find(oid)->second.have; dout(10) << "pick_newest_available " << oid << " " << v << " on osd." << osd->whoami << " (local)" << dendl; assert(!actingbackfill.empty()); @@ -9718,7 +9718,7 @@ eversion_t ReplicatedPG::pick_newest_available(const hobject_t& oid) assert(is_backfill_targets(peer)); continue; } - eversion_t h = peer_missing[peer].missing[oid].have; + eversion_t h = peer_missing[peer].get_items().at(oid).have; dout(10) << "pick_newest_available " << oid << " " << h << " on osd." << peer << dendl; if (h > v) v = h; @@ -10471,7 +10471,7 @@ bool ReplicatedPG::start_recovery_ops( if (missing.num_missing() > 0) { // this shouldn't happen! osd->clog->error() << info.pgid << " recovery ending with " << missing.num_missing() - << ": " << missing.missing << "\n"; + << ": " << missing.get_items() << "\n"; return work_in_progress; } @@ -10528,7 +10528,7 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl dout(10) << "recover_primary recovering " << recovering.size() << " in pg" << dendl; dout(10) << "recover_primary " << missing << dendl; - dout(25) << "recover_primary " << missing.missing << dendl; + dout(25) << "recover_primary " << missing.get_items() << dendl; // look at log! pg_log_entry_t *latest = 0; @@ -10537,8 +10537,8 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl PGBackend::RecoveryHandle *h = pgbackend->open_recovery_op(); map::const_iterator p = - missing.rmissing.lower_bound(pg_log.get_log().last_requested); - while (p != missing.rmissing.end()) { + missing.get_rmissing().lower_bound(pg_log.get_log().last_requested); + while (p != missing.get_rmissing().end()) { handle.reset_tp_timeout(); hobject_t soid; version_t v = p->first; @@ -10551,7 +10551,7 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl latest = 0; soid = p->second; } - const pg_missing_t::item& item = missing.missing.find(p->second)->second; + const pg_missing_t::item& item = missing.get_items().find(p->second)->second; ++p; hobject_t head = soid; @@ -10629,7 +10629,7 @@ uint64_t ReplicatedPG::recover_primary(uint64_t max, ThreadPool::TPHandle &handl p != peer_missing.end(); ++p) if (p->second.is_missing(soid, need) && - p->second.missing[soid].have == alternate_need) { + p->second.get_items().at(soid).have == alternate_need) { missing_loc.add_location(soid, p->first); } dout(10) << " will pull " << alternate_need << " or " << need @@ -10758,12 +10758,12 @@ uint64_t ReplicatedPG::recover_replicas(uint64_t max, ThreadPool::TPHandle &hand size_t m_sz = pm->second.num_missing(); dout(10) << " peer osd." << peer << " missing " << m_sz << " objects." << dendl; - dout(20) << " peer osd." << peer << " missing " << pm->second.missing << dendl; + dout(20) << " peer osd." << peer << " missing " << pm->second.get_items() << dendl; // oldest first! const pg_missing_t &m(pm->second); - for (map::const_iterator p = m.rmissing.begin(); - p != m.rmissing.end() && started < max; + for (map::const_iterator p = m.get_rmissing().begin(); + p != m.get_rmissing().end() && started < max; ++p) { handle.reset_tp_timeout(); const hobject_t soid(p->second); @@ -10805,7 +10805,7 @@ uint64_t ReplicatedPG::recover_replicas(uint64_t max, ThreadPool::TPHandle &hand } dout(10) << __func__ << ": recover_object_replicas(" << soid << ")" << dendl; - map::const_iterator r = m.missing.find(soid); + map::const_iterator r = m.get_items().find(soid); started += prep_object_replica_pushes(soid, r->second.need, h); } diff --git a/src/osd/osd_types.cc b/src/osd/osd_types.cc index 58f66d5bc84..8cb98af1fff 100644 --- a/src/osd/osd_types.cc +++ b/src/osd/osd_types.cc @@ -3957,7 +3957,7 @@ void pg_missing_t::rm(const hobject_t& oid, eversion_t v) rm(p); } -void pg_missing_t::rm(const std::map::iterator &m) +void pg_missing_t::rm(std::map::const_iterator m) { rmissing.erase(m->second.need.version); missing.erase(m); @@ -3971,7 +3971,7 @@ void pg_missing_t::got(const hobject_t& oid, eversion_t v) got(p); } -void pg_missing_t::got(const std::map::iterator &m) +void pg_missing_t::got(std::map::iterator m) { rmissing.erase(m->second.need.version); missing.erase(m); diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h index 694232bbb67..169ee2390a1 100644 --- a/src/osd/osd_types.h +++ b/src/osd/osd_types.h @@ -2744,7 +2744,8 @@ inline ostream& operator<<(ostream& out, const pg_log_t& log) * kept in memory, as a supplement to pg_log_t * also used to pass missing info in messages. */ -struct pg_missing_t { +class pg_missing_t { +public: struct item { eversion_t need, have; item() {} @@ -2772,23 +2773,32 @@ struct pg_missing_t { }; WRITE_CLASS_ENCODER(item) +private: map missing; // oid -> (need v, have v) map rmissing; // v -> oid +public: + const map &get_items() const { + return missing; + } + const map &get_rmissing() const { + return rmissing; + } unsigned int num_missing() const; bool have_missing() const; - void swap(pg_missing_t& o); bool is_missing(const hobject_t& oid) const; bool is_missing(const hobject_t& oid, eversion_t v) const; eversion_t have_old(const hobject_t& oid) const; + + void swap(pg_missing_t& o); void add_next_event(const pg_log_entry_t& e); void revise_need(hobject_t oid, eversion_t need); void revise_have(hobject_t oid, eversion_t have); void add(const hobject_t& oid, eversion_t need, eversion_t have); void rm(const hobject_t& oid, eversion_t v); - void rm(const std::map::iterator &m); + void rm(std::map::const_iterator m); void got(const hobject_t& oid, eversion_t v); - void got(const std::map::iterator &m); + void got(std::map::const_iterator m); void split_into(pg_t child_pgid, unsigned split_bits, pg_missing_t *omissing); void clear() { diff --git a/src/test/osd/TestPGLog.cc b/src/test/osd/TestPGLog.cc index f92cbe31300..8f39c1111a2 100644 --- a/src/test/osd/TestPGLog.cc +++ b/src/test/osd/TestPGLog.cc @@ -123,10 +123,10 @@ public: fulldiv.tail = divinfo.log_tail; divinfo.last_backfill = hobject_t::get_max(); - if (init.missing.empty()) { + if (init.get_items().empty()) { divinfo.last_complete = divinfo.last_update; } else { - eversion_t fmissing = init.missing[init.rmissing.begin()->second].need; + eversion_t fmissing = init.get_items().at(init.get_rmissing().begin()->second).need; for (list::const_iterator i = fulldiv.log.begin(); i != fulldiv.log.end(); ++i) { @@ -176,14 +176,13 @@ public: void verify_missing( const TestCase &tcase, const pg_missing_t &missing) { - ASSERT_EQ(tcase.final.missing.size(), missing.missing.size()); - for (map::const_iterator i = - missing.missing.begin(); - i != missing.missing.end(); + ASSERT_EQ(tcase.final.get_items().size(), missing.get_items().size()); + for (auto i = missing.get_items().begin(); + i != missing.get_items().end(); ++i) { - EXPECT_TRUE(tcase.final.missing.count(i->first)); - EXPECT_EQ(tcase.final.missing.find(i->first)->second.need, i->second.need); - EXPECT_EQ(tcase.final.missing.find(i->first)->second.have, i->second.have); + EXPECT_TRUE(tcase.final.get_items().count(i->first)); + EXPECT_EQ(tcase.final.get_items().find(i->first)->second.need, i->second.need); + EXPECT_EQ(tcase.final.get_items().find(i->first)->second.have, i->second.have); } } @@ -1515,7 +1514,7 @@ TEST_F(PGLogTest, proc_replica_log) { EXPECT_TRUE(t.empty()); EXPECT_TRUE(omissing.have_missing()); EXPECT_TRUE(omissing.is_missing(divergent_object)); - EXPECT_EQ(eversion_t(1, 2), omissing.missing[divergent_object].need); + EXPECT_EQ(eversion_t(1, 2), omissing.get_items().at(divergent_object).need); EXPECT_EQ(eversion_t(1, 6), oinfo.last_update); EXPECT_EQ(eversion_t(1, 1), oinfo.last_complete); } @@ -1604,8 +1603,8 @@ TEST_F(PGLogTest, proc_replica_log) { EXPECT_TRUE(t.empty()); EXPECT_TRUE(omissing.have_missing()); EXPECT_TRUE(omissing.is_missing(divergent_object)); - EXPECT_EQ(omissing.missing[divergent_object].have, eversion_t(0, 0)); - EXPECT_EQ(omissing.missing[divergent_object].need, eversion_t(1, 1)); + EXPECT_EQ(omissing.get_items().at(divergent_object).have, eversion_t(0, 0)); + EXPECT_EQ(omissing.get_items().at(divergent_object).need, eversion_t(1, 1)); EXPECT_EQ(last_update, oinfo.last_update); } @@ -1687,7 +1686,7 @@ TEST_F(PGLogTest, proc_replica_log) { EXPECT_TRUE(t.empty()); EXPECT_TRUE(omissing.have_missing()); EXPECT_TRUE(omissing.is_missing(divergent_object)); - EXPECT_EQ(eversion_t(1, 3), omissing.missing[divergent_object].need); + EXPECT_EQ(eversion_t(1, 3), omissing.get_items().at(divergent_object).need); EXPECT_EQ(olog.head, oinfo.last_update); EXPECT_EQ(olog.head, oinfo.last_complete); @@ -1696,8 +1695,8 @@ TEST_F(PGLogTest, proc_replica_log) { EXPECT_TRUE(t.empty()); EXPECT_TRUE(omissing.have_missing()); EXPECT_TRUE(omissing.is_missing(divergent_object)); - EXPECT_EQ(omissing.missing[divergent_object].have, eversion_t(0, 0)); - EXPECT_EQ(omissing.missing[divergent_object].need, eversion_t(1, 1)); + EXPECT_EQ(omissing.get_items().at(divergent_object).have, eversion_t(0, 0)); + EXPECT_EQ(omissing.get_items().at(divergent_object).need, eversion_t(1, 1)); EXPECT_EQ(last_update, oinfo.last_update); } @@ -1783,7 +1782,7 @@ TEST_F(PGLogTest, proc_replica_log) { EXPECT_TRUE(t.empty()); EXPECT_TRUE(omissing.have_missing()); EXPECT_TRUE(omissing.is_missing(divergent_object)); - EXPECT_EQ(divergent_version, omissing.missing[divergent_object].need); + EXPECT_EQ(divergent_version, omissing.get_items().at(divergent_object).need); EXPECT_EQ(olog.head, oinfo.last_update); EXPECT_EQ(olog.head, oinfo.last_complete); @@ -1791,7 +1790,7 @@ TEST_F(PGLogTest, proc_replica_log) { EXPECT_TRUE(t.empty()); EXPECT_TRUE(omissing.have_missing()); - EXPECT_TRUE(omissing.missing.begin()->second.need == eversion_t(1, 1)); + EXPECT_TRUE(omissing.get_items().begin()->second.need == eversion_t(1, 1)); EXPECT_EQ(last_update, oinfo.last_update); EXPECT_EQ(eversion_t(0, 0), oinfo.last_complete); } diff --git a/src/test/osd/types.cc b/src/test/osd/types.cc index ade7dd1a441..3d24d982369 100644 --- a/src/test/osd/types.cc +++ b/src/test/osd/types.cc @@ -824,16 +824,16 @@ TEST(pg_missing_t, add_next_event) EXPECT_FALSE(missing.is_missing(oid)); missing.add_next_event(e); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(eversion_t(), missing.missing[oid].have); - EXPECT_EQ(oid, missing.rmissing[e.version.version]); + EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have); + EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version)); EXPECT_EQ(1U, missing.num_missing()); - EXPECT_EQ(1U, missing.rmissing.size()); + EXPECT_EQ(1U, missing.get_rmissing().size()); // adding the same object replaces the previous one missing.add_next_event(e); EXPECT_TRUE(missing.is_missing(oid)); EXPECT_EQ(1U, missing.num_missing()); - EXPECT_EQ(1U, missing.rmissing.size()); + EXPECT_EQ(1U, missing.get_rmissing().size()); } // new object (CLONE) @@ -849,16 +849,16 @@ TEST(pg_missing_t, add_next_event) EXPECT_FALSE(missing.is_missing(oid)); missing.add_next_event(e); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(eversion_t(), missing.missing[oid].have); - EXPECT_EQ(oid, missing.rmissing[e.version.version]); + EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have); + EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version)); EXPECT_EQ(1U, missing.num_missing()); - EXPECT_EQ(1U, missing.rmissing.size()); + EXPECT_EQ(1U, missing.get_rmissing().size()); // adding the same object replaces the previous one missing.add_next_event(e); EXPECT_TRUE(missing.is_missing(oid)); EXPECT_EQ(1U, missing.num_missing()); - EXPECT_EQ(1U, missing.rmissing.size()); + EXPECT_EQ(1U, missing.get_rmissing().size()); } // existing object (MODIFY) @@ -874,18 +874,18 @@ TEST(pg_missing_t, add_next_event) EXPECT_FALSE(missing.is_missing(oid)); missing.add_next_event(e); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(eversion_t(), missing.missing[oid].have); - EXPECT_EQ(oid, missing.rmissing[e.version.version]); + EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have); + EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version)); EXPECT_EQ(1U, missing.num_missing()); - EXPECT_EQ(1U, missing.rmissing.size()); + EXPECT_EQ(1U, missing.get_rmissing().size()); // adding the same object with a different version e.prior_version = prior_version; missing.add_next_event(e); - EXPECT_EQ(eversion_t(), missing.missing[oid].have); + EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have); EXPECT_TRUE(missing.is_missing(oid)); EXPECT_EQ(1U, missing.num_missing()); - EXPECT_EQ(1U, missing.rmissing.size()); + EXPECT_EQ(1U, missing.get_rmissing().size()); } // object with prior version (MODIFY) @@ -900,11 +900,11 @@ TEST(pg_missing_t, add_next_event) EXPECT_FALSE(missing.is_missing(oid)); missing.add_next_event(e); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(prior_version, missing.missing[oid].have); - EXPECT_EQ(version, missing.missing[oid].need); - EXPECT_EQ(oid, missing.rmissing[e.version.version]); + EXPECT_EQ(prior_version, missing.get_items().at(oid).have); + EXPECT_EQ(version, missing.get_items().at(oid).need); + EXPECT_EQ(oid, missing.get_rmissing().at(e.version.version)); EXPECT_EQ(1U, missing.num_missing()); - EXPECT_EQ(1U, missing.rmissing.size()); + EXPECT_EQ(1U, missing.get_rmissing().size()); } // obsolete (BACKLOG) @@ -965,7 +965,7 @@ TEST(pg_missing_t, add_next_event) EXPECT_FALSE(missing.is_missing(oid)); missing.add_next_event(modify); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(missing.missing[oid].need, version); + EXPECT_EQ(missing.get_items().at(oid).need, version); pg_log_entry_t error = sample_e; error.op = pg_log_entry_t::ERROR; @@ -973,7 +973,7 @@ TEST(pg_missing_t, add_next_event) error.version = eversion_t(11, 5); missing.add_next_event(error); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(missing.missing[oid].need, version); + EXPECT_EQ(missing.get_items().at(oid).need, version); } } @@ -986,16 +986,16 @@ TEST(pg_missing_t, revise_need) eversion_t need(10,10); missing.revise_need(oid, need); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(eversion_t(), missing.missing[oid].have); - EXPECT_EQ(need, missing.missing[oid].need); + EXPECT_EQ(eversion_t(), missing.get_items().at(oid).have); + EXPECT_EQ(need, missing.get_items().at(oid).need); // update an existing entry and preserve have eversion_t have(1,1); missing.revise_have(oid, have); eversion_t new_need(10,12); - EXPECT_EQ(have, missing.missing[oid].have); + EXPECT_EQ(have, missing.get_items().at(oid).have); missing.revise_need(oid, new_need); - EXPECT_EQ(have, missing.missing[oid].have); - EXPECT_EQ(new_need, missing.missing[oid].need); + EXPECT_EQ(have, missing.get_items().at(oid).have); + EXPECT_EQ(new_need, missing.get_items().at(oid).need); } TEST(pg_missing_t, revise_have) @@ -1012,10 +1012,10 @@ TEST(pg_missing_t, revise_have) missing.add(oid, need, have); EXPECT_TRUE(missing.is_missing(oid)); eversion_t new_have(2,2); - EXPECT_EQ(have, missing.missing[oid].have); + EXPECT_EQ(have, missing.get_items().at(oid).have); missing.revise_have(oid, new_have); - EXPECT_EQ(new_have, missing.missing[oid].have); - EXPECT_EQ(need, missing.missing[oid].need); + EXPECT_EQ(new_have, missing.get_items().at(oid).have); + EXPECT_EQ(need, missing.get_items().at(oid).need); } TEST(pg_missing_t, add) @@ -1027,8 +1027,8 @@ TEST(pg_missing_t, add) eversion_t need(10,10); missing.add(oid, need, have); EXPECT_TRUE(missing.is_missing(oid)); - EXPECT_EQ(have, missing.missing[oid].have); - EXPECT_EQ(need, missing.missing[oid].need); + EXPECT_EQ(have, missing.get_items().at(oid).have); + EXPECT_EQ(need, missing.get_items().at(oid).need); } TEST(pg_missing_t, rm) @@ -1056,7 +1056,7 @@ TEST(pg_missing_t, rm) EXPECT_FALSE(missing.is_missing(oid)); missing.add(oid, eversion_t(), eversion_t()); EXPECT_TRUE(missing.is_missing(oid)); - const std::map::iterator m = missing.missing.find(oid); + auto m = missing.get_items().find(oid); missing.rm(m); EXPECT_FALSE(missing.is_missing(oid)); } @@ -1088,7 +1088,7 @@ TEST(pg_missing_t, got) EXPECT_FALSE(missing.is_missing(oid)); missing.add(oid, eversion_t(), eversion_t()); EXPECT_TRUE(missing.is_missing(oid)); - const std::map::iterator m = missing.missing.find(oid); + auto m = missing.get_items().find(oid); missing.got(m); EXPECT_FALSE(missing.is_missing(oid)); } -- 2.39.5