skypilot-nightly 1.0.0.dev20250905__py3-none-any.whl → 1.0.0.dev20251210__py3-none-any.whl

sky/utils/ux_utils.py

@@ -1,11 +1,12 @@
 """Utility functions for UX."""
 import contextlib
 import enum
+import fnmatch
 import os
 import sys
 import traceback
 import typing
-from typing import Callable, Optional, Union
+from typing import Callable, Iterable, List, Optional, Union
 
 import colorama
 
@@ -288,3 +289,36 @@ def command_hint_messages(hint_type: CommandHintType,
                 f'{BOLD}sky jobs queue{RESET_BOLD}')
     else:
         raise ValueError(f'Invalid hint type: {hint_type}')
+
+
+def is_glob_pattern(pattern: str) -> bool:
+    """Checks if a string contains common glob pattern wildcards."""
+    glob_chars = {'*', '?', '[', ']'}
+    # Also check for '**' as a specific globstar pattern
+    if '**' in pattern:
+        return True
+    for char in pattern:
+        if char in glob_chars:
+            return True
+    return False
+
+
+def get_non_matched_query(query_clusters: Iterable[str],
+                          cluster_names: Iterable[str]) -> List[str]:
+    """Gets the non-matched query clusters."""
+    glob_query_clusters = []
+    non_glob_query_clusters = []
+    for cluster_name in query_clusters:
+        if is_glob_pattern(cluster_name):
+            glob_query_clusters.append(cluster_name)
+        else:
+            non_glob_query_clusters.append(cluster_name)
+    not_found_clusters = [
+        query_cluster for query_cluster in non_glob_query_clusters
+        if query_cluster not in cluster_names
+    ]
+    not_found_clusters.extend([
+        query_cluster for query_cluster in glob_query_clusters
+        if not fnmatch.filter(cluster_names, query_cluster)
+    ])
+    return not_found_clusters

sky/utils/volume.py

@@ -1,12 +1,14 @@
 """Volume utilities."""
+from dataclasses import dataclass
 import enum
 import time
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from sky import exceptions
 from sky import global_user_state
 from sky import models
 from sky.utils import common_utils
+from sky.utils import resources_utils
 from sky.utils import schemas
 from sky.utils import status_lib
 
@@ -26,18 +28,42 @@ class VolumeType(enum.Enum):
     PVC = 'k8s-pvc'
     RUNPOD_NETWORK_VOLUME = 'runpod-network-volume'
 
+    @classmethod
+    def supported_types(cls) -> list:
+        """Return list of supported volume type values."""
+        return [vt.value for vt in cls]
+
+
+EPHEMERAL_VOLUME_TYPES = [VolumeType.PVC.value]
+
+
+@dataclass
+class VolumeInfo:
+    """Represents volume info."""
+    name: str
+    path: str
+    volume_name_on_cloud: Optional[str] = None
+    volume_id_on_cloud: Optional[str] = None
+
 
 class VolumeMount:
     """Volume mount specification."""
 
-    def __init__(self, path: str, volume_name: str,
-                 volume_config: models.VolumeConfig):
+    def __init__(self,
+                 path: str,
+                 volume_name: str,
+                 volume_config: models.VolumeConfig,
+                 is_ephemeral: bool = False):
         self.path: str = path
         self.volume_name: str = volume_name
         self.volume_config: models.VolumeConfig = volume_config
+        self.is_ephemeral: bool = is_ephemeral
 
     def pre_mount(self) -> None:
         """Update the volume status before actual mounting."""
+        # Skip pre_mount for ephemeral volumes as they don't exist yet
+        if self.is_ephemeral:
+            return
         # TODO(aylei): for ReadWriteOnce volume, we also need to queue the
         # mount request if the target volume is already mounted to another
         # cluster. For now, we only support ReadWriteMany volume.
@@ -63,19 +89,77 @@ class VolumeMount:
 
         path = config.pop('path', None)
         volume_name = config.pop('volume_name', None)
