flwr-nightly 1.23.0.dev20251027__py3-none-any.whl → 1.23.0.dev20251029__py3-none-any.whl

flwr/proto/fleet_pb2_grpc.py

@@ -28,6 +28,26 @@ class FleetStub(object):
                 request_serializer=flwr_dot_proto_dot_fleet__pb2.DeleteNodeRequest.SerializeToString,
                 response_deserializer=flwr_dot_proto_dot_fleet__pb2.DeleteNodeResponse.FromString,
                 )
+        self.RegisterNode = channel.unary_unary(
+                '/flwr.proto.Fleet/RegisterNode',
+                request_serializer=flwr_dot_proto_dot_fleet__pb2.RegisterNodeFleetRequest.SerializeToString,
+                response_deserializer=flwr_dot_proto_dot_fleet__pb2.RegisterNodeFleetResponse.FromString,
+                )
+        self.ActivateNode = channel.unary_unary(
+                '/flwr.proto.Fleet/ActivateNode',
+                request_serializer=flwr_dot_proto_dot_fleet__pb2.ActivateNodeRequest.SerializeToString,
+                response_deserializer=flwr_dot_proto_dot_fleet__pb2.ActivateNodeResponse.FromString,
+                )
+        self.DeactivateNode = channel.unary_unary(
+                '/flwr.proto.Fleet/DeactivateNode',
+                request_serializer=flwr_dot_proto_dot_fleet__pb2.DeactivateNodeRequest.SerializeToString,
+                response_deserializer=flwr_dot_proto_dot_fleet__pb2.DeactivateNodeResponse.FromString,
+                )
+        self.UnregisterNode = channel.unary_unary(
+                '/flwr.proto.Fleet/UnregisterNode',
+                request_serializer=flwr_dot_proto_dot_fleet__pb2.UnregisterNodeFleetRequest.SerializeToString,
+                response_deserializer=flwr_dot_proto_dot_fleet__pb2.UnregisterNodeFleetResponse.FromString,
+                )
         self.SendNodeHeartbeat = channel.unary_unary(
                 '/flwr.proto.Fleet/SendNodeHeartbeat',
                 request_serializer=flwr_dot_proto_dot_heartbeat__pb2.SendNodeHeartbeatRequest.SerializeToString,
@@ -85,6 +105,34 @@ class FleetServicer(object):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def RegisterNode(self, request, context):
+        """Register Node
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ActivateNode(self, request, context):
+        """Activate Node
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def DeactivateNode(self, request, context):
+        """Deactivate Node
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def UnregisterNode(self, request, context):
+        """Unregister Node
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
     def SendNodeHeartbeat(self, request, context):
         """Missing associated documentation comment in .proto file."""
         context.set_code(grpc.StatusCode.UNIMPLEMENTED)
@@ -156,6 +204,26 @@ def add_FleetServicer_to_server(servicer, server):
                     request_deserializer=flwr_dot_proto_dot_fleet__pb2.DeleteNodeRequest.FromString,
                     response_serializer=flwr_dot_proto_dot_fleet__pb2.DeleteNodeResponse.SerializeToString,
             ),
