pulpcore 3.89.1__py3-none-any.whl → 3.90.1__py3-none-any.whl

pulpcore/tasking/tasks.py

@@ -6,8 +6,9 @@ import os
 import sys
 import traceback
 import tempfile
-import threading
 from gettext import gettext as _
+from contextlib import contextmanager
+from asgiref.sync import sync_to_async, async_to_sync
 
 from django.conf import settings
 from django.db import connection
@@ -60,91 +61,129 @@ def execute_task(task):
     contextvars.copy_context().run(_execute_task, task)
 
 
+async def aexecute_task(task):
+    # This extra stack is needed to isolate the current_task ContextVar
+    await contextvars.copy_context().run(_aexecute_task, task)
+
+
 def _execute_task(task):
     # Store the task id in the context for `Task.current()`.
     current_task.set(task)
     task.set_running()
     domain = get_domain()
     try:
-        _logger.info(
-            "Starting task id: %s in domain: %s, task_type: %s, immediate: %s, deferred: %s",
-            task.pk,
-            domain.name,
-            task.name,
-            str(task.immediate),
-            str(task.deferred),
-        )
-
-        # Execute task
-        module_name, function_name = task.name.rsplit(".", 1)
-        module = importlib.import_module(module_name)
-        func = getattr(module, function_name)
-        args = task.enc_args or ()
-        kwargs = task.enc_kwargs or {}
-        immediate = task.immediate
-        is_coroutine_fn = asyncio.iscoroutinefunction(func)
-
-        if immediate and not is_coroutine_fn:
-            raise ValueError("Immediate tasks must be async functions.")
-
-        if is_coroutine_fn:
-            # both regular and immediate tasks can be coroutines, but only immediate must timeout
-            _logger.debug("Task is coroutine %s", task.pk)
-            coro = func(*args, **kwargs)
-            if immediate:
-                coro = asyncio.wait_for(coro, timeout=IMMEDIATE_TIMEOUT)
-            loop = asyncio.get_event_loop()
-            try:
-                result = loop.run_until_complete(coro)
-            except asyncio.TimeoutError:
-                _logger.info(
-                    "Immediate task %s timed out after %s seconds.", task.pk, IMMEDIATE_TIMEOUT
-                )
-                raise RuntimeError(
-                    "Immediate task timed out after {timeout} seconds.".format(
-                        timeout=IMMEDIATE_TIMEOUT,
-                    )
-                )
-        else:
-            result = func(*args, **kwargs)
-
+        log_task_start(task, domain)
+        task_function = get_task_function(task)
+        result = task_function()
     except Exception:
         exc_type, exc, tb = sys.exc_info()
         task.set_failed(exc, tb)
-        _logger.info(
-            "Task[{task_type}] {task_pk} failed ({exc_type}: {exc}) in domain: {domain}".format(
-                task_type=task.name,
-                task_pk=task.pk,
-                exc_type=exc_type.__name__,
-                exc=exc,
-                domain=domain.name,
-            )
-        )
-        _logger.info("\n".join(traceback.format_list(traceback.extract_tb(tb))))
+        log_task_failed(task, exc_type, exc, tb, domain)
         send_task_notification(task)
     else:
         task.set_completed(result)
-        execution_time = task.finished_at - task.started_at
-        execution_time_us = int(execution_time.total_seconds() * 1_000_000)  # μs
-        _logger.info(
-            "Task completed %s in domain:"
-            " %s, task_type: %s, immediate: %s, deferred: %s, execution_time: %s μs",
-            task.pk,
-            domain.name,
-            task.name,
-            str(task.immediate),
-            str(task.deferred),
-            execution_time_us,
-        )
+        log_task_completed(task, domain)
+        send_task_notification(task)
+        return result
+    return None
+
+
+async def _aexecute_task(task):
+    # Store the task id in the context for `Task.current()`.
+    current_task.set(task)
+    await sync_to_async(task.set_running)()
+    domain = get_domain()
+    try:
+        coroutine = get_task_function(task, ensure_coroutine=True)
+        result = await coroutine
+    except Exception:
+        exc_type, exc, tb = sys.exc_info()
+        await sync_to_async(task.set_failed)(exc, tb)
+        log_task_failed(task, exc_type, exc, tb, domain)
+        send_task_notification(task)
+    else:
+        await sync_to_async(task.set_completed)(result)
         send_task_notification(task)
