flwr-nightly 1.10.0.dev20240612__py3-none-any.whl → 1.10.0.dev20240619__py3-none-any.whl

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

@@ -0,0 +1,131 @@
+# 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, Type, TypeVar
+
+import grpc
+from google.protobuf.message import Message as GrpcMessage
+
+from flwr.common.logger import log
+from flwr.proto import grpcadapter_pb2_grpc  # 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.fleet.message_handler import message_handler
+from flwr.server.superlink.state import StateFactory
+
+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)
+    return MessageContainer(
+        metadata={},
+        grpc_message_name=res.__class__.__qualname__,
+        grpc_message_content=res.SerializeToString(),
+    )
+
+
+class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer):
+    """Fleet API via GrpcAdapter servicer."""
+
+    def __init__(self, state_factory: StateFactory) -> None:
+        self.state_factory = state_factory
+
+    def SendReceive(
+        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)
+        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(),
+        )

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

@@ -29,6 +29,9 @@ from flwr.proto.transport_pb2_grpc import (  # pylint: disable=E0611
 )
 from flwr.server.client_manager import ClientManager
 from flwr.server.superlink.driver.driver_servicer import DriverServicer
+from flwr.server.superlink.fleet.grpc_adapter.grpc_adapter_servicer import (
+    GrpcAdapterServicer,
+)
 from flwr.server.superlink.fleet.grpc_bidi.flower_service_servicer import (
     FlowerServiceServicer,
 )
