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

sky/provision/volume.py

@@ -0,0 +1,164 @@
+"""Volume functions for provisioning and deleting ephemeral volumes."""
+
+import copy
+from typing import Any, Dict, Optional
+
+from sky import clouds
+from sky import global_user_state
+from sky import models
+from sky import sky_logging
+from sky.provision import common as provision_common
+from sky.provision import constants as provision_constants
+from sky.provision.kubernetes import utils as kubernetes_utils
+from sky.utils import volume as volume_utils
+from sky.volumes import volume as volume_lib
+from sky.volumes.server import core as volume_server_core
+
+logger = sky_logging.init_logger(__name__)
+
+
+def _resolve_volume_type(cloud: clouds.Cloud,
+                         volume_type: Optional[str]) -> str:
+    if not volume_type:
+        volume_types = None
+        for cloud_key, vol_types in volume_lib.CLOUD_TO_VOLUME_TYPE.items():
+            if cloud.is_same_cloud(cloud_key):
+                volume_types = vol_types
+                break
+        if volume_types is None:
+            raise ValueError(f'No default volume type found for cloud {cloud}')
+        if len(volume_types) != 1:
+            raise ValueError(
+                f'Found multiple volume types for cloud {cloud}: {volume_types}'
+            )
+        return volume_types[0].value
+    supported_volume_types = [
+        volume_type.value for volume_type in volume_utils.VolumeType
+    ]
+    volume_type = volume_type.lower()
+    if volume_type not in supported_volume_types:
+        raise ValueError(
+            f'Invalid volume type: {volume_type} for cloud {cloud}')
+    return volume_type
+
+
+def _resolve_pvc_volume_config(cloud: clouds.Cloud,
+                               config: provision_common.ProvisionConfig,
+                               volume_config: Dict[str, Any]) -> Dict[str, Any]:
+    provider_config = config.provider_config
+    if not cloud.is_same_cloud(clouds.Kubernetes()):
+        raise ValueError(
+            f'PVC volume type is only supported on Kubernetes not on {cloud}')
+    supported_access_modes = [
+        access_mode.value for access_mode in volume_utils.VolumeAccessMode
+    ]
+    access_mode = volume_config.get('access_mode')
+    if access_mode is None:
+        access_mode = volume_utils.VolumeAccessMode.READ_WRITE_ONCE.value
+        volume_config['access_mode'] = access_mode
+    elif access_mode not in supported_access_modes:
+        raise ValueError(f'Invalid access mode: {access_mode} for PVC')
+    if (access_mode == volume_utils.VolumeAccessMode.READ_WRITE_ONCE.value and
+            config.count > 1):
+        raise ValueError(
+            'Access mode ReadWriteOnce is not supported for multi-node'
+            ' clusters.')
+    namespace = kubernetes_utils.get_namespace_from_config(provider_config)
+    volume_config['namespace'] = namespace
+    return volume_config
+
+
+def _create_ephemeral_volume(
+    cloud: clouds.Cloud, region: str, cluster_name_on_cloud: str,
+    config: provision_common.ProvisionConfig,
+    volume_mount: volume_utils.VolumeMount
+) -> Optional[volume_utils.VolumeInfo]:
+    provider_name = repr(cloud)
+    path = volume_mount.path
+    volume_config = volume_mount.volume_config
+    volume_type = _resolve_volume_type(cloud, volume_config.type)
+    labels = volume_config.labels
+    if volume_type == volume_utils.VolumeType.PVC.value:
+        internal_volume_config = _resolve_pvc_volume_config(
+            cloud, config, volume_config.config)
+        if labels:
+            for key, value in labels.items():
+                valid, err_msg = cloud.is_label_valid(key, value)
+                if not valid:
+                    raise ValueError(f'{err_msg}')
+        else:
+            labels = {}
+        labels.update({
+            provision_constants.TAG_SKYPILOT_CLUSTER_NAME: cluster_name_on_cloud
+        })
+    else:
+        logger.warning(f'Skipping unsupported ephemeral volume type: '
+                       f'{volume_type} for cloud {cloud}.')
+        return None
+    volume_name = volume_config.name
+    volume_server_core.volume_apply(
+        name=volume_name,
+        volume_type=volume_type,
+        cloud=provider_name,
+        region=region,
+        zone=None,
+        size=volume_config.size,
+        config=internal_volume_config,
+        labels=labels,
+        is_ephemeral=True,
+    )
+    volume = global_user_state.get_volume_by_name(volume_name)
+    if volume is None:
+        raise ValueError(f'Failed to get record for volume: {volume_name}')
+    assert 'handle' in volume, 'Volume handle is None.'
+    volume_config: models.VolumeConfig = volume['handle']
+    volume_info = volume_utils.VolumeInfo(
+        name=volume_name,
+        path=path,
+        volume_name_on_cloud=volume_config.name_on_cloud,
+        volume_id_on_cloud=volume_config.id_on_cloud,
+    )
+    return volume_info
+
+
+def provision_ephemeral_volumes(
+    cloud: clouds.Cloud,
+    region: str,
+    cluster_name_on_cloud: str,
+    config: provision_common.ProvisionConfig,
+) -> None:
+    """Provision ephemeral volumes for a cluster."""
+    provider_config = config.provider_config
+    ephemeral_volume_mounts = provider_config.get('ephemeral_volume_specs')
+    if not ephemeral_volume_mounts:
+        return
+    volume_infos = []
+    try:
+        for ephemeral_volume_mount in ephemeral_volume_mounts:
+            mount_copy = copy.deepcopy(ephemeral_volume_mount)
+            volume_mount = volume_utils.VolumeMount.from_yaml_config(mount_copy)
+            volume_info = _create_ephemeral_volume(cloud, region,
+                                                   cluster_name_on_cloud,
+                                                   config, volume_mount)
+            if volume_info is None:
+                continue
+            volume_infos.append(volume_info)
+        provider_config['ephemeral_volume_infos'] = volume_infos
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logger.error(f'Failed to provision ephemeral volumes: {e}')
+        raise e
+
+
+def delete_ephemeral_volumes(provider_config: Dict[str, Any],) -> None:
+    """Provision ephemeral volumes for a cluster."""
+    ephemeral_volume_mounts = provider_config.get('ephemeral_volume_specs')
+    if not ephemeral_volume_mounts:
+        return
+    ephemeral_volume_names = []
+    for ephemeral_volume_mount in ephemeral_volume_mounts:
+        mount_copy = copy.deepcopy(ephemeral_volume_mount)
+        volume_mount = volume_utils.VolumeMount.from_yaml_config(mount_copy)
+        volume_name = volume_mount.volume_config.name
+        ephemeral_volume_names.append(volume_name)
+    volume_server_core.volume_delete(names=ephemeral_volume_names,
+                                     ignore_not_found=True)