+        log_task_completed(task, domain)
+        return result
+    return None
+
 
+def log_task_start(task, domain):
+    _logger.info(
+        "Starting task id: %s in domain: %s, task_type: %s, immediate: %s, deferred: %s",
+        task.pk,
+        domain.name,
+        task.name,
+        str(task.immediate),
+        str(task.deferred),
+    )
 
-def running_from_thread_pool() -> bool:
-    # TODO: this needs an alternative approach ASAP!
-    # Currently we rely on the weak fact that ThreadPoolExecutor names threads like:
-    # "ThreadPoolExecutor-0_0"
-    thread_name = threading.current_thread().name
-    return "ThreadPoolExecutor" in thread_name
+
+def log_task_completed(task, domain):
+    execution_time = task.finished_at - task.started_at
+    execution_time_us = int(execution_time.total_seconds() * 1_000_000)  # μs
+    _logger.info(
+        "Task completed %s in domain:"
+        " %s, task_type: %s, immediate: %s, deferred: %s, execution_time: %s μs",
+        task.pk,
+        domain.name,
+        task.name,
+        str(task.immediate),
+        str(task.deferred),
+        execution_time_us,
+    )
+
+
+def log_task_failed(task, exc_type, exc, tb, domain):
+    _logger.info(
+        "Task[{task_type}] {task_pk} failed ({exc_type}: {exc}) in domain: {domain}".format(
+            task_type=task.name,
+            task_pk=task.pk,
+            exc_type=exc_type.__name__,
+            exc=exc,
+            domain=domain.name,
+        )
+    )
+    _logger.info("\n".join(traceback.format_list(traceback.extract_tb(tb))))
+
+
+def get_task_function(task, ensure_coroutine=False):
+    module_name, function_name = task.name.rsplit(".", 1)
+    module = importlib.import_module(module_name)
+    func = getattr(module, function_name)
+    args = task.enc_args or ()
+    kwargs = task.enc_kwargs or {}
+    immediate = task.immediate
+    is_coroutine_fn = asyncio.iscoroutinefunction(func)
+
+    if immediate and not is_coroutine_fn:
+        raise ValueError("Immediate tasks must be async functions.")
+
+    if ensure_coroutine:
+        if not is_coroutine_fn:
+            return sync_to_async(func)(*args, **kwargs)
+        coro = func(*args, **kwargs)
+        if immediate:
+            coro = asyncio.wait_for(coro, timeout=IMMEDIATE_TIMEOUT)
+        return coro
+    else:  # ensure normal function
+        if not is_coroutine_fn:
+            return lambda: func(*args, **kwargs)
+
+        async def task_wrapper():  # asyncio.wait_for + async_to_sync requires wrapping
+            coro = func(*args, **kwargs)
+            if immediate:
+                coro = asyncio.wait_for(coro, timeout=IMMEDIATE_TIMEOUT)
+            try:
+                return await coro
+            except asyncio.TimeoutError:
+                msg_template = "Immediate task %s timed out after %s seconds."
+                error_msg = msg_template % (task.pk, IMMEDIATE_TIMEOUT)
+                _logger.info(error_msg)
+                raise RuntimeError(error_msg)
+
+        return async_to_sync(task_wrapper)
 
 
 def dispatch(
@@ -194,18 +233,148 @@ def dispatch(
         ValueError: When `resources` is an unsupported type.
     """
 
-    # Can't run short tasks immediately if running from thread pool
-    immediate = immediate and not running_from_thread_pool()
+    execute_now = immediate and not called_from_content_app()
+    assert deferred or immediate, "A task must be at least `deferred` or `immediate`."
+    send_wakeup_signal = True if not immediate else False
+    function_name = get_function_name(func)
+    versions = get_version(versions, function_name)
+    colliding_resources, resources = get_resources(exclusive_resources, shared_resources, immediate)
+    task_payload = get_task_payload(
+        function_name, task_group, args, kwargs, resources, versions, immediate, deferred
+    )
+    task = Task.objects.create(**task_payload)
+    task.refresh_from_db()  # The database will have assigned a timestamp for us.
+    if execute_now:
+        if are_resources_available(colliding_resources, task):
+            send_wakeup_signal = True if resources else False
+            task.unblock()
+            with using_workdir():
+                execute_task(task)
+        elif deferred:  # Resources are blocked and can be deferred
+            task.app_lock = None
+            task.save()
+        else:  # Can't be deferred
+            task.set_canceling()
+            task.set_canceled(TASK_STATES.CANCELED, "Resources temporarily unavailable.")
+    if send_wakeup_signal:
+        wakeup_worker(TASK_WAKEUP_UNBLOCK)
+    return task
+
+
+async def adispatch(
+    func,
+    args=None,
+    kwargs=None,
+    task_group=None,
+    exclusive_resources=None,
+    shared_resources=None,
+    immediate=False,
+    deferred=True,
+    versions=None,
+):
+    """Async version of dispatch."""
+    execute_now = immediate and not called_from_content_app()
     assert deferred or immediate, "A task must be at least `deferred` or `immediate`."
+    function_name = get_function_name(func)
+    versions = get_version(versions, function_name)
+    colliding_resources, resources = get_resources(exclusive_resources, shared_resources, immediate)
+    send_wakeup_signal = False
+    task_payload = get_task_payload(
+        function_name, task_group, args, kwargs, resources, versions, immediate, deferred
+    )
+    task = await Task.objects.acreate(**task_payload)
+    await task.arefresh_from_db()  # The database will have assigned a timestamp for us.
+    if execute_now:
+        if await async_are_resources_available(colliding_resources, task):
+            send_wakeup_signal = True if resources else False
+            await task.aunblock()
+            with using_workdir():
+                await aexecute_task(task)
+        elif deferred:  # Resources are blocked and can be deferred
+            task.app_lock = None
+            await task.asave()
+        else:  # Can't be deferred
+            task.set_canceling()
+            task.set_canceled(TASK_STATES.CANCELED, "Resources temporarily unavailable.")
+    if send_wakeup_signal:
+        await sync_to_async(wakeup_worker)(TASK_WAKEUP_UNBLOCK)
+    return task
+
+
+def get_task_payload(
+    function_name, task_group, args, kwargs, resources, versions, immediate, deferred
+):
+    payload = {
+        "state": TASK_STATES.WAITING,
+        "logging_cid": (get_guid()),
+        "task_group": task_group,
+        "name": function_name,
+        "enc_args": args,
+        "enc_kwargs": kwargs,
+        "parent_task": Task.current(),
+        "reserved_resources_record": resources,
+        "versions": versions,
+        "immediate": immediate,
+        "deferred": deferred,
+        "profile_options": x_task_diagnostics_var.get(None),
+        "app_lock": None if not immediate else AppStatus.objects.current(),  # Lazy evaluation...
+    }
+    return payload
+
+
+@contextmanager
+def using_workdir():
+    cur_dir = os.getcwd()
+    with tempfile.TemporaryDirectory(dir=settings.WORKING_DIRECTORY) as working_dir:
+        os.chdir(working_dir)
+        try:
+            yield
+        finally:
+            # Whether the task fails or not, we should always restore the workdir.
+            os.chdir(cur_dir)
+
 
+async def async_are_resources_available(colliding_resources, task: Task) -> bool:
+    prior_tasks = Task.objects.filter(
+        state__in=TASK_INCOMPLETE_STATES, pulp_created__lt=task.pulp_created
+    )
+    colliding_resources_taken = await prior_tasks.filter(
+        reserved_resources_record__overlap=colliding_resources
+    ).aexists()
+    return not colliding_resources or not colliding_resources_taken
+
+
+def are_resources_available(colliding_resources, task: Task) -> bool:
+    prior_tasks = Task.objects.filter(
+        state__in=TASK_INCOMPLETE_STATES, pulp_created__lt=task.pulp_created
+    )
+    colliding_resources_taken = prior_tasks.filter(
+        reserved_resources_record__overlap=colliding_resources
+    ).exists()
+    return not colliding_resources or not colliding_resources_taken
+
+
+def called_from_content_app() -> bool:
+    current_app = AppStatus.objects.current()
+    return current_app is not None and current_app.app_type == "content"
+
+
+def get_function_name(func):
     if callable(func):
         function_name = f"{func.__module__}.{func.__name__}"
     else:
         function_name = func
+    return function_name
+
 
+def get_version(versions, function_name):
     if versions is None:
         versions = MODULE_PLUGIN_VERSIONS[function_name.split(".", maxsplit=1)[0]]
+    return versions
+
 
+def get_resources(exclusive_resources, shared_resources, immediate):
+    domain_prn = get_prn(get_domain())
     if exclusive_resources is None:
         exclusive_resources = []
     else:
@@ -216,70 +385,19 @@ def dispatch(
         shared_resources = _validate_and_get_resources(shared_resources)
 
     # A task that is exclusive on a domain will block all tasks within that domain
-    domain_prn = get_prn(get_domain())
     if domain_prn not in exclusive_resources:
         shared_resources.append(domain_prn)
     resources = exclusive_resources + [f"shared:{resource}" for resource in shared_resources]
 
-    notify_workers = False
-    task = Task.objects.create(
-        state=TASK_STATES.WAITING,
-        logging_cid=(get_guid()),
-        task_group=task_group,
-        name=function_name,
-        enc_args=args,
-        enc_kwargs=kwargs,
-        parent_task=Task.current(),
-        reserved_resources_record=resources,
-        versions=versions,
-        immediate=immediate,
-        deferred=deferred,
-        profile_options=x_task_diagnostics_var.get(None),
-        app_lock=None if not immediate else AppStatus.objects.current(),  # Lazy evaluation...
-    )
-    task.refresh_from_db()  # The database will have assigned a timestamp for us.
+    # Compile a list of resources that must not be taken by other tasks.
+    colliding_resources = []
     if immediate:
-        prior_tasks = Task.objects.filter(
-            state__in=TASK_INCOMPLETE_STATES, pulp_created__lt=task.pulp_created
-        )
-        # Compile a list of resources that must not be taken by other tasks.
         colliding_resources = (
             shared_resources
             + exclusive_resources
             + [f"shared:{resource}" for resource in exclusive_resources]
         )
-        # Can we execute this task immediately?
-        if (
-            not colliding_resources
-            or not prior_tasks.filter(
-                reserved_resources_record__overlap=colliding_resources
-            ).exists()
-        ):
-            task.unblock()
-
-            cur_dir = os.getcwd()
-            with tempfile.TemporaryDirectory(dir=settings.WORKING_DIRECTORY) as working_dir:
-                os.chdir(working_dir)
-                try:
-                    execute_task(task)
-                finally:
-                    # Whether the task fails or not, we should always restore the workdir.
-                    os.chdir(cur_dir)
-
-            if resources:
-                notify_workers = True
-        elif deferred:
-            # Resources are blocked. Let the others handle it.
-            task.app_lock = None
-            task.save()
-        else:
-            task.set_canceling()
-            task.set_canceled(TASK_STATES.CANCELED, "Resources temporarily unavailable.")
-    else:
-        notify_workers = True
-    if notify_workers:
-        wakeup_worker(TASK_WAKEUP_UNBLOCK)
-    return task
+    return colliding_resources, resources
 
 
 def cancel_task(task_id):

pulpcore/tasking/worker.py

@@ -28,7 +28,7 @@ from pulpcore.constants import (
 )
 from pulpcore.metrics import init_otel_meter
 from pulpcore.app.apps import pulp_plugin_configs
-from pulpcore.app.models import Worker, Task, AppStatus, ApiAppStatus, ContentAppStatus
+from pulpcore.app.models import Task, AppStatus
 from pulpcore.app.util import PGAdvisoryLock
 from pulpcore.exceptions import AdvisoryLockError
 
@@ -142,7 +142,7 @@ class PulpcoreWorker:
             elif notification.payload == TASK_WAKEUP_HANDLE:
                 self.wakeup_handle = True
             else:
-                _logger.warn("Unknown wakeup call recieved. Reason: '%s'", notification.payload)
+                _logger.warning("Unknown wakeup call recieved. Reason: '%s'", notification.payload)
                 # We cannot be sure so assume everything happened.
                 self.wakeup_unblock = not self.auxiliary
                 self.wakeup_handle = True
@@ -188,21 +188,15 @@ class PulpcoreWorker:
             self.ignored_task_ids.remove(pk)
 
     def worker_cleanup(self):
-        qs = AppStatus.objects.older_than(age=timedelta(days=7))
+        qs = AppStatus.objects.missing()
         for app_worker in qs:
-            _logger.info(_("Clean missing %s worker %s."), app_worker.app_type, app_worker.name)
+            _logger.warning(
+                "Cleanup record of missing %s process %s.", app_worker.app_type, app_worker.name
+            )
         qs.delete()
-        with contextlib.suppress(DatabaseError):
-            # By now a migration on a newer release may have deleted these tables already.
-            for cls, cls_name in (
-                (Worker, "pulp"),
-                (ApiAppStatus, "api"),
-                (ContentAppStatus, "content"),
-            ):
-                qs = cls.objects.missing(age=timedelta(days=7))
-                for app_worker in qs:
-                    _logger.info(_("Clean missing %s worker %s."), cls_name, app_worker.name)
-                qs.delete()
+        # This will also serve as a pacemaker because it will be triggered regularly.
+        # Don't bother the others.
+        self.wakeup_unblock = True
 
     def beat(self):
         if self.app_status.last_heartbeat < timezone.now() - self.heartbeat_period:
@@ -223,7 +217,7 @@ class PulpcoreWorker:
                 # to be able to report on a congested tasking system to produce reliable results.
                 self.record_unblocked_waiting_tasks_metric()
 
-    def notify_workers(self, reason="unknown"):
+    def notify_workers(self, reason):
         self.cursor.execute("SELECT pg_notify('pulp_worker_wakeup', %s)", (reason,))
 
     def cancel_abandoned_task(self, task, final_state, reason=None):
@@ -283,25 +277,28 @@ class PulpcoreWorker:
         Also it clears the notification about tasks to be unblocked and sends the notification that
         new unblocked tasks are made available.
 
-        Returns the number of new unblocked tasks.
+        Returns None if another worker held the lock, True if unblocked tasks exist, else False.
         """
 
         assert not self.auxiliary
 
-        count = 0
-        self.wakeup_unblock_tasks = False
+        self.wakeup_unblock = False
         with contextlib.suppress(AdvisoryLockError), PGAdvisoryLock(TASK_UNBLOCKING_LOCK):
-            if count := self._unblock_tasks():
+            self._unblock_tasks()
+
+            if (
+                Task.objects.filter(state__in=TASK_INCOMPLETE_STATES, app_lock=None)
+                .exclude(unblocked_at=None)
+                .exists()
+            ):
                 self.notify_workers(TASK_WAKEUP_HANDLE)
-        return count
+                return True
+            return False
+        return None
 
     def _unblock_tasks(self):
-        """Iterate over waiting tasks and mark them unblocked accordingly.
+        """Iterate over waiting tasks and mark them unblocked accordingly."""
 
-        Returns the number of new unblocked tasks.
-        """
-
-        count = 0
         taken_exclusive_resources = set()
         taken_shared_resources = set()
         # When batching this query, be sure to use "pulp_created" as a cursor
@@ -329,9 +326,6 @@ class PulpcoreWorker:
                         task.pulp_domain.name,
                     )
                     task.unblock()
-                    count += 1
-                # Don't consider this task's resources as held.
-                continue
 
             elif (
                 task.state == TASK_STATES.WAITING
@@ -350,7 +344,6 @@ class PulpcoreWorker:
                     task.pulp_domain.name,
                 )
                 task.unblock()
-                count += 1
             elif task.state == TASK_STATES.RUNNING and task.unblocked_at is None:
                 # This should not happen in normal operation.
                 # And it is only an issue if the worker running that task died, because it will
@@ -367,21 +360,22 @@ class PulpcoreWorker:
             taken_exclusive_resources.update(exclusive_resources)
             taken_shared_resources.update(shared_resources)
 
-        return count
-
     def sleep(self):
         """Wait for signals on the wakeup channel while heart beating."""
 
         _logger.debug(_("Worker %s entering sleep state."), self.name)
         while not self.shutdown_requested and not self.wakeup_handle:
             r, w, x = select.select(
-                [self.sentinel, connection.connection], [], [], self.heartbeat_period.seconds
+                [self.sentinel, connection.connection],
+                [],
+                [],
+                0 if self.wakeup_unblock else self.heartbeat_period.seconds,
             )
             self.beat()
             if connection.connection in r:
                 connection.connection.execute("SELECT 1")
-                if self.wakeup_unblock:
-                    self.unblock_tasks()
+            if self.wakeup_unblock:
+                self.unblock_tasks()
             if self.sentinel in r:
                 os.read(self.sentinel, 256)
         _logger.debug(_("Worker %s leaving sleep state."), self.name)
@@ -418,21 +412,21 @@ class PulpcoreWorker:
                     [self.sentinel, connection.connection, task_process.sentinel],
                     [],
                     [],
-                    self.heartbeat_period.seconds,
+                    0 if self.wakeup_unblock or self.cancel_task else self.heartbeat_period.seconds,
                 )
                 self.beat()
                 if connection.connection in r:
                     connection.connection.execute("SELECT 1")
