skypilot-nightly 1.0.0.dev20250413__py3-none-any.whl → 1.0.0.dev20250421__py3-none-any.whl

sky/skypilot_config.py

@@ -1,7 +1,7 @@
 """Immutable user configurations (EXPERIMENTAL).
 
-On module import, we attempt to parse the config located at _USER_CONFIG_PATH
-(default: ~/.sky/skyconfig.yaml). Caller can then use
+On module import, we attempt to parse the config located at _GLOBAL_CONFIG_PATH
+(default: ~/.sky/config.yaml). Caller can then use
 
   >> skypilot_config.loaded()
 
@@ -35,14 +35,14 @@ Consider the following config contents:
 
 then:
 
-    # Assuming ~/.sky/skyconfig.yaml exists and can be loaded:
+    # Assuming ~/.sky/config.yaml exists and can be loaded:
     skypilot_config.loaded()  # ==> True
 
     skypilot_config.get_nested(('a', 'nested'), None)    # ==> 1
     skypilot_config.get_nested(('a', 'nonexist'), None)  # ==> None
     skypilot_config.get_nested(('a',), None)             # ==> {'nested': 1}
 
-    # If ~/.sky/skyconfig.yaml doesn't exist or failed to be loaded:
+    # If ~/.sky/config.yaml doesn't exist or failed to be loaded:
     skypilot_config.loaded()  # ==> False
     skypilot_config.get_nested(('a', 'nested'), None)    # ==> None
     skypilot_config.get_nested(('a', 'nonexist'), None)  # ==> None
@@ -50,10 +50,13 @@ then:
 """
 import contextlib
 import copy
+import json
 import os
-import pprint
+import threading
 import typing
-from typing import Any, Dict, Iterator, Optional, Tuple
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+from omegaconf import OmegaConf
 
 from sky import exceptions
 from sky import sky_logging
@@ -77,8 +80,8 @@ logger = sky_logging.init_logger(__name__)
 #     path as the config file. Do not use any other config files.
 #     This behavior is subject to change and should not be relied on by users.
 # Else,
-# (1) If env var {ENV_VAR_USER_CONFIG} exists, use its path as the user
-#     config file. Else, use the default path {_USER_CONFIG_PATH}.
+# (1) If env var {ENV_VAR_GLOBAL_CONFIG} exists, use its path as the user
+#     config file. Else, use the default path {_GLOBAL_CONFIG_PATH}.
 # (2) If env var {ENV_VAR_PROJECT_CONFIG} exists, use its path as the project
 #     config file. Else, use the default path {_PROJECT_CONFIG_PATH}.
 # (3) Override any config keys in (1) with the ones in (2).
@@ -94,37 +97,113 @@ logger = sky_logging.init_logger(__name__)
 # use the same config file.
 ENV_VAR_SKYPILOT_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}CONFIG'
 
-# (Used by users) Environment variables for setting non-default user and
-# project config files on clients.
-ENV_VAR_USER_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}USER_CONFIG'
+# Environment variables for setting non-default server and user
+# config files.
+ENV_VAR_GLOBAL_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}GLOBAL_CONFIG'
+# Environment variables for setting non-default project config files.
 ENV_VAR_PROJECT_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}PROJECT_CONFIG'
 
-# Path to the local config files.
-_LEGACY_USER_CONFIG_PATH = '~/.sky/config.yaml'
-_USER_CONFIG_PATH = '~/.sky/skyconfig.yaml'
-_PROJECT_CONFIG_PATH = 'skyconfig.yaml'
+# Path to the client config files.
+_GLOBAL_CONFIG_PATH = '~/.sky/config.yaml'
+_PROJECT_CONFIG_PATH = '.sky.yaml'
 
 # The loaded config.
 _dict = config_utils.Config()
 _loaded_config_path: Optional[str] = None
 _config_overridden: bool = False
+_reload_config_lock = threading.Lock()
 
 
-# This function exists solely to maintain backward compatibility with the
-# legacy user config file located at ~/.sky/config.yaml.
 def get_user_config_path() -> str:
