skypilot-nightly 1.0.0.dev20250406__tar.gz → 1.0.0.dev20250408__tar.gz

{skypilot_nightly-1.0.0.dev20250406/skypilot_nightly.egg-info → skypilot_nightly-1.0.0.dev20250408}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250406
+Version: 1.0.0.dev20250408
 Summary: SkyPilot: An intercloud broker for the clouds
 Author: SkyPilot Team
 License: Apache 2.0

{skypilot_nightly-1.0.0.dev20250406 → skypilot_nightly-1.0.0.dev20250408}/sky/__init__.py

@@ -5,7 +5,7 @@ from typing import Optional
 import urllib.request
 
 # Replaced with the current commit when building the wheels.
-_SKYPILOT_COMMIT_SHA = '5025c819176d48aa8643fe9ec058158ce2bece9a'
+_SKYPILOT_COMMIT_SHA = 'e0674be528e87191ade88961c44c6449d01232fa'
 
 
 def _get_git_commit():
@@ -35,7 +35,7 @@ def _get_git_commit():
 
 
 __commit__ = _get_git_commit()
-__version__ = '1.0.0.dev20250406'
+__version__ = '1.0.0.dev20250408'
 __root_dir__ = os.path.dirname(os.path.abspath(__file__))
 
 

{skypilot_nightly-1.0.0.dev20250406 → skypilot_nightly-1.0.0.dev20250408}/sky/backends/cloud_vm_ray_backend.py

@@ -655,12 +655,9 @@ class RayCodeGen:
         rclone_flush_script = {rclone_flush_script!r}
         if run_fn is not None:
             script = run_fn({gang_scheduling_id}, gang_scheduling_id_to_ip)
-        if script is not None:
-            script += rclone_flush_script
-        else:
-            script = rclone_flush_script
 
         if script is not None:
+            script += rclone_flush_script
             sky_env_vars_dict['{constants.SKYPILOT_NUM_GPUS_PER_NODE}'] = {int(math.ceil(num_gpus))!r}
             # Backward compatibility: Environment starting with `SKY_` is
             # deprecated. Remove it in v0.9.0.

{skypilot_nightly-1.0.0.dev20250406 → skypilot_nightly-1.0.0.dev20250408}/sky/clouds/lambda_cloud.py

@@ -43,7 +43,6 @@ class Lambda(clouds.Cloud):
         clouds.CloudImplementationFeatures.SPOT_INSTANCE: f'Spot instances are not supported in {_REPR}.',
         clouds.CloudImplementationFeatures.IMAGE_ID: f'Specifying image ID is not supported in {_REPR}.',
         clouds.CloudImplementationFeatures.CUSTOM_DISK_TIER: f'Custom disk tiers are not supported in {_REPR}.',
-        clouds.CloudImplementationFeatures.OPEN_PORTS: f'Opening ports is currently not supported on {_REPR}.',
         clouds.CloudImplementationFeatures.HOST_CONTROLLERS: f'Host controllers are not supported in {_REPR}.',
     }
 

{skypilot_nightly-1.0.0.dev20250406 → skypilot_nightly-1.0.0.dev20250408}/sky/data/storage_utils.py

@@ -227,6 +227,9 @@ def get_excluded_files(src_dir_path: str) -> List[str]:
     expand_src_dir_path = os.path.expanduser(src_dir_path)
     skyignore_path = os.path.join(expand_src_dir_path,
                                   constants.SKY_IGNORE_FILE)
