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

sky/clouds/utils/scp_utils.py

@@ -3,7 +3,6 @@
 This module contains a set of rest api functions accessing SCP Open-API.
 """
 import base64
-import datetime
 from functools import wraps
 import hashlib
 import hmac
@@ -171,15 +170,18 @@ class SCPClient:
         self.secret_key = self._credentials['secret_key']
         self.project_id = self._credentials['project_id']
         self.client_type = 'OpenApi'
-        self.timestamp = ''
-        self.signature = ''
-
-        self.headers = {
-            'X-Cmp-AccessKey': f'{self.access_key}',
-            'X-Cmp-ClientType': f'{self.client_type}',
-            'X-Cmp-ProjectId': f'{self.project_id}',
-            'X-Cmp-Timestamp': f'{self.timestamp}',
-            'X-Cmp-Signature': f'{self.signature}'
+
+    def _signed_headers(self, method: str, url: str) -> dict:
+        timestamp = str(int(time.time() * 1000))
+        signature = self.get_signature(method=method,
+                                       url=url,
+                                       timestamp=timestamp)
+        return {
+            'X-Cmp-AccessKey': self.access_key,
+            'X-Cmp-ClientType': self.client_type,
+            'X-Cmp-ProjectId': self.project_id,
+            'X-Cmp-Timestamp': timestamp,
+            'X-Cmp-Signature': signature,
         }
 
     def create_instance(self, instance_config):
@@ -190,10 +192,8 @@ class SCPClient:
     @_retry
     def _get(self, url, contents_key='contents'):
         method = 'GET'
-        self.set_timestamp()
-        self.set_signature(url=url, method=method)
-
-        response = requests.get(url, headers=self.headers)
+        headers = self._signed_headers(method, url)
+        response = requests.get(url, headers=headers)
         raise_scp_error(response)
         if contents_key is not None:
             return response.json().get(contents_key, [])
@@ -203,26 +203,19 @@ class SCPClient:
     @_retry
     def _post(self, url, request_body):
         method = 'POST'
-        self.set_timestamp()
-        self.set_signature(url=url, method=method)
-
-        response = requests.post(url, json=request_body, headers=self.headers)
-
+        headers = self._signed_headers(method, url)
+        response = requests.post(url, json=request_body, headers=headers)
         raise_scp_error(response)
         return response.json()
 
     @_retry
     def _delete(self, url, request_body=None):
         method = 'DELETE'
-        self.set_timestamp()
-        self.set_signature(url=url, method=method)
+        headers = self._signed_headers(method, url)
         if request_body:
-            response = requests.delete(url,
-                                       json=request_body,
-                                       headers=self.headers)
-
+            response = requests.delete(url, json=request_body, headers=headers)
         else:
-            response = requests.delete(url, headers=self.headers)
+            response = requests.delete(url, headers=headers)
         raise_scp_error(response)
         return response.json()
 
@@ -252,12 +245,22 @@ class SCPClient:
         return True
 
     def add_security_group_rule(self, sg_id, direction,
-                                ports: Optional[List[str]]):
+                                ports: Optional[List[str]],
+                                cnt: Optional[int]) -> None:
         if ports is None:
             if direction == 'IN':
-                ports = ['22']
+                if cnt == 1:
+                    ports = ['22']
+                else:
+                    ports = ['22', '6380', '8076', '10001', '11001-11200']
             else:
-                ports = ['21', '22', '80', '443']
+                if cnt == 1:
+                    ports = ['21', '22', '80', '443']
+                else:
+                    ports = [
+                        '21', '22', '80', '443', '6380', '8076', '10001',
+                        '11001-11200'
+                    ]
         services = []
         for port in ports:
             services.append({'serviceType': 'TCP', 'serviceValue': port})
@@ -273,7 +276,9 @@ class SCPClient:
                 target_address: ['0.0.0.0/0'],
                 'ruleDescription': 'sky security group rule'
             }
-            return self._post(url, request_body)
+            self._post(url, request_body)
+        else:
+            return None
 
     def _firewall_rule_not_exist(self, firewall_id, internal_ip, direction,
                                  ports):
@@ -293,12 +298,22 @@ class SCPClient:
                 return False
         return True
 
-    def add_firewall_rule(self, firewall_id, internal_ip, direction, ports):
+    def add_firewall_rule(self, firewall_id, internal_ip, direction,
+                          ports: Optional[List[str]], cnt: Optional[int]):
         if ports is None:
             if direction == 'IN':
-                ports = ['22']
+                if cnt == 1:
+                    ports = ['22']
+                else:
+                    ports = ['22', '6380', '8076', '10001', '11001-11200']
             else:
-                ports = ['21', '22', '80', '443']
+                if cnt == 1:
+                    ports = ['21', '22', '80', '443']
+                else:
+                    ports = [
+                        '21', '22', '80', '443', '6380', '8076', '10001',
+                        '11001-11200'
+                    ]
         services = []
         for port in ports:
             services.append({'serviceType': 'TCP', 'serviceValue': port})
@@ -322,6 +337,8 @@ class SCPClient:
                 'ruleDescription': 'sky firewall rule'
             }
             return self._post(url, request_body)
+        else:
+            return None
 
     def terminate_instance(self, instance_id):
         url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}'
@@ -334,12 +351,19 @@ class SCPClient:
 
     def get_catalog(self) -> Dict[str, Any]:
         """List offered instances and their availability."""
-        response = requests.get(f'{API_ENDPOINT}/instance-types',
-                                headers=self.headers)
+        url = f'{API_ENDPOINT}/instance-types'
+        headers = self._signed_headers('GET', url)
+        response = requests.get(url, headers=headers)
         raise_scp_error(response)
         return response.json().get('data', [])
 
-    def get_signature(self, method: str, url: str) -> str:
+    def get_signature(self,
+                      method: str,
+                      url: str,
+                      timestamp: Optional[str] = None) -> str:
+        if timestamp is None:
+            timestamp = str(int(time.time() * 1000))
+
         url_info = parse.urlsplit(url)
         url = (f'{url_info.scheme}://{url_info.netloc}'
                f'{parse.quote(url_info.path)}')
@@ -349,7 +373,7 @@ class SCPClient:
                     parse.parse_qs(url_info.query).items()))
             url = f'{url}?{parse.urlencode(enc_params)}'
 
-        message = method + url + self.timestamp \
+        message = method + url + timestamp \
                   + self.access_key + self.project_id + self.client_type
         message = bytes(message, 'utf-8')
         secret = bytes(self.secret_key, 'utf-8')
@@ -360,19 +384,6 @@ class SCPClient:
 
         return str(signature)
 
-    def set_timestamp(self) -> None:
-        self.timestamp = str(
-            int(
-                round(
-                    datetime.datetime.timestamp(datetime.datetime.now() -
-                                                datetime.timedelta(minutes=1)) *
-                    1000)))
-        self.headers['X-Cmp-Timestamp'] = self.timestamp
-
-    def set_signature(self, method: str, url: str) -> None:
-        self.signature = self.get_signature(url=url, method=method)
-        self.headers['X-Cmp-Signature'] = self.signature
-
     def get_nic(self, instance_id) -> List[dict]:
         url = f'{API_ENDPOINT}/virtual-server/v2/virtual-servers/{instance_id}/nics'  # pylint: disable=line-too-long
         return self._get(url)

sky/clouds/vast.py

@@ -1,10 +1,13 @@
 """ Vast Cloud. """
 
+import os
 import typing
 from typing import Dict, Iterator, List, Optional, Tuple, Union
 
 from sky import catalog
 from sky import clouds
+from sky import skypilot_config
+from sky.adaptors import common
 from sky.utils import registry
 from sky.utils import resources_utils
 
@@ -12,6 +15,8 @@ if typing.TYPE_CHECKING:
     from sky import resources as resources_lib
     from sky.utils import volume as volume_lib
 
+_CREDENTIAL_PATH = '~/.config/vastai/vast_api_key'
+
 
 @registry.CLOUD_REGISTRY.register
 class Vast(clouds.Cloud):
@@ -51,7 +56,9 @@ class Vast(clouds.Cloud):
 
     @classmethod
     def _unsupported_features_for_resources(
-        cls, resources: 'resources_lib.Resources'
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
     ) -> Dict[clouds.CloudImplementationFeatures, str]:
         """The features not supported based on the resources provided.
 