-    """Returns the path to the user config file.
+    """Returns the path to the user config file."""
+    return _GLOBAL_CONFIG_PATH
 
-    If only the legacy user config file exists, return
-    the legacy user config path.
-    Otherwise, return the new user config path.
-    """
-    user_config_path = os.path.expanduser(_USER_CONFIG_PATH)
-    legacy_user_config_path = os.path.expanduser(_LEGACY_USER_CONFIG_PATH)
-    if (os.path.exists(legacy_user_config_path) and
-            not os.path.exists(user_config_path)):
-        return _LEGACY_USER_CONFIG_PATH
-    return _USER_CONFIG_PATH
+
+def get_user_config() -> config_utils.Config:
+    """Returns the user config."""
+    # find the user config file
+    user_config_path = _get_config_file_path(ENV_VAR_GLOBAL_CONFIG)
+    if user_config_path:
+        logger.debug('using user config file specified by '
+                     f'{ENV_VAR_GLOBAL_CONFIG}: {user_config_path}')
+        user_config_path = os.path.expanduser(user_config_path)
+        if not os.path.exists(user_config_path):
+            with ux_utils.print_exception_no_traceback():
+                raise FileNotFoundError(
+                    'Config file specified by env var '
+                    f'{ENV_VAR_GLOBAL_CONFIG} ({user_config_path!r}) '
+                    'does not exist. Please double check the path or unset the '
+                    f'env var: unset {ENV_VAR_GLOBAL_CONFIG}')
+    else:
+        user_config_path = get_user_config_path()
+        logger.debug(f'using default user config file: {user_config_path}')
+        user_config_path = os.path.expanduser(user_config_path)
+
+    # load the user config file
+    if os.path.exists(user_config_path):
+        user_config = _parse_config_file(user_config_path)
+        _validate_config(user_config, user_config_path)
+    else:
+        user_config = config_utils.Config()
+    return user_config
+
+
+def _get_project_config() -> config_utils.Config:
+    # find the project config file
+    project_config_path = _get_config_file_path(ENV_VAR_PROJECT_CONFIG)
+    if project_config_path:
+        logger.debug('using project config file specified by '
+                     f'{ENV_VAR_PROJECT_CONFIG}: {project_config_path}')
+        project_config_path = os.path.expanduser(project_config_path)
+        if not os.path.exists(project_config_path):
+            with ux_utils.print_exception_no_traceback():
+                raise FileNotFoundError(
+                    'Config file specified by env var '
+                    f'{ENV_VAR_PROJECT_CONFIG} ({project_config_path!r}) '
+                    'does not exist. Please double check the path or unset the '
+                    f'env var: unset {ENV_VAR_PROJECT_CONFIG}')
+    else:
+        logger.debug(
+            f'using default project config file: {_PROJECT_CONFIG_PATH}')
+        project_config_path = _PROJECT_CONFIG_PATH
+        project_config_path = os.path.expanduser(project_config_path)
+
+    # load the project config file
+    if os.path.exists(project_config_path):
+        project_config = _parse_config_file(project_config_path)
+        _validate_config(project_config, project_config_path)
+    else:
+        project_config = config_utils.Config()
+    return project_config
+
+
+def get_server_config() -> config_utils.Config:
+    """Returns the server config."""
+    # find the server config file
+    server_config_path = _get_config_file_path(ENV_VAR_GLOBAL_CONFIG)
+    if server_config_path:
+        logger.debug('using server config file specified by '
+                     f'{ENV_VAR_GLOBAL_CONFIG}: {server_config_path}')
+        server_config_path = os.path.expanduser(server_config_path)
+        if not os.path.exists(server_config_path):
+            with ux_utils.print_exception_no_traceback():
+                raise FileNotFoundError(
+                    'Config file specified by env var '
+                    f'{ENV_VAR_GLOBAL_CONFIG} ({server_config_path!r}) '
+                    'does not exist. Please double check the path or unset the '
+                    f'env var: unset {ENV_VAR_GLOBAL_CONFIG}')
+    else:
+        server_config_path = _GLOBAL_CONFIG_PATH
+        logger.debug(f'using default server config file: {server_config_path}')
+        server_config_path = os.path.expanduser(server_config_path)
+
+    # load the server config file
+    if os.path.exists(server_config_path):
+        server_config = _parse_config_file(server_config_path)
+        _validate_config(server_config, server_config_path)
+    else:
+        server_config = config_utils.Config()
+    return server_config
 
 
 def get_nested(keys: Tuple[str, ...],
@@ -177,18 +256,18 @@ def _get_config_file_path(envvar: str) -> Optional[str]:
     return None
 
 
-def _validate_config(config: Dict[str, Any], config_path: str) -> None:
+def _validate_config(config: Dict[str, Any], config_source: str) -> None:
     """Validates the config."""
     common_utils.validate_schema(
         config,
         schemas.get_config_schema(),
-        f'Invalid config YAML ({config_path}). See: '
+        f'Invalid config YAML from ({config_source}). See: '
         'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
         'Error: ',
         skip_none=False)
 
 
-def _overlay_skypilot_config(
+def overlay_skypilot_config(
         original_config: Optional[config_utils.Config],
         override_configs: Optional[config_utils.Config]) -> config_utils.Config:
     """Overlays the override configs on the original configs."""
@@ -202,6 +281,12 @@ def _overlay_skypilot_config(
     return config
 
 
+def safe_reload_config() -> None:
+    """Reloads the config, safe to be called concurrently."""
+    with _reload_config_lock:
+        _reload_config()
+
+
 def _reload_config() -> None:
     internal_config_path = os.environ.get(ENV_VAR_SKYPILOT_CONFIG)
     if internal_config_path is not None:
@@ -213,7 +298,10 @@ def _reload_config() -> None:
         _reload_config_from_internal_file(internal_config_path)
         return
 
-    _reload_config_hierarchical()
+    if os.environ.get(constants.ENV_VAR_IS_SKYPILOT_SERVER) is not None:
+        _reload_config_as_server()
+    else:
+        _reload_config_as_client()
 
 
 def _parse_config_file(config_path: str) -> config_utils.Config:
@@ -221,8 +309,9 @@ def _parse_config_file(config_path: str) -> config_utils.Config:
     try:
         config_dict = common_utils.read_yaml(config_path)
         config = config_utils.Config.from_dict(config_dict)
-        logger.debug(
-            f'Config loaded from {config_path}:\n{pprint.pformat(config)}')
+        if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
+            logger.debug(f'Config loaded from {config_path}:\n'
+                         f'{common_utils.dump_yaml_str(dict(config))}')
     except yaml.YAMLError as e:
         logger.error(f'Error in loading config file ({config_path}):', e)
     if config:
@@ -251,67 +340,50 @@ def _reload_config_from_internal_file(internal_config_path: str) -> None:
     _loaded_config_path = config_path
 
 
-def _reload_config_hierarchical() -> None:
+def _reload_config_as_server() -> None:
     global _dict
     # Reset the global variables, to avoid using stale values.
     _dict = config_utils.Config()
 
-    # find the user config file
-    user_config_path = _get_config_file_path(ENV_VAR_USER_CONFIG)
-    if user_config_path:
-        logger.debug('using user config file specified by '
-                     f'{ENV_VAR_USER_CONFIG}: {user_config_path}')
-        user_config_path = os.path.expanduser(user_config_path)
-        if not os.path.exists(user_config_path):
-            with ux_utils.print_exception_no_traceback():
-                raise FileNotFoundError(
-                    'Config file specified by env var '
-                    f'{ENV_VAR_USER_CONFIG} ({user_config_path!r}) '
-                    'does not exist. Please double check the path or unset the '
-                    f'env var: unset {ENV_VAR_USER_CONFIG}')
-    else:
-        user_config_path = get_user_config_path()
-        logger.debug(f'using default user config file: {user_config_path}')
-        user_config_path = os.path.expanduser(user_config_path)
-
-    overrides = []
+    overrides: List[config_utils.Config] = []
+    server_config = get_server_config()
+    if server_config:
+        overrides.append(server_config)
 
-    # find the project config file
-    project_config_path = _get_config_file_path(ENV_VAR_PROJECT_CONFIG)
-    if project_config_path:
-        logger.debug('using project config file specified by '
-                     f'{ENV_VAR_PROJECT_CONFIG}: {project_config_path}')
-        project_config_path = os.path.expanduser(project_config_path)
-        if not os.path.exists(project_config_path):
-            with ux_utils.print_exception_no_traceback():
-                raise FileNotFoundError(
-                    'Config file specified by env var '
-                    f'{ENV_VAR_PROJECT_CONFIG} ({project_config_path!r}) '
-                    'does not exist. Please double check the path or unset the '
-                    f'env var: unset {ENV_VAR_PROJECT_CONFIG}')
-    else:
+    # layer the configs on top of each other based on priority
+    overlaid_server_config: config_utils.Config = config_utils.Config()
+    for override in overrides:
+        overlaid_server_config = overlay_skypilot_config(
+            original_config=overlaid_server_config, override_configs=override)
+    if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
         logger.debug(
-            f'using default project config file: {_PROJECT_CONFIG_PATH}')
-        project_config_path = _PROJECT_CONFIG_PATH
-        project_config_path = os.path.expanduser(project_config_path)
+            f'server config: \n'
+            f'{common_utils.dump_yaml_str(dict(overlaid_server_config))}')
+    _dict = overlaid_server_config
 
-    # load the user config file
-    if os.path.exists(user_config_path):
-        user_config = _parse_config_file(user_config_path)
-        _validate_config(user_config, user_config_path)
-        overrides.append(user_config)
 
-    if os.path.exists(project_config_path):
-        project_config = _parse_config_file(project_config_path)
-        _validate_config(project_config, project_config_path)
+def _reload_config_as_client() -> None:
+    global _dict
+    # Reset the global variables, to avoid using stale values.
+    _dict = config_utils.Config()
+
+    overrides: List[config_utils.Config] = []
+    user_config = get_user_config()
+    if user_config:
+        overrides.append(user_config)
+    project_config = _get_project_config()
+    if project_config:
         overrides.append(project_config)
 
     # layer the configs on top of each other based on priority
     overlaid_client_config: config_utils.Config = config_utils.Config()
     for override in overrides:
-        overlaid_client_config = _overlay_skypilot_config(
+        overlaid_client_config = overlay_skypilot_config(
             original_config=overlaid_client_config, override_configs=override)
-    logger.debug(f'final config: {overlaid_client_config}')
+    if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
+        logger.debug(
+            f'client config (before task and CLI overrides): \n'
+            f'{common_utils.dump_yaml_str(dict(overlaid_client_config))}')
     _dict = overlaid_client_config
 
 
@@ -323,7 +395,7 @@ def loaded_config_path() -> Optional[str]:
     return _loaded_config_path
 
 
-# Load on import.
+# Load on import, synchronization is guaranteed by python interpreter.
 _reload_config()
 
 
@@ -344,10 +416,26 @@ def override_skypilot_config(
         yield
         return
     original_config = _dict
+    override_configs = config_utils.Config(override_configs)
+    disallowed_diff_keys = []
+    for key in constants.SKIPPED_CLIENT_OVERRIDE_KEYS:
+        value = override_configs.pop_nested(key, default_value=None)
+        if (value is not None and
+                value != original_config.get_nested(key, default_value=None)):
+            disallowed_diff_keys.append('.'.join(key))
+    # Only warn if there is a diff in disallowed override keys, as the client
+    # use the same config file when connecting to a local server.
+    if disallowed_diff_keys:
+        logger.warning(
+            f'The following keys ({json.dumps(disallowed_diff_keys)}) have '
+            'different values in the client SkyPilot config with the server '
+            'and will be ignored. Remove these keys to disable this warning. '
+            'If you want to specify it, please modify it on server side or '
+            'contact your administrator.')
     config = _dict.get_nested(
         keys=tuple(),
         default_value=None,
-        override_configs=override_configs,
+        override_configs=dict(override_configs),
         allowed_override_keys=None,
         disallowed_override_keys=constants.SKIPPED_CLIENT_OVERRIDE_KEYS)
     try:
@@ -369,8 +457,61 @@ def override_skypilot_config(
                 '=== SkyPilot config on API server ===\n'
                 f'{common_utils.dump_yaml_str(dict(original_config))}\n'
                 '=== Your local SkyPilot config ===\n'
-                f'{common_utils.dump_yaml_str(override_configs)}\n'
+                f'{common_utils.dump_yaml_str(dict(override_configs))}\n'
                 f'Details: {e}') from e
     finally:
         _dict = original_config
         _config_overridden = False
+
+
+def _compose_cli_config(cli_config: Optional[str],) -> config_utils.Config:
+    """Composes the skypilot CLI config.
+    CLI config can either be:
+    - A path to a config file
+    - A comma-separated list of key-value pairs
+    """
+
+    if not cli_config:
+        return config_utils.Config()
+
+    config_source = 'CLI'
+    maybe_config_path = os.path.expanduser(cli_config)
+    try:
+        if os.path.isfile(maybe_config_path):
+            config_source = maybe_config_path
+            # cli_config is a path to a config file
+            parsed_config = OmegaConf.to_object(
+                OmegaConf.load(maybe_config_path))
+        else:  # cli_config is a comma-separated list of key-value pairs
+            variables: List[str] = []
+            variables = cli_config.split(',')
+            parsed_config = OmegaConf.to_object(
+                OmegaConf.from_dotlist(variables))
+        _validate_config(parsed_config, config_source)
+    except ValueError as e:
+        raise ValueError(f'Invalid config override: {cli_config}. '
+                         f'Check if config file exists or if the dotlist '
+                         f'is formatted as: key1=value1,key2=value2') from e
+    logger.debug('CLI overrides config syntax check passed.')
+
+    return parsed_config
+
+
+def apply_cli_config(cli_config: Optional[str]) -> Dict[str, Any]:
+    """Applies the CLI provided config.
+    SAFETY:
+    This function directly modifies the global _dict variable.
+    This is considered fine in CLI context because the program will exit after
+    a single CLI command is executed.
+    Args:
+        cli_config: A path to a config file or a comma-separated
+        list of key-value pairs.
+    """
+    global _dict
+    parsed_config = _compose_cli_config(cli_config)
+    if sky_logging.logging_enabled(logger, sky_logging.DEBUG):
+        logger.debug(f'applying following CLI overrides: \n'
+                     f'{common_utils.dump_yaml_str(dict(parsed_config))}')
+    _dict = overlay_skypilot_config(original_config=_dict,
+                                    override_configs=parsed_config)
+    return parsed_config

sky/templates/kubernetes-ray.yml.j2

@@ -96,7 +96,7 @@ provider:
             name: skypilot-service-account-role
             apiGroup: rbac.authorization.k8s.io
 
-    # Role for the skypilot-system namespace to create FUSE device manager and
+    # Role for the skypilot-system namespace to create fusermount-server and
     # any other system components.
     autoscaler_skypilot_system_role:
         kind: Role
@@ -384,8 +384,12 @@ available_node_types:
                 set +e
                 
                 if [ ! -z "$MISSING_PACKAGES" ]; then
-                  echo "Installing missing packages: $MISSING_PACKAGES";
-                  DEBIAN_FRONTEND=noninteractive $(prefix_cmd) apt-get install -y -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" $MISSING_PACKAGES;
+                  # Install missing packages individually to avoid failure installation breaks the whole install process,
+                  # e.g. fuse3 is not available on some distributions.
+                  echo "Installing missing packages individually: $MISSING_PACKAGES";
+                  for pkg in $MISSING_PACKAGES; do
+                    DEBIAN_FRONTEND=noninteractive $(prefix_cmd) apt-get install -y -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" $pkg || echo "Optional package $pkg installation failed, skip.";
+                  done
                 fi;
 
                 {% if k8s_fuse_device_required %}

sky/utils/cli_utils/status_utils.py

@@ -6,8 +6,8 @@ import click
 import colorama
 
 from sky import backends
-from sky.skylet import constants
 from sky.utils import common_utils
+from sky.utils import controller_utils
 from sky.utils import log_utils
 from sky.utils import resources_utils
 from sky.utils import status_lib
@@ -198,12 +198,19 @@ def show_cost_report_table(cluster_records: List[_ClusterCostReportRecord],
 
     if cluster_records:
         if controller_name is not None:
-            autostop_minutes = constants.CONTROLLER_IDLE_MINUTES_TO_AUTOSTOP
+            controller = controller_utils.Controllers.from_name(controller_name)
+            if controller is None:
+                raise ValueError(f'Controller {controller_name} not found.')
+            autostop_minutes, _ = (
+                controller_utils.get_controller_autostop_config(
+                    controller=controller))
+            if autostop_minutes is not None:
+                autostop_str = (f'{colorama.Style.DIM} (will be autostopped if '
+                                f'idle for {autostop_minutes}min)'
+                                f'{colorama.Style.RESET_ALL}')
             click.echo(f'\n{colorama.Fore.CYAN}{colorama.Style.BRIGHT}'
                        f'{controller_name}{colorama.Style.RESET_ALL}'
-                       f'{colorama.Style.DIM} (will be autostopped if idle for '
-                       f'{autostop_minutes}min)'
-                       f'{colorama.Style.RESET_ALL}')
+                       f'{autostop_str}')
         else:
             click.echo(f'{colorama.Fore.CYAN}{colorama.Style.BRIGHT}Clusters'
                        f'{colorama.Style.RESET_ALL}')

sky/utils/config_utils.py

@@ -112,14 +112,39 @@ def _recursive_update(
         disallowed_override_keys: Optional[List[Tuple[str,
                                                       ...]]] = None) -> Config:
     """Recursively updates base configuration with override configuration"""
+
+    def _update_k8s_config(
+        base_config: Config,
+        override_config: Dict[str, Any],
+        allowed_override_keys: Optional[List[Tuple[str, ...]]] = None,
+        disallowed_override_keys: Optional[List[Tuple[str,
+                                                      ...]]] = None) -> Config:
+        """Updates the top-level k8s config with the override config."""
+        for key, value in override_config.items():
+            (next_allowed_override_keys, next_disallowed_override_keys
+            ) = _check_allowed_and_disallowed_override_keys(
+                key, allowed_override_keys, disallowed_override_keys)
+            if key in ['custom_metadata', 'pod_config'] and key in base_config:
+                merge_k8s_configs(base_config[key], value,
+                                  next_allowed_override_keys,
+                                  next_disallowed_override_keys)
+            elif (isinstance(value, dict) and key in base_config and
+                  isinstance(base_config[key], dict)):
+                _recursive_update(base_config[key], value,
+                                  next_allowed_override_keys,
+                                  next_disallowed_override_keys)
+            else:
+                base_config[key] = value
+        return base_config
+
     for key, value in override_config.items():
         (next_allowed_override_keys, next_disallowed_override_keys
         ) = _check_allowed_and_disallowed_override_keys(
             key, allowed_override_keys, disallowed_override_keys)
         if key == 'kubernetes' and key in base_config:
-            merge_k8s_configs(base_config[key], value,
-                              next_allowed_override_keys,
-                              next_disallowed_override_keys)
+            _update_k8s_config(base_config[key], value,
+                               next_allowed_override_keys,
+                               next_disallowed_override_keys)
         elif (isinstance(value, dict) and key in base_config and
               isinstance(base_config[key], dict)):
             _recursive_update(base_config[key], value,
@@ -146,7 +171,6 @@ def _get_nested(configs: Optional[Dict[str, Any]],
             curr = value
         else:
             return default_value
-    logger.debug(f'Config: {".".join(keys)} -> {curr}')
     return curr
 
 
@@ -185,19 +209,19 @@ def merge_k8s_configs(
                 merge_k8s_configs(base_config[key][0], value[0],
                                   next_allowed_override_keys,
                                   next_disallowed_override_keys)
-            elif key in ['volumes', 'volumeMounts']:
-                # If the key is 'volumes' or 'volumeMounts', we search for
-                # item with the same name and merge it.
-                for new_volume in value:
-                    new_volume_name = new_volume.get('name')
-                    if new_volume_name is not None:
-                        destination_volume = next(
+            elif key in ['volumes', 'volumeMounts', 'initContainers']:
+                # If the key is 'volumes', 'volumeMounts', or 'initContainers',
+                # we search for item with the same name and merge it.
+                for override_item in value:
+                    override_item_name = override_item.get('name')
+                    if override_item_name is not None:
+                        existing_base_item = next(
                             (v for v in base_config[key]
-                             if v.get('name') == new_volume_name), None)
-                        if destination_volume is not None:
-                            merge_k8s_configs(destination_volume, new_volume)
+                             if v.get('name') == override_item_name), None)
+                        if existing_base_item is not None:
+                            merge_k8s_configs(existing_base_item, override_item)
                         else:
-                            base_config[key].append(new_volume)
+                            base_config[key].append(override_item)
             else:
                 base_config[key].extend(value)
         else: