skypilot-nightly 1.0.0.dev20241109__py3-none-any.whl → 1.0.0.dev20241111__py3-none-any.whl

sky/{skylet/providers/oci/query_helper.py → provision/oci/query_utils.py}

@@ -1,56 +1,75 @@
-"""
-Helper class for some OCI operations methods which needs to be shared/called 
-by multiple places. 
+"""OCI query helper class
 
 History:
- - Hysun He (hysun.he@oracle.com) @ Apr, 2023: Initial implementation
- 
+ - Hysun He (hysun.he@oracle.com) @ Oct.16, 2024: Code here mainly
+   migrated from the old provisioning API.
+ - Hysun He (hysun.he@oracle.com) @ Oct.18, 2024: Enhancement.
+   find_compartment: allow search subtree when find a compartment.
 """
-
 from datetime import datetime
-import logging
+import functools
+from logging import Logger
 import re
 import time
 import traceback
 import typing
 from typing import Optional
 
+from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.adaptors import oci as oci_adaptor
 from sky.clouds.utils import oci_utils
-from sky.skylet.providers.oci import utils
 
 if typing.TYPE_CHECKING:
     import pandas as pd
 else:
     pd = adaptors_common.LazyImport('pandas')
 
-logger = logging.getLogger(__name__)
+logger = sky_logging.init_logger(__name__)
+
+
+def debug_enabled(log: Logger):
+
+    def decorate(f):
+
+        @functools.wraps(f)
+        def wrapper(*args, **kwargs):
+            dt_str = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            log.debug(f'{dt_str} Enter {f}, {args}, {kwargs}')
+            try:
+                return f(*args, **kwargs)
+            finally:
+                log.debug(f'{dt_str} Exit {f}')
+
+        return wrapper
 
+    return decorate
 
-class oci_query_helper:
 
+class QueryHelper:
+    """Helper class for some OCI operations
+    """
     # Call Cloud API to try getting the satisfied nodes.
     @classmethod
-    @utils.debug_enabled(logger=logger)
+    @debug_enabled(logger)
     def query_instances_by_tags(cls, tag_filters, region):
 
-        where_clause_tags = ""
+        where_clause_tags = ''
         for tag_key in tag_filters:
-            if where_clause_tags != "":
-                where_clause_tags += " && "
+            if where_clause_tags != '':
+                where_clause_tags += ' && '
 
             tag_value = tag_filters[tag_key]
-            where_clause_tags += (f"(freeformTags.key = '{tag_key}'"
-                                  f" && freeformTags.value = '{tag_value}')")
+            where_clause_tags += (f'(freeformTags.key = \'{tag_key}\''
+                                  f' && freeformTags.value = \'{tag_value}\')')
 
-        qv_str = (f"query instance resources where {where_clause_tags}"
-                  f" && (lifecycleState != 'TERMINATED'"
-                  f" && lifecycleState != 'TERMINATING')")
+        qv_str = (f'query instance resources where {where_clause_tags}'
+                  f' && (lifecycleState != \'TERMINATED\''
+                  f' && lifecycleState != \'TERMINATING\')')
 
         qv = oci_adaptor.oci.resource_search.models.StructuredSearchDetails(
             query=qv_str,
-            type="Structured",
+            type='Structured',
             matching_context_type=oci_adaptor.oci.resource_search.models.
             SearchDetails.MATCHING_CONTEXT_TYPE_NONE,
         )
@@ -63,44 +82,98 @@ class oci_query_helper:
 
     @classmethod
     def terminate_instances_by_tags(cls, tag_filters, region) -> int:
-        logger.debug(f"Terminate instance by tags: {tag_filters}")
+        logger.debug(f'Terminate instance by tags: {tag_filters}')
         insts = cls.query_instances_by_tags(tag_filters, region)
         fail_count = 0
         for inst in insts:
             inst_id = inst.identifier
-            logger.debug(f"Got instance(to be terminated): {inst_id}")
+            logger.debug(f'Got instance(to be terminated): {inst_id}')
 
             try:
                 oci_adaptor.get_core_client(
                     region,
                     oci_utils.oci_config.get_profile()).terminate_instance(
                         inst_id)
-            except Exception as e:
+            except oci_adaptor.oci.exceptions.ServiceError as e:
                 fail_count += 1
-                logger.error(f"Terminate instance failed: {str(e)}\n: {inst}")
+                logger.error(f'Terminate instance failed: {str(e)}\n: {inst}')
                 traceback.print_exc()
 
         if fail_count == 0:
-            logger.debug(f"Instance teardown result: OK")
+            logger.debug('Instance teardown result: OK')
         else:
-            logger.warn(f"Instance teardown result: {fail_count} failed!")
+            logger.warning(f'Instance teardown result: {fail_count} failed!')
 
         return fail_count
 
     @classmethod
-    @utils.debug_enabled(logger=logger)
+    @debug_enabled(logger)
+    def launch_instance(cls, region, launch_config):
+        """ To create a new instance """
+        return oci_adaptor.get_core_client(
+            region, oci_utils.oci_config.get_profile()).launch_instance(
+                launch_instance_details=launch_config)
+
+    @classmethod
+    @debug_enabled(logger)
+    def start_instance(cls, region, instance_id):
+        """ To start an existing instance """
+        return oci_adaptor.get_core_client(
+            region, oci_utils.oci_config.get_profile()).instance_action(
+                instance_id=instance_id, action='START')
+
+    @classmethod
+    @debug_enabled(logger)
+    def stop_instance(cls, region, instance_id):
+        """ To stop an instance """
+        return oci_adaptor.get_core_client(
+            region, oci_utils.oci_config.get_profile()).instance_action(
+                instance_id=instance_id, action='STOP')
+
+    @classmethod
+    @debug_enabled(logger)
+    def wait_instance_until_status(cls, region, node_id, status):
+        """ To wait a instance becoming the specified state """
+        compute_client = oci_adaptor.get_core_client(
+            region, oci_utils.oci_config.get_profile())
+
+        resp = compute_client.get_instance(instance_id=node_id)
+
+        oci_adaptor.oci.wait_until(
+            compute_client,
+            resp,
+            'lifecycle_state',
+            status,
+        )
+
+    @classmethod
+    def get_instance_primary_vnic(cls, region, inst_info):
+        """ Get the primary vnic infomation of the instance """
+        list_vnic_attachments_response = oci_adaptor.get_core_client(
+            region, oci_utils.oci_config.get_profile()).list_vnic_attachments(
+                availability_domain=inst_info['ad'],
+                compartment_id=inst_info['compartment'],
+                instance_id=inst_info['inst_id'],
+            )
+        vnic = list_vnic_attachments_response.data[0]
+        return oci_adaptor.get_net_client(
+            region, oci_utils.oci_config.get_profile()).get_vnic(
+                vnic_id=vnic.vnic_id).data
+
+    @classmethod
+    @debug_enabled(logger)
     def subscribe_image(cls, compartment_id, listing_id, resource_version,
                         region):
-        if (pd.isna(listing_id) or listing_id.strip() == "None" or
-                listing_id.strip() == "nan"):
+        if (pd.isna(listing_id) or listing_id.strip() == 'None' or
+                listing_id.strip() == 'nan'):
             return
 
         core_client = oci_adaptor.get_core_client(
             region, oci_utils.oci_config.get_profile())
         try:
-            agreements_response = core_client.get_app_catalog_listing_agreements(
+            agreements_resp = core_client.get_app_catalog_listing_agreements(
                 listing_id=listing_id, resource_version=resource_version)
-            agreements = agreements_response.data
+            agreements = agreements_resp.data
 
             core_client.create_app_catalog_subscription(
                 create_app_catalog_subscription_details=oci_adaptor.oci.core.
@@ -113,24 +186,24 @@ class oci_query_helper:
                     oracle_terms_of_use_link,
                     time_retrieved=datetime.strptime(
                         re.sub(
-                            "\d{3}\+\d{2}\:\d{2}",
-                            "Z",
+                            r'\d{3}\+\d{2}\:\d{2}',
+                            'Z',
                             str(agreements.time_retrieved),
                             0,
                         ),
-                        "%Y-%m-%d %H:%M:%S.%fZ",
+                        '%Y-%m-%d %H:%M:%S.%fZ',
                     ),
                     signature=agreements.signature,
                     eula_link=agreements.eula_link,
                 ))
-        except Exception as e:
+        except oci_adaptor.oci.exceptions.ServiceError as e:
             logger.critical(
-                f"subscribe_image: {listing_id} - {resource_version} ... [Failed]"
-                f"Error message: {str(e)}")
-            raise RuntimeError("ERR: Image subscription error!")
+                f'[Failed] subscribe_image: {listing_id} - {resource_version}'
+                f'Error message: {str(e)}')
+            raise RuntimeError('ERR: Image subscription error!') from e
 
     @classmethod
-    @utils.debug_enabled(logger=logger)
+    @debug_enabled(logger)
     def find_compartment(cls, region) -> str:
         """ If compartment is not configured, we use root compartment """
         # Try to use the configured one first
@@ -143,12 +216,18 @@ class oci_query_helper:
         # config file is supported (2023/06/09).
         root = oci_adaptor.get_oci_config(
             region, oci_utils.oci_config.get_profile())['tenancy']
+
         list_compartments_response = oci_adaptor.get_identity_client(
             region, oci_utils.oci_config.get_profile()).list_compartments(
                 compartment_id=root,
                 name=oci_utils.oci_config.COMPARTMENT,
+                compartment_id_in_subtree=True,
+                access_level='ACCESSIBLE',
                 lifecycle_state='ACTIVE',
+                sort_by='TIMECREATED',
+                sort_order='DESC',
                 limit=1)
+
         compartments = list_compartments_response.data
         if len(compartments) > 0:
             skypilot_compartment = compartments[0].id
@@ -159,7 +238,7 @@ class oci_query_helper:
         return skypilot_compartment
 
     @classmethod
-    @utils.debug_enabled(logger=logger)
+    @debug_enabled(logger)
     def find_create_vcn_subnet(cls, region) -> Optional[str]:
         """ If sub is not configured, we find/create VCN skypilot_vcn """
         subnet = oci_utils.oci_config.get_vcn_subnet(region)
@@ -174,7 +253,7 @@ class oci_query_helper:
         list_vcns_response = net_client.list_vcns(
             compartment_id=skypilot_compartment,
             display_name=oci_utils.oci_config.VCN_NAME,
-            lifecycle_state="AVAILABLE")
+            lifecycle_state='AVAILABLE')
         vcns = list_vcns_response.data
         if len(vcns) > 0:
             # Found the VCN.
@@ -184,7 +263,7 @@ class oci_query_helper:
                 limit=1,
                 vcn_id=skypilot_vcn,
                 display_name=oci_utils.oci_config.VCN_SUBNET_NAME,
-                lifecycle_state="AVAILABLE")
+                lifecycle_state='AVAILABLE')
             logger.debug(f'Got VCN subnet \n{list_subnets_response.data}')
             if len(list_subnets_response.data) < 1:
                 logger.error(
@@ -201,10 +280,17 @@ class oci_query_helper:
             return cls.create_vcn_subnet(net_client, skypilot_compartment)
 
     @classmethod
-    @utils.debug_enabled(logger=logger)
+    @debug_enabled(logger)
     def create_vcn_subnet(cls, net_client,
                           skypilot_compartment) -> Optional[str]:
+
+        skypilot_vcn = None  # VCN for the resources
+        subnet = None  # Subnet for the VMs
+        ig = None  # Internet gateway
+        sg = None  # Service gateway
+
         try:
+            # pylint: disable=line-too-long
             create_vcn_response = net_client.create_vcn(
                 create_vcn_details=oci_adaptor.oci.core.models.CreateVcnDetails(
                     compartment_id=skypilot_compartment,
@@ -274,38 +360,38 @@ class oci_query_helper:
                 update_security_list_details=oci_adaptor.oci.core.models.
                 UpdateSecurityListDetails(ingress_security_rules=[
                     oci_adaptor.oci.core.models.IngressSecurityRule(
-                        protocol="6",
+                        protocol='6',
                         source=oci_utils.oci_config.VCN_CIDR_INTERNET,
                         is_stateless=False,
-                        source_type="CIDR_BLOCK",
+                        source_type='CIDR_BLOCK',
                         tcp_options=oci_adaptor.oci.core.models.TcpOptions(
                             destination_port_range=oci_adaptor.oci.core.models.
                             PortRange(max=22, min=22),
                             source_port_range=oci_adaptor.oci.core.models.
                             PortRange(max=65535, min=1)),
-                        description="Allow SSH port."),
+                        description='Allow SSH port.'),
                     oci_adaptor.oci.core.models.IngressSecurityRule(
-                        protocol="all",
+                        protocol='all',
                         source=oci_utils.oci_config.VCN_SUBNET_CIDR,
                         is_stateless=False,
-                        source_type="CIDR_BLOCK",
-                        description="Allow all traffic from/to same subnet."),
+                        source_type='CIDR_BLOCK',
+                        description='Allow all traffic from/to same subnet.'),
                     oci_adaptor.oci.core.models.IngressSecurityRule(
-                        protocol="1",
+                        protocol='1',
                         source=oci_utils.oci_config.VCN_CIDR_INTERNET,
                         is_stateless=False,
-                        source_type="CIDR_BLOCK",
+                        source_type='CIDR_BLOCK',
                         icmp_options=oci_adaptor.oci.core.models.IcmpOptions(
                             type=3, code=4),
-                        description="ICMP traffic."),
+                        description='ICMP traffic.'),
                     oci_adaptor.oci.core.models.IngressSecurityRule(
-                        protocol="1",
+                        protocol='1',
                         source=oci_utils.oci_config.VCN_CIDR,
                         is_stateless=False,
-                        source_type="CIDR_BLOCK",
+                        source_type='CIDR_BLOCK',
                         icmp_options=oci_adaptor.oci.core.models.IcmpOptions(
                             type=3),
-                        description="ICMP traffic (VCN)."),
+                        description='ICMP traffic (VCN).'),
                 ]))
             logger.debug(
                 f'Updated security_list: \n{update_security_list_response.data}'
@@ -325,7 +411,7 @@ class oci_query_helper:
                 ]))
             logger.debug(f'Route table: \n{update_route_table_response.data}')
 
-        except oci_adaptor.service_exception() as e:
+        except oci_adaptor.oci.exceptions.ServiceError as e:
             logger.error(f'Create VCN Error: Create new VCN '
                          f'{oci_utils.oci_config.VCN_NAME} failed: {str(e)}')
             # In case of partial success while creating vcn
@@ -335,7 +421,7 @@ class oci_query_helper:
         return subnet
 
     @classmethod
-    @utils.debug_enabled(logger=logger)
+    @debug_enabled(logger)
     def delete_vcn(cls, net_client, skypilot_vcn, skypilot_subnet,
                    internet_gateway, service_gateway):
         if skypilot_vcn is None:
@@ -369,7 +455,7 @@ class oci_query_helper:
                         f'Deleted vcn {skypilot_vcn}-{delete_vcn_response.data}'
                     )
                     break
-                except oci_adaptor.service_exception() as e:
+                except oci_adaptor.oci.exceptions.ServiceError as e:
                     logger.info(f'Waiting del SG/IG/Subnet finish: {str(e)}')
                     retry_count = retry_count + 1
                     if retry_count == oci_utils.oci_config.MAX_RETRY_COUNT:
@@ -378,6 +464,9 @@ class oci_query_helper:
                         time.sleep(
                             oci_utils.oci_config.RETRY_INTERVAL_BASE_SECONDS)
 
-        except oci_adaptor.service_exception() as e:
+        except oci_adaptor.oci.exceptions.ServiceError as e:
             logger.error(
                 f'Delete VCN {oci_utils.oci_config.VCN_NAME} Error: {str(e)}')
+
+
+query_helper = QueryHelper()

sky/serve/__init__.py

@@ -11,6 +11,7 @@ from sky.serve.core import tail_logs
 from sky.serve.core import terminate_replica
 from sky.serve.core import up
 from sky.serve.core import update
+from sky.serve.load_balancing_policies import LB_POLICIES
 from sky.serve.serve_state import ReplicaStatus
 from sky.serve.serve_state import ServiceStatus
 from sky.serve.serve_utils import DEFAULT_UPDATE_MODE
@@ -35,6 +36,7 @@ __all__ = [
     'get_endpoint',
     'INITIAL_VERSION',
     'LB_CONTROLLER_SYNC_INTERVAL_SECONDS',
+    'LB_POLICIES',
     'ReplicaStatus',
     'ServiceComponent',
     'ServiceStatus',

sky/serve/load_balancer.py

@@ -2,7 +2,7 @@
 import asyncio
 import logging
 import threading
-from typing import Dict, Union
+from typing import Dict, Optional, Union
 
 import aiohttp
 import fastapi
@@ -27,18 +27,24 @@ class SkyServeLoadBalancer:
     policy.
     """
 
