flwr-nightly 1.8.0.dev20240315__py3-none-any.whl → 1.15.0.dev20250114__py3-none-any.whl

flwr/server/superlink/ffs/disk_ffs.py

@@ -0,0 +1,108 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Disk based Flower File Storage."""
+
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Optional
+
+from flwr.server.superlink.ffs.ffs import Ffs
+
+
+class DiskFfs(Ffs):  # pylint: disable=R0904
+    """Disk-based Flower File Storage interface for large objects."""
+
+    def __init__(self, base_dir: str) -> None:
+        """Create a new DiskFfs instance.
+
+        Parameters
+        ----------
+        base_dir : str
+            The base directory to store the objects.
+        """
+        self.base_dir = Path(base_dir)
+
+    def put(self, content: bytes, meta: dict[str, str]) -> str:
+        """Store bytes and metadata and return key (hash of content).
+
+        Parameters
+        ----------
+        content : bytes
+            The content to be stored.
+        meta : Dict[str, str]
+            The metadata to be stored.
+
+        Returns
+        -------
+        key : str
+            The key (sha256hex hash) of the content.
+        """
+        content_hash = hashlib.sha256(content).hexdigest()
+
+        self.base_dir.mkdir(exist_ok=True, parents=True)
+        (self.base_dir / content_hash).write_bytes(content)
+        (self.base_dir / f"{content_hash}.META").write_text(json.dumps(meta))
+
+        return content_hash
+
+    def get(self, key: str) -> Optional[tuple[bytes, dict[str, str]]]:
+        """Return tuple containing the object content and metadata.
+
+        Parameters
+        ----------
+        key : str
+            The sha256hex hash of the object to be retrieved.
+
+        Returns
+        -------
+        Optional[Tuple[bytes, Dict[str, str]]]
+            A tuple containing the object content and metadata.
+        """
+        if not (self.base_dir / key).exists():
+            return None
+
+        content = (self.base_dir / key).read_bytes()
+        meta = json.loads((self.base_dir / f"{key}.META").read_text())
+
+        return content, meta
+
+    def delete(self, key: str) -> None:
+        """Delete object with hash.
+
+        Parameters
+        ----------
+        key : str
+            The sha256hex hash of the object to be deleted.
+        """
+        (self.base_dir / key).unlink()
+        (self.base_dir / f"{key}.META").unlink()
+
+    def list(self) -> list[str]:
+        """List all keys.
+
+        Return all available keys in this `Ffs` instance.
+        This can be combined with, for example,
+        the `delete` method to delete objects.
+
+        Returns
+        -------
+        List[str]
+            A list of all available keys.
+        """
+        return [
+            item.name for item in self.base_dir.iterdir() if not item.suffix == ".META"
+        ]

flwr/server/superlink/ffs/ffs.py

@@ -0,0 +1,79 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Abstract base class for Flower File Storage interface."""
+
+
+import abc
+from typing import Optional
+
+
+class Ffs(abc.ABC):  # pylint: disable=R0904
+    """Abstract Flower File Storage interface for large objects."""
+
+    @abc.abstractmethod
+    def put(self, content: bytes, meta: dict[str, str]) -> str:
+        """Store bytes and metadata and return sha256hex hash of data as str.
+
+        Parameters
+        ----------
+        content : bytes
+            The content to be stored.
+        meta : Dict[str, str]
+            The metadata to be stored.
+
+        Returns
+        -------
+        key : str
+            The key (sha256hex hash) of the content.
+        """
+
+    @abc.abstractmethod
+    def get(self, key: str) -> Optional[tuple[bytes, dict[str, str]]]:
+        """Return tuple containing the object content and metadata.
+
+        Parameters
+        ----------
+        key : str
+            The key (sha256hex hash) of the object to be retrieved.
+
+        Returns
+        -------
+        Optional[Tuple[bytes, Dict[str, str]]]
+            A tuple containing the object content and metadata.
+        """
+
+    @abc.abstractmethod
+    def delete(self, key: str) -> None:
+        """Delete object with hash.
+
+        Parameters
+        ----------
+        key : str
+            The key (sha256hex hash) of the object to be deleted.
+        """
+
+    @abc.abstractmethod
+    def list(self) -> list[str]:
+        """List keys of all stored objects.
+
+        Return all available keys in this `Ffs` instance.
+        This can be combined with, for example,
+        the `delete` method to delete objects.
+
+        Returns
+        -------
+        List[str]
+            A list of all available keys.
+        """

