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

flwr/server/driver/grpc_driver.py

@@ -17,22 +17,21 @@
 import time
 import warnings
 from collections.abc import Iterable
-from logging import DEBUG, WARNING
-from typing import Optional, cast
+from logging import DEBUG, INFO, WARN, WARNING
+from typing import Any, Optional, cast
 
 import grpc
 
 from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
-from flwr.common.constant import DRIVER_API_DEFAULT_ADDRESS
+from flwr.common.constant import MAX_RETRY_DELAY, SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
-from flwr.common.serde import (
-    message_from_taskres,
-    message_to_taskins,
-    user_config_from_proto,
-)
+from flwr.common.retry_invoker import RetryInvoker, RetryState, exponential
+from flwr.common.serde import message_from_taskres, message_to_taskins, run_from_proto
 from flwr.common.typing import Run
-from flwr.proto.driver_pb2 import (  # pylint: disable=E0611
+from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
+from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
+from flwr.proto.serverappio_pb2 import (  # pylint: disable=E0611
     GetNodesRequest,
     GetNodesResponse,
     PullTaskResRequest,
@@ -40,9 +39,7 @@ from flwr.proto.driver_pb2 import (  # pylint: disable=E0611
     PushTaskInsRequest,
     PushTaskInsResponse,
 )
-from flwr.proto.driver_pb2_grpc import DriverStub  # pylint: disable=E0611
-from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
-from flwr.proto.run_pb2 import GetRunRequest, GetRunResponse  # pylint: disable=E0611
+from flwr.proto.serverappio_pb2_grpc import ServerAppIoStub  # pylint: disable=E0611
 from flwr.proto.task_pb2 import TaskIns  # pylint: disable=E0611
 
 from .driver import Driver
@@ -56,14 +53,12 @@ Call `connect()` on the `GrpcDriverStub` instance before calling any of the othe
 
 
 class GrpcDriver(Driver):
-    """`GrpcDriver` provides an interface to the Driver API.
+    """`GrpcDriver` provides an interface to the ServerAppIo API.
 
     Parameters
     ----------
-    run_id : int
-        The identifier of the run.
-    driver_service_address : str (default: "[::]:9091")
-        The address (URL, IPv6, IPv4) of the SuperLink Driver API service.
+    serverappio_service_address : str (default: "[::]:9091")
+        The address (URL, IPv6, IPv4) of the SuperLink ServerAppIo API service.
     root_certificates : Optional[bytes] (default: None)
         The PEM-encoded root certificates as a byte string.
         If provided, a secure connection using the certificates will be
@@ -72,25 +67,24 @@ class GrpcDriver(Driver):
 
     def __init__(  # pylint: disable=too-many-arguments
         self,
-        run_id: int,
-        driver_service_address: str = DRIVER_API_DEFAULT_ADDRESS,
+        serverappio_service_address: str = SERVERAPPIO_API_DEFAULT_CLIENT_ADDRESS,
         root_certificates: Optional[bytes] = None,
     ) -> None:
-        self._run_id = run_id
-        self._addr = driver_service_address
+        self._addr = serverappio_service_address
         self._cert = root_certificates
         self._run: Optional[Run] = None
-        self._grpc_stub: Optional[DriverStub] = None
+        self._grpc_stub: Optional[ServerAppIoStub] = None
         self._channel: Optional[grpc.Channel] = None
         self.node = Node(node_id=0, anonymous=True)
+        self._retry_invoker = _make_simple_grpc_retry_invoker()
 
     @property
     def _is_connected(self) -> bool:
-        """Check if connected to the Driver API server."""
+        """Check if connected to the ServerAppIo API server."""
         return self._channel is not None
 
     def _connect(self) -> None:
-        """Connect to the Driver API.
+        """Connect to the ServerAppIo API.
 
         This will not call GetRun.
         """
@@ -102,11 +96,12 @@ class GrpcDriver(Driver):
             insecure=(self._cert is None),
             root_certificates=self._cert,
         )
-        self._grpc_stub = DriverStub(self._channel)
+        self._grpc_stub = ServerAppIoStub(self._channel)
+        _wrap_stub(self._grpc_stub, self._retry_invoker)
         log(DEBUG, "[Driver] Connected to %s", self._addr)
 
     def _disconnect(self) -> None:
-        """Disconnect from the Driver API."""
+        """Disconnect from the ServerAppIo API."""
         if not self._is_connected:
             log(DEBUG, "Already disconnected")
             return
@@ -116,41 +111,32 @@ class GrpcDriver(Driver):
         channel.close()
         log(DEBUG, "[Driver] Disconnected")
 
-    def _init_run(self) -> None:
-        # Check if is initialized
-        if self._run is not None:
-            return
+    def set_run(self, run_id: int) -> None:
+        """Set the run."""
         # Get the run info
-        req = GetRunRequest(run_id=self._run_id)
+        req = GetRunRequest(run_id=run_id)
         res: GetRunResponse = self._stub.GetRun(req)
         if not res.HasField("run"):
-            raise RuntimeError(f"Cannot find the run with ID: {self._run_id}")
-        self._run = Run(
-            run_id=res.run.run_id,
-            fab_id=res.run.fab_id,
-            fab_version=res.run.fab_version,
-            fab_hash=res.run.fab_hash,
-            override_config=user_config_from_proto(res.run.override_config),
-        )
+            raise RuntimeError(f"Cannot find the run with ID: {run_id}")
+        self._run = run_from_proto(res.run)
 
     @property
     def run(self) -> Run:
         """Run information."""
-        self._init_run()
         return Run(**vars(self._run))
 
     @property
-    def _stub(self) -> DriverStub:
-        """Driver stub."""
+    def _stub(self) -> ServerAppIoStub:
+        """ServerAppIo stub."""
         if not self._is_connected:
             self._connect()
-        return cast(DriverStub, self._grpc_stub)
+        return cast(ServerAppIoStub, self._grpc_stub)
 
     def _check_message(self, message: Message) -> None:
         # Check if the message is valid
         if not (
             # Assume self._run being initialized
-            message.metadata.run_id == self._run_id
+            message.metadata.run_id == cast(Run, self._run).run_id
             and message.metadata.src_node_id == self.node.node_id
             and message.metadata.message_id == ""
             and message.metadata.reply_to_message == ""
@@ -171,7 +157,6 @@ class GrpcDriver(Driver):
         This method constructs a new `Message` with given content and metadata.
         The `run_id` and `src_node_id` will be set automatically.
         """
-        self._init_run()
         if ttl:
             warnings.warn(
                 "A custom TTL was set, but note that the SuperLink does not enforce "
@@ -182,7 +167,7 @@ class GrpcDriver(Driver):
 
         ttl_ = DEFAULT_TTL if ttl is None else ttl
         metadata = Metadata(
-            run_id=self._run_id,
+            run_id=cast(Run, self._run).run_id,
             message_id="",  # Will be set by the server
             src_node_id=self.node.node_id,
             dst_node_id=dst_node_id,
@@ -195,10 +180,9 @@ class GrpcDriver(Driver):
 
     def get_node_ids(self) -> list[int]:
         """Get node IDs."""
-        self._init_run()
         # Call GrpcDriverStub method
         res: GetNodesResponse = self._stub.GetNodes(
-            GetNodesRequest(run_id=self._run_id)
+            GetNodesRequest(run_id=cast(Run, self._run).run_id)
         )
         return [node.node_id for node in res.nodes]
 
@@ -208,7 +192,6 @@ class GrpcDriver(Driver):
         This method takes an iterable of messages and sends each message
         to the node specified in `dst_node_id`.
         """
-        self._init_run()
         # Construct TaskIns
         task_ins_list: list[TaskIns] = []
         for msg in messages:
@@ -230,7 +213,6 @@ class GrpcDriver(Driver):
         This method is used to collect messages from the SuperLink that correspond to a
         set of given message IDs.
         """
-        self._init_run()
         # Pull TaskRes
         res: PullTaskResResponse = self._stub.PullTaskRes(
             PullTaskResRequest(node=self.node, task_ids=message_ids)
@@ -276,3 +258,60 @@ class GrpcDriver(Driver):
             return
         # Disconnect
         self._disconnect()
+
+
+def _make_simple_grpc_retry_invoker() -> RetryInvoker:
+    """Create a simple gRPC retry invoker."""
+
+    def _on_sucess(retry_state: RetryState) -> None:
+        if retry_state.tries > 1:
+            log(
+                INFO,
+                "Connection successful after %.2f seconds and %s tries.",
+                retry_state.elapsed_time,
+                retry_state.tries,
+            )
+
+    def _on_backoff(retry_state: RetryState) -> None:
+        if retry_state.tries == 1:
+            log(WARN, "Connection attempt failed, retrying...")
+        else:
+            log(
+                WARN,
+                "Connection attempt failed, retrying in %.2f seconds",
+                retry_state.actual_wait,
+            )
+
+    def _on_giveup(retry_state: RetryState) -> None:
+        if retry_state.tries > 1:
+            log(
+                WARN,
+                "Giving up reconnection after %.2f seconds and %s tries.",
+                retry_state.elapsed_time,
+                retry_state.tries,
+            )
+
+    return RetryInvoker(
+        wait_gen_factory=lambda: exponential(max_delay=MAX_RETRY_DELAY),
+        recoverable_exceptions=grpc.RpcError,
+        max_tries=None,
+        max_time=None,
+        on_success=_on_sucess,
+        on_backoff=_on_backoff,
+        on_giveup=_on_giveup,
+        should_giveup=lambda e: e.code() != grpc.StatusCode.UNAVAILABLE,  # type: ignore
+    )
+
+
+def _wrap_stub(stub: ServerAppIoStub, retry_invoker: RetryInvoker) -> None:
+    """Wrap the gRPC stub with a retry invoker."""
+
+    def make_lambda(original_method: Any) -> Any:
+        return lambda *args, **kwargs: retry_invoker.invoke(
+            original_method, *args, **kwargs
+        )
+
+    for method_name in vars(stub):
+        method = getattr(stub, method_name)
+        if callable(method):
+            setattr(stub, method_name, make_lambda(method))

flwr/server/driver/inmemory_driver.py

@@ -25,18 +25,16 @@ from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
 from flwr.common.serde import message_from_taskres, message_to_taskins
 from flwr.common.typing import Run
 from flwr.proto.node_pb2 import Node  # pylint: disable=E0611
-from flwr.server.superlink.state import StateFactory
+from flwr.server.superlink.linkstate import LinkStateFactory
 
 from .driver import Driver
 
 
 class InMemoryDriver(Driver):
-    """`InMemoryDriver` class provides an interface to the Driver API.
+    """`InMemoryDriver` class provides an interface to the ServerAppIo API.
 
     Parameters
     ----------
-    run_id : int
-        The identifier of the run.
     state_factory : StateFactory
         A StateFactory embedding a state that this driver can interface with.
     pull_interval : float (default=0.1)
@@ -45,18 +43,15 @@ class InMemoryDriver(Driver):
 
     def __init__(
         self,
-        run_id: int,
-        state_factory: StateFactory,
+        state_factory: LinkStateFactory,
         pull_interval: float = 0.1,
     ) -> None:
-        self._run_id = run_id
         self._run: Optional[Run] = None
         self.state = state_factory.state()
         self.pull_interval = pull_interval
         self.node = Node(node_id=0, anonymous=True)
 
     def _check_message(self, message: Message) -> None:
-        self._init_run()
         # Check if the message is valid
         if not (
             message.metadata.run_id == cast(Run, self._run).run_id
@@ -67,19 +62,16 @@ class InMemoryDriver(Driver):
         ):
             raise ValueError(f"Invalid message: {message}")
 
-    def _init_run(self) -> None:
+    def set_run(self, run_id: int) -> None:
         """Initialize the run."""
-        if self._run is not None:
-            return
-        run = self.state.get_run(self._run_id)
+        run = self.state.get_run(run_id)
         if run is None:
-            raise RuntimeError(f"Cannot find the run with ID: {self._run_id}")
+            raise RuntimeError(f"Cannot find the run with ID: {run_id}")
         self._run = run
 
     @property
     def run(self) -> Run:
         """Run ID."""
-        self._init_run()
         return Run(**vars(cast(Run, self._run)))
 
     def create_message(  # pylint: disable=too-many-arguments,R0917
@@ -95,7 +87,6 @@ class InMemoryDriver(Driver):
         This method constructs a new `Message` with given content and metadata.
         The `run_id` and `src_node_id` will be set automatically.
         """
-        self._init_run()
         if ttl:
             warnings.warn(
                 "A custom TTL was set, but note that the SuperLink does not enforce "
@@ -119,7 +110,6 @@ class InMemoryDriver(Driver):
 
     def get_node_ids(self) -> list[int]:
         """Get node IDs."""
-        self._init_run()
         return list(self.state.get_nodes(cast(Run, self._run).run_id))
 
     def push_messages(self, messages: Iterable[Message]) -> Iterable[str]:

flwr/server/run_serverapp.py

@@ -15,44 +15,25 @@
 """Run ServerApp."""
 
 
-import argparse
 import sys
-from logging import DEBUG, INFO, WARN
-from pathlib import Path
+from logging import DEBUG, ERROR
 from typing import Optional
 
-from flwr.cli.config_utils import get_fab_metadata
-from flwr.cli.install import install_from_fab
-from flwr.common import Context, EventType, RecordSet, event
-from flwr.common.config import (
-    get_flwr_dir,
-    get_fused_config_from_dir,
-    get_metadata_from_config,
-    get_project_config,
-    get_project_dir,
-)
-from flwr.common.constant import DRIVER_API_DEFAULT_ADDRESS
-from flwr.common.logger import log, update_console_handler, warn_deprecated_feature
+from flwr.common import Context
+from flwr.common.logger import log, warn_unsupported_feature
 from flwr.common.object_ref import load_app
-from flwr.common.typing import UserConfig
-from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
-from flwr.proto.run_pb2 import (  # pylint: disable=E0611
-    CreateRunRequest,
-    CreateRunResponse,
-)
 
 from .driver import Driver
-from .driver.grpc_driver import GrpcDriver
 from .server_app import LoadServerAppError, ServerApp
 
 
 def run(
     driver: Driver,
+    context: Context,
     server_app_dir: str,
-    server_app_run_config: UserConfig,
     server_app_attr: Optional[str] = None,
     loaded_server_app: Optional[ServerApp] = None,
-) -> None:
+) -> Context:
     """Run ServerApp with a given Driver."""
     if not (server_app_attr is None) ^ (loaded_server_app is None):
         raise ValueError(
@@ -78,224 +59,19 @@ def run(
 
     server_app = _load()
 
-    # Initialize Context
-    context = Context(
-        node_id=0, node_config={}, state=RecordSet(), run_config=server_app_run_config
-    )
-
     # Call ServerApp
     server_app(driver=driver, context=context)
 
     log(DEBUG, "ServerApp finished running.")
+    return context
 
 
 # pylint: disable-next=too-many-branches,too-many-statements,too-many-locals
 def run_server_app() -> None:
     """Run Flower server app."""
-    event(EventType.RUN_SERVER_APP_ENTER)
-
-    args = _parse_args_run_server_app().parse_args()
-
-    # Check if the server app reference is passed.
-    # Since Flower 1.11, passing a reference is not allowed.
-    app_path: Optional[str] = args.app
-    # If the provided app_path doesn't exist, and contains a ":",
-    # it is likely to be a server app reference instead of a path.
-    if app_path is not None and not Path(app_path).exists() and ":" in app_path:
-        sys.exit(
-            "It appears you've passed a reference like `server:app`.\n\n"
-            "Note that since version `1.11.0`, `flower-server-app` no longer supports "
-            "passing a reference to a `ServerApp` attribute. Instead, you need to pass "
-            "the path to Flower app via the argument `--app`. This is the path to a "
-            "directory containing a `pyproject.toml`. You can create a valid Flower "
-            "app by executing `flwr new` and following the prompt."
-        )
-
-    if args.server != DRIVER_API_DEFAULT_ADDRESS:
-        warn = "Passing flag --server is deprecated. Use --superlink instead."
-        warn_deprecated_feature(warn)
-
-        if args.superlink != DRIVER_API_DEFAULT_ADDRESS:
-            # if `--superlink` also passed, then
-            # warn user that this argument overrides what was passed with `--server`
-            log(
-                WARN,
-                "Both `--server` and `--superlink` were passed. "
-                "`--server` will be ignored. Connecting to the Superlink Driver API "
-                "at %s.",
-                args.superlink,
-            )
-        else:
-            args.superlink = args.server
-
-    update_console_handler(
-        level=DEBUG if args.verbose else INFO,
-        timestamps=args.verbose,
-        colored=True,
-    )
-
-    # Obtain certificates
-    if args.insecure:
-        if args.root_certificates is not None:
-            sys.exit(
-                "Conflicting options: The '--insecure' flag disables HTTPS, "
-                "but '--root-certificates' was also specified. Please remove "
-                "the '--root-certificates' option when running in insecure mode, "
-                "or omit '--insecure' to use HTTPS."
-            )
-        log(
-            WARN,
-            "Option `--insecure` was set. "
-            "Starting insecure HTTP client connected to %s.",
-            args.superlink,
-        )
-        root_certificates = None
-    else:
-        # Load the certificates if provided, or load the system certificates
-        cert_path = args.root_certificates
-        if cert_path is None:
-            root_certificates = None
-        else:
-            root_certificates = Path(cert_path).read_bytes()
-        log(
-            DEBUG,
-            "Starting secure HTTPS client connected to %s "
-            "with the following certificates: %s.",
-            args.superlink,
-            cert_path,
-        )
-
-    if not (app_path is None) ^ (args.run_id is None):
-        raise sys.exit(
-            "Please provide either a Flower App path or a Run ID, but not both. "
-            "For more details, use: ``flower-server-app -h``"
-        )
-
-    # Initialize GrpcDriver
-    if app_path is None:
-        # User provided `--run-id`, but not `app_dir`
-        driver = GrpcDriver(
-            run_id=args.run_id,
-            driver_service_address=args.superlink,
-            root_certificates=root_certificates,
-        )
-        flwr_dir = get_flwr_dir(args.flwr_dir)
-        run_ = driver.run
-        if not run_.fab_hash:
-            raise ValueError("FAB hash not provided.")
-        fab_req = GetFabRequest(hash_str=run_.fab_hash)
-        # pylint: disable-next=W0212
-        fab_res: GetFabResponse = driver._stub.GetFab(fab_req)
-        if fab_res.fab.hash_str != run_.fab_hash:
-            raise ValueError("FAB hashes don't match.")
-        install_from_fab(fab_res.fab.content, flwr_dir, True)
-        fab_id, fab_version = get_fab_metadata(fab_res.fab.content)
-
-        app_path = str(get_project_dir(fab_id, fab_version, run_.fab_hash, flwr_dir))
-        config = get_project_config(app_path)
-    else:
-        # User provided `app_dir`, but not `--run-id`
-        # Create run if run_id is not provided
-        driver = GrpcDriver(
-            run_id=0,  # Will be overwritten
-            driver_service_address=args.superlink,
-            root_certificates=root_certificates,
-        )
-        # Load config from the project directory
-        config = get_project_config(app_path)
-        fab_version, fab_id = get_metadata_from_config(config)
-
-        # Create run
-        req = CreateRunRequest(fab_id=fab_id, fab_version=fab_version)
-        res: CreateRunResponse = driver._stub.CreateRun(req)  # pylint: disable=W0212
-        # Overwrite driver._run_id
-        driver._run_id = res.run_id  # pylint: disable=W0212
-
-    # 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), driver.run.override_config
+    warn_unsupported_feature(
+        "The command `flower-server-app` is deprecated and no longer in use. "
+        "Use the `flwr-serverapp` exclusively instead."
     )
-
-    log(DEBUG, "Flower will load ServerApp `%s` in %s", server_app_attr, app_path)
-
-    log(
-        DEBUG,
-        "root_certificates: `%s`",
-        root_certificates,
-    )
-
-    # Run the ServerApp with the Driver
-    run(
-        driver=driver,
-        server_app_dir=app_path,
-        server_app_run_config=server_app_run_config,
-        server_app_attr=server_app_attr,
-    )
-
-    # Clean up
-    driver.close()
-
-    event(EventType.RUN_SERVER_APP_LEAVE)
-
-
-def _parse_args_run_server_app() -> argparse.ArgumentParser:
-    """Parse flower-server-app command line arguments."""
-    parser = argparse.ArgumentParser(
-        description="Start a Flower server app",
-    )
-
-    parser.add_argument(
-        "app",
-        nargs="?",
-        default=None,
-        help="Load and run the `ServerApp` from the specified Flower App path. "
-        "The `pyproject.toml` file must be located in the root of this path.",
-    )
-    parser.add_argument(
-        "--insecure",
-        action="store_true",
-        help="Run the `ServerApp` without HTTPS. By default, the app runs with "
-        "HTTPS enabled. Use this flag only if you understand the risks.",
-    )
-    parser.add_argument(
-        "--verbose",
-        action="store_true",
-        help="Set the logging to `DEBUG`.",
-    )
-    parser.add_argument(
-        "--root-certificates",
-        metavar="ROOT_CERT",
-        type=str,
-        help="Specifies the path to the PEM-encoded root certificate file for "
-        "establishing secure HTTPS connections.",
-    )
-    parser.add_argument(
-        "--server",
-        default=DRIVER_API_DEFAULT_ADDRESS,
-        help="Server address",
-    )
-    parser.add_argument(
-        "--superlink",
-        default=DRIVER_API_DEFAULT_ADDRESS,
-        help="SuperLink Driver API (gRPC-rere) address (IPv4, IPv6, or a domain name)",
-    )
-    parser.add_argument(
-        "--run-id",
-        default=None,
-        type=int,
-        help="The identifier of the run.",
-    )
-    parser.add_argument(
-        "--flwr-dir",
-        default=None,
-        help="""The path containing installed Flower Apps.
-    By default, this value is equal to:
-
-        - `$FLWR_HOME/` if `$FLWR_HOME` is defined
-        - `$XDG_DATA_HOME/.flwr/` if `$XDG_DATA_HOME` is defined
-        - `$HOME/.flwr/` in all other cases
-    """,
-    )
-
-    return parser
+    log(ERROR, "`flower-server-app` used.")
+    sys.exit()

flwr/server/{superlink/state → serverapp}/__init__.py

@@ -12,17 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Flower server state."""
+"""Flower AppIO service."""
 
 
-from .in_memory_state import InMemoryState as InMemoryState
-from .sqlite_state import SqliteState as SqliteState
-from .state import State as State
-from .state_factory import StateFactory as StateFactory
+from .app import flwr_serverapp as flwr_serverapp
 
 __all__ = [
-    "InMemoryState",
-    "SqliteState",
-    "State",
-    "StateFactory",
+    "flwr_serverapp",
 ]