+        is_ephemeral = config.pop('is_ephemeral', False)
         volume_config: models.VolumeConfig = models.VolumeConfig.model_validate(
             config.pop('volume_config', None))
-        return cls(path, volume_name, volume_config)
+        return cls(path, volume_name, volume_config, is_ephemeral)
+
+    @classmethod
+    def resolve_ephemeral_config(cls, path: str,
+                                 config: Dict[str, Any]) -> 'VolumeMount':
+        """Create an ephemeral volume mount from inline config.
+
+        Args:
+            path: The mount path for the volume.
+            config: The volume configuration dict with size, and
+                optional type, labels, and config fields, etc.
+
+        Returns:
+            A VolumeMount instance for the ephemeral volume.
+        """
+        volume_type = config.get('type')
+        if volume_type and volume_type.lower() not in EPHEMERAL_VOLUME_TYPES:
+            raise ValueError(f'Unsupported ephemeral volume type: '
+                             f'{volume_type}. Supported types: '
+                             f'{", ".join(EPHEMERAL_VOLUME_TYPES)}')
+        size_config = config.get('size')
+        if size_config is None:
+            raise ValueError('Volume size must be specified for ephemeral '
+                             'volumes.')
+        try:
+            size = resources_utils.parse_memory_resource(size_config,
+                                                         'size',
+                                                         allow_rounding=True)
+            if size == '0':
+                raise ValueError('Size must be no less than 1Gi')
+        except ValueError as e:
+            raise ValueError(
+                f'Invalid size {size_config} for ephemeral volume: {e}') from e
+
+        # Create VolumeConfig for ephemeral volume
+        # Note: the empty fields will be populated during provisioning
+        volume_config = models.VolumeConfig(
+            name='',
+            type=config.get('type', ''),
+            # Default to kubernetes cloud here for backward compatibility,
+            # but this will be reset to the correct cloud during provisioning.
+            cloud='kubernetes',
+            region=None,
+            zone=None,
+            name_on_cloud='',
+            size=size,
+            config=config.get('config', {}),
+            labels=config.get('labels'),
+        )
+
+        return cls(path, '', volume_config, is_ephemeral=True)
 
     def to_yaml_config(self) -> Dict[str, Any]:
         return {
             'path': self.path,
             'volume_name': self.volume_name,
             'volume_config': self.volume_config.model_dump(),
+            'is_ephemeral': self.is_ephemeral,
         }
 
+    @property
+    def name(self) -> str:
+        """Return the volume name for use in provisioning."""
+        return self.volume_name
+
     def __repr__(self):
         return (f'VolumeMount('
                 f'\n\tpath={self.path},'
                 f'\n\tvolume_name={self.volume_name},'
+                f'\n\tis_ephemeral={self.is_ephemeral},'
                 f'\n\tvolume_config={self.volume_config})')

sky/utils/yaml_utils.py

@@ -44,6 +44,15 @@ def read_yaml(path: Optional[str]) -> Dict[str, Any]:
     return config
 
 
+def read_yaml_str(yaml_str: str) -> Dict[str, Any]:
+    stream = io.StringIO(yaml_str)
+    parsed_yaml = safe_load(stream)
+    if not parsed_yaml:
+        # Empty dict
+        return {}
+    return parsed_yaml
+
+
 def read_yaml_all_str(yaml_str: str) -> List[Dict[str, Any]]:
     stream = io.StringIO(yaml_str)
     config = safe_load_all(stream)

sky/volumes/client/sdk.py

@@ -1,15 +1,19 @@
 """SDK functions for managed jobs."""
 import json
 import typing
-from typing import Any, Dict, List
+from typing import List
 
+from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
+from sky.schemas.api import responses
 from sky.server import common as server_common
+from sky.server import versions
 from sky.server.requests import payloads
 from sky.usage import usage_lib
 from sky.utils import annotations
 from sky.utils import context