-    def __init__(self, controller_url: str, load_balancer_port: int) -> None:
+    def __init__(self,
+                 controller_url: str,
+                 load_balancer_port: int,
+                 load_balancing_policy_name: Optional[str] = None) -> None:
         """Initialize the load balancer.
 
         Args:
             controller_url: The URL of the controller.
             load_balancer_port: The port where the load balancer listens to.
+            load_balancing_policy_name: The name of the load balancing policy
+                to use. Defaults to None.
         """
         self._app = fastapi.FastAPI()
         self._controller_url: str = controller_url
         self._load_balancer_port: int = load_balancer_port
-        self._load_balancing_policy: lb_policies.LoadBalancingPolicy = (
-            lb_policies.RoundRobinPolicy())
+        # Use the registry to create the load balancing policy
+        self._load_balancing_policy = lb_policies.LoadBalancingPolicy.make(
+            load_balancing_policy_name)
         self._request_aggregator: serve_utils.RequestsAggregator = (
             serve_utils.RequestTimestamp())
         # TODO(tian): httpx.Client has a resource limit of 100 max connections
@@ -223,9 +229,21 @@ class SkyServeLoadBalancer:
         uvicorn.run(self._app, host='0.0.0.0', port=self._load_balancer_port)
 
 
-def run_load_balancer(controller_addr: str, load_balancer_port: int):
-    load_balancer = SkyServeLoadBalancer(controller_url=controller_addr,
-                                         load_balancer_port=load_balancer_port)
+def run_load_balancer(controller_addr: str,
+                      load_balancer_port: int,
+                      load_balancing_policy_name: Optional[str] = None) -> None:
+    """ Run the load balancer.
+
+    Args:
+        controller_addr: The address of the controller.
+        load_balancer_port: The port where the load balancer listens to.
+        policy_name: The name of the load balancing policy to use. Defaults to
+            None.
+    """
+    load_balancer = SkyServeLoadBalancer(
+        controller_url=controller_addr,
+        load_balancer_port=load_balancer_port,
+        load_balancing_policy_name=load_balancing_policy_name)
     load_balancer.run()
 
 
