flwr-nightly 1.23.0.dev20251016__py3-none-any.whl → 1.23.0.dev20251020__py3-none-any.whl

flwr/proto/node_pb2.py

@@ -14,7 +14,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x66lwr/proto/node.proto\x12\nflwr.proto\"\x17\n\x04Node\x12\x0f\n\x07node_id\x18\x01 \x01(\x04\"\xc6\x02\n\x08NodeInfo\x12\x0f\n\x07node_id\x18\x01 \x01(\x04\x12\x11\n\towner_aid\x18\x02 \x01(\t\x12\x0e\n\x06status\x18\x03 \x01(\t\x12\x12\n\ncreated_at\x18\x04 \x01(\t\x12\x1e\n\x11last_activated_at\x18\x05 \x01(\tH\x00\x88\x01\x01\x12 \n\x13last_deactivated_at\x18\x06 \x01(\tH\x01\x88\x01\x01\x12\x17\n\ndeleted_at\x18\x07 \x01(\tH\x02\x88\x01\x01\x12\x19\n\x0conline_until\x18\x08 \x01(\x01H\x03\x88\x01\x01\x12\x1a\n\x12heartbeat_interval\x18\t \x01(\x01\x12\x12\n\npublic_key\x18\n \x01(\x0c\x42\x14\n\x12_last_activated_atB\x16\n\x14_last_deactivated_atB\r\n\x0b_deleted_atB\x0f\n\r_online_untilb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x66lwr/proto/node.proto\x12\nflwr.proto\"\x17\n\x04Node\x12\x0f\n\x07node_id\x18\x01 \x01(\x04\"\xd3\x02\n\x08NodeInfo\x12\x0f\n\x07node_id\x18\x01 \x01(\x04\x12\x11\n\towner_aid\x18\x02 \x01(\t\x12\x0e\n\x06status\x18\x03 \x01(\t\x12\x15\n\rregistered_at\x18\x04 \x01(\t\x12\x1e\n\x11last_activated_at\x18\x05 \x01(\tH\x00\x88\x01\x01\x12 \n\x13last_deactivated_at\x18\x06 \x01(\tH\x01\x88\x01\x01\x12\x1c\n\x0funregistered_at\x18\x07 \x01(\tH\x02\x88\x01\x01\x12\x19\n\x0conline_until\x18\x08 \x01(\x01H\x03\x88\x01\x01\x12\x1a\n\x12heartbeat_interval\x18\t \x01(\x01\x12\x12\n\npublic_key\x18\n \x01(\x0c\x42\x14\n\x12_last_activated_atB\x16\n\x14_last_deactivated_atB\x12\n\x10_unregistered_atB\x0f\n\r_online_untilb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -24,5 +24,5 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   _globals['_NODE']._serialized_start=37
   _globals['_NODE']._serialized_end=60
   _globals['_NODEINFO']._serialized_start=63
-  _globals['_NODEINFO']._serialized_end=389
+  _globals['_NODEINFO']._serialized_end=402
 # @@protoc_insertion_point(module_scope)

flwr/proto/node_pb2.pyi

@@ -26,20 +26,20 @@ class NodeInfo(google.protobuf.message.Message):
     NODE_ID_FIELD_NUMBER: builtins.int
     OWNER_AID_FIELD_NUMBER: builtins.int
     STATUS_FIELD_NUMBER: builtins.int
-    CREATED_AT_FIELD_NUMBER: builtins.int
+    REGISTERED_AT_FIELD_NUMBER: builtins.int
     LAST_ACTIVATED_AT_FIELD_NUMBER: builtins.int
     LAST_DEACTIVATED_AT_FIELD_NUMBER: builtins.int
-    DELETED_AT_FIELD_NUMBER: builtins.int
+    UNREGISTERED_AT_FIELD_NUMBER: builtins.int
     ONLINE_UNTIL_FIELD_NUMBER: builtins.int
     HEARTBEAT_INTERVAL_FIELD_NUMBER: builtins.int
     PUBLIC_KEY_FIELD_NUMBER: builtins.int
     node_id: builtins.int
     owner_aid: typing.Text
     status: typing.Text
-    created_at: typing.Text
+    registered_at: typing.Text
     last_activated_at: typing.Text
     last_deactivated_at: typing.Text
-    deleted_at: typing.Text
+    unregistered_at: typing.Text
     online_until: builtins.float
     heartbeat_interval: builtins.float
     public_key: builtins.bytes
