vortexpy 4.3.9__tar.gz → 4.3.11__tar.gz

{vortexpy-4.3.9 → vortexpy-4.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.3.9
+Version: 4.3.11
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-4.3.9 → vortexpy-4.3.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.3.9"
+version = "4.3.11"
 license = {text = "MIT"}
 authors = [{name = "Flying Ion Pty Ltd", email = "contact@flyingion.com"}]
 description = "Flying Ion's observable, routable, data serialisation and transport code."

{vortexpy-4.3.9 → vortexpy-4.3.11}/vortex/PayloadResponse.py

@@ -16,6 +16,8 @@ from uuid import uuid4
 import pytz
 from twisted.internet import reactor
 from twisted.internet.defer import Deferred
+from twisted.internet.defer import TimeoutError
+from twisted.internet.interfaces import IDelayedCall
 from twisted.python.failure import Failure
 
 from vortex.PayloadEndpoint import PayloadEndpoint
@@ -68,6 +70,7 @@ class PayloadResponse(Deferred):
         timeout: Optional[float] = None,
         resultCheck=True,
         logTimeoutException=True,
+        retries: Optional[int] = None,
     ) -> None:
         """Constructor
 
@@ -83,9 +86,16 @@ class PayloadResponse(Deferred):
                     it errback will be called.
         :param logTimeoutException: When True, payload timeouts log at ERROR.
                     When False, timeouts log at DEBUG with neutral wording.
+        :param retries: The number of times to resend the payload envelope
+                    when the response times out; None sends once with no
+                    retries. Requires destVortexName or destVortexUuid.
         """
         Deferred.__init__(self)
 
+        assert retries is None or (destVortexName or destVortexUuid), (
+            "retries requires destVortexName or destVortexUuid to resend"
+        )
+
         if not timeout:
             timeout = self.TIMEOUT
 
@@ -99,6 +109,11 @@ class PayloadResponse(Deferred):
         payloadEnvelope.filt[self.MESSAGE_ID_KEY] = self._messageId
         self._filt = copy(payloadEnvelope.filt)
         self._destVortexName = destVortexName
+        self._destVortexUuid = destVortexUuid
+        self._payloadEnvelope = payloadEnvelope
+        self._timeout = timeout
+        self._retries: Optional[int] = retries
+        self._timeoutDelayedCall: Optional[IDelayedCall] = None
 
         self._status = self.PROCESSING
         self._date = datetime.now(pytz.utc)
@@ -107,23 +122,49 @@ class PayloadResponse(Deferred):
             self._filt, self._process, requiredPermissions=frozenset()
         )
 
-        if destVortexName or destVortexUuid:
-            d: Deferred = payloadEnvelope.toVortexMsgDefer()
-            d.addCallback(
-                VortexFactory.sendVortexMsg,
-                destVortexName=destVortexName,
-                destVortexUuid=destVortexUuid,
-            )
-            d.addErrback(self.errback)
+        self._sendVortexMsg()
 
         try:
             raise Exception()
         except:
             self._stack = sys.exc_info()[2]
 
-        # noinspection PyTypeChecker
-        self.addTimeout(timeout, reactor)
-        self.addErrback(self._timedOut)
+        if retries is None:
+            # noinspection PyTypeChecker
+            self.addTimeout(timeout, reactor)
+            self.addErrback(self._timedOut)
+        else:
+            self._armTimeout()
+
+    def _sendVortexMsg(self) -> None:
+        if not (self._destVortexName or self._destVortexUuid):
+            return
+
+        d: Deferred = self._payloadEnvelope.toVortexMsgDefer()
+        d.addCallback(
+            VortexFactory.sendVortexMsg,
+            destVortexName=self._destVortexName,
+            destVortexUuid=self._destVortexUuid,
+        )
+        d.addErrback(self.errback)
+
+    def _armTimeout(self) -> None:
+        self._timeoutDelayedCall = reactor.callLater(  # type: ignore[attr-defined]  # pyright: ignore[reportAttributeAccessIssue]
+            self._timeout, self._onTimeout
+        )
+
+    def _onTimeout(self) -> None:
+        self._timeoutDelayedCall = None
+
+        if self._retries:
+            self._retries -= 1
+            self._sendVortexMsg()
+            self._armTimeout()
+            return
+
+        failure = Failure(TimeoutError("timed out"))
+        self._timedOut(failure)
+        self.errback(failure)
 
     @classmethod
     def isResponsePayloadEnvelope(cls, payloadEnvelope: PayloadEnvelope):
@@ -163,6 +204,12 @@ class PayloadResponse(Deferred):
             self._endpoint.shutdown()
             self._endpoint = None
 
