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

mlrun/api/launcher.py

@@ -0,0 +1,196 @@
+# Copyright 2023 MLRun Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import Dict, List, Optional, Union
+
+import mlrun.api.crud
+import mlrun.api.db.sqldb.session
+import mlrun.common.schemas.schedule
+import mlrun.config
+import mlrun.execution
+import mlrun.launcher.base
+import mlrun.runtimes
+import mlrun.runtimes.generators
+import mlrun.runtimes.utils
+import mlrun.utils
+import mlrun.utils.regex
+
+
+class ServerSideLauncher(mlrun.launcher.base.BaseLauncher):
+    def launch(
+        self,
+        runtime: mlrun.runtimes.BaseRuntime,
+        task: Optional[
+            Union["mlrun.run.RunTemplate", "mlrun.run.RunObject", dict]
+        ] = None,
+        handler: Optional[str] = None,
+        name: Optional[str] = "",
+        project: Optional[str] = "",
+        params: Optional[dict] = None,
+        inputs: Optional[Dict[str, str]] = None,
+        out_path: Optional[str] = "",
+        workdir: Optional[str] = "",
+        artifact_path: Optional[str] = "",
+        watch: Optional[bool] = True,
+        schedule: Optional[
+            Union[str, mlrun.common.schemas.schedule.ScheduleCronTrigger]
+        ] = None,
+        hyperparams: Dict[str, list] = None,
+        hyper_param_options: Optional[mlrun.model.HyperParamOptions] = None,
+        verbose: Optional[bool] = None,
+        scrape_metrics: Optional[bool] = None,
+        local_code_path: Optional[str] = None,
+        auto_build: Optional[bool] = None,
+        param_file_secrets: Optional[Dict[str, str]] = None,
+        notifications: Optional[List[mlrun.model.Notification]] = None,
+        returns: Optional[List[Union[str, Dict[str, str]]]] = None,
+    ) -> mlrun.run.RunObject:
+        self.enrich_runtime(runtime, project)
+
+        run = self._create_run_object(task)
+
+        run = self._enrich_run(
+            runtime,
+            run=run,
+            handler=handler,
+            project_name=project,
+            name=name,
+            params=params,
+            inputs=inputs,
+            returns=returns,
+            hyperparams=hyperparams,
+            hyper_param_options=hyper_param_options,
+            verbose=verbose,
+            scrape_metrics=scrape_metrics,
+            out_path=out_path,
+            artifact_path=artifact_path,
+            workdir=workdir,
+            notifications=notifications,
+        )
+        self._validate_runtime(runtime, run)
+
+        if runtime.verbose:
+            mlrun.utils.logger.info(f"Run:\n{run.to_yaml()}")
+
+        if not runtime.is_child:
+            mlrun.utils.logger.info(
+                "Storing function",
+                name=run.metadata.name,
+                uid=run.metadata.uid,
+            )
+            self._store_function(runtime, run)
+
+        execution = mlrun.execution.MLClientCtx.from_dict(
+            run.to_dict(),
+            runtime._get_db(),
+            autocommit=False,
+            is_api=True,
+            store_run=False,
+        )
+
+        # create task generator (for child runs) from spec
+        task_generator = mlrun.runtimes.generators.get_generator(
+            run.spec, execution, param_file_secrets=param_file_secrets
+        )
+        if task_generator:
+            # verify valid task parameters
+            tasks = task_generator.generate(run)
+            for task in tasks:
+                self._validate_run_params(task.spec.parameters)
+
+        # post verifications, store execution in db and run pre run hooks
+        execution.store_run()
+        runtime._pre_run(run, execution)  # hook for runtime specific prep
+
+        resp = None
+        last_err = None
+        # If the runtime is nested, it means the hyper-run will run within a single instance of the run.
+        # So while in the API, we consider the hyper-run as a single run, and then in the runtime itself when the
+        # runtime is now a local runtime and therefore `self._is_nested == False`, we run each task as a separate run by
+        # using the task generator
+        if task_generator and not runtime._is_nested:
+            # multiple runs (based on hyper params or params file)
+            runner = runtime._run_many
+            if hasattr(runtime, "_parallel_run_many") and task_generator.use_parallel():
+                runner = runtime._parallel_run_many
+            results = runner(task_generator, execution, run)
+            mlrun.runtimes.utils.results_to_iter(results, run, execution)
+            result = execution.to_dict()
+            result = runtime._update_run_state(result, task=run)
+
+        else:
+            # single run
+            try:
+                resp = runtime._run(run, execution)
+
+            except mlrun.runtimes.utils.RunError as err:
+                last_err = err
+
+            finally:
+                result = runtime._update_run_state(resp=resp, task=run, err=last_err)
+
+        self._save_notifications(run)
+
+        runtime._post_run(result, execution)  # hook for runtime specific cleanup
+
+        return self._wrap_run_result(runtime, result, run, err=last_err)
+
+    @staticmethod
+    def enrich_runtime(
+        runtime: "mlrun.runtimes.base.BaseRuntime", project_name: Optional[str] = ""
+    ):
+        """
+        Enrich the runtime object with the project spec and metadata.
+        This is done only on the server side, since it's the source of truth for the project, and we want to keep the
+        client side enrichment as minimal as possible.
+        """
+        # ensure the runtime has a project before we enrich it with the project's spec
+        runtime.metadata.project = (
+            project_name
+            or runtime.metadata.project
+            or mlrun.config.config.default_project
+        )
+        project = runtime._get_db().get_project(runtime.metadata.project)
+        # this is mainly for tests with nop db
+        # in normal use cases if no project is found we will get an error
+        if project:
+            project = mlrun.projects.project.MlrunProject.from_dict(project.dict())
+            mlrun.projects.pipelines.enrich_function_object(
+                project, runtime, copy_function=False
+            )
+
+    def _save_notifications(self, runobj):
+        if not self._run_has_valid_notifications(runobj):
+            return
+
+        # If in the api server, we can assume that watch=False, so we save notification
+        # configs to the DB, for the run monitor to later pick up and push.
+        session = mlrun.api.db.sqldb.session.create_session()
+        mlrun.api.crud.Notifications().store_run_notifications(
+            session,
+            runobj.spec.notifications,
+            runobj.metadata.uid,
+            runobj.metadata.project,
+        )
+
+    def _store_function(
+        self, runtime: mlrun.runtimes.base.BaseRuntime, run: mlrun.run.RunObject
+    ):
+        run.metadata.labels["kind"] = runtime.kind
+        db = runtime._get_db()
+        if db and runtime.kind != "handler":
+            struct = runtime.to_dict()
+            hash_key = db.store_function(
+                struct, runtime.metadata.name, runtime.metadata.project, versioned=True
+            )
+            run.spec.function = runtime._function_uri(hash_key=hash_key)