+from sky.utils import ux_utils
 from sky.volumes import volume as volume_lib
 
 if typing.TYPE_CHECKING:
@@ -70,10 +74,10 @@ def apply(volume: volume_lib.Volume) -> server_common.RequestId[None]:
         size=volume.size,
         config=volume.config,
         labels=volume.labels,
+        use_existing=volume.use_existing,
     )
-    response = requests.post(f'{server_common.get_server_url()}/volumes/apply',
-                             json=json.loads(body.model_dump_json()),
-                             cookies=server_common.get_api_cookie_jar())
+    response = server_common.make_authenticated_request(
+        'POST', '/volumes/apply', json=json.loads(body.model_dump_json()))
     return server_common.get_request_id(response)
 
 
@@ -81,14 +85,49 @@ def apply(volume: volume_lib.Volume) -> server_common.RequestId[None]:
 @usage_lib.entrypoint
 @server_common.check_server_healthy_or_start
 @annotations.client_api
-def ls() -> server_common.RequestId[List[Dict[str, Any]]]:
+@versions.minimal_api_version(20)
+def validate(volume: volume_lib.Volume) -> None:
+    """Validates the volume.
+
+    All validation is done on the server side.
+
+    Args:
+        volume: The volume to validate.
+
+    Raises:
+        ValueError: If the volume is invalid.
+    """
+    body = payloads.VolumeValidateBody(
+        name=volume.name,
+        volume_type=volume.type,
+        infra=volume.infra,
+        size=volume.size,
+        config=volume.config,
+        labels=volume.labels,
+        use_existing=volume.use_existing,
+    )
+    response = server_common.make_authenticated_request(
+        'POST', '/volumes/validate', json=json.loads(body.model_dump_json()))
+    if response.status_code == 400:
+        with ux_utils.print_exception_no_traceback():
+            raise exceptions.deserialize_exception(
+                response.json().get('detail'))
+
+
+@context.contextual
+@usage_lib.entrypoint
+@server_common.check_server_healthy_or_start
+@annotations.client_api
+def ls() -> server_common.RequestId[List[responses.VolumeRecord]]:
     """Lists all volumes.
 
     Returns:
         The request ID of the list request.
     """
-    response = requests.get(f'{server_common.get_server_url()}/volumes',
-                            cookies=server_common.get_api_cookie_jar())
+    response = server_common.make_authenticated_request(
+        'GET',
+        '/volumes',
+    )
     return server_common.get_request_id(response)
 
 
@@ -106,7 +145,6 @@ def delete(names: List[str]) -> server_common.RequestId[None]:
         The request ID of the delete request.
     """
     body = payloads.VolumeDeleteBody(names=names)
-    response = requests.post(f'{server_common.get_server_url()}/volumes/delete',
-                             json=json.loads(body.model_dump_json()),
-                             cookies=server_common.get_api_cookie_jar())
+    response = server_common.make_authenticated_request(
+        'POST', '/volumes/delete', json=json.loads(body.model_dump_json()))
     return server_common.get_request_id(response)

sky/volumes/server/core.py

@@ -11,6 +11,7 @@ from sky import global_user_state
 from sky import models
 from sky import provision
 from sky import sky_logging
+from sky.schemas.api import responses
 from sky.utils import common_utils
 from sky.utils import registry
 from sky.utils import rich_utils
@@ -26,16 +27,10 @@ VOLUME_LOCK_TIMEOUT_SECONDS = 20
 
 def volume_refresh():
     """Refreshes the volume status."""
-    volumes = global_user_state.get_volumes()
+    volumes = volume_list(is_ephemeral=False)
     for volume in volumes:
-        volume_name = volume.get('name')
-        config = volume.get('handle')
-        if config is None:
-            logger.warning(f'Volume {volume_name} has no handle.'
-                           'Skipping status refresh...')
-            continue
-        cloud = config.cloud
-        usedby_pods, _ = provision.get_volume_usedby(cloud, config)
+        volume_name = volume.name
+        usedby_pods = volume.usedby_pods
         with _volume_lock(volume_name):
             latest_volume = global_user_state.get_volume_by_name(volume_name)
             if latest_volume is None:
@@ -56,7 +51,8 @@ def volume_refresh():
                         volume_name, status=status_lib.VolumeStatus.IN_USE)
 
 
-def volume_list() -> List[Dict[str, Any]]:
+def volume_list(
+        is_ephemeral: Optional[bool] = None) -> List[responses.VolumeRecord]:
     """Gets the volumes.
 
     Returns:
