vortexpy 4.3.6__tar.gz → 6.0.1__tar.gz

vortexpy-6.0.1/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2016-2026 Flying Ion Pty Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

{vortexpy-4.3.6 → vortexpy-6.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.3.6
+Version: 6.0.1
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT
@@ -32,7 +32,7 @@ Requires-Dist: txhttputil>=1.2.0
 Flying Ion's observable, routable, data serialisation and transport code.
 
 See [README_PERMISSIONS.md](README_PERMISSIONS.md) for the two-level permission
-system (endpoint guards + access control context) introduced in v5.0.
+system (endpoint guards + access control context) introduced in v6.0.
 
 **Tuple and Payload tutorials:** [docs/README.md](docs/README.md) (simple → full features, encode/decode, threaded decode).
 
@@ -40,9 +40,14 @@ Why PY at the end? To be consistent with VortexJS, which is the Browser side pac
 See https://gitlab.com/flyingion/vortexjs
 
 Requirements:
-* Python 3.5
-* Twisted 16+
-* SQLAlchemy 1, 1.1
+* Python 3.12 (development target)
+* Twisted (autobahn / txwebsocket)
+* SQLAlchemy >= 2.0
+
+See `pyproject.toml` for the authoritative dependency list.
+
+See [README_MIGRATION.md](README_MIGRATION.md) for breaking changes and
+migration guides (4.4.0, 6.0.0).
 
 The "vortex" is designed to transport "Payloads" from a web browser (VortexJS) to a
 twisted web server (VortexPY). There is also a python client for python client to python server

{vortexpy-4.3.6 → vortexpy-6.0.1}/README.md

@@ -3,7 +3,7 @@
 Flying Ion's observable, routable, data serialisation and transport code.
 
 See [README_PERMISSIONS.md](README_PERMISSIONS.md) for the two-level permission
-system (endpoint guards + access control context) introduced in v5.0.
+system (endpoint guards + access control context) introduced in v6.0.
 
 **Tuple and Payload tutorials:** [docs/README.md](docs/README.md) (simple → full features, encode/decode, threaded decode).
 
@@ -11,9 +11,14 @@ Why PY at the end? To be consistent with VortexJS, which is the Browser side pac
 See https://gitlab.com/flyingion/vortexjs
 
 Requirements:
-* Python 3.5
-* Twisted 16+
-* SQLAlchemy 1, 1.1
+* Python 3.12 (development target)
+* Twisted (autobahn / txwebsocket)
+* SQLAlchemy >= 2.0
+
+See `pyproject.toml` for the authoritative dependency list.
+
+See [README_MIGRATION.md](README_MIGRATION.md) for breaking changes and
+migration guides (4.4.0, 6.0.0).
 
 The "vortex" is designed to transport "Payloads" from a web browser (VortexJS) to a
 twisted web server (VortexPY). There is also a python client for python client to python server

{vortexpy-4.3.6 → vortexpy-6.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.3.6"
+version = "6.0.1"
 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.6 → vortexpy-6.0.1}/vortex/PayloadEndpoint.py

@@ -28,26 +28,14 @@ from vortex.VortexEndpointPermission import (
 from vortex.VortexSession import (
     _callableLabel,
     checkAccessControlContextSignature,
+    checkEndpointPermissionsSignature,
     checkNoHttpSessionInSignature,
+    checkNoVortexSessionInSignature,
 )
 
 logger = logging.getLogger(__name__)
 
 
-# TODO: typings needs to support keyword args before tbis will work.
-# PayloadEndpointProcessCallable = Callable[
-#     [
-#         ...
-#         # PayloadEnvelope,  # payloadEnvelope
-#         # str,  # vortexUuid
-#         # str,  # vortexName
-#         # Any,  # vortexSession
-#         # SendVortexMsgResponseCallable  # sendResponse
-#     ],
-#     Optional[Deferred]  # Return
-# ]
-
-
 class PayloadEndpoint:
     """
     The payload endpoint is responsible for matching payloads filters against
@@ -103,7 +91,14 @@ class PayloadEndpoint:
                 callableDescription=callableDesc,
             )
         )
+        self._callableAcceptsEndpointPermissions = (
+            checkEndpointPermissionsSignature(
+                callable_,
+                callableDescription=callableDesc,
+            )
+        )
         checkNoHttpSessionInSignature(callable_, callableDesc)
+        checkNoVortexSessionInSignature(callable_, callableDesc)
 
         self._acceptOnlyFromVortex = acceptOnlyFromVortex
         if isinstance(self._acceptOnlyFromVortex, str):
@@ -233,6 +228,7 @@ class PayloadEndpoint:
 
         # Level 1: Endpoint permission check
         auth = VortexFactory.getAuthenticator()
+        endpointPermissions = None
         if self._requiredPermissions:
             if not auth:
                 logger.error(
@@ -259,6 +255,19 @@ class PayloadEndpoint:
                 )
                 return
 
+        # Level 1 injection: when the callable declares endpointPermissions,
+        # compute the caller's permissions once here at the boundary so
+        # handlers never see the session or the authenticator.
+        if (
+            self._callableAcceptsEndpointPermissions
+            and endpointPermissions is None
+            and auth
+            and vortexSession
+        ):
+            endpointPermissions = yield maybeDeferred(
+                auth.getEndpointPermissions, vortexSession
+            )
+
         # Level 2: Get access control context, but only if the callback uses it.
         # Default to the sentinel so handlers always receive a non-None value
         # with a clear error on attribute access when auth is unavailable.
@@ -283,15 +292,16 @@ class PayloadEndpoint:
 
         callable_ = self._wref()
         if callable_:
-            kwargs = dict(
+            kwargs: Dict[str, object] = dict(
                 payloadEnvelope=payloadEnvelope,
                 vortexUuid=vortexUuid,
                 vortexName=vortexName,
                 sendResponse=sendResponse,
-                vortexSession=vortexSession,
             )
             if self._callableAcceptsAccessControlContext:
                 kwargs["accessControlContext"] = accessControlContext
+            if self._callableAcceptsEndpointPermissions:
+                kwargs["endpointPermissions"] = endpointPermissions
             return (yield maybeDeferred(callable_, **kwargs))
         else:
             PayloadIO().remove(self)

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/PayloadEndpointTest.py

@@ -54,7 +54,6 @@ class PayloadEndpointPyTest(unittest.TestCase):
             payloadEnvelope=PayloadEnvelope(filt=payload.filt),
             vortexUuid="test",
             vortexName="test",
-            vortexSession=None,
             sendResponse=lambda x: x,
         )
 

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/PayloadIO.py

@@ -8,6 +8,7 @@
 
 import logging
 from datetime import datetime
+from typing import Optional
 
 import pytz
 from twisted.internet import reactor
@@ -59,8 +60,8 @@ class PayloadIO(object):
         payloadEnvelope: PayloadEnvelope,
         vortexUuid: str,
         vortexName: str,
-        vortexSession,
-        sendResponse: SendVortexMsgResponseCallable,
+        vortexSession=None,
+        sendResponse: Optional[SendVortexMsgResponseCallable] = None,
     ):
         from vortex.VortexFactory import VortexFactory
 
@@ -95,8 +96,8 @@ class PayloadIO(object):
         payloadEnvelope: PayloadEnvelope,
         vortexUuid: str,
         vortexName: str,
-        vortexSession,
-        sendResponse: SendVortexMsgResponseCallable,
+        vortexSession=None,
+        sendResponse: Optional[SendVortexMsgResponseCallable] = None,
     ):
         startDate = datetime.now(pytz.utc)
 
@@ -106,6 +107,10 @@ class PayloadIO(object):
             common function
             """
             try:
+                assert sendResponse is not None, (
+                    "PayloadIO._processLater: sendResponse must be set"
+                    " to respond to an exception"
+                )
                 sendResponse(
                     PayloadEnvelope(
                         filt=payloadEnvelope.filt,

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/PayloadPriority.py

@@ -7,4 +7,5 @@
 # Support : contact@flyingion.com
 
 RPC_PRIORITY = 10
+HEARTBEAT_PRIORITY = 20
 DEFAULT_PRIORITY = 100

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/PayloadResponse.py

@@ -157,7 +157,6 @@ class PayloadResponse(Deferred):
         vortexUuid: str,
         vortexName: str,
         sendResponse=None,
-        vortexSession=None,
     ):
         if self._endpoint:
             self._endpoint.shutdown()

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/Tuple.py

@@ -288,6 +288,12 @@ class TupleField:
     class _Map:
         pass
 
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        # Tuple classes declare fields as `field: str = TupleField()`.
+        # The Any return keeps those declarations type-correct without
+        # per-field type-ignore comments. Runtime behaviour is unchanged.
+        return super().__new__(cls)
+
     def __init__(
         self,
         defaultValue=None,

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexAccessControlContextABC.py

@@ -6,8 +6,15 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
+# ruff: noqa: N999
+# Module names use PascalCase to match the primary class.
 
-class VortexAccessControlContextABC:
+from abc import ABC, abstractmethod
+
+from vortex.VortexUserDetailsABC import VortexUserDetailsABC
+
+
+class VortexAccessControlContextABC(ABC):
     """Abstract base class for application-level access control contexts.
 
     This is a **Level 2** permission mechanism.  Where
@@ -16,23 +23,27 @@ class VortexAccessControlContextABC:
     ``VortexAccessControlContextABC`` answers "given access, what specific data
     or actions is this user allowed to interact with?".
 
-    Subclass it and add domain-specific check methods.  Always call
-    ``super().__init__(vortexName, vortexUuid)`` to store the transport
-    metadata that the library passes through::
+    Subclass it, implement :meth:`userDetails`, and add domain-specific check
+    methods.  Always call ``super().__init__(vortexName, vortexUuid)`` to
+    store the transport metadata that the library passes through::
 
-        class AttuneAccessControlContext(VortexAccessControlContextABC):
+        class ExampleAccessControlContext(VortexAccessControlContextABC):
             def __init__(self, user, vortexName: str, vortexUuid: str):
                 super().__init__(vortexName=vortexName, vortexUuid=vortexUuid)
                 self._user = user
 
+            @property
+            def userDetails(self):
+                return None
+
             def canExecuteJob(self, job_id: int) -> bool:
                 return job_id in self._user.allowedJobIds
 
     Obtain the context inside a processing method via the ``accessControlContext``
     keyword argument that the library injects::
 
-        def processTupleAction(self, tupleAction, accessControlContext: AttuneAccessControlContext):
-            assert isinstance(accessControlContext, AttuneAccessControlContext)
+        def processTupleAction(self, tupleAction, accessControlContext: ExampleAccessControlContext):
+            assert isinstance(accessControlContext, ExampleAccessControlContext)
             if not accessControlContext.canExecuteJob(tupleAction.jobId):
                 raise PermissionError("Not allowed")
 
@@ -46,10 +57,18 @@ class VortexAccessControlContextABC:
     * ``vortexName`` — the name of the remote vortex that sent the request.
     * ``vortexUuid`` — the per-connection UUID of that vortex.
 
+    **User identity**
+
+    Contexts must implement ``userDetails``, the identity of the logged-in
+    user provided by the host application (``None`` when no identity is
+    available).  The library reads it to display who holds a live record
+    lock; it never mutates it.
+
     When no authenticator is registered, or the session is unavailable, the
     library passes :data:`NO_AUTH_ACCESS_CONTROL_CONTEXT` — a sentinel whose
-    ``vortexName`` and ``vortexUuid`` are empty strings and any other attribute
-    access raises :class:`RuntimeError`.
+    ``vortexName`` and ``vortexUuid`` are empty strings, whose ``userDetails``
+    is ``None``, and where any other attribute access raises
+    :class:`RuntimeError`.
 
     To detect the no-auth case explicitly::
 
@@ -76,15 +95,26 @@ class VortexAccessControlContextABC:
     def vortexUuid(self) -> str:
         return self._vortexUuid
 
+    @property
+    @abstractmethod
+    def userDetails(self) -> VortexUserDetailsABC | None:
+        """Identity of the logged-in user for this session.
+
+        The library reads this to display who holds a live record lock; it
+        never mutates it.  Return ``None`` when the host application does
+        not provide user identity.
+        """
+
 
 class _NoAuthAccessControlContext(VortexAccessControlContextABC):
     """Sentinel passed as ``accessControlContext`` when no authenticator is
     registered or the session is unavailable.
 
-    ``vortexName`` and ``vortexUuid`` return empty strings.  Any other
-    attribute access raises a descriptive :class:`RuntimeError` so that bugs
-    in handlers are caught immediately with an actionable message rather than
-    a bare ``AttributeError`` on ``None``.
+    ``vortexName`` and ``vortexUuid`` return empty strings and ``userDetails``
+    returns ``None``.  Any other attribute access raises a descriptive
+    :class:`RuntimeError` so that bugs in handlers are caught immediately
+    with an actionable message rather than a bare ``AttributeError`` on
+    ``None``.
     """
 
     def __init__(self):
@@ -93,6 +123,10 @@ class _NoAuthAccessControlContext(VortexAccessControlContextABC):
         object.__setattr__(self, "_vortexName", "")
         object.__setattr__(self, "_vortexUuid", "")
 
+    @property
+    def userDetails(self) -> None:
+        return None
+
     def __getattr__(self, name: str):
         raise RuntimeError(
             f"accessControlContext.{name} was accessed, but no authenticator is "

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexAuthenticatorABC.py

@@ -6,11 +6,13 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
+# ruff: noqa: N999
+# Module names use PascalCase to match the primary class.
+
 from abc import ABC, abstractmethod
 
 from twisted.internet.defer import Deferred
 
-from vortex.VortexEndpointPermission import EndpointPermissionsType
 from vortex.VortexSession import VortexSession
 
 
@@ -82,6 +84,9 @@ class VortexAuthenticatorABC(ABC):
             def __init__(self, user, vortexName: str, vortexUuid: str):
                 super().__init__(vortexName=vortexName, vortexUuid=vortexUuid)
                 self._user = user
+            @property
+            def userDetails(self):
+                return None
             def canEditRecord(self, record_id: int) -> bool:
                 return record_id in self._user.editableRecordIds
 

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexFactory.py

@@ -966,7 +966,6 @@ class VortexFactory:
                     payloadEnvelope=payloadEnvelope,
                     vortexUuid=vortexUuid,
                     vortexName=vortexName,
-                    vortexSession=None,
                     sendResponse=sendResponse,
                 )
                 return succeed(True)

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexPayloadProtocol.py

@@ -155,14 +155,13 @@ class VortexPayloadProtocol(Protocol, metaclass=ABCMeta):
     def _deliverPayload(self, payloadEnvelope):
         """Deliver a decoded payload envelope to the PayloadIO for processing.
 
-        Subclasses (e.g. VortexTcpServerProtocol) may override this to inject
-        an vortexSession or wait for authentication before dispatching.
+        Subclasses (e.g. VortexTcpServerProtocol) may override this to pass the
+        connection vortexSession or wait for authentication before dispatching.
         """
         PayloadIO().process(
             payloadEnvelope,
             vortexUuid=self._serverVortexUuid,
             vortexName=self._serverVortexName,
-            vortexSession=None,
             sendResponse=self._createResponseSenderCallable(),
         )
 

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexServer.py

@@ -138,6 +138,23 @@ class VortexServer(VortexABC):
 
         return "%s:%s" % (connection.ip, connection.port)
 
+    def httpSessionForVortexUuid(self, vortexUuid: str) -> Optional[Session]:
+        """HTTP Session for Vortex UUID
+
+        Return the HTTP session associated with the connection for
+        *vortexUuid*, or ``None`` when the vortex is not connected or has no
+        registered session.  For TCP connections this is the
+        :class:`~vortex.VortexSession.VortexTcpSession` stub stored at
+        connection time.
+
+        :param vortexUuid: The per-connection UUID of the remote vortex.
+        :return: The session for the connection, or ``None``.
+        """
+        connection = self._connectionByVortexUuid.get(vortexUuid)
+        if connection is None:
+            return None
+        return self._httpSessionsBySessionUuid.get(connection.httpSessionUuid)
+
     def connectionOpened(self, httpSession, vortexConnection):
         if self._DEBUG_LOGGING:
             logger.debug("VortexServer - connectionOpened")
@@ -154,9 +171,9 @@ class VortexServer(VortexABC):
                 )
 
             httpSessionConns = VortexSessionI(httpSession).connections
-            for oldConn in list(httpSessionConns.values()):
-                if oldConn is not vortexConnection:
-                    oldConn.close()
+            existingConn = httpSessionConns.get(vortexUuid)
+            if existingConn is not None and existingConn is not vortexConnection:
+                existingConn.close()
             httpSessionConns[vortexUuid] = vortexConnection
 
         if vortexUuid in self._connectionByVortexUuid:
@@ -304,7 +321,6 @@ class VortexServer(VortexABC):
                         payloadEnvelope,
                         vortexUuid=self._uuid,
                         vortexName=self._name,
-                        vortexSession=None,
                         sendResponse=sendResponse,
                     )
 

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexServerConnection.py

@@ -12,7 +12,7 @@ from datetime import datetime
 import pytz
 from twisted.internet import task
 
-from .PayloadPriority import DEFAULT_PRIORITY
+from .PayloadPriority import DEFAULT_PRIORITY, HEARTBEAT_PRIORITY
 from .VortexConnectionABC import VortexConnectionABC
 from .VortexServer import VortexServer, HEART_BEAT_PERIOD, HEART_BEAT_TIMEOUT
 from .VortexWritePushProducer import VortexWritePushProducer
@@ -94,7 +94,7 @@ class VortexServerConnection(VortexConnectionABC):
             self.close()
             return
 
-        self._write(b".", DEFAULT_PRIORITY)
+        self._write(b".", HEARTBEAT_PRIORITY)
 
     @property
     def ip(self):

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexServerWebsocket.py

@@ -336,7 +336,6 @@ class VortexWebSocketUpgradeResource(resource.Resource):
         request.channel.upgradeToWebsocket(websocketProtocol)
 
         def unregister():
-            request.channel.unregisterProducer()
             websocketProtocol.unregisterProducer()
 
         producer = VortexWritePushProducer(
@@ -351,7 +350,10 @@ class VortexWebSocketUpgradeResource(resource.Resource):
         producer.ERROR_DATA_LENGTH = 50 * 1024 * 1024
 
         unregister()
-        request.channel.registerProducer(producer, streaming=True)
+        # Register only on the WebSocket protocol. Registering the same producer
+        # on HTTPChannel._requestProducer as well lets HTTPChannel.pauseProducing
+        # stall outbound traffic without a matching resume while the websocket
+        # request is still open (NOT_DONE_YET).
         websocketProtocol.registerProducer(producer, streaming=True)
 
         def closedError(failure):

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexServer_test.py

@@ -84,12 +84,26 @@ class VortexServerConnectionClosedTest(SynchronousTestCase):
         server.connectionOpened(session, conn_a)
         server.connectionOpened(session, conn_b)
 
+        # A new connection with a different vortexUuid must not close the
+        # existing same-session connection (two browser tabs stay live).
         conns = VortexSessionI(session).connections
+        self.assertEqual(conns.get("uuid-a"), conn_a)
+        self.assertEqual(conns.get("uuid-b"), conn_b)
+
+        # Reconnecting with the same vortexUuid replaces the old connection.
+        conn_a2 = _MockServerConnection(
+            server, "uuid-a", "peek-office-app", session
+        )
+        server.connectionOpened(session, conn_a2)
+
+        self.assertIs(conns.get("uuid-a"), conn_a2)
         self.assertEqual(conns.get("uuid-b"), conn_b)
-        self.assertNotIn("uuid-a", conns)
 
+        # The replaced connection's teardown is idempotent and does not
+        # disturb the surviving connections.
         server.connectionClosed(conn_a)
 
+        self.assertIs(conns.get("uuid-a"), conn_a2)
         self.assertEqual(conns.get("uuid-b"), conn_b)
         self.assertIn("uuid-b", server._connectionByVortexUuid)
 

{vortexpy-4.3.6 → vortexpy-6.0.1}/vortex/VortexSession.py

@@ -181,28 +181,81 @@ def checkAccessControlContextSignature(
     return True
 
 
-def checkNoHttpSessionInSignature(callable_, callableDescription: str = ""):
-    """Log an ERROR if *callable_* declares httpSession as an explicit parameter.
+def checkEndpointPermissionsSignature(
+    callable_,
+    callableDescription: str = "",
+) -> bool:
+    """Check whether *callable_* accepts an ``endpointPermissions`` parameter.
 
-    Called at registration time to detect callbacks that still reference the
-    removed httpSession parameter.
+    Called at **registration time** (not call time) so that the boundary knows
+    whether to compute and inject the caller's endpoint permissions frozenset.
+
+    :param callable_: The callback to inspect.
+    :param callableDescription: Human-readable description for log messages.
+    :return: ``True`` if the callable declares an explicit
+        ``endpointPermissions`` parameter, ``False`` otherwise.
     """
+    return checkAccessControlContextSignature(
+        callable_,
+        paramName="endpointPermissions",
+        callableDescription=callableDescription,
+    )
+
+
+def _checkNoRemovedParamInSignature(
+    callable_,
+    paramName: str,
+    replacementHint: str,
+    callableDescription: str = "",
+):
+    """Log an ERROR if *callable_* declares a removed parameter explicitly."""
     try:
         sig = inspect.signature(callable_)
     except (ValueError, TypeError):
         return
 
-    if "httpSession" in sig.parameters:
-        param = sig.parameters["httpSession"]
+    if paramName in sig.parameters:
+        param = sig.parameters[paramName]
         if param.kind != inspect.Parameter.VAR_KEYWORD:
             logger.error(
-                "CRITICAL FIX REQUIRED: %s declares 'httpSession' which has been "
-                "removed in v5.0. Use 'accessControlContext' instead. "
-                "This callback will NOT receive 'httpSession'.",
+                "CRITICAL FIX REQUIRED: %s declares '%s' which has been "
+                "removed in v6.0.0. %s "
+                "This callback will NOT receive '%s'.",
                 callableDescription or _callableLabel(callable_),
+                paramName,
+                replacementHint,
+                paramName,
             )
 
 
+def checkNoHttpSessionInSignature(callable_, callableDescription: str = ""):
+    """Log an ERROR if *callable_* declares httpSession as an explicit parameter.
+
+    Called at registration time to detect callbacks that still reference the
+    removed httpSession parameter.
+    """
+    _checkNoRemovedParamInSignature(
+        callable_,
+        "httpSession",
+        "Use 'accessControlContext' instead.",
+        callableDescription,
+    )
+
+
+def checkNoVortexSessionInSignature(callable_, callableDescription: str = ""):
+    """Log an ERROR if *callable_* declares vortexSession as an explicit parameter.
+
+    Called at registration time to detect callbacks that still reference the
+    removed vortexSession parameter.
+    """
+    _checkNoRemovedParamInSignature(
+        callable_,
+        "vortexSession",
+        "Use 'accessControlContext' or 'endpointPermissions' instead.",
+        callableDescription,
+    )
+
+
 def _callableLabel(callable_) -> str:
     """Return a human-readable label for a callable for error messages."""
     if hasattr(callable_, "__qualname__"):