Rename EnvType to UserConfig

Author: badrogger

node_cli/configs/env.py

@@ -43,7 +43,7 @@ class ValidationResult(NamedTuple):
 
 
 @dataclass(kw_only=True)
-class BaseEnvConfig(ABC):
+class BaseUserConfig(ABC):
     container_configs_stream: str
     endpoint: str
     sgx_server_url: str
@@ -84,20 +84,20 @@ def validate_params(cls, params: Dict) -> ValidationResult:
 
 
 @dataclass
-class MirageEnvConfig(BaseEnvConfig):
+class MirageUserConfig(BaseUserConfig):
     mirage_contracts: str
     enforce_btrfs: str = ''
 
 
 @dataclass
-class MirageBootEnvConfig(BaseEnvConfig):
+class MirageBootUserConfig(BaseUserConfig):
     manager_contracts: str
     ima_contracts: str
     enforce_btrfs: str = ''
 
 
 @dataclass
-class SkaleEnvConfig(BaseEnvConfig):
+class SkaleUserConfig(BaseUserConfig):
     manager_contracts: str
     ima_contracts: str
     docker_lvmpy_stream: str
@@ -113,7 +113,7 @@ class SkaleEnvConfig(BaseEnvConfig):
 
 
 @dataclass
-class SyncEnvConfig(BaseEnvConfig):
+class SyncUserConfig(BaseUserConfig):
     manager_contracts: str
     schain_name: str = ''
     ima_contracts: str = ''
@@ -174,14 +174,14 @@ def absent_required_params(params: Dict[str, str]) -> List[str]:
     return [key for key in params if key not in OPTIONAL_PARAMS and not params[key]]
 
 
-def get_validated_env_config(
+def get_validated_user_config(
     node_type: NodeType,
     env_filepath: str = SKALE_DIR_ENV_FILEPATH,
     is_mirage_boot: bool = False,
-) -> BaseEnvConfig:
+) -> BaseUserConfig:
     params = parse_env_file(env_filepath)
-    EnvType = get_env_class(node_type, is_mirage_boot)
-    _, missing_params, extra_params = EnvType.validate_params(params)
+    UserConfigType = get_user_config_type(node_type, is_mirage_boot)
+    _, missing_params, extra_params = UserConfigType.validate_params(params)
 
     if len(missing_params) > 0:
         error_exit(f'Missing required parameters: {missing_params}')
@@ -191,19 +191,19 @@ def get_validated_env_config(
 
     validate_env_type(env_type=params['ENV_TYPE'])
     params = to_lower_keys(params)
-    env = EnvType(**params)
+    user_config = UserConfigType(**params)
 
     if node_type == NodeType.MIRAGE and not is_mirage_boot:
-        contract_alias_or_address = env.mirage_contracts
+        contract_alias_or_address = user_config.mirage_contracts
     else:
         contract_alias_or_address = params.get('MANAGER_CONTRACTS', '')
-        contract_alias_or_address = env.manager_contracts
-    validate_env_alias_or_address(contract_alias_or_address, ContractType.MANAGER, env.endpoint)
+        contract_alias_or_address = user_config.manager_contracts
+    validate_env_alias_or_address(contract_alias_or_address, ContractType.MANAGER, user_config.endpoint)
 
     if 'IMA_CONTRACTS' in params:
-        validate_env_alias_or_address(env.ima_contracts, ContractType.IMA, env.endpoint)
+        validate_env_alias_or_address(user_config.ima_contracts, ContractType.IMA, user_config.endpoint)
 
-    return env
+    return user_config
 
 
 def to_lower_keys(params: Dict[str, str]) -> Dict[str, str]:
@@ -216,26 +216,19 @@ def parse_env_file(env_filepath: str) -> Dict:
     return DotEnv(env_filepath).dict()
 
 
-def get_env_class(
+def get_user_config_type(
     node_type: NodeType,
     is_mirage_boot: bool = False,
-) -> type[BaseEnvConfig]:
+) -> type[BaseUserConfig]:
     if node_type == NodeType.MIRAGE and is_mirage_boot:
-        env_type = MirageBootEnvConfig
+        user_config_type = MirageBootUserConfig
     elif node_type == NodeType.MIRAGE:
-        env_type = MirageEnvConfig
+        user_config_type = MirageUserConfig
     elif node_type == NodeType.SYNC:
-        env_type = SyncEnvConfig
+        user_config_type = SyncUserConfig
     else:
-        env_type = SkaleEnvConfig
-    return env_type
-
-
-def populate_env_params(params: Dict[str, str]) -> None:
-    for key in params:
-        env_value = os.getenv(key)
-        if env_value is not None:
-            params[key] = str(env_value)
+        user_config_type = SkaleUserConfig
+    return user_config_type
 
 
 def validate_env_type(env_type: str) -> None:

node_cli/core/node.py

@@ -42,7 +42,7 @@
     TM_INIT_TIMEOUT,
 )
 from node_cli.cli import __version__
