skypilot-nightly 1.0.0.dev20250411__py3-none-any.whl → 1.0.0.dev20250413__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 CONFIG_PATH
-(default: ~/.sky/config.yaml). Caller can then use
+On module import, we attempt to parse the config located at _USER_CONFIG_PATH
+(default: ~/.sky/skyconfig.yaml). Caller can then use
 
   >> skypilot_config.loaded()
 
@@ -35,14 +35,14 @@ Consider the following config contents:
 
 then:
 
-    # Assuming ~/.sky/config.yaml exists and can be loaded:
+    # Assuming ~/.sky/skyconfig.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/config.yaml doesn't exist or failed to be loaded:
+    # If ~/.sky/skyconfig.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
@@ -71,22 +71,38 @@ else:
 
 logger = sky_logging.init_logger(__name__)
 
-# The config path is discovered in this order:
+# The config is generated as described below:
 #
-# (1) (Used internally) If env var {ENV_VAR_SKYPILOT_CONFIG} exists, use its
-#     path;
-# (2) If file {CONFIG_PATH} exists, use this file.
+# (*) (Used internally) If env var {ENV_VAR_SKYPILOT_CONFIG} exists, use its
+#     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}.
+# (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).
+# (4) Validate the final config.
 #
-# If the path discovered by (1) fails to load, we do not attempt to go to step
-# 2 in the list.
+# (*) is used internally to implement the behavior of the jobs controller.
+#     It is not intended to be used by end users.
+# (1) and (2) are used by end users to set non-default user and project config
+#     files on clients.
 
 # (Used internally) An env var holding the path to the local config file. This
 # is only used by jobs controller tasks to ensure recoveries of the same job
 # use the same config file.
 ENV_VAR_SKYPILOT_CONFIG = f'{constants.SKYPILOT_ENV_VAR_PREFIX}CONFIG'
 
-# Path to the local config file.
-CONFIG_PATH = '~/.sky/config.yaml'
+# (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'
+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'
 
 # The loaded config.
 _dict = config_utils.Config()
@@ -94,6 +110,23 @@ _loaded_config_path: Optional[str] = None
 _config_overridden: bool = False
 
 
+# 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.
+
+    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_nested(keys: Tuple[str, ...],
                default_value: Any,
                override_configs: Optional[Dict[str, Any]] = None) -> Any:
@@ -137,44 +170,149 @@ def to_dict() -> config_utils.Config:
     return copy.deepcopy(_dict)
 
 
