implement function job status endpoint

Author: bisgaard-itis

packages/models-library/src/models_library/functions_errors.py

@@ -163,8 +163,3 @@ class FunctionJobCollectionsExecuteApiAccessDeniedError(FunctionBaseError):
 class FunctionJobPatchModelIncompatibleError(FunctionBaseError):
     msg_template = "Incompatible patch model for Function '{function_id}' in product '{product_name}'."
     status_code: int = 422
-
-
-class FunctionJobCacheNotFoundError(FunctionBaseError):
-    msg_template: str = "No cached function job found."
-    status_code: int = 404  # Not Found

services/api-server/src/simcore_service_api_server/_service_function_jobs.py

@@ -26,7 +26,6 @@
 from models_library.functions_errors import (
     FunctionExecuteAccessDeniedError,
     FunctionInputsValidationError,
-    FunctionJobCacheNotFoundError,
     FunctionsExecuteApiAccessDeniedError,
     UnsupportedFunctionClassError,
     UnsupportedFunctionFunctionJobClassCombinationError,
@@ -41,6 +40,10 @@
 from pydantic import ValidationError
 
 from ._service_jobs import JobService
+from .exceptions.function_errors import (
+    FunctionJobCacheNotFoundError,
+    FunctionJobProjectMissingError,
+)
 from .models.api_resources import JobLinks
 from .models.domain.functions import PreRegisteredFunctionJobData
 from .models.schemas.jobs import (
@@ -127,7 +130,7 @@ async def validate_function_inputs(
     async def inspect_function_job(
         self, function: RegisteredFunction, function_job: RegisteredFunctionJob
     ) -> FunctionJobStatus:
-
+        """Raises FunctionJobProjectNotRegisteredError if no project is associated with job"""
         stored_job_status = await self._web_rpc_client.get_function_job_status(
             function_job_id=function_job.uid,
             user_id=self.user_id,
@@ -141,14 +144,16 @@ async def inspect_function_job(
             function.function_class == FunctionClass.PROJECT
             and function_job.function_class == FunctionClass.PROJECT
         ):
-            assert function_job.project_job_id is not None  # nosec
+            if function_job.project_job_id is None:
+                raise FunctionJobProjectMissingError()
             job_status = await self._job_service.inspect_study_job(
                 job_id=function_job.project_job_id,
             )
         elif (function.function_class == FunctionClass.SOLVER) and (
             function_job.function_class == FunctionClass.SOLVER
         ):
-            assert function_job.solver_job_id is not None  # nosec
+            if function_job.solver_job_id is None:
+                raise FunctionJobProjectMissingError()
             job_status = await self._job_service.inspect_solver_job(
                 solver_key=function.solver_key,
                 version=function.solver_version,

services/api-server/src/simcore_service_api_server/api/dependencies/celery.py

@@ -4,7 +4,6 @@
 from celery_library.task_manager import CeleryTaskManager
 from celery_library.types import register_celery_types, register_pydantic_types
 from fastapi import FastAPI
-from servicelib.celery.task_manager import TaskManager
 from settings_library.celery import CelerySettings
 
 from ...celery.worker_tasks.tasks import pydantic_types_to_register
@@ -24,7 +23,7 @@ async def on_startup() -> None:
     app.add_event_handler("startup", on_startup)
 
 
-def get_task_manager(app: FastAPI) -> TaskManager:
+def get_task_manager(app: FastAPI) -> CeleryTaskManager:
     assert hasattr(app.state, "task_manager")  # nosec
     task_manager = app.state.task_manager
     assert isinstance(task_manager, CeleryTaskManager)  # nosec

services/api-server/src/simcore_service_api_server/api/routes/function_jobs_routes.py

@@ -1,5 +1,7 @@
+from logging import getLogger
 from typing import Annotated, Final
 
+from common_library.error_codes import create_error_code
 from fastapi import APIRouter, Depends, FastAPI, HTTPException, status
 from fastapi_pagination.api import create_page
 from fastapi_pagination.bases import AbstractPage
@@ -15,23 +17,28 @@
 from models_library.functions import RegisteredFunction
 from models_library.functions_errors import (
     UnsupportedFunctionClassError,
+    UnsupportedFunctionFunctionJobClassCombinationError,
 )
 from models_library.products import ProductName
 from models_library.users import UserID
+from servicelib.celery.models import TaskUUID
 from servicelib.fastapi.dependencies import get_app
+from servicelib.logging_errors import create_troubleshootting_log_kwargs
 from simcore_service_api_server.models.schemas.functions_filters import (
     FunctionJobsListFilters,
 )
 from sqlalchemy.ext.asyncio import AsyncEngine
 
 from ..._service_function_jobs import FunctionJobService
 from ..._service_jobs import JobService
+from ...exceptions.function_errors import FunctionJobProjectMissingError
 from ...models.pagination import Page, PaginationParams
 from ...models.schemas.errors import ErrorGet
 from ...services_http.storage import StorageApi
 from ...services_http.webserver import AuthSession
 from ...services_rpc.wb_api_server import WbApiRpcClient
 from ..dependencies.authentication import get_current_user_id, get_product_name
+from ..dependencies.celery import get_task_manager
 from ..dependencies.database import get_db_asyncpg_engine
 from ..dependencies.functions import (
     get_function_from_functionjob,
@@ -52,6 +59,9 @@
     FMSG_CHANGELOG_NEW_IN_VERSION,
     create_route_description,
 )
+from .tasks import _get_task_filter
+
+_logger = getLogger(__name__)
 
 # pylint: disable=too-many-arguments
 # pylint: disable=cyclic-import
@@ -196,6 +206,9 @@ async def delete_function_job(
     ),
 )
 async def function_job_status(
+    app: Annotated[FastAPI, Depends(get_app)],
+    user_id: Annotated[UserID, Depends(get_current_user_id)],
+    product_name: Annotated[ProductName, Depends(get_product_name)],
     function_job: Annotated[
         RegisteredFunctionJob, Depends(get_function_job_dependency)
     ],
@@ -204,10 +217,46 @@ async def function_job_status(
         FunctionJobService, Depends(get_function_job_service)
     ],
 ) -> FunctionJobStatus:
+    try:
+        return await function_job_service.inspect_function_job(
+            function=function, function_job=function_job
+        )
+    except FunctionJobProjectMissingError as exc:
+        if (
+            function.function_class == FunctionClass.PROJECT
+            and function_job.function_class == FunctionClass.PROJECT
+        ) or (
+            function.function_class == FunctionClass.SOLVER
+            and function_job.function_class == FunctionClass.SOLVER
+        ):
+            if task_id := function_job.job_creation_task_id:
+                task_manager = get_task_manager(app)
+                task_filter = _get_task_filter(user_id, product_name)
+                task_status = await task_manager.get_task_status(
+                    task_uuid=TaskUUID(task_id), task_filter=task_filter
+                )
+                return FunctionJobStatus(
+                    status=f"JOB_CREATION_TASK_STATUS_{task_status.task_state}"
+                )
+            user_error_msg = f"The creation of job {function_job.uid} failed"
+            support_id = create_error_code(Exception())
+            _logger.exception(
+                **create_troubleshootting_log_kwargs(
+                    user_error_msg,
+                    error=Exception(),
+                    error_code=support_id,
+                    tip="Initial call to run metamodeling function must have failed",
+                )
+            )
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Function job is not in a valid state",
+            ) from exc
 
-    return await function_job_service.inspect_function_job(
-        function=function, function_job=function_job
-    )
+        raise UnsupportedFunctionFunctionJobClassCombinationError(
+            function_class=function.function_class,
+            function_job_class=function_job.function_class,
+        )
 
 
 async def get_function_from_functionjobid(

services/api-server/src/simcore_service_api_server/api/routes/functions_routes.py

@@ -17,7 +17,6 @@
     RegisteredFunctionJobCollection,
 )
 from models_library.api_schemas_rpc_async_jobs.async_jobs import AsyncJobFilter
-from models_library.functions_errors import FunctionJobCacheNotFoundError
 from models_library.products import ProductName
 from models_library.projects import ProjectID
 from models_library.projects_nodes_io import NodeID
@@ -28,6 +27,7 @@
 from ..._service_function_jobs import FunctionJobService
 from ..._service_functions import FunctionService
 from ...celery.worker_tasks.functions_tasks import run_function as run_function_task
+from ...exceptions.function_errors import FunctionJobCacheNotFoundError
 from ...models.pagination import Page, PaginationParams
 from ...models.schemas.errors import ErrorGet
 from ...models.schemas.jobs import JobPricingSpecification

services/api-server/src/simcore_service_api_server/exceptions/function_errors.py

@@ -0,0 +1,17 @@
+from fastapi import status
+
+from .backend_errors import BaseBackEndError
+
+
+class BaseFunctionBackendError(BaseBackEndError):
+    pass
+
+
+class FunctionJobCacheNotFoundError(BaseBackEndError):
+    msg_template: str = "No cached function job found."
+    status_code: int = 404  # Not Found
+
+
+class FunctionJobProjectMissingError(BaseBackEndError):
+    msg_template: str = "Could not process function job"
+    status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR  # Not Found