flwr 1.13.1__py3-none-any.whl → 1.15.0__py3-none-any.whl

flwr/server/superlink/driver/serverappio_servicer.py

@@ -16,14 +16,13 @@
 
 
 import threading
-import time
 from logging import DEBUG, INFO
 from typing import Optional
 from uuid import UUID
 
 import grpc
 
-from flwr.common import ConfigsRecord
+from flwr.common import ConfigsRecord, now
 from flwr.common.constant import Status
 from flwr.common.logger import log
 from flwr.common.serde import (
@@ -31,7 +30,12 @@ from flwr.common.serde import (
     context_to_proto,
     fab_from_proto,
     fab_to_proto,
+    message_from_proto,
+    message_from_taskres,
+    message_to_proto,
+    message_to_taskins,
     run_status_from_proto,
+    run_status_to_proto,
     run_to_proto,
     user_config_from_proto,
 )
@@ -48,25 +52,28 @@ from flwr.proto.run_pb2 import (  # pylint: disable=E0611
     CreateRunResponse,
     GetRunRequest,
     GetRunResponse,
+    GetRunStatusRequest,
+    GetRunStatusResponse,
     UpdateRunStatusRequest,
     UpdateRunStatusResponse,
 )
 from flwr.proto.serverappio_pb2 import (  # pylint: disable=E0611
     GetNodesRequest,
     GetNodesResponse,
+    PullResMessagesRequest,
+    PullResMessagesResponse,
     PullServerAppInputsRequest,
     PullServerAppInputsResponse,
-    PullTaskResRequest,
-    PullTaskResResponse,
+    PushInsMessagesRequest,
+    PushInsMessagesResponse,
     PushServerAppOutputsRequest,
     PushServerAppOutputsResponse,
-    PushTaskInsRequest,
-    PushTaskInsResponse,
 )
 from flwr.proto.task_pb2 import TaskRes  # pylint: disable=E0611
 from flwr.server.superlink.ffs.ffs import Ffs
 from flwr.server.superlink.ffs.ffs_factory import FfsFactory
 from flwr.server.superlink.linkstate import LinkState, LinkStateFactory
+from flwr.server.superlink.utils import abort_if
 from flwr.server.utils.validator import validate_task_ins_or_res
 
 
@@ -85,11 +92,20 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
     ) -> GetNodesResponse:
         """Get available nodes."""
         log(DEBUG, "ServerAppIoServicer.GetNodes")
+
+        # Init state
         state: LinkState = self.state_factory.state()
+
+        # Abort if the run is not running
+        abort_if(
+            request.run_id,
+            [Status.PENDING, Status.STARTING, Status.FINISHED],
+            state,
+            context,
+        )
+
         all_ids: set[int] = state.get_nodes(request.run_id)
-        nodes: list[Node] = [
-            Node(node_id=node_id, anonymous=False) for node_id in all_ids
-        ]
+        nodes: list[Node] = [Node(node_id=node_id) for node_id in all_ids]
         return GetNodesResponse(nodes=nodes)
 
     def CreateRun(
@@ -103,8 +119,9 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
             ffs: Ffs = self.ffs_factory.ffs()
             fab_hash = ffs.put(fab.content, {})
             _raise_if(
-                fab_hash != fab.hash_str,
-                f"FAB ({fab.hash_str}) hash from request doesn't match contents",
+                validation_error=fab_hash != fab.hash_str,
+                request_name="CreateRun",
+                detail=f"FAB ({fab.hash_str}) hash from request doesn't match contents",
             )
         else:
             fab_hash = ""
@@ -117,70 +134,104 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
         )
         return CreateRunResponse(run_id=run_id)
 
-    def PushTaskIns(
-        self, request: PushTaskInsRequest, context: grpc.ServicerContext
-    ) -> PushTaskInsResponse:
-        """Push a set of TaskIns."""
-        log(DEBUG, "ServerAppIoServicer.PushTaskIns")
+    def PushMessages(
+        self, request: PushInsMessagesRequest, context: grpc.ServicerContext
+    ) -> PushInsMessagesResponse:
+        """Push a set of Messages."""
+        log(DEBUG, "ServerAppIoServicer.PushMessages")
+
+        # Init state
+        state: LinkState = self.state_factory.state()
+
+        # Abort if the run is not running
+        abort_if(
+            request.run_id,
+            [Status.PENDING, Status.STARTING, Status.FINISHED],
+            state,
+            context,
+        )
 
         # Set pushed_at (timestamp in seconds)
-        pushed_at = time.time()
-        for task_ins in request.task_ins_list:
-            task_ins.task.pushed_at = pushed_at
+        pushed_at = now().timestamp()
 
