Fill in get_retry_limiter

Author: MadLittleMods

synapse/federation/sender/per_destination_queue.py

@@ -91,7 +91,7 @@ def __init__(
         transaction_manager: "synapse.federation.sender.TransactionManager",
         destination: str,
     ):
-        self._server_name = hs.hostname
+        self.server_name = hs.hostname
         self._clock = hs.get_clock()
         self._storage_controllers = hs.get_storage_controllers()
         self._store = hs.get_datastores().main
@@ -323,7 +323,12 @@ async def _transaction_transmission_loop(self) -> None:
             # This will throw if we wouldn't retry. We do this here so we fail
             # quickly, but we will later check this again in the http client,
             # hence why we throw the result away.
-            await get_retry_limiter(self._destination, self._clock, self._store)
+            await get_retry_limiter(
+                destination=self._destination,
+                our_server_name=self.server_name,
+                clock=self._clock,
+                store=self._store,
+            )
 
             if self._catching_up:
                 # we potentially need to catch-up first
@@ -567,7 +572,7 @@ async def _catch_up_transmission_loop(self) -> None:
                     new_pdus = await filter_events_for_server(
                         self._storage_controllers,
                         self._destination,
-                        self._server_name,
+                        self.server_name,
                         new_pdus,
                         redact=False,
                         filter_out_erased_senders=True,
@@ -614,7 +619,7 @@ def _get_receipt_edus(self, limit: int) -> Iterable[Edu]:
         # Send at most limit EDUs for receipts.
         for content in self._pending_receipt_edus[:limit]:
             yield Edu(
-                origin=self._server_name,
+                origin=self.server_name,
                 destination=self._destination,
                 edu_type=EduTypes.RECEIPT,
                 content=content,
@@ -640,7 +645,7 @@ async def _get_device_update_edus(self, limit: int) -> Tuple[List[Edu], int]:
         )
         edus = [
             Edu(
-                origin=self._server_name,
+                origin=self.server_name,
                 destination=self._destination,
                 edu_type=edu_type,
                 content=content,
@@ -667,7 +672,7 @@ async def _get_to_device_message_edus(self, limit: int) -> Tuple[List[Edu], int]
 
         edus = [
             Edu(
-                origin=self._server_name,
+                origin=self.server_name,
                 destination=self._destination,
                 edu_type=EduTypes.DIRECT_TO_DEVICE,
                 content=content,

synapse/http/matrixfederationclient.py

@@ -619,9 +619,10 @@ async def _send_request(
             raise FederationDeniedError(request.destination)
 
         limiter = await synapse.util.retryutils.get_retry_limiter(
-            request.destination,
-            self.clock,
-            self._store,
+            destination=request.destination,
+            our_server_name=self.server_name,
+            clock=self.clock,
+            store=self._store,
             backoff_on_404=backoff_on_404,
             ignore_backoff=ignore_backoff,
             notifier=self.hs.get_notifier(),

synapse/util/retryutils.py

@@ -59,6 +59,7 @@ def __init__(self, retry_last_ts: int, retry_interval: int, destination: str):
 
 
 async def get_retry_limiter(
+    *,
     destination: str,
     our_server_name: str,
     clock: Clock,
@@ -84,7 +85,12 @@ async def get_retry_limiter(
     Example usage:
 
         try:
-            limiter = await get_retry_limiter(destination, clock, store)
+            limiter = await get_retry_limiter(
+                destination=destination,
+                our_server_name=self.server_name,
+                clock=clock,
+                store=store,
+            )
             with limiter:
                 response = await do_request()
         except NotRetryingDestination:

tests/util/test_retryutils.py

@@ -31,7 +31,14 @@ class RetryLimiterTestCase(HomeserverTestCase):
     def test_new_destination(self) -> None:
         """A happy-path case with a new destination and a successful operation"""
         store = self.hs.get_datastores().main
-        limiter = self.get_success(get_retry_limiter("test_dest", self.clock, store))
+        limiter = self.get_success(
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            )
+        )
 
         # advance the clock a bit before making the request
         self.pump(1)
@@ -46,7 +53,14 @@ def test_limiter(self) -> None:
         """General test case which walks through the process of a failing request"""
         store = self.hs.get_datastores().main
 
-        limiter = self.get_success(get_retry_limiter("test_dest", self.clock, store))
+        limiter = self.get_success(
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            )
+        )
 
         min_retry_interval_ms = (
             self.hs.config.federation.destination_min_retry_interval_ms
@@ -72,15 +86,28 @@ def test_limiter(self) -> None:
 
         # now if we try again we should get a failure
         self.get_failure(
-            get_retry_limiter("test_dest", self.clock, store), NotRetryingDestination
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            ),
+            NotRetryingDestination,
         )
 
         #
         # advance the clock and try again
         #
 
         self.pump(min_retry_interval_ms)
-        limiter = self.get_success(get_retry_limiter("test_dest", self.clock, store))
+        limiter = self.get_success(
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            )
+        )
 
         self.pump(1)
         try:
@@ -108,7 +135,14 @@ def test_limiter(self) -> None:
         # one more go, with success
         #
         self.reactor.advance(min_retry_interval_ms * retry_multiplier * 2.0)
-        limiter = self.get_success(get_retry_limiter("test_dest", self.clock, store))
+        limiter = self.get_success(
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            )
+        )
 
         self.pump(1)
         with limiter:
@@ -129,9 +163,10 @@ def test_notifier_replication(self) -> None:
 
         limiter = self.get_success(
             get_retry_limiter(
-                "test_dest",
-                self.clock,
-                store,
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
                 notifier=notifier,
                 replication_client=replication_client,
             )
@@ -199,7 +234,14 @@ def test_max_retry_interval(self) -> None:
             self.hs.config.federation.destination_max_retry_interval_ms
         )
 
-        self.get_success(get_retry_limiter("test_dest", self.clock, store))
+        self.get_success(
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            )
+        )
         self.pump(1)
 
         failure_ts = self.clock.time_msec()
@@ -216,12 +258,25 @@ def test_max_retry_interval(self) -> None:
 
         # Check it fails
         self.get_failure(
-            get_retry_limiter("test_dest", self.clock, store), NotRetryingDestination
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            ),
+            NotRetryingDestination,
         )
 
         # Get past retry_interval and we can try again, and still throw an error to continue the backoff
         self.reactor.advance(destination_max_retry_interval_ms / 1000 + 1)
-        limiter = self.get_success(get_retry_limiter("test_dest", self.clock, store))
+        limiter = self.get_success(
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            )
+        )
         self.pump(1)
         try:
             with limiter:
@@ -239,5 +294,11 @@ def test_max_retry_interval(self) -> None:
 
         # Check it fails
         self.get_failure(
-            get_retry_limiter("test_dest", self.clock, store), NotRetryingDestination
+            get_retry_limiter(
+                destination="test_dest",
+                our_server_name=self.hs.hostname,
+                clock=self.clock,
+                store=store,
+            ),
+            NotRetryingDestination,
         )