From 09764e0e15ba6ced93315451b349a11fc67a8bb8 Mon Sep 17 00:00:00 2001 From: td-zhangshun Date: Wed, 16 Apr 2025 11:05:24 +0800 Subject: [PATCH 1/2] [fix] Enhance cache cleaning policy configuration - Add set_param_cleaning_policy method for ACP and ALRU policies - Add validation for wake-up and flush-max-buffers parameters - Improve cache configuration to handle different cleaning policies - Fix casctl stop with flush option for proper shutdown --- utils/open-cas.shutdown | 2 +- utils/opencas.py | 51 +++++++++++++++++++++++++++++++++++++---- 2 files changed, 48 insertions(+), 5 deletions(-) diff --git a/utils/open-cas.shutdown b/utils/open-cas.shutdown index e43a308..fd94042 100755 --- a/utils/open-cas.shutdown +++ b/utils/open-cas.shutdown @@ -7,4 +7,4 @@ # systemd-shutdown plugin to stop all remaining Open CAS devices /usr/bin/echo "Open CAS cleanup handler" > /dev/kmsg -/sbin/casctl stop +/sbin/casctl stop --flush diff --git a/utils/opencas.py b/utils/opencas.py index f3ae112..70c81a1 100644 --- a/utils/opencas.py +++ b/utils/opencas.py @@ -139,7 +139,16 @@ class casadm: cmd += ['--'+param.replace('_', '-'), str(value)] return cls.run_cmd(cmd) - + + @classmethod + def set_param_cleaning_policy(cls, policy, cache_id, **kwargs): + cmd = [cls.casadm_path, + '--set-param', '--name', 'cleaning-'+policy, + '--cache-id', str(cache_id)] + for param, value in kwargs.items(): + cmd += ['--'+param.replace('_', '-'), str(value)] + return cls.run_cmd(cmd) + @classmethod def get_params(cls, namespace, cache_id, **kwargs): cmd = [cls.casadm_path, @@ -269,6 +278,10 @@ class cas_config(object): self.check_lazy_startup_valid(param_value) elif param_name == "target_failover_state": self.check_failover_state_valid(param_value) + elif param_name == "wake-up": + self.check_wake_up_valid(param_value) + elif param_name == "flush-max-buffers": + self.check_flush_max_buffers_valid(param_value) else: raise ValueError(f'{param_name} is invalid parameter name') @@ -315,6 +328,29 @@ class cas_config(object): if cache_line_size not in ['4', '8', '16', '32', '64']: raise ValueError(f'{cache_line_size} is invalid cache line size') + def check_wake_up_valid(self, wake_up): + if self.params.get("cleaning_policy") == "acp": + if not wake_up.isdigit(): + raise ValueError(f"{wake_up} is invalid wake-up value for acp cleaning policy") + if int(wake_up) not in range(0, 10000): + raise ValueError(f"{wake_up} is invalid wake-up value for acp cleaning policy") + elif self.params.get("cleaning_policy") == "alru": + if not wake_up.isdigit(): + raise ValueError(f"{wake_up} is invalid wake-up value for alru cleaning policy") + if int(wake_up) not in range(0, 3600): + raise ValueError(f"{wake_up} is invalid wake-up value for alru cleaning policy") + + def check_flush_max_buffers_valid(self, flush_max_buffers): + if self.params.get("cleaning_policy") == "acp": + if not flush_max_buffers.isdigit(): + raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for acp cleaning policy") + if int(flush_max_buffers) not in range(1, 10000): + raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for acp cleaning policy") + elif self.params.get("cleaning_policy") == "alru": + if not flush_max_buffers.isdigit(): + raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for alru cleaning policy") + if int(flush_max_buffers) not in range(1, 10000): + raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for alru cleaning policy") def check_recursive(self): if not self.device.startswith('/dev/cas'): return @@ -590,9 +626,16 @@ def start_cache(cache, load, force=False): def configure_cache(cache): if "cleaning_policy" in cache.params: - casadm.set_param( - "cleaning", cache_id=cache.cache_id, policy=cache.params["cleaning_policy"] - ) + if cache.params["cleaning_policy"] == "acp" or cache.params["cleaning_policy"] == "alru": + casadm.set_param_cleaning_policy( + policy=cache.params["cleaning_policy"], cache_id=cache.cache_id, wake_up=cache.params["wake_up"], flush_max_buffers=cache.params["flush_max_buffers"] + ) + else: + casadm.set_param( + "cleaning", cache_id=cache.cache_id, policy=cache.params["cleaning_policy"] + ) + + if "promotion_policy" in cache.params: casadm.set_param( "promotion", cache_id=cache.cache_id, policy=cache.params["promotion_policy"] -- 2.45.2 From 02a209aff813186f6fa3dd0b8e02f68918682d85 Mon Sep 17 00:00:00 2001 From: td-zhangshun Date: Wed, 16 Apr 2025 11:13:18 +0800 Subject: [PATCH 2/2] [test] Add unit tests for ACP and ALRU cleaning policy parameters - Add tests for wake-up and flush-max-buffers parameter validation - Test parameter boundary values and error conditions - Cover parameter parsing from configuration strings - Verify set_param_cleaning_policy commands construction - Test proper handling of different cleaning policies in configure_cache These tests ensure the proper validation and handling of cleaning policy parameters introduced in the previous commits. --- README-TD.md | 77 ++++++++++ .../opencas-py-tests/test_cas_config_01.py | 138 ++++++++++++++++++ utils/opencas.py | 25 +++- 3 files changed, 232 insertions(+), 8 deletions(-) create mode 100644 README-TD.md diff --git a/README-TD.md b/README-TD.md new file mode 100644 index 0000000..e6292f2 --- /dev/null +++ b/README-TD.md @@ -0,0 +1,77 @@ +# Test Cas_Config +``` +python3 -m venv test_env +source test_env/bin/activate +pip3 install pytest +pytest test/utils_tests/opencas-py-tests/test_cas_config_01.py -vv +``` + +```shell +pytest test/utils_tests/opencas-py-tests/test_cas_config_01.py -vv + +================================================================================== test session starts ================================================================================== +platform linux -- Python 3.10.12, pytest-8.3.5, pluggy-1.5.0 -- /root/workspace/git/open-cas-linux/open-cas_env/bin/python3 +cachedir: .pytest_cache +rootdir: /root/workspace/git/open-cas-linux +collected 56 items + +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_exception PASSED [ 1%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_no_vertag PASSED [ 3%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_comments_only PASSED [ 5%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_inconsistent_configs[caches_config0-cores_config0-ConflictingConfigException] PASSED [ 7%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_inconsistent_configs[caches_config1-cores_config1-ConflictingConfigException] PASSED [ 8%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_inconsistent_configs[caches_config2-cores_config2-ConflictingConfigException] PASSED [ 10%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_inconsistent_configs[caches_config3-cores_config3-AlreadyConfiguredException] PASSED [ 12%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_inconsistent_configs[caches_config4-cores_config4-AlreadyConfiguredException] PASSED [ 14%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_inconsistent_configs[caches_config5-cores_config5-KeyError] PASSED [ 16%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_inconsistent_configs[caches_config6-cores_config6-ConflictingConfigException] PASSED [ 17%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_is_empty_non_empty PASSED [ 19%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_double_add_cache PASSED [ 21%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_double_add_core PASSED [ 23%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_insert_core_no_cache PASSED [ 25%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_add_same_cache_symlinked_01 PASSED [ 26%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_add_same_cache_symlinked_02 PASSED [ 28%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_add_same_core_symlinked_01 PASSED [ 30%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_add_same_core_symlinked_02 PASSED [ 32%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_get_by_id_path_not_found PASSED [ 33%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_to_file[caches_config0-cores_config0] PASSED [ 35%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_to_file[caches_config1-cores_config1] PASSED [ 37%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_to_file[caches_config2-cores_config2] PASSED [ 39%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_to_file[caches_config3-cores_config3] PASSED [ 41%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_to_file[caches_config4-cores_config4] PASSED [ 42%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_insert_cache_insert_core_to_file[caches_config0-cores_config0] PASSED [ 44%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_insert_cache_insert_core_to_file[caches_config1-cores_config1] PASSED [ 46%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_insert_cache_insert_core_to_file[caches_config2-cores_config2] PASSED [ 48%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cas_config_from_file_insert_cache_insert_core_to_file[caches_config3-cores_config3] PASSED [ 50%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-100-500-None] PASSED [ 51%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-0-1-None] PASSED [ 53%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-10000-9999-None] PASSED [ 55%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp--1-500-ValueError] PASSED [ 57%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-10001-500-ValueError] PASSED [ 58%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-abc-500-ValueError] PASSED [ 60%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-100-0-ValueError] PASSED [ 62%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-100-10001-ValueError] PASSED [ 64%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[acp-100-abc-ValueError] PASSED [ 66%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-100-500-None] PASSED [ 67%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-0-1-None] PASSED [ 69%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-3599-10000-None] PASSED [ 71%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru--1-500-ValueError] PASSED [ 73%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-3601-500-ValueError] PASSED [ 75%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-abc-500-ValueError] PASSED [ 76%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-100-0-ValueError] PASSED [ 78%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-100-10001-ValueError] PASSED [ 80%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[alru-100-abc-ValueError] PASSED [ 82%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_cleaning_policy_parameters[nop-100-500-None] PASSED [ 83%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_from_line_with_cleaning_parameters[1 /dev/dummy WT cleaning_policy=acp,wake_up=100,flush_max_buffers=500-None] PASSED [ 85%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_from_line_with_cleaning_parameters[1 /dev/dummy WT cleaning_policy=alru,wake_up=60,flush_max_buffers=100-None] PASSED [ 87%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_from_line_with_cleaning_parameters[1 /dev/dummy WT cleaning_policy=acp,wake_up=10001,flush_max_buffers=500-ValueError] PASSED [ 89%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_from_line_with_cleaning_parameters[1 /dev/dummy WT cleaning_policy=acp,wake_up=100,flush_max_buffers=0-ValueError] PASSED [ 91%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_from_line_with_cleaning_parameters[1 /dev/dummy WT cleaning_policy=alru,wake_up=3601,flush_max_buffers=100-ValueError] PASSED [ 92%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_from_line_with_cleaning_parameters[1 /dev/dummy WT cleaning_policy=alru,wake_up=100,flush_max_buffers=10001-ValueError] PASSED [ 94%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_cache_config_from_line_with_cleaning_parameters[1 /dev/dummy WT cleaning_policy=nop,wake_up=100,flush_max_buffers=500-None] PASSED [ 96%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_set_param_cleaning_policy PASSED [ 98%] +test/utils_tests/opencas-py-tests/test_cas_config_01.py::test_configure_cache_cleaning_policy PASSED [100%] + +================================================================================== 56 passed in 0.14s =================================================================================== + +``` \ No newline at end of file diff --git a/test/utils_tests/opencas-py-tests/test_cas_config_01.py b/test/utils_tests/opencas-py-tests/test_cas_config_01.py index b52ebe3..c34bd7e 100644 --- a/test/utils_tests/opencas-py-tests/test_cas_config_01.py +++ b/test/utils_tests/opencas-py-tests/test_cas_config_01.py @@ -476,3 +476,141 @@ def test_cas_config_from_file_insert_cache_insert_core_to_file( assert set(contents_hashed[cores_index + 1 :]) - set(cores_hashed) == set( ["51/dev/mango_core"] ) + + +@pytest.mark.parametrize( + "cleaning_policy,wake_up,flush_max_buffers,expected_exception", + [ + ("acp", "100", "500", None), # Valid normal values + ("acp", "0", "1", None), # Boundary value test - min + ("acp", "10000", "9999", None), # Boundary value test - max + ("acp", "-1", "500", ValueError), # Invalid wake_up value + ("acp", "10001", "500", ValueError), # Out of range wake_up value + ("acp", "abc", "500", ValueError), # Non-numeric wake_up value + ("acp", "100", "0", ValueError), # Invalid flush_max_buffers value + ("acp", "100", "10001", ValueError), # Out of range flush_max_buffers value + ("acp", "100", "abc", ValueError), # Non-numeric flush_max_buffers value + ("alru", "100", "500", None), # Valid normal values + ("alru", "0", "1", None), # Boundary value test - min + ("alru", "3599", "10000", None), # Boundary value test - max + ("alru", "-1", "500", ValueError), # Invalid wake_up value + ("alru", "3601", "500", ValueError), # Out of range wake_up value + ("alru", "abc", "500", ValueError), # Non-numeric wake_up value + ("alru", "100", "0", ValueError), # Invalid flush_max_buffers value + ("alru", "100", "10001", ValueError), # Out of range flush_max_buffers value + ("alru", "100", "abc", ValueError), # Non-numeric flush_max_buffers value + ("nop", "100", "500", None), # Testing parameters for unsupported cleaning policy + ], +) +def test_cache_config_cleaning_policy_parameters(cleaning_policy, wake_up, flush_max_buffers, expected_exception): + """Test validation of wake_up and flush_max_buffers parameters for different cleaning policies""" + cache = opencas.cas_config.cache_config(1, "/dev/dummy", "WT", cleaning_policy=cleaning_policy) + + # Add test parameters + cache.params["wake_up"] = wake_up + cache.params["flush_max_buffers"] = flush_max_buffers + + if expected_exception: + with pytest.raises(expected_exception): + cache.check_wake_up_valid(wake_up) + cache.check_flush_max_buffers_valid(flush_max_buffers) + else: + # No exception should be raised + cache.check_wake_up_valid(wake_up) + cache.check_flush_max_buffers_valid(flush_max_buffers) + + +@pytest.mark.parametrize( + "cache_config_str, exception", + [ + ("1 /dev/dummy WT cleaning_policy=acp,wake_up=100,flush_max_buffers=500", None), + ("1 /dev/dummy WT cleaning_policy=alru,wake_up=60,flush_max_buffers=100", None), + ("1 /dev/dummy WT cleaning_policy=acp,wake_up=10001,flush_max_buffers=500", ValueError), + ("1 /dev/dummy WT cleaning_policy=acp,wake_up=100,flush_max_buffers=0", ValueError), + ("1 /dev/dummy WT cleaning_policy=alru,wake_up=3601,flush_max_buffers=100", ValueError), + ("1 /dev/dummy WT cleaning_policy=alru,wake_up=100,flush_max_buffers=10001", ValueError), + ("1 /dev/dummy WT cleaning_policy=nop,wake_up=100,flush_max_buffers=500", None), + ], +) +def test_cache_config_from_line_with_cleaning_parameters(cache_config_str, exception): + """Test parsing cache configuration with cleaning policy parameters from config line""" + if exception: + with pytest.raises(exception): + cache = opencas.cas_config.cache_config.from_line(cache_config_str, True) + else: + cache = opencas.cas_config.cache_config.from_line(cache_config_str, True) + assert cache.params.get("cleaning_policy") in ["acp", "alru", "nop"] + assert "wake_up" in cache.params + assert "flush_max_buffers" in cache.params + + +@patch("opencas.casadm.run_cmd") +def test_set_param_cleaning_policy(mock_run_cmd): + """Test the set_param_cleaning_policy method call""" + # ACP policy + opencas.casadm.set_param_cleaning_policy("acp", 1, wake_up="100", flush_max_buffers="500") + mock_run_cmd.assert_called_with([ + '/sbin/casadm', + '--set-param', '--name', 'cleaning-acp', + '--cache-id', '1', + '--wake-up', '100', + '--flush-max-buffers', '500' + ]) + + # ALRU policy + mock_run_cmd.reset_mock() + opencas.casadm.set_param_cleaning_policy("alru", 2, wake_up="60", flush_max_buffers="200") + mock_run_cmd.assert_called_with([ + '/sbin/casadm', + '--set-param', '--name', 'cleaning-alru', + '--cache-id', '2', + '--wake-up', '60', + '--flush-max-buffers', '200' + ]) + + # Nop policy + mock_run_cmd.reset_mock() + opencas.casadm.set_param("cleaning", cache_id=3, policy="nop") + mock_run_cmd.assert_called_with([ + '/sbin/casadm', + '--set-param', '--name', 'cleaning', + '--cache-id', '3', + '--policy', 'nop' + ]) + + +@patch("opencas.casadm.set_param_cleaning_policy") +@patch("opencas.casadm.set_param") +def test_configure_cache_cleaning_policy(mock_set_param, mock_set_param_cleaning_policy): + """Test handling different cleaning policies in cache configuration""" + # ACP policy test + cache_acp = opencas.cas_config.cache_config(1, "/dev/dummy", "WT", + cleaning_policy="acp", + wake_up="100", + flush_max_buffers="500") + opencas.configure_cache(cache_acp) + mock_set_param_cleaning_policy.assert_called_once_with( + policy="acp", cache_id=1, wake_up="100", flush_max_buffers="500" + ) + mock_set_param.assert_not_called() + + # ALRU policy test + mock_set_param.reset_mock() + mock_set_param_cleaning_policy.reset_mock() + cache_alru = opencas.cas_config.cache_config(2, "/dev/dummy", "WT", + cleaning_policy="alru", + wake_up="60", + flush_max_buffers="200") + opencas.configure_cache(cache_alru) + mock_set_param_cleaning_policy.assert_called_once_with( + policy="alru", cache_id=2, wake_up="60", flush_max_buffers="200" + ) + mock_set_param.assert_not_called() + + # NOP policy test + mock_set_param.reset_mock() + mock_set_param_cleaning_policy.reset_mock() + cache_nop = opencas.cas_config.cache_config(3, "/dev/dummy", "WT", cleaning_policy="nop") + opencas.configure_cache(cache_nop) + mock_set_param.assert_called_once_with("cleaning", cache_id=3, policy="nop") + mock_set_param_cleaning_policy.assert_not_called() diff --git a/utils/opencas.py b/utils/opencas.py index 70c81a1..aa73fad 100644 --- a/utils/opencas.py +++ b/utils/opencas.py @@ -219,6 +219,9 @@ class cas_config(object): if not stat.S_ISBLK(mode): raise ValueError(f'{path} is not block device') + def __str__(self): + return f"cas_config(caches={[str(cache) for cache in self.caches.values()]}, cores={[str(core) for core in self.cores]}, version_tag={self.version_tag})" + class cache_config(object): def __init__(self, cache_id, device, cache_mode, **params): self.cache_id = int(cache_id) @@ -227,6 +230,9 @@ class cas_config(object): self.params = params self.cores = dict() + def __str__(self): + return f"cache_config(cache_id={self.cache_id}, device={self.device}, cache_mode={self.cache_mode}, params={self.params}, cores={self.cores})" + @classmethod def from_line(cls, line, allow_incomplete=False): values = line.split() @@ -278,9 +284,9 @@ class cas_config(object): self.check_lazy_startup_valid(param_value) elif param_name == "target_failover_state": self.check_failover_state_valid(param_value) - elif param_name == "wake-up": + elif param_name == "wake_up": self.check_wake_up_valid(param_value) - elif param_name == "flush-max-buffers": + elif param_name == "flush_max_buffers": self.check_flush_max_buffers_valid(param_value) else: raise ValueError(f'{param_name} is invalid parameter name') @@ -332,24 +338,24 @@ class cas_config(object): if self.params.get("cleaning_policy") == "acp": if not wake_up.isdigit(): raise ValueError(f"{wake_up} is invalid wake-up value for acp cleaning policy") - if int(wake_up) not in range(0, 10000): + if int(wake_up) not in range(0, 10001): raise ValueError(f"{wake_up} is invalid wake-up value for acp cleaning policy") elif self.params.get("cleaning_policy") == "alru": if not wake_up.isdigit(): raise ValueError(f"{wake_up} is invalid wake-up value for alru cleaning policy") - if int(wake_up) not in range(0, 3600): + if int(wake_up) not in range(0, 3601): raise ValueError(f"{wake_up} is invalid wake-up value for alru cleaning policy") def check_flush_max_buffers_valid(self, flush_max_buffers): if self.params.get("cleaning_policy") == "acp": if not flush_max_buffers.isdigit(): raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for acp cleaning policy") - if int(flush_max_buffers) not in range(1, 10000): + if int(flush_max_buffers) not in range(1, 10001): raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for acp cleaning policy") elif self.params.get("cleaning_policy") == "alru": if not flush_max_buffers.isdigit(): raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for alru cleaning policy") - if int(flush_max_buffers) not in range(1, 10000): + if int(flush_max_buffers) not in range(1, 10001): raise ValueError(f"{flush_max_buffers} is invalid flush-max-buffers value for alru cleaning policy") def check_recursive(self): if not self.device.startswith('/dev/cas'): @@ -387,6 +393,9 @@ class cas_config(object): self.device = path self.params = params + def __str__(self): + return f"core_config(cache_id={self.cache_id}, core_id={self.core_id}, device={self.device}, params={self.params})" + @classmethod def from_line(cls, line, allow_incomplete=False): values = line.split() @@ -646,12 +655,12 @@ def configure_cache(cache): ) -def add_core(core, attach): +def add_core(core, try_add): casadm.add_core( device=core.device, cache_id=core.cache_id, core_id=core.core_id, - try_add=attach) + try_add=try_add) # Another helper functions -- 2.45.2