+    # Fail fast if the source is a file.
+    if os.path.isfile(expand_src_dir_path):
+        raise ValueError(f'{src_dir_path} is a file, not a directory.')
     if os.path.exists(skyignore_path):
         logger.debug(f'  {colorama.Style.DIM}'
                      f'Excluded files to sync to cluster based on '
@@ -267,11 +270,15 @@ def zip_files_and_folders(items: List[str],
                 item = os.path.expanduser(item)
                 if not os.path.isfile(item) and not os.path.isdir(item):
                     raise ValueError(f'{item} does not exist.')
-                excluded_files = set(
-                    [os.path.join(item, f) for f in get_excluded_files(item)])
-                if os.path.isfile(item) and item not in excluded_files:
+                if os.path.isfile(item):
+                    # Add the file to the zip archive even if it matches
+                    # patterns in dot ignore files, as it was explicitly
+                    # specified by user.
                     zipf.write(item)
                 elif os.path.isdir(item):
+                    excluded_files = set([
+                        os.path.join(item, f) for f in get_excluded_files(item)
+                    ])
                     for root, dirs, files in os.walk(item, followlinks=False):
                         # Modify dirs in-place to control os.walk()'s traversal
                         # behavior. This filters out excluded directories BEFORE

{skypilot_nightly-1.0.0.dev20250406 → skypilot_nightly-1.0.0.dev20250408}/sky/provision/lambda_cloud/instance.py

@@ -1,12 +1,13 @@
-"""Lambda instance provisioning."""
+"""Lambda Cloud instance provisioning."""
 
 import time
 from typing import Any, Dict, List, Optional
 
 from sky import sky_logging
 from sky.provision import common
-import sky.provision.lambda_cloud.lambda_utils as lambda_utils
+from sky.provision.lambda_cloud import lambda_utils
 from sky.utils import common_utils
+from sky.utils import resources_utils
 from sky.utils import status_lib
 from sky.utils import ux_utils
 
@@ -248,18 +249,102 @@ def query_instances(
     return statuses
 
 
-def open_ports(
-    cluster_name_on_cloud: str,
-    ports: List[str],
-    provider_config: Optional[Dict[str, Any]] = None,
-) -> None:
-    raise NotImplementedError('open_ports is not supported for Lambda Cloud')
-
-
-def cleanup_ports(
-    cluster_name_on_cloud: str,
-    ports: List[str],
-    provider_config: Optional[Dict[str, Any]] = None,
-) -> None:
-    """See sky/provision/__init__.py"""
+def open_ports(cluster_name_on_cloud: str,
+               ports: List[str],
+               provider_config: Optional[Dict[str, Any]] = None) -> None:
+    """Open firewall ports for Lambda Cloud.
+
+    Args:
+        cluster_name_on_cloud: Cluster name on Lambda Cloud.
+        ports: List of ports to open.
+        provider_config: Lambda Cloud provider config. Contains the API key.
+    """
+    if not ports:
+        return
+
+    # Skip port opening for us-south-1 region where it's not supported
+    region = None
+    if provider_config is not None:
+        region = provider_config.get('region')
+
+    # Skip port opening for us-south-1, as it's not supported by Lambda Cloud
+    # https://cloud.lambda.ai/api/v1/docs#get-/api/v1/firewall-rules
+    if region == 'us-south-1':
+        logger.warning(
+            f'Skipping port opening for cluster {cluster_name_on_cloud} in '
+            f'us-south-1 region, as firewall rules are not supported there.')
+        return
+
+    del provider_config, cluster_name_on_cloud  # No longer needed
+
+    lambda_client = lambda_utils.LambdaCloudClient()
+
+    # Get existing rules to avoid duplicates
+    existing_rules = lambda_client.list_firewall_rules()
+    existing_ports = set()
+    for rule in existing_rules:
+        port_range = rule.get('port_range')
+        if rule.get('protocol') == 'tcp' and port_range is not None:
+            if len(port_range) == 1:
+                # For single ports
+                existing_ports.add(port_range[0])
+            elif len(port_range) == 2:
+                # For port ranges, add all ports in the range
+                existing_ports.update(range(port_range[0], port_range[1] + 1))
+
+    # Convert port strings to a set of individual ports
+    ports_to_open = resources_utils.port_ranges_to_set(ports)
+
+    # Remove ports that are already open
+    ports_to_open = ports_to_open - existing_ports
+
+    # If no ports need to be opened, return early
+    if not ports_to_open:
+        return
+
+    # Convert individual ports to consolidated ranges
+    port_ranges = resources_utils.port_set_to_ranges(ports_to_open)
+
+    # Open port ranges
+    for port_range in port_ranges:
+        if '-' in port_range:
+            # Handle range (e.g., "1000-1010")
+            start, end = map(int, port_range.split('-'))
+            logger.debug(f'Opening port range {port_range}/tcp')
+            try:
+                lambda_client.create_firewall_rule(port_range=[start, end],
+                                                   protocol='tcp')
+            except lambda_utils.LambdaCloudError as e:
+                logger.warning(f'Failed to open port range {port_range}: {e}')
+        else:
+            # Handle single port
+            port = int(port_range)
+            logger.debug(f'Opening port {port}/tcp')
+            try:
+                lambda_client.create_firewall_rule(port_range=[port, port],
+                                                   protocol='tcp')
+            except lambda_utils.LambdaCloudError as e:
+                logger.warning(f'Failed to open port {port}: {e}')
+
+
+def cleanup_ports(cluster_name_on_cloud: str,
+                  ports: List[str],
+                  provider_config: Optional[Dict[str, Any]] = None) -> None:
+    """Skip cleanup of firewall rules.
+
+    Lambda Cloud firewall rules are global to the account, not cluster-specific.
+    We skip cleanup because rules may be used by other clusters.
+
+    TODO(zhwu): the firewall rules may accumulate over time, and we may need
+    to add a way to automatically clean them up.
+
+    Args:
+        cluster_name_on_cloud: Unused.
+        ports: Unused.
+        provider_config: Unused.
+    """
     del cluster_name_on_cloud, ports, provider_config  # Unused.
+
+    # Break the long line by splitting it
+    logger.info('Skipping cleanup of Lambda Cloud firewall rules '
+                'as they are account-wide.')

{skypilot_nightly-1.0.0.dev20250406 → skypilot_nightly-1.0.0.dev20250408}/sky/provision/lambda_cloud/lambda_utils.py

@@ -112,6 +112,8 @@ def _try_request_with_backoff(method: str,
             response = requests.get(url, headers=headers)
         elif method == 'post':
             response = requests.post(url, headers=headers, data=data)
+        elif method == 'put':
+            response = requests.put(url, headers=headers, data=data)
         else:
             raise ValueError(f'Unsupported requests method: {method}')
         # If rate limited, wait and try again
@@ -249,4 +251,86 @@ class LambdaCloudClient:
         response = _try_request_with_backoff('get',
                                              f'{API_ENDPOINT}/instance-types',
                                              headers=self.headers)
+        return response.json().get('data', {})
+
+    def list_firewall_rules(self) -> List[Dict[str, Any]]:
+        """List firewall rules."""
+        response = _try_request_with_backoff('get',
+                                             f'{API_ENDPOINT}/firewall-rules',
+                                             headers=self.headers)
         return response.json().get('data', [])
+
+    def create_firewall_rule(self,
+                             port_range: List[int],
+                             protocol: str = 'tcp',
+                             description: str = '') -> Dict[str, Any]:
+        """Create a firewall rule.
+
+        Args:
+            port_range: Port range as [min_port, max_port]. For a single port,
+              use [port, port].
+            protocol: Protocol ('tcp', 'udp', 'icmp', or 'all').
+            description: Description for the rule.
+
+        Returns:
+            The created firewall rule.
+        """
+        # First, get all existing rules
+        existing_rules = self.list_firewall_rules()
+
+        # Convert existing rules to the format expected by the API
+        rule_list = []
+        for rule in existing_rules:
+            if rule.get('protocol') and rule.get('source_network'):
+                api_rule = {
+                    'protocol': rule.get('protocol'),
+                    'source_network': rule.get('source_network'),
+                    'description': rule.get('description', '')
+                }
+
+                # Add port_range for non-icmp protocols
+                if rule.get('protocol') != 'icmp' and rule.get('port_range'):
+                    api_rule['port_range'] = rule.get('port_range')
+
+                rule_list.append(api_rule)
+
+        # Add our new rule
+        new_rule: Dict[str, Any] = {
+            'protocol': protocol,
+            'source_network': '0.0.0.0/0',  # Allow from any IP address
+            'description': description or
+                           ('SkyPilot auto-generated rule for port '
+                            f'{port_range[0]}-{port_range[1]}/{protocol}')
+        }
+
+        # Add port_range for non-icmp protocols
+        if protocol != 'icmp':
+            new_rule['port_range'] = port_range
+
+        # Check if this rule already exists to avoid duplicates
+        rule_exists = False
+        for rule in rule_list:
+            if (rule.get('protocol') == protocol and
+                    rule.get('source_network') == '0.0.0.0/0'):
+                if protocol != 'icmp':
+                    if rule.get('port_range') == port_range:
+                        rule_exists = True
+                        break
+                else:
+                    rule_exists = True
+                    break
+
+        # Only add the rule if it doesn't already exist
+        if not rule_exists:
+            rule_list.append(new_rule)
+
+        # Create a data structure that matches the API schema
+        data = json.dumps({'data': rule_list})
+
+        response = _try_request_with_backoff(
+            'put',  # Using PUT instead of POST as per API documentation
+            f'{API_ENDPOINT}/firewall-rules',
+            data=data,
+            headers=self.headers,
+        )
+        return response.json().get('data', {})