skypilot-nightly 1.0.0.dev20250215__py3-none-any.whl → 1.0.0.dev20250217__py3-none-any.whl

sky/execution.py

@@ -3,28 +3,32 @@
 See `Stage` for a Task's life cycle.
 """
 import enum
+import typing
 from typing import List, Optional, Tuple, Union
 
 import colorama
 
-import sky
 from sky import admin_policy
 from sky import backends
 from sky import clouds
 from sky import global_user_state
 from sky import optimizer
 from sky import sky_logging
-from sky import status_lib
 from sky.backends import backend_utils
 from sky.usage import usage_lib
 from sky.utils import admin_policy_utils
+from sky.utils import common
 from sky.utils import controller_utils
 from sky.utils import dag_utils
 from sky.utils import resources_utils
 from sky.utils import rich_utils
+from sky.utils import status_lib
 from sky.utils import timeline
 from sky.utils import ux_utils
 
+if typing.TYPE_CHECKING:
+    import sky
+
 logger = sky_logging.init_logger(__name__)
 
 
@@ -100,7 +104,7 @@ def _execute(
     handle: Optional[backends.ResourceHandle] = None,
     backend: Optional[backends.Backend] = None,
     retry_until_up: bool = False,
-    optimize_target: optimizer.OptimizeTarget = optimizer.OptimizeTarget.COST,
+    optimize_target: common.OptimizeTarget = common.OptimizeTarget.COST,
     stages: Optional[List[Stage]] = None,
     cluster_name: Optional[str] = None,
     detach_setup: bool = False,
@@ -111,6 +115,7 @@ def _execute(
     skip_unnecessary_provisioning: bool = False,
     # Internal only:
     # pylint: disable=invalid-name
+    _quiet_optimizer: bool = False,
     _is_launched_by_jobs_controller: bool = False,
     _is_launched_by_sky_serve_controller: bool = False,
 ) -> Tuple[Optional[int], Optional[backends.ResourceHandle]]:
@@ -167,16 +172,19 @@ def _execute(
     """
 
     dag = dag_utils.convert_entrypoint_to_dag(entrypoint)
-    if not dag.policy_applied:
-        dag, _ = admin_policy_utils.apply(
-            dag,
-            request_options=admin_policy.RequestOptions(
-                cluster_name=cluster_name,
-                idle_minutes_to_autostop=idle_minutes_to_autostop,
-                down=down,
-                dryrun=dryrun,
-            ),
-        )
+    for task in dag.tasks:
+        if task.storage_mounts is not None:
+            for storage in task.storage_mounts.values():
+                # Ensure the storage is constructed.
+                storage.construct()
+    dag, _ = admin_policy_utils.apply(
+        dag,
+        request_options=admin_policy.RequestOptions(
+            cluster_name=cluster_name,
+            idle_minutes_to_autostop=idle_minutes_to_autostop,
+            down=down,
+            dryrun=dryrun,
+        ))
     assert len(dag) == 1, f'We support 1 task for now. {dag}'
     task = dag.tasks[0]
 