mlrun/api/main.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.
@@ -24,12 +24,14 @@ import sqlalchemy.orm
 import uvicorn
 from fastapi.exception_handlers import http_exception_handler
 
-import mlrun.api.schemas
+import mlrun.api.db.base
 import mlrun.api.utils.clients.chief
 import mlrun.api.utils.clients.log_collector
+import mlrun.common.schemas
 import mlrun.errors
 import mlrun.lists
 import mlrun.utils
+import mlrun.utils.notifications
 import mlrun.utils.version
 from mlrun.api.api.api import api_router
 from mlrun.api.db.session import close_session, create_session
@@ -41,6 +43,7 @@ from mlrun.api.utils.periodic import (
     run_function_periodically,
 )
 from mlrun.api.utils.singletons.db import get_db, initialize_db
+from mlrun.api.utils.singletons.k8s import get_k8s_helper
 from mlrun.api.utils.singletons.logs_dir import initialize_logs_dir
 from mlrun.api.utils.singletons.project_member import (
     get_project_member,
@@ -49,13 +52,20 @@ from mlrun.api.utils.singletons.project_member import (
 from mlrun.api.utils.singletons.scheduler import get_scheduler, initialize_scheduler
 from mlrun.config import config
 from mlrun.errors import err_to_str
-from mlrun.k8s_utils import get_k8s_helper
 from mlrun.runtimes import RuntimeClassMode, RuntimeKinds, get_runtime_handler
 from mlrun.utils import logger
 
 API_PREFIX = "/api"
 BASE_VERSIONED_API_PREFIX = f"{API_PREFIX}/v1"
 
+# When pushing notifications, push notifications only for runs that entered a terminal state
+# since the last time we pushed notifications.
+# On the first time we push notifications, we'll push notifications for all runs that are in a terminal state
+# and their notifications haven't been sent yet.
+# TODO: find better solution than a global variable for chunking the list of runs
+#      for which to push notifications
+_last_notification_push_time: datetime.datetime = None
+
 
 app = fastapi.FastAPI(
     title="MLRun",
@@ -70,8 +80,9 @@ app = fastapi.FastAPI(
 )
 app.include_router(api_router, prefix=BASE_VERSIONED_API_PREFIX)
 # This is for backward compatibility, that is why we still leave it here but not include it in the schema
-# so new users won't use the old un-versioned api
-# TODO: remove in 1.4.0
+# so new users won't use the old un-versioned api.
+# /api points to /api/v1 since it is used externally, and we don't want to break it.
+# TODO: make sure UI and all relevant Iguazio versions uses /api/v1 and deprecate this
 app.include_router(api_router, prefix=API_PREFIX, include_in_schema=False)
 
 init_middlewares(app)
@@ -93,6 +104,11 @@ async def generic_error_handler(request: fastapi.Request, exc: Exception):
 async def http_status_error_handler(
     request: fastapi.Request, exc: mlrun.errors.MLRunHTTPStatusError
 ):
+    request_id = None
+
+    # request might not have request id when the error is raised before the request id is set on middleware
+    if hasattr(request.state, "request_id"):
+        request_id = request.state.request_id
     status_code = exc.response.status_code
     error_message = repr(exc)
     logger.warning(
@@ -100,6 +116,7 @@ async def http_status_error_handler(
         error_message=error_message,
         status_code=status_code,
         traceback=traceback.format_exc(),
+        request_id=request_id,
     )
     return await http_exception_handler(
         request,
@@ -110,8 +127,8 @@ async def http_status_error_handler(
 @app.on_event("startup")
 async def startup_event():
     logger.info(
-        "configuration dump",
-        dumped_config=config.dump_yaml(),
+        "On startup event handler called",
+        config=config.dump_yaml(),
         version=mlrun.utils.version.Version().get(),
     )
     loop = asyncio.get_running_loop()
@@ -126,13 +143,13 @@ async def startup_event():
 
     if (
         config.httpdb.clusterization.worker.sync_with_chief.mode
-        == mlrun.api.schemas.WaitForChiefToReachOnlineStateFeatureFlag.enabled
+        == mlrun.common.schemas.WaitForChiefToReachOnlineStateFeatureFlag.enabled
         and config.httpdb.clusterization.role
-        == mlrun.api.schemas.ClusterizationRole.worker
+        == mlrun.common.schemas.ClusterizationRole.worker
     ):
         _start_chief_clusterization_spec_sync_loop()
 
-    if config.httpdb.state == mlrun.api.schemas.APIStates.online:
+    if config.httpdb.state == mlrun.common.schemas.APIStates.online:
         await move_api_to_online()
 
 
@@ -155,7 +172,10 @@ async def move_api_to_online():
     initialize_project_member()
 
     # maintenance periodic functions should only run on the chief instance
-    if config.httpdb.clusterization.role == mlrun.api.schemas.ClusterizationRole.chief:
+    if (
+        config.httpdb.clusterization.role
+        == mlrun.common.schemas.ClusterizationRole.chief
+    ):
         # runs cleanup/monitoring is not needed if we're not inside kubernetes cluster
         if get_k8s_helper(silent=True).is_running_inside_kubernetes_cluster():
             _start_periodic_cleanup()
@@ -165,7 +185,7 @@ async def move_api_to_online():
 
 
 async def _start_logs_collection():
-    if config.log_collector.mode == mlrun.api.schemas.LogsCollectorMode.legacy:
+    if config.log_collector.mode == mlrun.common.schemas.LogsCollectorMode.legacy:
         logger.info(
             "Using legacy logs collection method, skipping logs collection periodic function",
             mode=config.log_collector.mode,
@@ -405,7 +425,7 @@ def _start_periodic_runs_monitoring():
 
 
 async def _start_periodic_stop_logs():
-    if config.log_collector.mode == mlrun.api.schemas.LogsCollectorMode.legacy:
+    if config.log_collector.mode == mlrun.common.schemas.LogsCollectorMode.legacy:
         logger.info(
             "Using legacy logs collection method, skipping stop logs periodic function",
             mode=config.log_collector.mode,
@@ -469,7 +489,7 @@ def _start_chief_clusterization_spec_sync_loop():
 async def _synchronize_with_chief_clusterization_spec():
     # sanity
     # if we are still in the periodic function and the worker has reached the terminal state, then cancel it
-    if config.httpdb.state in mlrun.api.schemas.APIStates.terminal_states():
+    if config.httpdb.state in mlrun.common.schemas.APIStates.terminal_states():
         cancel_periodic_function(_synchronize_with_chief_clusterization_spec.__name__)
 
     try:
@@ -488,14 +508,14 @@ async def _synchronize_with_chief_clusterization_spec():
 
 
 async def _align_worker_state_with_chief_state(
-    clusterization_spec: mlrun.api.schemas.ClusterizationSpec,
+    clusterization_spec: mlrun.common.schemas.ClusterizationSpec,
 ):
     chief_state = clusterization_spec.chief_api_state
     if not chief_state:
         logger.warning("Chief did not return any state")
         return
 
-    if chief_state not in mlrun.api.schemas.APIStates.terminal_states():
+    if chief_state not in mlrun.common.schemas.APIStates.terminal_states():
         logger.debug(
             "Chief did not reach online state yet, will retry after sync interval",
             interval=config.httpdb.clusterization.worker.sync_with_chief.interval,
@@ -505,7 +525,7 @@ async def _align_worker_state_with_chief_state(
         config.httpdb.state = chief_state
         return
 
-    if chief_state == mlrun.api.schemas.APIStates.online:
+    if chief_state == mlrun.common.schemas.APIStates.online:
         logger.info("Chief reached online state! Switching worker state to online")
         await move_api_to_online()
         logger.info("Worker state reached online")
@@ -522,18 +542,20 @@ async def _align_worker_state_with_chief_state(
 
 
 def _monitor_runs():
+    db = get_db()
     db_session = create_session()
     try:
         for kind in RuntimeKinds.runtime_with_handlers():
             try:
                 runtime_handler = get_runtime_handler(kind)
-                runtime_handler.monitor_runs(get_db(), db_session)
+                runtime_handler.monitor_runs(db, db_session)
             except Exception as exc:
                 logger.warning(
                     "Failed monitoring runs. Ignoring",
                     exc=err_to_str(exc),
                     kind=kind,
                 )
+        _push_terminal_run_notifications(db, db_session)
     finally:
         close_session(db_session)
 
@@ -555,6 +577,50 @@ def _cleanup_runtimes():
         close_session(db_session)
 
 
+def _push_terminal_run_notifications(db: mlrun.api.db.base.DBInterface, db_session):
+    """
+    Get all runs with notification configs which became terminal since the last call to the function
+    and push their notifications if they haven't been pushed yet.
+    """
+    # Import here to avoid circular import
+    import mlrun.api.api.utils
+
+    # When pushing notifications, push notifications only for runs that entered a terminal state
+    # since the last time we pushed notifications.
+    # On the first time we push notifications, we'll push notifications for all runs that are in a terminal state
+    # and their notifications haven't been sent yet.
+    global _last_notification_push_time
+
+    now = datetime.datetime.now(datetime.timezone.utc)
+
+    runs = db.list_runs(
+        db_session,
+        project="*",
+        states=mlrun.runtimes.constants.RunStates.terminal_states(),
+        last_update_time_from=_last_notification_push_time,
+        with_notifications=True,
+    )
+
+    if not len(runs):
+        return
+
+    # Unmasking the run parameters from secrets before handing them over to the notification handler
+    # as importing the `Secrets` crud in the notification handler will cause a circular import
+    unmasked_runs = [
+        mlrun.api.api.utils.unmask_notification_params_secret_on_task(
+            db, db_session, run
+        )
+        for run in runs
+    ]
+
+    logger.debug(
+        "Got terminal runs with configured notifications", runs_amount=len(runs)
+    )
+    mlrun.utils.notifications.NotificationPusher(unmasked_runs).push(db)
+
+    _last_notification_push_time = now
+
+
 async def _stop_logs():
     """
     Stop logs for runs that are in terminal state and last updated in the previous interval
@@ -607,16 +673,19 @@ async def _stop_logs_for_runs(runs: list):
 
 
 def main():
-    if config.httpdb.clusterization.role == mlrun.api.schemas.ClusterizationRole.chief:
+    if (
+        config.httpdb.clusterization.role
+        == mlrun.common.schemas.ClusterizationRole.chief
+    ):
         init_data()
     elif (
         config.httpdb.clusterization.worker.sync_with_chief.mode
-        == mlrun.api.schemas.WaitForChiefToReachOnlineStateFeatureFlag.enabled
+        == mlrun.common.schemas.WaitForChiefToReachOnlineStateFeatureFlag.enabled
         and config.httpdb.clusterization.role
-        == mlrun.api.schemas.ClusterizationRole.worker
+        == mlrun.common.schemas.ClusterizationRole.worker
     ):
         # we set this state to mark the phase between the startup of the instance until we able to pull the chief state
-        config.httpdb.state = mlrun.api.schemas.APIStates.waiting_for_chief
+        config.httpdb.state = mlrun.common.schemas.APIStates.waiting_for_chief
 
     logger.info(
         "Starting API server",

mlrun/api/middlewares.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.
@@ -21,7 +21,7 @@ import fastapi
 import uvicorn.protocols.utils
 from starlette.middleware.base import BaseHTTPMiddleware
 
-import mlrun.api.schemas.constants
+import mlrun.common.schemas.constants
 from mlrun.config import config
 from mlrun.utils import logger
 
@@ -46,6 +46,7 @@ async def log_request_response(request: fastapi.Request, call_next):
     path_with_query_string = uvicorn.protocols.utils.get_path_with_query_string(
         request.scope
     )
+    request.state.request_id = request_id
     start_time = time.perf_counter_ns()
     if not any(
         silent_logging_path in path_with_query_string
@@ -100,7 +101,7 @@ async def ui_clear_cache(request: fastapi.Request, call_next):
     This middleware tells ui when to clear its cache based on backend version changes.
     """
     ui_version = request.headers.get(
-        mlrun.api.schemas.constants.HeaderNames.ui_version, ""
+        mlrun.common.schemas.constants.HeaderNames.ui_version, ""
     )
     response: fastapi.Response = await call_next(request)
     development_version = config.version.startswith("0.0.0")
@@ -117,7 +118,7 @@ async def ui_clear_cache(request: fastapi.Request, call_next):
 
         # tell ui to reload
         response.headers[
-            mlrun.api.schemas.constants.HeaderNames.ui_clear_cache
+            mlrun.common.schemas.constants.HeaderNames.ui_clear_cache
         ] = "true"
     return response
 
@@ -128,7 +129,7 @@ async def ensure_be_version(request: fastapi.Request, call_next):
     """
     response: fastapi.Response = await call_next(request)
     response.headers[
-        mlrun.api.schemas.constants.HeaderNames.backend_version
+        mlrun.common.schemas.constants.HeaderNames.backend_version
     ] = config.version
     return response
 

mlrun/api/migrations_mysql/env.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.

mlrun/api/migrations_mysql/versions/28383af526f3_market_place_to_hub.py

@@ -0,0 +1,40 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""market_place_to_hub
+
+Revision ID: 28383af526f3
+Revises: c905d15bd91d
+Create Date: 2023-04-24 11:06:36.177314
+
+"""
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "28383af526f3"
+down_revision = "c905d15bd91d"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.rename_table("marketplace_sources", "hub_sources")
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.rename_table("hub_sources", "marketplace_sources")
+    # ### end Alembic commands ###

mlrun/api/migrations_mysql/versions/32bae1b0e29c_increase_timestamp_fields_precision.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.

mlrun/api/migrations_mysql/versions/4903aef6a91d_tag_foreign_key_and_cascades.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.

mlrun/api/migrations_mysql/versions/5f1351c88a19_adding_background_tasks_table.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.

mlrun/api/migrations_mysql/versions/88e656800d6a_add_requested_logs_column_and_index_to_.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.

mlrun/api/migrations_mysql/versions/9d16de5f03a7_adding_data_versions_table.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.

mlrun/api/migrations_mysql/versions/b86f5b53f3d7_adding_name_and_updated_to_runs_table.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.

mlrun/api/migrations_mysql/versions/c4af40b0bf61_init.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.

mlrun/api/migrations_mysql/versions/c905d15bd91d_notifications.py

@@ -0,0 +1,72 @@
+# 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.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""notifications
+
+Revision ID: c905d15bd91d
+Revises: 88e656800d6a
+Create Date: 2022-09-20 10:44:41.727488
+
+"""
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import mysql
+
+# revision identifiers, used by Alembic.
+revision = "c905d15bd91d"
+down_revision = "88e656800d6a"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "runs_notifications",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("project", sa.String(length=255, collation="utf8_bin")),
+        sa.Column("name", sa.String(length=255, collation="utf8_bin"), nullable=False),
+        sa.Column("kind", sa.String(length=255, collation="utf8_bin"), nullable=False),
+        sa.Column(
+            "message", sa.String(length=255, collation="utf8_bin"), nullable=False
+        ),
+        sa.Column(
+            "severity", sa.String(length=255, collation="utf8_bin"), nullable=False
+        ),
+        sa.Column("when", sa.String(length=255, collation="utf8_bin"), nullable=False),
+        sa.Column(
+            "condition", sa.String(length=255, collation="utf8_bin"), nullable=False
+        ),
+        sa.Column("params", sa.JSON(), nullable=True),
+        # A generic parent_id rather than run_id since notification table is standard across objects, see the
+        # make_notification function for its definition and usage.
+        sa.Column("parent_id", sa.Integer(), nullable=True),
+        sa.Column("sent_time", mysql.TIMESTAMP(fsp=3), nullable=True),
+        sa.Column(
+            "status", sa.String(length=255, collation="utf8_bin"), nullable=False
+        ),
+        sa.ForeignKeyConstraint(
+            ["parent_id"],
+            ["runs.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("name", "parent_id", name="_runs_notifications_uc"),
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("notifications")
+    # ### end Alembic commands ###