-                    if self.cancel_task:
-                        _logger.info(
-                            _("Received signal to cancel current task %s in domain: %s."),
-                            task.pk,
-                            domain.name,
-                        )
-                        cancel_state = TASK_STATES.CANCELED
-                        self.cancel_task = False
-                    if self.wakeup_unblock:
-                        self.unblock_tasks()
+                if self.cancel_task:
+                    _logger.info(
+                        _("Received signal to cancel current task %s in domain: %s."),
+                        task.pk,
+                        domain.name,
+                    )
+                    cancel_state = TASK_STATES.CANCELED
+                    self.cancel_task = False
+                if self.wakeup_unblock:
+                    self.unblock_tasks()
                 if task_process.sentinel in r:
                     if not task_process.is_alive():
                         break
@@ -600,7 +594,7 @@ class PulpcoreWorker:
                 if not self.auxiliary:
                     # Attempt to flush the task queue completely.
                     # Stop iteration if no new tasks were found to unblock.
-                    while self.unblock_tasks():
+                    while self.unblock_tasks() is not False:
                         self.handle_unblocked_tasks()
                 self.handle_unblocked_tasks()
             else:

pulpcore/tests/functional/api/test_crud_domains.py

@@ -44,6 +44,13 @@ def test_crud_domains(pulpcore_bindings, monitor_task):
     valid_settings["location"] = "/testing/"
     assert domain.storage_settings == valid_settings
 