-        # Validate request
-        _raise_if(len(request.task_ins_list) == 0, "`task_ins_list` must not be empty")
-        for task_ins in request.task_ins_list:
+        # Validate request and insert in State
+        _raise_if(
+            validation_error=len(request.messages_list) == 0,
+            request_name="PushMessages",
+            detail="`messages_list` must not be empty",
+        )
+        message_ids: list[Optional[UUID]] = []
+        while request.messages_list:
+            message_proto = request.messages_list.pop(0)
+            message = message_from_proto(message_proto=message_proto)
+            task_ins = message_to_taskins(message=message)
+            task_ins.task.pushed_at = pushed_at
             validation_errors = validate_task_ins_or_res(task_ins)
-            _raise_if(bool(validation_errors), ", ".join(validation_errors))
+            _raise_if(
+                validation_error=bool(validation_errors),
+                request_name="PushMessages",
+                detail=", ".join(validation_errors),
+            )
+            _raise_if(
+                validation_error=request.run_id != task_ins.run_id,
+                request_name="PushMessages",
+                detail="`task_ins` has mismatched `run_id`",
+            )
+            # Store
+            message_id: Optional[UUID] = state.store_task_ins(task_ins=task_ins)
+            message_ids.append(message_id)
+
+        return PushInsMessagesResponse(
+            message_ids=[
+                str(message_id) if message_id else "" for message_id in message_ids
+            ]
+        )
+
+    def PullMessages(
+        self, request: PullResMessagesRequest, context: grpc.ServicerContext
+    ) -> PullResMessagesResponse:
+        """Pull a set of Messages."""
+        log(DEBUG, "ServerAppIoServicer.PullMessages")
 
         # Init state
         state: LinkState = self.state_factory.state()
 
-        # Store each TaskIns
-        task_ids: list[Optional[UUID]] = []
-        for task_ins in request.task_ins_list:
-            task_id: Optional[UUID] = state.store_task_ins(task_ins=task_ins)
-            task_ids.append(task_id)
-
-        return PushTaskInsResponse(
-            task_ids=[str(task_id) if task_id else "" for task_id in task_ids]
+        # Abort if the run is not running
+        abort_if(
+            request.run_id,
+            [Status.PENDING, Status.STARTING, Status.FINISHED],
+            state,
+            context,
         )
 
-    def PullTaskRes(
-        self, request: PullTaskResRequest, context: grpc.ServicerContext
-    ) -> PullTaskResResponse:
-        """Pull a set of TaskRes."""
-        log(DEBUG, "ServerAppIoServicer.PullTaskRes")
-
         # Convert each task_id str to UUID
-        task_ids: set[UUID] = {UUID(task_id) for task_id in request.task_ids}
+        message_ids: set[UUID] = {
+            UUID(message_id) for message_id in request.message_ids
+        }
 
-        # Init state
-        state: LinkState = self.state_factory.state()
+        # Read from state
+        task_res_list: list[TaskRes] = state.get_task_res(task_ids=message_ids)
 
-        # Register callback
-        def on_rpc_done() -> None:
-            log(
-                DEBUG,
-                "ServerAppIoServicer.PullTaskRes callback: delete TaskIns/TaskRes",
+        # Convert to Messages
+        messages_list = []
+        while task_res_list:
+            task_res = task_res_list.pop(0)
+            _raise_if(
+                validation_error=request.run_id != task_res.run_id,
+                request_name="PullMessages",
+                detail="`task_res` has mismatched `run_id`",
             )
+            message = message_from_taskres(taskres=task_res)
+            messages_list.append(message_to_proto(message))
 
-            if context.is_active():
-                return
-            if context.code() != grpc.StatusCode.OK:
-                return
+        # Delete the TaskIns/TaskRes pairs if TaskRes is found
+        task_ins_ids_to_delete = {
+            UUID(task_res.task.ancestry[0]) for task_res in task_res_list
+        }
 
-            # Delete delivered TaskIns and TaskRes
-            state.delete_tasks(task_ids=task_ids)
+        state.delete_tasks(task_ins_ids=task_ins_ids_to_delete)
 
-        context.add_callback(on_rpc_done)
-
-        # Read from state
-        task_res_list: list[TaskRes] = state.get_task_res(task_ids=task_ids)
-
-        context.set_code(grpc.StatusCode.OK)
-        return PullTaskResResponse(task_res_list=task_res_list)
+        return PullResMessagesResponse(messages_list=messages_list)
 
     def GetRun(
         self, request: GetRunRequest, context: grpc.ServicerContext
@@ -217,9 +268,8 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
     ) -> PullServerAppInputsResponse:
         """Pull ServerApp process inputs."""
         log(DEBUG, "ServerAppIoServicer.PullServerAppInputs")
-        # Init access to LinkState and Ffs
+        # Init access to LinkState
         state = self.state_factory.state()
-        ffs = self.ffs_factory.ffs()
 
         # Lock access to LinkState, preventing obtaining the same pending run_id
         with self.lock:
@@ -229,6 +279,9 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
             if run_id is None:
                 return PullServerAppInputsResponse()
 
+            # Init access to Ffs
+            ffs = self.ffs_factory.ffs()
+
             # Retrieve Context, Run and Fab for the run_id
             serverapp_ctxt = state.get_serverapp_context(run_id)
             run = state.get_run(run_id)
@@ -255,7 +308,18 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
     ) -> PushServerAppOutputsResponse:
         """Push ServerApp process outputs."""
         log(DEBUG, "ServerAppIoServicer.PushServerAppOutputs")
+
+        # Init state
         state = self.state_factory.state()
+
+        # Abort if the run is not running
+        abort_if(
+            request.run_id,
+            [Status.PENDING, Status.STARTING, Status.FINISHED],
+            state,
+            context,
+        )
+
         state.set_serverapp_context(request.run_id, context_from_proto(request.context))
         return PushServerAppOutputsResponse()
 
@@ -263,9 +327,14 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
         self, request: UpdateRunStatusRequest, context: grpc.ServicerContext
     ) -> UpdateRunStatusResponse:
         """Update the status of a run."""
