skypilot-nightly 1.0.0.dev20251009__py3-none-any.whl → 1.0.0.dev20251107__py3-none-any.whl

sky/utils/controller_utils.py

@@ -72,7 +72,8 @@ class _ControllerSpec:
     """Spec for skypilot controllers."""
     controller_type: str
     name: str
-    cluster_name: str
+    _cluster_name_func: Callable[[], str]
+    _cluster_name_from_server: Optional[str]  # For client-side only
     in_progress_hint: Callable[[bool], str]
     decline_cancel_hint: str
     _decline_down_when_failed_to_fetch_status_hint: str
@@ -93,6 +94,24 @@ class _ControllerSpec:
         return self._check_cluster_name_hint.format(
             cluster_name=self.cluster_name)
 
+    @property
+    def cluster_name(self) -> str:
+        """The cluster name of the controller.
+
+        On the server-side, the cluster name is the actual cluster name,
+        which is read from common.(JOB|SKY_SERVE)_CONTROLLER_NAME.
+
+        On the client-side, the cluster name may not be accurate,
+        as we may not know the exact name, because we are missing
+        the server-side common.SERVER_ID. We have to wait until
+        we get the actual cluster name from the server.
+        """
+        return (self._cluster_name_from_server if self._cluster_name_from_server
+                is not None else self._cluster_name_func())
+
+    def set_cluster_name_from_server(self, cluster_name: str) -> None:
+        self._cluster_name_from_server = cluster_name
+
 
 # TODO: refactor controller class to not be an enum.
 class Controllers(enum.Enum):
