flwr-nightly 1.23.0.dev20251017__py3-none-any.whl → 1.23.0.dev20251021__py3-none-any.whl

flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -18,11 +18,10 @@
 # pylint: disable=too-many-lines
 
 import json
-import re
 import secrets
 import sqlite3
 from collections.abc import Sequence
-from logging import DEBUG, ERROR, WARNING
+from logging import ERROR, WARNING
 from typing import Any, Optional, Union, cast
 
 from flwr.common import Context, Message, Metadata, log, now
@@ -52,6 +51,7 @@ from flwr.proto.recorddict_pb2 import RecordDict as ProtoRecordDict
 # pylint: enable=E0611
 from flwr.server.utils.validator import validate_message
 from flwr.supercore.constant import NodeStatus
+from flwr.supercore.sqlite_mixin import SqliteMixin
 
 from .linkstate import LinkState
 from .utils import (
@@ -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
@@ -183,95 +183,25 @@ CREATE TABLE IF NOT EXISTS token_store (
 );
 """
 
-DictOrTuple = Union[tuple[Any, ...], dict[str, Any]]
 
-
-class SqliteLinkState(LinkState):  # pylint: disable=R0904
+class SqliteLinkState(LinkState, SqliteMixin):  # pylint: disable=R0904
     """SQLite-based LinkState implementation."""
 
-    def __init__(
-        self,
-        database_path: str,
-    ) -> None:
-        """Initialize an SqliteLinkState.
-
-        Parameters
-        ----------
-        database : (path-like object)
-            The path to the database file to be opened. Pass ":memory:" to open
-            a connection to a database that is in RAM, instead of on disk.
-        """
-        self.database_path = database_path
-        self.conn: Optional[sqlite3.Connection] = None
-
     def initialize(self, log_queries: bool = False) -> list[tuple[str]]:
-        """Create tables if they don't exist yet.
-
-        Parameters
-        ----------
-        log_queries : bool
-            Log each query which is executed.
-
-        Returns
-        -------
-        list[tuple[str]]
-            The list of all tables in the DB.
-        """
-        self.conn = sqlite3.connect(self.database_path)
-        self.conn.execute("PRAGMA foreign_keys = ON;")
-        self.conn.row_factory = dict_factory
-        if log_queries:
-            self.conn.set_trace_callback(lambda query: log(DEBUG, query))
-        cur = self.conn.cursor()
-
-        # Create each table if not exists queries
-        cur.execute(SQL_CREATE_TABLE_RUN)
-        cur.execute(SQL_CREATE_TABLE_LOGS)
-        cur.execute(SQL_CREATE_TABLE_CONTEXT)
-        cur.execute(SQL_CREATE_TABLE_MESSAGE_INS)
-        cur.execute(SQL_CREATE_TABLE_MESSAGE_RES)
-        cur.execute(SQL_CREATE_TABLE_NODE)
-        cur.execute(SQL_CREATE_TABLE_PUBLIC_KEY)
-        cur.execute(SQL_CREATE_TABLE_TOKEN_STORE)
-        cur.execute(SQL_CREATE_INDEX_ONLINE_UNTIL)
-        cur.execute(SQL_CREATE_INDEX_OWNER_AID)
-        res = cur.execute("SELECT name FROM sqlite_schema;")
-        return res.fetchall()
-
-    def query(
-        self,
-        query: str,
-        data: Optional[Union[Sequence[DictOrTuple], DictOrTuple]] = None,
-    ) -> list[dict[str, Any]]:
-        """Execute a SQL query."""
-        if self.conn is None:
-            raise AttributeError("LinkState is not initialized.")
-
-        if data is None:
-            data = []
-
-        # Clean up whitespace to make the logs nicer
-        query = re.sub(r"\s+", " ", query)
-
-        try:
-            with self.conn:
-                if (
-                    len(data) > 0
-                    and isinstance(data, (tuple, list))
-                    and isinstance(data[0], (tuple, dict))
-                ):
-                    rows = self.conn.executemany(query, data)
-                else:
-                    rows = self.conn.execute(query, data)
-
-                # Extract results before committing to support
-                #   INSERT/UPDATE ... RETURNING
-                # style queries
-                result = rows.fetchall()
-        except KeyError as exc:
-            log(ERROR, {"query": query, "data": data, "exception": exc})
-
-        return result
+        """Connect to the DB, enable FK support, and create tables if needed."""
+        return self._ensure_initialized(
+            SQL_CREATE_TABLE_RUN,
+            SQL_CREATE_TABLE_LOGS,
+            SQL_CREATE_TABLE_CONTEXT,
+            SQL_CREATE_TABLE_MESSAGE_INS,
+            SQL_CREATE_TABLE_MESSAGE_RES,
+            SQL_CREATE_TABLE_NODE,
+            SQL_CREATE_TABLE_PUBLIC_KEY,
+            SQL_CREATE_TABLE_TOKEN_STORE,
+            SQL_CREATE_INDEX_ONLINE_UNTIL,
+            SQL_CREATE_INDEX_OWNER_AID,
+            log_queries=log_queries,
+        )
 
     def store_message_ins(self, message: Message) -> Optional[str]:
         """Store one Message."""
@@ -490,11 +420,12 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             sint_node_id = convert_uint64_to_sint64(in_message.metadata.dst_node_id)
             dst_node_ids.add(sint_node_id)
         query = f"""
-                    SELECT node_id, online_until
-                    FROM node
-                    WHERE node_id IN ({",".join(["?"] * len(dst_node_ids))});
-                """
-        rows = self.query(query, tuple(dst_node_ids))
+            SELECT node_id, online_until
+            FROM node
+            WHERE node_id IN ({",".join(["?"] * len(dst_node_ids))})
+            AND status != ?
+        """
+        rows = self.query(query, tuple(dst_node_ids) + (NodeStatus.UNREGISTERED,))
         tmp_ret_dict = check_node_availability_for_in_message(
             inquired_in_message_ids=message_ids,
             found_in_message_dict=found_message_ins_dict,
@@ -623,8 +554,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 +567,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 +593,19 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
 
         query = """
             UPDATE node
-            SET status = ?, deleted_at = ?
+            SET status = ?, unregistered_at = ?,
+            online_until = IIF(online_until > ?, ?, online_until)
             WHERE node_id = ? AND status != ? AND owner_aid = ?
             RETURNING node_id
         """
+        current = now()
         params = (
-            NodeStatus.DELETED,
-            now().isoformat(),
+            NodeStatus.UNREGISTERED,
+            current.isoformat(),
+            current.timestamp(),
+            current.timestamp(),
             sint64_node_id,
-            NodeStatus.DELETED,
+            NodeStatus.UNREGISTERED,
             owner_aid,
         )
 
@@ -775,7 +710,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:
@@ -788,7 +723,7 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         """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:
@@ -1059,7 +994,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
@@ -1250,18 +1185,6 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         return convert_sint64_to_uint64(rows[0]["run_id"])
 
 
-def dict_factory(
-    cursor: sqlite3.Cursor,
-    row: sqlite3.Row,
-) -> dict[str, Any]:
-    """Turn SQLite results into dicts.
-
-    Less efficent for retrival of large amounts of data but easier to use.
-    """
-    fields = [column[0] for column in cursor.description]
-    return dict(zip(fields, row))
-
-
 def message_to_dict(message: Message) -> dict[str, Any]:
     """Transform Message to dict."""
     result = {

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/supercore/sqlite_mixin.py

@@ -0,0 +1,188 @@
+# Copyright 2025 Flower Labs GmbH. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+"""Mixin providing common SQLite connection and initialization logic."""
+
+
+import contextlib
+import re
+import sqlite3
+from abc import ABC, abstractmethod
+from collections.abc import Iterator, Sequence
+from logging import DEBUG, ERROR
+from typing import Any, Optional, Union
+
+from flwr.common.logger import log
+
+DictOrTuple = Union[tuple[Any, ...], dict[str, Any]]
+
+
+class SqliteMixin(ABC):
+    """Mixin providing common SQLite connection and initialization logic."""
+
+    def __init__(self, database_path: str) -> None:
+        self.database_path = database_path
+        self._conn: Optional[sqlite3.Connection] = None
+
+    @property
+    def conn(self) -> sqlite3.Connection:
+        """Get the SQLite connection."""
+        if self._conn is None:
+            raise AttributeError("Database not initialized. Call initialize() first.")
+        return self._conn
+
+    @contextlib.contextmanager
+    def transaction(self) -> Iterator[None]:
+        """Context manager for a transaction.
+
+        This allows nesting of transactions by checking if a transaction is
+        already in progress.
+
+        Examples
+        --------
+        ::
+
+            with self.transaction():
+                # Do some DB operations here
+                ...
+                with self.transaction():
+                    # Do some more DB operations here
+                    ...
+        """
+        if self._conn is None:
+            raise AttributeError("Database not initialized. Call initialize() first.")
+
+        # Start a transaction if not already in one
+        if not self._conn.in_transaction:
+            self._conn.execute("BEGIN")
+            try:
+                yield
+                self._conn.commit()
+            except Exception:
+                self._conn.rollback()
+                raise
+        # Do nothing if already in a transaction
+        else:
+            yield
+
+    @abstractmethod
+    def initialize(self, log_queries: bool = False) -> list[tuple[str]]:
+        """Connect to the DB, enable FK support, and create tables if needed.
+
+        Parameters
+        ----------
+        log_queries : bool
+            Log each query which is executed.
+
+        Returns
+        -------
+        list[tuple[str]]
+            The list of all tables in the DB.
+
+        Examples
+        --------
+        Implement in subclass:
+
+        .. code:: python
+
+            def initialize(self, log_queries: bool = False) -> list[tuple[str]]:
+                return self._ensure_initialized(
+                    SQL_CREATE_TABLE_FOO,
+                    SQL_CREATE_TABLE_BAR,
+                    log_queries=log_queries
+                )
+        """
+
+    def _ensure_initialized(
+        self,
+        *create_statements: str,
+        log_queries: bool = False,
+    ) -> list[tuple[str]]:
+        """Connect to the DB, enable FK support, and create tables if needed.
+
+        Subclasses should call this with their own CREATE TABLE/INDEX statements in
+        their `.initialize()` methods.
+
+        Parameters
+        ----------
+        create_statements : str
+            SQL statements to create tables and indexes.
+        log_queries : bool
+            Log each query which is executed.
+
+        Returns
+        -------
+        list[tuple[str]]
+            The list of all tables in the DB.
+        """
+        self._conn = sqlite3.connect(self.database_path)
+        self._conn.execute("PRAGMA foreign_keys = ON;")
+        self._conn.row_factory = dict_factory
+
+        if log_queries:
+            self._conn.set_trace_callback(lambda q: log(DEBUG, q))
+
+        # Create tables and indexes
+        cur = self._conn.cursor()
+        for sql in create_statements:
+            cur.execute(sql)
+        res = cur.execute("SELECT name FROM sqlite_schema;")
+        return res.fetchall()
+
+    def query(
+        self,
+        query: str,
+        data: Optional[Union[Sequence[DictOrTuple], DictOrTuple]] = None,
+    ) -> list[dict[str, Any]]:
+        """Execute a SQL query and return the results as list of dicts."""
+        if self._conn is None:
+            raise AttributeError("LinkState is not initialized.")
+
+        if data is None:
+            data = []
+
+        # Clean up whitespace to make the logs nicer
+        query = re.sub(r"\s+", " ", query)
+
+        try:
+            with self.transaction():
+                if (
+                    len(data) > 0
+                    and isinstance(data, (tuple, list))
+                    and isinstance(data[0], (tuple, dict))
+                ):
+                    rows = self._conn.executemany(query, data)
+                else:
+                    rows = self._conn.execute(query, data)
+
+                # Extract results before committing to support
+                #   INSERT/UPDATE ... RETURNING
+                # style queries
+                result = rows.fetchall()
+        except KeyError as exc:
+            log(ERROR, {"query": query, "data": data, "exception": exc})
+
+        return result
+
+
+def dict_factory(
+    cursor: sqlite3.Cursor,
+    row: sqlite3.Row,
+) -> dict[str, Any]:
+    """Turn SQLite results into dicts.
+
+    Less efficent for retrival of large amounts of data but easier to use.
+    """
+    fields = [column[0] for column in cursor.description]
+    return dict(zip(fields, row))

flwr/superlink/servicer/control/control_servicer.py

@@ -18,7 +18,6 @@
 import hashlib
 import time
 from collections.abc import Generator, Sequence
-from datetime import timedelta
 from logging import ERROR, INFO
 from typing import Any, Optional, cast
 
@@ -49,26 +48,26 @@ 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
@@ -389,11 +388,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 +426,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,94 +447,32 @@ 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
 
         nodes_info: Sequence[NodeInfo] = []
-        # If dry run is enabled, create dummy NodeInfo data
-        if request.dry_run:
-            nodes_info = _create_list_nodeif_for_dry_run()
-
-        else:
-            # Init link state
-            state = self.linkstate_factory.state()
-
-            flwr_aid = shared_account_info.get().flwr_aid
-            flwr_aid = _check_flwr_aid_exists(flwr_aid, context)
-            # 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())
-
-
-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)
-    nodes_info.append(
-        NodeInfo(
-            node_id=15390646978706312628,
-            owner_aid="owner_aid_1",
-            status="created",
-            created_at=(now()).isoformat(),
-            last_activated_at="",
-            last_deactivated_at="",
-            deleted_at="",
-        )
-    )
-
-    # A node created and connected
-    nodes_info.append(
-        NodeInfo(
-            node_id=2941141058168602545,
-            owner_aid="owner_aid_2",
-            status="online",
-            created_at=(now()).isoformat(),
-            last_activated_at=(now() + timedelta(hours=0.5)).isoformat(),
-            last_deactivated_at="",
-            deleted_at="",
-        )
-    )
+        # Init link state
+        state = self.linkstate_factory.state()
 
-    # A node created and deleted (never connected)
-    nodes_info.append(
-        NodeInfo(
-            node_id=906971720890549292,
-            owner_aid="owner_aid_3",
-            status="deleted",
-            created_at=(now()).isoformat(),
-            last_activated_at="",
-            last_deactivated_at="",
-            deleted_at=(now() + timedelta(hours=1)).isoformat(),
-        )
-    )
+        flwr_aid = shared_account_info.get().flwr_aid
+        flwr_aid = _check_flwr_aid_exists(flwr_aid, context)
+        # Retrieve all nodes for the account
+        nodes_info = state.get_node_info(owner_aids=[flwr_aid])
 
-    # A node created, deactivate and then deleted
-    nodes_info.append(
-        NodeInfo(
-            node_id=1781174086018058152,
-            owner_aid="owner_aid_4",
-            status="offline",
-            created_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(),
-        )
-    )
-    return nodes_info
+        return ListNodesResponse(nodes_info=nodes_info, now=now().isoformat())
 
 
 def _create_list_runs_response(

flwr/supernode/start_client_internal.py

@@ -54,6 +54,7 @@ from flwr.common.logger import log
 from flwr.common.retry_invoker import RetryInvoker, _make_simple_grpc_retry_invoker
 from flwr.common.telemetry import EventType
 from flwr.common.typing import Fab, Run, RunNotRunningException, UserConfig
+from flwr.common.version import package_version
 from flwr.proto.clientappio_pb2_grpc import add_ClientAppIoServicer_to_server
 from flwr.proto.message_pb2 import ObjectTree  # pylint: disable=E0611
 from flwr.supercore.ffs import Ffs, FfsFactory
@@ -141,6 +142,19 @@ def start_client_internal(
     if insecure is None:
         insecure = root_certificates is None
 
+    # Insecure HTTP is incompatible with authentication
+    if insecure and authentication_keys is not None:
+        url_v = f"https://flower.ai/docs/framework/v{package_version}/en/"
+        page = "how-to-authenticate-supernodes.html"
+        flwr_exit(
+            ExitCode.SUPERNODE_STARTED_WITHOUT_TLS_BUT_NODE_AUTH_ENABLED,
+            "Insecure connection is enabled, but the SuperNode's private key is "
+            "provided for authentication. SuperNode authentication requires a "
+            "secure TLS connection with the SuperLink. Please enable TLS by "
+            "providing the certificate via `--root-certificates`. Please refer "
+            f"to the Flower documentation for more information: {url_v}{page}",
+        )
+
     # Initialize factories
     state_factory = NodeStateFactory()
     ffs_factory = FfsFactory(get_flwr_dir(flwr_path) / "supernode" / "ffs")  # type: ignore

{flwr_nightly-1.23.0.dev20251017.dist-info → flwr_nightly-1.23.0.dev20251021.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: flwr-nightly
-Version: 1.23.0.dev20251017
+Version: 1.23.0.dev20251021
 Summary: Flower: A Friendly Federated AI Framework
 License: Apache-2.0
 Keywords: Artificial Intelligence,Federated AI,Federated Analytics,Federated Evaluation,Federated Learning,Flower,Machine Learning