flwr-nightly 1.15.0.dev20250114__py3-none-any.whl → 1.15.0.dev20250123__py3-none-any.whl

flwr/server/superlink/driver/serverappio_servicer.py

@@ -16,14 +16,13 @@
 
 
 import threading
-import time
 from logging import DEBUG, INFO
 from typing import Optional
 from uuid import UUID
 
 import grpc
 
-from flwr.common import ConfigsRecord
+from flwr.common import ConfigsRecord, now
 from flwr.common.constant import Status
 from flwr.common.logger import log
 from flwr.common.serde import (
@@ -31,6 +30,10 @@ from flwr.common.serde import (
     context_to_proto,
     fab_from_proto,
     fab_to_proto,
+    message_from_proto,
+    message_from_taskres,
+    message_to_proto,
+    message_to_taskins,
     run_status_from_proto,
     run_status_to_proto,
     run_to_proto,
@@ -57,10 +60,14 @@ from flwr.proto.run_pb2 import (  # pylint: disable=E0611
 from flwr.proto.serverappio_pb2 import (  # pylint: disable=E0611
     GetNodesRequest,
     GetNodesResponse,
+    PullResMessagesRequest,
+    PullResMessagesResponse,
     PullServerAppInputsRequest,
     PullServerAppInputsResponse,
     PullTaskResRequest,
     PullTaskResResponse,
+    PushInsMessagesRequest,
+    PushInsMessagesResponse,
     PushServerAppOutputsRequest,
     PushServerAppOutputsResponse,
     PushTaskInsRequest,
@@ -102,9 +109,7 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
         )
 
         all_ids: set[int] = state.get_nodes(request.run_id)
-        nodes: list[Node] = [
-            Node(node_id=node_id, anonymous=False) for node_id in all_ids
-        ]
+        nodes: list[Node] = [Node(node_id=node_id) for node_id in all_ids]
         return GetNodesResponse(nodes=nodes)
 
     def CreateRun(
@@ -151,7 +156,7 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
         )
 
         # Set pushed_at (timestamp in seconds)
-        pushed_at = time.time()
+        pushed_at = now().timestamp()
         for task_ins in request.task_ins_list:
             task_ins.task.pushed_at = pushed_at
 
@@ -184,6 +189,59 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
             task_ids=[str(task_id) if task_id else "" for task_id in task_ids]
         )
 
+    def PushMessages(
+        self, request: PushInsMessagesRequest, context: grpc.ServicerContext
+    ) -> PushInsMessagesResponse:
+        """Push a set of Messages."""
+        log(DEBUG, "ServerAppIoServicer.PushMessages")
+
+        # Init state
+        state: LinkState = self.state_factory.state()
+
+        # Abort if the run is not running
+        abort_if(
+            request.run_id,
+            [Status.PENDING, Status.STARTING, Status.FINISHED],
+            state,
+            context,
+        )
+
+        # Set pushed_at (timestamp in seconds)
+        pushed_at = now().timestamp()
+
+        # Validate request and insert in State
+        _raise_if(
+            validation_error=len(request.messages_list) == 0,
+            request_name="PushMessages",
+            detail="`messages_list` must not be empty",
+        )
+        message_ids: list[Optional[UUID]] = []
+        while request.messages_list:
+            message_proto = request.messages_list.pop(0)
+            message = message_from_proto(message_proto=message_proto)
+            task_ins = message_to_taskins(message=message)
+            task_ins.task.pushed_at = pushed_at
+            validation_errors = validate_task_ins_or_res(task_ins)
+            _raise_if(
+                validation_error=bool(validation_errors),
+                request_name="PushMessages",
+                detail=", ".join(validation_errors),
+            )
+            _raise_if(
+                validation_error=request.run_id != task_ins.run_id,
+                request_name="PushMessages",
+                detail="`task_ins` has mismatched `run_id`",
+            )
+            # Store
+            message_id: Optional[UUID] = state.store_task_ins(task_ins=task_ins)
+            message_ids.append(message_id)
+
+        return PushInsMessagesResponse(
+            message_ids=[
+                str(message_id) if message_id else "" for message_id in message_ids
+            ]
+        )
+
     def PullTaskRes(
         self, request: PullTaskResRequest, context: grpc.ServicerContext
     ) -> PullTaskResResponse:
@@ -223,6 +281,52 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
 
         return PullTaskResResponse(task_res_list=task_res_list)
 
+    def PullMessages(
+        self, request: PullResMessagesRequest, context: grpc.ServicerContext
+    ) -> PullResMessagesResponse:
+        """Pull a set of Messages."""
+        log(DEBUG, "ServerAppIoServicer.PullMessages")
+
+        # Init state
+        state: LinkState = self.state_factory.state()
+
+        # Abort if the run is not running
+        abort_if(
+            request.run_id,
+            [Status.PENDING, Status.STARTING, Status.FINISHED],
+            state,
+            context,
+        )
+
+        # Convert each task_id str to UUID
+        message_ids: set[UUID] = {
+            UUID(message_id) for message_id in request.message_ids
+        }
+
+        # Read from state
+        task_res_list: list[TaskRes] = state.get_task_res(task_ids=message_ids)
+
+        # Convert to Messages
+        messages_list = []
+        while task_res_list:
+            task_res = task_res_list.pop(0)
+            _raise_if(
+                validation_error=request.run_id != task_res.run_id,
+                request_name="PullMessages",
+                detail="`task_res` has mismatched `run_id`",
+            )
+            message = message_from_taskres(taskres=task_res)
+            messages_list.append(message_to_proto(message))
+
+        # Delete the TaskIns/TaskRes pairs if TaskRes is found
+        task_ins_ids_to_delete = {
+            UUID(task_res.task.ancestry[0]) for task_res in task_res_list
+        }
+
+        state.delete_tasks(task_ins_ids=task_ins_ids_to_delete)
+
+        return PullResMessagesResponse(messages_list=messages_list)
+
     def GetRun(
         self, request: GetRunRequest, context: grpc.ServicerContext
     ) -> GetRunResponse:

flwr/server/superlink/fleet/grpc_adapter/grpc_adapter_servicer.py

@@ -15,7 +15,7 @@
 """Fleet API gRPC adapter servicer."""
 
 
-from logging import DEBUG, INFO
+from logging import DEBUG
 from typing import Callable, TypeVar
 
 import grpc
@@ -31,35 +31,30 @@ from flwr.common.constant import (
 from flwr.common.logger import log
 from flwr.common.version import package_name, package_version
 from flwr.proto import grpcadapter_pb2_grpc  # pylint: disable=E0611
-from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
+from flwr.proto.fab_pb2 import GetFabRequest  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
-    CreateNodeResponse,
     DeleteNodeRequest,
-    DeleteNodeResponse,
     PingRequest,
-    PingResponse,
-    PullTaskInsRequest,
-    PullTaskInsResponse,
-    PushTaskResRequest,
-    PushTaskResResponse,
+    PullMessagesRequest,
+    PushMessagesRequest,
 )
 from flwr.proto.grpcadapter_pb2 import MessageContainer  # pylint: disable=E0611
-from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
-from flwr.server.superlink.ffs.ffs_factory import FfsFactory
-from flwr.server.superlink.fleet.message_handler import message_handler
-from flwr.server.superlink.linkstate import LinkStateFactory
+from flwr.proto.run_pb2 import GetRunRequest  # pylint: disable=E0611
+
+from ..grpc_rere.fleet_servicer import FleetServicer
 
 T = TypeVar("T", bound=GrpcMessage)
 
 
 def _handle(
     msg_container: MessageContainer,
+    context: grpc.ServicerContext,
     request_type: type[T],
-    handler: Callable[[T], GrpcMessage],
+    handler: Callable[[T, grpc.ServicerContext], GrpcMessage],
 ) -> MessageContainer:
     req = request_type.FromString(msg_container.grpc_message_content)
-    res = handler(req)
+    res = handler(req, context)
     res_cls = res.__class__
     return MessageContainer(
         metadata={
@@ -74,89 +69,26 @@ def _handle(
     )
 
 
-class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer):
+class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer, FleetServicer):
     """Fleet API via GrpcAdapter servicer."""
 
-    def __init__(
-        self, state_factory: LinkStateFactory, ffs_factory: FfsFactory
-    ) -> None:
-        self.state_factory = state_factory
-        self.ffs_factory = ffs_factory
-
     def SendReceive(  # pylint: disable=too-many-return-statements
         self, request: MessageContainer, context: grpc.ServicerContext
     ) -> MessageContainer:
         """."""
         log(DEBUG, "GrpcAdapterServicer.SendReceive")
         if request.grpc_message_name == CreateNodeRequest.__qualname__:
-            return _handle(request, CreateNodeRequest, self._create_node)
+            return _handle(request, context, CreateNodeRequest, self.CreateNode)
         if request.grpc_message_name == DeleteNodeRequest.__qualname__:
-            return _handle(request, DeleteNodeRequest, self._delete_node)
+            return _handle(request, context, DeleteNodeRequest, self.DeleteNode)
         if request.grpc_message_name == PingRequest.__qualname__:
-            return _handle(request, PingRequest, self._ping)
-        if request.grpc_message_name == PullTaskInsRequest.__qualname__:
-            return _handle(request, PullTaskInsRequest, self._pull_task_ins)
-        if request.grpc_message_name == PushTaskResRequest.__qualname__:
-            return _handle(request, PushTaskResRequest, self._push_task_res)
+            return _handle(request, context, PingRequest, self.Ping)
         if request.grpc_message_name == GetRunRequest.__qualname__:
-            return _handle(request, GetRunRequest, self._get_run)
+            return _handle(request, context, GetRunRequest, self.GetRun)
         if request.grpc_message_name == GetFabRequest.__qualname__:
-            return _handle(request, GetFabRequest, self._get_fab)
+            return _handle(request, context, GetFabRequest, self.GetFab)
+        if request.grpc_message_name == PullMessagesRequest.__qualname__:
+            return _handle(request, context, PullMessagesRequest, self.PullMessages)
+        if request.grpc_message_name == PushMessagesRequest.__qualname__:
+            return _handle(request, context, PushMessagesRequest, self.PushMessages)
         raise ValueError(f"Invalid grpc_message_name: {request.grpc_message_name}")
-
-    def _create_node(self, request: CreateNodeRequest) -> CreateNodeResponse:
-        """."""
-        log(INFO, "GrpcAdapter.CreateNode")
-        return message_handler.create_node(
-            request=request,
-            state=self.state_factory.state(),
-        )
-
-    def _delete_node(self, request: DeleteNodeRequest) -> DeleteNodeResponse:
-        """."""
-        log(INFO, "GrpcAdapter.DeleteNode")
-        return message_handler.delete_node(
-            request=request,
-            state=self.state_factory.state(),
-        )
-
-    def _ping(self, request: PingRequest) -> PingResponse:
-        """."""
-        log(DEBUG, "GrpcAdapter.Ping")
-        return message_handler.ping(
-            request=request,
-            state=self.state_factory.state(),
-        )
-
-    def _pull_task_ins(self, request: PullTaskInsRequest) -> PullTaskInsResponse:
-        """Pull TaskIns."""
-        log(INFO, "GrpcAdapter.PullTaskIns")
-        return message_handler.pull_task_ins(
-            request=request,
-            state=self.state_factory.state(),
-        )
-
-    def _push_task_res(self, request: PushTaskResRequest) -> PushTaskResResponse:
-        """Push TaskRes."""
-        log(INFO, "GrpcAdapter.PushTaskRes")
-        return message_handler.push_task_res(
-            request=request,
-            state=self.state_factory.state(),
-        )
-
-    def _get_run(self, request: GetRunRequest) -> GetRunResponse:
-        """Get run information."""
-        log(INFO, "GrpcAdapter.GetRun")
-        return message_handler.get_run(
-            request=request,
-            state=self.state_factory.state(),
-        )
-
-    def _get_fab(self, request: GetFabRequest) -> GetFabResponse:
-        """Get FAB."""
-        log(INFO, "GrpcAdapter.GetFab")
-        return message_handler.get_fab(
-            request=request,
-            ffs=self.ffs_factory.ffs(),
-            state=self.state_factory.state(),
-        )

flwr/server/superlink/fleet/grpc_rere/server_interceptor.py

@@ -15,91 +15,54 @@
 """Flower server interceptor."""
 
 
-import base64
-from collections.abc import Sequence
-from logging import INFO, WARNING
-from typing import Any, Callable, Optional, Union
+import datetime
+from typing import Any, Callable, Optional, cast
 
 import grpc
-from cryptography.hazmat.primitives.asymmetric import ec
-
-from flwr.common.logger import log
+from google.protobuf.message import Message as GrpcMessage
+
+from flwr.common import now
+from flwr.common.constant import (
+    PUBLIC_KEY_HEADER,
+    SIGNATURE_HEADER,
+    TIMESTAMP_HEADER,
+    TIMESTAMP_TOLERANCE,
+)
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
-    bytes_to_private_key,
     bytes_to_public_key,
-    generate_shared_key,
-    verify_hmac,
+    verify_signature,
 )
-from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     CreateNodeRequest,
     CreateNodeResponse,
-    DeleteNodeRequest,
-    DeleteNodeResponse,
-    PingRequest,
-    PingResponse,
-    PullTaskInsRequest,
-    PullTaskInsResponse,
-    PushTaskResRequest,
-    PushTaskResResponse,
 )
