skypilot-nightly 1.0.0.dev20250718__py3-none-any.whl → 1.0.0.dev20250720__py3-none-any.whl

sky/setup_files/alembic.ini

@@ -0,0 +1,152 @@
+# alembic configuration for global user state, jobs state, and sky config db migrations.
+
+[DEFAULT]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/../schemas/db
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# database URL.  This is consumed by the user-maintained env.py script only.
+# other means of configuring database URLs may be customized within the env.py
+# file.
+# sqlalchemy.url = driver://user:pass@localhost/dbname
+
+[state_db]
+version_locations = %(here)s/../schemas/db/global_user_state
+version_table = alembic_version_state_db
+
+[spot_jobs_db]
+version_locations = %(here)s/../schemas/db/spot_jobs
+version_table = alembic_version_spot_jobs_db
+
+[sky_config_db]
+version_locations = %(here)s/../schemas/db/skypilot_config
+version_table = alembic_version_sky_config_db
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration.  This is also consumed by the user-maintained
+# env.py script only.
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = WARNING
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

sky/setup_files/dependencies.py

@@ -68,6 +68,7 @@ install_requires = [
     'pyjwt',
     'gitpython',
     'types-paramiko',
+    'alembic',
 ]
 
 server_dependencies = [

sky/skylet/configs.py

@@ -5,7 +5,7 @@ import pathlib
 import threading
 from typing import Callable, Optional, Union
 
-from sky.utils import db_utils
+from sky.utils.db import db_utils
 
 _DB_PATH = None
 _db_init_lock = threading.Lock()

sky/skylet/job_lib.py

@@ -24,10 +24,10 @@ from sky import sky_logging
 from sky.adaptors import common as adaptors_common
 from sky.skylet import constants
 from sky.utils import common_utils
-from sky.utils import db_utils
 from sky.utils import log_utils
 from sky.utils import message_utils
 from sky.utils import subprocess_utils
+from sky.utils.db import db_utils
 
 if typing.TYPE_CHECKING:
     import psutil

sky/skypilot_config.py

@@ -58,8 +58,10 @@ import threading
 import typing
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
 
+from alembic import command as alembic_command
 import filelock
 import sqlalchemy
+from sqlalchemy import exc as sqlalchemy_exc
 from sqlalchemy import orm
 from sqlalchemy.dialects import postgresql
 from sqlalchemy.dialects import sqlite
@@ -73,9 +75,10 @@ from sky.skylet import constants
 from sky.utils import common_utils
 from sky.utils import config_utils
 from sky.utils import context
-from sky.utils import db_utils
 from sky.utils import schemas
 from sky.utils import ux_utils
+from sky.utils.db import db_utils
+from sky.utils.db import migration_utils
 from sky.utils.kubernetes import config_map_utils
 
 if typing.TYPE_CHECKING:
@@ -571,11 +574,17 @@ def _reload_config_as_server() -> None:
             'if db config is specified, no other config is allowed')
 
     if db_url:
-        with _DB_USE_LOCK:
+        with migration_utils.db_lock(migration_utils.SKYPILOT_CONFIG_DB_NAME):
             sqlalchemy_engine = sqlalchemy.create_engine(db_url,
                                                          poolclass=NullPool)
-            db_utils.add_tables_to_db_sqlalchemy(Base.metadata,
-                                                 sqlalchemy_engine)
+
+            # Get alembic config for sky config db and run migrations
+            alembic_config = migration_utils.get_alembic_config(
+                sqlalchemy_engine, migration_utils.SKYPILOT_CONFIG_DB_NAME)
+            # pylint: disable=line-too-long
+            alembic_config.config_ini_section = migration_utils.SKYPILOT_CONFIG_DB_NAME
+            alembic_command.upgrade(alembic_config,
+                                    migration_utils.SKYPILOT_CONFIG_VERSION)
 
             def _get_config_yaml_from_db(
                     key: str) -> Optional[config_utils.Config]:
@@ -863,8 +872,25 @@ def update_api_server_config_no_lock(config: config_utils.Config) -> None:
             with _DB_USE_LOCK:
                 sqlalchemy_engine = sqlalchemy.create_engine(existing_db_url,
                                                              poolclass=NullPool)
-                db_utils.add_tables_to_db_sqlalchemy(Base.metadata,
-                                                     sqlalchemy_engine)
+
+                # Get alembic config for sky config db and run migrations
+                alembic_config = migration_utils.get_alembic_config(
+                    sqlalchemy_engine, 'sky_config_db')
+                alembic_config.config_ini_section = 'sky_config_db'
+                try:
+                    alembic_command.upgrade(alembic_config, '001')
+                except (sqlalchemy_exc.IntegrityError,
+                        sqlalchemy_exc.OperationalError) as e:
+                    # If the version already exists (due to concurrent
+                    # initialization), we can safely ignore this error
+                    if ('UNIQUE constraint failed: '
+                            'alembic_version_sky_config_db.version_num'
+                            in str(e) or
+                            'table alembic_version_sky_config_db already exists'
+                            in str(e)):
+                        pass
+                    else:
+                        raise
 
                 def _set_config_yaml_to_db(key: str,
                                            config: config_utils.Config):

