mlrun 1.3.3rc1__py3-none-any.whl → 1.4.0__py3-none-any.whl

mlrun/api/db/sqldb/models/models_sqlite.py

@@ -1,4 +1,4 @@
-# Copyright 2019 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -31,9 +31,10 @@ from sqlalchemy import (
     UniqueConstraint,
 )
 from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import class_mapper, relationship
+from sqlalchemy.orm import relationship
 
-from mlrun.api import schemas
+import mlrun.common.schemas
+import mlrun.utils.db
 from mlrun.api.utils.db.sql_collation import SQLCollationUtil
 
 Base = declarative_base()
@@ -41,42 +42,8 @@ NULL = None  # Avoid flake8 issuing warnings when comparing in filter
 run_time_fmt = "%Y-%m-%dT%H:%M:%S.%fZ"
 
 
-class BaseModel:
-    def to_dict(self, exclude=None):
-        """
-        NOTE - this function (currently) does not handle serializing relationships
-        """
-        exclude = exclude or []
-        mapper = class_mapper(self.__class__)
-        columns = [column.key for column in mapper.columns if column.key not in exclude]
-        get_key_value = (
-            lambda c: (c, getattr(self, c).isoformat())
-            if isinstance(getattr(self, c), datetime)
-            else (c, getattr(self, c))
-        )
-        return dict(map(get_key_value, columns))
-
-
-class HasStruct(BaseModel):
-    @property
-    def struct(self):
-        return pickle.loads(self.body)
-
-    @struct.setter
-    def struct(self, value):
-        self.body = pickle.dumps(value)
-
-    def to_dict(self, exclude=None):
-        """
-        NOTE - this function (currently) does not handle serializing relationships
-        """
-        exclude = exclude or []
-        exclude.append("body")
-        return super().to_dict(exclude)
-
-
 def make_label(table):
