skypilot-nightly 1.0.0.dev20250502__py3-none-any.whl → 1.0.0.dev20251203__py3-none-any.whl

sky/provision/volume.py

@@ -0,0 +1,164 @@
+"""Volume functions for provisioning and deleting ephemeral volumes."""
+
+import copy
+from typing import Any, Dict, Optional
+
+from sky import clouds
+from sky import global_user_state
+from sky import models
+from sky import sky_logging
+from sky.provision import common as provision_common
+from sky.provision import constants as provision_constants
+from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.utils import volume as volume_utils
+from sky.volumes import volume as volume_lib
+from sky.volumes.server import core as volume_server_core
+
+logger = sky_logging.init_logger(__name__)
+
+
+def _resolve_volume_type(cloud: clouds.Cloud,
+                         volume_type: Optional[str]) -> str:
+    if not volume_type:
+        volume_types = None
+        for cloud_key, vol_types in volume_lib.CLOUD_TO_VOLUME_TYPE.items():
+            if cloud.is_same_cloud(cloud_key):
+                volume_types = vol_types
+                break
+        if volume_types is None:
+            raise ValueError(f'No default volume type found for cloud {cloud}')
+        if len(volume_types) != 1:
+            raise ValueError(
+                f'Found multiple volume types for cloud {cloud}: {volume_types}'
+            )
+        return volume_types[0].value
+    supported_volume_types = [
+        volume_type.value for volume_type in volume_utils.VolumeType
+    ]
+    volume_type = volume_type.lower()
+    if volume_type not in supported_volume_types:
+        raise ValueError(
+            f'Invalid volume type: {volume_type} for cloud {cloud}')
+    return volume_type
+
+
+def _resolve_pvc_volume_config(cloud: clouds.Cloud,
+                               config: provision_common.ProvisionConfig,
+                               volume_config: Dict[str, Any]) -> Dict[str, Any]:
+    provider_config = config.provider_config
+    if not cloud.is_same_cloud(clouds.Kubernetes()):
+        raise ValueError(
+            f'PVC volume type is only supported on Kubernetes not on {cloud}')
+    supported_access_modes = [
+        access_mode.value for access_mode in volume_utils.VolumeAccessMode
+    ]
+    access_mode = volume_config.get('access_mode')
+    if access_mode is None:
+        access_mode = volume_utils.VolumeAccessMode.READ_WRITE_ONCE.value
+        volume_config['access_mode'] = access_mode
+    elif access_mode not in supported_access_modes:
+        raise ValueError(f'Invalid access mode: {access_mode} for PVC')
+    if (access_mode == volume_utils.VolumeAccessMode.READ_WRITE_ONCE.value and
+            config.count > 1):
+        raise ValueError(
+            'Access mode ReadWriteOnce is not supported for multi-node'
+            ' clusters.')
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
+    volume_config['namespace'] = namespace
+    return volume_config
+
+
+def _create_ephemeral_volume(
+    cloud: clouds.Cloud, region: str, cluster_name_on_cloud: str,
+    config: provision_common.ProvisionConfig,
+    volume_mount: volume_utils.VolumeMount
+) -> Optional[volume_utils.VolumeInfo]:
+    provider_name = repr(cloud)
+    path = volume_mount.path
+    volume_config = volume_mount.volume_config
+    volume_type = _resolve_volume_type(cloud, volume_config.type)
+    labels = volume_config.labels
+    if volume_type == volume_utils.VolumeType.PVC.value:
+        internal_volume_config = _resolve_pvc_volume_config(
+            cloud, config, volume_config.config)
+        if labels:
+            for key, value in labels.items():
+                valid, err_msg = cloud.is_label_valid(key, value)
+                if not valid:
+                    raise ValueError(f'{err_msg}')
+        else:
+            labels = {}
+        labels.update({
+            provision_constants.TAG_SKYPILOT_CLUSTER_NAME: cluster_name_on_cloud
+        })
+    else:
+        logger.warning(f'Skipping unsupported ephemeral volume type: '
+                       f'{volume_type} for cloud {cloud}.')
+        return None
+    volume_name = volume_config.name
+    volume_server_core.volume_apply(
+        name=volume_name,
+        volume_type=volume_type,
+        cloud=provider_name,
+        region=region,
+        zone=None,
+        size=volume_config.size,
+        config=internal_volume_config,
+        labels=labels,
+        is_ephemeral=True,
+    )
+    volume = global_user_state.get_volume_by_name(volume_name)
+    if volume is None:
+        raise ValueError(f'Failed to get record for volume: {volume_name}')
+    assert 'handle' in volume, 'Volume handle is None.'
+    volume_config: models.VolumeConfig = volume['handle']
+    volume_info = volume_utils.VolumeInfo(
+        name=volume_name,
+        path=path,
+        volume_name_on_cloud=volume_config.name_on_cloud,
+        volume_id_on_cloud=volume_config.id_on_cloud,
+    )
+    return volume_info
+
+
+def provision_ephemeral_volumes(
+    cloud: clouds.Cloud,
+    region: str,
+    cluster_name_on_cloud: str,
+    config: provision_common.ProvisionConfig,
+) -> None:
+    """Provision ephemeral volumes for a cluster."""
+    provider_config = config.provider_config
+    ephemeral_volume_mounts = provider_config.get('ephemeral_volume_specs')
+    if not ephemeral_volume_mounts:
+        return
+    volume_infos = []
+    try:
+        for ephemeral_volume_mount in ephemeral_volume_mounts:
+            mount_copy = copy.deepcopy(ephemeral_volume_mount)
+            volume_mount = volume_utils.VolumeMount.from_yaml_config(mount_copy)
+            volume_info = _create_ephemeral_volume(cloud, region,
+                                                   cluster_name_on_cloud,
+                                                   config, volume_mount)
+            if volume_info is None:
+                continue
+            volume_infos.append(volume_info)
+        provider_config['ephemeral_volume_infos'] = volume_infos
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logger.error(f'Failed to provision ephemeral volumes: {e}')
+        raise e
+
+
+def delete_ephemeral_volumes(provider_config: Dict[str, Any],) -> None:
+    """Provision ephemeral volumes for a cluster."""
+    ephemeral_volume_mounts = provider_config.get('ephemeral_volume_specs')
+    if not ephemeral_volume_mounts:
+        return
+    ephemeral_volume_names = []
+    for ephemeral_volume_mount in ephemeral_volume_mounts:
+        mount_copy = copy.deepcopy(ephemeral_volume_mount)
+        volume_mount = volume_utils.VolumeMount.from_yaml_config(mount_copy)
+        volume_name = volume_mount.volume_config.name
+        ephemeral_volume_names.append(volume_name)
+    volume_server_core.volume_delete(names=ephemeral_volume_names,
+                                     ignore_not_found=True)

