int OSDMap::Incremental::get_net_marked_out(const OSDMap *previous) const
{
int n = 0;
- for (const auto &elem : new_weight) {
- if (elem.second == CEPH_OSD_OUT && !previous->is_out(elem.first))
+ for (const auto &weight : new_weight) {
+ if (weight.second == CEPH_OSD_OUT && !previous->is_out(weight.first))
n++; // marked out
- else if (elem.second != CEPH_OSD_OUT && previous->is_out(elem.first))
+ else if (weight.second != CEPH_OSD_OUT && previous->is_out(weight.first))
n--; // marked in
}
return n;
int OSDMap::Incremental::get_net_marked_down(const OSDMap *previous) const
{
int n = 0;
- for (const auto &elem : new_state) {
- if (elem.second & CEPH_OSD_UP) {
- if (previous->is_up(elem.first))
+ for (const auto &state : new_state) { //
+ if (state.second & CEPH_OSD_UP) {
+ if (previous->is_up(state.first))
n++; // marked down
else
n--; // marked up
int OSDMap::Incremental::identify_osd(uuid_d u) const
{
- for (const auto &elem : new_uuid)
- if (elem.second == u)
- return elem.first;
+ for (const auto &uuid : new_uuid)
+ if (uuid.second == u)
+ return uuid.first;
return -1;
}
f->open_array_section("new_up_osds");
- for (const auto &elem : new_up_client) {
+ for (const auto &upclient : new_up_client) {
f->open_object_section("osd");
- f->dump_int("osd", elem.first);
- f->dump_stream("public_addr") << elem.second;
- f->dump_stream("cluster_addr") << new_up_cluster.find(elem.first)->second;
- f->dump_stream("heartbeat_back_addr") << new_hb_back_up.find(elem.first)->second;
+ f->dump_int("osd", upclient.first);
+ f->dump_stream("public_addr") << upclient.second;
+ f->dump_stream("cluster_addr") << new_up_cluster.find(upclient.first)->second;
+ f->dump_stream("heartbeat_back_addr") << new_hb_back_up.find(upclient.first)->second;
map<int32_t, entity_addr_t>::const_iterator q;
- if ((q = new_hb_front_up.find(elem.first)) != new_hb_front_up.end())
+ if ((q = new_hb_front_up.find(upclient.first)) != new_hb_front_up.end())
f->dump_stream("heartbeat_front_addr") << q->second;
f->close_section();
}
f->open_array_section("new_weight");
- for (const auto &elem : new_weight) {
+ for (const auto &weight : new_weight) {
f->open_object_section("osd");
- f->dump_int("osd", elem.first);
- f->dump_int("weight", elem.second);
+ f->dump_int("osd", weight.first);
+ f->dump_int("weight", weight.second);
f->close_section();
}
f->close_section();
set<string> st;
calc_state_set(new_state.find(ns.first)->second, st);
f->open_array_section("state_xor");
- for (auto &elemst : st)
- f->dump_string("state", elemst);
+ for (auto &state : st)
+ f->dump_string("state", state);
f->close_section();
}
f->close_section();
f->dump_stream("pgid") << pg_temp.first;
f->open_array_section("osds");
- for (const auto &elems : pg_temp.second)
- f->dump_int("osd", elems);
+ for (const auto &osd : pg_temp.second)
+ f->dump_int("osd", osd);
f->close_section();
f->close_section();
}
f->open_array_section("primary_temp");
- for (const auto &elem : new_primary_temp) {
- f->dump_stream("pgid") << elem.first;
- f->dump_int("osd", elem.second);
+ for (const auto &primary_temp : new_primary_temp) {
+ f->dump_stream("pgid") << primary_temp.first;
+ f->dump_int("osd", primary_temp.second);
}
f->close_section(); // primary_temp
f->open_array_section("new_up_thru");
- for (const auto &elem : new_up_thru) {
+ for (const auto &up_thru : new_up_thru) {
f->open_object_section("osd");
- f->dump_int("osd", elem.first);
- f->dump_int("up_thru", elem.second);
+ f->dump_int("osd", up_thru.first);
+ f->dump_int("up_thru", up_thru.second);
f->close_section();
}
f->close_section();
f->open_array_section("new_lost");
- for (const auto &elem : new_lost) {
+ for (const auto &lost : new_lost) {
f->open_object_section("osd");
- f->dump_int("osd", elem.first);
- f->dump_int("epoch_lost", elem.second);
+ f->dump_int("osd", lost.first);
+ f->dump_int("epoch_lost", lost.second);
f->close_section();
}
f->close_section();
f->open_array_section("new_last_clean_interval");
- for (const auto &elem : new_last_clean_interval) {
+ for (const auto &last_clean_interval : new_last_clean_interval) {
f->open_object_section("osd");
- f->dump_int("osd", elem.first);
- f->dump_int("first", elem.second.first);
- f->dump_int("last", elem.second.second);
+ f->dump_int("osd", last_clean_interval.first);
+ f->dump_int("first", last_clean_interval.second.first);
+ f->dump_int("last", last_clean_interval.second.second);
f->close_section();
}
f->close_section();
f->open_array_section("new_blacklist");
- for (const auto &elem : new_blacklist) {
+ for (const auto &blacklist : new_blacklist) {
stringstream ss;
- ss << elem.first;
- f->dump_stream(ss.str().c_str()) << elem.second;
+ ss << blacklist.first;
+ f->dump_stream(ss.str().c_str()) << blacklist.second;
}
f->close_section();
f->open_array_section("old_blacklist");
- for (const auto &elem : old_blacklist)
- f->dump_stream("addr") << elem;
+ for (const auto &blacklist : old_blacklist)
+ f->dump_stream("addr") << blacklist;
f->close_section();
f->open_array_section("new_xinfo");
- for (const auto &elem : new_xinfo) {
+ for (const auto &xinfo : new_xinfo) {
f->open_object_section("xinfo");
- f->dump_int("osd", elem.first);
- elem.second.dump(f);
+ f->dump_int("osd", xinfo.first);
+ xinfo.second.dump(f);
f->close_section();
}
f->close_section();
f->dump_string("cluster_snapshot", cluster_snapshot);
f->open_array_section("new_uuid");
- for (const auto &elem : new_uuid) {
+ for (const auto &uuid : new_uuid) {
f->open_object_section("osd");
- f->dump_int("osd", elem.first);
- f->dump_stream("uuid") << elem.second;
+ f->dump_int("osd", uuid.first);
+ f->dump_stream("uuid") << uuid.second;
f->close_section();
}
f->close_section();
OSDMap::dump_erasure_code_profiles(new_erasure_code_profiles, f);
f->open_array_section("old_erasure_code_profiles");
- for (const auto &elem : old_erasure_code_profiles) {
- f->dump_string("old", elem.c_str());
+ for (const auto &erasure_code_profile : old_erasure_code_profiles) {
+ f->dump_string("old", erasure_code_profile.c_str());
}
f->close_section();
}
void OSDMap::set_epoch(epoch_t e)
{
epoch = e;
- for (auto &elem : pools)
- elem.second.last_change = e;
+ for (auto &pool : pools)
+ pool.second.last_change = e;
}
bool OSDMap::is_blacklisted(const entity_addr_t& a) const
void OSDMap::adjust_osd_weights(const map<int,double>& weights, Incremental& inc) const
{
float max = 0;
- for (const auto &elem : weights) {
- if (elem.second > max)
- max = elem.second;
+ for (const auto &weight : weights) {
+ if (weight.second > max)
+ max = weight.second;
}
- for (const auto &elem : weights) {
- inc.new_weight[elem.first] = (unsigned)((elem.second / max) * CEPH_OSD_IN);
+ for (const auto &weight : weights) {
+ inc.new_weight[weight.first] = (unsigned)((weight.second / max) * CEPH_OSD_IN);
}
}
features |= CEPH_FEATUREMASK_OSDMAP_REMAP;
mask |= CEPH_FEATUREMASK_OSDMAP_REMAP;
- for (auto &elem: pools) {
- if (elem.second.has_flag(pg_pool_t::FLAG_HASHPSPOOL)) {
+ for (auto &pool: pools) {
+ if (pool.second.has_flag(pg_pool_t::FLAG_HASHPSPOOL)) {
features |= CEPH_FEATURE_OSDHASHPSPOOL;
}
- if (elem.second.is_erasure() &&
+ if (pool.second.is_erasure() &&
entity_type != CEPH_ENTITY_TYPE_CLIENT) { // not for clients
features |= CEPH_FEATURE_OSD_ERASURE_CODES;
}
- if (!elem.second.tiers.empty() ||
- elem.second.is_tier()) {
+ if (!pool.second.tiers.empty() ||
+ pool.second.is_tier()) {
features |= CEPH_FEATURE_OSD_CACHEPOOL;
}
- int ruleid = crush->find_rule(elem.second.get_crush_ruleset(),
- elem.second.get_type(),
- elem.second.get_size());
+ int ruleid = crush->find_rule(pool.second.get_crush_ruleset(),
+ pool.second.get_type(),
+ pool.second.get_size());
if (ruleid >= 0) {
if (crush->is_v2_rule(ruleid))
features |= CEPH_FEATURE_CRUSH_V2;
}
}
if (entity_type == CEPH_ENTITY_TYPE_OSD) {
- for (auto &elem : erasure_code_profiles) {
- const map<string,string> &profile = elem.second;
+ for (auto &erasure_code_profile : erasure_code_profiles) {
+ const map<string,string> &profile = erasure_code_profile.second;
const auto &plugin = profile.find("plugin");
if (plugin != profile.end()) {
if (plugin->second == "isa" || plugin->second == "lrc")
tmpmap.deepish_copy_from(osdmap);
tmpmap.apply_incremental(*pending_inc);
- for (auto &elem : *tmpmap.pg_temp) {
+ for (auto pg : *tmpmap.pg_temp) {
// if pool does not exist, remove any existing pg_temps associated with
// it. we don't care about pg_temps on the pending_inc either; if there
// are new_pg_temp entries on the pending, clear them out just as well.
- if (!osdmap.have_pg_pool(elem.first.pool())) {
- ldout(cct, 10) << __func__ << " removing pg_temp " << elem.first
- << " for nonexistent pool " << elem.first.pool() << dendl;
- pending_inc->new_pg_temp[elem.first].clear();
+ if (!osdmap.have_pg_pool(pg.first.pool())) {
+ ldout(cct, 10) << __func__ << " removing pg_temp " << pg.first
+ << " for nonexistent pool " << pg.first.pool() << dendl;
+ pending_inc->new_pg_temp[pg.first].clear();
continue;
}
// all osds down?
unsigned num_up = 0;
- for (auto o : elem.second) {
+ for (auto o : pg.second) {
if (!tmpmap.is_down(o)) {
++num_up;
break;
}
}
if (num_up == 0) {
- ldout(cct, 10) << __func__ << " removing pg_temp " << elem.first
- << " with all down osds" << elem.second << dendl;
- pending_inc->new_pg_temp[elem.first].clear();
+ ldout(cct, 10) << __func__ << " removing pg_temp " << pg.first
+ << " with all down osds" << pg.second << dendl;
+ pending_inc->new_pg_temp[pg.first].clear();
continue;
}
// redundant pg_temp?
vector<int> raw_up;
int primary;
- tmpmap.pg_to_raw_up(elem.first, &raw_up, &primary);
- if (raw_up == elem.second) {
- ldout(cct, 10) << __func__ << " removing pg_temp " << elem.first << " "
- << elem.second << " that matches raw_up mapping" << dendl;
- if (osdmap.pg_temp->count(elem.first))
- pending_inc->new_pg_temp[elem.first].clear();
+ tmpmap.pg_to_raw_up(pg.first, &raw_up, &primary);
+ if (raw_up == pg.second) {
+ ldout(cct, 10) << __func__ << " removing pg_temp " << pg.first << " "
+ << pg.second << " that matches raw_up mapping" << dendl;
+ if (osdmap.pg_temp->count(pg.first))
+ pending_inc->new_pg_temp[pg.first].clear();
else
- pending_inc->new_pg_temp.erase(elem.first);
+ pending_inc->new_pg_temp.erase(pg.first);
}
}
- for (auto &elem : *tmpmap.primary_temp) {
+
+ for (auto pg : *tmpmap.primary_temp) {
// primary down?
- if (tmpmap.is_down(elem.second)) {
- ldout(cct, 10) << __func__ << " removing primary_temp " << elem.first
- << " to down " << elem.second << dendl;
- pending_inc->new_primary_temp[elem.first] = -1;
+ if (tmpmap.is_down(pg.second)) {
+ ldout(cct, 10) << __func__ << " removing primary_temp " << pg.first
+ << " to down " << pg.second << dendl;
+ pending_inc->new_primary_temp[pg.first] = -1;
continue;
}
// redundant primary_temp?
vector<int> real_up, templess_up;
int real_primary, templess_primary;
- pg_t pgid = elem.first;
+ pg_t pgid = pg.first;
tmpmap.pg_to_acting_osds(pgid, &real_up, &real_primary);
tmpmap.pg_to_raw_up(pgid, &templess_up, &templess_primary);
if (real_primary == templess_primary){
if (inc.new_pool_max != -1)
pool_max = inc.new_pool_max;
- for (const auto &elem : inc.new_pools) {
- pools[elem.first] = elem.second;
- pools[elem.first].last_change = epoch;
+ for (const auto &pool : inc.new_pools) {
+ pools[pool.first] = pool.second;
+ pools[pool.first].last_change = epoch;
}
- for (const auto &elem : inc.new_pool_names) {
- auto pool_name_entry = pool_name.find(elem.first);
+ for (const auto &pname : inc.new_pool_names) {
+ auto pool_name_entry = pool_name.find(pname.first);
if (pool_name_entry != pool_name.end()) {
name_pool.erase(pool_name_entry->second);
- pool_name_entry->second = elem.second;
+ pool_name_entry->second = pname.second;
} else {
- pool_name[elem.first] = elem.second;
+ pool_name[pname.first] = pname.second;
}
- name_pool[elem.second] = elem.first;
+ name_pool[pname.second] = pname.first;
}
- for (const auto &elem : inc.old_pools) {
- pools.erase(elem);
- name_pool.erase(pool_name[elem]);
- pool_name.erase(elem);
+
+ for (const auto &pool : inc.old_pools) {
+ pools.erase(pool);
+ name_pool.erase(pool_name[pool]);
+ pool_name.erase(pool);
}
- for (const auto &elem : inc.new_weight) {
- set_weight(elem.first, elem.second);
+ for (const auto &weight : inc.new_weight) {
+ set_weight(weight.first, weight.second);
// if we are marking in, clear the AUTOOUT and NEW bits, and clear
// xinfo old_weight.
- if (elem.second) {
- osd_state[elem.first] &= ~(CEPH_OSD_AUTOOUT | CEPH_OSD_NEW);
- osd_xinfo[elem.first].old_weight = 0;
+ if (weight.second) {
+ osd_state[weight.first] &= ~(CEPH_OSD_AUTOOUT | CEPH_OSD_NEW);
+ osd_xinfo[weight.first].old_weight = 0;
}
}
- for (const auto &elem : inc.new_primary_affinity) {
- set_primary_affinity(elem.first, elem.second);
+ for (const auto &primary_affinity : inc.new_primary_affinity) {
+ set_primary_affinity(primary_affinity.first, primary_affinity.second);
}
// erasure_code_profiles
- for (const auto &elem : inc.old_erasure_code_profiles)
- erasure_code_profiles.erase(elem);
+ for (const auto &profile : inc.old_erasure_code_profiles)
+ erasure_code_profiles.erase(profile);
- for (const auto &elem : inc.new_erasure_code_profiles) {
- set_erasure_code_profile(elem.first, elem.second);
+ for (const auto &profile : inc.new_erasure_code_profiles) {
+ set_erasure_code_profile(profile.first, profile.second);
}
// up/down
- for (const auto &elem : inc.new_state) {
- int s = elem.second ? elem.second : CEPH_OSD_UP;
- if ((osd_state[elem.first] & CEPH_OSD_UP) &&
+ for (const auto &state : inc.new_state) {
+ const auto osd = state.first;
+ int s = state.second ? state.second : CEPH_OSD_UP;
+ if ((osd_state[osd] & CEPH_OSD_UP) &&
(s & CEPH_OSD_UP)) {
- osd_info[elem.first].down_at = epoch;
- osd_xinfo[elem.first].down_stamp = modified;
+ osd_info[osd].down_at = epoch;
+ osd_xinfo[osd].down_stamp = modified;
}
- if ((osd_state[elem.first] & CEPH_OSD_EXISTS) &&
+ if ((osd_state[osd] & CEPH_OSD_EXISTS) &&
(s & CEPH_OSD_EXISTS)) {
// osd is destroyed; clear out anything interesting.
- (*osd_uuid)[elem.first] = uuid_d();
- osd_info[elem.first] = osd_info_t();
- osd_xinfo[elem.first] = osd_xinfo_t();
- set_primary_affinity(elem.first, CEPH_OSD_DEFAULT_PRIMARY_AFFINITY);
- osd_addrs->client_addr[elem.first].reset(new entity_addr_t());
- osd_addrs->cluster_addr[elem.first].reset(new entity_addr_t());
- osd_addrs->hb_front_addr[elem.first].reset(new entity_addr_t());
- osd_addrs->hb_back_addr[elem.first].reset(new entity_addr_t());
- osd_state[elem.first] = 0;
+ (*osd_uuid)[osd] = uuid_d();
+ osd_info[osd] = osd_info_t();
+ osd_xinfo[osd] = osd_xinfo_t();
+ set_primary_affinity(osd, CEPH_OSD_DEFAULT_PRIMARY_AFFINITY);
+ osd_addrs->client_addr[osd].reset(new entity_addr_t());
+ osd_addrs->cluster_addr[osd].reset(new entity_addr_t());
+ osd_addrs->hb_front_addr[osd].reset(new entity_addr_t());
+ osd_addrs->hb_back_addr[osd].reset(new entity_addr_t());
+ osd_state[osd] = 0;
} else {
- osd_state[elem.first] ^= s;
+ osd_state[osd] ^= s;
}
}
- for (const auto &elem : inc.new_up_client) {
- osd_state[elem.first] |= CEPH_OSD_EXISTS | CEPH_OSD_UP;
- osd_addrs->client_addr[elem.first].reset(new entity_addr_t(elem.second));
+ for (const auto &client : inc.new_up_client) {
+ osd_state[client.first] |= CEPH_OSD_EXISTS | CEPH_OSD_UP;
+ osd_addrs->client_addr[client.first].reset(new entity_addr_t(client.second));
if (inc.new_hb_back_up.empty())
- osd_addrs->hb_back_addr[elem.first].reset(new entity_addr_t(elem.second)); //this is a backward-compatibility hack
+ osd_addrs->hb_back_addr[client.first].reset(new entity_addr_t(client.second)); //this is a backward-compatibility hack
else
- osd_addrs->hb_back_addr[elem.first].reset(
- new entity_addr_t(inc.new_hb_back_up.find(elem.first)->second));
- const auto j = inc.new_hb_front_up.find(elem.first);
+ osd_addrs->hb_back_addr[client.first].reset(
+ new entity_addr_t(inc.new_hb_back_up.find(client.first)->second));
+ const auto j = inc.new_hb_front_up.find(client.first);
if (j != inc.new_hb_front_up.end())
- osd_addrs->hb_front_addr[elem.first].reset(new entity_addr_t(j->second));
+ osd_addrs->hb_front_addr[client.first].reset(new entity_addr_t(j->second));
else
- osd_addrs->hb_front_addr[elem.first].reset();
+ osd_addrs->hb_front_addr[client.first].reset();
- osd_info[elem.first].up_from = epoch;
+ osd_info[client.first].up_from = epoch;
}
- for (const auto &elem : inc.new_up_cluster)
- osd_addrs->cluster_addr[elem.first].reset(new entity_addr_t(elem.second));
+ for (const auto &cluster : inc.new_up_cluster)
+ osd_addrs->cluster_addr[cluster.first].reset(new entity_addr_t(cluster.second));
// info
- for (const auto &elem : inc.new_up_thru)
- osd_info[elem.first].up_thru = elem.second;
- for (const auto &elem : inc.new_last_clean_interval) {
- osd_info[elem.first].last_clean_begin = elem.second.first;
- osd_info[elem.first].last_clean_end = elem.second.second;
+ for (const auto &thru : inc.new_up_thru)
+ osd_info[thru.first].up_thru = thru.second;
+
+ for (const auto &interval : inc.new_last_clean_interval) {
+ osd_info[interval.first].last_clean_begin = interval.second.first;
+ osd_info[interval.first].last_clean_end = interval.second.second;
}
- for (const auto &elem : inc.new_lost)
- osd_info[elem.first].lost_at = elem.second;
+
+ for (const auto &lost : inc.new_lost)
+ osd_info[lost.first].lost_at = lost.second;
// xinfo
- for (const auto &elem : inc.new_xinfo)
- osd_xinfo[elem.first] = elem.second;
+ for (const auto &xinfo : inc.new_xinfo)
+ osd_xinfo[xinfo.first] = xinfo.second;
// uuid
- for (const auto &elem : inc.new_uuid)
- (*osd_uuid)[elem.first] = elem.second;
+ for (const auto &uuid : inc.new_uuid)
+ (*osd_uuid)[uuid.first] = uuid.second;
// pg rebuild
- for (const auto &elem : inc.new_pg_temp) {
- if (elem.second.empty())
- pg_temp->erase(elem.first);
+ for (const auto &pg : inc.new_pg_temp) {
+ if (pg.second.empty())
+ pg_temp->erase(pg.first);
else
- (*pg_temp)[elem.first] = elem.second;
+ (*pg_temp)[pg.first] = pg.second;
}
- for (const auto &elem : inc.new_primary_temp) {
- if (elem.second == -1)
- primary_temp->erase(elem.first);
+ for (const auto &pg : inc.new_primary_temp) {
+ if (pg.second == -1)
+ primary_temp->erase(pg.first);
else
- (*primary_temp)[elem.first] = elem.second;
+ (*primary_temp)[pg.first] = pg.second;
}
for (auto& p : inc.new_pg_remap) {
blacklist.insert(inc.new_blacklist.begin(),inc.new_blacklist.end());
new_blacklist_entries = true;
}
- for (const auto &elem : inc.old_blacklist)
- blacklist.erase(elem);
+ for (const auto &addr : inc.old_blacklist)
+ blacklist.erase(addr);
// cluster snapshot?
if (inc.cluster_snapshot.length()) {
if (removed)
osds.resize(osds.size() - removed);
} else {
- for (auto &elem : osds) {
- if (!exists(elem))
- elem = CRUSH_ITEM_NONE;
+ for (auto osd : osds) {
+ if (!exists(osd))
+ osd = CRUSH_ITEM_NONE;
}
}
}
return;
bool any = false;
- for (const auto &elem : *osds) {
- if (elem != CRUSH_ITEM_NONE &&
- (*osd_primary_affinity)[elem] != CEPH_OSD_DEFAULT_PRIMARY_AFFINITY) {
+ for (const auto osd : *osds) {
+ if (osd != CRUSH_ITEM_NONE &&
+ (*osd_primary_affinity)[osd] != CEPH_OSD_DEFAULT_PRIMARY_AFFINITY) {
any = true;
break;
}
__u32 n = pools.size();
::encode(n, bl);
- for (const auto &elem : pools) {
- n = elem.first;
+ for (const auto &pool : pools) {
+ n = pool.first;
::encode(n, bl);
- ::encode(elem.second, bl, 0);
+ ::encode(pool.second, bl, 0);
}
// for ::encode(pool_name, bl);
n = pool_name.size();
::encode(n, bl);
- for (const auto &elem : pool_name) {
- n = elem.first;
+ for (const auto &pname : pool_name) {
+ n = pname.first;
::encode(n, bl);
- ::encode(elem.second, bl);
+ ::encode(pname.second, bl);
}
// for ::encode(pool_max, bl);
n = pool_max;
// for ::encode(pg_temp, bl);
n = pg_temp->size();
::encode(n, bl);
- for (const auto &elem : *pg_temp) {
- old_pg_t opg = elem.first.get_old_pg();
+ for (const auto pg : *pg_temp) {
+ old_pg_t opg = pg.first.get_old_pg();
::encode(opg, bl);
- ::encode(elem.second, bl);
+ ::encode(pg.second, bl);
}
// crush
// put this in a sorted, ordered map<> so that we encode in a
// deterministic order.
map<entity_addr_t,utime_t> blacklist_map;
- for (const auto &elem : blacklist)
- blacklist_map.insert(make_pair(elem.first, elem.second));
+ for (const auto &addr : blacklist)
+ blacklist_map.insert(make_pair(addr.first, addr.second));
::encode(blacklist_map, bl, features);
}
::encode(osd_addrs->cluster_addr, bl, features);
{
// index pool names
name_pool.clear();
- for (const auto &elem : pool_name) {
- name_pool[elem.second] = elem.first;
+ for (const auto &pname : pool_name) {
+ name_pool[pname.second] = pname.first;
}
calc_num_osds();
f->open_object_section("erasure_code_profiles");
for (const auto &profile : profiles) {
f->open_object_section(profile.first.c_str());
- for (const auto &elems : profile.second) {
- f->dump_string(elems.first.c_str(), elems.second.c_str());
+ for (const auto &profm : profile.second) {
+ f->dump_string(profm.first.c_str(), profm.second.c_str());
}
f->close_section();
}
f->dump_int("max_osd", get_max_osd());
f->open_array_section("pools");
- for (const auto &elem : pools) {
+ for (const auto &pool : pools) {
std::string name("<unknown>");
- const auto &pni = pool_name.find(elem.first);
+ const auto &pni = pool_name.find(pool.first);
if (pni != pool_name.end())
name = pni->second;
f->open_object_section("pool");
- f->dump_int("pool", elem.first);
+ f->dump_int("pool", pool.first);
f->dump_string("pool_name", name);
- elem.second.dump(f);
+ pool.second.dump(f);
f->close_section();
}
f->close_section();
set<string> st;
get_state(i, st);
f->open_array_section("state");
- for (auto &elem : st)
- f->dump_string("state", elem);
+ for (auto &state : st)
+ f->dump_string("state", state);
f->close_section();
f->close_section();
}
f->close_section();
f->open_array_section("pg_temp");
- for (const auto &elempg : *pg_temp) {
+ for (const auto pg : *pg_temp) {
f->open_object_section("osds");
- f->dump_stream("pgid") << elempg.first;
+ f->dump_stream("pgid") << pg.first;
f->open_array_section("osds");
- for (const auto &elems : elempg.second)
- f->dump_int("osd", elems);
+ for (const auto osd : pg.second)
+ f->dump_int("osd", osd);
f->close_section();
f->close_section();
}
f->close_section();
f->open_array_section("primary_temp");
- for (const auto &elem : *primary_temp) {
- f->dump_stream("pgid") << elem.first;
- f->dump_int("osd", elem.second);
+ for (const auto pg : *primary_temp) {
+ f->dump_stream("pgid") << pg.first;
+ f->dump_int("osd", pg.second);
}
f->close_section(); // primary_temp
f->open_object_section("blacklist");
- for (const auto &elem : blacklist) {
+ for (const auto &addr : blacklist) {
stringstream ss;
- ss << elem.first;
- f->dump_stream(ss.str().c_str()) << elem.second;
+ ss << addr.first;
+ f->dump_stream(ss.str().c_str()) << addr.second;
}
f->close_section();
out << "pg_remap_items " << p.first << " " << p.second << "\n";
}
- for (const auto &elem : *pg_temp)
- out << "pg_temp " << elem.first << " " << elem.second << "\n";
+ for (const auto pg : *pg_temp)
+ out << "pg_temp " << pg.first << " " << pg.second << "\n";
- for (const auto &elem : *primary_temp)
- out << "primary_temp " << elem.first << " " << elem.second << "\n";
+ for (const auto pg : *primary_temp)
+ out << "primary_temp " << pg.first << " " << pg.second << "\n";
- for (const auto &elem : blacklist)
- out << "blacklist " << elem.first << " expires " << elem.second << "\n";
+ for (const auto &addr : blacklist)
+ out << "blacklist " << addr.first << " expires " << addr.second << "\n";
// ignore pg_swap_primary
}
bool OSDMap::crush_ruleset_in_use(int ruleset) const
{
- for (const auto &elem : pools) {
- if (elem.second.crush_ruleset == ruleset)
+ for (const auto &pool : pools) {
+ if (pool.second.crush_ruleset == ruleset)
return true;
}
return false;
vector<string> sections;
conf->get_all_sections(sections);
- for (auto &elem : sections) {
- if (elem.find("osd.") != 0)
+ for (auto §ion : sections) {
+ if (section.find("osd.") != 0)
continue;
- const char *begin = elem.c_str() + 4;
+ const char *begin = section.c_str() + 4;
char *end = (char*)begin;
int o = strtol(begin, &end, 10);
if (*end != '\0')
int const default_replicated_ruleset = crush->get_osd_pool_default_crush_replicated_ruleset(cct);
assert(default_replicated_ruleset >= 0);
- for (auto &elem : pool_names) {
+ for (auto &plname : pool_names) {
int64_t pool = ++pool_max;
pools[pool].type = pg_pool_t::TYPE_REPLICATED;
pools[pool].flags = cct->_conf->osd_pool_default_flags;
pools[pool].set_pg_num(poolbase << pg_bits);
pools[pool].set_pgp_num(poolbase << pgp_bits);
pools[pool].last_change = epoch;
- pool_name[pool] = elem;
- name_pool[elem] = pool;
+ pool_name[pool] = plname;
+ name_pool[plname] = pool;
}
for (int i=0; i<get_max_osd(); i++) {
vector<string> sections;
conf->get_all_sections(sections);
- for (auto &elem : sections) {
- if (elem.find("osd.") != 0)
+ for (auto §ion : sections) {
+ if (section.find("osd.") != 0)
continue;
- const char *begin = elem.c_str() + 4;
+ const char *begin = section.c_str() + 4;
char *end = (char*)begin;
int o = strtol(begin, &end, 10);
if (*end != '\0')
string host, rack, row, room, dc, pool;
vector<string> sections;
sections.push_back("osd");
- sections.push_back(elem);
+ sections.push_back(section);
conf->get_val_from_conf_file(sections, "host", host, false);
conf->get_val_from_conf_file(sections, "rack", rack, false);
conf->get_val_from_conf_file(sections, "row", row, false);
loc["root"] = "default";
ldout(cct, 5) << " adding osd." << o << " at " << loc << dendl;
- crush.insert_item(cct, o, 1.0, elem, loc);
+ crush.insert_item(cct, o, 1.0, section, loc);
}
build_simple_crush_rulesets(cct, crush, "default", ss);
projects / ceph.git / commitdiff