+def _get_config_file_path(envvar: str) -> Optional[str]:
+    config_path_via_env_var = os.environ.get(envvar)
+    if config_path_via_env_var is not None:
+        return os.path.expanduser(config_path_via_env_var)
+    return None
+
+
+def _validate_config(config: Dict[str, Any], config_path: str) -> None:
+    """Validates the config."""
+    common_utils.validate_schema(
+        config,
+        schemas.get_config_schema(),
+        f'Invalid config YAML ({config_path}). See: '
+        'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
+        'Error: ',
+        skip_none=False)
+
+
+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."""
+    if original_config is None:
+        original_config = config_utils.Config()
+    config = original_config.get_nested(keys=tuple(),
+                                        default_value=None,
+                                        override_configs=override_configs,
+                                        allowed_override_keys=None,
+                                        disallowed_override_keys=None)
+    return config
+
+
 def _reload_config() -> None:
+    internal_config_path = os.environ.get(ENV_VAR_SKYPILOT_CONFIG)
+    if internal_config_path is not None:
+        # {ENV_VAR_SKYPILOT_CONFIG} is used internally.
+        # When this environment variable is set, the config loading
+        # behavior is not defined in the public interface.
+        # SkyPilot reserves the right to change the config loading behavior
+        # at any time when this environment variable is set.
+        _reload_config_from_internal_file(internal_config_path)
+        return
+
+    _reload_config_hierarchical()
+
+
+def _parse_config_file(config_path: str) -> config_utils.Config:
+    config = 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)}')
+    except yaml.YAMLError as e:
+        logger.error(f'Error in loading config file ({config_path}):', e)
+    if config:
+        _validate_config(config, config_path)
+
+    logger.debug(f'Config syntax check passed for path: {config_path}')
+    return config
+
+
+def _reload_config_from_internal_file(internal_config_path: str) -> None:
     global _dict, _loaded_config_path
     # Reset the global variables, to avoid using stale values.
     _dict = config_utils.Config()
     _loaded_config_path = None
 
-    config_path_via_env_var = os.environ.get(ENV_VAR_SKYPILOT_CONFIG)
-    if config_path_via_env_var is not None:
-        config_path = os.path.expanduser(config_path_via_env_var)
-        if not os.path.exists(config_path):
+    config_path = os.path.expanduser(internal_config_path)
+    if not os.path.exists(config_path):
+        with ux_utils.print_exception_no_traceback():
+            raise FileNotFoundError(
+                'Config file specified by env var '
+                f'{ENV_VAR_SKYPILOT_CONFIG} ({config_path!r}) does not '
+                'exist. Please double check the path or unset the env var: '
+                f'unset {ENV_VAR_SKYPILOT_CONFIG}')
+    logger.debug(f'Using config path: {config_path}')
+    _dict = _parse_config_file(config_path)
+    _loaded_config_path = config_path
+
+
+def _reload_config_hierarchical() -> 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 = []
+
+    # 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_SKYPILOT_CONFIG} ({config_path!r}) does not '
-                    'exist. Please double check the path or unset the env var: '
-                    f'unset {ENV_VAR_SKYPILOT_CONFIG}')
+                    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:
-        config_path = CONFIG_PATH
-    config_path = os.path.expanduser(config_path)
-    if os.path.exists(config_path):
-        logger.debug(f'Using config path: {config_path}')
-        try:
-            config = common_utils.read_yaml(config_path)
-            _dict = config_utils.Config.from_dict(config)
-            _loaded_config_path = config_path
-            logger.debug(f'Config loaded:\n{pprint.pformat(_dict)}')
-        except yaml.YAMLError as e:
-            logger.error(f'Error in loading config file ({config_path}):', e)
-        if _dict:
-            common_utils.validate_schema(
-                _dict,
-                schemas.get_config_schema(),
-                f'Invalid config YAML ({config_path}). See: '
-                'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
-                'Error: ',
-                skip_none=False)
-
-        logger.debug('Config syntax check passed.')
+        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 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)
+        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(
+            original_config=overlaid_client_config, override_configs=override)
+    logger.debug(f'final config: {overlaid_client_config}')
+    _dict = overlaid_client_config
 
 
 def loaded_config_path() -> Optional[str]:
@@ -216,7 +354,7 @@ def override_skypilot_config(
         common_utils.validate_schema(
             config,
             schemas.get_config_schema(),
-            f'Invalid config {config}. See: '
+            'Invalid config. See: '
             'https://docs.skypilot.co/en/latest/reference/config.html. '  # pylint: disable=line-too-long
             'Error: ',
             skip_none=False)

sky/templates/kubernetes-ray.yml.j2

@@ -267,11 +267,6 @@ available_node_types:
             {%- for label_key, label_value in labels.items() %}
             {{ label_key }}: {{ label_value|tojson }}
             {%- endfor %}
-        {% if k8s_fuse_device_required %}
-        annotations:
-            # Required for FUSE mounting to access /dev/fuse
-            container.apparmor.security.beta.kubernetes.io/ray-node: unconfined
-        {% endif %}
       spec:
         # serviceAccountName: skypilot-service-account
         serviceAccountName: {{k8s_service_account_name}}
@@ -310,9 +305,12 @@ available_node_types:
         - name: dshm
           emptyDir:
             medium: Memory
-        - name: dev-fuse    # Required for fuse mounting
+        {% if k8s_fuse_device_required %}
+        - name: fusermount-shared-dir
           hostPath:
-            path: /dev/fuse
+            path: {{k8s_fusermount_shared_dir}}
+            type: DirectoryOrCreate
+        {% endif %}
         containers:
         - name: ray-node
           imagePullPolicy: IfNotPresent
@@ -326,6 +324,10 @@ available_node_types:
             - name: {{ key }}
               value: {{ value }}
             {% endfor %}
+            {% if k8s_fuse_device_required %}
+            - name: FUSERMOUNT_SHARED_DIR
+              value: {{k8s_fusermount_shared_dir}}
+            {% endif %}
           # Do not change this command - it keeps the pod alive until it is
           # explicitly killed.
           command: ["/bin/bash", "-c", "--"]
@@ -350,11 +352,14 @@ available_node_types:
                 (
                 DEBIAN_FRONTEND=noninteractive $(prefix_cmd) apt-get update > /tmp/apt-update.log 2>&1 || \
                 echo "Warning: apt-get update failed. Continuing anyway..." >> /tmp/apt-update.log
-                PACKAGES="rsync curl netcat gcc patch pciutils fuse openssh-server";
+                # Install both fuse2 and fuse3 for compatibility for all possible fuse adapters in advance,
+                # so that both fusemount and fusermount3 can be masked before enabling SSH access.
+                PACKAGES="rsync curl wget netcat gcc patch pciutils fuse fuse3 openssh-server";
 
                 # Separate packages into two groups: packages that are installed first
-                # so that curl and rsync are available sooner to unblock the following
+                # so that curl, rsync and wget are available sooner to unblock the following
                 # conda installation and rsync.
+                # Also, we install fuse first to avoid confliction with fuse3.
                 set -e
                 INSTALL_FIRST="";
                 MISSING_PACKAGES="";
@@ -364,7 +369,7 @@ available_node_types:
                       INSTALL_FIRST="$INSTALL_FIRST netcat-openbsd";
                     fi
                   elif ! dpkg -l | grep -q "^ii  $pkg "; then
-                    if [ "$pkg" == "curl" ] || [ "$pkg" == "rsync" ]; then
+                    if [ "$pkg" == "curl" ] || [ "$pkg" == "rsync" ] || [ "$pkg" == "fuse" ] || [ "$pkg" == "wget" ]; then
                       INSTALL_FIRST="$INSTALL_FIRST $pkg";
                     else
                       MISSING_PACKAGES="$MISSING_PACKAGES $pkg";
@@ -382,7 +387,52 @@ available_node_types:
                   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;
                 fi;
-              
+
+                {% if k8s_fuse_device_required %}
+                set -e
+                # Mask fusermount binary before enabling SSH access
+                FUSERMOUNT_PATH=$(which fusermount)
+                if [ -z "$FUSERMOUNT_PATH" ]; then
+                    echo "Error: fusermount binary not found"
+                    exit 1
+                fi
+                $(prefix_cmd) cp -p "$FUSERMOUNT_PATH" "${FUSERMOUNT_PATH}-original"
+                $(prefix_cmd) ln -sf {{k8s_fusermount_shared_dir}}/fusermount-shim "$FUSERMOUNT_PATH"
+                FUSERMOUNT3_PATH=$(which fusermount3)
+                if [ -z "$FUSERMOUNT3_PATH" ]; then
+                    FUSERMOUNT3_PATH="${FUSERMOUNT_PATH}3"
+                fi
+                # Also mask fusermount3 for rclone and blobfuse2 (for unmount operation)
+                $(prefix_cmd) ln -sf "$FUSERMOUNT_PATH" "$FUSERMOUNT3_PATH"
+                # Add fusermount-wrapper to handle adapters that use libfuse directly, e.g. blobfuse2
+                $(prefix_cmd) ln -sf {{k8s_fusermount_shared_dir}}/fusermount-wrapper /bin/fusermount-wrapper
+                # Wait for the server to setup the fusermount shim binary in case:
+                # 1. The server daemonset was just deployed and is still starting up.
+                # 2. The node was just started and the server Pod is still starting up.
+                wait_for_fusermount() {
+                    local timeout=60
+                    local start_time=$(date +%s)
+                    while ! command -v fusermount >/dev/null 2>&1; do
+                        current_time=$(date +%s)
+                        elapsed=$((current_time - start_time))
+                        if [ $elapsed -ge $timeout ]; then
+                            echo "Error: fusermount not ready after $timeout seconds"
+                            exit 1
+                        fi
+                        sleep 1
+                    done
+                }
+                wait_for_fusermount
+                # Some distributions may mount hostPath with noexec, copy the binary in this case.
+                if ! fusermount -V; then
+                    echo "fusermount -V failed, copying fusermount-shim directly"
+                    $(prefix_cmd) rm -f "$FUSERMOUNT_PATH"
+                    $(prefix_cmd) cp -p {{k8s_fusermount_shared_dir}}/fusermount-shim "$FUSERMOUNT_PATH"
+                    $(prefix_cmd) rm -f /bin/fusermount-wrapper
+                    $(prefix_cmd) cp -p {{k8s_fusermount_shared_dir}}/fusermount-wrapper /bin/fusermount-wrapper
+                fi
+                {% endif %}            
+
                 $(prefix_cmd) mkdir -p /var/run/sshd;
                 $(prefix_cmd) sed -i "s/PermitRootLogin prohibit-password/PermitRootLogin yes/" /etc/ssh/sshd_config;
                 $(prefix_cmd) sed "s@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g" -i /etc/pam.d/sshd;
@@ -394,6 +444,7 @@ available_node_types:
                 $(prefix_cmd) chmod 644 ~/.ssh/authorized_keys;
                 $(prefix_cmd) service ssh restart;
                 $(prefix_cmd) sed -i "s/mesg n/tty -s \&\& mesg n/" ~/.profile;
+
                 ) > /tmp/${STEPS[0]}.log 2>&1 || {
                   echo "Error: ${STEPS[0]} failed. Continuing anyway..." > /tmp/${STEPS[0]}.failed
                   cat /tmp/${STEPS[0]}.log
@@ -539,10 +590,8 @@ available_node_types:
           - mountPath: /dev/shm
             name: dshm
           {% if k8s_fuse_device_required %}
-          securityContext:
-            capabilities:
-              add:
-                - "SYS_ADMIN"
+          - name: fusermount-shared-dir
+            mountPath: {{k8s_fusermount_shared_dir}}
           {% endif %}
           resources:
             requests:
@@ -556,20 +605,12 @@ available_node_types:
               # https://cloud.google.com/kubernetes-engine/docs/concepts/tpus#how_tpus_work
               {{k8s_resource_key}}: {{accelerator_count}}
               {% endif %}
-              {% if k8s_fuse_device_required %}
-              # Kubernetes resource exposed by the fuse device manager
-              # https://gitlab.com/arm-research/smarter/smarter-device-manager
-              smarter-devices/fuse: "1"
-              {% endif %}
-            {% if k8s_resource_key is not none or k8s_fuse_device_required %}
+            {% if k8s_resource_key is not none %}
             limits:
               # Limits need to be defined for GPU/TPU requests
               {% if k8s_resource_key is not none %}
               {{k8s_resource_key}}: {{accelerator_count}}
               {% endif %}
-              {% if k8s_fuse_device_required %}
-              smarter-devices/fuse: "1"
-              {% endif %}
             {% endif %}
             
 setup_commands:
@@ -578,7 +619,7 @@ setup_commands:
   # Line 'sudo bash ..': set the ulimit as suggested by ray docs for performance. https://docs.ray.io/en/latest/cluster/vms/user-guides/large-cluster-best-practices.html#system-configuration
   # Line 'sudo grep ..': set the number of threads per process to unlimited to avoid ray job submit stucking issue when the number of running ray jobs increase.
   # Line 'mkdir -p ..': disable host key check
-  # Line 'python3 -c ..': patch the buggy ray files and enable `-o allow_other` option for `goofys`
+  # Line '[-f /etc/fuse.conf] ..': enable `-o allow_other` option for `goofys`
   # Line 'for step in ..': check if any failure indicator exists for the setup done in pod args and print the error message. This is only a best effort, as the
   # commands in pod args are asynchronous and we cannot guarantee the failure indicators are created before the setup commands finish.
   - |

sky/templates/websocket_proxy.py

@@ -1,17 +1,46 @@
 #!/usr/bin/env python3
+# /// script
+# dependencies = [
+#   "websockets>=14.0",
+# ]
+# ///
 """Starting a websocket with SkyPilot API server to proxy SSH to a k8s pod.
 
 This script is useful for users who do not have local Kubernetes credentials.
 """
 import asyncio
+from http.cookiejar import MozillaCookieJar
 import os
 import sys
+from typing import Dict
+from urllib.request import Request
 
 import websockets
+from websockets.asyncio.client import connect
+
+
+def _get_cookie_header(url: str) -> Dict[str, str]:
+    """Extract Cookie header value from a cookie jar for a specific URL"""
+    cookie_path = os.environ.get('SKYPILOT_API_COOKIE_FILE')
+    if cookie_path is None:
+        return {}
+
+    request = Request(url)
+    cookie_jar = MozillaCookieJar(os.path.expanduser(cookie_path))
+    cookie_jar.load(ignore_discard=True, ignore_expires=True)
+    cookie_jar.add_cookie_header(request)
+    cookie_header = request.get_header('Cookie')
+    # if cookie file is empty, return empty dict
+    if cookie_header is None:
+        return {}
+    return {'Cookie': cookie_header}
 
 
 async def main(url: str) -> None:
-    async with websockets.connect(url, ping_interval=None) as websocket:
+    cookie_header = _get_cookie_header(url)
+    async with connect(url,
+                       ping_interval=None,
+                       additional_headers=cookie_header) as websocket:
         if os.isatty(sys.stdin.fileno()):
             # pylint: disable=import-outside-toplevel
             import termios
@@ -59,6 +88,16 @@ async def websocket_to_stdout(websocket):
 
 if __name__ == '__main__':
     server_url = sys.argv[1].strip('/')
-    websocket_url = (f'ws://{server_url}/kubernetes-pod-ssh-proxy'
+    if '://' not in server_url:
+        # Keep backward compatibility for legacy server URLs without protocol
+        # TODO(aylei): Remove this after 0.10.0
+        server_url = f'http://{server_url}'
+
+    server_proto, server_fqdn = server_url.split('://')
+    websocket_proto = 'ws'
+    if server_proto == 'https':
+        websocket_proto = 'wss'
+    server_url = f'{websocket_proto}://{server_fqdn}'
+    websocket_url = (f'{server_url}/kubernetes-pod-ssh-proxy'
                      f'?cluster_name={sys.argv[2]}')
     asyncio.run(main(websocket_url))

sky/utils/config_utils.py

@@ -146,7 +146,7 @@ def _get_nested(configs: Optional[Dict[str, Any]],
             curr = value
         else:
             return default_value
-    logger.debug(f'User config: {".".join(keys)} -> {curr}')
+    logger.debug(f'Config: {".".join(keys)} -> {curr}')
     return curr
 
 

sky/utils/controller_utils.py

@@ -46,7 +46,7 @@ logger = sky_logging.init_logger(__name__)
 # controller resources spec.
 CONTROLLER_RESOURCES_NOT_VALID_MESSAGE = (
     '{controller_type} controller resources is not valid, please check '
-    '~/.sky/config.yaml file and make sure '
+    '~/.sky/skyconfig.yaml file and make sure '
     '{controller_type}.controller.resources is a valid resources spec. '
     'Details:\n  {err}')
 

sky/utils/kubernetes/generate_kubeconfig.sh

@@ -328,9 +328,9 @@ cp kubeconfig ~/.kube/config
 # Verify that you can access the cluster
 kubectl get pods
 
-Also add this to your ~/.sky/config.yaml to use the new service account:
+Also add this to your ~/.sky/skyconfig.yaml to use the new service account:
 
-# ~/.sky/config.yaml
+# ~/.sky/skyconfig.yaml
 kubernetes:
   remote_identity: ${SKYPILOT_SA}
 "

sky/utils/kubernetes/rsync_helper.sh

@@ -1,20 +1,35 @@
-# When using pod@namespace+context, rsync passes args as: {us} -l pod namespace+context
-# We need to split the pod@namespace+context into pod, namespace and context
+# We need to determine the pod, namespace and context from the args
 # For backward compatibility, we use + as the separator between namespace and context and add handling when context is not provided
-shift
-pod=$1
-shift
-echo "pod: $pod" >&2
-encoded_namespace_context=$1
-# Revert the encoded namespace+context to the original string.
-namespace_context=$(echo "$encoded_namespace_context" | sed 's|%40|@|g' | sed 's|%3A|:|g' | sed 's|%2B|+|g' | sed 's|%2F|/|g')
-echo "namespace_context: $namespace_context" >&2
+if [ "$1" = "-l" ]; then
+    # -l pod namespace+context ...
+    # used by normal rsync
+    shift
+    pod=$1
+    shift
+    encoded_namespace_context=$1
+    shift
+    echo "pod: $pod" >&2
+    # Revert the encoded namespace+context to the original string.
+    namespace_context=$(echo "$encoded_namespace_context" | sed 's|%40|@|g' | sed 's|%3A|:|g' | sed 's|%2B|+|g' | sed 's|%2F|/|g')
+    echo "namespace_context: $namespace_context" >&2
+else
+    # pod@namespace+context ...
+    # used by openrsync
+    encoded_pod_namespace_context=$1
+    shift
+    pod_namespace_context=$(echo "$encoded_pod_namespace_context" | sed 's|%40|@|g' | sed 's|%3A|:|g' | sed 's|%2B|+|g' | sed 's|%2F|/|g')
+    echo "pod_namespace_context: $pod_namespace_context" >&2
+    pod=$(echo $pod_namespace_context | cut -d@ -f1)
+    echo "pod: $pod" >&2
+    namespace_context=$(echo $pod_namespace_context | cut -d@ -f2-)
+    echo "namespace_context: $namespace_context" >&2
+fi
 namespace=$(echo $namespace_context | cut -d+ -f1)
 echo "namespace: $namespace" >&2
 context=$(echo $namespace_context | grep '+' >/dev/null && echo $namespace_context | cut -d+ -f2- || echo "")
 echo "context: $context" >&2
 context_lower=$(echo "$context" | tr '[:upper:]' '[:lower:]')
-shift
+
 if [ -z "$context" ] || [ "$context_lower" = "none" ]; then
     # If context is none, it means we are using incluster auth. In this case,
     # use need to set KUBECONFIG to /dev/null to avoid using kubeconfig file.

{skypilot_nightly-1.0.0.dev20250411.dist-info → skypilot_nightly-1.0.0.dev20250413.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250411
+Version: 1.0.0.dev20250413
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0
@@ -88,6 +88,7 @@ Requires-Dist: oci; extra == "oci"
 Requires-Dist: ray[default]!=2.6.0,>=2.2.0; extra == "oci"
 Provides-Extra: kubernetes
 Requires-Dist: kubernetes!=32.0.0,>=20.0.0; extra == "kubernetes"
+Requires-Dist: websockets; extra == "kubernetes"
 Provides-Extra: remote
 Requires-Dist: grpcio!=1.48.0,>=1.32.0; python_version < "3.10" and extra == "remote"
 Requires-Dist: grpcio!=1.48.0,>=1.42.0; python_version >= "3.10" and extra == "remote"
@@ -145,6 +146,7 @@ Requires-Dist: ray[default]!=2.6.0,>=2.2.0; extra == "all"
 Requires-Dist: oci; extra == "all"
 Requires-Dist: ray[default]!=2.6.0,>=2.2.0; extra == "all"
 Requires-Dist: kubernetes!=32.0.0,>=20.0.0; extra == "all"
+Requires-Dist: websockets; extra == "all"
 Requires-Dist: grpcio!=1.48.0,>=1.32.0; python_version < "3.10" and extra == "all"
 Requires-Dist: grpcio!=1.48.0,>=1.42.0; python_version >= "3.10" and extra == "all"
 Requires-Dist: protobuf!=3.19.5,>=3.15.3; extra == "all"