-from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
-from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
 from flwr.server.superlink.linkstate import LinkStateFactory
 
-_PUBLIC_KEY_HEADER = "public-key"
-_AUTH_TOKEN_HEADER = "auth-token"
-
-Request = Union[
-    CreateNodeRequest,
-    DeleteNodeRequest,
-    PullTaskInsRequest,
-    PushTaskResRequest,
-    GetRunRequest,
-    PingRequest,
-    GetFabRequest,
-]
-
-Response = Union[
-    CreateNodeResponse,
-    DeleteNodeResponse,
-    PullTaskInsResponse,
-    PushTaskResResponse,
-    GetRunResponse,
-    PingResponse,
-    GetFabResponse,
-]
-
 
-def _get_value_from_tuples(
-    key_string: str, tuples: Sequence[tuple[str, Union[str, bytes]]]
-) -> bytes:
-    value = next((value for key, value in tuples if key == key_string), "")
-    if isinstance(value, str):
-        return value.encode()
+def _unary_unary_rpc_terminator(message: str) -> grpc.RpcMethodHandler:
+    def terminate(_request: GrpcMessage, context: grpc.ServicerContext) -> GrpcMessage:
+        context.abort(grpc.StatusCode.UNAUTHENTICATED, message)
+        raise RuntimeError("Should not reach this point")  # Make mypy happy
 
