flwr-nightly 1.13.0.dev20241109__py3-none-any.whl → 1.13.0.dev20241112__py3-none-any.whl

flwr/server/serverapp/app.py

@@ -15,9 +15,7 @@
 """Flower ServerApp process."""
 
 import argparse
-import sys
-from logging import DEBUG, ERROR, INFO, WARN
-from os.path import isfile
+from logging import DEBUG, ERROR, INFO
 from pathlib import Path
 from queue import Queue
 from time import sleep
@@ -25,6 +23,7 @@ from typing import Optional
 
 from flwr.cli.config_utils import get_fab_metadata
 from flwr.cli.install import install_from_fab
+from flwr.common.args import add_args_flwr_app_common, try_obtain_root_certificates
 from flwr.common.config import (
     get_flwr_dir,
     get_fused_config_from_dir,
@@ -69,54 +68,30 @@ def flwr_serverapp() -> None:
     parser.add_argument(
         "--superlink",
         type=str,
-        help="Address of SuperLink's DriverAPI",
+        help="Address of SuperLink's ServerAppIo API",
     )
     parser.add_argument(
         "--run-once",
         action="store_true",
-        help="When set, this process will start a single ServerApp "
-        "for a pending Run. If no pending run the process will exit. ",
-    )
-    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
-    """,
-    )
-    parser.add_argument(
-        "--insecure",
-        action="store_true",
-        help="Run the server 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(
-        "--root-certificates",
-        metavar="ROOT_CERT",
-        type=str,
-        help="Specifies the path to the PEM-encoded root certificate file for "
-        "establishing secure HTTPS connections.",
+        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)
     args = parser.parse_args()
 
     log(INFO, "Starting Flower ServerApp")
-    certificates = _try_obtain_certificates(args)
+    certificates = try_obtain_root_certificates(args, args.superlink)
 
     log(
         DEBUG,
-        "Staring isolated `ServerApp` connected to SuperLink DriverAPI at %s",
+        "Starting isolated `ServerApp` connected to SuperLink's ServerAppIo API at %s",
         args.superlink,
     )
     run_serverapp(
         superlink=args.superlink,
         log_queue=log_queue,
         run_once=args.run_once,
-        flwr_dir_=args.flwr_dir,
+        flwr_dir=args.flwr_dir,
         certificates=certificates,
     )
 
@@ -124,44 +99,11 @@ def flwr_serverapp() -> None:
     restore_output()
 
 
-def _try_obtain_certificates(
-    args: argparse.Namespace,
-) -> Optional[bytes]:
-
-    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 channel to %s.",
-            args.superlink,
-        )
-        root_certificates = None
-    else:
-        # Load the certificates if provided, or load the system certificates
-        if not isfile(args.root_certificates):
-            sys.exit("Path argument `--root-certificates` does not point to a file.")
-        root_certificates = Path(args.root_certificates).read_bytes()
-        log(
-            DEBUG,
-            "Starting secure HTTPS channel to %s "
-            "with the following certificates: %s.",
-            args.superlink,
-            args.root_certificates,
-        )
-    return root_certificates
-
-
 def run_serverapp(  # pylint: disable=R0914, disable=W0212
     superlink: str,
     log_queue: Queue[Optional[str]],
     run_once: bool,
-    flwr_dir_: Optional[str] = None,
+    flwr_dir: Optional[str] = None,
     certificates: Optional[bytes] = None,
 ) -> None:
     """Run Flower ServerApp process."""
@@ -171,7 +113,7 @@ def run_serverapp(  # pylint: disable=R0914, disable=W0212
     )
 
     # Resolve directory where FABs are installed
-    flwr_dir = get_flwr_dir(flwr_dir_)
+    flwr_dir_ = get_flwr_dir(flwr_dir)
     log_uploader = None
 
     while True:
@@ -200,11 +142,13 @@ def run_serverapp(  # pylint: disable=R0914, disable=W0212
             )
 
             log(DEBUG, "ServerApp process starts FAB installation.")
-            install_from_fab(fab.content, flwr_dir=flwr_dir, skip_prompt=True)
+            install_from_fab(fab.content, flwr_dir=flwr_dir_, skip_prompt=True)
 
             fab_id, fab_version = get_fab_metadata(fab.content)
 
-            app_path = str(get_project_dir(fab_id, fab_version, fab.hash_str, flwr_dir))
+            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

flwr/server/superlink/linkstate/in_memory_linkstate.py

@@ -435,6 +435,11 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         """Retrieve all currently stored `node_public_keys` as a set."""
         return self.node_public_keys
 
+    def get_run_ids(self) -> set[int]:
+        """Retrieve all run IDs."""
+        with self.lock:
+            return set(self.run_ids.keys())
+
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""
         with self.lock:

flwr/server/superlink/linkstate/linkstate.py

@@ -163,6 +163,10 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
     ) -> int:
         """Create a new run for the specified `fab_hash`."""
 
+    @abc.abstractmethod
+    def get_run_ids(self) -> set[int]:
+        """Retrieve all run IDs."""
+
     @abc.abstractmethod
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`.
@@ -175,10 +179,7 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
         Returns
         -------
         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.
+            The `Run` instance if found; otherwise, `None`.
         """
 
     @abc.abstractmethod

flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -902,6 +902,12 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         result: set[bytes] = {row["public_key"] for row in rows}
         return result
 
+    def get_run_ids(self) -> set[int]:
+        """Retrieve all run IDs."""
+        query = "SELECT run_id FROM run;"
+        rows = self.query(query)
+        return {convert_sint64_to_uint64(row["run_id"]) for row in rows}
+
     def get_run(self, run_id: int) -> Optional[Run]:
         """Retrieve information about the run with the specified `run_id`."""
         # Convert the uint64 value to sint64 for SQLite
@@ -1249,10 +1255,10 @@ def dict_to_task_res(task_dict: dict[str, Any]) -> TaskRes:
 def determine_run_status(row: dict[str, Any]) -> str:
     """Determine the status of the run based on timestamp fields."""
     if row["pending_at"]:
+        if row["finished_at"]:
+            return Status.FINISHED
         if row["starting_at"]:
             if row["running_at"]:
-                if row["finished_at"]:
-                    return Status.FINISHED
                 return Status.RUNNING
             return Status.STARTING
         return Status.PENDING

flwr/server/superlink/linkstate/utils.py

@@ -34,6 +34,9 @@ VALID_RUN_STATUS_TRANSITIONS = {
     (Status.PENDING, Status.STARTING),
     (Status.STARTING, Status.RUNNING),
     (Status.RUNNING, Status.FINISHED),
+    # Any non-FINISHED status can transition to FINISHED
+    (Status.PENDING, Status.FINISHED),
+    (Status.STARTING, Status.FINISHED),
 }
 VALID_RUN_SUB_STATUSES = {
     SubStatus.COMPLETED,
@@ -170,6 +173,14 @@ def is_valid_transition(current_status: RunStatus, new_status: RunStatus) -> boo
     bool
         True if the transition is valid, False otherwise.
     """
+    # Transition to FINISHED from a non-RUNNING status is only allowed
+    # if the sub-status is not COMPLETED
+    if (
+        current_status.status in [Status.PENDING, Status.STARTING]
+        and new_status.status == Status.FINISHED
+    ):
+        return new_status.sub_status != SubStatus.COMPLETED
+
     return (
         current_status.status,
         new_status.status,

flwr/simulation/__init__.py

@@ -17,13 +17,14 @@
 
 import importlib
 
+from flwr.simulation.app import run_simulation_process
 from flwr.simulation.run_simulation import run_simulation
 from flwr.simulation.simulationio_connection import SimulationIoConnection
 
 is_ray_installed = importlib.util.find_spec("ray") is not None
 
 if is_ray_installed:
-    from flwr.simulation.app import start_simulation
+    from flwr.simulation.legacy_app import start_simulation
 else:
     RAY_IMPORT_ERROR: str = """Unable to import module `ray`.
 
@@ -40,5 +41,6 @@ To install the necessary dependencies, install `flwr` with the `simulation` extr
 __all__ = [
     "SimulationIoConnection",
     "run_simulation",
+    "run_simulation_process",
     "start_simulation",
 ]