@@ -102,7 +121,8 @@ class Controllers(enum.Enum):
     JOBS_CONTROLLER = _ControllerSpec(
         controller_type='jobs',
         name='managed jobs controller',
-        cluster_name=common.JOB_CONTROLLER_NAME,
+        _cluster_name_func=lambda: common.JOB_CONTROLLER_NAME,
+        _cluster_name_from_server=None,
         in_progress_hint=lambda _:
         ('* {job_info}To see all managed jobs: '
          f'{colorama.Style.BRIGHT}sky jobs queue{colorama.Style.RESET_ALL}'),
@@ -133,7 +153,8 @@ class Controllers(enum.Enum):
     SKY_SERVE_CONTROLLER = _ControllerSpec(
         controller_type='serve',
         name='serve controller',
-        cluster_name=common.SKY_SERVE_CONTROLLER_NAME,
+        _cluster_name_func=lambda: common.SKY_SERVE_CONTROLLER_NAME,
+        _cluster_name_from_server=None,
         in_progress_hint=(
             lambda pool:
             (f'* To see detailed pool status: {colorama.Style.BRIGHT}'
@@ -166,7 +187,9 @@ class Controllers(enum.Enum):
         default_autostop_config=serve_constants.CONTROLLER_AUTOSTOP)
 
     @classmethod
-    def from_name(cls, name: Optional[str]) -> Optional['Controllers']:
+    def from_name(cls,
+                  name: Optional[str],
+                  expect_exact_match: bool = True) -> Optional['Controllers']:
         """Check if the cluster name is a controller name.
 
         Returns:
@@ -187,7 +210,11 @@ class Controllers(enum.Enum):
         elif name.startswith(common.JOB_CONTROLLER_PREFIX):
             controller = cls.JOBS_CONTROLLER
             prefix = common.JOB_CONTROLLER_PREFIX
-        if controller is not None and name != controller.value.cluster_name:
+
+        if controller is not None and expect_exact_match:
+            assert name == controller.value.cluster_name, (
+                name, controller.value.cluster_name)
+        elif controller is not None and name != controller.value.cluster_name:
             # The client-side cluster_name is not accurate. Assume that `name`
             # is the actual cluster name, so need to set the controller's
             # cluster name to the input name.
@@ -201,7 +228,7 @@ class Controllers(enum.Enum):
                                                                          prefix)
 
             # Update the cluster name.
-            controller.value.cluster_name = name
+            controller.value.set_cluster_name_from_server(name)
         return controller
 
     @classmethod
@@ -228,7 +255,7 @@ def get_controller_for_pool(pool: bool) -> Controllers:
 def high_availability_specified(cluster_name: Optional[str]) -> bool:
     """Check if the controller high availability is specified in user config.
     """
-    controller = Controllers.from_name(cluster_name)
+    controller = Controllers.from_name(cluster_name, expect_exact_match=False)
     if controller is None:
         return False
 
@@ -411,7 +438,7 @@ def check_cluster_name_not_controller(
     Returns:
       None, if the cluster name is not a controller name.
     """
-    controller = Controllers.from_name(cluster_name)
+    controller = Controllers.from_name(cluster_name, expect_exact_match=False)
     if controller is not None:
         msg = controller.value.check_cluster_name_hint
         if operation_str is not None:

sky/utils/db/db_utils.py

@@ -185,7 +185,7 @@ def add_column_to_table_sqlalchemy(
             pass
         else:
             raise
-    #postgressql
+    #postgresql
     except sqlalchemy_exc.ProgrammingError as e:
         if 'already exists' in str(e):
             pass
@@ -358,6 +358,27 @@ class SQLiteConn(threading.local):
         conn = await self._get_async_conn()
         return await conn.execute_fetchall(sql, parameters)
 
+    async def execute_get_returning_value_async(
+            self,
+            sql: str,
+            parameters: Optional[Iterable[Any]] = None
+    ) -> Optional[sqlite3.Row]:
+        conn = await self._get_async_conn()
+
+        if parameters is None:
+            parameters = []
+
+        def exec_and_get_returning_value(sql: str,
+                                         parameters: Optional[Iterable[Any]]):
+            # pylint: disable=protected-access
+            row = conn._conn.execute(sql, parameters).fetchone()
+            conn._conn.commit()
+            return row
+
+        # pylint: disable=protected-access
+        return await conn._execute(exec_and_get_returning_value, sql,
+                                   parameters)
+
     async def close(self):
         if self._async_conn is not None:
             await self._async_conn.close()
@@ -382,21 +403,28 @@ def get_max_connections():
 
 @typing.overload
 def get_engine(
-        db_name: str,
+        db_name: Optional[str],
         async_engine: Literal[False] = False) -> sqlalchemy.engine.Engine:
     ...
 
 
 @typing.overload
-def get_engine(db_name: str,
+def get_engine(db_name: Optional[str],
                async_engine: Literal[True]) -> sqlalchemy_async.AsyncEngine:
     ...
 
 
 def get_engine(
-    db_name: str,
+    db_name: Optional[str],
     async_engine: bool = False
 ) -> Union[sqlalchemy.engine.Engine, sqlalchemy_async.AsyncEngine]:
+    """Get the engine for the given database name.
+
+    Args:
+        db_name: The name of the database. ONLY used for SQLite. On Postgres,
+        we use a single database, which we get from the connection string.
+        async_engine: Whether to return an async engine.
+    """
     conn_string = None
     if os.environ.get(constants.ENV_VAR_IS_SKYPILOT_SERVER) is not None:
         conn_string = os.environ.get(constants.ENV_VAR_DB_CONNECTION_URI)
@@ -416,19 +444,18 @@ def get_engine(
                     _postgres_engine_cache[conn_string] = (
                         sqlalchemy.create_engine(
                             conn_string, poolclass=sqlalchemy.pool.NullPool))
-                elif _max_connections == 1:
-                    _postgres_engine_cache[conn_string] = (
-                        sqlalchemy.create_engine(
-                            conn_string, poolclass=sqlalchemy.pool.StaticPool))
                 else:
                     _postgres_engine_cache[conn_string] = (
                         sqlalchemy.create_engine(
                             conn_string,
                             poolclass=sqlalchemy.pool.QueuePool,
-                            size=_max_connections,
-                            max_overflow=0))
+                            pool_size=_max_connections,
+                            max_overflow=max(0, 5 - _max_connections),
+                            pool_pre_ping=True,
+                            pool_recycle=1800))
             engine = _postgres_engine_cache[conn_string]
     else:
+        assert db_name is not None, 'db_name must be provided for SQLite'
         db_path = os.path.expanduser(f'~/.sky/{db_name}.db')
         pathlib.Path(db_path).parents[0].mkdir(parents=True, exist_ok=True)
         if async_engine:

sky/utils/db/migration_utils.py

@@ -19,15 +19,19 @@ DB_INIT_LOCK_TIMEOUT_SECONDS = 10
 
 GLOBAL_USER_STATE_DB_NAME = 'state_db'
 GLOBAL_USER_STATE_VERSION = '010'
-GLOBAL_USER_STATE_LOCK_PATH = '~/.sky/locks/.state_db.lock'
+GLOBAL_USER_STATE_LOCK_PATH = f'~/.sky/locks/.{GLOBAL_USER_STATE_DB_NAME}.lock'
 
 SPOT_JOBS_DB_NAME = 'spot_jobs_db'
-SPOT_JOBS_VERSION = '003'
-SPOT_JOBS_LOCK_PATH = '~/.sky/locks/.spot_jobs_db.lock'
+SPOT_JOBS_VERSION = '005'
+SPOT_JOBS_LOCK_PATH = f'~/.sky/locks/.{SPOT_JOBS_DB_NAME}.lock'
 
 SERVE_DB_NAME = 'serve_db'
 SERVE_VERSION = '001'
-SERVE_LOCK_PATH = '~/.sky/locks/.serve_db.lock'
+SERVE_LOCK_PATH = f'~/.sky/locks/.{SERVE_DB_NAME}.lock'
+
+SKYPILOT_CONFIG_DB_NAME = 'sky_config_db'
+SKYPILOT_CONFIG_VERSION = '001'
+SKYPILOT_CONFIG_LOCK_PATH = f'~/.sky/locks/.{SKYPILOT_CONFIG_DB_NAME}.lock'
 
 
 @contextlib.contextmanager

sky/utils/locks.py

@@ -243,6 +243,7 @@ class PostgresLock(DistributedLock):
         if not self._acquired or not self._connection:
             return
 
+        connection_lost = False
         try:
             cursor = self._connection.cursor()
             cursor.execute('SELECT pg_advisory_unlock(%s)', (self._lock_key,))
@@ -252,8 +253,11 @@ class PostgresLock(DistributedLock):
             # Lost connection to the database, likely the lock is force unlocked
             # by other routines.
             logger.debug(f'Failed to release postgres lock {self.lock_id}: {e}')
+            connection_lost = True
         finally:
-            self._close_connection()
+            # Invalidate if connection was lost to prevent SQLAlchemy from
+            # trying to reset a dead connection
+            self._close_connection(invalidate=connection_lost)
 
     def force_unlock(self) -> None:
         """Force unlock the postgres advisory lock."""
@@ -270,7 +274,7 @@ class PostgresLock(DistributedLock):
             cursor.execute('SELECT pg_advisory_unlock(%s)', (self._lock_key,))
             result = cursor.fetchone()[0]
             if result:
-                # The lock is held by current routine and unlock suceed
+                # The lock is held by current routine and unlock succeed
                 self._connection.commit()
                 self._acquired = False
                 return
@@ -292,13 +296,27 @@ class PostgresLock(DistributedLock):
         finally:
             self._close_connection()
 
-    def _close_connection(self) -> None:
-        """Close the postgres connection."""
+    def _close_connection(self, invalidate: bool = False) -> None:
+        """Close the postgres connection.
+
+        Args:
+            invalidate: If True, invalidate connection instead of closing it.
+                Use this when the connection might be broken (e.g., after
+                pg_terminate_backend) to prevent SQLAlchemy from trying to
+                reset it (which would result in an error being logged).
+        """
         if self._connection:
             try:
-                self._connection.close()
+                if invalidate:
+                    self._connection.invalidate()
+                else:
+                    self._connection.close()
             except Exception as e:  # pylint: disable=broad-except
-                logger.debug(f'Failed to close postgres connection: {e}')
+                if invalidate:
+                    logger.debug(
+                        f'Failed to invalidate postgres connection: {e}')
+                else:
+                    logger.debug(f'Failed to close postgres connection: {e}')
             self._connection = None
 
     def is_locked(self) -> bool:

sky/utils/resource_checker.py

@@ -278,7 +278,10 @@ def _get_active_resources(
         from sky.jobs.server import core as managed_jobs_core
         try:
             filtered_jobs, _, _, _ = managed_jobs_core.queue_v2(
-                refresh=False, skip_finished=True, all_users=True)
+                refresh=False,
+                skip_finished=True,
+                all_users=True,
+                fields=['job_id', 'user_hash', 'workspace'])
             return filtered_jobs
         except exceptions.ClusterNotUpError:
             logger.warning('All jobs should be finished.')

sky/utils/resources_utils.py

@@ -181,57 +181,81 @@ def simplify_ports(ports: List[str]) -> List[str]:
 
 
 def format_resource(resource: 'resources_lib.Resources',
-                    simplify: bool = False) -> str:
+                    simplified_only: bool = False) -> Tuple[str, Optional[str]]:
     resource = resource.assert_launchable()
-    vcpu, mem = resource.cloud.get_vcpus_mem_from_instance_type(
-        resource.instance_type)
+    is_k8s = str(resource.cloud).lower() == 'kubernetes'
+    if resource.accelerators is None or is_k8s or not simplified_only:
+        vcpu, mem = resource.cloud.get_vcpus_mem_from_instance_type(
+            resource.instance_type)
 
-    components = []
+    elements_simple = []
+    elements_full = []
 
     if resource.accelerators is not None:
         acc, count = list(resource.accelerators.items())[0]
-        components.append(f'gpus={acc}:{count}')
+        elements_simple.append(f'gpus={acc}:{count}')
+        elements_full.append(f'gpus={acc}:{count}')
 
-    is_k8s = str(resource.cloud).lower() == 'kubernetes'
-    if (resource.accelerators is None or is_k8s or not simplify):
+    if (resource.accelerators is None or is_k8s):
+        if vcpu is not None:
+            elements_simple.append(f'cpus={int(vcpu)}')
+            elements_full.append(f'cpus={int(vcpu)}')
+        if mem is not None:
+            elements_simple.append(f'mem={int(mem)}')
+            elements_full.append(f'mem={int(mem)}')
+    elif not simplified_only:
         if vcpu is not None:
-            components.append(f'cpus={int(vcpu)}')
+            elements_full.append(f'cpus={int(vcpu)}')
         if mem is not None:
-            components.append(f'mem={int(mem)}')
+            elements_full.append(f'mem={int(mem)}')
 
-    instance_type = resource.instance_type
-    if simplify:
-        instance_type = common_utils.truncate_long_string(instance_type, 15)
     if not is_k8s:
-        components.append(instance_type)
-    if simplify:
-        components.append('...')
-    else:
+        instance_type_full = resource.instance_type
+        instance_type_simple = common_utils.truncate_long_string(
+            instance_type_full, 15)
+        elements_simple.append(instance_type_simple)
+        elements_full.append(instance_type_full)
+    elements_simple.append('...')
+    if not simplified_only:
         image_id = resource.image_id
         if image_id is not None:
             if None in image_id:
-                components.append(f'image_id={image_id[None]}')
+                elements_full.append(f'image_id={image_id[None]}')
             else:
-                components.append(f'image_id={image_id}')
-        components.append(f'disk={resource.disk_size}')
+                elements_full.append(f'image_id={image_id}')
+        elements_full.append(f'disk={resource.disk_size}')
         disk_tier = resource.disk_tier
         if disk_tier is not None:
-            components.append(f'disk_tier={disk_tier.value}')
+            elements_full.append(f'disk_tier={disk_tier.value}')
         ports = resource.ports
         if ports is not None:
-            components.append(f'ports={ports}')
+            elements_full.append(f'ports={ports}')
 
     spot = '[spot]' if resource.use_spot else ''
-    return f'{spot}({"" if not components else ", ".join(components)})'
-
-
-def get_readable_resources_repr(handle: 'backends.CloudVmRayResourceHandle',
-                                simplify: bool = False) -> str:
+    resources_str_simple = (
+        f'{spot}({"" if not elements_simple else ", ".join(elements_simple)})')
+    if simplified_only:
+        return resources_str_simple, None
+    else:
+        resources_str_full = (
+            f'{spot}({"" if not elements_full else ", ".join(elements_full)})')
+        return resources_str_simple, resources_str_full
+
+
+def get_readable_resources_repr(
+        handle: 'backends.CloudVmRayResourceHandle',
+        simplified_only: bool = False) -> Tuple[str, Optional[str]]:
+    resource_str_simple, resource_str_full = format_resource(
+        handle.launched_resources, simplified_only)
+    if not simplified_only:
+        assert resource_str_full is not None
     if (handle.launched_nodes is not None and
             handle.launched_resources is not None):
-        return (f'{handle.launched_nodes}x'
-                f'{format_resource(handle.launched_resources, simplify)}')
-    return _DEFAULT_MESSAGE_HANDLE_INITIALIZING
+        return (f'{handle.launched_nodes}x{resource_str_simple}',
+                None if simplified_only else
+                f'{handle.launched_nodes}x{resource_str_full}')
+    return (_DEFAULT_MESSAGE_HANDLE_INITIALIZING,
+            _DEFAULT_MESSAGE_HANDLE_INITIALIZING)
 
 
 def make_ray_custom_resources_str(

sky/utils/schemas.py

@@ -1190,7 +1190,13 @@ def get_config_schema():
                         'consolidation_mode': {
                             'type': 'boolean',
                             'default': False,
-                        }
+                        },
+                        'controller_logs_gc_retention_hours': {
+                            'type': 'integer',
+                        },
+                        'task_logs_gc_retention_hours': {
+                            'type': 'integer',
+                        },
                     },
                 },
                 'bucket': {
@@ -1592,10 +1598,10 @@ def get_config_schema():
 
     allowed_workspace_cloud_names = list(constants.ALL_CLOUDS) + ['cloudflare']
     # Create pattern for not supported clouds, i.e.
-    # all clouds except gcp, kubernetes, ssh
+    # all clouds except aws, gcp, kubernetes, ssh, nebius
     not_supported_clouds = [
         cloud for cloud in allowed_workspace_cloud_names
-        if cloud.lower() not in ['gcp', 'kubernetes', 'ssh', 'nebius']
+        if cloud.lower() not in ['aws', 'gcp', 'kubernetes', 'ssh', 'nebius']
     ]
     not_supported_cloud_regex = '|'.join(not_supported_clouds)
     workspaces_schema = {
@@ -1606,7 +1612,8 @@ def get_config_schema():
             'type': 'object',
             'additionalProperties': False,
             'patternProperties': {
-                # Pattern for non-GCP clouds - only allows 'disabled' property
+                # Pattern for clouds with no workspace-specific config -
+                # only allow 'disabled' property.
                 f'^({not_supported_cloud_regex})$': {
                     'type': 'object',
                     'additionalProperties': False,
@@ -1641,6 +1648,18 @@ def get_config_schema():
                     },
                     'additionalProperties': False,
                 },
+                'aws': {
+                    'type': 'object',
+                    'properties': {
+                        'profile': {
+                            'type': 'string'
+                        },
+                        'disabled': {
+                            'type': 'boolean'
+                        },
+                    },
+                    'additionalProperties': False,
+                },
                 'ssh': {
                     'type': 'object',
                     'required': [],

sky/utils/subprocess_utils.py

@@ -10,7 +10,8 @@ import sys
 import threading
 import time
 import typing
-from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Union
+from typing import (Any, Callable, Dict, List, Optional, Protocol, Set, Tuple,
+                    Union)
 
 import colorama
 
@@ -18,6 +19,7 @@ from sky import exceptions
 from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.skylet import log_lib
+from sky.skylet import subprocess_daemon
 from sky.utils import common_utils
 from sky.utils import timeline
 from sky.utils import ux_utils
@@ -107,7 +109,7 @@ def get_parallel_threads(cloud_str: Optional[str] = None) -> int:
 
 
 def run_in_parallel(func: Callable,
-                    args: List[Any],
+                    args: Union[List[Any], Set[Any]],
                     num_threads: Optional[int] = None) -> List[Any]:
     """Run a function in parallel on a list of arguments.
 
@@ -128,7 +130,7 @@ def run_in_parallel(func: Callable,
     if len(args) == 0:
         return []
     if len(args) == 1:
-        return [func(args[0])]
+        return [func(list(args)[0])]
 
     processes = (num_threads
                  if num_threads is not None else get_parallel_threads())
@@ -305,11 +307,17 @@ def run_with_retries(
     return returncode, stdout, stderr
 
 
-def kill_process_daemon(process_pid: int) -> None:
+def kill_process_daemon(process_pid: int, use_kill_pg: bool = False) -> None:
     """Start a daemon as a safety net to kill the process.
 
     Args:
         process_pid: The PID of the process to kill.
+        use_kill_pg: Whether to use kill process group to kill the process. If
+            True, the process will use os.killpg() to kill the target process
+            group on UNIX system, which is more efficient than using the daemon
+            to refresh the process tree in the daemon. Note that both
+            implementations have corner cases where subprocesses might not be
+            killed. Refer to subprocess_daemon.py for more details.
     """
     # Get initial children list
     try:
@@ -336,6 +344,10 @@ def kill_process_daemon(process_pid: int) -> None:
         ','.join(map(str, initial_children)),
     ]
 
+    env = os.environ.copy()
+    if use_kill_pg:
+        env[subprocess_daemon.USE_KILL_PG_ENV_VAR] = '1'
+
     # We do not need to set `start_new_session=True` here, as the
     # daemon script will detach itself from the parent process with
     # fork to avoid being killed by parent process. See the reason we
@@ -347,6 +359,7 @@ def kill_process_daemon(process_pid: int) -> None:
         stderr=subprocess.DEVNULL,
         # Disable input
         stdin=subprocess.DEVNULL,
+        env=env,
     )
 
 

sky/volumes/server/server.py

@@ -7,6 +7,7 @@ from sky import exceptions
 from sky import sky_logging
 from sky.server.requests import executor
 from sky.server.requests import payloads
+from sky.server.requests import request_names
 from sky.server.requests import requests as requests_lib
 from sky.utils import registry
 from sky.utils import volume as volume_utils
@@ -25,9 +26,9 @@ async def volume_list(request: fastapi.Request) -> None:
         'env_vars': auth_user.to_env_vars()
     } if auth_user else {}
     request_body = payloads.RequestBody(**auth_user_env_vars_kwargs)
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='volume_list',
+        request_name=request_names.RequestName.VOLUME_LIST,
         request_body=request_body,
         func=core.volume_list,
         schedule_type=requests_lib.ScheduleType.SHORT,
@@ -38,9 +39,9 @@ async def volume_list(request: fastapi.Request) -> None:
 async def volume_delete(request: fastapi.Request,
                         volume_delete_body: payloads.VolumeDeleteBody) -> None:
     """Deletes a volume."""
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='volume_delete',
+        request_name=request_names.RequestName.VOLUME_DELETE,
         request_body=volume_delete_body,
         func=core.volume_delete,
         schedule_type=requests_lib.ScheduleType.LONG,
@@ -112,9 +113,9 @@ async def volume_apply(request: fastapi.Request,
             raise fastapi.HTTPException(
                 status_code=400,
                 detail='Runpod network volume is only supported on Runpod')
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='volume_apply',
+        request_name=request_names.RequestName.VOLUME_APPLY,
         request_body=volume_apply_body,
         func=core.volume_apply,
         schedule_type=requests_lib.ScheduleType.LONG,

sky/workspaces/server.py

@@ -4,6 +4,7 @@ import fastapi
 
 from sky.server.requests import executor
 from sky.server.requests import payloads
+from sky.server.requests import request_names
 from sky.server.requests import requests as api_requests
 from sky.workspaces import core
 
@@ -22,9 +23,9 @@ async def get(request: fastapi.Request) -> None:
     } if auth_user else {}
     request_body = payloads.RequestBody(**auth_user_env_vars_kwargs)
 
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='workspaces.get',
+        request_name=request_names.RequestName.WORKSPACES_GET,
         request_body=request_body,
         func=core.get_workspaces,
         schedule_type=api_requests.ScheduleType.SHORT,
@@ -35,9 +36,9 @@ async def get(request: fastapi.Request) -> None:
 async def update(request: fastapi.Request,
                  update_workspace_body: payloads.UpdateWorkspaceBody) -> None:
     """Updates a specific workspace configuration."""
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='workspaces.update',
+        request_name=request_names.RequestName.WORKSPACES_UPDATE,
         request_body=update_workspace_body,
         func=core.update_workspace,
         schedule_type=api_requests.ScheduleType.SHORT,
@@ -48,9 +49,9 @@ async def update(request: fastapi.Request,
 async def create(request: fastapi.Request,
                  create_workspace_body: payloads.CreateWorkspaceBody) -> None:
     """Creates a new workspace configuration."""
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='workspaces.create',
+        request_name=request_names.RequestName.WORKSPACES_CREATE,
         request_body=create_workspace_body,
         func=core.create_workspace,
         schedule_type=api_requests.ScheduleType.SHORT,
@@ -61,9 +62,9 @@ async def create(request: fastapi.Request,
 async def delete(request: fastapi.Request,
                  delete_workspace_body: payloads.DeleteWorkspaceBody) -> None:
     """Deletes a workspace configuration."""
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='workspaces.delete',
+        request_name=request_names.RequestName.WORKSPACES_DELETE,
         request_body=delete_workspace_body,
         func=core.delete_workspace,
         schedule_type=api_requests.ScheduleType.SHORT,
@@ -78,9 +79,9 @@ async def get_config(request: fastapi.Request) -> None:
         'env_vars': auth_user.to_env_vars()
     } if auth_user else {}
     get_config_body = payloads.GetConfigBody(**auth_user_env_vars_kwargs)
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='workspaces.get_config',
+        request_name=request_names.RequestName.WORKSPACES_GET_CONFIG,
         request_body=get_config_body,
         func=core.get_config,
         schedule_type=api_requests.ScheduleType.SHORT,
@@ -91,9 +92,9 @@ async def get_config(request: fastapi.Request) -> None:
 async def update_config(request: fastapi.Request,
                         update_config_body: payloads.UpdateConfigBody) -> None:
     """Updates the entire SkyPilot configuration."""
-    executor.schedule_request(
+    await executor.schedule_request_async(
         request_id=request.state.request_id,
-        request_name='workspaces.update_config',
+        request_name=request_names.RequestName.WORKSPACES_UPDATE_CONFIG,
         request_body=update_config_body,
         func=core.update_config,
         schedule_type=api_requests.ScheduleType.SHORT,