-    return value
+    return grpc.unary_unary_rpc_method_handler(terminate)
 
 
 class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
-    """Server interceptor for node authentication."""
-
-    def __init__(self, state_factory: LinkStateFactory):
+    """Server interceptor for node authentication.
+
+    Parameters
+    ----------
+    state_factory : LinkStateFactory
+        A factory for creating new instances of LinkState.
+    auto_auth : bool (default: False)
+        If True, nodes are authenticated without requiring their public keys to be
+        pre-stored in the LinkState. If False, only nodes with pre-stored public keys
+        can be authenticated.
+    """
+
+    def __init__(self, state_factory: LinkStateFactory, auto_auth: bool = False):
         self.state_factory = state_factory
-        state = self.state_factory.state()
-
-        self.node_public_keys = state.get_node_public_keys()
-        if len(self.node_public_keys) == 0:
-            log(WARNING, "Authentication enabled, but no known public keys configured")
-
-        private_key = state.get_server_private_key()
-        public_key = state.get_server_public_key()
-
-        if private_key is None or public_key is None:
-            raise ValueError("Error loading authentication keys")
-
-        self.server_private_key = bytes_to_private_key(private_key)
-        self.encoded_server_public_key = base64.urlsafe_b64encode(public_key)
+        self.auto_auth = auto_auth
 
     def intercept_service(
         self,
@@ -112,117 +75,80 @@ class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
         metadata sent by the node. Continue RPC call if node is authenticated, else,
         terminate RPC call by setting context to abort.
         """
+        state = self.state_factory.state()
+        metadata_dict = dict(handler_call_details.invocation_metadata)
+
+        # Retrieve info from the metadata
+        try:
+            node_pk_bytes = cast(bytes, metadata_dict[PUBLIC_KEY_HEADER])
+            timestamp_iso = cast(str, metadata_dict[TIMESTAMP_HEADER])
+            signature = cast(bytes, metadata_dict[SIGNATURE_HEADER])
+        except KeyError:
+            return _unary_unary_rpc_terminator("Missing authentication metadata")
+
+        if not self.auto_auth:
+            # Abort the RPC call if the node public key is not found
+            if node_pk_bytes not in state.get_node_public_keys():
+                return _unary_unary_rpc_terminator("Public key not recognized")
+
+        # Verify the signature
+        node_pk = bytes_to_public_key(node_pk_bytes)
+        if not verify_signature(node_pk, timestamp_iso.encode("ascii"), signature):
+            return _unary_unary_rpc_terminator("Invalid signature")
+
+        # Verify the timestamp
+        current = now()
+        time_diff = current - datetime.datetime.fromisoformat(timestamp_iso)
+        # Abort the RPC call if the timestamp is too old or in the future
+        if not 0 < time_diff.total_seconds() < TIMESTAMP_TOLERANCE:
+            return _unary_unary_rpc_terminator("Invalid timestamp")
+
+        # Continue the RPC call
+        expected_node_id = state.get_node_id(node_pk_bytes)
+        if not handler_call_details.method.endswith("CreateNode"):
+            if expected_node_id is None:
+                return _unary_unary_rpc_terminator("Invalid node ID")
         # One of the method handlers in
         # `flwr.server.superlink.fleet.grpc_rere.fleet_server.FleetServicer`
         method_handler: grpc.RpcMethodHandler = continuation(handler_call_details)
-        return self._generic_auth_unary_method_handler(method_handler)
+        return self._wrap_method_handler(
+            method_handler, expected_node_id, node_pk_bytes
+        )
 
-    def _generic_auth_unary_method_handler(
-        self, method_handler: grpc.RpcMethodHandler
+    def _wrap_method_handler(
+        self,
+        method_handler: grpc.RpcMethodHandler,
+        expected_node_id: Optional[int],
+        node_public_key: bytes,
     ) -> grpc.RpcMethodHandler:
         def _generic_method_handler(
-            request: Request,
+            request: GrpcMessage,
             context: grpc.ServicerContext,
-        ) -> Response:
-            node_public_key_bytes = base64.urlsafe_b64decode(
-                _get_value_from_tuples(
-                    _PUBLIC_KEY_HEADER, context.invocation_metadata()
-                )
-            )
-            if node_public_key_bytes not in self.node_public_keys:
-                context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")
-
-            if isinstance(request, CreateNodeRequest):
-                response = self._create_authenticated_node(
-                    node_public_key_bytes, request, context
-                )
-                log(
-                    INFO,
-                    "AuthenticateServerInterceptor: Created node_id=%s",
-                    response.node.node_id,
-                )
-                return response
-
-            # Verify hmac value
-            hmac_value = base64.urlsafe_b64decode(
-                _get_value_from_tuples(
-                    _AUTH_TOKEN_HEADER, context.invocation_metadata()
-                )
-            )
-            public_key = bytes_to_public_key(node_public_key_bytes)
-
-            if not self._verify_hmac(public_key, request, hmac_value):
-                context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")
-
-            # Verify node_id
-            node_id = self.state_factory.state().get_node_id(node_public_key_bytes)
-
-            if not self._verify_node_id(node_id, request):
-                context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")
-
-            return method_handler.unary_unary(request, context)  # type: ignore
+        ) -> GrpcMessage:
+            # Verify the node ID
+            if not isinstance(request, CreateNodeRequest):
+                try:
+                    if request.node.node_id != expected_node_id:  # type: ignore
+                        raise ValueError
+                except (AttributeError, ValueError):
+                    context.abort(grpc.StatusCode.UNAUTHENTICATED, "Invalid node ID")
+
+            response: GrpcMessage = method_handler.unary_unary(request, context)
+
+            # Set the public key after a successful CreateNode request
+            if isinstance(response, CreateNodeResponse):
+                state = self.state_factory.state()
+                try:
+                    state.set_node_public_key(response.node.node_id, node_public_key)
+                except ValueError as e:
+                    # Remove newly created node if setting the public key fails
+                    state.delete_node(response.node.node_id)
+                    context.abort(grpc.StatusCode.UNAUTHENTICATED, str(e))
+
+            return response
 
         return grpc.unary_unary_rpc_method_handler(
             _generic_method_handler,
             request_deserializer=method_handler.request_deserializer,
             response_serializer=method_handler.response_serializer,
         )
-
-    def _verify_node_id(
-        self,
-        node_id: Optional[int],
-        request: Union[
-            DeleteNodeRequest,
-            PullTaskInsRequest,
-            PushTaskResRequest,
-            GetRunRequest,
-            PingRequest,
-            GetFabRequest,
-        ],
-    ) -> bool:
-        if node_id is None:
-            return False
-        if isinstance(request, PushTaskResRequest):
-            if len(request.task_res_list) == 0:
-                return False
-            return request.task_res_list[0].task.producer.node_id == node_id
-        if isinstance(request, GetRunRequest):
-            return node_id in self.state_factory.state().get_nodes(request.run_id)
-        return request.node.node_id == node_id
-
-    def _verify_hmac(
-        self, public_key: ec.EllipticCurvePublicKey, request: Request, hmac_value: bytes
-    ) -> bool:
-        shared_secret = generate_shared_key(self.server_private_key, public_key)
-        message_bytes = request.SerializeToString(deterministic=True)
-        return verify_hmac(shared_secret, message_bytes, hmac_value)
-
-    def _create_authenticated_node(
-        self,
-        public_key_bytes: bytes,
-        request: CreateNodeRequest,
-        context: grpc.ServicerContext,
-    ) -> CreateNodeResponse:
-        context.send_initial_metadata(
-            (
-                (
-                    _PUBLIC_KEY_HEADER,
-                    self.encoded_server_public_key,
-                ),
-            )
-        )
-        state = self.state_factory.state()
-        node_id = state.get_node_id(public_key_bytes)
-
-        # Handle `CreateNode` here instead of calling the default method handler
-        # Return previously assigned `node_id` for the provided `public_key`
-        if node_id is not None:
-            state.acknowledge_ping(node_id, request.ping_interval)
-            return CreateNodeResponse(node=Node(node_id=node_id, anonymous=False))
-
-        # No `node_id` exists for the provided `public_key`
-        # Handle `CreateNode` here instead of calling the default method handler
-        # Note: the innermost `CreateNode` method will never be called
-        node_id = state.create_node(request.ping_interval)
-        state.set_node_public_key(node_id, public_key_bytes)
-        return CreateNodeResponse(node=Node(node_id=node_id, anonymous=False))

flwr/server/superlink/fleet/message_handler/message_handler.py

@@ -66,13 +66,13 @@ def create_node(
     """."""
     # Create node
     node_id = state.create_node(ping_interval=request.ping_interval)
-    return CreateNodeResponse(node=Node(node_id=node_id, anonymous=False))
+    return CreateNodeResponse(node=Node(node_id=node_id))
 
 
 def delete_node(request: DeleteNodeRequest, state: LinkState) -> DeleteNodeResponse:
     """."""
     # Validate node_id
-    if request.node.anonymous or request.node.node_id == 0:
+    if request.node.node_id == 0:  # i.e. unset `node_id`
         return DeleteNodeResponse()
 
     # Update state
@@ -91,9 +91,8 @@ def ping(
 
 def pull_task_ins(request: PullTaskInsRequest, state: LinkState) -> PullTaskInsResponse:
     """Pull TaskIns handler."""
-    # Get node_id if client node is not anonymous
     node = request.node  # pylint: disable=no-member
-    node_id: Optional[int] = None if node.anonymous else node.node_id
+    node_id: int = node.node_id
 
     # Retrieve TaskIns from State
     task_ins_list: list[TaskIns] = state.get_task_ins(node_id=node_id, limit=1)
@@ -111,7 +110,7 @@ def pull_messages(
     """Pull Messages handler."""
     # Get node_id if client node is not anonymous
     node = request.node  # pylint: disable=no-member
-    node_id: Optional[int] = None if node.anonymous else node.node_id
+    node_id: int = node.node_id
 
     # Retrieve TaskIns from State
     task_ins_list: list[TaskIns] = state.get_task_ins(node_id=node_id, limit=1)