@@ -274,14 +282,15 @@ def _execute(
                     # no-credential machine should not enter optimize(), which
                     # would directly error out ('No cloud is enabled...').  Fix
                     # by moving `sky check` checks out of optimize()?
-
                     controller = controller_utils.Controllers.from_name(
                         cluster_name)
                     if controller is not None:
                         logger.info(
                             f'Choosing resources for {controller.value.name}...'
                         )
-                    dag = sky.optimize(dag, minimize=optimize_target)
+                    dag = optimizer.Optimizer.optimize(dag,
+                                                       minimize=optimize_target,
+                                                       quiet=_quiet_optimizer)
                     task = dag.tasks[0]  # Keep: dag may have been deep-copied.
                     assert task.best_resources is not None, task
 
@@ -320,7 +329,7 @@ def _execute(
                           (task.file_mounts is not None or
                            task.storage_mounts is not None))
         if do_workdir or do_file_mounts:
-            logger.info(ux_utils.starting_message('Mounting files.'))
+            logger.info(ux_utils.starting_message('Syncing files.'))
 
         if do_workdir:
             backend.sync_workdir(handle, task.workdir)
@@ -374,20 +383,19 @@ def launch(
     down: bool = False,
     stream_logs: bool = True,
     backend: Optional[backends.Backend] = None,
-    optimize_target: optimizer.OptimizeTarget = optimizer.OptimizeTarget.COST,
-    detach_setup: bool = False,
-    detach_run: bool = False,
+    optimize_target: common.OptimizeTarget = common.OptimizeTarget.COST,
     no_setup: bool = False,
     clone_disk_from: Optional[str] = None,
     fast: bool = False,
     # Internal only:
     # pylint: disable=invalid-name
+    _quiet_optimizer: bool = False,
     _is_launched_by_jobs_controller: bool = False,
     _is_launched_by_sky_serve_controller: bool = False,
     _disable_controller_check: bool = False,
 ) -> Tuple[Optional[int], Optional[backends.ResourceHandle]]:
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
-    """Launch a cluster or task.
+    """Launches a cluster or task.
 
     The task's setup and run commands are executed under the task's workdir
     (when specified, it is synced to remote cluster).  The task undergoes job
@@ -397,6 +405,16 @@ def launch(
     usage) a sky.Dag. In the latter case, currently it must contain a single
     task; support for pipelines/general DAGs are in experimental branches.
 
+    Example:
+        .. code-block:: python
+
+            import sky
+            task = sky.Task(run='echo hello SkyPilot')
+            task.set_resources(
+                sky.Resources(cloud=sky.AWS(), accelerators='V100:4'))
+            sky.launch(task, cluster_name='my-cluster')
+
+
     Args:
         task: sky.Task, or sky.Dag (experimental; 1-task only) to launch.
         cluster_name: name of the cluster to create/reuse.  If None,
@@ -408,7 +426,7 @@ def launch(
             cluster's job queue. Idleness gets reset whenever setting-up/
             running/pending jobs are found in the job queue. Setting this
             flag is equivalent to running
-            ``sky.launch(..., detach_run=True, ...)`` and then
+            ``sky.launch(...)`` and then
             ``sky.autostop(idle_minutes=<minutes>)``. If not set, the cluster
             will not be autostopped.
         down: Tear down the cluster after all jobs finish (successfully or
@@ -422,14 +440,6 @@ def launch(
             (CloudVMRayBackend).
         optimize_target: target to optimize for. Choices: OptimizeTarget.COST,
             OptimizeTarget.TIME.
-        detach_setup: If True, run setup in non-interactive mode as part of the
-            job itself. You can safely ctrl-c to detach from logging, and it
-            will not interrupt the setup process. To see the logs again after
-            detaching, use `sky logs`. To cancel setup, cancel the job via
-            `sky cancel`. Useful for long-running setup
-            commands.
-        detach_run: If True, as soon as a job is submitted, return from this
-            function and do not stream execution logs.
         no_setup: if True, do not re-run setup commands.
         clone_disk_from: [Experimental] if set, clone the disk from the
             specified cluster. This is useful to migrate the cluster to a
@@ -437,15 +447,6 @@ def launch(
         fast: [Experimental] If the cluster is already up and available,
             skip provisioning and setup steps.
 
-    Example:
-        .. code-block:: python
-
-            import sky
-            task = sky.Task(run='echo hello SkyPilot')
-            task.set_resources(
-                sky.Resources(cloud=sky.AWS(), accelerators='V100:4'))
-            sky.launch(task, cluster_name='my-cluster')
-
     Raises:
         exceptions.ClusterOwnerIdentityMismatchError: if the cluster is
             owned by another user.
@@ -474,7 +475,9 @@ def launch(
       handle: Optional[backends.ResourceHandle]; the handle to the cluster. None
         if dryrun.
     """
+
     entrypoint = task
+    entrypoint.validate()
     if not _disable_controller_check:
         controller_utils.check_cluster_name_not_controller(
             cluster_name, operation_str='sky.launch')
@@ -537,12 +540,13 @@ def launch(
         optimize_target=optimize_target,
         stages=stages,
         cluster_name=cluster_name,
-        detach_setup=detach_setup,
-        detach_run=detach_run,
+        detach_setup=True,
+        detach_run=True,
         idle_minutes_to_autostop=idle_minutes_to_autostop,
         no_setup=no_setup,
         clone_disk_from=clone_disk_from,
         skip_unnecessary_provisioning=skip_unnecessary_provisioning,
+        _quiet_optimizer=_quiet_optimizer,
         _is_launched_by_jobs_controller=_is_launched_by_jobs_controller,
         _is_launched_by_sky_serve_controller=
         _is_launched_by_sky_serve_controller,
@@ -557,10 +561,9 @@ def exec(  # pylint: disable=redefined-builtin
     down: bool = False,
     stream_logs: bool = True,
     backend: Optional[backends.Backend] = None,
-    detach_run: bool = False,
 ) -> Tuple[Optional[int], Optional[backends.ResourceHandle]]:
     # NOTE(dev): Keep the docstring consistent between the Python API and CLI.
-    """Execute a task on an existing cluster.
+    """Executes a task on an existing cluster.
 
     This function performs two actions:
 
@@ -595,8 +598,6 @@ def exec(  # pylint: disable=redefined-builtin
         stream_logs: if True, show the logs in the terminal.
         backend: backend to use.  If None, use the default backend
             (CloudVMRayBackend).
-        detach_run: if True, detach from logging once the task has been
-            submitted.
 
     Raises:
         ValueError: if the specified cluster is not in UP status.
@@ -613,11 +614,7 @@ def exec(  # pylint: disable=redefined-builtin
         if dryrun.
     """
     entrypoint = task
-    if isinstance(entrypoint, sky.Dag):
-        logger.warning(
-            f'{colorama.Fore.YELLOW}Passing a sky.Dag to sky.exec() is '
-            'deprecated. Pass sky.Task instead.'
-            f'{colorama.Style.RESET_ALL}')
+    entrypoint.validate(workdir_only=True)
     controller_utils.check_cluster_name_not_controller(cluster_name,
                                                        operation_str='sky.exec')
 
@@ -638,5 +635,5 @@ def exec(  # pylint: disable=redefined-builtin
             Stage.EXEC,
         ],
         cluster_name=cluster_name,
-        detach_run=detach_run,
+        detach_run=True,
     )

sky/global_user_state.py

@@ -16,15 +16,20 @@ import typing
 from typing import Any, Dict, List, Optional, Set, Tuple
 import uuid
 
-from sky import clouds
-from sky import status_lib
+from sky import models
+from sky import sky_logging
 from sky.utils import common_utils
 from sky.utils import db_utils
+from sky.utils import registry
+from sky.utils import status_lib
 
 if typing.TYPE_CHECKING:
     from sky import backends
+    from sky import clouds
     from sky.data import Storage
 
+logger = sky_logging.init_logger(__name__)
+
 _ENABLED_CLOUDS_KEY = 'enabled_clouds'
 
 _DB_PATH = os.path.expanduser('~/.sky/state.db')
@@ -62,7 +67,8 @@ def create_table(cursor, conn):
         storage_mounts_metadata BLOB DEFAULT null,
         cluster_ever_up INTEGER DEFAULT 0,
         status_updated_at INTEGER DEFAULT null,
-        config_hash TEXT DEFAULT null)""")
+        config_hash TEXT DEFAULT null,
+        user_hash TEXT DEFAULT null)""")
 
     # Table for Cluster History
     # usage_intervals: List[Tuple[int, int]]
@@ -85,7 +91,8 @@ def create_table(cursor, conn):
         num_nodes int,
         requested_resources BLOB,
         launched_resources BLOB,
-        usage_intervals BLOB)""")
+        usage_intervals BLOB,
+        user_hash TEXT)""")
     # Table for configs (e.g. enabled clouds)
     cursor.execute("""\
         CREATE TABLE IF NOT EXISTS config (
@@ -98,6 +105,11 @@ def create_table(cursor, conn):
         handle BLOB,
         last_use TEXT,
         status TEXT)""")
+    # Table for User
+    cursor.execute("""\
+        CREATE TABLE IF NOT EXISTS users (
+        id TEXT PRIMARY KEY,
+        name TEXT)""")
     # For backward compatibility.
     # TODO(zhwu): Remove this function after all users have migrated to
     # the latest version of SkyPilot.
@@ -111,6 +123,7 @@ def create_table(cursor, conn):
     db_utils.add_column_to_table(cursor, conn, 'clusters', 'to_down',
                                  'INTEGER DEFAULT 0')
 
+    # The cloud identity that created the cluster.
     db_utils.add_column_to_table(cursor, conn, 'clusters', 'owner', 'TEXT')
 
     db_utils.add_column_to_table(cursor, conn, 'clusters', 'cluster_hash',
@@ -132,19 +145,46 @@ def create_table(cursor, conn):
         # clusters were never really UP, setting it to 1 means they won't be
         # auto-deleted during any failover.
         value_to_replace_existing_entries=1)
-
     db_utils.add_column_to_table(cursor, conn, 'clusters', 'status_updated_at',
                                  'INTEGER DEFAULT null')
+    db_utils.add_column_to_table(
+        cursor,
+        conn,
+        'clusters',
+        'user_hash',
+        'TEXT DEFAULT null',
+        value_to_replace_existing_entries=common_utils.get_user_hash())
+    db_utils.add_column_to_table(cursor, conn, 'clusters', 'config_hash',
+                                 'TEXT DEFAULT null')
 
     db_utils.add_column_to_table(cursor, conn, 'clusters', 'config_hash',
                                  'TEXT DEFAULT null')
 
+    db_utils.add_column_to_table(cursor, conn, 'cluster_history', 'user_hash',
+                                 'TEXT DEFAULT null')
     conn.commit()
 
 
 _DB = db_utils.SQLiteConn(_DB_PATH, create_table)
 
 
+def add_or_update_user(user: models.User):
+    """Store the mapping from user hash to user name for display purposes."""
+    if user.name is None:
+        return
+    _DB.cursor.execute('INSERT OR REPLACE INTO users (id, name) VALUES (?, ?)',
+                       (user.id, user.name))
+    _DB.conn.commit()
+
+
+def get_user(user_id: str) -> models.User:
+    row = _DB.cursor.execute('SELECT id, name FROM users WHERE id=?',
+                             (user_id,)).fetchone()
+    if row is None:
+        return models.User(id=user_id)
+    return models.User(id=row[0], name=row[1])
+
+
 def add_or_update_cluster(cluster_name: str,
                           cluster_handle: 'backends.ResourceHandle',
                           requested_resources: Optional[Set[Any]],
@@ -165,7 +205,7 @@ def add_or_update_cluster(cluster_name: str,
     # FIXME: launched_at will be changed when `sky launch -c` is called.
     handle = pickle.dumps(cluster_handle)
     cluster_launched_at = int(time.time()) if is_launch else None
-    last_use = common_utils.get_pretty_entry_point() if is_launch else None
+    last_use = common_utils.get_current_command() if is_launch else None
     status = status_lib.ClusterStatus.INIT
     if ready:
         status = status_lib.ClusterStatus.UP
@@ -194,6 +234,8 @@ def add_or_update_cluster(cluster_name: str,
             cluster_launched_at = int(time.time())
         usage_intervals.append((cluster_launched_at, None))
 
+    user_hash = common_utils.get_user_hash()
+
     _DB.cursor.execute(
         'INSERT or REPLACE INTO clusters'
         # All the fields need to exist here, even if they don't need
@@ -203,7 +245,7 @@ def add_or_update_cluster(cluster_name: str,
         '(name, launched_at, handle, last_use, status, '
         'autostop, to_down, metadata, owner, cluster_hash, '
         'storage_mounts_metadata, cluster_ever_up, status_updated_at, '
-        'config_hash) '
+        'config_hash, user_hash) '
         'VALUES ('
         # name
         '?, '
@@ -240,11 +282,14 @@ def add_or_update_cluster(cluster_name: str,
         'COALESCE('
         '(SELECT storage_mounts_metadata FROM clusters WHERE name=?), null), '
         # cluster_ever_up
-        '((SELECT cluster_ever_up FROM clusters WHERE name=?) OR ?),'
+        '((SELECT cluster_ever_up FROM clusters WHERE name=?) OR ?), '
         # status_updated_at
         '?,'
         # config_hash
-        'COALESCE(?, (SELECT config_hash FROM clusters WHERE name=?))'
+        'COALESCE(?, (SELECT config_hash FROM clusters WHERE name=?)),'
+        # user_hash: keep original user_hash if it exists
+        'COALESCE('
+        '(SELECT user_hash FROM clusters WHERE name=?), ?)'
         ')',
         (
             # name
@@ -281,6 +326,9 @@ def add_or_update_cluster(cluster_name: str,
             # config_hash
             config_hash,
             cluster_name,
+            # user_hash
+            cluster_name,
+            user_hash,
         ))
 
     launched_nodes = getattr(cluster_handle, 'launched_nodes', None)
@@ -288,7 +336,7 @@ def add_or_update_cluster(cluster_name: str,
     _DB.cursor.execute(
         'INSERT or REPLACE INTO cluster_history'
         '(cluster_hash, name, num_nodes, requested_resources, '
-        'launched_resources, usage_intervals) '
+        'launched_resources, usage_intervals, user_hash) '
         'VALUES ('
         # hash
         '?, '
@@ -301,7 +349,10 @@ def add_or_update_cluster(cluster_name: str,
         # number of nodes
         '?, '
         # usage intervals
-        '?)',
+        '?, '
+        # user_hash
+        '?'
+        ')',
         (
             # hash
             cluster_hash,
@@ -315,15 +366,37 @@ def add_or_update_cluster(cluster_name: str,
             pickle.dumps(launched_resources),
             # usage intervals
             pickle.dumps(usage_intervals),
+            # user_hash
+            user_hash,
         ))
 
     _DB.conn.commit()
 
 
+def _get_user_hash_or_current_user(user_hash: Optional[str]) -> str:
+    """Returns the user hash or the current user hash, if user_hash is None.
+
+    This is to ensure that the clusters created before the client-server
+    architecture (no user hash info previously) are associated with the current
+    user.
+    """
+    if user_hash is not None:
+        return user_hash
+    return common_utils.get_user_hash()
+
+
+def update_cluster_handle(cluster_name: str,
+                          cluster_handle: 'backends.ResourceHandle'):
+    handle = pickle.dumps(cluster_handle)
+    _DB.cursor.execute('UPDATE clusters SET handle=(?) WHERE name=(?)',
+                       (handle, cluster_name))
+    _DB.conn.commit()
+
+
 def update_last_use(cluster_name: str):
     """Updates the last used command for the cluster."""
     _DB.cursor.execute('UPDATE clusters SET last_use=(?) WHERE name=(?)',
-                       (common_utils.get_pretty_entry_point(), cluster_name))
+                       (common_utils.get_current_command(), cluster_name))
     _DB.conn.commit()
 
 
@@ -596,7 +669,7 @@ def get_cluster_from_name(
     rows = _DB.cursor.execute(
         'SELECT name, launched_at, handle, last_use, status, autostop, '
         'metadata, to_down, owner, cluster_hash, storage_mounts_metadata, '
-        'cluster_ever_up, status_updated_at, config_hash '
+        'cluster_ever_up, status_updated_at, config_hash, user_hash '
         'FROM clusters WHERE name=(?)', (cluster_name,)).fetchall()
     for row in rows:
         # Explicitly specify the number of fields to unpack, so that
@@ -604,7 +677,8 @@ def get_cluster_from_name(
         # breaking the previous code.
         (name, launched_at, handle, last_use, status, autostop, metadata,
          to_down, owner, cluster_hash, storage_mounts_metadata, cluster_ever_up,
-         status_updated_at, config_hash) = row[:14]
+         status_updated_at, config_hash, user_hash) = row
+        user_hash = _get_user_hash_or_current_user(user_hash)
         # TODO: use namedtuple instead of dict
         record = {
             'name': name,
@@ -621,6 +695,8 @@ def get_cluster_from_name(
                 _load_storage_mounts_metadata(storage_mounts_metadata),
             'cluster_ever_up': bool(cluster_ever_up),
             'status_updated_at': status_updated_at,
+            'user_hash': user_hash,
+            'user_name': get_user(user_hash).name,
             'config_hash': config_hash,
         }
         return record
@@ -631,13 +707,14 @@ def get_clusters() -> List[Dict[str, Any]]:
     rows = _DB.cursor.execute(
         'select name, launched_at, handle, last_use, status, autostop, '
         'metadata, to_down, owner, cluster_hash, storage_mounts_metadata, '
-        'cluster_ever_up, status_updated_at, config_hash '
+        'cluster_ever_up, status_updated_at, config_hash, user_hash '
         'from clusters order by launched_at desc').fetchall()
     records = []
     for row in rows:
         (name, launched_at, handle, last_use, status, autostop, metadata,
          to_down, owner, cluster_hash, storage_mounts_metadata, cluster_ever_up,
-         status_updated_at, config_hash) = row[:14]
+         status_updated_at, config_hash, user_hash) = row
+        user_hash = _get_user_hash_or_current_user(user_hash)
         # TODO: use namedtuple instead of dict
         record = {
             'name': name,
@@ -654,6 +731,8 @@ def get_clusters() -> List[Dict[str, Any]]:
                 _load_storage_mounts_metadata(storage_mounts_metadata),
             'cluster_ever_up': bool(cluster_ever_up),
             'status_updated_at': status_updated_at,
+            'user_hash': user_hash,
+            'user_name': get_user(user_hash).name,
             'config_hash': config_hash,
         }
 
@@ -664,7 +743,8 @@ def get_clusters() -> List[Dict[str, Any]]:
 def get_clusters_from_history() -> List[Dict[str, Any]]:
     rows = _DB.cursor.execute(
         'SELECT ch.cluster_hash, ch.name, ch.num_nodes, '
-        'ch.launched_resources, ch.usage_intervals, clusters.status  '
+        'ch.launched_resources, ch.usage_intervals, clusters.status, '
+        'ch.user_hash  '
         'FROM cluster_history ch '
         'LEFT OUTER JOIN clusters '
         'ON ch.cluster_hash=clusters.cluster_hash ').fetchall()
@@ -683,7 +763,9 @@ def get_clusters_from_history() -> List[Dict[str, Any]]:
             launched_resources,
             usage_intervals,
             status,
-        ) = row[:6]
+            user_hash,
+        ) = row[:7]
+        user_hash = _get_user_hash_or_current_user(user_hash)
 
         if status is not None:
             status = status_lib.ClusterStatus[status]
@@ -697,6 +779,7 @@ def get_clusters_from_history() -> List[Dict[str, Any]]:
             'cluster_hash': cluster_hash,
             'usage_intervals': pickle.loads(usage_intervals),
             'status': status,
+            'user_hash': user_hash,
         }
 
         records.append(record)
@@ -712,17 +795,17 @@ def get_cluster_names_start_with(starts_with: str) -> List[str]:
     return [row[0] for row in rows]
 
 
-def get_cached_enabled_clouds() -> List[clouds.Cloud]:
+def get_cached_enabled_clouds() -> List['clouds.Cloud']:
     rows = _DB.cursor.execute('SELECT value FROM config WHERE key = ?',
                               (_ENABLED_CLOUDS_KEY,))
     ret = []
     for (value,) in rows:
         ret = json.loads(value)
         break
-    enabled_clouds: List[clouds.Cloud] = []
+    enabled_clouds: List['clouds.Cloud'] = []
     for c in ret:
         try:
-            cloud = clouds.CLOUD_REGISTRY.from_str(c)
+            cloud = registry.CLOUD_REGISTRY.from_str(c)
         except ValueError:
             # Handle the case for the clouds whose support has been removed from
             # SkyPilot, e.g., 'local' was a cloud in the past and may be stored
@@ -745,7 +828,7 @@ def add_or_update_storage(storage_name: str,
                           storage_status: status_lib.StorageStatus):
     storage_launched_at = int(time.time())
     handle = pickle.dumps(storage_handle)
-    last_use = common_utils.get_pretty_entry_point()
+    last_use = common_utils.get_current_command()
 
     def status_check(status):
         return status in status_lib.StorageStatus

sky/jobs/__init__.py

@@ -1,47 +1,45 @@
 """Managed jobs."""
 import pathlib
 
+from sky.jobs.client.sdk import cancel
+from sky.jobs.client.sdk import dashboard
+from sky.jobs.client.sdk import download_logs
+from sky.jobs.client.sdk import launch
+from sky.jobs.client.sdk import queue
+from sky.jobs.client.sdk import tail_logs
 from sky.jobs.constants import JOBS_CLUSTER_NAME_PREFIX_LENGTH
+from sky.jobs.constants import JOBS_CONTROLLER_LOGS_DIR
 from sky.jobs.constants import JOBS_CONTROLLER_TEMPLATE
 from sky.jobs.constants import JOBS_CONTROLLER_YAML_PREFIX
 from sky.jobs.constants import JOBS_TASK_YAML_PREFIX
-from sky.jobs.core import cancel
-from sky.jobs.core import launch
-from sky.jobs.core import queue
-from sky.jobs.core import queue_from_kubernetes_pod
-from sky.jobs.core import sync_down_logs
-from sky.jobs.core import tail_logs
-from sky.jobs.recovery_strategy import DEFAULT_RECOVERY_STRATEGY
-from sky.jobs.recovery_strategy import RECOVERY_STRATEGIES
+from sky.jobs.recovery_strategy import StrategyExecutor
 from sky.jobs.state import ManagedJobStatus
 from sky.jobs.utils import dump_managed_job_queue
 from sky.jobs.utils import format_job_table
-from sky.jobs.utils import JOB_CONTROLLER_NAME
 from sky.jobs.utils import load_managed_job_queue
 from sky.jobs.utils import ManagedJobCodeGen
 
 pathlib.Path(JOBS_TASK_YAML_PREFIX).expanduser().parent.mkdir(parents=True,
                                                               exist_ok=True)
 __all__ = [
-    'RECOVERY_STRATEGIES',
-    'DEFAULT_RECOVERY_STRATEGY',
-    'JOB_CONTROLLER_NAME',
     # Constants
     'JOBS_CONTROLLER_TEMPLATE',
     'JOBS_CONTROLLER_YAML_PREFIX',
     'JOBS_TASK_YAML_PREFIX',
+    'JOBS_CONTROLLER_LOGS_DIR',
     # Enums
     'ManagedJobStatus',
     # Core
     'cancel',
     'launch',
     'queue',
-    'queue_from_kubernetes_pod',
     'tail_logs',
-    'sync_down_logs',
+    'dashboard',
+    'download_logs',
     # utils
     'ManagedJobCodeGen',
     'format_job_table',
     'dump_managed_job_queue',
     'load_managed_job_queue',
+    'StrategyExecutor',
 ]