@@ -70,10 +77,15 @@ class Vast(clouds.Cloud):
         return cls._MAX_CLUSTER_NAME_LEN_LIMIT
 
     @classmethod
-    def regions_with_offering(cls, instance_type: str,
-                              accelerators: Optional[Dict[str, int]],
-                              use_spot: bool, region: Optional[str],
-                              zone: Optional[str]) -> List[clouds.Region]:
+    def regions_with_offering(
+        cls,
+        instance_type: str,
+        accelerators: Optional[Dict[str, int]],
+        use_spot: bool,
+        region: Optional[str],
+        zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
+    ) -> List[clouds.Region]:
         assert zone is None, 'Vast does not support zones.'
         del accelerators, zone  # unused
         regions = catalog.get_region_zones_for_instance_type(
@@ -185,11 +197,20 @@ class Vast(clouds.Cloud):
         else:
             image_id = resources.image_id[resources.region]
 
+        secure_only = skypilot_config.get_effective_region_config(
+            cloud='vast',
+            region=region.name,
+            keys=('secure_only',),
+            default_value=False,
+            override_configs=resources.cluster_config_overrides,
+        )
+
         return {
             'instance_type': resources.instance_type,
             'custom_resources': custom_resources,
             'region': region.name,
             'image_id': image_id,
+            'secure_only': secure_only,
         }
 
     def _get_feasible_launchable_resources(
@@ -253,32 +274,27 @@ class Vast(clouds.Cloud):
     def _check_compute_credentials(
             cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has valid credentials for
-        Vast's compute service. """
-        try:
-            import vastai_sdk as _vast  # pylint: disable=import-outside-toplevel
-            vast = _vast.VastAI()
-
-            # We only support file pased credential passing
-            if vast.creds_source != 'FILE':
-                return False, (
-                    'error \n'  # First line is indented by 4 spaces
-                    '    Credentials can be set up by running: \n'
-                    '        $ pip install vastai\n'
-                    '        $ mkdir -p ~/.config/vastai\n'
-                    '        $ echo [key] > ~/.config/vastai/vast_api_key\n'
-                    '    For more information, see https://skypilot.readthedocs.io/en/latest/getting-started/installation.html#vast'  # pylint: disable=line-too-long
-                )
+        Vast's compute service."""
+
+        dependency_error_msg = ('Failed to import vast. '
+                                'To install, run: pip install skypilot[vast]')
+        if not common.can_import_modules(['vastai_sdk']):
+            return False, dependency_error_msg
 
-            return True, None
+        if not os.path.exists(os.path.expanduser(_CREDENTIAL_PATH)):
+            return False, (
+                'error \n'  # First line is indented by 4 spaces
+                '    Credentials can be set up by running: \n'
+                '        $ pip install vastai\n'
+                '        $ mkdir -p ~/.config/vastai\n'
+                f'        $ echo [key] > {_CREDENTIAL_PATH}\n'
+                '    For more information, see https://skypilot.readthedocs.io/en/latest/getting-started/installation.html#vast'  # pylint: disable=line-too-long
+            )
 
-        except ImportError:
-            return False, ('Failed to import vast. '
-                           'To install, run: pip install skypilot[vast]')
+        return True, None
 
     def get_credential_file_mounts(self) -> Dict[str, str]:
-        return {
-            '~/.config/vastai/vast_api_key': '~/.config/vastai/vast_api_key'
-        }
+        return {f'{_CREDENTIAL_PATH}': f'{_CREDENTIAL_PATH}'}
 
     @classmethod
     def get_user_identities(cls) -> Optional[List[List[str]]]:

sky/clouds/vsphere.py

@@ -1,5 +1,4 @@
 """Vsphere cloud implementation."""
-import subprocess
 import typing
 from typing import Dict, Iterator, List, Optional, Tuple, Union
 
@@ -9,7 +8,6 @@ from sky.adaptors import common as adaptors_common
 from sky.provision.vsphere import vsphere_utils
 from sky.provision.vsphere.vsphere_utils import get_vsphere_credentials
 from sky.provision.vsphere.vsphere_utils import initialize_vsphere_data
-from sky.utils import common_utils
 from sky.utils import registry
 from sky.utils import resources_utils
 
@@ -75,7 +73,9 @@ class Vsphere(clouds.Cloud):
 
     @classmethod
     def _unsupported_features_for_resources(
-        cls, resources: 'resources_lib.Resources'
+        cls,
+        resources: 'resources_lib.Resources',
+        region: Optional[str] = None,
     ) -> Dict[clouds.CloudImplementationFeatures, str]:
         features = cls._CLOUD_UNSUPPORTED_FEATURES
         return features
@@ -92,6 +92,7 @@ class Vsphere(clouds.Cloud):
         use_spot: bool,
         region: Optional[str],
         zone: Optional[str],
+        resources: Optional['resources_lib.Resources'] = None,
     ) -> List[clouds.Region]:
         del accelerators, zone  # unused
         regions = catalog.get_region_zones_for_instance_type(
@@ -278,19 +279,16 @@ class Vsphere(clouds.Cloud):
             cls) -> Tuple[bool, Optional[Union[str, Dict[str, str]]]]:
         """Checks if the user has access credentials to
         vSphere's compute service."""
-
-        try:
-            # pylint: disable=import-outside-toplevel,unused-import
-            # Check pyVmomi installation.
-            import pyVmomi
-        except (ImportError, subprocess.CalledProcessError) as e:
-            return False, (
-                'vSphere dependencies are not installed. '
-                'Run the following commands:'
-                f'\n{cls._INDENT_PREFIX}  $ pip install skypilot[vSphere]'
-                f'\n{cls._INDENT_PREFIX}Credentials may also need to be set. '
-                'For more details. See https://docs.skypilot.co/en/latest/getting-started/installation.html#vmware-vsphere'  # pylint: disable=line-too-long
-                f'{common_utils.format_exception(e, use_bracket=True)}')
+        dependency_error_msg = (
+            'vSphere dependencies are not installed. '
+            'Run the following commands:'
+            f'\n{cls._INDENT_PREFIX}  $ pip install skypilot[vSphere]'
+            f'\n{cls._INDENT_PREFIX}Credentials may also need to be set. '
+            'For more details. See https://docs.skypilot.co/en/latest/getting-started/installation.html#vmware-vsphere'  # pylint: disable=line-too-long
+        )
+        # Check pyVmomi installation.
+        if not adaptors_common.can_import_modules(['pyVmomi']):
+            return False, dependency_error_msg
 
         required_keys = ['name', 'username', 'password', 'clusters']
         skip_key = 'skip_verification'