sky/provision/vsphere/common/ssl_helper.py

@@ -30,5 +30,5 @@ def get_unverified_session():
     """
     session = requests.session()
     session.verify = False
-    requests.packages.urllib3.disable_warnings()
+    requests.packages.urllib3.disable_warnings()  # type: ignore[attr-defined]
     return session

sky/provision/vsphere/common/vapiconnect.py

@@ -89,5 +89,6 @@ def create_unverified_session(session, suppress_warning=True):
     session.verify = False
     if suppress_warning:
         # Suppress unverified https request warnings
-        requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+        requests.packages.urllib3.disable_warnings(  # type: ignore
+            InsecureRequestWarning)
     return session

sky/provision/vsphere/common/vim_utils.py

@@ -4,7 +4,7 @@
 import re
 import subprocess
 import time
-from typing import List
+from typing import List, Union
 
 from sky import sky_logging
 from sky.adaptors import vsphere as vsphere_adaptor
@@ -15,7 +15,8 @@ DISPLAY_CONTROLLER_CLASS_ID_PREFIXES = ['03']
 VMWARE_VIRTUAL_DISPLAY_CONTROLLER_IDS = ['0000:00:0f.0']
 
 
-def get_objs_by_names(content, vimtype: type, names: List[str]):
+def get_objs_by_names(content, vimtype: Union[type, List[type]],
+                      names: List[str]):
     """    Get the vsphere managed object associated with a given text name
     """
     # Create a set for the names for faster lookups

sky/provision/vsphere/instance.py

@@ -30,9 +30,10 @@ HEAD_NODE_VALUE = '1'
 WORKER_NODE_VALUE = '0'
 
 
-def run_instances(region: str, cluster_name: str,
+def run_instances(region: str, cluster_name: str, cluster_name_on_cloud: str,
                   config: common.ProvisionConfig) -> common.ProvisionRecord:
     """See sky/provision/__init__.py"""
+    del cluster_name  # unused
     logger.info('New provision of Vsphere: run_instances().')
 
     resumed_instance_ids: List[str] = []
@@ -40,7 +41,7 @@ def run_instances(region: str, cluster_name: str,
     vc_object = _get_vc_object(region)
     vc_object.connect()
 
-    exist_instances = _get_filtered_instance(vc_object, cluster_name,
+    exist_instances = _get_filtered_instance(vc_object, cluster_name_on_cloud,
                                              config.provider_config)
     head_instance_id = _get_head_instance_id(exist_instances)
 
@@ -89,8 +90,8 @@ def run_instances(region: str, cluster_name: str,
             config, region, vc_object)
         # TODO: update logic for multi-node creation
         for _ in range(to_start_num):
-            created_instance_uuid = _create_instances(cluster_name, config,
-                                                      region, vc_object,
+            created_instance_uuid = _create_instances(cluster_name_on_cloud,
+                                                      config, region, vc_object,
                                                       vsphere_cluster_name)
             created_instance_ids.append(created_instance_uuid)
         if head_instance_id is None:
@@ -104,7 +105,7 @@ def run_instances(region: str, cluster_name: str,
         provider_name='vsphere',
         region=region,
         zone=vsphere_cluster_name,
-        cluster_name=cluster_name,
+        cluster_name=cluster_name_on_cloud,
         head_instance_id=head_instance_id,
         resumed_instance_ids=resumed_instance_ids,
         created_instance_ids=created_instance_ids,
@@ -397,9 +398,10 @@ def query_instances(
     cluster_name_on_cloud: str,
     provider_config: Optional[Dict[str, Any]] = None,
     non_terminated_only: bool = True,
+    retry_if_missing: bool = False,
 ) -> Dict[str, Tuple[Optional['status_lib.ClusterStatus'], Optional[str]]]:
     """See sky/provision/__init__.py"""
-    del cluster_name  # unused
+    del cluster_name, retry_if_missing  # unused
     logger.info('New provision of Vsphere: query_instances().')
     assert provider_config is not None, cluster_name_on_cloud
     region = provider_config['region']

sky/provision/vsphere/vsphere_utils.py

@@ -262,6 +262,10 @@ class VsphereClient:
 
     def get_pbm_manager(self):
         self.connect()
+        if self.servicemanager is None:
+            raise VsphereError('Failed to connect to vSphere.')
+        if self.servicemanager.si is None:
+            raise VsphereError('Failed to connect to vSphere.')
         pbm_si, pm_content = self._create_pbm_connection(  # pylint: disable=unused-variable
             self.servicemanager.si._stub)  # pylint: disable=protected-access
         pm = pm_content.profileManager
@@ -360,6 +364,8 @@ def initialize_vsphere_data():
         vcenter_name = vcenter['name']
         vc_object.connect()
         vc_servicemanager = vc_object.servicemanager
+        if vc_servicemanager is None or vc_servicemanager.content is None:
+            raise VsphereError('Failed to connect to vSphere.')
         vc_content = vc_servicemanager.content
 
         cluster_name_dicts = vc_object.clusters
@@ -370,4 +376,5 @@ def initialize_vsphere_data():
         initialize_images_csv(images_csv_path, vc_object, vcenter_name)
         initialize_instance_image_mapping_csv(vms_csv_path, images_csv_path,
                                               instance_image_mapping_csv_path)
-        vc_object.servicemanager.disconnect()
+        if vc_object.servicemanager is not None:
+            vc_object.servicemanager.disconnect()

sky/resources.py

@@ -1104,7 +1104,7 @@ class Resources:
         regions = self.cloud.regions_with_offering(self._instance_type,
                                                    self.accelerators,
                                                    self._use_spot, self._region,
-                                                   self._zone)
+                                                   self._zone, self)
         if self._image_id is not None and None not in self._image_id:
             regions = [r for r in regions if r.name in self._image_id]
 
@@ -1331,10 +1331,18 @@ class Resources:
                     clouds.CloudImplementationFeatures.IMAGE_ID
                 })
         except exceptions.NotSupportedError as e:
+            # Provide a more helpful error message for Lambda cloud
+            if self.cloud.is_same_cloud(clouds.Lambda()):
+                with ux_utils.print_exception_no_traceback():
+                    raise ValueError(
+                        'Lambda cloud only supports Docker images. '
+                        'Please prefix your image with "docker:" '
+                        '(e.g., image_id: docker:your-image-name).') from e
             with ux_utils.print_exception_no_traceback():
                 raise ValueError(
                     'image_id is only supported for AWS/GCP/Azure/IBM/OCI/'
-                    'Kubernetes, please explicitly specify the cloud.') from e
+                    'Kubernetes. For Lambda cloud, use "docker:" prefix for '
+                    'Docker images.') from e
 
         if self._region is not None:
             # If the image_id has None as key (region-agnostic),
@@ -1516,7 +1524,7 @@ class Resources:
         if self.accelerators is not None:
             hourly_cost += self.cloud.accelerators_to_hourly_cost(
                 self.accelerators, self.use_spot, self._region, self._zone)
-        return hourly_cost * hours
+        return float(hourly_cost * hours)
 
     def get_accelerators_str(self) -> str:
         accelerators = self.accelerators

sky/schemas/api/responses.py

@@ -5,8 +5,11 @@ from typing import Any, Dict, List, Optional
 
 import pydantic
 
+from sky import data
 from sky import models
+from sky.jobs import state as job_state
 from sky.server import common
+from sky.skylet import job_lib
 from sky.utils import status_lib
 
 
@@ -74,8 +77,13 @@ class APIHealthResponse(ResponseBaseModel):
     version: str = ''
     version_on_disk: str = ''
     commit: str = ''
+    # Whether basic auth on api server is enabled
     basic_auth_enabled: bool = False
     user: Optional[models.User] = None
+    # Whether service account token is enabled
+    service_account_token_enabled: bool = False
+    # Whether basic auth on ingress is enabled
+    ingress_basic_auth_enabled: bool = False
 
 
 class StatusResponse(ResponseBaseModel):
@@ -86,8 +94,8 @@ class StatusResponse(ResponseBaseModel):
     # backends.ResourceHandle, so we use Any here.
     # This is an internally facing field anyway, so it's less
     # of a problem that it's not typed.
-    handle: Any
-    last_use: str
+    handle: Optional[Any] = None
+    last_use: Optional[str] = None
     status: status_lib.ClusterStatus
     autostop: int
     to_down: bool
@@ -95,11 +103,8 @@ class StatusResponse(ResponseBaseModel):
     # metadata is a JSON, so we use Any here.
     metadata: Optional[Dict[str, Any]] = None
     cluster_hash: str
-    # pydantic cannot generate the pydantic-core schema for
-    # storage_mounts_metadata, so we use Any here.
-    storage_mounts_metadata: Optional[Dict[str, Any]] = None
     cluster_ever_up: bool
-    status_updated_at: int
+    status_updated_at: Optional[int] = None
     user_hash: str
     user_name: str
     config_hash: Optional[str] = None
@@ -118,9 +123,105 @@ class StatusResponse(ResponseBaseModel):
     cpus: Optional[str] = None
     memory: Optional[str] = None
     accelerators: Optional[str] = None
+    cluster_name_on_cloud: Optional[str] = None
+
+
+class ClusterJobRecord(ResponseBaseModel):
+    """Response for the cluster job queue endpoint."""
+    job_id: int
+    job_name: str
+    username: str
+    user_hash: str
+    submitted_at: float
+    # None if the job has not started yet.
+    start_at: Optional[float] = None
+    # None if the job has not ended yet.
+    end_at: Optional[float] = None
+    resources: str
+    status: job_lib.JobStatus
+    log_path: str
+    metadata: Dict[str, Any] = {}
 
 
 class UploadStatus(enum.Enum):
     """Status of the upload."""
     UPLOADING = 'uploading'
     COMPLETED = 'completed'
+
+
+class StorageRecord(ResponseBaseModel):
+    """Response for the storage list endpoint."""
+    name: str
+    launched_at: int
+    store: List[data.StoreType]
+    last_use: str
+    status: status_lib.StorageStatus
+
+
+# TODO (syang) figure out which fields are always present
+# and therefore can be non-optional.
+class ManagedJobRecord(ResponseBaseModel):
+    """A single managed job record."""
+    # The job_id in the spot table
+    task_job_id: Optional[int] = pydantic.Field(None, alias='_job_id')
+    job_id: Optional[int] = None
+    task_id: Optional[int] = None
+    job_name: Optional[str] = None
+    task_name: Optional[str] = None
+    job_duration: Optional[float] = None
+    workspace: Optional[str] = None
+    status: Optional[job_state.ManagedJobStatus] = None
+    schedule_state: Optional[str] = None
+    resources: Optional[str] = None
+    cluster_resources: Optional[str] = None
+    cluster_resources_full: Optional[str] = None
+    cloud: Optional[str] = None
+    region: Optional[str] = None
+    zone: Optional[str] = None
+    infra: Optional[str] = None
+    recovery_count: Optional[int] = None
+    details: Optional[str] = None
+    failure_reason: Optional[str] = None
+    user_name: Optional[str] = None
+    user_hash: Optional[str] = None
+    submitted_at: Optional[float] = None
+    start_at: Optional[float] = None
+    end_at: Optional[float] = None
+    user_yaml: Optional[str] = None
+    entrypoint: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    controller_pid: Optional[int] = None
+    controller_pid_started_at: Optional[float] = None
+    dag_yaml_path: Optional[str] = None
+    env_file_path: Optional[str] = None
+    last_recovered_at: Optional[float] = None
+    run_timestamp: Optional[str] = None
+    priority: Optional[int] = None
+    original_user_yaml_path: Optional[str] = None
+    pool: Optional[str] = None
+    pool_hash: Optional[str] = None
+    current_cluster_name: Optional[str] = None
+    job_id_on_pool_cluster: Optional[int] = None
+    accelerators: Optional[Dict[str, int]] = None
+
+
+class VolumeRecord(ResponseBaseModel):
+    """A single volume record."""
+    name: str
+    type: str
+    launched_at: int
+    cloud: str
+    region: Optional[str] = None
+    zone: Optional[str] = None
+    size: Optional[str] = None
+    config: Dict[str, Any]
+    name_on_cloud: str
+    user_hash: str
+    user_name: str
+    workspace: str
+    last_attached_at: Optional[int] = None
+    last_use: Optional[str] = None
+    status: Optional[str] = None
+    usedby_pods: List[str]
+    usedby_clusters: List[str]
+    is_ephemeral: bool = False

sky/schemas/db/global_user_state/008_skylet_ssh_tunnel_metadata.py

@@ -0,0 +1,34 @@
+"""Add skylet_ssh_tunnel_metadata to clusters.
+
+Revision ID: 008
+Revises: 007
+Create Date: 2025-09-09
+
+"""
+# pylint: disable=invalid-name
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+from sky.utils.db import db_utils
+
+# revision identifiers, used by Alembic.
+revision: str = '008'
+down_revision: Union[str, Sequence[str], None] = '007'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade():
+    """Add skylet_ssh_tunnel_metadata column to clusters."""
+    with op.get_context().autocommit_block():
+        db_utils.add_column_to_table_alembic('clusters',
+                                             'skylet_ssh_tunnel_metadata',
+                                             sa.LargeBinary(),
+                                             server_default=None)
+
+
+def downgrade():
+    """No-op for backward compatibility."""
+    pass

sky/schemas/db/global_user_state/009_last_activity_and_launched_at.py

@@ -0,0 +1,89 @@
+"""Add last_activity_time and launched_at to cluster history.
+
+Revision ID: 009
+Revises: 008
+Create Date: 2025-09-24
+
+"""
+# pylint: disable=invalid-name
+import pickle
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+from sky.utils.db import db_utils
+
+# revision identifiers, used by Alembic.
+revision: str = '009'
+down_revision: Union[str, Sequence[str], None] = '008'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade():
+    """Add last_activity_time and launched_at columns to cluster history."""
+    with op.get_context().autocommit_block():
+        # Add the columns with indices
+        db_utils.add_column_to_table_alembic('cluster_history',
+                                             'last_activity_time',
+                                             sa.Integer(),
+                                             server_default=None,
+                                             index=True)
+
+        db_utils.add_column_to_table_alembic('cluster_history',
+                                             'launched_at',
+                                             sa.Integer(),
+                                             server_default=None,
+                                             index=True)
+
+        # Populate the columns for existing rows
+        _populate_cluster_history_columns()
+
+
+def _populate_cluster_history_columns():
+    """Populate last_activity_time and launched_at for existing rows using
+    usage_intervals logic."""
+    connection = op.get_bind()
+
+    # Get all existing rows with usage_intervals
+    result = connection.execute(
+        sa.text('SELECT cluster_hash, usage_intervals FROM cluster_history '
+                'WHERE usage_intervals IS NOT NULL'))
+
+    for row in result:
+        cluster_hash = row[0]
+        usage_intervals_blob = row[1]
+
+        try:
+            # Deserialize the usage_intervals
+            usage_intervals = pickle.loads(usage_intervals_blob)
+
+            if usage_intervals:
+                # Calculate last_activity_time: end time of last interval
+                # or start time if still running
+                last_interval = usage_intervals[-1]
+                last_activity_time = (last_interval[1] if last_interval[1]
+                                      is not None else last_interval[0])
+
+                # Calculate launched_at: start time of first interval
+                launched_at = usage_intervals[0][0]
+
+                # Update the row with both calculated values
+                connection.execute(
+                    sa.text('UPDATE cluster_history '
+                            'SET last_activity_time = :last_activity_time, '
+                            'launched_at = :launched_at '
+                            'WHERE cluster_hash = :cluster_hash'), {
+                                'last_activity_time': last_activity_time,
+                                'launched_at': launched_at,
+                                'cluster_hash': cluster_hash
+                            })
+        except (pickle.PickleError, AttributeError, IndexError):
+            # Skip rows with corrupted or invalid usage_intervals
+            continue
+
+
+def downgrade():
+    """No-op for backward compatibility."""
+    pass

sky/schemas/db/global_user_state/010_save_ssh_key.py

@@ -0,0 +1,66 @@
+"""Add ssh keys in filesystem to global user state.
+
+Revision ID: 010
+Revises: 009
+Create Date: 2025-10-07
+
+"""
+import glob
+# pylint: disable=invalid-name
+import os
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = '010'
+down_revision: Union[str, Sequence[str], None] = '009'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade():
+    """Add last_activity_time and launched_at columns to cluster history."""
+    connection = op.get_bind()
+
+    match_dirs = glob.glob(os.path.expanduser('~/.sky/clients/*/ssh'))
+    file_user_hashes = set()
+    for match_dir in match_dirs:
+        user_hash = match_dir.split('/')[-2]
+        file_user_hashes.add(user_hash)
+
+    # Get all existing ssh keys
+    existing_user_hashes = set()
+    result = connection.execute(sa.text('SELECT user_hash FROM ssh_key'))
+    for row in result:
+        existing_user_hashes.add(row[0])
+
+    user_hashes_to_add = file_user_hashes - existing_user_hashes
+    for user_hash in user_hashes_to_add:
+        match_dir = os.path.join(os.path.expanduser('~/.sky/clients'),
+                                 user_hash, 'ssh')
+        public_key_path = os.path.join(match_dir, 'sky-key.pub')
+        private_key_path = os.path.join(match_dir, 'sky-key')
+        try:
+            with open(public_key_path, 'r', encoding='utf-8') as f:
+                public_key = f.read().strip()
+            with open(private_key_path, 'r', encoding='utf-8') as f:
+                private_key = f.read().strip()
+        except FileNotFoundError:
+            # Skip if the key files are not found
+            continue
+        connection.execute(
+            sa.text('INSERT INTO ssh_key '
+                    '(user_hash, ssh_public_key, ssh_private_key) '
+                    'VALUES (:user_hash, :ssh_public_key, :ssh_private_key) '
+                    'ON CONFLICT DO NOTHING'), {
+                        'user_hash': user_hash,
+                        'ssh_public_key': public_key,
+                        'ssh_private_key': private_key
+                    })
+
+
+def downgrade():
+    """No-op for backward compatibility."""
+    pass