@@ -48,22 +48,22 @@ class NodeInfo(google.protobuf.message.Message):
         node_id: builtins.int = ...,
         owner_aid: typing.Text = ...,
         status: typing.Text = ...,
-        created_at: typing.Text = ...,
+        registered_at: typing.Text = ...,
         last_activated_at: typing.Optional[typing.Text] = ...,
         last_deactivated_at: typing.Optional[typing.Text] = ...,
-        deleted_at: typing.Optional[typing.Text] = ...,
+        unregistered_at: typing.Optional[typing.Text] = ...,
         online_until: typing.Optional[builtins.float] = ...,
         heartbeat_interval: builtins.float = ...,
         public_key: builtins.bytes = ...,
         ) -> None: ...
-    def HasField(self, field_name: typing_extensions.Literal["_deleted_at",b"_deleted_at","_last_activated_at",b"_last_activated_at","_last_deactivated_at",b"_last_deactivated_at","_online_until",b"_online_until","deleted_at",b"deleted_at","last_activated_at",b"last_activated_at","last_deactivated_at",b"last_deactivated_at","online_until",b"online_until"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["_deleted_at",b"_deleted_at","_last_activated_at",b"_last_activated_at","_last_deactivated_at",b"_last_deactivated_at","_online_until",b"_online_until","created_at",b"created_at","deleted_at",b"deleted_at","heartbeat_interval",b"heartbeat_interval","last_activated_at",b"last_activated_at","last_deactivated_at",b"last_deactivated_at","node_id",b"node_id","online_until",b"online_until","owner_aid",b"owner_aid","public_key",b"public_key","status",b"status"]) -> None: ...
-    @typing.overload
-    def WhichOneof(self, oneof_group: typing_extensions.Literal["_deleted_at",b"_deleted_at"]) -> typing.Optional[typing_extensions.Literal["deleted_at"]]: ...
+    def HasField(self, field_name: typing_extensions.Literal["_last_activated_at",b"_last_activated_at","_last_deactivated_at",b"_last_deactivated_at","_online_until",b"_online_until","_unregistered_at",b"_unregistered_at","last_activated_at",b"last_activated_at","last_deactivated_at",b"last_deactivated_at","online_until",b"online_until","unregistered_at",b"unregistered_at"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing_extensions.Literal["_last_activated_at",b"_last_activated_at","_last_deactivated_at",b"_last_deactivated_at","_online_until",b"_online_until","_unregistered_at",b"_unregistered_at","heartbeat_interval",b"heartbeat_interval","last_activated_at",b"last_activated_at","last_deactivated_at",b"last_deactivated_at","node_id",b"node_id","online_until",b"online_until","owner_aid",b"owner_aid","public_key",b"public_key","registered_at",b"registered_at","status",b"status","unregistered_at",b"unregistered_at"]) -> None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing_extensions.Literal["_last_activated_at",b"_last_activated_at"]) -> typing.Optional[typing_extensions.Literal["last_activated_at"]]: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing_extensions.Literal["_last_deactivated_at",b"_last_deactivated_at"]) -> typing.Optional[typing_extensions.Literal["last_deactivated_at"]]: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing_extensions.Literal["_online_until",b"_online_until"]) -> typing.Optional[typing_extensions.Literal["online_until"]]: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing_extensions.Literal["_unregistered_at",b"_unregistered_at"]) -> typing.Optional[typing_extensions.Literal["unregistered_at"]]: ...
 global___NodeInfo = NodeInfo

flwr/server/app.py

@@ -71,8 +71,8 @@ from flwr.superlink.artifact_provider import ArtifactProvider
 from flwr.superlink.auth_plugin import (
     ControlAuthnPlugin,
     ControlAuthzPlugin,
-    get_control_authn_plugins,
-    get_control_authz_plugins,
+    NoOpControlAuthnPlugin,
+    NoOpControlAuthzPlugin,
 )
 from flwr.superlink.servicer.control import run_control_api_grpc
 
@@ -93,6 +93,8 @@ P = TypeVar("P", ControlAuthnPlugin, ControlAuthzPlugin)
 try:
     from flwr.ee import (
         add_ee_args_superlink,
+        get_control_authn_ee_plugins,
+        get_control_authz_ee_plugins,
         get_control_event_log_writer_plugins,
         get_ee_artifact_provider,
         get_fleet_event_log_writer_plugins,
@@ -119,6 +121,26 @@ except ImportError:
             "No event log writer plugins are currently supported."
         )
 
