flwr 1.19.0__py3-none-any.whl → 1.21.0__py3-none-any.whl

flwr/server/grid/grpc_grid.py

@@ -22,31 +22,43 @@ from typing import Optional, cast
 
 import grpc
 
-from flwr.common import Message, RecordDict
+from flwr.app.error import Error
+from flwr.common import Message, Metadata, RecordDict, now
 from flwr.common.constant import (
     SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS,
     SUPERLINK_NODE_ID,
+    ErrorCode,
+    MessageType,
 )
 from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.inflatable import (
+    InflatableObject,
     get_all_nested_objects,
     get_object_tree,
+    iterate_object_tree,
     no_object_id_recompute,
 )
-from flwr.common.inflatable_grpc_utils import (
-    make_pull_object_fn_grpc,
-    make_push_object_fn_grpc,
+from flwr.common.inflatable_protobuf_utils import (
+    make_pull_object_fn_protobuf,
+    make_push_object_fn_protobuf,
 )
 from flwr.common.inflatable_utils import (
+    ObjectUnavailableError,
     inflate_object_from_contents,
     pull_objects,
     push_objects,
 )
 from flwr.common.logger import log, warn_deprecated_feature
-from flwr.common.message import remove_content_from_message
+from flwr.common.message import make_message, remove_content_from_message
 from flwr.common.retry_invoker import _make_simple_grpc_retry_invoker, _wrap_stub
 from flwr.common.serde import message_to_proto, run_from_proto
 from flwr.common.typing import Run
+from flwr.proto.appio_pb2 import (  # pylint: disable=E0611
+    PullAppMessagesRequest,
+    PullAppMessagesResponse,
+    PushAppMessagesRequest,
+    PushAppMessagesResponse,
+)
 from flwr.proto.message_pb2 import (  # pylint: disable=E0611
     ConfirmMessageReceivedRequest,
 )
@@ -55,10 +67,6 @@ from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=
 from flwr.proto.serverappio_pb2 import (  # pylint: disable=E0611
     GetNodesRequest,
     GetNodesResponse,
-    PullResMessagesRequest,
-    PullResMessagesResponse,
-    PushInsMessagesRequest,
-    PushInsMessagesResponse,
 )
 from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub  # pylint: disable=E0611
 
@@ -215,37 +223,38 @@ class GrpcGrid(Grid):
         )
         return [node.node_id for node in res.nodes]
 
-    def _try_push_message(self, run_id: int, message: Message) -> str:
-        """Push one message and its associated objects."""
-        # Compute mapping of message descendants
-        all_objects = get_all_nested_objects(message)
-        msg_id = message.object_id
-        object_tree = get_object_tree(message)
+    def _try_push_messages(self, run_id: int, messages: Iterable[Message]) -> list[str]:
+        """Push all messages and its associated objects."""
+        # Prepare all Messages to be sent in a single request
+        proto_messages = []
+        object_trees = []
+        all_objects: dict[str, InflatableObject] = {}
+        for msg in messages:
+            proto_messages.append(message_to_proto(remove_content_from_message(msg)))
+            all_objects.update(get_all_nested_objects(msg))
+            object_trees.append(get_object_tree(msg))
+            del msg
 
         # Call GrpcServerAppIoStub method