-    class Label(Base, BaseModel):
+    class Label(Base, mlrun.utils.db.BaseModel):
         __tablename__ = f"{table}_labels"
         __table_args__ = (
             UniqueConstraint("name", "parent", name=f"_{table}_labels_uc"),
@@ -91,7 +58,7 @@ def make_label(table):
 
 
 def make_tag(table):
-    class Tag(Base, BaseModel):
+    class Tag(Base, mlrun.utils.db.BaseModel):
         __tablename__ = f"{table}_tags"
         __table_args__ = (
             UniqueConstraint("project", "name", "obj_id", name=f"_{table}_tags_uc"),
@@ -108,7 +75,7 @@ def make_tag(table):
 # TODO: don't want to refactor everything in one PR so splitting this function to 2 versions - eventually only this one
 #  should be used
 def make_tag_v2(table):
-    class Tag(Base, BaseModel):
+    class Tag(Base, mlrun.utils.db.BaseModel):
         __tablename__ = f"{table}_tags"
         __table_args__ = (
             UniqueConstraint("project", "name", "obj_name", name=f"_{table}_tags_uc"),
@@ -126,11 +93,51 @@ def make_tag_v2(table):
     return Tag
 
 
+def make_notification(table):
+    class Notification(Base, mlrun.utils.db.BaseModel):
+        __tablename__ = f"{table}_notifications"
+        __table_args__ = (
+            UniqueConstraint("name", "parent_id", name=f"_{table}_notifications_uc"),
+        )
+
+        id = Column(Integer, primary_key=True)
+        project = Column(String(255, collation=SQLCollationUtil.collation()))
+        name = Column(
+            String(255, collation=SQLCollationUtil.collation()), nullable=False
+        )
+        kind = Column(
+            String(255, collation=SQLCollationUtil.collation()), nullable=False
+        )
+        message = Column(
+            String(255, collation=SQLCollationUtil.collation()), nullable=False
+        )
+        severity = Column(
+            String(255, collation=SQLCollationUtil.collation()), nullable=False
+        )
+        when = Column(
+            String(255, collation=SQLCollationUtil.collation()), nullable=False
+        )
+        condition = Column(
+            String(255, collation=SQLCollationUtil.collation()), nullable=False
+        )
+        params = Column("params", JSON)
+        parent_id = Column(Integer, ForeignKey(f"{table}.id"))
+        sent_time = Column(
+            TIMESTAMP(),
+            nullable=True,
+        )
+        status = Column(
+            String(255, collation=SQLCollationUtil.collation()), nullable=False
+        )
+
+    return Notification
+
+
 # quell SQLAlchemy warnings on duplicate class name (Label)
 with warnings.catch_warnings():
     warnings.simplefilter("ignore")
 
-    class Artifact(Base, HasStruct):
+    class Artifact(Base, mlrun.utils.db.HasStruct):
         __tablename__ = "artifacts"
         __table_args__ = (
             UniqueConstraint("uid", "project", "key", name="_artifacts_uc"),
@@ -144,14 +151,14 @@ with warnings.catch_warnings():
         project = Column(String(255, collation=SQLCollationUtil.collation()))
         uid = Column(String(255, collation=SQLCollationUtil.collation()))
         updated = Column(TIMESTAMP)
-        # TODO: change to JSON, see mlrun/api/schemas/function.py::FunctionState for reasoning
+        # TODO: change to JSON, see mlrun/common/schemas/function.py::FunctionState for reasoning
         body = Column(BLOB)
         labels = relationship(Label)
 
         def get_identifier_string(self) -> str:
             return f"{self.project}/{self.key}/{self.uid}"
 
-    class Function(Base, HasStruct):
+    class Function(Base, mlrun.utils.db.HasStruct):
         __tablename__ = "functions"
         __table_args__ = (
             UniqueConstraint("name", "project", "uid", name="_functions_uc"),
@@ -164,7 +171,7 @@ with warnings.catch_warnings():
         name = Column(String(255, collation=SQLCollationUtil.collation()))
         project = Column(String(255, collation=SQLCollationUtil.collation()))
         uid = Column(String(255, collation=SQLCollationUtil.collation()))
-        # TODO: change to JSON, see mlrun/api/schemas/function.py::FunctionState for reasoning
+        # TODO: change to JSON, see mlrun/common/schemas/function.py::FunctionState for reasoning
         body = Column(BLOB)
         updated = Column(TIMESTAMP)
         labels = relationship(Label)
@@ -172,19 +179,19 @@ with warnings.catch_warnings():
         def get_identifier_string(self) -> str:
             return f"{self.project}/{self.name}/{self.uid}"
 
-    class Log(Base, BaseModel):
+    class Log(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "logs"
 
         id = Column(Integer, primary_key=True)
         uid = Column(String(255, collation=SQLCollationUtil.collation()))
         project = Column(String(255, collation=SQLCollationUtil.collation()))
-        # TODO: change to JSON, see mlrun/api/schemas/function.py::FunctionState for reasoning
+        # TODO: change to JSON, see mlrun/common/schemas/function.py::FunctionState for reasoning
         body = Column(BLOB)
 
         def get_identifier_string(self) -> str:
             return f"{self.project}/{self.uid}"
 
-    class Run(Base, HasStruct):
+    class Run(Base, mlrun.utils.db.HasStruct):
         __tablename__ = "runs"
         __table_args__ = (
             UniqueConstraint("uid", "project", "iteration", name="_runs_uc"),
@@ -192,6 +199,7 @@ with warnings.catch_warnings():
 
         Label = make_label(__tablename__)
         Tag = make_tag(__tablename__)
+        Notification = make_notification(__tablename__)
 
         id = Column(Integer, primary_key=True)
         uid = Column(String(255, collation=SQLCollationUtil.collation()))
@@ -201,7 +209,7 @@ with warnings.catch_warnings():
         )
         iteration = Column(Integer)
         state = Column(String(255, collation=SQLCollationUtil.collation()))
-        # TODO: change to JSON, see mlrun/api/schemas/function.py::FunctionState for reasoning
+        # TODO: change to JSON, see mlrun/common/schemas/function.py::FunctionState for reasoning
         body = Column(BLOB)
         start_time = Column(TIMESTAMP)
         # requested logs column indicates whether logs were requested for this run
@@ -211,11 +219,12 @@ with warnings.catch_warnings():
         requested_logs = Column(BOOLEAN)
         updated = Column(TIMESTAMP, default=datetime.utcnow)
         labels = relationship(Label)
+        notifications = relationship(Notification, cascade="all, delete-orphan")
 
         def get_identifier_string(self) -> str:
             return f"{self.project}/{self.uid}/{self.iteration}"
 
-    class BackgroundTask(Base, BaseModel):
+    class BackgroundTask(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "background_tasks"
         __table_args__ = (
             UniqueConstraint("name", "project", name="_background_tasks_uc"),
@@ -233,7 +242,7 @@ with warnings.catch_warnings():
         state = Column(String(255, collation=SQLCollationUtil.collation()))
         timeout = Column(Integer)
 
-    class Schedule(Base, BaseModel):
+    class Schedule(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "schedules_v2"
         __table_args__ = (UniqueConstraint("project", "name", name="_schedules_v2_uc"),)
 
@@ -252,7 +261,7 @@ with warnings.catch_warnings():
         creation_time = Column(TIMESTAMP)
         cron_trigger_str = Column(String(255, collation=SQLCollationUtil.collation()))
         last_run_uri = Column(String(255, collation=SQLCollationUtil.collation()))
-        # TODO: change to JSON, see mlrun/api/schemas/function.py::FunctionState for reasoning
+        # TODO: change to JSON, see mlrun/common/schemas/function.py::FunctionState for reasoning
         struct = Column(BLOB)
         labels = relationship(Label, cascade="all, delete-orphan")
         concurrency_limit = Column(Integer, nullable=False)
@@ -270,11 +279,11 @@ with warnings.catch_warnings():
             self.struct = pickle.dumps(value)
 
         @property
-        def cron_trigger(self) -> schemas.ScheduleCronTrigger:
+        def cron_trigger(self) -> mlrun.common.schemas.ScheduleCronTrigger:
             return orjson.loads(self.cron_trigger_str)
 
         @cron_trigger.setter
-        def cron_trigger(self, trigger: schemas.ScheduleCronTrigger):
+        def cron_trigger(self, trigger: mlrun.common.schemas.ScheduleCronTrigger):
             self.cron_trigger_str = orjson.dumps(trigger.dict(exclude_unset=True))
 
     # Define "many to many" users/projects
@@ -285,14 +294,14 @@ with warnings.catch_warnings():
         Column("user_id", Integer, ForeignKey("users.id")),
     )
 
-    class User(Base, BaseModel):
+    class User(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "users"
         __table_args__ = (UniqueConstraint("name", name="_users_uc"),)
 
         id = Column(Integer, primary_key=True)
         name = Column(String(255, collation=SQLCollationUtil.collation()))
 
-    class Project(Base, BaseModel):
+    class Project(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "projects"
         # For now since we use project name a lot
         __table_args__ = (UniqueConstraint("name", name="_projects_uc"),)
@@ -304,7 +313,7 @@ with warnings.catch_warnings():
         source = Column(String(255, collation=SQLCollationUtil.collation()))
         # the attribute name used to be _spec which is just a wrong naming, the attribute was renamed to _full_object
         # leaving the column as is to prevent redundant migration
-        # TODO: change to JSON, see mlrun/api/schemas/function.py::FunctionState for reasoning
+        # TODO: change to JSON, see mlrun/common/schemas/function.py::FunctionState for reasoning
         _full_object = Column("spec", BLOB)
         created = Column(TIMESTAMP, default=datetime.utcnow)
         state = Column(String(255, collation=SQLCollationUtil.collation()))
@@ -326,7 +335,7 @@ with warnings.catch_warnings():
         def full_object(self, value):
             self._full_object = pickle.dumps(value)
 
-    class Feature(Base, BaseModel):
+    class Feature(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "features"
         id = Column(Integer, primary_key=True)
         feature_set_id = Column(Integer, ForeignKey("feature_sets.id"))
@@ -340,7 +349,7 @@ with warnings.catch_warnings():
         def get_identifier_string(self) -> str:
             return f"{self.project}/{self.name}"
 
-    class Entity(Base, BaseModel):
+    class Entity(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "entities"
         id = Column(Integer, primary_key=True)
         feature_set_id = Column(Integer, ForeignKey("feature_sets.id"))
@@ -354,7 +363,7 @@ with warnings.catch_warnings():
         def get_identifier_string(self) -> str:
             return f"{self.project}/{self.name}"
 
-    class FeatureSet(Base, BaseModel):
+    class FeatureSet(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "feature_sets"
         __table_args__ = (
             UniqueConstraint("name", "project", "uid", name="_feature_set_uc"),
@@ -390,7 +399,7 @@ with warnings.catch_warnings():
         def full_object(self, value):
             self._full_object = json.dumps(value, default=str)
 
-    class FeatureVector(Base, BaseModel):
+    class FeatureVector(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "feature_vectors"
         __table_args__ = (
             UniqueConstraint("name", "project", "uid", name="_feature_vectors_uc"),
@@ -423,9 +432,9 @@ with warnings.catch_warnings():
         def full_object(self, value):
             self._full_object = json.dumps(value, default=str)
 
-    class MarketplaceSource(Base, BaseModel):
-        __tablename__ = "marketplace_sources"
-        __table_args__ = (UniqueConstraint("name", name="_marketplace_sources_uc"),)
+    class HubSource(Base, mlrun.utils.db.BaseModel):
+        __tablename__ = "hub_sources"
+        __table_args__ = (UniqueConstraint("name", name="_hub_sources_uc"),)
 
         id = Column(Integer, primary_key=True)
         name = Column(String(255, collation=SQLCollationUtil.collation()))
@@ -447,7 +456,7 @@ with warnings.catch_warnings():
         def full_object(self, value):
             self._full_object = json.dumps(value, default=str)
 
-    class DataVersion(Base, BaseModel):
+    class DataVersion(Base, mlrun.utils.db.BaseModel):
         __tablename__ = "data_versions"
         __table_args__ = (UniqueConstraint("version", name="_versions_uc"),)
 
@@ -459,5 +468,8 @@ with warnings.catch_warnings():
 # Must be after all table definitions
 _tagged = [cls for cls in Base.__subclasses__() if hasattr(cls, "Tag")]
 _labeled = [cls for cls in Base.__subclasses__() if hasattr(cls, "Label")]
+_with_notifications = [
+    cls for cls in Base.__subclasses__() if hasattr(cls, "Notification")
+]
 _classes = [cls for cls in Base.__subclasses__()]
 _table2cls = {cls.__table__.name: cls for cls in Base.__subclasses__()}

mlrun/api/db/sqldb/session.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,6 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
+import typing
+
 from sqlalchemy import create_engine
 from sqlalchemy.engine import Engine
 from sqlalchemy.orm import Session
@@ -19,35 +22,38 @@ from sqlalchemy.orm import sessionmaker as SessionMaker
 
 from mlrun.config import config
 
-engine: Engine = None
-_session_maker: SessionMaker = None
+# TODO: wrap the following functions in a singleton class
+_engines: typing.Dict[str, Engine] = {}
+_session_makers: typing.Dict[str, SessionMaker] = {}
 
 
 # doing lazy load to allow tests to initialize the engine
-def get_engine() -> Engine:
-    global engine
-    if engine is None:
-        _init_engine()
-    return engine
+def get_engine(dsn=None) -> Engine:
+    global _engines
+    dsn = dsn or config.httpdb.dsn
+    if dsn not in _engines:
+        _init_engine(dsn=dsn)
+    return _engines[dsn]
 
 
-def create_session() -> Session:
-    session_maker = _get_session_maker()
+def create_session(dsn=None) -> Session:
+    session_maker = _get_session_maker(dsn=dsn)
     return session_maker()
 
 
 # doing lazy load to allow tests to initialize the engine
-def _get_session_maker() -> SessionMaker:
-    global _session_maker
-    if _session_maker is None:
-        _init_session_maker()
-    return _session_maker
+def _get_session_maker(dsn) -> SessionMaker:
+    global _session_makers
+    dsn = dsn or config.httpdb.dsn
+    if dsn not in _session_makers:
+        _init_session_maker(dsn=dsn)
+    return _session_makers[dsn]
 
 
 # TODO: we accept the dsn here to enable tests to override it, the "right" thing will be that config will be easily
 #  overridable by tests (today when you import the config it is already being initialized.. should be lazy load)
 def _init_engine(dsn=None):
-    global engine
+    global _engines
     dsn = dsn or config.httpdb.dsn
     kwargs = {}
     if "mysql" in dsn:
@@ -62,9 +68,10 @@ def _init_engine(dsn=None):
             "max_overflow": max_overflow,
         }
     engine = create_engine(dsn, **kwargs)
-    _init_session_maker()
+    _engines[dsn] = engine
+    _init_session_maker(dsn=dsn)
 
 
-def _init_session_maker():
-    global _session_maker
-    _session_maker = SessionMaker(bind=get_engine())
+def _init_session_maker(dsn):
+    global _session_makers
+    _session_makers[dsn] = SessionMaker(bind=get_engine(dsn=dsn))

mlrun/api/initial_data.py

@@ -1,4 +1,4 @@
-# Copyright 2018 Iguazio
+# Copyright 2023 Iguazio
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@ import pathlib
 import typing
 
 import dateutil.parser
+import pydantic.error_wrappers
 import pymysql.err
 import sqlalchemy.exc
 import sqlalchemy.orm
@@ -26,12 +27,12 @@ import sqlalchemy.orm
 import mlrun.api.db.sqldb.db
 import mlrun.api.db.sqldb.helpers
 import mlrun.api.db.sqldb.models
-import mlrun.api.schemas
 import mlrun.api.utils.db.alembic
 import mlrun.api.utils.db.backup
 import mlrun.api.utils.db.mysql
 import mlrun.api.utils.db.sqlite_migration
 import mlrun.artifacts
+import mlrun.common.schemas
 from mlrun.api.db.init_db import init_db
 from mlrun.api.db.session import close_session, create_session
 from mlrun.config import config
@@ -43,7 +44,20 @@ def init_data(
     from_scratch: bool = False, perform_migrations_if_needed: bool = False
 ) -> None:
     logger.info("Initializing DB data")
-    mlrun.api.utils.db.mysql.MySQLUtil.wait_for_db_liveness(logger)
+
+    # create mysql util, and if mlrun is configured to use mysql, wait for it to be live and set its db modes
+    mysql_util = mlrun.api.utils.db.mysql.MySQLUtil(logger)
+    if mysql_util.get_mysql_dsn_data():
+        mysql_util.wait_for_db_liveness()
+        mysql_util.set_modes(mlrun.mlconf.httpdb.db.mysql.modes)
+    else:
+        dsn = mysql_util.get_dsn()
+        if "sqlite" in dsn:
+            logger.debug("SQLite DB is used, liveness check not needed")
+        else:
+            logger.warn(
+                f"Invalid mysql dsn: {dsn}, assuming live and skipping liveness verification"
+            )
 
     sqlite_migration_util = None
     if not from_scratch and config.httpdb.db.database_migration_mode == "enabled":
@@ -62,7 +76,7 @@ def init_data(
         and not perform_migrations_if_needed
         and is_migration_needed
     ):
-        state = mlrun.api.schemas.APIStates.waiting_for_migrations
+        state = mlrun.common.schemas.APIStates.waiting_for_migrations
         logger.info("Migration is needed, changing API state", state=state)
         config.httpdb.state = state
         return
@@ -73,7 +87,7 @@ def init_data(
         db_backup.backup_database()
 
     logger.info("Creating initial data")
-    config.httpdb.state = mlrun.api.schemas.APIStates.migrations_in_progress
+    config.httpdb.state = mlrun.common.schemas.APIStates.migrations_in_progress
 
     if is_migration_from_scratch or is_migration_needed:
         try:
@@ -81,15 +95,15 @@ def init_data(
 
             _perform_database_migration(sqlite_migration_util)
 
+            init_db()
             db_session = create_session()
             try:
-                init_db(db_session)
                 _add_initial_data(db_session)
                 _perform_data_migrations(db_session)
             finally:
                 close_session(db_session)
         except Exception:
-            state = mlrun.api.schemas.APIStates.migrations_failed
+            state = mlrun.common.schemas.APIStates.migrations_failed
             logger.warning("Migrations failed, changing API state", state=state)
             config.httpdb.state = state
             raise
@@ -97,17 +111,19 @@ def init_data(
     # should happen - we can't do it here because it requires an asyncio loop which can't be accessible here
     # therefore moving to migration_completed state, and other component will take care of moving to online
     if not is_migration_from_scratch and is_migration_needed:
-        config.httpdb.state = mlrun.api.schemas.APIStates.migrations_completed
+        config.httpdb.state = mlrun.common.schemas.APIStates.migrations_completed
     else:
-        config.httpdb.state = mlrun.api.schemas.APIStates.online
+        config.httpdb.state = mlrun.common.schemas.APIStates.online
     logger.info("Initial data created")
 
 
 # If the data_table version doesn't exist, we can assume the data version is 1.
-# This is because data version 1 points to to a data migration which was added back in 0.6.0, and
+# This is because data version 1 points to a data migration which was added back in 0.6.0, and
 # upgrading from a version earlier than 0.6.0 to v>=0.8.0 is not supported.
 data_version_prior_to_table_addition = 1
-latest_data_version = 2
+
+# NOTE: Bump this number when adding a new data migration
+latest_data_version = 3
 
 
 def _resolve_needed_operations(
@@ -212,13 +228,16 @@ def _perform_data_migrations(db_session: sqlalchemy.orm.Session):
                 _perform_version_1_data_migrations(db, db_session)
             if current_data_version < 2:
                 _perform_version_2_data_migrations(db, db_session)
+            if current_data_version < 3:
+                _perform_version_3_data_migrations(db, db_session)
+
             db.create_data_version(db_session, str(latest_data_version))
 
 
 def _add_initial_data(db_session: sqlalchemy.orm.Session):
     # FileDB is not really a thing anymore, so using SQLDB directly
     db = mlrun.api.db.sqldb.db.SQLDB("")
-    _add_default_marketplace_source_if_needed(db, db_session)
+    _add_default_hub_source_if_needed(db, db_session)
     _add_data_version(db, db_session)
 
 
@@ -465,6 +484,30 @@ def _align_runs_table(
         db._upsert(db_session, [run], ignore=True)
 
 
+def _perform_version_3_data_migrations(
+    db: mlrun.api.db.sqldb.db.SQLDB, db_session: sqlalchemy.orm.Session
+):
+    _rename_marketplace_kind_to_hub(db, db_session)
+
+
+def _rename_marketplace_kind_to_hub(
+    db: mlrun.api.db.sqldb.db.SQLDB, db_session: sqlalchemy.orm.Session
+):
+    logger.info("Renaming 'Marketplace' kinds to 'Hub'")
+
+    hubs = db._list_hub_sources_without_transform(db_session)
+    for hub in hubs:
+        hub_dict = hub.full_object
+
+        # rename kind from "MarketplaceSource" to "HubSource"
+        if "Marketplace" in hub_dict.get("kind", ""):
+            hub_dict["kind"] = hub_dict["kind"].replace("Marketplace", "Hub")
+
+        # save the object back to the db
+        hub.full_object = hub_dict
+        db._upsert(db_session, [hub], ignore=True)
+
+
 def _perform_version_1_data_migrations(
     db: mlrun.api.db.sqldb.db.SQLDB, db_session: sqlalchemy.orm.Session
 ):
@@ -482,7 +525,7 @@ def _enrich_project_state(
         changed = False
         if not project.spec.desired_state:
             changed = True
-            project.spec.desired_state = mlrun.api.schemas.ProjectState.online
+            project.spec.desired_state = mlrun.common.schemas.ProjectState.online
         if not project.status.state:
             changed = True
             project.status.state = project.spec.desired_state
@@ -494,32 +537,47 @@ def _enrich_project_state(
             db.store_project(db_session, project.metadata.name, project)
 
 
-def _add_default_marketplace_source_if_needed(
+def _add_default_hub_source_if_needed(
     db: mlrun.api.db.sqldb.db.SQLDB, db_session: sqlalchemy.orm.Session
 ):
     try:
-        hub_marketplace_source = db.get_marketplace_source(
-            db_session, config.marketplace.default_source.name
+        hub_marketplace_source = db.get_hub_source(
+            db_session, config.hub.default_source.name
         )
     except mlrun.errors.MLRunNotFoundError:
         hub_marketplace_source = None
+    except pydantic.error_wrappers.ValidationError as exc:
+
+        # following the renaming of 'marketplace' to 'hub', validation errors can occur on the old 'marketplace'.
+        # this will be handled later in the data migrations, but for now - if a validation error occurs, we assume
+        # that a default hub source exists
+        if all(
+            [
+                "validation error for HubSource" in str(exc),
+                "value is not a valid enumeration member" in str(exc),
+            ]
+        ):
+            logger.info("Found existing default hub source, data migration needed")
+            hub_marketplace_source = True
+        else:
+            raise exc
 
     if not hub_marketplace_source:
-        hub_source = mlrun.api.schemas.MarketplaceSource.generate_default_source()
-        # hub_source will be None if the configuration has marketplace.default_source.create=False
+        hub_source = mlrun.common.schemas.HubSource.generate_default_source()
+        # hub_source will be None if the configuration has hub.default_source.create=False
         if hub_source:
-            logger.info("Adding default marketplace source")
-            # Not using db.store_marketplace_source() since it doesn't allow changing the default marketplace source.
-            hub_record = db._transform_marketplace_source_schema_to_record(
-                mlrun.api.schemas.IndexedMarketplaceSource(
-                    index=mlrun.api.schemas.marketplace.last_source_index,
+            logger.info("Adding default hub source")
+            # Not using db.store_marketplace_source() since it doesn't allow changing the default hub source.
+            hub_record = db._transform_hub_source_schema_to_record(
+                mlrun.common.schemas.IndexedHubSource(
+                    index=mlrun.common.schemas.hub.last_source_index,
                     source=hub_source,
                 )
             )
             db_session.add(hub_record)
             db_session.commit()
         else:
-            logger.info("Not adding default marketplace source, per configuration")
+            logger.info("Not adding default hub source, per configuration")
     return