flwr/server/superlink/ffs/ffs_factory.py

@@ -0,0 +1,47 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Factory class that creates Ffs instances."""
+
+
+from logging import DEBUG
+from typing import Optional
+
+from flwr.common.logger import log
+
+from .disk_ffs import DiskFfs
+from .ffs import Ffs
+
+
+class FfsFactory:
+    """Factory class that creates Ffs instances.
+
+    Parameters
+    ----------
+    base_dir : str
+        The base directory used by DiskFfs to store objects.
+    """
+
+    def __init__(self, base_dir: str) -> None:
+        self.base_dir = base_dir
+        self.ffs_instance: Optional[Ffs] = None
+
+    def ffs(self) -> Ffs:
+        """Return a Ffs instance and create it, if necessary."""
+        if not self.ffs_instance:
+            log(DEBUG, "Initializing DiskFfs")
+            self.ffs_instance = DiskFfs(self.base_dir)
+
+        log(DEBUG, "Using DiskFfs")
+        return self.ffs_instance

flwr/server/superlink/fleet/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.

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

@@ -0,0 +1,15 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Server-side part of the GrpcAdapter transport layer."""

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

@@ -0,0 +1,162 @@
+# Copyright 2024 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.
+# ==============================================================================
+"""Fleet API gRPC adapter servicer."""
+
+
+from logging import DEBUG, INFO
+from typing import Callable, TypeVar
+
+import grpc
+from google.protobuf.message import Message as GrpcMessage
+
+from flwr.common.constant import (
+    GRPC_ADAPTER_METADATA_FLOWER_PACKAGE_NAME_KEY,
+    GRPC_ADAPTER_METADATA_FLOWER_PACKAGE_VERSION_KEY,
+    GRPC_ADAPTER_METADATA_FLOWER_VERSION_KEY,
+    GRPC_ADAPTER_METADATA_MESSAGE_MODULE_KEY,
+    GRPC_ADAPTER_METADATA_MESSAGE_QUALNAME_KEY,
+)
+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.fleet_pb2 import (  # pylint: disable=E0611
+    CreateNodeRequest,
+    CreateNodeResponse,
+    DeleteNodeRequest,
+    DeleteNodeResponse,
+    PingRequest,
+    PingResponse,
+    PullTaskInsRequest,
+    PullTaskInsResponse,
+    PushTaskResRequest,
+    PushTaskResResponse,
+)
+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
+
+T = TypeVar("T", bound=GrpcMessage)
+
+
+def _handle(
+    msg_container: MessageContainer,
+    request_type: type[T],
+    handler: Callable[[T], GrpcMessage],
+) -> MessageContainer:
+    req = request_type.FromString(msg_container.grpc_message_content)
+    res = handler(req)
+    res_cls = res.__class__
+    return MessageContainer(
+        metadata={
+            GRPC_ADAPTER_METADATA_FLOWER_PACKAGE_NAME_KEY: package_name,
+            GRPC_ADAPTER_METADATA_FLOWER_PACKAGE_VERSION_KEY: package_version,
+            GRPC_ADAPTER_METADATA_FLOWER_VERSION_KEY: package_version,
+            GRPC_ADAPTER_METADATA_MESSAGE_MODULE_KEY: res_cls.__module__,
+            GRPC_ADAPTER_METADATA_MESSAGE_QUALNAME_KEY: res_cls.__qualname__,
+        },
+        grpc_message_name=res_cls.__qualname__,
+        grpc_message_content=res.SerializeToString(),
+    )
+
+
+class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer):
+    """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)
+        if request.grpc_message_name == DeleteNodeRequest.__qualname__:
+            return _handle(request, DeleteNodeRequest, self._delete_node)
+        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)
+        if request.grpc_message_name == GetRunRequest.__qualname__:
+            return _handle(request, GetRunRequest, self._get_run)
+        if request.grpc_message_name == GetFabRequest.__qualname__:
+            return _handle(request, GetFabRequest, self._get_fab)
+        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_bidi/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.

flwr/server/superlink/fleet/grpc_bidi/flower_service_servicer.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.
@@ -18,8 +18,10 @@ Relevant knowledge for reading this modules code:
 - https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
 """
 