sky/provision/vsphere/common/ssl_helper.py

@@ -30,5 +30,5 @@ def get_unverified_session():
     """
     session = requests.session()
     session.verify = False
-    requests.packages.urllib3.disable_warnings()
+    requests.packages.urllib3.disable_warnings()  # type: ignore[attr-defined]
     return session

sky/provision/vsphere/common/vapiconnect.py

@@ -89,5 +89,6 @@ def create_unverified_session(session, suppress_warning=True):
     session.verify = False
     if suppress_warning:
         # Suppress unverified https request warnings
-        requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+        requests.packages.urllib3.disable_warnings(  # type: ignore
+            InsecureRequestWarning)
     return session

sky/provision/vsphere/common/vim_utils.py

@@ -4,19 +4,19 @@
 import re
 import subprocess
 import time
-from typing import List
+from typing import List, Union
 
 from sky import sky_logging
 from sky.adaptors import vsphere as vsphere_adaptor
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    get_accelerators_from_csv)
+from sky.catalog.data_fetchers.fetch_vsphere import get_accelerators_from_csv
 
 logger = sky_logging.init_logger(__name__)
 DISPLAY_CONTROLLER_CLASS_ID_PREFIXES = ['03']
 VMWARE_VIRTUAL_DISPLAY_CONTROLLER_IDS = ['0000:00:0f.0']
 
 
-def get_objs_by_names(content, vimtype: type, names: List[str]):
+def get_objs_by_names(content, vimtype: Union[type, List[type]],
+                      names: List[str]):
     """    Get the vsphere managed object associated with a given text name
     """
     # Create a set for the names for faster lookups

sky/provision/vsphere/instance.py

@@ -1,12 +1,12 @@
 """Vsphere instance provisioning."""
 import json
 import typing
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import vsphere as vsphere_adaptor
-from sky.clouds.service_catalog.common import get_catalog_path
+from sky.catalog.common import get_catalog_path
 from sky.provision import common
 from sky.provision.vsphere import vsphere_utils
 from sky.provision.vsphere.common import custom_script as custom_script_lib
@@ -30,9 +30,10 @@ HEAD_NODE_VALUE = '1'
 WORKER_NODE_VALUE = '0'
 
 
-def run_instances(region: str, cluster_name: str,
+def run_instances(region: str, cluster_name: str, cluster_name_on_cloud: str,
                   config: common.ProvisionConfig) -> common.ProvisionRecord:
     """See sky/provision/__init__.py"""
+    del cluster_name  # unused
     logger.info('New provision of Vsphere: run_instances().')
 
     resumed_instance_ids: List[str] = []
@@ -40,7 +41,7 @@ def run_instances(region: str, cluster_name: str,
     vc_object = _get_vc_object(region)
     vc_object.connect()
 
-    exist_instances = _get_filtered_instance(vc_object, cluster_name,
+    exist_instances = _get_filtered_instance(vc_object, cluster_name_on_cloud,
                                              config.provider_config)
     head_instance_id = _get_head_instance_id(exist_instances)
 
@@ -89,8 +90,8 @@ def run_instances(region: str, cluster_name: str,
             config, region, vc_object)
         # TODO: update logic for multi-node creation
         for _ in range(to_start_num):
-            created_instance_uuid = _create_instances(cluster_name, config,
-                                                      region, vc_object,
+            created_instance_uuid = _create_instances(cluster_name_on_cloud,
+                                                      config, region, vc_object,
                                                       vsphere_cluster_name)
             created_instance_ids.append(created_instance_uuid)
         if head_instance_id is None:
@@ -104,7 +105,7 @@ def run_instances(region: str, cluster_name: str,
         provider_name='vsphere',
         region=region,
         zone=vsphere_cluster_name,
-        cluster_name=cluster_name,
+        cluster_name=cluster_name_on_cloud,
         head_instance_id=head_instance_id,
         resumed_instance_ids=resumed_instance_ids,
         created_instance_ids=created_instance_ids,
@@ -393,11 +394,14 @@ def _get_cluster_name_filter(cluster_name_on_cloud):
 
 
 def query_instances(
+    cluster_name: str,
     cluster_name_on_cloud: str,
     provider_config: Optional[Dict[str, Any]] = None,
     non_terminated_only: bool = True,
-) -> Dict[str, Optional[status_lib.ClusterStatus]]:
+    retry_if_missing: bool = False,
+) -> Dict[str, Tuple[Optional['status_lib.ClusterStatus'], Optional[str]]]:
     """See sky/provision/__init__.py"""
+    del cluster_name, retry_if_missing  # unused
     logger.info('New provision of Vsphere: query_instances().')
     assert provider_config is not None, cluster_name_on_cloud
     region = provider_config['region']
@@ -413,12 +417,13 @@ def query_instances(
         'suspended': None,
     }
 
-    status = {}
+    status: Dict[str, Tuple[Optional['status_lib.ClusterStatus'],
+                            Optional[str]]] = {}
     for inst in instances:
         stat = status_map[inst.runtime.powerState]
         if non_terminated_only and stat is None:
             continue
-        status[inst.summary.config.instanceUuid] = stat
+        status[inst.summary.config.instanceUuid] = (stat, None)
     vc_object.disconnect()
     return status
 

sky/provision/vsphere/vsphere_utils.py

@@ -3,25 +3,19 @@
 import http.cookies as http_cookies
 import os
 import ssl
-import typing
 from typing import Any, Dict, List, Optional
 
 from sky import exceptions
 from sky import sky_logging
-from sky.adaptors import common as adaptors_common
 from sky.adaptors import vsphere as vsphere_adaptor
-from sky.clouds.service_catalog import vsphere_catalog
-from sky.clouds.service_catalog.common import get_catalog_path
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_accelerators_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_hosts_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_images_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
+from sky.catalog import vsphere_catalog
+from sky.catalog.common import get_catalog_path
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_accelerators_csv
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_hosts_csv
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_images_csv
+from sky.catalog.data_fetchers.fetch_vsphere import (
     initialize_instance_image_mapping_csv)
-from sky.clouds.service_catalog.data_fetchers.fetch_vsphere import (
-    initialize_vms_csv)
+from sky.catalog.data_fetchers.fetch_vsphere import initialize_vms_csv
 from sky.provision.vsphere.common import vim_utils
 from sky.provision.vsphere.common.cls_api_client import ClsApiClient
 from sky.provision.vsphere.common.cls_api_helper import ClsApiHelper
@@ -32,11 +26,7 @@ from sky.provision.vsphere.common.vim_utils import create_spec_with_script
 from sky.provision.vsphere.common.vim_utils import poweron_vm
 from sky.provision.vsphere.common.vim_utils import wait_for_tasks
 from sky.provision.vsphere.common.vim_utils import wait_internal_ip_ready
-
-if typing.TYPE_CHECKING:
-    import yaml
-else:
-    yaml = adaptors_common.LazyImport('yaml')
+from sky.utils import yaml_utils
 
 logger = sky_logging.init_logger(__name__)
 
@@ -272,6 +262,10 @@ class VsphereClient:
 
     def get_pbm_manager(self):
         self.connect()
+        if self.servicemanager is None:
+            raise VsphereError('Failed to connect to vSphere.')
+        if self.servicemanager.si is None:
+            raise VsphereError('Failed to connect to vSphere.')
         pbm_si, pm_content = self._create_pbm_connection(  # pylint: disable=unused-variable
             self.servicemanager.si._stub)  # pylint: disable=protected-access
         pm = pm_content.profileManager
@@ -327,7 +321,7 @@ def get_vsphere_credentials(name=None):
     assert os.path.exists(
         credential_path), f'Missing credential file at {credential_path}.'
     with open(credential_path, 'r', encoding='utf-8') as file:
-        credential = yaml.safe_load(file)
+        credential = yaml_utils.safe_load(file)
         vcenters = credential['vcenters']
         if name is None:
             return vcenters
@@ -370,6 +364,8 @@ def initialize_vsphere_data():
         vcenter_name = vcenter['name']
         vc_object.connect()
         vc_servicemanager = vc_object.servicemanager
+        if vc_servicemanager is None or vc_servicemanager.content is None:
+            raise VsphereError('Failed to connect to vSphere.')
         vc_content = vc_servicemanager.content
 
         cluster_name_dicts = vc_object.clusters
@@ -380,4 +376,5 @@ def initialize_vsphere_data():
         initialize_images_csv(images_csv_path, vc_object, vcenter_name)
         initialize_instance_image_mapping_csv(vms_csv_path, images_csv_path,
                                               instance_image_mapping_csv_path)
-        vc_object.servicemanager.disconnect()
+        if vc_object.servicemanager is not None:
+            vc_object.servicemanager.disconnect()