flwr-nightly 1.13.0.dev20241105__py3-none-any.whl → 1.13.0.dev20241107__py3-none-any.whl

flwr/server/app.py

@@ -47,6 +47,7 @@ from flwr.common.constant import (
     ISOLATION_MODE_SUBPROCESS,
     MISSING_EXTRA_REST,
     SERVERAPPIO_API_DEFAULT_ADDRESS,
+    SIMULATIONIO_API_DEFAULT_ADDRESS,
     TRANSPORT_TYPE_GRPC_ADAPTER,
     TRANSPORT_TYPE_GRPC_RERE,
     TRANSPORT_TYPE_REST,
@@ -63,6 +64,7 @@ from flwr.proto.fleet_pb2_grpc import (  # pylint: disable=E0611
 from flwr.proto.grpcadapter_pb2_grpc import add_GrpcAdapterServicer_to_server
 from flwr.superexec.app import load_executor
 from flwr.superexec.exec_grpc import run_exec_api_grpc
+from flwr.superexec.simulation import SimulationEngine
 
 from .client_manager import ClientManager
 from .history import History
@@ -79,6 +81,7 @@ from .superlink.fleet.grpc_bidi.grpc_server import (
 from .superlink.fleet.grpc_rere.fleet_servicer import FleetServicer
 from .superlink.fleet.grpc_rere.server_interceptor import AuthenticateServerInterceptor
 from .superlink.linkstate import LinkStateFactory
+from .superlink.simulation.simulationio_grpc import run_simulationio_api_grpc
 
 DATABASE = ":flwr-in-memory-state:"
 BASE_DIR = get_flwr_dir() / "superlink" / "ffs"
@@ -215,6 +218,7 @@ def run_superlink() -> None:
     # Parse IP addresses
     serverappio_address, _, _ = _format_address(args.serverappio_api_address)
     exec_address, _, _ = _format_address(args.exec_api_address)
+    simulationio_address, _, _ = _format_address(args.simulationio_api_address)
 
     # Obtain certificates
     certificates = _try_obtain_certificates(args)
@@ -225,128 +229,148 @@ def run_superlink() -> None:
     # Initialize FfsFactory
     ffs_factory = FfsFactory(args.storage_dir)
 
-    # Start ServerAppIo API
-    serverappio_server: grpc.Server = run_serverappio_api_grpc(
-        address=serverappio_address,
+    # Start Exec API
+    executor = load_executor(args)
+    exec_server: grpc.Server = run_exec_api_grpc(
+        address=exec_address,
         state_factory=state_factory,
         ffs_factory=ffs_factory,
+        executor=executor,
         certificates=certificates,
+        config=parse_config_args(
+            [args.executor_config] if args.executor_config else args.executor_config
+        ),
     )
-    grpc_servers = [serverappio_server]
+    grpc_servers = [exec_server]
 
-    # Start Fleet API
-    bckg_threads = []
-    if not args.fleet_api_address:
-        if args.fleet_api_type in [
-            TRANSPORT_TYPE_GRPC_RERE,
-            TRANSPORT_TYPE_GRPC_ADAPTER,
-        ]:
-            args.fleet_api_address = FLEET_API_GRPC_RERE_DEFAULT_ADDRESS
-        elif args.fleet_api_type == TRANSPORT_TYPE_REST:
-            args.fleet_api_address = FLEET_API_REST_DEFAULT_ADDRESS
-
-    fleet_address, host, port = _format_address(args.fleet_api_address)
-
-    num_workers = args.fleet_api_num_workers
-    if num_workers != 1:
-        log(
-            WARN,
-            "The Fleet API currently supports only 1 worker. "
-            "You have specified %d workers. "
-            "Support for multiple workers will be added in future releases. "
-            "Proceeding with a single worker.",
-            args.fleet_api_num_workers,
-        )
-        num_workers = 1
+    # Determine Exec plugin
+    # If simulation is used, don't start ServerAppIo and Fleet APIs
+    sim_exec = isinstance(executor, SimulationEngine)
 
-    if args.fleet_api_type == TRANSPORT_TYPE_REST:
-        if (
-            importlib.util.find_spec("requests")
-            and importlib.util.find_spec("starlette")
-            and importlib.util.find_spec("uvicorn")
-        ) is None:
-            sys.exit(MISSING_EXTRA_REST)
-
-        _, ssl_certfile, ssl_keyfile = (
-            certificates if certificates is not None else (None, None, None)
-        )
-
-        fleet_thread = threading.Thread(
-            target=_run_fleet_api_rest,
-            args=(
-                host,
-                port,
-                ssl_keyfile,
-                ssl_certfile,
-                state_factory,
-                ffs_factory,
-                num_workers,
-            ),
-        )
-        fleet_thread.start()
-        bckg_threads.append(fleet_thread)
-    elif args.fleet_api_type == TRANSPORT_TYPE_GRPC_RERE:
-        maybe_keys = _try_setup_node_authentication(args, certificates)
-        interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None
-        if maybe_keys is not None:
-            (
-                node_public_keys,
-                server_private_key,
-                server_public_key,
-            ) = maybe_keys
-            state = state_factory.state()
-            state.store_node_public_keys(node_public_keys)
-            state.store_server_private_public_key(
-                private_key_to_bytes(server_private_key),
-                public_key_to_bytes(server_public_key),
-            )
-            log(
-                INFO,
-                "Node authentication enabled with %d known public keys",
-                len(node_public_keys),
-            )
-            interceptors = [AuthenticateServerInterceptor(state)]
+    bckg_threads = []
 
-        fleet_server = _run_fleet_api_grpc_rere(
-            address=fleet_address,
+    if sim_exec:
+        simulationio_server: grpc.Server = run_simulationio_api_grpc(
+            address=simulationio_address,
             state_factory=state_factory,
             ffs_factory=ffs_factory,
             certificates=certificates,
-            interceptors=interceptors,
         )
-        grpc_servers.append(fleet_server)
-    elif args.fleet_api_type == TRANSPORT_TYPE_GRPC_ADAPTER:
-        fleet_server = _run_fleet_api_grpc_adapter(
-            address=fleet_address,
+        grpc_servers.append(simulationio_server)
+
+    else:
+        # Start ServerAppIo API
+        serverappio_server: grpc.Server = run_serverappio_api_grpc(
+            address=serverappio_address,
             state_factory=state_factory,
             ffs_factory=ffs_factory,
             certificates=certificates,
         )
-        grpc_servers.append(fleet_server)
-    else:
-        raise ValueError(f"Unknown fleet_api_type: {args.fleet_api_type}")
-
-    # Start Exec API
-    exec_server: grpc.Server = run_exec_api_grpc(
-        address=exec_address,
-        state_factory=state_factory,
-        ffs_factory=ffs_factory,
-        executor=load_executor(args),
-        certificates=certificates,
-        config=parse_config_args(
-            [args.executor_config] if args.executor_config else args.executor_config
-        ),
-    )
-    grpc_servers.append(exec_server)
+        grpc_servers.append(serverappio_server)
+
+        # Start Fleet API
+        if not args.fleet_api_address:
+            if args.fleet_api_type in [
+                TRANSPORT_TYPE_GRPC_RERE,
+                TRANSPORT_TYPE_GRPC_ADAPTER,
+            ]:
+                args.fleet_api_address = FLEET_API_GRPC_RERE_DEFAULT_ADDRESS
+            elif args.fleet_api_type == TRANSPORT_TYPE_REST:
+                args.fleet_api_address = FLEET_API_REST_DEFAULT_ADDRESS
+
+        fleet_address, host, port = _format_address(args.fleet_api_address)
+
+        num_workers = args.fleet_api_num_workers
+        if num_workers != 1:
+            log(
+                WARN,
+                "The Fleet API currently supports only 1 worker. "
+                "You have specified %d workers. "
+                "Support for multiple workers will be added in future releases. "
+                "Proceeding with a single worker.",
+                args.fleet_api_num_workers,
+            )
+            num_workers = 1
+
+        if args.fleet_api_type == TRANSPORT_TYPE_REST:
+            if (
+                importlib.util.find_spec("requests")
+                and importlib.util.find_spec("starlette")
+                and importlib.util.find_spec("uvicorn")
+            ) is None:
+                sys.exit(MISSING_EXTRA_REST)
+
+            _, ssl_certfile, ssl_keyfile = (
+                certificates if certificates is not None else (None, None, None)
+            )
 
-    if args.isolation == ISOLATION_MODE_SUBPROCESS:
-        # Scheduler thread
-        scheduler_th = threading.Thread(
-            target=_flwr_serverapp_scheduler,
-            args=(state_factory, args.serverappio_api_address, args.ssl_ca_certfile),
-        )
-        scheduler_th.start()
-        bckg_threads.append(scheduler_th)
+            fleet_thread = threading.Thread(
+                target=_run_fleet_api_rest,
+                args=(
+                    host,
+                    port,
+                    ssl_keyfile,
+                    ssl_certfile,
+                    state_factory,
+                    ffs_factory,
+                    num_workers,
+                ),
+            )
+            fleet_thread.start()
+            bckg_threads.append(fleet_thread)
+        elif args.fleet_api_type == TRANSPORT_TYPE_GRPC_RERE:
+            maybe_keys = _try_setup_node_authentication(args, certificates)
+            interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None
+            if maybe_keys is not None:
+                (
+                    node_public_keys,
+                    server_private_key,
+                    server_public_key,
+                ) = maybe_keys
+                state = state_factory.state()
+                state.store_node_public_keys(node_public_keys)
+                state.store_server_private_public_key(
+                    private_key_to_bytes(server_private_key),
+                    public_key_to_bytes(server_public_key),
+                )
+                log(
+                    INFO,
+                    "Node authentication enabled with %d known public keys",
+                    len(node_public_keys),
+                )
+                interceptors = [AuthenticateServerInterceptor(state)]
+
+            fleet_server = _run_fleet_api_grpc_rere(
+                address=fleet_address,
+                state_factory=state_factory,
+                ffs_factory=ffs_factory,
+                certificates=certificates,
+                interceptors=interceptors,
+            )
+            grpc_servers.append(fleet_server)
+        elif args.fleet_api_type == TRANSPORT_TYPE_GRPC_ADAPTER:
+            fleet_server = _run_fleet_api_grpc_adapter(
+                address=fleet_address,
+                state_factory=state_factory,
+                ffs_factory=ffs_factory,
+                certificates=certificates,
+            )
+            grpc_servers.append(fleet_server)
+        else:
+            raise ValueError(f"Unknown fleet_api_type: {args.fleet_api_type}")
+
+        if args.isolation == ISOLATION_MODE_SUBPROCESS:
+            # Scheduler thread
+            scheduler_th = threading.Thread(
+                target=_flwr_serverapp_scheduler,
+                args=(
+                    state_factory,
+                    args.serverappio_api_address,
+                    args.ssl_ca_certfile,
+                ),
+            )
+            scheduler_th.start()
+            bckg_threads.append(scheduler_th)
 
     # Graceful shutdown
     register_exit_handlers(
@@ -361,7 +385,7 @@ def run_superlink() -> None:
             for thread in bckg_threads:
                 if not thread.is_alive():
                     sys.exit(1)
-        serverappio_server.wait_for_termination(timeout=1)
+        exec_server.wait_for_termination(timeout=1)
 
 
 def _flwr_serverapp_scheduler(
@@ -657,6 +681,7 @@ def _parse_args_run_superlink() -> argparse.ArgumentParser:
     _add_args_serverappio_api(parser=parser)
     _add_args_fleet_api(parser=parser)
     _add_args_exec_api(parser=parser)
+    _add_args_simulationio_api(parser=parser)
 
     return parser
 
@@ -790,3 +815,11 @@ def _add_args_exec_api(parser: argparse.ArgumentParser) -> None:
         "For example:\n\n`--executor-config 'verbose=true "
         'root-certificates="certificates/superlink-ca.crt"\'`',
     )
+
+
+def _add_args_simulationio_api(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--simulationio-api-address",
+        help="SimulationIo API (gRPC) server address (IPv4, IPv6, or a domain name).",
+        default=SIMULATIONIO_API_DEFAULT_ADDRESS,
+    )

flwr/server/driver/driver.py

@@ -27,7 +27,7 @@ class Driver(ABC):
     """Abstract base Driver class for the ServerAppIo API."""
 
     @abstractmethod
-    def init_run(self, run_id: int) -> None:
+    def set_run(self, run_id: int) -> None:
         """Request a run to the SuperLink with a given `run_id`.
 
         If a Run with the specified `run_id` exists, a local Run

flwr/server/driver/grpc_driver.py

@@ -112,12 +112,8 @@ class GrpcDriver(Driver):
         channel.close()
         log(DEBUG, "[Driver] Disconnected")
 
-    def init_run(self, run_id: int) -> None:
-        """Initialize the run."""
-        # 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=run_id)
         res: GetRunResponse = self._stub.GetRun(req)

flwr/server/driver/inmemory_driver.py

@@ -62,10 +62,8 @@ class InMemoryDriver(Driver):
         ):
             raise ValueError(f"Invalid message: {message}")
 
-    def init_run(self, run_id: int) -> None:
+    def set_run(self, run_id: int) -> None:
         """Initialize the run."""
-        if self._run is not None:
-            return
         run = self.state.get_run(run_id)
         if run is None:
             raise RuntimeError(f"Cannot find the run with ID: {run_id}")

flwr/server/run_serverapp.py

@@ -174,7 +174,7 @@ def run_server_app() -> None:
             root_certificates=root_certificates,
         )
         flwr_dir = get_flwr_dir(args.flwr_dir)
-        driver.init_run(args.run_id)
+        driver.set_run(args.run_id)
         run_ = driver.run
         if not run_.fab_hash:
             raise ValueError("FAB hash not provided.")
@@ -188,6 +188,7 @@ def run_server_app() -> None:
 
         app_path = str(get_project_dir(fab_id, fab_version, run_.fab_hash, flwr_dir))
         config = get_project_config(app_path)
+        run_id = run_.run_id
     else:
         # User provided `app_dir`, but not `--run-id`
         # Create run if run_id is not provided
@@ -203,7 +204,8 @@ def run_server_app() -> None:
         req = CreateRunRequest(fab_id=fab_id, fab_version=fab_version)
         res: CreateRunResponse = driver._stub.CreateRun(req)  # pylint: disable=W0212
         # Fetch full `Run` using `run_id`
-        driver.init_run(res.run_id)  # pylint: disable=W0212
+        driver.set_run(res.run_id)  # pylint: disable=W0212
+        run_id = res.run_id
 
     # Obtain server app reference and the run config
     server_app_attr = config["tool"]["flwr"]["app"]["components"]["serverapp"]
@@ -221,6 +223,7 @@ def run_server_app() -> None:
 
     # Initialize Context
     context = Context(
+        run_id=run_id,
         node_id=0,
         node_config={},
         state=RecordSet(),

flwr/server/serverapp/app.py

@@ -189,7 +189,7 @@ def run_serverapp(  # pylint: disable=R0914, disable=W0212
             run = run_from_proto(res.run)
             fab = fab_from_proto(res.fab)
 
-            driver.init_run(run.run_id)
+            driver.set_run(run.run_id)
 
             # Start log uploader for this run
             log_uploader = start_log_uploader(

flwr/server/superlink/driver/serverappio_servicer.py

@@ -23,6 +23,7 @@ from uuid import UUID
 
 import grpc
 
+from flwr.common import ConfigsRecord
 from flwr.common.constant import Status
 from flwr.common.logger import log
 from flwr.common.serde import (
@@ -112,6 +113,7 @@ class ServerAppIoServicer(serverappio_pb2_grpc.ServerAppIoServicer):
             request.fab_version,
             fab_hash,
             user_config_from_proto(request.override_config),
+            ConfigsRecord(),
         )
         return CreateRunResponse(run_id=run_id)
 

flwr/server/superlink/linkstate/in_memory_linkstate.py

@@ -30,6 +30,7 @@ from flwr.common.constant import (
     RUN_ID_NUM_BYTES,
     Status,
 )
+from flwr.common.record import ConfigsRecord
 from flwr.common.typing import Run, RunStatus, UserConfig
 from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 from flwr.server.superlink.linkstate.linkstate import LinkState
@@ -39,7 +40,6 @@ from .utils import (
     generate_rand_int_from_bytes,
     has_valid_sub_status,
     is_valid_transition,
-    make_node_unavailable_taskres,
 )
 
 
@@ -69,6 +69,7 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         # Map run_id to RunRecord
         self.run_ids: dict[int, RunRecord] = {}
         self.contexts: dict[int, Context] = {}
+        self.federation_options: dict[int, ConfigsRecord] = {}
         self.task_ins_store: dict[UUID, TaskIns] = {}
         self.task_res_store: dict[UUID, TaskRes] = {}
 
@@ -255,21 +256,6 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
                     task_res_list.append(task_res)
                     replied_task_ids.add(reply_to)
 
-            # Check if the node is offline
-            for task_id in task_ids - replied_task_ids:
-                task_ins = self.task_ins_store.get(task_id)
-                if task_ins is None:
-                    continue
-                node_id = task_ins.task.consumer.node_id
-                online_until, _ = self.node_ids[node_id]
-                # Generate a TaskRes containing an error reply if the node is offline.
-                if online_until < time.time():
-                    err_taskres = make_node_unavailable_taskres(
-                        ref_taskins=task_ins,
-                    )
-                    self.task_res_store[UUID(err_taskres.task_id)] = err_taskres
-                    task_res_list.append(err_taskres)
-
             # Mark all of them as delivered
             delivered_at = now().isoformat()
             for task_res in task_res_list:
@@ -378,12 +364,14 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
         """Retrieve stored `node_id` filtered by `node_public_keys`."""
         return self.public_key_to_node_id.get(node_public_key)
 
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     def create_run(
         self,
         fab_id: Optional[str],
         fab_version: Optional[str],
         fab_hash: Optional[str],
         override_config: UserConfig,
+        federation_options: ConfigsRecord,
     ) -> int:
         """Create a new run for the specified `fab_hash`."""
         # Sample a random int64 as run_id
@@ -407,6 +395,9 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
                     pending_at=now().isoformat(),
                 )
                 self.run_ids[run_id] = run_record
+
+                # Record federation options. Leave empty if not passed
+                self.federation_options[run_id] = federation_options
                 return run_id
         log(ERROR, "Unexpected run creation failure.")
         return 0
@@ -514,6 +505,14 @@ class InMemoryLinkState(LinkState):  # pylint: disable=R0902,R0904
 
         return pending_run_id
 
+    def get_federation_options(self, run_id: int) -> Optional[ConfigsRecord]:
+        """Retrieve the federation options for the specified `run_id`."""
+        with self.lock:
+            if run_id not in self.run_ids:
+                log(ERROR, "`run_id` is invalid")
+                return None
+            return self.federation_options[run_id]
+
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:
         """Acknowledge a ping received from a node, serving as a heartbeat."""
         with self.lock:

flwr/server/superlink/linkstate/linkstate.py

@@ -20,6 +20,7 @@ from typing import Optional
 from uuid import UUID
 
 from flwr.common import Context
+from flwr.common.record import ConfigsRecord
 from flwr.common.typing import Run, RunStatus, UserConfig
 from flwr.proto.task_pb2 import TaskIns, TaskRes  # pylint: disable=E0611
 
@@ -152,12 +153,13 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
         """Retrieve stored `node_id` filtered by `node_public_keys`."""
 
     @abc.abstractmethod
-    def create_run(
+    def create_run(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
         fab_id: Optional[str],
         fab_version: Optional[str],
         fab_hash: Optional[str],
         override_config: UserConfig,
+        federation_options: ConfigsRecord,
     ) -> int:
         """Create a new run for the specified `fab_hash`."""
 
@@ -227,6 +229,21 @@ class LinkState(abc.ABC):  # pylint: disable=R0904
             there is no Run pending.
         """
 
+    @abc.abstractmethod
+    def get_federation_options(self, run_id: int) -> Optional[ConfigsRecord]:
+        """Retrieve the federation options for the specified `run_id`.
+
+        Parameters
+        ----------
+        run_id : int
+            The identifier of the run.
+
+        Returns
+        -------
+        Optional[ConfigsRecord]
+            The federation options for the run if it exists; None otherwise.
+        """
+
     @abc.abstractmethod
     def store_server_private_public_key(
         self, private_key: bytes, public_key: bytes

flwr/server/superlink/linkstate/sqlite_linkstate.py

@@ -33,6 +33,7 @@ from flwr.common.constant import (
     RUN_ID_NUM_BYTES,
     Status,
 )
+from flwr.common.record import ConfigsRecord
 from flwr.common.typing import Run, RunStatus, UserConfig
 
 # pylint: disable=E0611
@@ -45,6 +46,8 @@ from flwr.server.utils.validator import validate_task_ins_or_res
 
 from .linkstate import LinkState
 from .utils import (
+    configsrecord_from_bytes,
+    configsrecord_to_bytes,
     context_from_bytes,
     context_to_bytes,
     convert_sint64_to_uint64,
@@ -54,7 +57,6 @@ from .utils import (
     generate_rand_int_from_bytes,
     has_valid_sub_status,
     is_valid_transition,
-    make_node_unavailable_taskres,
 )
 
 SQL_CREATE_TABLE_NODE = """
@@ -95,7 +97,8 @@ CREATE TABLE IF NOT EXISTS run(
     running_at            TEXT,
     finished_at           TEXT,
     sub_status            TEXT,
-    details               TEXT
+    details               TEXT,
+    federation_options    BLOB
 );
 """
 
@@ -636,20 +639,6 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         data = {f"id_{i}": str(node_id) for i, node_id in enumerate(offline_node_ids)}
         task_ins_rows = self.query(query, data)
 
-        # Make TaskRes containing node unavailabe error
-        for row in task_ins_rows:
-            for row in rows:
-                # Convert values from sint64 to uint64
-                convert_sint64_values_in_dict_to_uint64(
-                    row, ["run_id", "producer_node_id", "consumer_node_id"]
-                )
-
-            task_ins = dict_to_task_ins(row)
-            err_taskres = make_node_unavailable_taskres(
-                ref_taskins=task_ins,
-            )
-            result.append(err_taskres)
-
         return result
 
     def num_task_ins(self) -> int:
@@ -810,12 +799,14 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
             return uint64_node_id
         return None
 
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
     def create_run(
         self,
         fab_id: Optional[str],
         fab_version: Optional[str],
         fab_hash: Optional[str],
         override_config: UserConfig,
+        federation_options: ConfigsRecord,
     ) -> int:
         """Create a new run for the specified `fab_id` and `fab_version`."""
         # Sample a random int64 as run_id
@@ -830,15 +821,29 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
         if self.query(query, (sint64_run_id,))[0]["COUNT(*)"] == 0:
             query = (
                 "INSERT INTO run "
-                "(run_id, fab_id, fab_version, fab_hash, override_config, pending_at, "
-                "starting_at, running_at, finished_at, sub_status, details)"
-                "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
+                "(run_id, fab_id, fab_version, fab_hash, override_config, "
+                "federation_options, pending_at, starting_at, running_at, finished_at, "
+                "sub_status, details) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
             )
             if fab_hash:
                 fab_id, fab_version = "", ""
             override_config_json = json.dumps(override_config)
-            data = [sint64_run_id, fab_id, fab_version, fab_hash, override_config_json]
-            data += [now().isoformat(), "", "", "", "", ""]
+            data = [
+                sint64_run_id,
+                fab_id,
+                fab_version,
+                fab_hash,
+                override_config_json,
+                configsrecord_to_bytes(federation_options),
+            ]
+            data += [
+                now().isoformat(),
+                "",
+                "",
+                "",
+                "",
+                "",
+            ]
             self.query(query, tuple(data))
             return uint64_run_id
         log(ERROR, "Unexpected run creation failure.")
@@ -1003,6 +1008,21 @@ class SqliteLinkState(LinkState):  # pylint: disable=R0904
 
         return pending_run_id
 
+    def get_federation_options(self, run_id: int) -> Optional[ConfigsRecord]:
+        """Retrieve the federation options for the specified `run_id`."""
+        # Convert the uint64 value to sint64 for SQLite
+        sint64_run_id = convert_uint64_to_sint64(run_id)
+        query = "SELECT federation_options FROM run WHERE run_id = ?;"
+        rows = self.query(query, (sint64_run_id,))
+
+        # Check if the run_id exists
+        if not rows:
+            log(ERROR, "`run_id` is invalid")
+            return None
+
+        row = rows[0]
+        return configsrecord_from_bytes(row["federation_options"])
+
     def acknowledge_ping(self, node_id: int, ping_interval: float) -> bool:
         """Acknowledge a ping received from a node, serving as a heartbeat."""
         sint64_node_id = convert_uint64_to_sint64(node_id)