@@ -154,6 +157,7 @@ def start_grpc_server(  # pylint: disable=too-many-arguments
 def generic_create_grpc_server(  # pylint: disable=too-many-arguments
     servicer_and_add_fn: Union[
         Tuple[FleetServicer, AddServicerToServerFn],
+        Tuple[GrpcAdapterServicer, AddServicerToServerFn],
         Tuple[FlowerServiceServicer, AddServicerToServerFn],
         Tuple[DriverServicer, AddServicerToServerFn],
     ],

flwr/server/superlink/fleet/message_handler/message_handler.py

@@ -112,6 +112,6 @@ def get_run(
     request: GetRunRequest, state: State  # pylint: disable=W0613
 ) -> GetRunResponse:
     """Get run information."""
-    run_id, fab_id, fab_version = state.get_run(request.run_id)
-    run = Run(run_id=run_id, fab_id=fab_id, fab_version=fab_version)
-    return GetRunResponse(run=run)
+    run = state.get_run(request.run_id)
+    run_proto = None if run is None else Run(**vars(run))
+    return GetRunResponse(run=run_proto)

flwr/server/superlink/fleet/vce/vce_api.py

@@ -20,6 +20,7 @@ import sys
 import time
 import traceback
 from logging import DEBUG, ERROR, INFO, WARN
+from pathlib import Path
 from typing import Callable, Dict, List, Optional
 
 from flwr.client.client_app import ClientApp, ClientAppException, LoadClientAppError
@@ -274,6 +275,7 @@ def start_vce(
         # Use mapping constructed externally. This also means nodes
         # have previously being registered.
         nodes_mapping = existing_nodes_mapping
+    app_dir = str(Path(app_dir).absolute())
 
     if not state_factory:
         log(INFO, "A StateFactory was not supplied to the SimulationEngine.")
@@ -323,7 +325,7 @@ def start_vce(
             if app_dir is not None:
                 sys.path.insert(0, app_dir)
 
-            app: ClientApp = load_app(client_app_attr, LoadClientAppError)
+            app: ClientApp = load_app(client_app_attr, LoadClientAppError, app_dir)
 
             if not isinstance(app, ClientApp):
                 raise LoadClientAppError(

flwr/server/superlink/state/in_memory_state.py

@@ -23,6 +23,7 @@ from typing import Dict, List, Optional, Set, Tuple
 from uuid import UUID, uuid4
 
 from flwr.common import log, now
+from flwr.common.typing import Run
 from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 from flwr.server.superlink.state.state import State
 from flwr.server.utils import validate_task_ins_or_res
@@ -40,7 +41,7 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         self.public_key_to_node_id: Dict[bytes, int] = {}
 
         # Map run_id to (fab_id, fab_version)
-        self.run_ids: Dict[int, Tuple[str, str]] = {}
+        self.run_ids: Dict[int, Run] = {}
         self.task_ins_store: Dict[UUID, TaskIns] = {}
         self.task_res_store: Dict[UUID, TaskRes] = {}
 
@@ -281,7 +282,9 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
             run_id: int = int.from_bytes(os.urandom(8), "little", signed=True)
 
             if run_id not in self.run_ids:
-                self.run_ids[run_id] = (fab_id, fab_version)
+                self.run_ids[run_id] = Run(
+                    run_id=run_id, fab_id=fab_id, fab_version=fab_version
+                )
                 return run_id
         log(ERROR, "Unexpected run creation failure.")
         return 0
@@ -319,13 +322,13 @@ class InMemoryState(State):  # pylint: disable=R0902,R0904
         """Retrieve all currently stored `client_public_keys` as a set."""
         return self.client_public_keys
 
-    def get_run(self, run_id: int) -> Tuple[int, str, str]:
+    def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""
         with self.lock:
             if run_id not in self.run_ids:
                 log(ERROR, "`run_id` is invalid")
-                return 0, "", ""
-            return run_id, *self.run_ids[run_id]
+                return None
+            return self.run_ids[run_id]
 
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:
         """Acknowledge a ping received from a node, serving as a heartbeat."""

flwr/server/superlink/state/sqlite_state.py

@@ -24,6 +24,7 @@ from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Union, cast
 from uuid import UUID, uuid4
 
 from flwr.common import log, now
+from flwr.common.typing import Run
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
 from flwr.proto.recordset_pb2 import RecordSet  # pylint: disable=E0611
 from flwr.proto.task_pb2 import Task, TaskIns, TaskRes  # pylint: disable=E0611
@@ -680,15 +681,17 @@ class SqliteState(State):  # pylint: disable=R0904
         result: Set[bytes] = {row["public_key"] for row in rows}
         return result
 
-    def get_run(self, run_id: int) -> Tuple[int, str, str]:
+    def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""
         query = "SELECT * FROM run WHERE run_id = ?;"
         try:
             row = self.query(query, (run_id,))[0]
-            return run_id, row["fab_id"], row["fab_version"]
+            return Run(
+                run_id=run_id, fab_id=row["fab_id"], fab_version=row["fab_version"]
+            )
         except sqlite3.IntegrityError:
             log(ERROR, "`run_id` does not exist.")
-            return 0, "", ""
+            return None
 
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:
         """Acknowledge a ping received from a node, serving as a heartbeat."""

flwr/server/superlink/state/state.py

@@ -16,9 +16,10 @@
 
 
 import abc
-from typing import List, Optional, Set, Tuple
+from typing import List, Optional, Set
 from uuid import UUID
 
+from flwr.common.typing import Run
 from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
 
@@ -160,7 +161,7 @@ class State(abc.ABC):  # pylint: disable=R0904
         """Create a new run for the specified `fab_id` and `fab_version`."""
 
     @abc.abstractmethod
-    def get_run(self, run_id: int) -> Tuple[int, str, str]:
+    def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`.
 
         Parameters
@@ -170,8 +171,8 @@ class State(abc.ABC):  # pylint: disable=R0904
 
         Returns
         -------
-        Tuple[int, str, str]
-            A tuple containing three elements:
+        Optional[Run]
+            A dataclass instance containing three elements if `run_id` is valid:
             - `run_id`: The identifier of the run, same as the specified `run_id`.
             - `fab_id`: The identifier of the FAB used in the specified run.
             - `fab_version`: The version of the FAB used in the specified run.

flwr/simulation/__init__.py

@@ -36,4 +36,7 @@ To install the necessary dependencies, install `flwr` with the `simulation` extr
         raise ImportError(RAY_IMPORT_ERROR)
 
 
-__all__ = ["start_simulation", "run_simulation"]
+__all__ = [
+    "run_simulation",
+    "start_simulation",
+]

flwr/simulation/run_simulation.py

@@ -53,6 +53,7 @@ def run_simulation_from_cli() -> None:
         backend_name=args.backend,
         backend_config=backend_config_dict,
         app_dir=args.app_dir,
+        run_id=args.run_id,
         enable_tf_gpu_growth=args.enable_tf_gpu_growth,
         verbose_logging=args.verbose,
     )
@@ -168,6 +169,13 @@ def run_serverapp_th(
     return serverapp_th
 
 
+def _init_run_id(driver: InMemoryDriver, state: StateFactory, run_id: int) -> None:
+    """Create a run with a given `run_id`."""
+    log(DEBUG, "Pre-registering run with id %s", run_id)
+    state.state().run_ids[run_id] = ("", "")  # type: ignore
+    driver.run_id = run_id
+
+
 # pylint: disable=too-many-locals
 def _main_loop(
     num_supernodes: int,
@@ -175,6 +183,7 @@ def _main_loop(
     backend_config_stream: str,
     app_dir: str,
     enable_tf_gpu_growth: bool,
+    run_id: Optional[int] = None,
     client_app: Optional[ClientApp] = None,
     client_app_attr: Optional[str] = None,
     server_app: Optional[ServerApp] = None,
@@ -195,6 +204,9 @@ def _main_loop(
         # Initialize Driver
         driver = InMemoryDriver(state_factory)
 
+        if run_id:
+            _init_run_id(driver, state_factory, run_id)
+
         # Get and run ServerApp thread
         serverapp_th = run_serverapp_th(
             server_app_attr=server_app_attr,
@@ -244,6 +256,7 @@ def _run_simulation(
     client_app_attr: Optional[str] = None,
     server_app_attr: Optional[str] = None,
     app_dir: str = "",
+    run_id: Optional[int] = None,
     enable_tf_gpu_growth: bool = False,
     verbose_logging: bool = False,
 ) -> None:
@@ -283,6 +296,9 @@ def _run_simulation(
         Add specified directory to the PYTHONPATH and load `ClientApp` from there.
         (Default: current working directory.)
 
+    run_id : Optional[int]
+        An integer specifying the ID of the run started when running this function.
+
     enable_tf_gpu_growth : bool (default: False)
         A boolean to indicate whether to enable GPU growth on the main thread. This is
         desirable if you make use of a TensorFlow model on your `ServerApp` while
@@ -322,6 +338,7 @@ def _run_simulation(
         backend_config_stream,
         app_dir,
         enable_tf_gpu_growth,
+        run_id,
         client_app,
         client_app_attr,
         server_app,
@@ -413,5 +430,10 @@ def _parse_args_run_simulation() -> argparse.ArgumentParser:
         "ClientApp and ServerApp from there."
         " Default: current working directory.",
     )
+    parser.add_argument(
+        "--run-id",
+        type=int,
+        help="Sets the ID of the run started by the Simulation Engine.",
+    )
 
     return parser

flwr/superexec/__init__.py

@@ -0,0 +1,21 @@
+# 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.
+# ==============================================================================
+"""Flower SuperExec service."""
+
+from .app import run_superexec as run_superexec
+
+__all__ = [
+    "run_superexec",
+]

flwr/superexec/app.py

@@ -0,0 +1,178 @@
+# 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.
+# ==============================================================================
+"""Flower SuperExec app."""
+
+import argparse
+import sys
+from logging import INFO, WARN
+from pathlib import Path
+from typing import Optional, Tuple
+
+import grpc
+
+from flwr.common import EventType, event, log
+from flwr.common.address import parse_address
+from flwr.common.constant import SUPEREXEC_DEFAULT_ADDRESS
+from flwr.common.exit_handlers import register_exit_handlers
+from flwr.common.object_ref import load_app, validate
+
+from .exec_grpc import run_superexec_api_grpc
+from .executor import Executor
+
+
+def run_superexec() -> None:
+    """Run Flower SuperExec."""
+    log(INFO, "Starting Flower SuperExec")
+
+    event(EventType.RUN_SUPEREXEC_ENTER)
+
+    args = _parse_args_run_superexec().parse_args()
+
+    # Parse IP address
+    parsed_address = parse_address(args.address)
+    if not parsed_address:
+        sys.exit(f"SuperExec IP address ({args.address}) cannot be parsed.")
+    host, port, is_v6 = parsed_address
+    address = f"[{host}]:{port}" if is_v6 else f"{host}:{port}"
+
+    # Obtain certificates
+    certificates = _try_obtain_certificates(args)
+
+    # Start SuperExec API
+    superexec_server: grpc.Server = run_superexec_api_grpc(
+        address=address,
+        executor=_load_executor(args),
+        certificates=certificates,
+    )
+
+    grpc_servers = [superexec_server]
+
+    # Graceful shutdown
+    register_exit_handlers(
+        event_type=EventType.RUN_SUPEREXEC_LEAVE,
+        grpc_servers=grpc_servers,
+        bckg_threads=None,
+    )
+
+    superexec_server.wait_for_termination()
+
+
+def _parse_args_run_superexec() -> argparse.ArgumentParser:
+    """Parse command line arguments for SuperExec."""
+    parser = argparse.ArgumentParser(
+        description="Start a Flower SuperExec",
+    )
+    parser.add_argument(
+        "executor",
+        help="For example: `deployment:exec` or `project.package.module:wrapper.exec`.",
+    )
+    parser.add_argument(
+        "--address",
+        help="SuperExec (gRPC) server address (IPv4, IPv6, or a domain name)",
+        default=SUPEREXEC_DEFAULT_ADDRESS,
+    )
+    parser.add_argument(
+        "--executor-dir",
+        help="The directory for the executor.",
+        default=".",
+    )
+    parser.add_argument(
+        "--insecure",
+        action="store_true",
+        help="Run the SuperExec without HTTPS, regardless of whether certificate "
+        "paths are provided. By default, the server runs with HTTPS enabled. "
+        "Use this flag only if you understand the risks.",
+    )
+    parser.add_argument(
+        "--ssl-certfile",
+        help="SuperExec server SSL certificate file (as a path str) "
+        "to create a secure connection.",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--ssl-keyfile",
+        help="SuperExec server SSL private key file (as a path str) "
+        "to create a secure connection.",
+        type=str,
+    )
+    parser.add_argument(
+        "--ssl-ca-certfile",
+        help="SuperExec server SSL CA certificate file (as a path str) "
+        "to create a secure connection.",
+        type=str,
+    )
+    return parser
+
+
+def _try_obtain_certificates(
+    args: argparse.Namespace,
+) -> Optional[Tuple[bytes, bytes, bytes]]:
+    # Obtain certificates
+    if args.insecure:
+        log(WARN, "Option `--insecure` was set. Starting insecure HTTP server.")
+        return None
+    # Check if certificates are provided
+    if args.ssl_certfile and args.ssl_keyfile and args.ssl_ca_certfile:
+        if not Path.is_file(args.ssl_ca_certfile):
+            sys.exit("Path argument `--ssl-ca-certfile` does not point to a file.")
+        if not Path.is_file(args.ssl_certfile):
+            sys.exit("Path argument `--ssl-certfile` does not point to a file.")
+        if not Path.is_file(args.ssl_keyfile):
+            sys.exit("Path argument `--ssl-keyfile` does not point to a file.")
+        certificates = (
+            Path(args.ssl_ca_certfile).read_bytes(),  # CA certificate
+            Path(args.ssl_certfile).read_bytes(),  # server certificate
+            Path(args.ssl_keyfile).read_bytes(),  # server private key
+        )
+        return certificates
+    if args.ssl_certfile or args.ssl_keyfile or args.ssl_ca_certfile:
+        sys.exit(
+            "You need to provide valid file paths to `--ssl-certfile`, "
+            "`--ssl-keyfile`, and `—-ssl-ca-certfile` to create a secure "
+            "connection in SuperExec server (gRPC-rere)."
+        )
+    sys.exit(
+        "Certificates are required unless running in insecure mode. "
+        "Please provide certificate paths to `--ssl-certfile`, "
+        "`--ssl-keyfile`, and `—-ssl-ca-certfile` or run the server "
+        "in insecure mode using '--insecure' if you understand the risks."
+    )
+
+
+def _load_executor(
+    args: argparse.Namespace,
+) -> Executor:
+    """Get the executor plugin."""
+    if args.executor_dir is not None:
+        sys.path.insert(0, args.executor_dir)
+
+    executor_ref: str = args.executor
+    valid, error_msg = validate(executor_ref)
+    if not valid and error_msg:
+        raise LoadExecutorError(error_msg) from None
+
+    executor = load_app(executor_ref, LoadExecutorError, args.executor_dir)
+
+    if not isinstance(executor, Executor):
+        raise LoadExecutorError(
+            f"Attribute {executor_ref} is not of type {Executor}",
+        ) from None
+
+    return executor
+
+
+class LoadExecutorError(Exception):
+    """Error when trying to load `Executor`."""

flwr/superexec/exec_grpc.py

@@ -0,0 +1,51 @@
+# 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.
+# ==============================================================================
+"""SuperExec gRPC API."""
+
+from logging import INFO
+from typing import Optional, Tuple
+
+import grpc
+
+from flwr.common import GRPC_MAX_MESSAGE_LENGTH
+from flwr.common.logger import log
+from flwr.proto.exec_pb2_grpc import add_ExecServicer_to_server
+from flwr.server.superlink.fleet.grpc_bidi.grpc_server import generic_create_grpc_server
+
+from .exec_servicer import ExecServicer
+from .executor import Executor
+
+
+def run_superexec_api_grpc(
+    address: str,
+    executor: Executor,
+    certificates: Optional[Tuple[bytes, bytes, bytes]],
+) -> grpc.Server:
+    """Run SuperExec API (gRPC, request-response)."""
+    exec_servicer: grpc.Server = ExecServicer(
+        executor=executor,
+    )
+    superexec_add_servicer_to_server_fn = add_ExecServicer_to_server
+    superexec_grpc_server = generic_create_grpc_server(
+        servicer_and_add_fn=(exec_servicer, superexec_add_servicer_to_server_fn),
+        server_address=address,
+        max_message_length=GRPC_MAX_MESSAGE_LENGTH,
+        certificates=certificates,
+    )
+
+    log(INFO, "Flower ECE: Starting SuperExec API (gRPC-rere) on %s", address)
+    superexec_grpc_server.start()
+
+    return superexec_grpc_server