+    def get_control_authn_ee_plugins() -> dict[str, type[ControlAuthnPlugin]]:
+        """Return all Control API authentication plugins for EE."""
+        return {}
+
+    def get_control_authz_ee_plugins() -> dict[str, type[ControlAuthzPlugin]]:
+        """Return all Control API authorization plugins for EE."""
+        return {}
+
+
+def get_control_authn_plugins() -> dict[str, type[ControlAuthnPlugin]]:
+    """Return all Control API authentication plugins."""
+    ee_dict: dict[str, type[ControlAuthnPlugin]] = get_control_authn_ee_plugins()
+    return ee_dict | {AuthnType.NOOP: NoOpControlAuthnPlugin}
+
+
+def get_control_authz_plugins() -> dict[str, type[ControlAuthzPlugin]]:
+    """Return all Control API authorization plugins."""
+    ee_dict: dict[str, type[ControlAuthzPlugin]] = get_control_authz_ee_plugins()
+    return ee_dict | {AuthzType.NOOP: NoOpControlAuthzPlugin}
+
 
 # pylint: disable=too-many-branches, too-many-locals, too-many-statements
 def run_superlink() -> None:
@@ -213,6 +235,17 @@ def run_superlink() -> None:
 
     # If supernode authentication is disabled, warn users
     enable_supernode_auth: bool = args.enable_supernode_auth