@@ -241,5 +259,13 @@ if __name__ == '__main__':
                         required=True,
                         default=8890,
                         help='The port where the load balancer listens to.')
+    available_policies = list(lb_policies.LB_POLICIES.keys())
+    parser.add_argument(
+        '--load-balancing-policy',
+        choices=available_policies,
+        default='round_robin',
+        help=f'The load balancing policy to use. Available policies: '
+        f'{", ".join(available_policies)}.')
     args = parser.parse_args()
-    run_load_balancer(args.controller_addr, args.load_balancer_port)
+    run_load_balancer(args.controller_addr, args.load_balancer_port,
+                      args.load_balancing_policy)

sky/serve/load_balancing_policies.py

@@ -10,6 +10,10 @@ if typing.TYPE_CHECKING:
 
 logger = sky_logging.init_logger(__name__)
 
+# Define a registry for load balancing policies
+LB_POLICIES = {}
+DEFAULT_LB_POLICY = None
+
 
 def _request_repr(request: 'fastapi.Request') -> str:
     return ('<Request '
@@ -25,6 +29,24 @@ class LoadBalancingPolicy:
     def __init__(self) -> None:
         self.ready_replicas: List[str] = []
 
+    def __init_subclass__(cls, name: str, default: bool = False):
+        LB_POLICIES[name] = cls
+        if default:
+            global DEFAULT_LB_POLICY
+            assert DEFAULT_LB_POLICY is None, (
+                'Only one policy can be default.')
+            DEFAULT_LB_POLICY = name
+
+    @classmethod
+    def make(cls, policy_name: Optional[str] = None) -> 'LoadBalancingPolicy':
+        """Create a load balancing policy from a name."""
+        if policy_name is None:
+            policy_name = DEFAULT_LB_POLICY
+
+        if policy_name not in LB_POLICIES:
+            raise ValueError(f'Unknown load balancing policy: {policy_name}')
+        return LB_POLICIES[policy_name]()
+
     def set_ready_replicas(self, ready_replicas: List[str]) -> None:
         raise NotImplementedError
 
@@ -44,7 +66,7 @@ class LoadBalancingPolicy:
         raise NotImplementedError
 
 
-class RoundRobinPolicy(LoadBalancingPolicy):
+class RoundRobinPolicy(LoadBalancingPolicy, name='round_robin', default=True):
     """Round-robin load balancing policy."""
 
     def __init__(self) -> None:

sky/serve/service.py

@@ -219,6 +219,9 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
             load_balancer_port = common_utils.find_free_port(
                 constants.LOAD_BALANCER_PORT_START)
 
+            # Extract the load balancing policy from the service spec
+            policy_name = service_spec.load_balancing_policy
+
             # Start the load balancer.
             # TODO(tian): Probably we could enable multiple ports specified in
             # service spec and we could start multiple load balancers.
@@ -227,7 +230,7 @@ def _start(service_name: str, tmp_task_yaml: str, job_id: int):
                 target=ux_utils.RedirectOutputForProcess(
                     load_balancer.run_load_balancer,
                     load_balancer_log_file).run,
-                args=(controller_addr, load_balancer_port))
+                args=(controller_addr, load_balancer_port, policy_name))
             load_balancer_process.start()
             serve_state.set_service_load_balancer_port(service_name,
                                                        load_balancer_port)