+            'RegisterNode': grpc.unary_unary_rpc_method_handler(
+                    servicer.RegisterNode,
+                    request_deserializer=flwr_dot_proto_dot_fleet__pb2.RegisterNodeFleetRequest.FromString,
+                    response_serializer=flwr_dot_proto_dot_fleet__pb2.RegisterNodeFleetResponse.SerializeToString,
+            ),
+            'ActivateNode': grpc.unary_unary_rpc_method_handler(
+                    servicer.ActivateNode,
+                    request_deserializer=flwr_dot_proto_dot_fleet__pb2.ActivateNodeRequest.FromString,
+                    response_serializer=flwr_dot_proto_dot_fleet__pb2.ActivateNodeResponse.SerializeToString,
+            ),
+            'DeactivateNode': grpc.unary_unary_rpc_method_handler(
+                    servicer.DeactivateNode,
+                    request_deserializer=flwr_dot_proto_dot_fleet__pb2.DeactivateNodeRequest.FromString,
+                    response_serializer=flwr_dot_proto_dot_fleet__pb2.DeactivateNodeResponse.SerializeToString,
+            ),
+            'UnregisterNode': grpc.unary_unary_rpc_method_handler(
+                    servicer.UnregisterNode,
+                    request_deserializer=flwr_dot_proto_dot_fleet__pb2.UnregisterNodeFleetRequest.FromString,
+                    response_serializer=flwr_dot_proto_dot_fleet__pb2.UnregisterNodeFleetResponse.SerializeToString,
+            ),
             'SendNodeHeartbeat': grpc.unary_unary_rpc_method_handler(
                     servicer.SendNodeHeartbeat,
                     request_deserializer=flwr_dot_proto_dot_heartbeat__pb2.SendNodeHeartbeatRequest.FromString,
@@ -240,6 +308,74 @@ class Fleet(object):
             options, channel_credentials,
             insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
 
+    @staticmethod
+    def RegisterNode(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/flwr.proto.Fleet/RegisterNode',
+            flwr_dot_proto_dot_fleet__pb2.RegisterNodeFleetRequest.SerializeToString,
+            flwr_dot_proto_dot_fleet__pb2.RegisterNodeFleetResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def ActivateNode(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/flwr.proto.Fleet/ActivateNode',
+            flwr_dot_proto_dot_fleet__pb2.ActivateNodeRequest.SerializeToString,
+            flwr_dot_proto_dot_fleet__pb2.ActivateNodeResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def DeactivateNode(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/flwr.proto.Fleet/DeactivateNode',
+            flwr_dot_proto_dot_fleet__pb2.DeactivateNodeRequest.SerializeToString,
+            flwr_dot_proto_dot_fleet__pb2.DeactivateNodeResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def UnregisterNode(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/flwr.proto.Fleet/UnregisterNode',
+            flwr_dot_proto_dot_fleet__pb2.UnregisterNodeFleetRequest.SerializeToString,
+            flwr_dot_proto_dot_fleet__pb2.UnregisterNodeFleetResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
     @staticmethod
     def SendNodeHeartbeat(request,
             target,

flwr/proto/fleet_pb2_grpc.pyi

@@ -20,6 +20,26 @@ class FleetStub:
         flwr.proto.fleet_pb2.DeleteNodeRequest,
         flwr.proto.fleet_pb2.DeleteNodeResponse]
 
+    RegisterNode: grpc.UnaryUnaryMultiCallable[
+        flwr.proto.fleet_pb2.RegisterNodeFleetRequest,
+        flwr.proto.fleet_pb2.RegisterNodeFleetResponse]
+    """Register Node"""
+
+    ActivateNode: grpc.UnaryUnaryMultiCallable[
+        flwr.proto.fleet_pb2.ActivateNodeRequest,
+        flwr.proto.fleet_pb2.ActivateNodeResponse]
+    """Activate Node"""
+
+    DeactivateNode: grpc.UnaryUnaryMultiCallable[
+        flwr.proto.fleet_pb2.DeactivateNodeRequest,
+        flwr.proto.fleet_pb2.DeactivateNodeResponse]
+    """Deactivate Node"""
+
+    UnregisterNode: grpc.UnaryUnaryMultiCallable[
+        flwr.proto.fleet_pb2.UnregisterNodeFleetRequest,
+        flwr.proto.fleet_pb2.UnregisterNodeFleetResponse]
+    """Unregister Node"""
+
     SendNodeHeartbeat: grpc.UnaryUnaryMultiCallable[
         flwr.proto.heartbeat_pb2.SendNodeHeartbeatRequest,
         flwr.proto.heartbeat_pb2.SendNodeHeartbeatResponse]
@@ -78,6 +98,38 @@ class FleetServicer(metaclass=abc.ABCMeta):
         context: grpc.ServicerContext,
     ) -> flwr.proto.fleet_pb2.DeleteNodeResponse: ...
 
+    @abc.abstractmethod
+    def RegisterNode(self,
+        request: flwr.proto.fleet_pb2.RegisterNodeFleetRequest,
+        context: grpc.ServicerContext,
+    ) -> flwr.proto.fleet_pb2.RegisterNodeFleetResponse:
+        """Register Node"""
+        pass
+
+    @abc.abstractmethod
+    def ActivateNode(self,
+        request: flwr.proto.fleet_pb2.ActivateNodeRequest,
+        context: grpc.ServicerContext,
+    ) -> flwr.proto.fleet_pb2.ActivateNodeResponse:
+        """Activate Node"""
+        pass
+
+    @abc.abstractmethod
+    def DeactivateNode(self,
+        request: flwr.proto.fleet_pb2.DeactivateNodeRequest,
+        context: grpc.ServicerContext,
+    ) -> flwr.proto.fleet_pb2.DeactivateNodeResponse:
+        """Deactivate Node"""
+        pass
+
+    @abc.abstractmethod
+    def UnregisterNode(self,
+        request: flwr.proto.fleet_pb2.UnregisterNodeFleetRequest,
+        context: grpc.ServicerContext,
+    ) -> flwr.proto.fleet_pb2.UnregisterNodeFleetResponse:
+        """Unregister Node"""
+        pass
+
     @abc.abstractmethod
     def SendNodeHeartbeat(self,
         request: flwr.proto.heartbeat_pb2.SendNodeHeartbeatRequest,

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

@@ -33,10 +33,14 @@ 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  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
+    ActivateNodeRequest,
     CreateNodeRequest,
+    DeactivateNodeRequest,
     DeleteNodeRequest,
     PullMessagesRequest,
     PushMessagesRequest,
+    RegisterNodeFleetRequest,
+    UnregisterNodeFleetRequest,
 )
 from flwr.proto.grpcadapter_pb2 import MessageContainer  # pylint: disable=E0611
 from flwr.proto.heartbeat_pb2 import SendNodeHeartbeatRequest  # pylint: disable=E0611
@@ -77,7 +81,7 @@ def _handle(
 class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer, FleetServicer):
     """Fleet API via GrpcAdapter servicer."""
 
-    def SendReceive(  # pylint: disable=too-many-return-statements
+    def SendReceive(  # pylint: disable=too-many-return-statements, too-many-branches
         self, request: MessageContainer, context: grpc.ServicerContext
     ) -> MessageContainer:
         """."""
@@ -86,6 +90,18 @@ class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer, FleetService
             return _handle(request, context, CreateNodeRequest, self.CreateNode)
         if request.grpc_message_name == DeleteNodeRequest.__qualname__:
             return _handle(request, context, DeleteNodeRequest, self.DeleteNode)
+        if request.grpc_message_name == RegisterNodeFleetRequest.__qualname__:
+            return _handle(
+                request, context, RegisterNodeFleetRequest, self.RegisterNode
+            )
+        if request.grpc_message_name == ActivateNodeRequest.__qualname__:
+            return _handle(request, context, ActivateNodeRequest, self.ActivateNode)
+        if request.grpc_message_name == DeactivateNodeRequest.__qualname__:
+            return _handle(request, context, DeactivateNodeRequest, self.DeactivateNode)
+        if request.grpc_message_name == UnregisterNodeFleetRequest.__qualname__:
+            return _handle(
+                request, context, UnregisterNodeFleetRequest, self.UnregisterNode
+            )
         if request.grpc_message_name == SendNodeHeartbeatRequest.__qualname__:
             return _handle(
                 request, context, SendNodeHeartbeatRequest, self.SendNodeHeartbeat

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

@@ -28,14 +28,22 @@ from flwr.common.typing import InvalidRunStatusException
 from flwr.proto import fleet_pb2_grpc  # pylint: disable=E0611
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
+    ActivateNodeRequest,
+    ActivateNodeResponse,
     CreateNodeRequest,
     CreateNodeResponse,
+    DeactivateNodeRequest,
+    DeactivateNodeResponse,
     DeleteNodeRequest,
     DeleteNodeResponse,
     PullMessagesRequest,
     PullMessagesResponse,
     PushMessagesRequest,
     PushMessagesResponse,
+    RegisterNodeFleetRequest,
+    RegisterNodeFleetResponse,
+    UnregisterNodeFleetRequest,
+    UnregisterNodeFleetResponse,
 )
 from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
@@ -140,6 +148,50 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         log(DEBUG, "[Fleet.CreateNode] Response: %s", MessageToDict(response))
         return response
 
+    def RegisterNode(
+        self, request: RegisterNodeFleetRequest, context: grpc.ServicerContext
+    ) -> RegisterNodeFleetResponse:
+        """Register a node (not implemented)."""
+        log(ERROR, "[Fleet.RegisterNode] RegisterNode is not implemented")
+        context.abort(
+            grpc.StatusCode.UNIMPLEMENTED,
+            "RegisterNode RPC is not yet implemented",
+        )
+        raise NotImplementedError
+
+    def ActivateNode(
+        self, request: ActivateNodeRequest, context: grpc.ServicerContext
+    ) -> ActivateNodeResponse:
+        """Activate a node (not implemented)."""
+        log(ERROR, "[Fleet.ActivateNode] ActivateNode is not implemented")
+        context.abort(
+            grpc.StatusCode.UNIMPLEMENTED,
+            "ActivateNode RPC is not yet implemented",
+        )
+        raise NotImplementedError
+
+    def DeactivateNode(
+        self, request: DeactivateNodeRequest, context: grpc.ServicerContext
+    ) -> DeactivateNodeResponse:
+        """Deactivate a node (not implemented)."""
+        log(ERROR, "[Fleet.DeactivateNode] DeactivateNode is not implemented")
+        context.abort(
+            grpc.StatusCode.UNIMPLEMENTED,
+            "DeactivateNode RPC is not yet implemented",
+        )
+        raise NotImplementedError
+
+    def UnregisterNode(
+        self, request: UnregisterNodeFleetRequest, context: grpc.ServicerContext
+    ) -> UnregisterNodeFleetResponse:
+        """Unregister a node (not implemented)."""
+        log(ERROR, "[Fleet.UnregisterNode] UnregisterNode is not implemented")
+        context.abort(
+            grpc.StatusCode.UNIMPLEMENTED,
+            "UnregisterNode RPC is not yet implemented",
+        )
+        raise NotImplementedError
+
     def DeleteNode(
         self, request: DeleteNodeRequest, context: grpc.ServicerContext
     ) -> DeleteNodeResponse:

flwr/server/superlink/fleet/rest_rere/rest_api.py

@@ -25,14 +25,22 @@ from google.protobuf.message import Message as GrpcMessage
 from flwr.common.exit import ExitCode, flwr_exit
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
+    ActivateNodeRequest,
+    ActivateNodeResponse,
     CreateNodeRequest,
     CreateNodeResponse,
+    DeactivateNodeRequest,
+    DeactivateNodeResponse,
     DeleteNodeRequest,
     DeleteNodeResponse,
     PullMessagesRequest,
     PullMessagesResponse,
     PushMessagesRequest,
     PushMessagesResponse,
+    RegisterNodeFleetRequest,
+    RegisterNodeFleetResponse,
+    UnregisterNodeFleetRequest,
+    UnregisterNodeFleetResponse,
 )
 from flwr.proto.heartbeat_pb2 import (  # pylint: disable=E0611
     SendNodeHeartbeatRequest,
@@ -69,6 +77,8 @@ GrpcResponse = TypeVar("GrpcResponse", bound=GrpcMessage)
 GrpcAsyncFunction = Callable[[GrpcRequest], Awaitable[GrpcResponse]]
 RestEndPoint = Callable[[Request], Awaitable[Response]]
 
+routes = []
+
 
 def rest_request_response(
     grpc_request_type: type[GrpcRequest],
@@ -76,6 +86,7 @@ def rest_request_response(
     """Convert an async gRPC-based function into a RESTful HTTP endpoint."""
 
     def decorator(func: GrpcAsyncFunction[GrpcRequest, GrpcResponse]) -> RestEndPoint:
+
         async def wrapper(request: Request) -> Response:
             _check_headers(request.headers)
 
@@ -91,6 +102,9 @@ def rest_request_response(
                 headers={"Content-Type": "application/protobuf"},
             )
 
+        # Register route
+        path = f"/api/v0/fleet/{func.__name__.replace('_', '-')}"
+        routes.append(Route(path, wrapper, methods=["POST"]))
         return wrapper
 
     return decorator
@@ -116,8 +130,40 @@ async def delete_node(request: DeleteNodeRequest) -> DeleteNodeResponse:
     return message_handler.delete_node(request=request, state=state)
 
 
+@rest_request_response(RegisterNodeFleetRequest)
+async def register_node(
+    request: RegisterNodeFleetRequest,
+) -> RegisterNodeFleetResponse:
+    """Register a node (Fleet API only)."""
+    raise NotImplementedError("RegisterNode is not yet implemented.")
+
+
+@rest_request_response(ActivateNodeRequest)
+async def activate_node(
+    request: ActivateNodeRequest,
+) -> ActivateNodeResponse:
+    """Activate a node."""
+    raise NotImplementedError("ActivateNode is not yet implemented.")
+
+
+@rest_request_response(DeactivateNodeRequest)
+async def deactivate_node(
+    request: DeactivateNodeRequest,
+) -> DeactivateNodeResponse:
+    """Deactivate a node."""
+    raise NotImplementedError("DeactivateNode is not yet implemented.")
+
+
+@rest_request_response(UnregisterNodeFleetRequest)
+async def unregister_node(
+    request: UnregisterNodeFleetRequest,
+) -> UnregisterNodeFleetResponse:
+    """Unregister a node (Fleet API only)."""
+    raise NotImplementedError("UnregisterNode is not yet implemented.")
+
+
 @rest_request_response(PullMessagesRequest)
-async def pull_message(request: PullMessagesRequest) -> PullMessagesResponse:
+async def pull_messages(request: PullMessagesRequest) -> PullMessagesResponse:
     """Pull PullMessages."""
     # Get state from app
     state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
@@ -128,7 +174,7 @@ async def pull_message(request: PullMessagesRequest) -> PullMessagesResponse:
 
 
 @rest_request_response(PushMessagesRequest)
-async def push_message(request: PushMessagesRequest) -> PushMessagesResponse:
+async def push_messages(request: PushMessagesRequest) -> PushMessagesResponse:
     """Pull PushMessages."""
     # Get state from app
     state: LinkState = cast(LinkStateFactory, app.state.STATE_FACTORY).state()
@@ -212,23 +258,6 @@ async def confirm_message_received(
     )
 
 
-routes = [
-    Route("/api/v0/fleet/create-node", create_node, methods=["POST"]),
-    Route("/api/v0/fleet/delete-node", delete_node, methods=["POST"]),
-    Route("/api/v0/fleet/pull-messages", pull_message, methods=["POST"]),
-    Route("/api/v0/fleet/push-messages", push_message, methods=["POST"]),
-    Route("/api/v0/fleet/pull-object", pull_object, methods=["POST"]),
-    Route("/api/v0/fleet/push-object", push_object, methods=["POST"]),
-    Route("/api/v0/fleet/send-node-heartbeat", send_node_heartbeat, methods=["POST"]),
-    Route("/api/v0/fleet/get-run", get_run, methods=["POST"]),
-    Route("/api/v0/fleet/get-fab", get_fab, methods=["POST"]),
-    Route(
-        "/api/v0/fleet/confirm-message-received",
-        confirm_message_received,
-        methods=["POST"],
-    ),
-]
-
 app: Starlette = Starlette(
     debug=False,
     routes=routes,

flwr/server/superlink/linkstate/in_memory_linkstate.py

@@ -386,6 +386,47 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
             # Set online_until to current timestamp on deletion, if it is in the future
             node.online_until = min(node.online_until, current.timestamp())
 
+    def activate_node(self, node_id: int, heartbeat_interval: float) -> bool:
+        """Activate the node with the specified `node_id`."""
+        with self.lock:
+            self._check_and_tag_offline_nodes(node_ids=[node_id])
+
+            # Check if the node exists
+            if not (node := self.nodes.get(node_id)):
+                return False
+
+            # Only activate if the node is currently registered or offline
+            current_dt = now()
+            if node.status in (NodeStatus.REGISTERED, NodeStatus.OFFLINE):
+                node.status = NodeStatus.ONLINE
+                node.last_activated_at = current_dt.isoformat()
+                node.online_until = (
+                    current_dt.timestamp() + HEARTBEAT_PATIENCE * heartbeat_interval
+                )
+                node.heartbeat_interval = heartbeat_interval
+                return True
+            return False
+
+    def deactivate_node(self, node_id: int) -> bool:
+        """Deactivate the node with the specified `node_id`."""
+        with self.lock:
+            self._check_and_tag_offline_nodes(node_ids=[node_id])
+
+            # Check if the node exists
+            if not (node := self.nodes.get(node_id)):
+                return False
+
+            # Only deactivate if the node is currently online
+            current_dt = now()
+            if node.status == NodeStatus.ONLINE:
+                node.status = NodeStatus.OFFLINE
+                node.last_deactivated_at = current_dt.isoformat()
+
+                # Set online_until to current timestamp
+                node.online_until = current_dt.timestamp()
+                return True
+            return False
+
     def get_nodes(self, run_id: int) -> set[int]:
         """Return all available nodes.
 
@@ -411,10 +452,10 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
     ) -> Sequence[NodeInfo]:
         """Retrieve information about nodes based on the specified filters."""
         with self.lock:
-            self._check_and_tag_deactivated_nodes()
+            self._check_and_tag_offline_nodes()
             result = []
-            for node in self.nodes.values():
-                if node_ids is not None and node.node_id not in node_ids:
+            for node_id in self.nodes.keys() if node_ids is None else node_ids:
+                if (node := self.nodes.get(node_id)) is None:
                     continue
                 if owner_aids is not None and node.owner_aid not in owner_aids:
                     continue
@@ -423,11 +464,15 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
                 result.append(node)
             return result
 
-    def _check_and_tag_deactivated_nodes(self) -> None:
+    def _check_and_tag_offline_nodes(
+        self, node_ids: Optional[list[int]] = None
+    ) -> None:
         with self.lock:
             # Set all nodes of "online" status to "offline" if they've offline
             current_ts = now().timestamp()
-            for node in self.nodes.values():
+            for node_id in node_ids or self.nodes.keys():
+                if (node := self.nodes.get(node_id)) is None:
+                    continue
                 if node.status == NodeStatus.ONLINE:
                     if node.online_until <= current_ts:
                         node.status = NodeStatus.OFFLINE

flwr/server/superlink/linkstate/linkstate.py

@@ -139,6 +139,45 @@ class LinkState(CoreState):  # pylint: disable=R0904
     def delete_node(self, owner_aid: str, node_id: int) -> None:
         """Remove `node_id` from the link state."""
 
+    @abc.abstractmethod
+    def activate_node(self, node_id: int, heartbeat_interval: float) -> bool:
+        """Activate the node with the specified `node_id`.
+
+        Transitions the node status to "online". The transition will fail
+        if the current status is not "registered" or "offline".
+
+        Parameters
+        ----------
+        node_id : int
+            The identifier of the node to activate.
+        heartbeat_interval : float
+            The interval (in seconds) from the current timestamp within which
+            the next heartbeat from this node is expected to be received.
+
+        Returns
+        -------
+        bool
+            True if the status transition was successful, False otherwise.
+        """
+
+    @abc.abstractmethod
+    def deactivate_node(self, node_id: int) -> bool:
+        """Deactivate the node with the specified `node_id`.
+
+        Transitions the node status to "offline". The transition will fail
+        if the current status is not "online".
+
+        Parameters
+        ----------
+        node_id : int
+            The identifier of the node to deactivate.
+
+        Returns
+        -------
+        bool
+            True if the status transition was successful, False otherwise.
+        """
+
     @abc.abstractmethod
     def get_nodes(self, run_id: int) -> set[int]:
         """Retrieve all currently stored node IDs as a set.