sky/users/permission.py

@@ -15,7 +15,7 @@ from sky import sky_logging
 from sky.skylet import constants
 from sky.users import rbac
 from sky.utils import common_utils
-from sky.utils import db_utils
+from sky.utils.db import db_utils
 
 logging.getLogger('casbin.policy').setLevel(sky_logging.ERROR)
 logging.getLogger('casbin.role').setLevel(sky_logging.ERROR)

sky/utils/common_utils.py

@@ -369,6 +369,83 @@ def get_pretty_entrypoint_cmd() -> str:
     return ' '.join(argv)
 
 
+def read_last_n_lines(file_path: str,
+                      n: int,
+                      chunk_size: int = 8192,
+                      encoding: str = 'utf-8',
+                      errors: str = 'replace') -> List[str]:
+    """Read the last N lines of a file.
+
+    Args:
+        file_path: Path to the file to read.
+        n: Number of lines to read from the end of the file.
+        chunk_size: Size of chunks in bytes.
+        encoding: Encoding to use when decoding binary chunks.
+        errors: Error handling for decode errors (e.g., 'replace', 'ignore').
+
+    Returns:
+        A list of the last N lines, preserving newlines where applicable.
+    """
+
+    assert n >= 0, f'n must be non-negative. Got {n}'
+    assert chunk_size > 0, f'chunk_size must be positive. Got {chunk_size}'
+    assert os.path.exists(file_path), f'File not found: {file_path}'
+
+    if n == 0:
+        return []
+
+    try:
+        with open(file_path, 'rb') as f:
+            # Start reading from the end of the file
+            f.seek(0, os.SEEK_END)
+            file_size = f.tell()
+            if file_size == 0:
+                return []
+
+            pos = file_size
+            lines_found = 0
+            chunks = []
+
+            # Read backwards in chunks until we've found at least n newlines
+            while pos > 0 and lines_found <= n:
+                read_size = min(chunk_size, pos)
+                pos -= read_size
+                f.seek(pos)
+                chunk = f.read(read_size)
+                chunks.append(chunk)
+                lines_found += chunk.count(b'\n')
+
+            # Combine all chunks in reverse order since we read backwards
+            full_bytes = b''.join(reversed(chunks))
+
+            # Split by newline byte. Note: this handles '\n' endings.
+            all_lines = full_bytes.split(b'\n')
+
+            # Handle edge case: if file ends with a newline, last element is b''
+            if all_lines and all_lines[-1] == b'':
+                result_bytes = all_lines[-n - 1:-1]
+            else:
+                result_bytes = all_lines[-n:]
+
+            # Decode each line and normalize CR/LF endings
+            decoded_lines = [
+                line.decode(encoding, errors=errors).rstrip('\r') + '\n'
+                for line in result_bytes[:-1]
+            ]
+
+            # Decode the final line — only add newline if it was present
+            last_line = result_bytes[-1].decode(encoding,
+                                                errors=errors).rstrip('\r')
+            decoded_lines.append(last_line)
+
+            return decoded_lines
+
+    except OSError as e:
+        with ux_utils.print_exception_no_traceback():
+            raise RuntimeError(
+                f'Failed to read last {n} lines from {file_path}: {e}') from e
+
+
 def _redact_secrets_values(argv: List[str]) -> List[str]:
     """Redact sensitive values from --secret arguments.
 

sky/utils/{db_utils.py → db/db_utils.py}

@@ -9,6 +9,9 @@ from typing import Any, Callable, Optional
 import sqlalchemy
 from sqlalchemy import exc as sqlalchemy_exc
 
+from sky import sky_logging
+
+logger = sky_logging.init_logger(__name__)
 if typing.TYPE_CHECKING:
     from sqlalchemy.orm import Session
 
@@ -146,6 +149,62 @@ def add_column_to_table_sqlalchemy(
     session.commit()
 
 
+def add_column_to_table_alembic(
+    table_name: str,
+    column_name: str,
+    column_type: sqlalchemy.types.TypeEngine,
+    server_default: Optional[str] = None,
+    copy_from: Optional[str] = None,
+    value_to_replace_existing_entries: Optional[Any] = None,
+):
+    """Add a column to a table using Alembic operations.
+
+    This provides the same interface as add_column_to_table_sqlalchemy but
+    uses Alembic's connection context for proper migration support.
+
+    Args:
+        table_name: Name of the table to add column to
+        column_name: Name of the new column
+        column_type: SQLAlchemy column type
+        server_default: Server-side default value for the column
+        copy_from: Column name to copy values from (for existing rows)
+        value_to_replace_existing_entries: Default value for existing NULL
+            entries
+    """
+    from alembic import op  # pylint: disable=import-outside-toplevel
+
+    try:
+        # Create the column with server_default if provided
+        column = sqlalchemy.Column(column_name,
+                                   column_type,
+                                   server_default=server_default)
+        op.add_column(table_name, column)
+
+        # Handle data migration
+        if copy_from is not None:
+            op.execute(
+                sqlalchemy.text(
+                    f'UPDATE {table_name} SET {column_name} = {copy_from}'))
+
+        if value_to_replace_existing_entries is not None:
+            # Use parameterized query for safety
+            op.get_bind().execute(
+                sqlalchemy.text(f'UPDATE {table_name} '
+                                f'SET {column_name} = :replacement_value '
+                                f'WHERE {column_name} IS NULL'),
+                {'replacement_value': value_to_replace_existing_entries})
+    except sqlalchemy_exc.ProgrammingError as e:
+        if 'already exists' in str(e).lower():
+            pass  # Column already exists, that's fine
+        else:
+            raise
+    except sqlalchemy_exc.OperationalError as e:
+        if 'duplicate column name' in str(e).lower():
+            pass  # Column already exists, that's fine
+        else:
+            raise
+
+
 class SQLiteConn(threading.local):
     """Thread-local connection to the sqlite3 database."""
 

sky/utils/db/migration_utils.py

@@ -0,0 +1,53 @@
+"""Constants for the database schemas."""
+
+import contextlib
+import os
+
+from alembic.config import Config
+import filelock
+import sqlalchemy
+
+DB_INIT_LOCK_TIMEOUT_SECONDS = 10
+
+GLOBAL_USER_STATE_DB_NAME = 'state_db'
+GLOBAL_USER_STATE_VERSION = '001'
+GLOBAL_USER_STATE_LOCK_PATH = '~/.sky/locks/.state_db.lock'
+
+SKYPILOT_CONFIG_DB_NAME = 'skypilot_config_db'
+SKYPILOT_CONFIG_VERSION = '001'
+SKYPILOT_CONFIG_LOCK_PATH = '~/.sky/locks/.skypilot_config_db.lock'
+
+SPOT_JOBS_DB_NAME = 'spot_jobs_db'
+SPOT_JOBS_VERSION = '001'
+SPOT_JOBS_LOCK_PATH = '~/.sky/locks/.spot_jobs_db.lock'
+
+
+@contextlib.contextmanager
+def db_lock(db_name: str):
+    lock_path = os.path.expanduser(f'~/.sky/locks/.{db_name}.lock')
+    try:
+        with filelock.FileLock(lock_path, timeout=DB_INIT_LOCK_TIMEOUT_SECONDS):
+            yield
+    except filelock.Timeout as e:
+        raise RuntimeError(f'Failed to initialize database due to a timeout '
+                           f'when trying to acquire the lock at '
+                           f'{lock_path}. '
+                           'Please try again or manually remove the lock '
+                           f'file if you believe it is stale.') from e
+
+
+def get_alembic_config(engine: sqlalchemy.engine.Engine, section: str):
+    """Get Alembic configuration for the given section"""
+    # Use the alembic.ini file from setup_files (included in wheel)
+    # From sky/utils/db/migration_utils.py -> sky/setup_files/alembic.ini
+    alembic_ini_path = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.dirname(__file__))),
+        'setup_files', 'alembic.ini')
+    alembic_cfg = Config(alembic_ini_path, ini_section=section)
+
+    # Override the database URL to match SkyPilot's current connection
+    # Use render_as_string to get the full URL with password
+    url = engine.url.render_as_string(hide_password=False)
+    alembic_cfg.set_section_option(section, 'sqlalchemy.url', url)
+
+    return alembic_cfg

{skypilot_nightly-1.0.0.dev20250718.dist-info → skypilot_nightly-1.0.0.dev20250720.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skypilot-nightly
-Version: 1.0.0.dev20250718
+Version: 1.0.0.dev20250720
 Summary: SkyPilot: Run AI on Any Infra — Unified, Faster, Cheaper.
 Author: SkyPilot Team
 License: Apache 2.0
@@ -56,6 +56,7 @@ Requires-Dist: passlib
 Requires-Dist: pyjwt
 Requires-Dist: gitpython
 Requires-Dist: types-paramiko
+Requires-Dist: alembic
 Provides-Extra: aws
 Requires-Dist: awscli>=1.27.10; extra == "aws"
 Requires-Dist: botocore>=1.29.10; extra == "aws"