-        log(DEBUG, "ControlServicer.UpdateRunStatus")
+        log(DEBUG, "ServerAppIoServicer.UpdateRunStatus")
+
+        # Init state
         state = self.state_factory.state()
 
+        # Abort if the run is finished
+        abort_if(request.run_id, [Status.FINISHED], state, context)
+
         # Update the run status
         state.update_run_status(
             run_id=request.run_id, new_status=run_status_from_proto(request.run_status)
@@ -284,7 +353,23 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
         state.add_serverapp_log(request.run_id, merged_logs)
         return PushLogsResponse()
 
+    def GetRunStatus(
+        self, request: GetRunStatusRequest, context: grpc.ServicerContext
+    ) -> GetRunStatusResponse:
+        """Get the status of a run."""
+        log(DEBUG, "ServerAppIoServicer.GetRunStatus")
+        state = self.state_factory.state()
+
+        # Get run status from LinkState
+        run_statuses = state.get_run_status(set(request.run_ids))
+        run_status_dict = {
+            run_id: run_status_to_proto(run_status)
+            for run_id, run_status in run_statuses.items()
+        }
+        return GetRunStatusResponse(run_status_dict=run_status_dict)
+
 
-def _raise_if(validation_error: bool, detail: str) -> None:
+def _raise_if(validation_error: bool, request_name: str, detail: str) -> None:
+    """Raise a `ValueError` with a detailed message if a validation error occurs."""
     if validation_error:
-        raise ValueError(f"Malformed PushTaskInsRequest: {detail}")
+        raise ValueError(f"Malformed {request_name}: {detail}")

flwr/server/superlink/ffs/disk_ffs.py

@@ -14,6 +14,7 @@
 # ==============================================================================
 """Disk based Flower File Storage."""
 
+
 import hashlib
 import json
 from pathlib import Path

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

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

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

@@ -18,6 +18,7 @@ Relevant knowledge for reading this modules code:
 - https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
 """
 
+
 import uuid
 from collections.abc import Iterator
 from typing import Callable

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

@@ -15,49 +15,19 @@
 """Implements utility function to create a gRPC server."""
 
 
-import concurrent.futures
-import sys
-from collections.abc import Sequence
-from logging import ERROR
-from typing import Any, Callable, Optional, Union
+from typing import Optional
 
 import grpc
 
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
-from flwr.common.address import is_port_in_use
-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.serverappio_servicer import ServerAppIoServicer
-from flwr.server.superlink.fleet.grpc_adapter.grpc_adapter_servicer import (
-    GrpcAdapterServicer,
-)
 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,R0917
@@ -154,136 +124,3 @@ def start_grpc_server(  # pylint: disable=too-many-arguments,R0917
     server.start()
 
     return server
-
-
-def generic_create_grpc_server(  # pylint: disable=too-many-arguments,R0917
-    servicer_and_add_fn: Union[
-        tuple[FleetServicer, AddServicerToServerFn],
-        tuple[GrpcAdapterServicer, AddServicerToServerFn],
-        tuple[FlowerServiceServicer, AddServicerToServerFn],
-        tuple[ServerAppIoServicer, 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,
-    interceptors: Optional[Sequence[grpc.ServerInterceptor]] = 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.
-    interceptors : Optional[Sequence[grpc.ServerInterceptor]] (default: None)
-        A list of gRPC interceptors.
-
-    Returns
-    -------
-    server : grpc.Server
-        A non-running instance of a gRPC server.
-    """
-    # Check if port is in use
-    if is_port_in_use(server_address):
-        sys.exit(f"Port in server address {server_address} is already in use.")
-
-    # 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,
-        interceptors=interceptors,
-    )
-    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