flwr-nightly 1.11.0.dev20240823__py3-none-any.whl → 1.12.0.dev20240906__py3-none-any.whl

flwr/cli/new/templates/app/pyproject.flowertune.toml.tpl

@@ -8,15 +8,15 @@ version = "1.0.0"
 description = ""
 license = "Apache-2.0"
 dependencies = [
-    "flwr[simulation]>=1.9.0,<2.0",
-    "flwr-datasets>=0.1.0,<1.0.0",
-    "hydra-core==1.3.2",
+    "flwr[simulation]>=1.10.0",
+    "flwr-datasets>=0.3.0",
     "trl==0.8.1",
     "bitsandbytes==0.43.0",
     "scipy==1.13.0",
     "peft==0.6.2",
     "transformers==4.39.3",
     "sentencepiece==0.2.0",
+    "omegaconf==2.3.0",
 ]
 
 [tool.hatch.build.targets.wheel]
@@ -26,14 +26,41 @@ packages = ["."]
 publisher = "$username"
 
 [tool.flwr.app.components]
-serverapp = "$import_name.app:server"
-clientapp = "$import_name.app:client"
+serverapp = "$import_name.server_app:app"
+clientapp = "$import_name.client_app:app"
 
 [tool.flwr.app.config]
-num-server-rounds = 3
+model.name = "mistralai/Mistral-7B-v0.3"
+model.quantization = 4
+model.gradient-checkpointing = true
+model.lora.peft-lora-r = 32
+model.lora.peft-lora-alpha = 64
+train.save-every-round = 5
+train.learning-rate-max = 5e-5
+train.learning-rate-min = 1e-6
+train.seq-length = 512
+train.training-arguments.output-dir = ""
+train.training-arguments.learning-rate = ""
+train.training-arguments.per-device-train-batch-size = 16
+train.training-arguments.gradient-accumulation-steps = 1
+train.training-arguments.logging-steps = 10
+train.training-arguments.num-train-epochs = 3
+train.training-arguments.max-steps = 10
+train.training-arguments.save-steps = 1000
+train.training-arguments.save-total-limit = 10
+train.training-arguments.gradient-checkpointing = true
+train.training-arguments.lr-scheduler-type = "constant"
+strategy.fraction-fit = $fraction_fit
+strategy.fraction-evaluate = 0.0
+num-server-rounds = 200
+
+[tool.flwr.app.config.static]
+dataset.name = "$dataset_name"
 
 [tool.flwr.federations]
 default = "local-simulation"
 
 [tool.flwr.federations.local-simulation]
-options.num-supernodes = 10
+options.num-supernodes = $num_clients
+options.backend.client-resources.num-cpus = 6
+options.backend.client-resources.num-gpus = 1.0

flwr/cli/run/run.py