+    if enable_supernode_auth and args.insecure:
+        url_v = f"https://flower.ai/docs/framework/v{package_version}/en/"
+        page = "how-to-authenticate-supernodes.html"
+        flwr_exit(
+            ExitCode.SUPERLINK_INVALID_ARGS,
+            "The `--enable-supernode-auth` flag requires encrypted TLS communications. "
+            "Please provide TLS certificates using the `--ssl-certfile`, "
+            "`--ssl-keyfile` and `--ssl-ca-certfile` arguments to your SuperLink. "
+            "Please refer to the Flower documentation for more information: "
+            f"{url_v}{page}",
+        )
     if not enable_supernode_auth:
         log(
             WARN,

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

@@ -15,6 +15,7 @@
 """Fleet API gRPC request-response servicer."""
 
 
+import threading
 from logging import DEBUG, ERROR, INFO
 
 import grpc
@@ -53,6 +54,7 @@ from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=
 from flwr.server.superlink.fleet.message_handler import message_handler
 from flwr.server.superlink.linkstate import LinkStateFactory
 from flwr.server.superlink.utils import abort_grpc_context
+from flwr.supercore.constant import NodeStatus
 from flwr.supercore.ffs import FfsFactory
 from flwr.supercore.object_store import ObjectStoreFactory
 
@@ -71,6 +73,7 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self.ffs_factory = ffs_factory
         self.objectstore_factory = objectstore_factory
         self.enable_supernode_auth = enable_supernode_auth
+        self.lock = threading.Lock()
 
     def CreateNode(
         self, request: CreateNodeRequest, context: grpc.ServicerContext
@@ -88,8 +91,31 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
 
             # Check if public key is already in use
             if node_id := state.get_node_id_by_public_key(request.public_key):
-                # Prepare response with existing node_id
-                response = CreateNodeResponse(node=Node(node_id=node_id))
+
+                # Ensure only one request that requires checking the node state
+                # is processed at a time. This avoids race conditions when two
+                # SuperNodes try to connect at the same time with the same
+                # public key.
+                with self.lock:
+                    node_info = state.get_node_info(node_ids=[node_id])[0]
+                    if node_info.status == NodeStatus.ONLINE:
+                        # Node is already active
+                        log(
+                            ERROR,
+                            "Public key already in use (node_id=%s)",
+                            node_id,
+                        )
+                        raise ValueError(
+                            "Public key already in use by an active SuperNode"
+                        )
+
+                    # Prepare response with existing node_id
+                    response = CreateNodeResponse(node=Node(node_id=node_id))
+                    # Awknowledge heartbeat to mark node as online
+                    state.acknowledge_node_heartbeat(
+                        node_id=node_id,
+                        heartbeat_interval=request.heartbeat_interval,
+                    )
             else:
                 if self.enable_supernode_auth:
                     # When SuperNode authentication is enabled,

flwr/server/superlink/linkstate/in_memory_linkstate.py

@@ -353,11 +353,11 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
             self.nodes[node_id] = NodeInfo(
                 node_id=node_id,
                 owner_aid=owner_aid,
-                status=NodeStatus.CREATED,
-                created_at=now().isoformat(),
+                status=NodeStatus.REGISTERED,
+                registered_at=now().isoformat(),
                 last_activated_at=None,
                 last_deactivated_at=None,
-                deleted_at=None,
+                unregistered_at=None,
                 online_until=None,
                 heartbeat_interval=heartbeat_interval,
                 public_key=public_key,
@@ -371,16 +371,16 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         with self.lock:
             if (
                 not (node := self.nodes.get(node_id))
-                or node.status == NodeStatus.DELETED
+                or node.status == NodeStatus.UNREGISTERED
                 or owner_aid != self.nodes[node_id].owner_aid
             ):
                 raise ValueError(
-                    f"Node ID {node_id} already deleted, not found or unauthorized "
-                    "deletion attempt."
+                    f"Node ID {node_id} already unregistered, not found or "
+                    "the request was unauthorized."
                 )
 
-            node.status = NodeStatus.DELETED
-            node.deleted_at = now().isoformat()
+            node.status = NodeStatus.UNREGISTERED
+            node.unregistered_at = now().isoformat()
 
     def get_nodes(self, run_id: int) -> set[int]:
         """Return all available nodes.
@@ -436,14 +436,23 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         with self.lock:
             if (
                 node := self.nodes.get(node_id)
-            ) is None or node.status == NodeStatus.DELETED:
+            ) is None or node.status == NodeStatus.UNREGISTERED:
                 raise ValueError(f"Node ID {node_id} not found")
             return node.public_key
 
     def get_node_id_by_public_key(self, public_key: bytes) -> Optional[int]:
-        """Get `node_id` for the specified `public_key`."""
+        """Get `node_id` for the specified `public_key` if it exists and is not
+        deleted."""
         with self.lock:
-            return self.node_public_key_to_node_id.get(public_key)
+            node_id = self.node_public_key_to_node_id.get(public_key)
+
+            if node_id is None:
+                return None
+
+            node_info = self.nodes[node_id]
+            if node_info.status == NodeStatus.UNREGISTERED:
+                return None
+            return node_id
 
     # pylint: disable=too-many-arguments,too-many-positional-arguments
     def create_run(
@@ -630,11 +639,13 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         the node is marked as offline.
         """
         with self.lock:
-            if (node := self.nodes.get(node_id)) and node.status != NodeStatus.DELETED:
+            if (
+                node := self.nodes.get(node_id)
+            ) and node.status != NodeStatus.UNREGISTERED:
                 current_dt = now()
 
                 # Set timestamp if the status changes
-                if node.status != NodeStatus.ONLINE:  # offline or created
+                if node.status != NodeStatus.ONLINE:  # offline or registered
                     node.status = NodeStatus.ONLINE
                     node.last_activated_at = current_dt.isoformat()
 

flwr/server/superlink/linkstate/linkstate.py

@@ -151,7 +151,7 @@ class LinkState(CoreState):  # pylint: disable=R0904
 
     @abc.abstractmethod
     def get_node_id_by_public_key(self, public_key: bytes) -> Optional[int]:
-        """Get `node_id` for the specified `public_key`.
+        """Get `node_id` for the specified `public_key` if it exists and is not deleted.
 
         Parameters
         ----------
@@ -161,7 +161,8 @@ class LinkState(CoreState):  # pylint: disable=R0904
         Returns
         -------
         Optional[int]
-            The `node_id` associated with the specified `public_key`.
+            The `node_id` associated with the specified `public_key` if it exists
+            and is not deleted; otherwise, `None`.
         """
 
     @abc.abstractmethod

flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -76,10 +76,10 @@ CREATE TABLE IF NOT EXISTS node(
     node_id                 INTEGER UNIQUE,
     owner_aid               TEXT,
     status                  TEXT,
-    created_at              TEXT,
+    registered_at           TEXT,
     last_activated_at       TEXT NULL,
     last_deactivated_at     TEXT NULL,
-    deleted_at              TEXT NULL,
+    unregistered_at         TEXT NULL,
     online_until            TIMESTAMP NULL,
     heartbeat_interval      REAL,
     public_key              BLOB UNIQUE
@@ -623,8 +623,8 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
 
         query = """
             INSERT INTO node
-            (node_id, owner_aid, status, created_at, last_activated_at,
-            last_deactivated_at, deleted_at, online_until, heartbeat_interval,
+            (node_id, owner_aid, status, registered_at, last_activated_at,
+            last_deactivated_at, unregistered_at, online_until, heartbeat_interval,
             public_key)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         """
@@ -636,11 +636,11 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
                 (
                     sint64_node_id,  # node_id
                     owner_aid,  # owner_aid
-                    NodeStatus.CREATED,  # status
-                    now().isoformat(),  # created_at
+                    NodeStatus.REGISTERED,  # status
+                    now().isoformat(),  # registered_at
                     None,  # last_activated_at
                     None,  # last_deactivated_at
-                    None,  # deleted_at
+                    None,  # unregistered_at
                     None,  # online_until, initialized with offline status
                     heartbeat_interval,  # heartbeat_interval
                     public_key,  # public_key
@@ -662,15 +662,15 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
 
         query = """
             UPDATE node
-            SET status = ?, deleted_at = ?
+            SET status = ?, unregistered_at = ?
             WHERE node_id = ? AND status != ? AND owner_aid = ?
             RETURNING node_id
         """
         params = (
-            NodeStatus.DELETED,
+            NodeStatus.UNREGISTERED,
             now().isoformat(),
             sint64_node_id,
-            NodeStatus.DELETED,
+            NodeStatus.UNREGISTERED,
             owner_aid,
         )
 
@@ -775,7 +775,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
 
         # Query the public key for the given node_id
         query = "SELECT public_key FROM node WHERE node_id = ? AND status != ?;"
-        rows = self.query(query, (sint64_node_id, NodeStatus.DELETED))
+        rows = self.query(query, (sint64_node_id, NodeStatus.UNREGISTERED))
 
         # If no result is found, return None
         if not rows:
@@ -785,9 +785,10 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         return cast(bytes, rows[0]["public_key"])
 
     def get_node_id_by_public_key(self, public_key: bytes) -> Optional[int]:
-        """Get `node_id` for the specified `public_key`."""
+        """Get `node_id` for the specified `public_key` if it exists and is not
+        deleted."""
         query = "SELECT node_id FROM node WHERE public_key = ? AND status != ?;"
-        rows = self.query(query, (public_key, NodeStatus.DELETED))
+        rows = self.query(query, (public_key, NodeStatus.UNREGISTERED))
 
         # If no result is found, return None
         if not rows:
@@ -1058,7 +1059,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             # Check if node exists and not deleted
             query = "SELECT status FROM node WHERE node_id = ? AND status != ?"
             row = self.conn.execute(
-                query, (sint64_node_id, NodeStatus.DELETED)
+                query, (sint64_node_id, NodeStatus.UNREGISTERED)
             ).fetchone()
             if row is None:
                 return False

flwr/supercore/constant.py

@@ -24,10 +24,10 @@ EXEC_PLUGIN_SECTION = "exec_plugin"
 class NodeStatus:
     """Event log writer types."""
 
-    CREATED = "created"
+    REGISTERED = "registered"
     ONLINE = "online"
     OFFLINE = "offline"
-    DELETED = "deleted"
+    UNREGISTERED = "unregistered"
 
     def __new__(cls) -> NodeStatus:
         """Prevent instantiation."""

flwr/superlink/auth_plugin/__init__.py

@@ -15,41 +15,12 @@
 """Account auth plugin for ControlServicer."""
 
 
-from flwr.common.constant import AuthnType, AuthzType
-
 from .auth_plugin import ControlAuthnPlugin, ControlAuthzPlugin
 from .noop_auth_plugin import NoOpControlAuthnPlugin, NoOpControlAuthzPlugin
 
-try:
-    from flwr.ee import get_control_authn_ee_plugins, get_control_authz_ee_plugins
-except ImportError:
-
-    def get_control_authn_ee_plugins() -> dict[str, type[ControlAuthnPlugin]]:
-        """Return all Control API authentication plugins for EE."""
-        return {}
-
-    def get_control_authz_ee_plugins() -> dict[str, type[ControlAuthzPlugin]]:
-        """Return all Control API authorization plugins for EE."""
-        return {}
-
-
-def get_control_authn_plugins() -> dict[str, type[ControlAuthnPlugin]]:
-    """Return all Control API authentication plugins."""
-    ee_dict: dict[str, type[ControlAuthnPlugin]] = get_control_authn_ee_plugins()
-    return ee_dict | {AuthnType.NOOP: NoOpControlAuthnPlugin}
-
-
-def get_control_authz_plugins() -> dict[str, type[ControlAuthzPlugin]]:
-    """Return all Control API authorization plugins."""
-    ee_dict: dict[str, type[ControlAuthzPlugin]] = get_control_authz_ee_plugins()
-    return ee_dict | {AuthzType.NOOP: NoOpControlAuthzPlugin}
-
-
 __all__ = [
     "ControlAuthnPlugin",
     "ControlAuthzPlugin",
     "NoOpControlAuthnPlugin",
     "NoOpControlAuthzPlugin",
-    "get_control_authn_plugins",
-    "get_control_authz_plugins",
 ]

flwr/superlink/servicer/control/control_servicer.py

@@ -49,29 +49,30 @@ from flwr.common.serde import (
 from flwr.common.typing import Fab, Run, RunStatus
 from flwr.proto import control_pb2_grpc  # pylint: disable=E0611
 from flwr.proto.control_pb2 import (  # pylint: disable=E0611
-    CreateNodeCliRequest,
-    CreateNodeCliResponse,
-    DeleteNodeCliRequest,
-    DeleteNodeCliResponse,
     GetAuthTokensRequest,
     GetAuthTokensResponse,
     GetLoginDetailsRequest,
     GetLoginDetailsResponse,
-    ListNodesCliRequest,
-    ListNodesCliResponse,
+    ListNodesRequest,
+    ListNodesResponse,
     ListRunsRequest,
     ListRunsResponse,
     PullArtifactsRequest,
     PullArtifactsResponse,
+    RegisterNodeRequest,
+    RegisterNodeResponse,
     StartRunRequest,
     StartRunResponse,
     StopRunRequest,
     StopRunResponse,
     StreamLogsRequest,
     StreamLogsResponse,
+    UnregisterNodeRequest,
+    UnregisterNodeResponse,
 )
 from flwr.proto.node_pb2 import NodeInfo  # pylint: disable=E0611
 from flwr.server.superlink.linkstate import LinkState, LinkStateFactory
+from flwr.supercore.constant import NodeStatus
 from flwr.supercore.ffs import FfsFactory
 from flwr.supercore.object_store import ObjectStore, ObjectStoreFactory
 from flwr.supercore.primitives.asymmetric import bytes_to_public_key, uses_nist_ec_curve
@@ -389,11 +390,11 @@ class ControlServicer(control_pb2_grpc.ControlServicer):
         download_url = self.artifact_provider.get_url(run_id)
         return PullArtifactsResponse(url=download_url)
 
-    def CreateNodeCli(
-        self, request: CreateNodeCliRequest, context: grpc.ServicerContext
-    ) -> CreateNodeCliResponse:
+    def RegisterNode(
+        self, request: RegisterNodeRequest, context: grpc.ServicerContext
+    ) -> RegisterNodeResponse:
         """Add a SuperNode."""
-        log(INFO, "ControlServicer.CreateNodeCli")
+        log(INFO, "ControlServicer.RegisterNode")
 
         # Verify public key
         try:
@@ -427,15 +428,15 @@ class ControlServicer(control_pb2_grpc.ControlServicer):
             context.abort(
                 grpc.StatusCode.FAILED_PRECONDITION, PUBLIC_KEY_ALREADY_IN_USE_MESSAGE
             )
-        log(INFO, "[ControlServicer.CreateNodeCli] Created node_id=%s", node_id)
+        log(INFO, "[ControlServicer.RegisterNode] Created node_id=%s", node_id)
 
-        return CreateNodeCliResponse(node_id=node_id)
+        return RegisterNodeResponse(node_id=node_id)
 
-    def DeleteNodeCli(
-        self, request: DeleteNodeCliRequest, context: grpc.ServicerContext
-    ) -> DeleteNodeCliResponse:
+    def UnregisterNode(
+        self, request: UnregisterNodeRequest, context: grpc.ServicerContext
+    ) -> UnregisterNodeResponse:
         """Remove a SuperNode."""
-        log(INFO, "ControlServicer.RemoveNode")
+        log(INFO, "ControlServicer.UnregisterNode")
 
         # Init link state
         state = self.linkstate_factory.state()
@@ -448,19 +449,19 @@ class ControlServicer(control_pb2_grpc.ControlServicer):
             log(ERROR, NODE_NOT_FOUND_MESSAGE)
             context.abort(grpc.StatusCode.NOT_FOUND, NODE_NOT_FOUND_MESSAGE)
 
-        return DeleteNodeCliResponse()
+        return UnregisterNodeResponse()
 
-    def ListNodesCli(
-        self, request: ListNodesCliRequest, context: grpc.ServicerContext
-    ) -> ListNodesCliResponse:
+    def ListNodes(
+        self, request: ListNodesRequest, context: grpc.ServicerContext
+    ) -> ListNodesResponse:
         """List all SuperNodes."""
-        log(INFO, "ControlServicer.ListNodesCli")
+        log(INFO, "ControlServicer.ListNodes")
 
         if self.is_simulation:
-            log(ERROR, "ListNodesCli is not available in simulation mode.")
+            log(ERROR, "ListNodes is not available in simulation mode.")
             context.abort(
                 grpc.StatusCode.UNIMPLEMENTED,
-                "ListNodesCli is not available in simulation mode.",
+                "ListNodesis not available in simulation mode.",
             )
             raise grpc.RpcError()  # This line is unreachable
 
@@ -478,61 +479,61 @@ class ControlServicer(control_pb2_grpc.ControlServicer):
             # Retrieve all nodes for the account
             nodes_info = state.get_node_info(owner_aids=[flwr_aid])
 
-        return ListNodesCliResponse(nodes_info=nodes_info, now=now().isoformat())
+        return ListNodesResponse(nodes_info=nodes_info, now=now().isoformat())
 
 
 def _create_list_nodeif_for_dry_run() -> Sequence[NodeInfo]:
     """Create a list of NodeInfo for dry run testing."""
     nodes_info: list[NodeInfo] = []
-    # A node created (but not connected)
+    # A node registered (but not connected)
     nodes_info.append(
         NodeInfo(
             node_id=15390646978706312628,
             owner_aid="owner_aid_1",
-            status="created",
-            created_at=(now()).isoformat(),
+            status=NodeStatus.REGISTERED,
+            registered_at=(now()).isoformat(),
             last_activated_at="",
             last_deactivated_at="",
-            deleted_at="",
+            unregistered_at="",
         )
     )
 
-    # A node created and connected
+    # A node registered and connected
     nodes_info.append(
         NodeInfo(
             node_id=2941141058168602545,
             owner_aid="owner_aid_2",
-            status="online",
-            created_at=(now()).isoformat(),
+            status=NodeStatus.ONLINE,
+            registered_at=(now()).isoformat(),
             last_activated_at=(now() + timedelta(hours=0.5)).isoformat(),
             last_deactivated_at="",
-            deleted_at="",
+            unregistered_at="",
         )
     )
 
-    # A node created and deleted (never connected)
+    # A node registered and unregistered (never connected)
     nodes_info.append(
         NodeInfo(
             node_id=906971720890549292,
             owner_aid="owner_aid_3",
-            status="deleted",
-            created_at=(now()).isoformat(),
+            status=NodeStatus.UNREGISTERED,
+            registered_at=(now()).isoformat(),
             last_activated_at="",
             last_deactivated_at="",
-            deleted_at=(now() + timedelta(hours=1)).isoformat(),
+            unregistered_at=(now() + timedelta(hours=1)).isoformat(),
         )
     )
 
-    # A node created, deactivate and then deleted
+    # A node registered, deactivate and then unregistered
     nodes_info.append(
         NodeInfo(
             node_id=1781174086018058152,
             owner_aid="owner_aid_4",
-            status="offline",
-            created_at=(now()).isoformat(),
+            status=NodeStatus.OFFLINE,
+            registered_at=(now()).isoformat(),
             last_activated_at=(now() + timedelta(hours=0.5)).isoformat(),
             last_deactivated_at=(now() + timedelta(hours=1)).isoformat(),
-            deleted_at=(now() + timedelta(hours=1.5)).isoformat(),
+            unregistered_at=(now() + timedelta(hours=1.5)).isoformat(),
         )
     )
     return nodes_info