+
 import uuid
-from typing import Callable, Iterator
+from collections.abc import Iterator
+from typing import Callable
 
 import grpc
 from iterators import TimeoutIterator

flwr/server/superlink/fleet/grpc_bidi/grpc_bridge.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.
@@ -15,10 +15,11 @@
 """Provides class GrpcBridge."""
 
 
+from collections.abc import Iterator
 from dataclasses import dataclass
 from enum import Enum
 from threading import Condition
-from typing import Iterator, Optional
+from typing import Optional
 
 from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
     ClientMessage,

flwr/server/superlink/fleet/grpc_bidi/grpc_client_proxy.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.

flwr/server/superlink/fleet/grpc_bidi/grpc_server.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.
@@ -15,53 +15,28 @@
 """Implements utility function to create a gRPC server."""
 
 
-import concurrent.futures
-import sys
-from logging import ERROR
-from typing import Any, Callable, Optional, Tuple, Union
+from typing import Optional
 
 import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
-from flwr.common.logger import log
+from flwr.common.grpc import generic_create_grpc_server
 from flwr.proto.transport_pb2_grpc import (  # pylint: disable=E0611
     add_FlowerServiceServicer_to_server,
 )
 from flwr.server.client_manager import ClientManager
-from flwr.server.superlink.driver.driver_servicer import DriverServicer
 from flwr.server.superlink.fleet.grpc_bidi.flower_service_servicer import (
     FlowerServiceServicer,
 )
-from flwr.server.superlink.fleet.grpc_rere.fleet_servicer import FleetServicer
 
-INVALID_CERTIFICATES_ERR_MSG = """
-    When setting any of root_certificate, certificate, or private_key,
-    all of them need to be set.
-"""
 