+        if self._timeoutDelayedCall is not None:
+            # zope Interface methods omit self, which static analysis cannot bind
+            if self._timeoutDelayedCall.active():  # pyright: ignore[reportAttributeAccessIssue]
+                self._timeoutDelayedCall.cancel()  # pyright: ignore[reportAttributeAccessIssue]
+            self._timeoutDelayedCall = None
+
         if self._destVortexName and vortexName != self._destVortexName:
             logger.debug(
                 "Received response from a vortex other than the dest vortex, "
@@ -176,14 +223,10 @@ class PayloadResponse(Deferred):
             logger.error("Received response after timeout for %s" % self._filt)
             return
 
-        if self._resultCheck and not payloadEnvelope.result in (None, True):
+        if self._resultCheck and payloadEnvelope.result not in (None, True):
             self._status = self.FAILED
             self.errback(
-                Failure(
-                    Exception(payloadEnvelope.result).with_traceback(
-                        self._stack
-                    )
-                )
+                Failure(Exception(payloadEnvelope.result).with_traceback(self._stack))
             )
 
         else:

vortexpy-4.3.11/vortex/PayloadResponse_test.py

@@ -0,0 +1,161 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from twisted.internet.defer import TimeoutError
+from twisted.internet.defer import succeed
+from twisted.python.failure import Failure
+
+from vortex.PayloadEnvelope import PayloadEnvelope
+from vortex.PayloadResponse import PayloadResponse
+
+
+class _FakeDelayedCall:
+    def __init__(self, callback) -> None:
+        self.callback = callback
+        self.cancelled = False
+
+    def active(self) -> bool:
+        return not self.cancelled
+
+    def cancel(self) -> None:
+        self.cancelled = True
+
+    def fire(self) -> None:
+        self.callback()
+
+
+class _FakeReactor:
+    def __init__(self) -> None:
+        self.delayedCalls: list[_FakeDelayedCall] = []
+
+    def callLater(self, _seconds: float, callback) -> _FakeDelayedCall:
+        call = _FakeDelayedCall(callback)
+        self.delayedCalls.append(call)
+        return call
+
+
+class PayloadResponseLoggingTest(unittest.TestCase):
+    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
+    @patch("vortex.PayloadResponse.logger")
+    def testTimeoutLogsDebugWhenLogTimeoutExceptionFalse(
+        self, mockLogger: MagicMock, _mockSend: MagicMock
+    ) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            timeout=30.0,
+            logTimeoutException=False,
+        )
+        pr._timedOut(Failure(TimeoutError("timed out")))
+        mockLogger.error.assert_not_called()
+        mockLogger.debug.assert_called_once()
+
+    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
+    @patch("vortex.PayloadResponse.logger")
+    def testTimeoutLogsErrorWhenLogTimeoutExceptionTrue(
+        self, mockLogger: MagicMock, _mockSend: MagicMock
+    ) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            timeout=30.0,
+            logTimeoutException=True,
+        )
+        pr._timedOut(Failure(TimeoutError("timed out")))
+        mockLogger.debug.assert_not_called()
+        mockLogger.error.assert_called_once()
+
+
+class PayloadResponseRetryTest(unittest.TestCase):
+    def setUp(self) -> None:
+        self.fakeReactor = _FakeReactor()
+        patch("vortex.PayloadResponse.reactor", self.fakeReactor).start()
+        self.mockSend: MagicMock = patch(
+            "vortex.PayloadResponse.VortexFactory.sendVortexMsg"
+        ).start()
+        patch(
+            "vortex.PayloadEnvelope.PayloadEnvelope.toVortexMsgDefer",
+            return_value=succeed(b"{}"),
+        ).start()
+        self.addCleanup(patch.stopall)
+
+    def testTimeoutResendsPayloadAndSucceedsOnLateResponse(self) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            destVortexName="destVortex",
+            timeout=30.0,
+            retries=1,
+        )
+
+        self.assertEqual(self.mockSend.call_count, 1)
+        self.assertEqual(len(self.fakeReactor.delayedCalls), 1)
+
+        # First attempt times out, the payload is resent and re-armed
+        self.fakeReactor.delayedCalls[0].fire()
+
+        self.assertEqual(self.mockSend.call_count, 2)
+        self.assertEqual(len(self.fakeReactor.delayedCalls), 2)
+        self.assertEqual(pr.status, PayloadResponse.PROCESSING)
+
+        # The resent payload receives a response
+        results = []
+        pr.addCallback(results.append)
+        response = PayloadEnvelope(filt={"key": "example"})
+        pr._process(response, "vortexUuid", "destVortex")
+
+        self.assertEqual(pr.status, PayloadResponse.SUCCESS)
+        self.assertEqual(results, [response])
+        self.assertTrue(self.fakeReactor.delayedCalls[1].cancelled)
+
+    def testExhaustedRetriesErrbackWithTimedOut(self) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            destVortexName="destVortex",
+            timeout=30.0,
+            retries=1,
+        )
+
+        failures = []
+        pr.addErrback(failures.append)
+
+        self.fakeReactor.delayedCalls[0].fire()
+        self.assertEqual(self.mockSend.call_count, 2)
+        self.assertEqual(pr.status, PayloadResponse.PROCESSING)
+
+        self.fakeReactor.delayedCalls[1].fire()
+
+        self.assertEqual(self.mockSend.call_count, 2)
+        self.assertEqual(pr.status, PayloadResponse.TIMED_OUT)
+        self.assertEqual(len(failures), 1)
+        self.assertIsInstance(failures[0].value, TimeoutError)
+
+    def testRetriesRequiresDestinationVortex(self) -> None:
+        with self.assertRaises(AssertionError):
+            PayloadResponse(
+                PayloadEnvelope(filt={"key": "example"}),
+                timeout=30.0,
+                retries=1,
+            )
+
+    def testDefaultTimeoutPathDoesNotResend(self) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            destVortexName="destVortex",
+            timeout=30.0,
+        )
+
+        failures = []
+        pr.addErrback(failures.append)
+
+        self.assertEqual(self.mockSend.call_count, 1)
+        self.assertEqual(len(self.fakeReactor.delayedCalls), 1)
+
+        # addTimeout cancels the deferred, which errbacks with TimeoutError
+        self.fakeReactor.delayedCalls[0].fire()
+
+        self.assertEqual(self.mockSend.call_count, 1)
+        self.assertEqual(pr.status, PayloadResponse.TIMED_OUT)
+        self.assertEqual(len(failures), 1)
+        self.assertIsInstance(failures[0].value, TimeoutError)
+
+
+if __name__ == "__main__":
+    unittest.main()