-        res: PushInsMessagesResponse = self._stub.PushMessages(
-            PushInsMessagesRequest(
-                messages_list=[message_to_proto(remove_content_from_message(message))],
+        res: PushAppMessagesResponse = self._stub.PushMessages(
+            PushAppMessagesRequest(
+                messages_list=proto_messages,
                 run_id=run_id,
-                message_object_trees=[object_tree],
+                message_object_trees=object_trees,
             )
         )
 
         # Push objects
-        # If Message was added to the LinkState correctly
-        if msg_id is not None:
-            obj_ids_to_push = set(res.objects_to_push[msg_id].object_ids)
-            # Push only object that are not in the store
-            push_objects(
-                all_objects,
-                push_object_fn=make_push_object_fn_grpc(
-                    push_object_grpc=self._stub.PushObject,
-                    node=self.node,
-                    run_id=run_id,
-                ),
-                object_ids_to_push=obj_ids_to_push,
-            )
-        return msg_id
+        push_objects(
+            all_objects,
+            push_object_fn=make_push_object_fn_protobuf(
+                push_object_protobuf=self._stub.PushObject,
+                node=self.node,
+                run_id=run_id,
+            ),
+            object_ids_to_push=set(res.objects_to_push),
+        )
+        return cast(list[str], res.message_ids)
 
     def push_messages(self, messages: Iterable[Message]) -> Iterable[str]:
         """Push messages to specified node IDs.
@@ -256,17 +265,19 @@ class GrpcGrid(Grid):
         # Construct Messages
         run_id = cast(Run, self._run).run_id
         message_ids: list[str] = []
+        if not messages:
+            return message_ids
         try:
-            for msg in messages:
-                # Populate metadata
-                msg.metadata.__dict__["_run_id"] = run_id
-                msg.metadata.__dict__["_src_node_id"] = self.node.node_id
-                msg.metadata.__dict__["_message_id"] = msg.object_id
-                # Check message
-                self._check_message(msg)
-                # Try pushing message and its objects
-                with no_object_id_recompute():
-                    message_ids.append(self._try_push_message(run_id, msg))
+            with no_object_id_recompute():
+                for msg in messages:
+                    # Populate metadata
+                    msg.metadata.__dict__["_run_id"] = run_id
+                    msg.metadata.__dict__["_src_node_id"] = self.node.node_id
+                    msg.metadata.__dict__["_message_id"] = msg.object_id
+                    # Check message
+                    self._check_message(msg)
+                # Try pushing messages and their objects
+                message_ids = self._try_push_messages(run_id, messages)
 
         except grpc.RpcError as e:
             if e.code() == grpc.StatusCode.RESOURCE_EXHAUSTED:  # pylint: disable=E1101
@@ -294,24 +305,52 @@ class GrpcGrid(Grid):
         run_id = cast(Run, self._run).run_id
         try:
             # Pull Messages
-            res: PullResMessagesResponse = self._stub.PullMessages(
-                PullResMessagesRequest(
+            res: PullAppMessagesResponse = self._stub.PullMessages(
+                PullAppMessagesRequest(
                     message_ids=message_ids,
                     run_id=run_id,
                 )
             )
             # Pull Messages from store
             inflated_msgs: list[Message] = []
-            for msg_proto in res.messages_list:
+            for msg_proto, msg_tree in zip(res.messages_list, res.message_object_trees):
                 msg_id = msg_proto.metadata.message_id
-                all_object_contents = pull_objects(
-                    list(res.objects_to_pull[msg_id].object_ids) + [msg_id],
-                    pull_object_fn=make_pull_object_fn_grpc(
-                        pull_object_grpc=self._stub.PullObject,
-                        node=self.node,
-                        run_id=run_id,
-                    ),
-                )
+                try:
+                    all_object_contents = pull_objects(
+                        object_ids=[
+                            tree.object_id for tree in iterate_object_tree(msg_tree)
+                        ],
+                        pull_object_fn=make_pull_object_fn_protobuf(
+                            pull_object_protobuf=self._stub.PullObject,
+                            node=self.node,
+                            run_id=run_id,
+                        ),
+                    )
+                except ObjectUnavailableError as e:
+                    # An ObjectUnavailableError indicates that the object is not yet
+                    # available. If this point has been reached, it means that the
+                    # Grid has tried to pull the object for the maximum number of times
+                    # or for the maximum time allowed, so we return an inflated message
+                    # with an error
+                    inflated_msgs.append(
+                        make_message(
+                            metadata=Metadata(
+                                run_id=run_id,
+                                message_id="",
+                                src_node_id=self.node.node_id,
+                                dst_node_id=self.node.node_id,
+                                message_type=MessageType.SYSTEM,
+                                group_id="",
+                                ttl=0,
+                                reply_to_message_id=msg_proto.metadata.reply_to_message_id,
+                                created_at=now().timestamp(),
+                            ),
+                            error=Error(
+                                code=ErrorCode.MESSAGE_UNAVAILABLE, reason=(str(e))
+                            ),
+                        )
+                    )
+                    continue
 
                 # Confirm that the message has been received
                 self._stub.ConfirmMessageReceived(
@@ -347,6 +386,7 @@ class GrpcGrid(Grid):
         """
         # Push messages
         msg_ids = set(self.push_messages(messages))
+        del messages
 
         # Pull messages
         end_time = time.time() + (timeout if timeout is not None else 0.0)

flwr/server/grid/inmemory_grid.py

@@ -153,6 +153,7 @@ class InMemoryGrid(Grid):
         """
         # Push messages
         msg_ids = set(self.push_messages(messages))
+        del messages
 
         # Pull messages
         end_time = time.time() + (timeout if timeout is not None else 0.0)

flwr/server/serverapp/app.py

@@ -19,9 +19,9 @@ import argparse
 from logging import DEBUG, ERROR, INFO
 from pathlib import Path
 from queue import Queue
-from time import sleep
 from typing import Optional
 
+from flwr.app.exception import AppExitException
 from flwr.cli.config_utils import get_fab_metadata
 from flwr.cli.install import install_from_fab
 from flwr.cli.utils import get_sha256_hash
@@ -34,10 +34,11 @@ from flwr.common.config import (
 )
 from flwr.common.constant import (
     SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS,
+    ExecPluginType,
     Status,
     SubStatus,
 )
-from flwr.common.exit import ExitCode, flwr_exit
+from flwr.common.exit import ExitCode, add_exit_handler, flwr_exit
 from flwr.common.heartbeat import HeartbeatSender, get_grpc_app_heartbeat_fn
 from flwr.common.logger import (
     log,
@@ -55,14 +56,18 @@ from flwr.common.serde import (
 )
 from flwr.common.telemetry import EventType, event
 from flwr.common.typing import RunNotRunningException, RunStatus
-from flwr.proto.run_pb2 import UpdateRunStatusRequest  # pylint: disable=E0611
-from flwr.proto.serverappio_pb2 import (  # pylint: disable=E0611
-    PullServerAppInputsRequest,
-    PullServerAppInputsResponse,
-    PushServerAppOutputsRequest,
+from flwr.proto.appio_pb2 import (  # pylint: disable=E0611
+    PullAppInputsRequest,
+    PullAppInputsResponse,
+    PushAppOutputsRequest,
 )
+from flwr.proto.run_pb2 import UpdateRunStatusRequest  # pylint: disable=E0611
+from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub
 from flwr.server.grid.grpc_grid import GrpcGrid
 from flwr.server.run_serverapp import run as run_
+from flwr.supercore.app_utils import start_parent_process_monitor
+from flwr.supercore.superexec.plugin import ServerAppExecPlugin
+from flwr.supercore.superexec.run_superexec import run_with_deprecation_warning
 
 
 def flwr_serverapp() -> None:
@@ -73,14 +78,27 @@ def flwr_serverapp() -> None:
 
     args = _parse_args_run_flwr_serverapp().parse_args()
 
-    log(INFO, "Start `flwr-serverapp` process")
-
     if not args.insecure:
         flwr_exit(
             ExitCode.COMMON_TLS_NOT_SUPPORTED,
             "`flwr-serverapp` does not support TLS yet.",
         )
 
+    # Disallow long-running `flwr-serverapp` processes
+    if args.token is None:
+        run_with_deprecation_warning(
+            cmd="flwr-serverapp",
+            plugin_type=ExecPluginType.SERVER_APP,
+            plugin_class=ServerAppExecPlugin,
+            stub_class=ServerAppIoStub,
+            appio_api_address=args.serverappio_api_address,
+            flwr_dir=args.flwr_dir,
+            parent_pid=args.parent_pid,
+            warn_run_once=args.run_once,
+        )
+        return
+
+    log(INFO, "Start `flwr-serverapp` process")
     log(
         DEBUG,
         "`flwr-serverapp` will attempt to connect to SuperLink's "
@@ -90,168 +108,177 @@ def flwr_serverapp() -> None:
     run_serverapp(
         serverappio_api_address=args.serverappio_api_address,
         log_queue=log_queue,
-        run_once=args.run_once,
+        token=args.token,
         flwr_dir=args.flwr_dir,
         certificates=None,
+        parent_pid=args.parent_pid,
     )
 
     # Restore stdout/stderr
     restore_output()
 
 
-def run_serverapp(  # pylint: disable=R0914, disable=W0212, disable=R0915
+def run_serverapp(  # pylint: disable=R0913, R0914, R0915, R0917, W0212
     serverappio_api_address: str,
     log_queue: Queue[Optional[str]],
-    run_once: bool,
+    token: str,
     flwr_dir: Optional[str] = None,
     certificates: Optional[bytes] = None,
+    parent_pid: Optional[int] = None,
 ) -> None:
     """Run Flower ServerApp process."""
-    grid = GrpcGrid(
-        serverappio_service_address=serverappio_api_address,
-        root_certificates=certificates,
-    )
+    # Monitor the main process in case of SIGKILL
+    if parent_pid is not None:
+        start_parent_process_monitor(parent_pid)
 
     # Resolve directory where FABs are installed
     flwr_dir_ = get_flwr_dir(flwr_dir)
     log_uploader = None
-    success = True
     hash_run_id = None
     run_status = None
     heartbeat_sender = None
-    while True:
-
-        try:
-            # Pull ServerAppInputs from LinkState
-            req = PullServerAppInputsRequest()
-            log(DEBUG, "[flwr-serverapp] Pull ServerAppInputs")
-            res: PullServerAppInputsResponse = grid._stub.PullServerAppInputs(req)
-            if not res.HasField("run"):
-                sleep(3)
-                run_status = None
-                continue
-
-            context = context_from_proto(res.context)
-            run = run_from_proto(res.run)
-            fab = fab_from_proto(res.fab)
-
-            hash_run_id = get_sha256_hash(run.run_id)
-
-            grid.set_run(run.run_id)
-
-            # Start log uploader for this run
-            log_uploader = start_log_uploader(
-                log_queue=log_queue,
-                node_id=0,
-                run_id=run.run_id,
-                stub=grid._stub,
+    grid = None
+    context = None
+    exit_code = ExitCode.SUCCESS
+
+    def on_exit() -> None:
+        # Stop heartbeat sender
+        if heartbeat_sender:
+            heartbeat_sender.stop()
+
+        # Stop log uploader for this run and upload final logs
+        if log_uploader:
+            stop_log_uploader(log_queue, log_uploader)
+
+        # Update run status
+        if run_status and grid:
+            run_status_proto = run_status_to_proto(run_status)
+            grid._stub.UpdateRunStatus(
+                UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
             )
 
-            log(DEBUG, "[flwr-serverapp] Start FAB installation.")
-            install_from_fab(fab.content, flwr_dir=flwr_dir_, skip_prompt=True)
+        # Close the Grpc connection
+        if grid:
+            grid.close()
 
-            fab_id, fab_version = get_fab_metadata(fab.content)
+    add_exit_handler(on_exit)
 
-            app_path = str(
-                get_project_dir(fab_id, fab_version, fab.hash_str, flwr_dir_)
-            )
-            config = get_project_config(app_path)
+    try:
+        # Initialize the GrpcGrid
+        grid = GrpcGrid(
+            serverappio_service_address=serverappio_api_address,
+            root_certificates=certificates,
+        )
 
-            # Obtain server app reference and the run config
-            server_app_attr = config["tool"]["flwr"]["app"]["components"]["serverapp"]
-            server_app_run_config = get_fused_config_from_dir(
-                Path(app_path), run.override_config
-            )
+        # Pull ServerAppInputs from LinkState
+        req = PullAppInputsRequest(token=token)
+        log(DEBUG, "[flwr-serverapp] Pull ServerAppInputs")
+        res: PullAppInputsResponse = grid._stub.PullAppInputs(req)
+        context = context_from_proto(res.context)
+        run = run_from_proto(res.run)
+        fab = fab_from_proto(res.fab)
 
-            # Update run_config in context
-            context.run_config = server_app_run_config
+        hash_run_id = get_sha256_hash(run.run_id)
 
-            log(
-                DEBUG,
-                "[flwr-serverapp] Will load ServerApp `%s` in %s",
-                server_app_attr,
-                app_path,
-            )
+        grid.set_run(run.run_id)
 
-            # Change status to Running
-            run_status_proto = run_status_to_proto(RunStatus(Status.RUNNING, "", ""))
-            grid._stub.UpdateRunStatus(
-                UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
-            )
+        # Start log uploader for this run
+        log_uploader = start_log_uploader(
+            log_queue=log_queue,
+            node_id=0,
+            run_id=run.run_id,
+            stub=grid._stub,
+        )
 
-            event(
-                EventType.FLWR_SERVERAPP_RUN_ENTER,
-                event_details={"run-id-hash": hash_run_id},
-            )
+        log(DEBUG, "[flwr-serverapp] Start FAB installation.")
+        install_from_fab(fab.content, flwr_dir=flwr_dir_, skip_prompt=True)
 
-            # Set up heartbeat sender
-            heartbeat_fn = get_grpc_app_heartbeat_fn(
-                grid._stub,
-                run.run_id,
-                failure_message="Heartbeat failed unexpectedly. The SuperLink could "
-                "not find the provided run ID, or the run status is invalid.",
-            )
-            heartbeat_sender = HeartbeatSender(heartbeat_fn)
-            heartbeat_sender.start()
-
-            # Load and run the ServerApp with the Grid
-            updated_context = run_(
-                grid=grid,
-                server_app_dir=app_path,
-                server_app_attr=server_app_attr,
-                context=context,
-            )
+        fab_id, fab_version = get_fab_metadata(fab.content)
 
-            # Send resulting context
-            context_proto = context_to_proto(updated_context)
-            log(DEBUG, "[flwr-serverapp] Will push ServerAppOutputs")
-            out_req = PushServerAppOutputsRequest(
-                run_id=run.run_id, context=context_proto
-            )
-            _ = grid._stub.PushServerAppOutputs(out_req)
-
-            run_status = RunStatus(Status.FINISHED, SubStatus.COMPLETED, "")
-        except RunNotRunningException:
-            log(INFO, "")
-            log(INFO, "Run ID %s stopped.", run.run_id)
-            log(INFO, "")
-            run_status = None
-            success = False
-
-        except Exception as ex:  # pylint: disable=broad-exception-caught
-            exc_entity = "ServerApp"
-            log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
-            run_status = RunStatus(Status.FINISHED, SubStatus.FAILED, str(ex))
-            success = False
-
-        finally:
-            # Stop heartbeat sender
-            if heartbeat_sender:
-                heartbeat_sender.stop()
-                heartbeat_sender = None
-
-            # Stop log uploader for this run and upload final logs
-            if log_uploader:
-                stop_log_uploader(log_queue, log_uploader)
-                log_uploader = None
-
-            # Update run status
-            if run_status:
-                run_status_proto = run_status_to_proto(run_status)
-                grid._stub.UpdateRunStatus(
-                    UpdateRunStatusRequest(
-                        run_id=run.run_id, run_status=run_status_proto
-                    )
-                )
-
-            event(
-                EventType.FLWR_SERVERAPP_RUN_LEAVE,
-                event_details={"run-id-hash": hash_run_id, "success": success},
-            )
+        app_path = str(get_project_dir(fab_id, fab_version, fab.hash_str, flwr_dir_))
+        config = get_project_config(app_path)
+
+        # Obtain server app reference and the run config
+        server_app_attr = config["tool"]["flwr"]["app"]["components"]["serverapp"]
+        server_app_run_config = get_fused_config_from_dir(
+            Path(app_path), run.override_config
+        )
 
-        # Stop the loop if `flwr-serverapp` is expected to process a single run
-        if run_once:
-            break
+        # Update run_config in context
+        context.run_config = server_app_run_config
+
+        log(
+            DEBUG,
+            "[flwr-serverapp] Will load ServerApp `%s` in %s",
+            server_app_attr,
+            app_path,
+        )
+
+        # Change status to Running
+        run_status_proto = run_status_to_proto(RunStatus(Status.RUNNING, "", ""))
+        grid._stub.UpdateRunStatus(
+            UpdateRunStatusRequest(run_id=run.run_id, run_status=run_status_proto)
+        )
+
+        event(
+            EventType.FLWR_SERVERAPP_RUN_ENTER,
+            event_details={"run-id-hash": hash_run_id},
+        )
+
+        # Set up heartbeat sender
+        heartbeat_fn = get_grpc_app_heartbeat_fn(
+            grid._stub,
+            run.run_id,
+            failure_message="Heartbeat failed unexpectedly. The SuperLink could "
+            "not find the provided run ID, or the run status is invalid.",
+        )
+        heartbeat_sender = HeartbeatSender(heartbeat_fn)
+        heartbeat_sender.start()
+
+        # Load and run the ServerApp with the Grid
+        updated_context = run_(
+            grid=grid,
+            server_app_dir=app_path,
+            server_app_attr=server_app_attr,
+            context=context,
+        )
+
+        # Send resulting context
+        context_proto = context_to_proto(updated_context)
+        log(DEBUG, "[flwr-serverapp] Will push ServerAppOutputs")
+        out_req = PushAppOutputsRequest(
+            token=token, run_id=run.run_id, context=context_proto
+        )
+        _ = grid._stub.PushAppOutputs(out_req)
+
+        run_status = RunStatus(Status.FINISHED, SubStatus.COMPLETED, "")
+
+    # Raised when the run is already stopped by the user
+    except RunNotRunningException:
+        log(INFO, "")
+        log(INFO, "Run ID %s stopped.", run.run_id)
+        log(INFO, "")
+        run_status = None
+        # No need to update the exit code since this is expected behavior
+
+    except Exception as ex:  # pylint: disable=broad-exception-caught
+        exc_entity = "ServerApp"
+        log(ERROR, "%s raised an exception", exc_entity, exc_info=ex)
+        run_status = RunStatus(Status.FINISHED, SubStatus.FAILED, str(ex))
+
+        # Set exit code
+        exit_code = ExitCode.SERVERAPP_EXCEPTION  # General exit code
+        if isinstance(ex, AppExitException):
+            exit_code = ex.exit_code
+
+    flwr_exit(
+        code=exit_code,
+        event_type=EventType.FLWR_SERVERAPP_RUN_LEAVE,
+        event_details={
+            "run-id-hash": hash_run_id,
+            "success": exit_code == ExitCode.SUCCESS,
+        },
+    )
 
 
 def _parse_args_run_flwr_serverapp() -> argparse.ArgumentParser:
@@ -266,11 +293,5 @@ def _parse_args_run_flwr_serverapp() -> argparse.ArgumentParser:
         help="Address of SuperLink's ServerAppIo API (IPv4, IPv6, or a domain name)."
         f"By default, it is set to {SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS}.",
     )
-    parser.add_argument(
-        "--run-once",
-        action="store_true",
-        help="When set, this process will start a single ServerApp for a pending Run. "
-        "If there is no pending Run, the process will exit.",
-    )
     add_args_flwr_app_common(parser=parser)
     return parser

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

@@ -41,6 +41,7 @@ from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
 from flwr.proto.grpcadapter_pb2 import MessageContainer  # pylint: disable=E0611
 from flwr.proto.heartbeat_pb2 import SendNodeHeartbeatRequest  # pylint: disable=E0611
 from flwr.proto.message_pb2 import (  # pylint: disable=E0611
+    ConfirmMessageReceivedRequest,
     PullObjectRequest,
     PushObjectRequest,
 )
@@ -101,4 +102,11 @@ class GrpcAdapterServicer(grpcadapter_pb2_grpc.GrpcAdapterServicer, FleetService
             return _handle(request, context, PushObjectRequest, self.PushObject)
         if request.grpc_message_name == PullObjectRequest.__qualname__:
             return _handle(request, context, PullObjectRequest, self.PullObject)
+        if request.grpc_message_name == ConfirmMessageReceivedRequest.__qualname__:
+            return _handle(
+                request,
+                context,
+                ConfirmMessageReceivedRequest,
+                self.ConfirmMessageReceived,
+            )
         raise ValueError(f"Invalid grpc_message_name: {request.grpc_message_name}")

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

@@ -48,10 +48,10 @@ from flwr.proto.message_pb2 import (  # pylint: disable=E0611
     PushObjectResponse,
 )
 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.server.superlink.utils import abort_grpc_context
+from flwr.supercore.ffs import FfsFactory
 from flwr.supercore.object_store import ObjectStoreFactory