sky/serve/service_spec.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, Optional
 
 import yaml
 
+from sky import serve
 from sky.serve import constants
 from sky.utils import common_utils
 from sky.utils import schemas
@@ -29,6 +30,7 @@ class SkyServiceSpec:
         base_ondemand_fallback_replicas: Optional[int] = None,
         upscale_delay_seconds: Optional[int] = None,
         downscale_delay_seconds: Optional[int] = None,
+        load_balancing_policy: Optional[str] = None,
     ) -> None:
         if max_replicas is not None and max_replicas < min_replicas:
             with ux_utils.print_exception_no_traceback():
@@ -55,6 +57,13 @@ class SkyServiceSpec:
                 raise ValueError('readiness_path must start with a slash (/). '
                                  f'Got: {readiness_path}')
 
+        # Add the check for unknown load balancing policies
+        if (load_balancing_policy is not None and
+                load_balancing_policy not in serve.LB_POLICIES):
+            with ux_utils.print_exception_no_traceback():
+                raise ValueError(
+                    f'Unknown load balancing policy: {load_balancing_policy}. '
+                    f'Available policies: {list(serve.LB_POLICIES.keys())}')
         self._readiness_path: str = readiness_path
         self._initial_delay_seconds: int = initial_delay_seconds
         self._readiness_timeout_seconds: int = readiness_timeout_seconds
