diff options
Diffstat (limited to 'src/pybind/mgr/pg_autoscaler/tests')
4 files changed, 1192 insertions, 0 deletions
diff --git a/src/pybind/mgr/pg_autoscaler/tests/__init__.py b/src/pybind/mgr/pg_autoscaler/tests/__init__.py new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/src/pybind/mgr/pg_autoscaler/tests/__init__.py diff --git a/src/pybind/mgr/pg_autoscaler/tests/test_cal_final_pg_target.py b/src/pybind/mgr/pg_autoscaler/tests/test_cal_final_pg_target.py new file mode 100644 index 000000000..655025bbe --- /dev/null +++ b/src/pybind/mgr/pg_autoscaler/tests/test_cal_final_pg_target.py @@ -0,0 +1,676 @@ +# python unit test +import unittest +from tests import mock +import pytest +import json +from pg_autoscaler import module + + +class RootMapItem: + + def __init__(self, pool_count, pg_target, pg_left): + + self.pool_count = pool_count + self.pg_target = pg_target + self.pg_left = pg_left + self.pool_used = 0 + + +class TestPgAutoscaler(object): + + def setup_method(self): + # a bunch of attributes for testing. + self.autoscaler = module.PgAutoscaler('module_name', 0, 0) + + def helper_test(self, pools, root_map, bias, overlapped_roots): + # Here we simulate how _get_pool_pg_target() works. + + bulk_pools = {} + even_pools = {} + + # first pass + for pool_name, p in pools.items(): + root_id = p['root_id'] + if root_id in overlapped_roots: + # skip pools with overlapping roots + assert p['no_scale'] + continue + + final_ratio, pool_pg_target, final_pg_target = self.autoscaler._calc_final_pg_target( + p, pool_name, root_map, + p['root_id'], p['capacity_ratio'], + bias, even_pools, bulk_pools, 'first', p['bulk']) + + if final_ratio == None: + # no final_ratio means current pool is an even pool + # and we do not have to do any assertion on it. + continue + + assert p['expected_final_pg_target'] == final_pg_target + assert p['expected_final_ratio'] == final_ratio + assert not p['expected_bulk_pool'] and pool_name not in bulk_pools + + # second pass + for pool_name, p in bulk_pools.items(): + final_ratio, pool_pg_target, final_pg_target = self.autoscaler._calc_final_pg_target( + p, pool_name, root_map, + p['root_id'], p['capacity_ratio'], + bias, even_pools, bulk_pools, 'second', p['bulk']) + + if final_ratio == None: + # no final_ratio means current pool is an even pool + # and we do not have to do any assertion on it. + continue + + assert p['expected_final_pg_target'] == final_pg_target + assert p['expected_final_ratio'] == final_ratio + assert not p['even_pools'] and pool_name not in even_pools + + #third pass + for pool_name, p in even_pools.items(): + final_ratio, pool_pg_target, final_pg_target = self.autoscaler._calc_final_pg_target( + p, pool_name, root_map, + p['root_id'], p['capacity_ratio'], + bias, even_pools, bulk_pools, 'third', p['bulk']) + + assert p['expected_final_pg_target'] == final_pg_target + assert p['expected_final_ratio'] == final_ratio + assert p['even_pools'] and pool_name in even_pools + + def test_even_pools_one_meta_three_bulk(self): + pools = { + + "meta_0": { + + "pool": 0, + "pool_name": "meta_0", + "pg_num_target": 32, + "capacity_ratio": 0.2, + "root_id": 0, + "expected_final_pg_target": 64, + "expected_final_ratio": 0.2, + "expected_bulk_pool": False, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "bulk_0": { + + "pool": 1, + "pool_name": "bulk_0", + "pg_num_target": 32, + "capacity_ratio": 0.2, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 1/3, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk_1": { + + "pool": 2, + "pool_name": "bulk_1", + "pg_num_target": 32, + "capacity_ratio": 0.2, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 1/3, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk_2": { + + "pool": 3, + "pool_name": "bulk_2", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 1/3, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + } + + root_map = { + + 0: RootMapItem(4, 400, 400), + 1: RootMapItem(4, 400, 400), + + } + + bias = 1 + overlapped_roots = set() + self.helper_test(pools, root_map, bias, overlapped_roots) + + def test_even_pools_two_meta_two_bulk(self): + pools = { + + "meta0": { + + "pool": 0, + "pool_name": "meta0", + "pg_num_target": 32, + "capacity_ratio": 0.2, + "root_id": 0, + "expected_final_pg_target": 64, + "expected_final_ratio": 0.2, + "expected_bulk_pool": False, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "meta1": { + + "pool": 1, + "pool_name": "meta1", + "pg_num_target": 32, + "capacity_ratio": 0.2, + "root_id": 0, + "expected_final_pg_target": 64, + "expected_final_ratio": 0.2, + "expected_bulk_pool": False, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "bulk0": { + + "pool": 2, + "pool_name": "bulk0", + "pg_num_target": 32, + "capacity_ratio": 0.2, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk1": { + + "pool": 3, + "pool_name": "test3", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + } + + root_map = { + + 0: RootMapItem(4, 400, 400), + 1: RootMapItem(4, 400, 400), + + } + + bias = 1 + overlapped_roots = set() + self.helper_test(pools, root_map, bias, overlapped_roots) + + def test_uneven_pools_one_meta_three_bulk(self): + pools = { + + "meta0": { + + "pool": 0, + "pool_name": "meta0", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 32, + "expected_final_ratio": 0.1, + "expected_bulk_pool": False, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "bulk0": { + + "pool": 1, + "pool_name": "bulk0", + "pg_num_target": 32, + "capacity_ratio": 0.5, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk1": { + + "pool": 2, + "pool_name": "bulk1", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 64, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk2": { + + "pool": 3, + "pool_name": "bulk2", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 64, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + } + + root_map = { + + 0: RootMapItem(4, 400, 400), + 1: RootMapItem(4, 400, 400), + + } + + bias = 1 + overlapped_roots = set() + self.helper_test(pools, root_map, bias, overlapped_roots) + + def test_uneven_pools_two_meta_two_bulk(self): + pools = { + + "meta0": { + + "pool": 0, + "pool_name": "meta0", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 32, + "expected_final_ratio": 0.1, + "expected_bulk_pool": False, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "meta1": { + + "pool": 1, + "pool_name": "meta1", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 32, + "expected_final_ratio": 0.1, + "expected_bulk_pool": False, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "bulk0": { + + "pool": 2, + "pool_name": "bulk0", + "pg_num_target": 32, + "capacity_ratio": 0.5, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk1": { + + "pool": 3, + "pool_name": "bulk1", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 128, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + } + + root_map = { + + 0: RootMapItem(4, 400, 400), + 1: RootMapItem(4, 400, 400), + + } + + bias = 1 + overlapped_roots = set() + self.helper_test(pools, root_map, bias, overlapped_roots) + + def test_uneven_pools_with_diff_roots(self): + pools = { + + "meta0": { + + "pool": 0, + "pool_name": "meta0", + "pg_num_target": 32, + "capacity_ratio": 0.3, + "root_id": 0, + "expected_final_pg_target": 1024, + "expected_final_ratio": 0.3, + "expected_bulk_pool": False, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "meta1": { + + "pool": 1, + "pool_name": "meta1", + "pg_num_target": 32, + "capacity_ratio": 0.6, + "root_id": 1, + "expected_final_pg_target": 2048, + "expected_final_ratio": 0.6, + "expected_bulk_pool": False, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "bulk2": { + + "pool": 2, + "pool_name": "bulk2", + "pg_num_target": 32, + "capacity_ratio": 0.6, + "root_id": 0, + "expected_final_pg_target": 2048, + "expected_final_ratio": 0.6, + "expected_bulk_pool": True, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk3": { + + "pool": 3, + "pool_name": "test3", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 1024, + "expected_final_ratio": 1, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk4": { + + "pool": 4, + "pool_name": "bulk4", + "pg_num_target": 32, + "capacity_ratio": 0.4, + "root_id": 1, + "expected_final_pg_target": 2048, + "expected_final_ratio": 1, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + } + + root_map = { + + 0: RootMapItem(3, 5000, 5000), + 1: RootMapItem(2, 5000, 5000), + + } + + bias = 1 + overlapped_roots = set() + self.helper_test(pools, root_map, bias, overlapped_roots) + + def test_even_pools_with_diff_roots(self): + pools = { + + "meta0": { + + "pool": 0, + "pool_name": "meta0", + "pg_num_target": 32, + "capacity_ratio": 0.4, + "root_id": 0, + "expected_final_pg_target": 2048, + "expected_final_ratio": 0.4, + "expected_bulk_pool": False, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "meta1": { + + "pool": 1, + "pool_name": "meta1", + "pg_num_target": 32, + "capacity_ratio": 0.6, + "root_id": 1, + "expected_final_pg_target": 2048, + "expected_final_ratio": 0.6, + "expected_bulk_pool": False, + "even_pools": False, + "size": 1, + "no_scale": False, + "bulk": False, + }, + + "bulk1": { + + "pool": 2, + "pool_name": "bulk1", + "pg_num_target": 32, + "capacity_ratio": 0.2, + "root_id": 0, + "expected_final_pg_target": 1024, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk2": { + + "pool": 3, + "pool_name": "bulk2", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 1024, + "expected_final_ratio": 0.5, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + "bulk3": { + + "pool": 4, + "pool_name": "bulk4", + "pg_num_target": 32, + "capacity_ratio": 0.25, + "root_id": 1, + "expected_final_pg_target": 2048, + "expected_final_ratio": 1, + "expected_bulk_pool": True, + "even_pools": True, + "size": 1, + "no_scale": False, + "bulk": True, + }, + + } + + root_map = { + + 0: RootMapItem(3, 5000, 5000), + 1: RootMapItem(2, 5000, 5000), + + } + + bias = 1 + overlapped_roots = set() + self.helper_test(pools, root_map, bias, overlapped_roots) + + def test_uneven_pools_with_overlapped_roots(self): + pools = { + + "test0": { + + "pool": 0, + "pool_name": "test0", + "pg_num_target": 32, + "capacity_ratio": 0.4, + "root_id": 0, + "expected_final_pg_target": 2048, + "expected_final_ratio": 0.4, + "even_pools": False, + "size": 1, + "no_scale": True, + }, + + "test1": { + + "pool": 1, + "pool_name": "test1", + "pg_num_target": 32, + "capacity_ratio": 0.6, + "root_id": 1, + "expected_final_pg_target": 2048, + "expected_final_ratio": 0.6, + "even_pools": False, + "size": 1, + "no_scale": True, + }, + + "test2": { + + "pool": 2, + "pool_name": "test2", + "pg_num_target": 32, + "capacity_ratio": 0.5, + "root_id": 0, + "expected_final_pg_target": 2048, + "expected_final_ratio": 0.5, + "even_pools": False, + "size": 1, + "no_scale": True, + }, + + "test3": { + + "pool": 3, + "pool_name": "test3", + "pg_num_target": 32, + "capacity_ratio": 0.1, + "root_id": 0, + "expected_final_pg_target": 512, + "expected_final_ratio": 1, + "even_pools": True, + "size": 1, + "no_scale": True, + }, + + "test4": { + + "pool": 4, + "pool_name": "test4", + "pg_num_target": 32, + "capacity_ratio": 0.4, + "root_id": 1, + "expected_final_pg_target": 2048, + "expected_final_ratio": 1, + "even_pools": True, + "size": 1, + "no_scale": True, + }, + + } + + root_map = { + + 0: RootMapItem(3, 5000, 5000), + 1: RootMapItem(2, 5000, 5000), + + } + + bias = 1 + overlapped_roots = {0, 1} + self.helper_test(pools, root_map, bias, overlapped_roots) diff --git a/src/pybind/mgr/pg_autoscaler/tests/test_cal_ratio.py b/src/pybind/mgr/pg_autoscaler/tests/test_cal_ratio.py new file mode 100644 index 000000000..d96671360 --- /dev/null +++ b/src/pybind/mgr/pg_autoscaler/tests/test_cal_ratio.py @@ -0,0 +1,37 @@ +from pg_autoscaler import effective_target_ratio +from pytest import approx + + +def check_simple_ratio(target_ratio, tot_ratio): + etr = effective_target_ratio(target_ratio, tot_ratio, 0, 0) + assert (target_ratio / tot_ratio) == approx(etr) + return etr + + +def test_simple(): + etr1 = check_simple_ratio(0.2, 0.9) + etr2 = check_simple_ratio(2, 9) + etr3 = check_simple_ratio(20, 90) + assert etr1 == approx(etr2) + assert etr1 == approx(etr3) + + etr = check_simple_ratio(0.9, 0.9) + assert etr == approx(1.0) + etr1 = check_simple_ratio(1, 2) + etr2 = check_simple_ratio(0.5, 1.0) + assert etr1 == approx(etr2) + + +def test_total_bytes(): + etr = effective_target_ratio(1, 10, 5, 10) + assert etr == approx(0.05) + etr = effective_target_ratio(0.1, 1, 5, 10) + assert etr == approx(0.05) + etr = effective_target_ratio(1, 1, 5, 10) + assert etr == approx(0.5) + etr = effective_target_ratio(1, 1, 0, 10) + assert etr == approx(1.0) + etr = effective_target_ratio(0, 1, 5, 10) + assert etr == approx(0.0) + etr = effective_target_ratio(1, 1, 10, 10) + assert etr == approx(0.0) diff --git a/src/pybind/mgr/pg_autoscaler/tests/test_overlapping_roots.py b/src/pybind/mgr/pg_autoscaler/tests/test_overlapping_roots.py new file mode 100644 index 000000000..009019707 --- /dev/null +++ b/src/pybind/mgr/pg_autoscaler/tests/test_overlapping_roots.py @@ -0,0 +1,479 @@ +# python unit test +import unittest +from tests import mock +import pytest +import json +from pg_autoscaler import module + + +class OSDMAP: + def __init__(self, pools): + self.pools = pools + + def get_pools(self): + return self.pools + + def pool_raw_used_rate(pool_id): + return 1 + + +class CRUSH: + def __init__(self, rules, osd_dic): + self.rules = rules + self.osd_dic = osd_dic + + def get_rule_by_id(self, rule_id): + for rule in self.rules: + if rule['rule_id'] == rule_id: + return rule + + return None + + def get_rule_root(self, rule_name): + for rule in self.rules: + if rule['rule_name'] == rule_name: + return rule['root_id'] + + return None + + def get_osds_under(self, root_id): + return self.osd_dic[root_id] + + +class TestPgAutoscaler(object): + + def setup_method(self): + # a bunch of attributes for testing. + self.autoscaler = module.PgAutoscaler('module_name', 0, 0) + + def helper_test(self, osd_dic, rules, pools, expected_overlapped_roots): + result = {} + roots = [] + overlapped_roots = set() + osdmap = OSDMAP(pools) + crush = CRUSH(rules, osd_dic) + roots, overlapped_roots = self.autoscaler.identify_subtrees_and_overlaps(osdmap, + crush, result, overlapped_roots, roots) + assert overlapped_roots == expected_overlapped_roots + + def test_subtrees_and_overlaps(self): + osd_dic = { + -1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + -40: [11, 12, 13, 14, 15], + -5: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], + } + + rules = [ + { + "rule_id": 0, + "rule_name": "data", + "ruleset": 0, + "type": 1, + "min_size": 1, + "max_size": 10, + "root_id": -1, + }, + { + "rule_id": 1, + "rule_name": "teuthology-data-ec", + "ruleset": 1, + "type": 3, + "min_size": 3, + "max_size": 6, + "root_id": -5, + }, + { + "rule_id": 4, + "rule_name": "rep-ssd", + "ruleset": 4, + "type": 1, + "min_size": 1, + "max_size": 10, + "root_id": -40, + }, + ] + pools = { + 0: { + "pool_name": "data", + "pg_num_target": 1024, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.1624, + "options": { + "pg_num_min": 1024, + }, + "expected_final_pg_target": 1024, + }, + 1: { + "pool_name": "metadata", + "pg_num_target": 64, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.0144, + "options": { + "pg_num_min": 64, + }, + "expected_final_pg_target": 64, + }, + 4: { + "pool_name": "libvirt-pool", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0001, + "options": {}, + "expected_final_pg_target": 128, + }, + 93: { + "pool_name": ".rgw.root", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 94: { + "pool_name": "default.rgw.control", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 95: { + "pool_name": "default.rgw.meta", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 96: { + "pool_name": "default.rgw.log", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 97: { + "pool_name": "default.rgw.buckets.index", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.0002, + "options": {}, + "expected_final_pg_target": 32, + }, + 98: { + "pool_name": "default.rgw.buckets.data", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0457, + "options": {}, + "expected_final_pg_target": 128, + }, + 99: { + "pool_name": "default.rgw.buckets.non-ec", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 100: { + "pool_name": "device_health_metrics", + "pg_num_target": 1, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0, + "options": { + "pg_num_min": 1 + }, + "expected_final_pg_target": 1, + }, + 113: { + "pool_name": "cephfs.teuthology.meta", + "pg_num_target": 64, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.1389, + "options": { + "pg_autoscale_bias": 4, + "pg_num_min": 64, + }, + "expected_final_pg_target": 512, + }, + 114: { + "pool_name": "cephfs.teuthology.data", + "pg_num_target": 256, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0006, + "options": { + "pg_num_min": 128, + }, + "expected_final_pg_target": 1024, + "expected_final_pg_target": 256, + }, + 117: { + "pool_name": "cephfs.scratch.meta", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.0027, + "options": { + "pg_autoscale_bias": 4, + "pg_num_min": 16, + }, + "expected_final_pg_target": 64, + }, + 118: { + "pool_name": "cephfs.scratch.data", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0027, + "options": {}, + "expected_final_pg_target": 128, + }, + 119: { + "pool_name": "cephfs.teuthology.data-ec", + "pg_num_target": 1024, + "size": 6, + "crush_rule": 1, + "capacity_ratio": 0.8490, + "options": { + "pg_num_min": 1024 + }, + "expected_final_pg_target": 1024, + }, + 121: { + "pool_name": "cephsqlite", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 128, + }, + } + expected_overlapped_roots = {-40, -1, -5} + self.helper_test(osd_dic, rules, pools, expected_overlapped_roots) + + def test_no_overlaps(self): + osd_dic = { + -1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], + -40: [11, 12, 13, 14, 15], + -5: [16, 17, 18], + } + + rules = [ + { + "rule_id": 0, + "rule_name": "data", + "ruleset": 0, + "type": 1, + "min_size": 1, + "max_size": 10, + "root_id": -1, + }, + { + "rule_id": 1, + "rule_name": "teuthology-data-ec", + "ruleset": 1, + "type": 3, + "min_size": 3, + "max_size": 6, + "root_id": -5, + }, + { + "rule_id": 4, + "rule_name": "rep-ssd", + "ruleset": 4, + "type": 1, + "min_size": 1, + "max_size": 10, + "root_id": -40, + }, + ] + pools = { + 0: { + "pool_name": "data", + "pg_num_target": 1024, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.1624, + "options": { + "pg_num_min": 1024, + }, + "expected_final_pg_target": 1024, + }, + 1: { + "pool_name": "metadata", + "pg_num_target": 64, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.0144, + "options": { + "pg_num_min": 64, + }, + "expected_final_pg_target": 64, + }, + 4: { + "pool_name": "libvirt-pool", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0001, + "options": {}, + "expected_final_pg_target": 128, + }, + 93: { + "pool_name": ".rgw.root", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 94: { + "pool_name": "default.rgw.control", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 95: { + "pool_name": "default.rgw.meta", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 96: { + "pool_name": "default.rgw.log", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 97: { + "pool_name": "default.rgw.buckets.index", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.0002, + "options": {}, + "expected_final_pg_target": 32, + }, + 98: { + "pool_name": "default.rgw.buckets.data", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0457, + "options": {}, + "expected_final_pg_target": 128, + }, + 99: { + "pool_name": "default.rgw.buckets.non-ec", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 32, + }, + 100: { + "pool_name": "device_health_metrics", + "pg_num_target": 1, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0, + "options": { + "pg_num_min": 1 + }, + "expected_final_pg_target": 1, + }, + 113: { + "pool_name": "cephfs.teuthology.meta", + "pg_num_target": 64, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.1389, + "options": { + "pg_autoscale_bias": 4, + "pg_num_min": 64, + }, + "expected_final_pg_target": 512, + }, + 114: { + "pool_name": "cephfs.teuthology.data", + "pg_num_target": 256, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0006, + "options": { + "pg_num_min": 128, + }, + "expected_final_pg_target": 1024, + "expected_final_pg_target": 256, + }, + 117: { + "pool_name": "cephfs.scratch.meta", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0.0027, + "options": { + "pg_autoscale_bias": 4, + "pg_num_min": 16, + }, + "expected_final_pg_target": 64, + }, + 118: { + "pool_name": "cephfs.scratch.data", + "pg_num_target": 32, + "size": 3, + "crush_rule": 0, + "capacity_ratio": 0.0027, + "options": {}, + "expected_final_pg_target": 128, + }, + 119: { + "pool_name": "cephfs.teuthology.data-ec", + "pg_num_target": 1024, + "size": 6, + "crush_rule": 1, + "capacity_ratio": 0.8490, + "options": { + "pg_num_min": 1024 + }, + "expected_final_pg_target": 1024, + }, + 121: { + "pool_name": "cephsqlite", + "pg_num_target": 32, + "size": 3, + "crush_rule": 4, + "capacity_ratio": 0, + "options": {}, + "expected_final_pg_target": 128, + }, + } + expected_overlapped_roots = set() + self.helper_test(osd_dic, rules, pools, expected_overlapped_roots) |