-AddServicerToServerFn = Callable[..., Any]
-
-
-def valid_certificates(certificates: Tuple[bytes, bytes, bytes]) -> bool:
-    """Validate certificates tuple."""
-    is_valid = (
-        all(isinstance(certificate, bytes) for certificate in certificates)
-        and len(certificates) == 3
-    )
-
-    if not is_valid:
-        log(ERROR, INVALID_CERTIFICATES_ERR_MSG)
-
-    return is_valid
-
-
-def start_grpc_server(  # pylint: disable=too-many-arguments
+def start_grpc_server(  # pylint: disable=too-many-arguments,R0917
     client_manager: ClientManager,
     server_address: str,
     max_concurrent_workers: int = 1000,
     max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
     keepalive_time_ms: int = 210000,
-    certificates: Optional[Tuple[bytes, bytes, bytes]] = None,
+    certificates: Optional[tuple[bytes, bytes, bytes]] = None,
 ) -> grpc.Server:
     """Create and start a gRPC server running FlowerServiceServicer.
 
@@ -149,127 +124,3 @@ def start_grpc_server(  # pylint: disable=too-many-arguments
     server.start()
 
     return server
-
-
-def generic_create_grpc_server(  # pylint: disable=too-many-arguments
-    servicer_and_add_fn: Union[
-        Tuple[FleetServicer, AddServicerToServerFn],
-        Tuple[FlowerServiceServicer, AddServicerToServerFn],
-        Tuple[DriverServicer, AddServicerToServerFn],
-    ],
-    server_address: str,
-    max_concurrent_workers: int = 1000,
-    max_message_length: int = GRPC_MAX_MESSAGE_LENGTH,
-    keepalive_time_ms: int = 210000,
-    certificates: Optional[Tuple[bytes, bytes, bytes]] = None,
-) -> grpc.Server:
-    """Create a gRPC server with a single servicer.
-
-    Parameters
-    ----------
-    servicer_and_add_fn : Tuple
-        A tuple holding a servicer implementation and a matching
-        add_Servicer_to_server function.
-    server_address : str
-        Server address in the form of HOST:PORT e.g. "[::]:8080"
-    max_concurrent_workers : int
-        Maximum number of clients the server can process before returning
-        RESOURCE_EXHAUSTED status (default: 1000)
-    max_message_length : int
-        Maximum message length that the server can send or receive.
-        Int valued in bytes. -1 means unlimited. (default: GRPC_MAX_MESSAGE_LENGTH)
-    keepalive_time_ms : int
-        Flower uses a default gRPC keepalive time of 210000ms (3 minutes 30 seconds)
-        because some cloud providers (for example, Azure) agressively clean up idle
-        TCP connections by terminating them after some time (4 minutes in the case
-        of Azure). Flower does not use application-level keepalive signals and relies
-        on the assumption that the transport layer will fail in cases where the
-        connection is no longer active. `keepalive_time_ms` can be used to customize
-        the keepalive interval for specific environments. The default Flower gRPC
-        keepalive of 210000 ms (3 minutes 30 seconds) ensures that Flower can keep
-        the long running streaming connection alive in most environments. The actual
-        gRPC default of this setting is 7200000 (2 hours), which results in dropped
-        connections in some cloud environments.
-
-        These settings are related to the issue described here:
-        - https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md
-        - https://github.com/grpc/grpc/blob/master/doc/keepalive.md
-        - https://grpc.io/docs/guides/performance/
-
-        Mobile Flower clients may choose to increase this value if their server
-        environment allows long-running idle TCP connections.
-        (default: 210000)
-    certificates : Tuple[bytes, bytes, bytes] (default: None)
-        Tuple containing root certificate, server certificate, and private key to
-        start a secure SSL-enabled server. The tuple is expected to have three bytes
-        elements in the following order:
-
-            * CA certificate.
-            * server certificate.
-            * server private key.
-
-    Returns
-    -------
-    server : grpc.Server
-        A non-running instance of a gRPC server.
-    """
-    # Deconstruct tuple into servicer and function
-    servicer, add_servicer_to_server_fn = servicer_and_add_fn
-
-    # Possible options:
-    # https://github.com/grpc/grpc/blob/v1.43.x/include/grpc/impl/codegen/grpc_types.h
-    options = [
-        # Maximum number of concurrent incoming streams to allow on a http2
-        # connection. Int valued.
-        ("grpc.max_concurrent_streams", max(100, max_concurrent_workers)),
-        # Maximum message length that the channel can send.
-        # Int valued, bytes. -1 means unlimited.
-        ("grpc.max_send_message_length", max_message_length),
-        # Maximum message length that the channel can receive.
-        # Int valued, bytes. -1 means unlimited.
-        ("grpc.max_receive_message_length", max_message_length),
-        # The gRPC default for this setting is 7200000 (2 hours). Flower uses a
-        # customized default of 210000 (3 minutes and 30 seconds) to improve
-        # compatibility with popular cloud providers. Mobile Flower clients may
-        # choose to increase this value if their server environment allows
-        # long-running idle TCP connections.
-        ("grpc.keepalive_time_ms", keepalive_time_ms),
-        # Setting this to zero will allow sending unlimited keepalive pings in between
-        # sending actual data frames.
-        ("grpc.http2.max_pings_without_data", 0),
-        # Is it permissible to send keepalive pings from the client without
-        # any outstanding streams. More explanation here:
-        # https://github.com/adap/flower/pull/2197
-        ("grpc.keepalive_permit_without_calls", 0),
-    ]
-
-    server = grpc.server(
-        concurrent.futures.ThreadPoolExecutor(max_workers=max_concurrent_workers),
-        # Set the maximum number of concurrent RPCs this server will service before
-        # returning RESOURCE_EXHAUSTED status, or None to indicate no limit.
-        maximum_concurrent_rpcs=max_concurrent_workers,
-        options=options,
-    )
-    add_servicer_to_server_fn(servicer, server)
-
-    if certificates is not None:
-        if not valid_certificates(certificates):
-            sys.exit(1)
-
-        root_certificate_b, certificate_b, private_key_b = certificates
-
-        server_credentials = grpc.ssl_server_credentials(
-            ((private_key_b, certificate_b),),
-            root_certificates=root_certificate_b,
-            # A boolean indicating whether or not to require clients to be
-            # authenticated. May only be True if root_certificates is not None.
-            # We are explicitly setting the current gRPC default to document
-            # the option. For further reference see:
-            # https://grpc.github.io/grpc/python/grpc.html#create-server-credentials
-            require_client_auth=False,
-        )
-        server.add_secure_port(server_address, server_credentials)
-    else:
-        server.add_insecure_port(server_address)
-
-    return server

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

@@ -1,4 +1,4 @@
-# Copyright 2020 Flower Labs GmbH. All Rights Reserved.
+# Copyright 2024 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.