@@ -124,14 +124,14 @@ def run(
 
 
 def _run_with_superexec(
-    app: Optional[Path],
+    app: Path,
     federation_config: Dict[str, Any],
     config_overrides: Optional[List[str]],
 ) -> None:
 
     insecure_str = federation_config.get("insecure")
     if root_certificates := federation_config.get("root-certificates"):
-        root_certificates_bytes = Path(root_certificates).read_bytes()
+        root_certificates_bytes = (app / root_certificates).read_bytes()
         if insecure := bool(insecure_str):
             typer.secho(
                 "❌ `root_certificates` were provided but the `insecure` parameter"

flwr/client/__init__.py

@@ -20,8 +20,6 @@ from .app import start_numpy_client as start_numpy_client
 from .client import Client as Client
 from .client_app import ClientApp as ClientApp
 from .numpy_client import NumPyClient as NumPyClient
-from .supernode import run_client_app as run_client_app
-from .supernode import run_supernode as run_supernode
 from .typing import ClientFn as ClientFn
 from .typing import ClientFnExt as ClientFnExt
 
@@ -32,8 +30,6 @@ __all__ = [
     "ClientFnExt",
     "NumPyClient",
     "mod",
-    "run_client_app",
-    "run_supernode",
     "start_client",
     "start_numpy_client",
 ]

flwr/client/grpc_rere_client/client_interceptor.py

@@ -17,11 +17,13 @@
 
 import base64
 import collections
+from logging import WARNING
 from typing import Any, Callable, Optional, Sequence, Tuple, Union
 
 import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
 
+from flwr.common.logger import log
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
     bytes_to_public_key,
     compute_hmac,
@@ -151,8 +153,15 @@ class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type:
             server_public_key_bytes = base64.urlsafe_b64decode(
                 _get_value_from_tuples(_PUBLIC_KEY_HEADER, response.initial_metadata())
             )
-            self.server_public_key = bytes_to_public_key(server_public_key_bytes)
-            self.shared_secret = generate_shared_key(
-                self.private_key, self.server_public_key
-            )
+
+            if server_public_key_bytes != b"":
+                self.server_public_key = bytes_to_public_key(server_public_key_bytes)
+            else:
+                log(WARNING, "Can't get server public key, SuperLink may be offline")
+
+            if self.server_public_key is not None:
+                self.shared_secret = generate_shared_key(
+                    self.private_key, self.server_public_key
+                )
+
         return response

flwr/client/supernode/app.py

@@ -77,7 +77,9 @@ def run_supernode() -> None:
         authentication_keys=authentication_keys,
         max_retries=args.max_retries,
         max_wait_time=args.max_wait_time,
-        node_config=parse_config_args([args.node_config]),
+        node_config=parse_config_args(
+            [args.node_config] if args.node_config else args.node_config
+        ),
         isolation=args.isolation,
         supernode_address=args.supernode_address,
     )

flwr/common/config.py

@@ -185,23 +185,26 @@ def parse_config_args(
     if config is None:
         return overrides
 
+    # Handle if .toml file is passed
+    if len(config) == 1 and config[0].endswith(".toml"):
+        with Path(config[0]).open("rb") as config_file:
+            overrides = flatten_dict(tomli.load(config_file))
+        return overrides
+
     # Regular expression to capture key-value pairs with possible quoted values
     pattern = re.compile(r"(\S+?)=(\'[^\']*\'|\"[^\"]*\"|\S+)")
 
     for config_line in config:
         if config_line:
-            matches = pattern.findall(config_line)
+            # .toml files aren't allowed alongside other configs
+            if config_line.endswith(".toml"):
+                raise ValueError(
+                    "TOML files cannot be passed alongside key-value pairs."
+                )
 
-            if (
-                len(matches) == 1
-                and "=" not in matches[0][0]
-                and matches[0][0].endswith(".toml")
-            ):
-                with Path(matches[0][0]).open("rb") as config_file:
-                    overrides = flatten_dict(tomli.load(config_file))
-            else:
-                toml_str = "\n".join(f"{k} = {v}" for k, v in matches)
-                overrides.update(tomli.loads(toml_str))
+            matches = pattern.findall(config_line)
+            toml_str = "\n".join(f"{k} = {v}" for k, v in matches)
+            overrides.update(tomli.loads(toml_str))
 
     return overrides
 

flwr/common/telemetry.py

@@ -132,53 +132,59 @@ class EventType(str, Enum):
     # Ping
     PING = auto()
 
-    # Client: start_client
+    # --- LEGACY FUNCTIONS -------------------------------------------------------------
+
+    # Legacy: `start_client` function
     START_CLIENT_ENTER = auto()
     START_CLIENT_LEAVE = auto()
 
-    # Server: start_server
+    # Legacy: `start_server` function
     START_SERVER_ENTER = auto()
     START_SERVER_LEAVE = auto()
 
-    # Driver API
-    RUN_DRIVER_API_ENTER = auto()
-    RUN_DRIVER_API_LEAVE = auto()
+    # Legacy: `start_simulation` function
+    START_SIMULATION_ENTER = auto()
+    START_SIMULATION_LEAVE = auto()
 
-    # Fleet API
-    RUN_FLEET_API_ENTER = auto()
-    RUN_FLEET_API_LEAVE = auto()
+    # --- `flwr` CLI -------------------------------------------------------------------
 
-    # Driver API and Fleet API
-    RUN_SUPERLINK_ENTER = auto()
-    RUN_SUPERLINK_LEAVE = auto()
+    # Not yet implemented
 
-    # Simulation
-    START_SIMULATION_ENTER = auto()
-    START_SIMULATION_LEAVE = auto()
+    # --- SuperExec --------------------------------------------------------------------
 
-    # Driver: Driver
-    DRIVER_CONNECT = auto()
-    DRIVER_DISCONNECT = auto()
+    # SuperExec
+    RUN_SUPEREXEC_ENTER = auto()
+    RUN_SUPEREXEC_LEAVE = auto()
 
-    # Driver: start_driver
-    START_DRIVER_ENTER = auto()
-    START_DRIVER_LEAVE = auto()
+    # --- Simulation Engine ------------------------------------------------------------
 
-    # flower-client-app
-    RUN_CLIENT_APP_ENTER = auto()
-    RUN_CLIENT_APP_LEAVE = auto()
+    # CLI: flower-simulation
+    CLI_FLOWER_SIMULATION_ENTER = auto()
+    CLI_FLOWER_SIMULATION_LEAVE = auto()
 
-    # flower-server-app
-    RUN_SERVER_APP_ENTER = auto()
-    RUN_SERVER_APP_LEAVE = auto()
+    # Python API: `run_simulation`
+    PYTHON_API_RUN_SIMULATION_ENTER = auto()
+    PYTHON_API_RUN_SIMULATION_LEAVE = auto()
 
-    # SuperNode
+    # --- Deployment Engine ------------------------------------------------------------
+
+    # CLI: `flower-superlink`
+    RUN_SUPERLINK_ENTER = auto()
+    RUN_SUPERLINK_LEAVE = auto()
+
+    # CLI: `flower-supernode`
     RUN_SUPERNODE_ENTER = auto()
     RUN_SUPERNODE_LEAVE = auto()
 
-    # SuperExec
-    RUN_SUPEREXEC_ENTER = auto()
-    RUN_SUPEREXEC_LEAVE = auto()
+    # CLI: `flower-server-app`
+    RUN_SERVER_APP_ENTER = auto()
+    RUN_SERVER_APP_LEAVE = auto()
+
+    # --- DEPRECATED -------------------------------------------------------------------
+
+    # [DEPRECATED] CLI: `flower-client-app`
+    RUN_CLIENT_APP_ENTER = auto()
+    RUN_CLIENT_APP_LEAVE = auto()
 
 
 # Use the ThreadPoolExecutor with max_workers=1 to have a queue

flwr/server/__init__.py

@@ -17,14 +17,12 @@
 
 from . import strategy
 from . import workflow as workflow
-from .app import run_superlink as run_superlink
 from .app import start_server as start_server
 from .client_manager import ClientManager as ClientManager
 from .client_manager import SimpleClientManager as SimpleClientManager
 from .compat import LegacyContext as LegacyContext
 from .driver import Driver as Driver
 from .history import History as History
-from .run_serverapp import run_server_app as run_server_app
 from .server import Server as Server
 from .server_app import ServerApp as ServerApp
 from .server_config import ServerConfig as ServerConfig
@@ -40,8 +38,6 @@ __all__ = [
     "ServerAppComponents",
     "ServerConfig",
     "SimpleClientManager",
-    "run_server_app",
-    "run_superlink",
     "start_server",
     "strategy",
     "workflow",

flwr/server/app.py

@@ -278,24 +278,24 @@ def run_superlink() -> None:
         fleet_thread.start()
         bckg_threads.append(fleet_thread)
     elif args.fleet_api_type == TRANSPORT_TYPE_GRPC_RERE:
-        maybe_keys = _try_setup_client_authentication(args, certificates)
+        maybe_keys = _try_setup_node_authentication(args, certificates)
         interceptors: Optional[Sequence[grpc.ServerInterceptor]] = None
         if maybe_keys is not None:
             (
-                client_public_keys,
+                node_public_keys,
                 server_private_key,
                 server_public_key,
             ) = maybe_keys
             state = state_factory.state()
-            state.store_client_public_keys(client_public_keys)
+            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,
-                "Client authentication enabled with %d known public keys",
-                len(client_public_keys),
+                "Node authentication enabled with %d known public keys",
+                len(node_public_keys),
             )
             interceptors = [AuthenticateServerInterceptor(state)]
 
@@ -344,7 +344,7 @@ def _format_address(address: str) -> Tuple[str, str, int]:
     return (f"[{host}]:{port}" if is_v6 else f"{host}:{port}", host, port)
 
 
-def _try_setup_client_authentication(
+def _try_setup_node_authentication(
     args: argparse.Namespace,
     certificates: Optional[Tuple[bytes, bytes, bytes]],
 ) -> Optional[Tuple[Set[bytes], ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey]]:
@@ -373,16 +373,16 @@ def _try_setup_client_authentication(
             "`--ssl-keyfile`, and `—-ssl-ca-certfile` and try again."
         )
 
-    client_keys_file_path = Path(args.auth_list_public_keys)
-    if not client_keys_file_path.exists():
+    node_keys_file_path = Path(args.auth_list_public_keys)
+    if not node_keys_file_path.exists():
         sys.exit(
             "The provided path to the known public keys CSV file does not exist: "
-            f"{client_keys_file_path}. "
+            f"{node_keys_file_path}. "
             "Please provide the CSV file path containing known public keys "
             "to '--auth-list-public-keys'."
         )
 
-    client_public_keys: Set[bytes] = set()
+    node_public_keys: Set[bytes] = set()
 
     try:
         ssh_private_key = load_ssh_private_key(
@@ -413,13 +413,13 @@ def _try_setup_client_authentication(
             "path points to a valid public key file and try again."
         )
 
-    with open(client_keys_file_path, newline="", encoding="utf-8") as csvfile:
+    with open(node_keys_file_path, newline="", encoding="utf-8") as csvfile:
         reader = csv.reader(csvfile)
         for row in reader:
             for element in row:
                 public_key = load_ssh_public_key(element.encode())
                 if isinstance(public_key, ec.EllipticCurvePublicKey):
-                    client_public_keys.add(public_key_to_bytes(public_key))
+                    node_public_keys.add(public_key_to_bytes(public_key))
                 else:
                     sys.exit(
                         "Error: Unable to parse the public keys in the CSV "
@@ -427,7 +427,7 @@ def _try_setup_client_authentication(
                         "known SSH public keys files and try again."
                     )
         return (
-            client_public_keys,
+            node_public_keys,
             ssh_private_key,
             ssh_public_key,
         )

flwr/server/compat/app.py

@@ -18,7 +18,6 @@
 from logging import INFO
 from typing import Optional
 
-from flwr.common import EventType, event
 from flwr.common.logger import log
 from flwr.server.client_manager import ClientManager
 from flwr.server.history import History
@@ -65,8 +64,6 @@ def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
     hist : flwr.server.history.History
         Object containing training and evaluation metrics.
     """
-    event(EventType.START_DRIVER_ENTER)
-
     # Initialize the Driver API server and config
     initialized_server, initialized_config = init_defaults(
         server=server,
@@ -96,6 +93,4 @@ def start_driver(  # pylint: disable=too-many-arguments, too-many-locals
     f_stop.set()
     thread.join()
 
-    event(EventType.START_SERVER_LEAVE)
-
     return hist

flwr/server/driver/grpc_driver.py

@@ -21,7 +21,7 @@ from typing import Iterable, List, Optional, cast
 
 import grpc
 
-from flwr.common import DEFAULT_TTL, EventType, Message, Metadata, RecordSet, event
+from flwr.common import DEFAULT_TTL, Message, Metadata, RecordSet
 from flwr.common.grpc import create_channel
 from flwr.common.logger import log
 from flwr.common.serde import (
@@ -94,7 +94,6 @@ class GrpcDriver(Driver):
 
         This will not call GetRun.
         """
-        event(EventType.DRIVER_CONNECT)
         if self._is_connected:
             log(WARNING, "Already connected")
             return
@@ -108,7 +107,6 @@ class GrpcDriver(Driver):
 
     def _disconnect(self) -> None:
         """Disconnect from the Driver API."""
-        event(EventType.DRIVER_DISCONNECT)
         if not self._is_connected:
             log(DEBUG, "Already disconnected")
             return

flwr/server/run_serverapp.py

@@ -97,6 +97,21 @@ def run_server_app() -> None:
 
     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 != ADDRESS_DRIVER_API:
         warn = "Passing flag --server is deprecated. Use --superlink instead."
         warn_deprecated_feature(warn)
@@ -151,7 +166,6 @@ def run_server_app() -> None:
             cert_path,
         )
 
-    app_path: Optional[str] = args.app
     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. "

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

@@ -51,19 +51,22 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: CreateNodeRequest, context: grpc.ServicerContext
     ) -> CreateNodeResponse:
         """."""
-        log(INFO, "FleetServicer.CreateNode")
+        log(INFO, "[Fleet.CreateNode] Request ping_interval=%s", request.ping_interval)
+        log(DEBUG, "[Fleet.CreateNode] Request: %s", request)
         response = message_handler.create_node(
             request=request,
             state=self.state_factory.state(),
         )
-        log(INFO, "FleetServicer: Created node_id=%s", response.node.node_id)
+        log(INFO, "[Fleet.CreateNode] Created node_id=%s", response.node.node_id)
+        log(DEBUG, "[Fleet.CreateNode] Response: %s", response)
         return response
 
     def DeleteNode(
         self, request: DeleteNodeRequest, context: grpc.ServicerContext
     ) -> DeleteNodeResponse:
         """."""
-        log(INFO, "FleetServicer.DeleteNode")
+        log(INFO, "[Fleet.DeleteNode] Delete node_id=%s", request.node.node_id)
+        log(DEBUG, "[Fleet.DeleteNode] Request: %s", request)
         return message_handler.delete_node(
             request=request,
             state=self.state_factory.state(),
@@ -71,7 +74,7 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
 
     def Ping(self, request: PingRequest, context: grpc.ServicerContext) -> PingResponse:
         """."""
-        log(DEBUG, "FleetServicer.Ping")
+        log(DEBUG, "[Fleet.Ping] Request: %s", request)
         return message_handler.ping(
             request=request,
             state=self.state_factory.state(),
@@ -81,7 +84,8 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: PullTaskInsRequest, context: grpc.ServicerContext
     ) -> PullTaskInsResponse:
         """Pull TaskIns."""
-        log(INFO, "FleetServicer.PullTaskIns")
+        log(INFO, "[Fleet.PullTaskIns] node_id=%s", request.node.node_id)
+        log(DEBUG, "[Fleet.PullTaskIns] Request: %s", request)
         return message_handler.pull_task_ins(
             request=request,
             state=self.state_factory.state(),
@@ -91,7 +95,14 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: PushTaskResRequest, context: grpc.ServicerContext
     ) -> PushTaskResResponse:
         """Push TaskRes."""
-        log(INFO, "FleetServicer.PushTaskRes")
+        if request.task_res_list:
+            log(
+                INFO,
+                "[Fleet.PushTaskRes] Push results from node_id=%s",
+                request.task_res_list[0].task.producer.node_id,
+            )
+        else:
+            log(INFO, "[Fleet.PushTaskRes] No task results to push")
         return message_handler.push_task_res(
             request=request,
             state=self.state_factory.state(),
@@ -101,7 +112,7 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: GetRunRequest, context: grpc.ServicerContext
     ) -> GetRunResponse:
         """Get run information."""
-        log(INFO, "FleetServicer.GetRun")
+        log(INFO, "[Fleet.GetRun] Requesting `Run` for run_id=%s", request.run_id)
         return message_handler.get_run(
             request=request,
             state=self.state_factory.state(),
@@ -111,7 +122,7 @@ class FleetServicer(fleet_pb2_grpc.FleetServicer):
         self, request: GetFabRequest, context: grpc.ServicerContext
     ) -> GetFabResponse:
         """Get FAB."""
-        log(DEBUG, "DriverServicer.GetFab")
+        log(INFO, "[Fleet.GetFab] Requesting FAB for fab_hash=%s", request.hash_str)
         return message_handler.get_fab(
             request=request,
             ffs=self.ffs_factory.ffs(),

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

@@ -78,13 +78,13 @@ def _get_value_from_tuples(
 
 
 class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
-    """Server interceptor for client authentication."""
+    """Server interceptor for node authentication."""
 
     def __init__(self, state: State):
         self.state = state
 
-        self.client_public_keys = state.get_client_public_keys()
-        if len(self.client_public_keys) == 0:
+        self.node_public_keys = state.get_node_public_keys()
+        if len(self.node_public_keys) == 0:
             log(WARNING, "Authentication enabled, but no known public keys configured")
 
         private_key = self.state.get_server_private_key()
@@ -103,9 +103,9 @@ class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
     ) -> grpc.RpcMethodHandler:
         """Flower server interceptor authentication logic.
 
-        Intercept all unary calls from clients and authenticate clients by validating
-        auth metadata sent by the client. Continue RPC call if client is authenticated,
-        else, terminate RPC call by setting context to abort.
+        Intercept all unary calls from nodes and authenticate nodes by validating auth
+        metadata sent by the node. Continue RPC call if node is authenticated, else,
+        terminate RPC call by setting context to abort.
         """
         # One of the method handlers in
         # `flwr.server.superlink.fleet.grpc_rere.fleet_server.FleetServicer`
@@ -119,17 +119,17 @@ class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
             request: Request,
             context: grpc.ServicerContext,
         ) -> Response:
-            client_public_key_bytes = base64.urlsafe_b64decode(
+            node_public_key_bytes = base64.urlsafe_b64decode(
                 _get_value_from_tuples(
                     _PUBLIC_KEY_HEADER, context.invocation_metadata()
                 )
             )
-            if client_public_key_bytes not in self.client_public_keys:
+            if node_public_key_bytes not in self.node_public_keys:
                 context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")
 
             if isinstance(request, CreateNodeRequest):
                 response = self._create_authenticated_node(
-                    client_public_key_bytes, request, context
+                    node_public_key_bytes, request, context
                 )
                 log(
                     INFO,
@@ -144,13 +144,13 @@ class AuthenticateServerInterceptor(grpc.ServerInterceptor):  # type: ignore
                     _AUTH_TOKEN_HEADER, context.invocation_metadata()
                 )
             )
-            public_key = bytes_to_public_key(client_public_key_bytes)
+            public_key = bytes_to_public_key(node_public_key_bytes)
 
             if not self._verify_hmac(public_key, request, hmac_value):
                 context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")
 
             # Verify node_id
-            node_id = self.state.get_node_id(client_public_key_bytes)
+            node_id = self.state.get_node_id(node_public_key_bytes)
 
             if not self._verify_node_id(node_id, request):
                 context.abort(grpc.StatusCode.UNAUTHENTICATED, "Access denied")