+    # An update request with no changes should return a 200 OK (without dispatching a task)
+    response = pulpcore_bindings.DomainsApi.partial_update_with_http_info(
+        domain.pulp_href, update_body
+    )
+    assert response.status_code == 200
+    assert response.data == domain
+
     # Delete the domain
     response = pulpcore_bindings.DomainsApi.delete(domain.pulp_href)
     monitor_task(response.task)

pulpcore/tests/functional/api/test_tasking.py

@@ -484,7 +484,7 @@ class TestImmediateTaskWithNoResource:
         )
         task = pulpcore_bindings.TasksApi.read(task_href)
         assert task.state == "failed"
-        assert "task timed out after" in task.error["description"]
+        assert "timed out after" in task.error["description"]
 
 
 @pytest.fixture
@@ -576,4 +576,4 @@ class TestImmediateTaskWithBlockedResource:
                     exclusive_resources=[COMMON_RESOURCE],
                 )
             monitor_task(task_href)
-        assert "task timed out after" in ctx.value.task.error["description"]
+        assert "timed out after" in ctx.value.task.error["description"]

pulpcore/tests/functional/api/using_plugin/test_crud_repos.py

@@ -208,6 +208,11 @@ def test_crud_remotes_full_workflow(
     new_remote = file_bindings.RemotesFileApi.read(remote.pulp_href)
     _compare_results(data, new_remote)
 
+    # An update request with no changes should return a 200 OK (without dispatching a task)
+    response = file_bindings.RemotesFileApi.partial_update_with_http_info(remote.pulp_href, data)
+    assert response.status_code == 200
+    _compare_results(data, response.data)
+
     # Test that a password can be updated with a PUT request.
     temp_remote = file_remote_factory(
         manifest_path=basic_manifest_path, url="http://", password="new"
@@ -226,6 +231,7 @@ def test_crud_remotes_full_workflow(
     assert exc.stdout.rstrip("\n") == "changed"
 
     # Test that password doesn't get unset when not passed with a PUT request.
+    # QUESTION: Why not? PUT is supposed to replace the whole entity in place.
     temp_remote = file_remote_factory(url="http://", password="new")
     href = temp_remote.pulp_href
     uuid = re.search(r"/api/v3/remotes/file/file/([\w-]+)/", href).group(1)
@@ -235,8 +241,9 @@ def test_crud_remotes_full_workflow(
 
     # test a PUT request without a password
     remote_update = {"name": temp_remote.name, "url": "http://"}
-    response = file_bindings.RemotesFileApi.update(href, remote_update)
-    monitor_task(response.task)
+    response = file_bindings.RemotesFileApi.update_with_http_info(href, remote_update)
+    assert response.status_code == 200
+    _compare_results(remote_update, response.data)
     exc = run(["pulpcore-manager", "shell", "-c", shell_cmd], text=True, capture_output=True)
     assert exc.stdout.rstrip("\n") == "new"