@@ -69,6 +78,7 @@ class SkyServiceSpec:
             int] = base_ondemand_fallback_replicas
         self._upscale_delay_seconds: Optional[int] = upscale_delay_seconds
         self._downscale_delay_seconds: Optional[int] = downscale_delay_seconds
+        self._load_balancing_policy: Optional[str] = load_balancing_policy
 
         self._use_ondemand_fallback: bool = (
             self.dynamic_ondemand_fallback is not None and
@@ -150,6 +160,8 @@ class SkyServiceSpec:
             service_config['dynamic_ondemand_fallback'] = policy_section.get(
                 'dynamic_ondemand_fallback', None)
 
+        service_config['load_balancing_policy'] = config.get(
+            'load_balancing_policy', None)
         return SkyServiceSpec(**service_config)
 
     @staticmethod
@@ -205,6 +217,8 @@ class SkyServiceSpec:
                         self.upscale_delay_seconds)
         add_if_not_none('replica_policy', 'downscale_delay_seconds',
                         self.downscale_delay_seconds)
+        add_if_not_none('load_balancing_policy', None,
+                        self._load_balancing_policy)
         return config
 
     def probe_str(self):
@@ -256,6 +270,7 @@ class SkyServiceSpec:
             Readiness probe timeout seconds:  {self.readiness_timeout_seconds}
             Replica autoscaling policy:       {self.autoscaling_policy_str()}
             Spot Policy:                      {self.spot_policy_str()}
+            Load Balancing Policy:            {self.load_balancing_policy}
         """)
 
     @property
@@ -310,3 +325,7 @@ class SkyServiceSpec:
     @property
     def use_ondemand_fallback(self) -> bool:
         return self._use_ondemand_fallback
+
+    @property
+    def load_balancing_policy(self) -> Optional[str]:
+        return self._load_balancing_policy

sky/setup_files/MANIFEST.in

@@ -6,7 +6,6 @@ include sky/setup_files/*
 include sky/skylet/*.sh
 include sky/skylet/LICENSE
 include sky/skylet/providers/ibm/*
-include sky/skylet/providers/oci/*
 include sky/skylet/providers/scp/*
 include sky/skylet/providers/*.py
 include sky/skylet/ray_patches/*.patch