def identify_subtrees_and_overlaps(self,
osdmap: OSDMap,
crush: CRUSHMap,
result: Dict[int, CrushSubtreeResourceStatus],
overlapped_roots: Set[int],
roots: List[CrushSubtreeResourceStatus]) -> \
Tuple[List[CrushSubtreeResourceStatus],
Set[int]]:
# We identify subtrees and overlapping roots from osdmap
for pool_id, pool in osdmap.get_pools().items():
crush_rule = crush.get_rule_by_id(pool['crush_rule'])
assert crush_rule is not None
cr_name = crush_rule['rule_name']
root_id = crush.get_rule_root(cr_name)
assert root_id is not None
osds = set(crush.get_osds_under(root_id))
# Are there overlapping roots?
s = None
for prev_root_id, prev in result.items():
if osds & prev.osds:
s = prev
if prev_root_id != root_id:
overlapped_roots.add(prev_root_id)
overlapped_roots.add(root_id)
self.log.error('pool %d has overlapping roots: %s',
pool_id, overlapped_roots)
break
if not s:
s = CrushSubtreeResourceStatus()
roots.append(s)
result[root_id] = s
s.root_ids.append(root_id)
s.osds |= osds
s.pool_ids.append(pool_id)
s.pool_names.append(pool['pool_name'])
s.pg_current += pool['pg_num_target'] * pool['size']
target_ratio = pool['options'].get('target_size_ratio', 0.0)
if target_ratio:
s.total_target_ratio += target_ratio
else:
target_bytes = pool['options'].get('target_size_bytes', 0)
if target_bytes:
s.total_target_bytes += target_bytes * osdmap.pool_raw_used_rate(
pool_id)
return roots, overlapped_roots
def get_subtree_resource_status(self,
osdmap: OSDMap,
crush: CRUSHMap) -> Tuple[Dict[int, CrushSubtreeResourceStatus],
Dict[int, int]]:
"""
For each CRUSH subtree of interest (i.e. the roots under which
we have pools), calculate the current resource usages and targets,
such as how many PGs there are, vs. how many PGs we would
like there to be.
"""
result: Dict[int, CrushSubtreeResourceStatus] = {}
pool_root = {}
roots = []
# identify subtrees (note that they may overlap!)
for pool_id, pool in osdmap.get_pools().items():
crush_rule = crush.get_rule_by_id(pool['crush_rule'])
assert crush_rule is not None
cr_name = crush_rule['rule_name']
root_id = crush.get_rule_root(cr_name)
assert root_id is not None
pool_root[pool_id] = root_id
osds = set(crush.get_osds_under(root_id))
# do we intersect an existing root?
s = None
for prev in result.values():
if osds & prev.osds:
s = prev
break
if not s:
s = CrushSubtreeResourceStatus()
roots.append(s)
result[root_id] = s
s.root_ids.append(root_id)
s.osds |= osds
s.pool_ids.append(pool_id)
s.pool_names.append(pool['pool_name'])
s.pg_current += pool['pg_num_target'] * pool['size']
target_ratio = pool['options'].get('target_size_ratio', 0.0)
if target_ratio:
s.total_target_ratio += target_ratio
else:
target_bytes = pool['options'].get('target_size_bytes', 0)
if target_bytes:
s.total_target_bytes += target_bytes * osdmap.pool_raw_used_rate(pool_id)
# finish subtrees
all_stats = self.get('osd_stats')
for s in roots:
assert s.osds is not None
s.osd_count = len(s.osds)
s.pg_target = s.osd_count * self.mon_target_pg_per_osd
s.pg_left = s.pg_target
s.pool_count = len(s.pool_ids)
capacity = 0
for osd_stats in all_stats['osd_stats']:
if osd_stats['osd'] in s.osds:
# Intentionally do not apply the OSD's reweight to
# this, because we want to calculate PG counts based
# on the physical storage available, not how it is
# reweighted right now.
capacity += osd_stats['kb'] * 1024
s.capacity = capacity
self.log.debug('root_ids %s pools %s with %d osds, pg_target %d',
s.root_ids,
s.pool_ids,
s.osd_count,
s.pg_target)
return result, pool_root