@@ -78,11 +74,31 @@ def volume_list() -> List[Dict[str, Any]]:
                 'status': sky.VolumeStatus,
                 'usedby_pods': List[str],
                 'usedby_clusters': List[str],
+                'is_ephemeral': bool,
             }
         ]
     """
     with rich_utils.safe_status(ux_utils.spinner_message('Listing volumes')):
-        volumes = global_user_state.get_volumes()
+        volumes = global_user_state.get_volumes(is_ephemeral=is_ephemeral)
+        cloud_to_configs: Dict[str, List[models.VolumeConfig]] = {}
+        for volume in volumes:
+            config = volume.get('handle')
+            if config is None:
+                volume_name = volume.get('name')
+                logger.warning(f'Volume {volume_name} has no handle.')
+                continue
+            cloud = config.cloud
+            if cloud not in cloud_to_configs:
+                cloud_to_configs[cloud] = []
+            cloud_to_configs[cloud].append(config)
+
+        cloud_to_used_by_pods, cloud_to_used_by_clusters = {}, {}
+        for cloud, configs in cloud_to_configs.items():
+            used_by_pods, used_by_clusters = provision.get_all_volumes_usedby(
+                cloud, configs)
+            cloud_to_used_by_pods[cloud] = used_by_pods
+            cloud_to_used_by_clusters[cloud] = used_by_clusters
+
         all_users = global_user_state.get_all_users()
         user_map = {user.id: user.name for user in all_users}
         records = []
@@ -98,6 +114,7 @@ def volume_list() -> List[Dict[str, Any]]:
                 'last_use': volume.get('last_use'),
                 'usedby_pods': [],
                 'usedby_clusters': [],
+                'is_ephemeral': volume.get('is_ephemeral', False),
             }
             status = volume.get('status')
             if status is not None:
@@ -109,8 +126,12 @@ def volume_list() -> List[Dict[str, Any]]:
                 logger.warning(f'Volume {volume_name} has no handle.')
                 continue
             cloud = config.cloud
-            usedby_pods, usedby_clusters = provision.get_volume_usedby(
-                cloud, config)
+            usedby_pods, usedby_clusters = provision.map_all_volumes_usedby(
+                cloud,
+                cloud_to_used_by_pods[cloud],
+                cloud_to_used_by_clusters[cloud],
+                config,
+            )
             record['type'] = config.type
             record['cloud'] = config.cloud
             record['region'] = config.region
@@ -120,15 +141,16 @@ def volume_list() -> List[Dict[str, Any]]:
             record['name_on_cloud'] = config.name_on_cloud
             record['usedby_pods'] = usedby_pods
             record['usedby_clusters'] = usedby_clusters
-            records.append(record)
+            records.append(responses.VolumeRecord(**record))
         return records
 
 
-def volume_delete(names: List[str]) -> None:
+def volume_delete(names: List[str], ignore_not_found: bool = False) -> None:
     """Deletes volumes.
 
     Args:
         names: List of volume names to delete.
+        ignore_not_found: If True, ignore volumes that are not found.
 
     Raises:
         ValueError: If the volume does not exist
@@ -138,6 +160,8 @@ def volume_delete(names: List[str]) -> None:
         for name in names:
             volume = global_user_state.get_volume_by_name(name)
             if volume is None:
