Merge branch 'master' into 7348-add-dummy-functions-api

Author: bisgaard-itis

api/specs/web-server/_auth.py

@@ -15,29 +15,29 @@
 from models_library.rest_error import EnvelopedError, Log
 from pydantic import BaseModel, Field, confloat
 from simcore_service_webserver._meta import API_VTAG
-from simcore_service_webserver.login._2fa_handlers import Resend2faBody
-from simcore_service_webserver.login._auth_handlers import (
+from simcore_service_webserver.login._controller.rest.auth import (
     LoginBody,
     LoginNextPage,
     LoginTwoFactorAuthBody,
     LogoutBody,
 )
-from simcore_service_webserver.login.handlers_change import (
+from simcore_service_webserver.login._controller.rest.change import (
     ChangeEmailBody,
     ChangePasswordBody,
     ResetPasswordBody,
 )
-from simcore_service_webserver.login.handlers_confirmation import (
+from simcore_service_webserver.login._controller.rest.confirmation import (
     PhoneConfirmationBody,
     ResetPasswordConfirmation,
 )
-from simcore_service_webserver.login.handlers_registration import (
+from simcore_service_webserver.login._controller.rest.registration import (
     InvitationCheck,
     InvitationInfo,
     RegisterBody,
     RegisterPhoneBody,
     RegisterPhoneNextPage,
 )
+from simcore_service_webserver.login._controller.rest.twofa import Resend2faBody
 
 router = APIRouter(prefix=f"/{API_VTAG}", tags=["auth"])
 

packages/pytest-simcore/src/pytest_simcore/helpers/playwright.py

@@ -11,7 +11,7 @@
 from typing import Any, Final
 
 from playwright._impl._sync_base import EventContextManager
-from playwright.sync_api import APIRequestContext, FrameLocator, Page, Request
+from playwright.sync_api import APIRequestContext, FrameLocator, Locator, Page, Request
 from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
 from playwright.sync_api import WebSocket
 from pydantic import AnyUrl
@@ -137,9 +137,7 @@ def on_framereceived(payload: str | bytes) -> None:
                     ctx.logger.debug("⬆️ Frame received: %s", payload)
 
                 def on_close(_: WebSocket) -> None:
-                    ctx.logger.warning(
-                        "⚠️ WebSocket closed. Attempting to reconnect..."
-                    )
+                    ctx.logger.warning("⚠️ WebSocket closed. Attempting to reconnect...")
                     self._attempt_reconnect(ctx.logger)
 
                 def on_socketerror(error_msg: str) -> None:
@@ -320,9 +318,9 @@ def __call__(self, message: str) -> bool:
                         new_progress
                         != self._current_progress[node_progress_event.progress_type]
                     ):
-                        self._current_progress[
-                            node_progress_event.progress_type
-                        ] = new_progress
+                        self._current_progress[node_progress_event.progress_type] = (
+                            new_progress
+                        )
 
                         self.logger.info(
                             "Current startup progress [expected number of node-progress-types=%d]: %s",
@@ -343,29 +341,30 @@ def __call__(self, message: str) -> bool:
                 url = (
                     f"https://{self.node_id}.services.{self.get_partial_product_url()}"
                 )
-            response = self.api_request_context.get(url, timeout=1000)
-            level = logging.DEBUG
-            if (response.status >= 400) and (response.status not in (502, 503)):
-                level = logging.ERROR
-            self.logger.log(
-                level,
-                "Querying service endpoint in case we missed some websocket messages. Url: %s Response: '%s' TIP: %s",
-                url,
-                f"{response.status}: {response.text()}",
-                (
-                    "We are emulating the frontend; a 5XX response is acceptable if the service is not yet ready."
-                ),
-            )
+            with contextlib.suppress(PlaywrightTimeoutError):
+                response = self.api_request_context.get(url, timeout=1000)
+                level = logging.DEBUG
+                if (response.status >= 400) and (response.status not in (502, 503)):
+                    level = logging.ERROR
+                self.logger.log(
+                    level,
+                    "Querying service endpoint in case we missed some websocket messages. Url: %s Response: '%s' TIP: %s",
+                    url,
+                    f"{response.status}: {response.text()}",
+                    (
+                        "We are emulating the frontend; a 5XX response is acceptable if the service is not yet ready."
+                    ),
+                )
 
-            if response.status <= 400:
-                # NOTE: If the response status is less than 400, it means that the backend is ready (There are some services that respond with a 3XX)
-                if self.got_expected_node_progress_types():
-                    self.logger.warning(
-                        "⚠️ Progress bar didn't receive 100 percent but service is already running: %s. TIP: we missed some websocket messages! ⚠️",  # https://github.com/ITISFoundation/osparc-simcore/issues/6449
-                        self.get_current_progress(),
-                    )
-                return True
-            self._last_poll_timestamp = datetime.now(UTC)
+                if response.status <= 400:
+                    # NOTE: If the response status is less than 400, it means that the backend is ready (There are some services that respond with a 3XX)
+                    if self.got_expected_node_progress_types():
+                        self.logger.warning(
+                            "⚠️ Progress bar didn't receive 100 percent but service is already running: %s. TIP: we missed some websocket messages! ⚠️",  # https://github.com/ITISFoundation/osparc-simcore/issues/6449
+                            self.get_current_progress(),
+                        )
+                    return True
+                self._last_poll_timestamp = datetime.now(UTC)
 
         return False
 
@@ -508,3 +507,16 @@ def app_mode_trigger_next_app(page: Page) -> None:
     ):
         # Move to next step (this auto starts the next service)
         page.get_by_test_id("AppMode_NextBtn").click()
+
+
+def wait_for_label_text(
+    page: Page, locator: str, substring: str, timeout: int = 10000
+) -> Locator:
+    page.locator(locator).wait_for(state="visible", timeout=timeout)
+
+    page.wait_for_function(
+        f"() => document.querySelector('{locator}').innerText.includes('{substring}')",
+        timeout=timeout,
+    )
+
+    return page.locator(locator)

packages/pytest-simcore/src/pytest_simcore/helpers/webserver_login.py

@@ -11,8 +11,11 @@
 from simcore_service_webserver.db.models import UserRole, UserStatus
 from simcore_service_webserver.groups.api import auto_add_user_to_product_group
 from simcore_service_webserver.login._constants import MSG_LOGGED_IN
-from simcore_service_webserver.login._registration import create_invitation_token
-from simcore_service_webserver.login.storage import AsyncpgStorage, get_plugin_storage
+from simcore_service_webserver.login._invitations_service import create_invitation_token
+from simcore_service_webserver.login._login_repository_legacy import (
+    AsyncpgStorage,
+    get_plugin_storage,
+)
 from simcore_service_webserver.products.products_service import list_products
 from simcore_service_webserver.security.api import clean_auth_policy_cache
 from yarl import URL

packages/pytest-simcore/src/pytest_simcore/simcore_storage_data_models.py

@@ -18,7 +18,7 @@
 from sqlalchemy.dialects.postgresql import insert as pg_insert
 from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
 
-from .helpers.faker_factories import random_project, random_user
+from .helpers.faker_factories import DEFAULT_FAKER, random_project, random_user
 
 
 @asynccontextmanager
@@ -62,7 +62,7 @@ async def other_user_id(sqlalchemy_async_engine: AsyncEngine) -> AsyncIterator[U
 @pytest.fixture
 async def create_project(
     user_id: UserID, sqlalchemy_async_engine: AsyncEngine
-) -> AsyncIterator[Callable[[], Awaitable[dict[str, Any]]]]:
+) -> AsyncIterator[Callable[..., Awaitable[dict[str, Any]]]]:
     created_project_uuids = []
 
     async def _creator(**kwargs) -> dict[str, Any]:
@@ -71,7 +71,7 @@ async def _creator(**kwargs) -> dict[str, Any]:
         async with sqlalchemy_async_engine.begin() as conn:
             result = await conn.execute(
                 projects.insert()
-                .values(**random_project(**prj_config))
+                .values(**random_project(DEFAULT_FAKER, **prj_config))
                 .returning(sa.literal_column("*"))
             )
             row = result.one()

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/async_jobs/async_jobs.py

@@ -12,6 +12,7 @@
     AsyncJobResult,
     AsyncJobStatus,
 )
+from models_library.api_schemas_rpc_async_jobs.exceptions import JobMissingError
 from models_library.rabbitmq_basic_types import RPCMethodName, RPCNamespace
 from pydantic import NonNegativeInt, TypeAdapter
 from tenacity import (
@@ -20,6 +21,7 @@
     before_sleep_log,
     retry,
     retry_if_exception_type,
+    stop_after_attempt,
     stop_after_delay,
     wait_fixed,
     wait_random_exponential,
@@ -124,11 +126,11 @@ async def submit(
 
 
 _DEFAULT_RPC_RETRY_POLICY: dict[str, Any] = {
-    "retry": retry_if_exception_type(RemoteMethodNotRegisteredError),
+    "retry": retry_if_exception_type((RemoteMethodNotRegisteredError,)),
     "wait": wait_random_exponential(max=20),
-    "stop": stop_after_delay(60),
+    "stop": stop_after_attempt(30),
     "reraise": True,
-    "before_sleep": before_sleep_log(_logger, logging.INFO),
+    "before_sleep": before_sleep_log(_logger, logging.WARNING),
 }
 
 
@@ -146,7 +148,7 @@ async def _wait_for_completion(
         async for attempt in AsyncRetrying(
             stop=stop_after_delay(client_timeout.total_seconds()),
             reraise=True,
-            retry=retry_if_exception_type(TryAgain),
+            retry=retry_if_exception_type((TryAgain, JobMissingError)),
             before_sleep=before_sleep_log(_logger, logging.DEBUG),
             wait=wait_fixed(_DEFAULT_POLL_INTERVAL_S),
         ):
@@ -184,45 +186,72 @@ async def result(self) -> Any:
         return await self._result
 
 
-async def submit_and_wait(
+async def wait_and_get_result(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     rpc_namespace: RPCNamespace,
     method_name: str,
+    job_id: AsyncJobId,
     job_id_data: AsyncJobNameData,
     client_timeout: datetime.timedelta,
-    **kwargs,
 ) -> AsyncGenerator[AsyncJobComposedResult, None]:
-    async_job_rpc_get = None
+    """when a job is already submitted this will wait for its completion
+    and return the composed result"""
     try:
-        async_job_rpc_get = await submit(
-            rabbitmq_rpc_client,
-            rpc_namespace=rpc_namespace,
-            method_name=method_name,
-            job_id_data=job_id_data,
-            **kwargs,
-        )
-        job_status: AsyncJobStatus | None = None
+        job_status = None
         async for job_status in _wait_for_completion(
             rabbitmq_rpc_client,
             rpc_namespace=rpc_namespace,
             method_name=method_name,
-            job_id=async_job_rpc_get.job_id,
+            job_id=job_id,
             job_id_data=job_id_data,
             client_timeout=client_timeout,
         ):
             assert job_status is not None  # nosec
             yield AsyncJobComposedResult(job_status)
+
+        # return the result
         if job_status:
             yield AsyncJobComposedResult(
                 job_status,
                 result(
                     rabbitmq_rpc_client,
                     rpc_namespace=rpc_namespace,
-                    job_id=async_job_rpc_get.job_id,
+                    job_id=job_id,
                     job_id_data=job_id_data,
                 ),
             )
+    except (TimeoutError, CancelledError) as error:
+        try:
+            await cancel(
+                rabbitmq_rpc_client,
+                rpc_namespace=rpc_namespace,
+                job_id=job_id,
+                job_id_data=job_id_data,
+            )
+        except Exception as exc:
+            raise exc from error  # NOSONAR
+        raise
+
+
+async def submit_and_wait(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    rpc_namespace: RPCNamespace,
+    method_name: str,
+    job_id_data: AsyncJobNameData,
+    client_timeout: datetime.timedelta,
+    **kwargs,
+) -> AsyncGenerator[AsyncJobComposedResult, None]:
+    async_job_rpc_get = None
+    try:
+        async_job_rpc_get = await submit(
+            rabbitmq_rpc_client,
+            rpc_namespace=rpc_namespace,
+            method_name=method_name,
+            job_id_data=job_id_data,
+            **kwargs,
+        )
     except (TimeoutError, CancelledError) as error:
         if async_job_rpc_get is not None:
             try:
@@ -235,3 +264,13 @@ async def submit_and_wait(
             except Exception as exc:
                 raise exc from error
         raise
+
+    async for wait_and_ in wait_and_get_result(
+        rabbitmq_rpc_client,
+        rpc_namespace=rpc_namespace,
+        method_name=method_name,
+        job_id=async_job_rpc_get.job_id,
+        job_id_data=job_id_data,
+        client_timeout=client_timeout,
+    ):
+        yield wait_and_

services/static-webserver/client/source/class/osparc/data/PollTask.js

@@ -22,10 +22,10 @@
 qx.Class.define("osparc.data.PollTask", {
   extend: qx.core.Object,
 
-  construct: function(taskData, interval) {
+  construct: function(taskData, interval = 1000) {
     this.base(arguments);
 
-    interval ? this.setPollInterval(interval) : this.initPollInterval();
+    this.setPollInterval(interval);
 
     if (taskData && "task_id" in taskData) {
       this.set({

services/static-webserver/client/source/class/osparc/data/Resources.js

@@ -1241,26 +1241,6 @@ qx.Class.define("osparc.data.Resources", {
           }
         }
       },
-      /*
-       * STORAGE ASYNC
-       */
-      "storageAsyncJobs": {
-        useCache: false,
-        endpoints: {
-          jobStatus: {
-            method: "GET",
-            url: statics.API + "/storage/async-jobs/{jobId}/status"
-          },
-          jobResult: {
-            method: "GET",
-            url: statics.API + "/storage/async-jobs/{jobId}/result"
-          },
-          abortJob: {
-            method: "POST",
-            url: statics.API + "/storage/async-jobs/{jobId}/abort"
-          },
-        }
-      },
       /*
        * ACTIVITY
        */