{vortexpy-4.3.9 → vortexpy-4.3.11}/vortex/VortexServer.py

@@ -43,7 +43,10 @@ VortexServer
 """
 
 HEART_BEAT_PERIOD = 10.0
-HEART_BEAT_TIMEOUT = 60.0
+# Browser background-tab timer throttling (Chrome intensive wake-up throttling)
+# can reduce a hidden tab's client heartbeats to one per minute; 75s gives one
+# full missed-beat margin over that 60s cadence before the connection is closed.
+HEART_BEAT_TIMEOUT = 75.0
 
 
 class VortexServer(VortexABC):
@@ -362,7 +365,11 @@ class VortexSessionI(Interface):
 @implementer(VortexSessionI)
 class VortexSession(object):
     def __init__(self, session):
-        session.sessionTimeout = HEART_BEAT_TIMEOUT
+        # Never shorten a configured session timeout: the heartbeat floor
+        # applies only when the app (or Twisted default) allows less.
+        # Shortening here expires active operator sessions when browser
+        # background-tab timer throttling delays heartbeats past 60s.
+        session.sessionTimeout = max(session.sessionTimeout, HEART_BEAT_TIMEOUT)
         self.connections = {}
 
 

{vortexpy-4.3.9 → vortexpy-4.3.11}/vortex/__init__.py

@@ -6,4 +6,4 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
-__version__ = '4.3.9'
+__version__ = '4.3.11'

{vortexpy-4.3.9 → vortexpy-4.3.11}/vortexpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.3.9
+Version: 4.3.11
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

vortexpy-4.3.9/vortex/PayloadResponse_test.py

@@ -1,42 +0,0 @@
-import unittest
-from unittest.mock import MagicMock, patch
-
-from twisted.internet.defer import TimeoutError
-from twisted.python.failure import Failure
-
-from vortex.PayloadEnvelope import PayloadEnvelope
-from vortex.PayloadResponse import PayloadResponse
-
-
-class PayloadResponseLoggingTest(unittest.TestCase):
-    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
-    @patch("vortex.PayloadResponse.logger")
-    def testTimeoutLogsDebugWhenLogTimeoutExceptionFalse(
-        self, mockLogger: MagicMock, _mockSend: MagicMock
-    ) -> None:
-        pr = PayloadResponse(
-            PayloadEnvelope(filt={"key": "example"}),
-            timeout=30.0,
-            logTimeoutException=False,
-        )
-        pr._timedOut(Failure(TimeoutError("timed out")))
-        mockLogger.error.assert_not_called()
-        mockLogger.debug.assert_called_once()
-
-    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
-    @patch("vortex.PayloadResponse.logger")
-    def testTimeoutLogsErrorWhenLogTimeoutExceptionTrue(
-        self, mockLogger: MagicMock, _mockSend: MagicMock
-    ) -> None:
-        pr = PayloadResponse(
-            PayloadEnvelope(filt={"key": "example"}),
-            timeout=30.0,
-            logTimeoutException=True,
-        )
-        pr._timedOut(Failure(TimeoutError("timed out")))
-        mockLogger.debug.assert_not_called()
-        mockLogger.error.assert_called_once()
-
-
-if __name__ == "__main__":
-    unittest.main()