+                if ignore_not_found:
+                    continue
                 raise ValueError(f'Volume {name} not found.')
             config = volume.get('handle')
             if config is None:
@@ -160,6 +184,7 @@ def volume_delete(names: List[str]) -> None:
             with _volume_lock(name):
                 provision.delete_volume(cloud, config)
                 global_user_state.delete_volume(name)
+        logger.info(f'Deleted volumes: {names}')
 
 
 def volume_apply(
@@ -171,6 +196,8 @@ def volume_apply(
     size: Optional[str],
     config: Dict[str, Any],
     labels: Optional[Dict[str, str]] = None,
+    use_existing: Optional[bool] = None,
+    is_ephemeral: bool = False,
 ) -> None:
     """Creates or registers a volume.
 
@@ -183,17 +210,22 @@ def volume_apply(
         size: The size of the volume.
         config: The configuration of the volume.
         labels: The labels of the volume.
-
+        use_existing: Whether to use an existing volume.
+        is_ephemeral: Whether the volume is ephemeral.
     """
     with rich_utils.safe_status(ux_utils.spinner_message('Creating volume')):
         # Reuse the method for cluster name on cloud to
         # generate the storage name on cloud.
         cloud_obj = registry.CLOUD_REGISTRY.from_str(cloud)
         assert cloud_obj is not None
-        name_uuid = str(uuid.uuid4())[:6]
-        name_on_cloud = common_utils.make_cluster_name_on_cloud(
-            name, max_length=cloud_obj.max_cluster_name_length())
-        name_on_cloud += '-' + name_uuid
+        region, zone = cloud_obj.validate_region_zone(region, zone)
+        if use_existing:
+            name_on_cloud = name
+        else:
+            name_uuid = str(uuid.uuid4())[:6]
+            name_on_cloud = common_utils.make_cluster_name_on_cloud(
+                name, max_length=cloud_obj.max_cluster_name_length())
+            name_on_cloud += '-' + name_uuid
         config = models.VolumeConfig(
             name=name,
             type=volume_type,
@@ -213,8 +245,13 @@ def volume_apply(
                 logger.info(f'Volume {name} already exists.')
                 return
             config = provision.apply_volume(cloud, config)
-            global_user_state.add_volume(name, config,
-                                         status_lib.VolumeStatus.READY)
+            global_user_state.add_volume(
+                name,
+                config,
+                status_lib.VolumeStatus.READY,
+                is_ephemeral,
+            )
+        logger.info(f'Created volume {name} on cloud {cloud}')
 
 
 @contextlib.contextmanager

sky/volumes/server/server.py

@@ -3,12 +3,14 @@
 import fastapi
 
 from sky import clouds
+from sky import exceptions
 from sky import sky_logging
 from sky.server.requests import executor
 from sky.server.requests import payloads
+from sky.server.requests import request_names
 from sky.server.requests import requests as requests_lib
 from sky.utils import registry
-from sky.utils import volume
+from sky.utils import volume as volume_utils
 from sky.volumes.server import core
 
 logger = sky_logging.init_logger(__name__)
@@ -23,11 +25,11 @@ async def volume_list(request: fastapi.Request) -> None:
     auth_user_env_vars_kwargs = {
         'env_vars': auth_user.to_env_vars()
     } if auth_user else {}
-    volume_list_body = payloads.VolumeListBody(**auth_user_env_vars_kwargs)
-    executor.schedule_request(
+    request_body = payloads.RequestBody(**auth_user_env_vars_kwargs)
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='volume_list',
-        request_body=volume_list_body,
+        request_name=request_names.RequestName.VOLUME_LIST,
+        request_body=request_body,
         func=core.volume_list,
         schedule_type=requests_lib.ScheduleType.SHORT,
     )
@@ -37,15 +39,41 @@ async def volume_list(request: fastapi.Request) -> None:
 async def volume_delete(request: fastapi.Request,
                         volume_delete_body: payloads.VolumeDeleteBody) -> None:
     """Deletes a volume."""
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='volume_delete',
+        request_name=request_names.RequestName.VOLUME_DELETE,
         request_body=volume_delete_body,
         func=core.volume_delete,
         schedule_type=requests_lib.ScheduleType.LONG,
     )
 
 
+@router.post('/validate')
+async def volume_validate(
+        _: fastapi.Request,
+        volume_validate_body: payloads.VolumeValidateBody) -> None:
+    """Validates a volume."""
+    # pylint: disable=import-outside-toplevel
+    from sky.volumes import volume as volume_lib
+
+    try:
+        volume_config = {
+            'name': volume_validate_body.name,
+            'type': volume_validate_body.volume_type,
+            'infra': volume_validate_body.infra,
+            'size': volume_validate_body.size,
+            'labels': volume_validate_body.labels,
+            'config': volume_validate_body.config,
+            'use_existing': volume_validate_body.use_existing,
+        }
+        volume = volume_lib.Volume.from_yaml_config(volume_config)
+        volume.validate()
+    except Exception as e:
+        requests_lib.set_exception_stacktrace(e)
+        raise fastapi.HTTPException(status_code=400,
+                                    detail=exceptions.serialize_exception(e))
+
+
 @router.post('/apply')
 async def volume_apply(request: fastapi.Request,
                        volume_apply_body: payloads.VolumeApplyBody) -> None:
@@ -53,9 +81,12 @@ async def volume_apply(request: fastapi.Request,
     volume_cloud = volume_apply_body.cloud
     volume_type = volume_apply_body.volume_type
     volume_config = volume_apply_body.config
+    if volume_config is None:
+        volume_config = {}
+    volume_config['use_existing'] = volume_apply_body.use_existing
 
     supported_volume_types = [
-        volume_type.value for volume_type in volume.VolumeType
+        volume_type.value for volume_type in volume_utils.VolumeType
     ]
     if volume_type not in supported_volume_types:
         raise fastapi.HTTPException(
@@ -64,31 +95,29 @@ async def volume_apply(request: fastapi.Request,
     if cloud is None:
         raise fastapi.HTTPException(status_code=400,
                                     detail=f'Invalid cloud: {volume_cloud}')
-    if volume_type == volume.VolumeType.PVC.value:
+    if volume_type == volume_utils.VolumeType.PVC.value:
         if not cloud.is_same_cloud(clouds.Kubernetes()):
             raise fastapi.HTTPException(
                 status_code=400,
                 detail='PVC storage is only supported on Kubernetes')
         supported_access_modes = [
-            access_mode.value for access_mode in volume.VolumeAccessMode
+            access_mode.value for access_mode in volume_utils.VolumeAccessMode
         ]
-        if volume_config is None:
-            volume_config = {}
         access_mode = volume_config.get('access_mode')
         if access_mode is None:
-            volume_config[
-                'access_mode'] = volume.VolumeAccessMode.READ_WRITE_ONCE.value
+            volume_config['access_mode'] = (
+                volume_utils.VolumeAccessMode.READ_WRITE_ONCE.value)
         elif access_mode not in supported_access_modes:
             raise fastapi.HTTPException(
                 status_code=400, detail=f'Invalid access mode: {access_mode}')
-    elif volume_type == volume.VolumeType.RUNPOD_NETWORK_VOLUME.value:
+    elif volume_type == volume_utils.VolumeType.RUNPOD_NETWORK_VOLUME.value:
         if not cloud.is_same_cloud(clouds.RunPod()):
             raise fastapi.HTTPException(
                 status_code=400,
                 detail='Runpod network volume is only supported on Runpod')
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='volume_apply',
+        request_name=request_names.RequestName.VOLUME_APPLY,
         request_body=volume_apply_body,
         func=core.volume_apply,
         schedule_type=requests_lib.ScheduleType.LONG,