lockable_resources: use abstract Retry class in API

Author: cdleonard

jenkinsapi/lockable_resources.py

@@ -1,5 +1,4 @@
 import logging
-import time
 from typing import (
     TYPE_CHECKING,
     Dict,
@@ -15,6 +14,7 @@
 from jenkinsapi.custom_exceptions import JenkinsAPIException
 from jenkinsapi.jenkinsbase import JenkinsBase
 from jenkinsapi.utils.requester import Requester
+from jenkinsapi.utils.retry import Retry, SimpleRetry
 
 if TYPE_CHECKING:
     from jenkinsapi.jenkins import Jenkins
@@ -226,67 +226,59 @@ def try_reserve(
     def wait_reserve(
         self,
         selector: "ResourceSelector",
-        sleep_period: float = DEFAULT_WAIT_SLEEP_PERIOD,
-        timeout: float = DEFAULT_WAIT_TIMEOUT_PERIOD,
+        retry: Optional[Retry] = None,
     ) -> str:
         """
         Reserve a resource that matches the given condition
 
         :return: the name of the reserved resource
         :raise TimeoutError: if no resource could be reserved
         """
-        start_time = time.time()
+        if retry is None:
+            retry = SimpleRetry(
+                sleep_period=self.DEFAULT_WAIT_SLEEP_PERIOD,
+                timeout=self.DEFAULT_WAIT_TIMEOUT_PERIOD,
+            )
+        retry.begin()
         while True:
             result = self.try_reserve(selector)
             if result is not None:
                 return result
-            if time.time() - start_time > timeout:
-                raise TimeoutError("Timed out waiting for resource")
-            logger.info(
-                "No free resources matching %r, sleep %.3f seconds",
-                selector,
-                sleep_period,
-            )
+            retry.check()
+            logger.info("No free resources matching %r, retry", selector)
             self.poll()
-            time.sleep(sleep_period)
 
     def reservation_by_label(
         self,
         label: str,
-        sleep_period: float = DEFAULT_WAIT_SLEEP_PERIOD,
-        timeout: float = DEFAULT_WAIT_TIMEOUT_PERIOD,
+        retry: Optional[Retry] = None,
     ) -> "LockedResourceReservation":
         return LockedResourceReservation(
             self,
             ResourceLabelSelector(label),
-            sleep_period=sleep_period,
-            timeout=timeout,
+            retry=retry,
         )
 
     def reservation_by_name(
         self,
         name: str,
-        sleep_period: float = DEFAULT_WAIT_SLEEP_PERIOD,
-        timeout: float = DEFAULT_WAIT_TIMEOUT_PERIOD,
+        retry: Optional[Retry] = None,
     ) -> "LockedResourceReservation":
         return LockedResourceReservation(
             self,
             ResourceNameSelector(name),
-            sleep_period=sleep_period,
-            timeout=timeout,
+            retry=retry,
         )
 
     def reservation_by_name_list(
         self,
         name_list: List[str],
-        sleep_period: float = DEFAULT_WAIT_SLEEP_PERIOD,
-        timeout: float = DEFAULT_WAIT_TIMEOUT_PERIOD,
+        retry: Optional[Retry] = None,
     ) -> "LockedResourceReservation":
         return LockedResourceReservation(
             self,
             ResourceNameListSelector(name_list),
-            sleep_period=sleep_period,
-            timeout=timeout,
+            retry=retry,
         )
 
 
@@ -363,13 +355,11 @@ def __init__(
         self,
         api: LockableResources,
         selector: ResourceSelector,
-        sleep_period: float = LockableResources.DEFAULT_WAIT_SLEEP_PERIOD,
-        timeout: float = LockableResources.DEFAULT_WAIT_TIMEOUT_PERIOD,
+        retry: Optional[Retry] = None,
     ):
         self.api = api
         self.selector = selector
-        self.sleep_period = sleep_period
-        self.timeout = timeout
+        self.retry = retry
 
     @property
     def locked_resource_name(self) -> str:
@@ -387,7 +377,7 @@ def __enter__(self) -> "LockedResourceReservation":
         if self._locked_resource_name is not None:
             raise RuntimeError("Lock already acquired")
         self._locked_resource_name = self.api.wait_reserve(
-            self.selector, sleep_period=self.sleep_period, timeout=self.timeout
+            self.selector, retry=self.retry
         )
         self.locked = True
         return self

jenkinsapi_tests/systests/test_lockable_resources.py

@@ -1,3 +1,5 @@
+from contextlib import ExitStack
+from unittest import mock
 import pytest
 
 from jenkinsapi.jenkins import Jenkins
@@ -7,6 +9,7 @@
     ResourceLockedError,
 )
 from jenkinsapi.utils.jenkins_launcher import JenkinsLancher
+from jenkinsapi.utils.retry import SimpleRetry
 
 GROOVY_SCRIPT_INIT_TEST_RESOURCES = """
 import org.jenkins.plugins.lockableresources.*
@@ -158,3 +161,44 @@ def test_reservation_by_label(
         assert locked_resource.is_free() is False
         assert test_lock_label in locked_resource.data["labelsAsList"]
     assert locked_resource.is_free() is True
+
+
+def test_custom_retry(
+    lockable_resources: LockableResources,
+    test_lock_name: str,
+):
+    with ExitStack() as exit_stack:
+        exit_stack.enter_context(
+            mock.patch(
+                "time.monotonic",
+                side_effect=range(1000, 10000),
+            )
+        )
+        mock_time_sleep = exit_stack.enter_context(
+            mock.patch("time.sleep"),
+        )
+        mock_try_reserve = exit_stack.enter_context(
+            mock.patch.object(
+                lockable_resources,
+                "try_reserve",
+                return_value=None,
+            )
+        )
+        mock_poll = exit_stack.enter_context(
+            mock.patch.object(
+                lockable_resources,
+                "poll",
+            )
+        )
+        exit_stack.enter_context(pytest.raises(TimeoutError))
+        with lockable_resources.reservation_by_name(
+            test_lock_name,
+            retry=SimpleRetry(
+                sleep_period=1,
+                timeout=5.5,
+            ),
+        ):
+            pass
+    assert mock_time_sleep.call_count == 5
+    assert mock_try_reserve.call_count == 6
+    assert mock_poll.call_count == 5