-from node_cli.configs.env import get_validated_env_config, SKALE_DIR_ENV_FILEPATH
+from node_cli.configs.env import get_validated_user_config, SKALE_DIR_ENV_FILEPATH
 from node_cli.configs.cli_logger import LOG_DATA_PATH as CLI_LOG_DATA_PATH
 
 from node_cli.core.host import is_node_inited, save_env_params, get_flask_secret_key
@@ -233,15 +233,15 @@ def compose_node_env(
     is_mirage_boot: bool = False,
 ) -> dict[str, str]:
     if env_filepath is not None:
-        env_config = get_validated_env_config(
+        user_config = get_validated_user_config(
             node_type=node_type,
             env_filepath=env_filepath,
             is_mirage_boot=is_mirage_boot,
         )
         if save:
             save_env_params(env_filepath)
     else:
-        env_config = get_validated_env_config(
+        user_config = get_validated_user_config(
             node_type=node_type,
             env_filepath=INIT_ENV_FILEPATH,
             is_mirage_boot=is_mirage_boot,
@@ -257,7 +257,7 @@ def compose_node_env(
         'SCHAINS_MNT_DIR': mnt_dir,
         'FILESTORAGE_MAPPING': FILESTORAGE_MAPPING,
         'SKALE_LIB_PATH': SKALE_STATE_DIR,
-        **env_config.to_env(),
+        **user_config.to_env(),
     }
 
     if inited_node and not node_type == NodeType.SYNC:
@@ -502,7 +502,7 @@ def run_checks(
         return
 
     if disk is None:
-        env_config = get_validated_env_config(node_type=node_type)
+        env_config = get_validated_user_config(node_type=node_type)
         disk = env_config.disk_mountpoint
     failed_checks = run_host_checks(disk, node_type, network, container_config_path)
     if not failed_checks:

node_cli/core/resources.py

@@ -24,7 +24,7 @@
 
 import psutil
 
-from node_cli.configs.env import get_validated_env_config
+from node_cli.configs.env import get_validated_user_config
 from node_cli.utils.docker_utils import ensure_volume
 from node_cli.utils.schain_types import SchainTypes
 from node_cli.utils.helper import write_json, read_json, run_cmd, safe_load_yml
@@ -102,10 +102,10 @@ def generate_resource_allocation_config(
         logger.debug(msg)
         print(msg)
         return
-    env_config = get_validated_env_config(node_type=node_type, env_filepath=env_file)
+    user_config = get_validated_user_config(node_type=node_type, env_filepath=env_file)
     logger.info('Generating resource allocation file ...')
     try:
-        update_resource_allocation(env_config.env_type)
+        update_resource_allocation(user_config.env_type)
     except Exception as e:
         logger.exception(e)
         print("Can't generate resource allocation file, check out CLI logs")

node_cli/core/schains.py

@@ -15,7 +15,7 @@
     SCHAIN_NODE_DATA_PATH,
     SCHAINS_MNT_DIR_SINGLE_CHAIN,
 )
-from node_cli.configs.env import get_validated_env_config
+from node_cli.configs.env import get_validated_user_config
 
 from node_cli.utils.helper import get_request, error_exit, safe_load_yml
 from node_cli.utils.exit_codes import CLIExitCodes
@@ -190,8 +190,8 @@ def restore_schain_from_snapshot(
     schain_type: str = 'medium',
 ) -> None:
     if env_type is None:
-        env_config = get_validated_env_config(node_type=node_type)
-        env_type = env_config.env_type
+        user_config = get_validated_user_config(node_type=node_type)
+        env_type = user_config.env_type
     ensure_schain_volume(schain, schain_type, env_type)
     block_number = get_block_number_from_path(snapshot_path)
     if block_number == -1:

tests/configs/configs_env_validate_test.py

@@ -1,33 +1,32 @@
 import os
 from typing import Optional
+
+import mock
 import pytest
 import requests
-import mock
 
-from node_cli.configs.env import (
-    SkaleEnvConfig,
-    SyncEnvConfig,
-    MirageEnvConfig,
-    absent_required_params,
-    get_env_class,
-    populate_env_params,
-    get_validated_env_config,
-    validate_env_params,
-    validate_env_type,
-    ALLOWED_ENV_TYPES,
-    REQUIRED_PARAMS_MIRAGE_BOOT,
-    REQUIRED_PARAMS_MIRAGE,
-    OPTIONAL_PARAMS,
-)
 from node_cli.configs.alias_address_validation import (
-    validate_env_alias_or_address,
-    validate_contract_address,
-    validate_contract_alias,
+    ContractType,
     get_chain_id,
     get_network_metadata,
-    ContractType,
+    validate_contract_address,
+    validate_contract_alias,
+    validate_env_alias_or_address,
+)
+from node_cli.configs.env import (
+    ALLOWED_ENV_TYPES,
+    OPTIONAL_PARAMS,
+    REQUIRED_PARAMS_MIRAGE,
+    REQUIRED_PARAMS_MIRAGE_BOOT,
+    MirageBootUserConfig,
+    MirageUserConfig,
+    SkaleUserConfig,
+    SyncUserConfig,
+    absent_required_params,
+    get_user_config_type,
+    get_validated_user_config,
+    validate_env_type,
 )
-from node_cli.utils.exit_codes import CLIExitCodes
 from node_cli.utils.node_type import NodeType
 
 ENDPOINT = 'http://localhost:8545'
@@ -42,38 +41,18 @@ def json(self):
         return self._json_data
 
 
-def test_absent_required_params_returns_missing_keys():
-    params = {
-        'A': '',
-        'B': 'value',
-        'C': '',
-        'MONITORING_CONTAINERS': 'optional',
-    }
-    missing = absent_required_params(params)
-    assert 'A' in missing
-    assert 'C' in missing
-    assert 'MONITORING_CONTAINERS' not in missing
-
-
-def test_populate_env_params_updates_from_environ(monkeypatch):
-    params = {'FOO': ''}
-    monkeypatch.setenv('FOO', 'bar')
-    populate_env_params(params)
-    assert params['FOO'] == 'bar'
-
-
 @pytest.mark.parametrize(
     'node_type, is_mirage_boot, expected_type',
     [
-        (NodeType.REGULAR, False, SkaleEnvConfig),
-        (NodeType.SYNC, False, SyncEnvConfig),
-        (NodeType.MIRAGE, True, SkaleEnvConfig),
-        (NodeType.MIRAGE, False, MirageEnvConfig),
+        (NodeType.REGULAR, False, SkaleUserConfig),
+        (NodeType.SYNC, False, SyncUserConfig),
+        (NodeType.MIRAGE, True, MirageBootUserConfig),
+        (NodeType.MIRAGE, False, MirageUserConfig),
     ],
     ids=['regular', 'sync', 'mirage_boot', 'mirage_regular'],
 )
 def test_build_env_params_keys(node_type, is_mirage_boot, expected_type):
-    env_type = get_env_class(node_type=node_type, is_mirage_boot=is_mirage_boot)
+    env_type = get_user_config_type(node_type=node_type, is_mirage_boot=is_mirage_boot)
     assert env_type == expected_type
 
 
@@ -190,47 +169,6 @@ def test_validate_env_alias_or_address_with_alias(requests_mock):
     validate_env_alias_or_address('test-alias', ContractType.IMA, ENDPOINT)
 
 
-@pytest.mark.parametrize('env_type', ALLOWED_ENV_TYPES)
-@pytest.mark.parametrize(
-    'required_params, key_to_remove, should_fail',
-    [
-        (REQUIRED_PARAMS_MIRAGE_BOOT, None, False),
-        (REQUIRED_PARAMS_MIRAGE, None, False),
-        (REQUIRED_PARAMS_MIRAGE_BOOT, 'IMA_CONTRACTS', True),
-        (REQUIRED_PARAMS_MIRAGE_BOOT, 'FILEBEAT_HOST', True),
-        (REQUIRED_PARAMS_MIRAGE, 'FILEBEAT_HOST', True),
-    ],
-    ids=[
-        'mirage_boot',
-        'mirage_regular',
-        'mirage_boot_missing_ima',
-        'mirage_boot_missing_filebeat',
-        'mirage_regular_missing_filebeat',
-    ],
-)
-@mock.patch('node_cli.configs.env.validate_env_alias_or_address')
-@mock.patch('node_cli.configs.env.validate_env_type')
-def test_validate_env_params_mirage(
-    mock_validate_type,
-    mock_validate_alias,
-    required_params,
-    key_to_remove,
-    should_fail,
-    env_type,
-):
-    params = {k: f'{k}_val' for k in required_params}
-    params['ENV_TYPE'] = env_type
-
-    if key_to_remove:
-        params[key_to_remove] = ''
-
-    if should_fail:
-        with pytest.raises(SystemExit):
-            validate_env_params(params=params)
-    else:
-        validate_env_params(params=params)
-
-
 @pytest.mark.parametrize(
     'node_type, is_boot, required_keys_dict',
     [
@@ -280,12 +218,12 @@ def test_get_validated_env_config_mirage_success(
     with mock.patch('node_cli.configs.alias_address_validation.requests.post') as mock_post:
         mock_post.return_value = FakeResponse(200, {'result': '0x123'})
 
-        config = get_validated_env_config(
+        user_config = get_validated_user_config(
             node_type=node_type, env_filepath=str(env_file), is_mirage_boot=is_boot
         )
 
-    assert config is not None
-    plain_config = config.to_env()
+    assert user_config is not None
+    plain_config = user_config.to_env()
     assert set(plain_config.keys()) == set(expected_config.keys())
     for key in expected_config:
         assert plain_config[key] == expected_config[key]
@@ -296,7 +234,7 @@ def test_get_validated_env_config_mirage_success(
 
 def test_get_validated_env_config_missing_file():
     with pytest.raises(SystemExit):
-        get_validated_env_config(env_filepath='nonexistent.env', node_type=NodeType.REGULAR)
+        get_validated_user_config(env_filepath='nonexistent.env', node_type=NodeType.REGULAR)
 
 
 def test_get_validated_env_config_unreadable_file(tmp_path):
@@ -306,6 +244,6 @@ def test_get_validated_env_config_unreadable_file(tmp_path):
     try:
         os.chmod(env_file, 0o000)
         with pytest.raises(PermissionError):
-            get_validated_env_config(env_filepath=str(env_file), node_type=NodeType.REGULAR)
+            get_validated_user_config(env_filepath=str(env_file), node_type=NodeType.REGULAR)
     finally:
         os.chmod(env_file, original_mode)