flwr 1.14.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

flwr/client/clientapp/app.py

@@ -16,7 +16,6 @@
 
 
 import argparse
-import sys
 import time
 from logging import DEBUG, ERROR, INFO
 from typing import Optional
@@ -29,7 +28,8 @@ from flwr.common import Context, Message
 from flwr.common.args import add_args_flwr_app_common
 from flwr.common.config import get_flwr_dir
 from flwr.common.constant import CLIENTAPPIO_API_DEFAULT_CLIENT_ADDRESS, ErrorCode
-from flwr.common.grpc import create_channel
+from flwr.common.exit import ExitCode, flwr_exit
+from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.logger import log
 from flwr.common.message import Error
 from flwr.common.retry_invoker import _make_simple_grpc_retry_invoker, _wrap_stub
@@ -61,18 +61,16 @@ def flwr_clientapp() -> None:
     """Run process-isolated Flower ClientApp."""
     args = _parse_args_run_flwr_clientapp().parse_args()
     if not args.insecure:
-        log(
-            ERROR,
-            "flwr-clientapp does not support TLS yet. "
-            "Please use the '--insecure' flag.",
+        flwr_exit(
+            ExitCode.COMMON_TLS_NOT_SUPPORTED,
+            "flwr-clientapp does not support TLS yet.",
         )
-        sys.exit(1)
 
-    log(INFO, "Starting Flower ClientApp")
+    log(INFO, "Start `flwr-clientapp` process")
     log(
         DEBUG,
-        "Starting isolated `ClientApp` connected to SuperNode's ClientAppIo API at %s "
-        "with token %s",
+        "`flwr-clientapp` will attempt to connect to SuperNode's "
+        "ClientAppIo API at %s with token %s",
         args.clientappio_api_address,
         args.token,
     )
@@ -85,11 +83,6 @@ def flwr_clientapp() -> None:
     )
 
 
-def on_channel_state_change(channel_connectivity: str) -> None:
-    """Log channel connectivity."""
-    log(DEBUG, channel_connectivity)
-
-
 def run_clientapp(  # pylint: disable=R0914
     clientappio_api_address: str,
     run_once: bool,
@@ -118,11 +111,11 @@ def run_clientapp(  # pylint: disable=R0914
                 time.sleep(1)
 
             # Pull Message, Context, Run and (optional) FAB from SuperNode
-            message, context, run, fab = pull_message(stub=stub, token=token)
+            message, context, run, fab = pull_clientappinputs(stub=stub, token=token)
 
             # Install FAB, if provided
             if fab:
-                log(DEBUG, "Flower ClientApp starts FAB installation.")
+                log(DEBUG, "[flwr-clientapp] Start FAB installation.")
                 install_from_fab(fab.content, flwr_dir=flwr_dir_, skip_prompt=True)
 
             load_client_app_fn = get_load_client_app_fn(
@@ -134,6 +127,7 @@ def run_clientapp(  # pylint: disable=R0914
 
             try:
                 # Load ClientApp
+                log(DEBUG, "[flwr-clientapp] Start `ClientApp` Loading.")
                 client_app: ClientApp = load_client_app_fn(
                     run.fab_id, run.fab_version, fab.hash_str if fab else ""
                 )
@@ -162,7 +156,7 @@ def run_clientapp(  # pylint: disable=R0914
                 )
 
             # Push Message and Context to SuperNode
-            _ = push_message(
+            _ = push_clientappoutputs(
                 stub=stub, token=token, message=reply_message, context=context
             )
 
@@ -185,7 +179,7 @@ def run_clientapp(  # pylint: disable=R0914
 
 def get_token(stub: grpc.Channel) -> Optional[int]:
     """Get a token from SuperNode."""
-    log(DEBUG, "Flower ClientApp process requests token")
+    log(DEBUG, "[flwr-clientapp] Request token")
     try:
         res: GetTokenResponse = stub.GetToken(GetTokenRequest())
         log(DEBUG, "[GetToken] Received token: %s", res.token)
@@ -198,11 +192,11 @@ def get_token(stub: grpc.Channel) -> Optional[int]:
         return None
 
 
-def pull_message(
+def pull_clientappinputs(
     stub: grpc.Channel, token: int
 ) -> tuple[Message, Context, Run, Optional[Fab]]:
-    """Pull message from SuperNode to ClientApp."""
-    log(INFO, "Pulling ClientAppInputs for token %s", token)
+    """Pull ClientAppInputs from SuperNode."""
+    log(INFO, "[flwr-clientapp] Pull `ClientAppInputs` for token %s", token)
     try:
         res: PullClientAppInputsResponse = stub.PullClientAppInputs(
             PullClientAppInputsRequest(token=token)
@@ -217,11 +211,11 @@ def pull_message(
         raise e
 
 
-def push_message(
+def push_clientappoutputs(
     stub: grpc.Channel, token: int, message: Message, context: Context
 ) -> PushClientAppOutputsResponse:
-    """Push message to SuperNode from ClientApp."""
-    log(INFO, "Pushing ClientAppOutputs for token %s", token)
+    """Push ClientAppOutputs to SuperNode."""
+    log(INFO, "[flwr-clientapp] Push `ClientAppOutputs` for token %s", token)
     proto_message = message_to_proto(message)
     proto_context = context_to_proto(context)
 

flwr/client/clientapp/utils.py

@@ -66,7 +66,7 @@ def get_load_client_app_fn(
         # `fab_hash` is not required since the app is loaded from `runtime_app_dir`.
         elif app_path is not None:
             config = get_project_config(runtime_app_dir)
-            this_fab_version, this_fab_id = get_metadata_from_config(config)
+            this_fab_id, this_fab_version = get_metadata_from_config(config)
 
             if this_fab_version != fab_version or this_fab_id != fab_id:
                 raise LoadClientAppError(

flwr/client/grpc_client/connection.py

@@ -36,7 +36,7 @@ from flwr.common import (
 from flwr.common import recordset_compat as compat
 from flwr.common import serde
 from flwr.common.constant import MessageType, MessageTypeLegacy
-from flwr.common.grpc import create_channel
+from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.logger import log
 from flwr.common.retry_invoker import RetryInvoker
 from flwr.common.typing import Fab, Run
@@ -47,17 +47,6 @@ from flwr.proto.transport_pb2 import (  # pylint: disable=E0611
 )
 from flwr.proto.transport_pb2_grpc import FlowerServiceStub  # pylint: disable=E0611
 
-# The following flags can be uncommented for debugging. Other possible values:
-# https://github.com/grpc/grpc/blob/master/doc/environment_variables.md
-# import os
-# os.environ["GRPC_VERBOSITY"] = "debug"
-# os.environ["GRPC_TRACE"] = "tcp,http"
-
-
-def on_channel_state_change(channel_connectivity: str) -> None:
-    """Log channel connectivity."""
-    log(DEBUG, channel_connectivity)
-
 
 @contextmanager
 def grpc_connection(  # pylint: disable=R0913,R0915,too-many-positional-arguments

flwr/client/grpc_rere_client/client_interceptor.py

@@ -15,67 +15,18 @@
 """Flower client interceptor."""
 
 
-import base64
-import collections
-from collections.abc import Sequence
-from logging import WARNING
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable
 
 import grpc
 from cryptography.hazmat.primitives.asymmetric import ec
+from google.protobuf.message import Message as GrpcMessage
 
-from flwr.common.logger import log
+from flwr.common import now
+from flwr.common.constant import PUBLIC_KEY_HEADER, SIGNATURE_HEADER, TIMESTAMP_HEADER
 from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
-    bytes_to_public_key,
-    compute_hmac,
-    generate_shared_key,
     public_key_to_bytes,
+    sign_message,
 )
-from flwr.proto.fab_pb2 import GetFabRequest  # pylint: disable=E0611
-from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
-    CreateNodeRequest,
-    DeleteNodeRequest,
-    PingRequest,
-    PullTaskInsRequest,
-    PushTaskResRequest,
-)
-from flwr.proto.run_pb2 import GetRunRequest  # pylint: disable=E0611
-
-_PUBLIC_KEY_HEADER = "public-key"
-_AUTH_TOKEN_HEADER = "auth-token"
-
-Request = Union[
-    CreateNodeRequest,
-    DeleteNodeRequest,
-    PullTaskInsRequest,
-    PushTaskResRequest,
-    GetRunRequest,
-    PingRequest,
-    GetFabRequest,
-]
-
-
-def _get_value_from_tuples(
-    key_string: str, tuples: Sequence[tuple[str, Union[str, bytes]]]
-) -> bytes:
-    value = next((value for key, value in tuples if key == key_string), "")
-    if isinstance(value, str):
-        return value.encode()
-
-    return value
-
-
-class _ClientCallDetails(
-    collections.namedtuple(
-        "_ClientCallDetails", ("method", "timeout", "metadata", "credentials")
-    ),
-    grpc.ClientCallDetails,  # type: ignore
-):
-    """Details for each client call.
-
-    The class will be passed on as the first argument in continuation function.
-    In our case, `AuthenticateClientInterceptor` adds new metadata to the construct.
-    """
 
 
 class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type: ignore
@@ -87,84 +38,33 @@ class AuthenticateClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # type:
         public_key: ec.EllipticCurvePublicKey,
     ):
         self.private_key = private_key
-        self.public_key = public_key
-        self.shared_secret: Optional[bytes] = None
-        self.server_public_key: Optional[ec.EllipticCurvePublicKey] = None
-        self.encoded_public_key = base64.urlsafe_b64encode(
-            public_key_to_bytes(self.public_key)
-        )
+        self.public_key_bytes = public_key_to_bytes(public_key)
 
     def intercept_unary_unary(
         self,
         continuation: Callable[[Any, Any], Any],
         client_call_details: grpc.ClientCallDetails,
-        request: Request,
+        request: GrpcMessage,
     ) -> grpc.Call:
         """Flower client interceptor.
 
         Intercept unary call from client and add necessary authentication header in the
         RPC metadata.
         """
-        metadata = []
-        postprocess = False
-        if client_call_details.metadata is not None:
-            metadata = list(client_call_details.metadata)
-
-        # Always add the public key header
-        metadata.append(
-            (
-                _PUBLIC_KEY_HEADER,
-                self.encoded_public_key,
-            )
-        )
-
-        if isinstance(request, CreateNodeRequest):
-            postprocess = True
-        elif isinstance(
-            request,
-            (
-                DeleteNodeRequest,
-                PullTaskInsRequest,
-                PushTaskResRequest,
-                GetRunRequest,
-                PingRequest,
-                GetFabRequest,
-            ),
-        ):
-            if self.shared_secret is None:
-                raise RuntimeError("Failure to compute hmac")
-
-            message_bytes = request.SerializeToString(deterministic=True)
-            metadata.append(
-                (
-                    _AUTH_TOKEN_HEADER,
-                    base64.urlsafe_b64encode(
-                        compute_hmac(self.shared_secret, message_bytes)
-                    ),
-                )
-            )
+        metadata = list(client_call_details.metadata or [])
 
-        client_call_details = _ClientCallDetails(
-            client_call_details.method,
-            client_call_details.timeout,
-            metadata,
-            client_call_details.credentials,
-        )
+        # Add the public key
+        metadata.append((PUBLIC_KEY_HEADER, self.public_key_bytes))
 
-        response = continuation(client_call_details, request)
-        if postprocess:
-            server_public_key_bytes = base64.urlsafe_b64decode(
-                _get_value_from_tuples(_PUBLIC_KEY_HEADER, response.initial_metadata())
-            )
+        # Add timestamp
+        timestamp = now().isoformat()
+        metadata.append((TIMESTAMP_HEADER, timestamp))
 
-            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")
+        # Sign and add the signature
+        signature = sign_message(self.private_key, timestamp.encode("ascii"))
+        metadata.append((SIGNATURE_HEADER, signature))
 
-            if self.server_public_key is not None:
-                self.shared_secret = generate_shared_key(
-                    self.private_key, self.server_public_key
-                )
+        # Overwrite the metadata
+        details = client_call_details._replace(metadata=metadata)
 
-        return response
+        return continuation(details, request)

flwr/client/grpc_rere_client/connection.py

@@ -20,7 +20,7 @@ import threading
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from copy import copy
-from logging import DEBUG, ERROR
+from logging import ERROR
 from pathlib import Path
 from typing import Callable, Optional, Union, cast
 
@@ -29,7 +29,6 @@ from cryptography.hazmat.primitives.asymmetric import ec
 
 from flwr.client.heartbeat import start_ping_loop
 from flwr.client.message_handler.message_handler import validate_out_message
-from flwr.client.message_handler.task_handler import get_task_ins, validate_task_ins
 from flwr.common import GRPC_MAX_MESSAGE_LENGTH
 from flwr.common.constant import (
     PING_BASE_MULTIPLIER,
@@ -37,11 +36,14 @@ from flwr.common.constant import (
     PING_DEFAULT_INTERVAL,
     PING_RANDOM_RANGE,
 )
-from flwr.common.grpc import create_channel
+from flwr.common.grpc import create_channel, on_channel_state_change
 from flwr.common.logger import log
 from flwr.common.message import Message, Metadata
 from flwr.common.retry_invoker import RetryInvoker
-from flwr.common.serde import message_from_taskins, message_to_taskres, run_from_proto
+from flwr.common.secure_aggregation.crypto.symmetric_encryption import (
+    generate_key_pairs,
+)
+from flwr.common.serde import message_from_proto, message_to_proto, run_from_proto
 from flwr.common.typing import Fab, Run, RunNotRunningException
 from flwr.proto.fab_pb2 import GetFabRequest, GetFabResponse  # pylint: disable=E0611
 from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
@@ -49,23 +51,18 @@ from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     DeleteNodeRequest,
     PingRequest,
     PingResponse,
-    PullTaskInsRequest,
-    PushTaskResRequest,
+    PullMessagesRequest,
+    PullMessagesResponse,
+    PushMessagesRequest,
 )
 from flwr.proto.fleet_pb2_grpc import FleetStub  # 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.task_pb2 import TaskIns  # pylint: disable=E0611
 
 from .client_interceptor import AuthenticateClientInterceptor
 from .grpc_adapter import GrpcAdapter
 
 
-def on_channel_state_change(channel_connectivity: str) -> None:
-    """Log channel connectivity."""
-    log(DEBUG, channel_connectivity)
-
-
 @contextmanager
 def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     server_address: str,
@@ -131,12 +128,14 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
     if isinstance(root_certificates, str):
         root_certificates = Path(root_certificates).read_bytes()
 
-    interceptors: Optional[Sequence[grpc.UnaryUnaryClientInterceptor]] = None
-    if authentication_keys is not None:
-        interceptors = AuthenticateClientInterceptor(
-            authentication_keys[0], authentication_keys[1]
-        )
+    # Automatic node auth: generate keys if user didn't provide any
+    if authentication_keys is None:
+        authentication_keys = generate_key_pairs()
 
+    # Always configure auth interceptor, with either user-provided or generated keys
+    interceptors: Sequence[grpc.UnaryUnaryClientInterceptor] = [
+        AuthenticateClientInterceptor(*authentication_keys),
+    ]
     channel = create_channel(
         server_address=server_address,
         insecure=insecure,
@@ -227,28 +226,31 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         node = None
 
     def receive() -> Optional[Message]:
-        """Receive next task from server."""
+        """Receive next message from server."""
         # Get Node
         if node is None:
             log(ERROR, "Node instance missing")
             return None
 
-        # Request instructions (task) from server
-        request = PullTaskInsRequest(node=node)
-        response = retry_invoker.invoke(stub.PullTaskIns, request=request)
+        # Request instructions (message) from server
+        request = PullMessagesRequest(node=node)
+        response: PullMessagesResponse = retry_invoker.invoke(
+            stub.PullMessages, request=request
+        )
 
-        # Get the current TaskIns
-        task_ins: Optional[TaskIns] = get_task_ins(response)
+        # Get the current Messages
+        message_proto = (
+            None if len(response.messages_list) == 0 else response.messages_list[0]
+        )
 
-        # Discard the current TaskIns if not valid
-        if task_ins is not None and not (
-            task_ins.task.consumer.node_id == node.node_id
-            and validate_task_ins(task_ins)
+        # Discard the current message if not valid
+        if message_proto is not None and not (
+            message_proto.metadata.dst_node_id == node.node_id
         ):
-            task_ins = None
+            message_proto = None
 
         # Construct the Message
-        in_message = message_from_taskins(task_ins) if task_ins else None
+        in_message = message_from_proto(message_proto) if message_proto else None
 
         # Remember `metadata` of the in message
         nonlocal metadata
@@ -258,7 +260,7 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         return in_message
 
     def send(message: Message) -> None:
-        """Send task result back to server."""
+        """Send message reply to server."""
         # Get Node
         if node is None:
             log(ERROR, "Node instance missing")
@@ -275,12 +277,10 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
             log(ERROR, "Invalid out message")
             return
 
-        # Construct TaskRes
-        task_res = message_to_taskres(message)
-
-        # Serialize ProtoBuf to bytes
-        request = PushTaskResRequest(node=node, task_res_list=[task_res])
-        _ = retry_invoker.invoke(stub.PushTaskRes, request)
+        # Serialize Message
+        message_proto = message_to_proto(message=message)
+        request = PushMessagesRequest(node=node, messages_list=[message_proto])
+        _ = retry_invoker.invoke(stub.PushMessages, request)
 
         # Cleanup
         metadata = None
@@ -311,3 +311,13 @@ def grpc_request_response(  # pylint: disable=R0913,R0914,R0915,R0917
         yield (receive, send, create_node, delete_node, get_run, get_fab)
     except Exception as exc:  # pylint: disable=broad-except
         log(ERROR, exc)
+    # Cleanup
+    finally:
+        try:
+            if node is not None:
+                # Disable retrying
+                retry_invoker.max_tries = 1
+                delete_node()
+        except grpc.RpcError:
+            pass
+        channel.close()

flwr/client/grpc_rere_client/grpc_adapter.py

@@ -40,10 +40,10 @@ from flwr.proto.fleet_pb2 import (  # pylint: disable=E0611
     DeleteNodeResponse,
     PingRequest,
     PingResponse,
-    PullTaskInsRequest,
-    PullTaskInsResponse,
-    PushTaskResRequest,
-    PushTaskResResponse,
+    PullMessagesRequest,
+    PullMessagesResponse,
+    PushMessagesRequest,
+    PushMessagesResponse,
 )
 from flwr.proto.grpcadapter_pb2 import MessageContainer  # pylint: disable=E0611
 from flwr.proto.grpcadapter_pb2_grpc import GrpcAdapterStub
@@ -126,17 +126,17 @@ class GrpcAdapter:
         """."""
         return self._send_and_receive(request, PingResponse, **kwargs)
 
-    def PullTaskIns(  # pylint: disable=C0103
-        self, request: PullTaskInsRequest, **kwargs: Any
-    ) -> PullTaskInsResponse:
+    def PullMessages(  # pylint: disable=C0103
+        self, request: PullMessagesRequest, **kwargs: Any
+    ) -> PullMessagesResponse:
         """."""
-        return self._send_and_receive(request, PullTaskInsResponse, **kwargs)
+        return self._send_and_receive(request, PullMessagesResponse, **kwargs)
 
-    def PushTaskRes(  # pylint: disable=C0103
-        self, request: PushTaskResRequest, **kwargs: Any
-    ) -> PushTaskResResponse:
+    def PushMessages(  # pylint: disable=C0103
+        self, request: PushMessagesRequest, **kwargs: Any
+    ) -> PushMessagesResponse:
         """."""
-        return self._send_and_receive(request, PushTaskResResponse, **kwargs)
+        return self._send_and_receive(request, PushMessagesResponse, **kwargs)
 
     def GetRun(  # pylint: disable=C0103
         self, request: GetRunRequest, **kwargs: Any

flwr/client/message_handler/task_handler.py

@@ -15,9 +15,6 @@
 """Task handling."""
 
 
-from typing import Optional
-
-from flwr.proto.fleet_pb2 import PullTaskInsResponse  # pylint: disable=E0611
 from flwr.proto.task_pb2 import TaskIns  # pylint: disable=E0611
 
 
@@ -38,17 +35,3 @@ def validate_task_ins(task_ins: TaskIns) -> bool:
     if not (task_ins.HasField("task") and task_ins.task.HasField("recordset")):
         return False
     return True
-
-
-def get_task_ins(
-    pull_task_ins_response: PullTaskInsResponse,
-) -> Optional[TaskIns]:
-    """Get the first TaskIns, if available."""
-    # Extract a single ServerMessage from the response, if possible
-    if len(pull_task_ins_response.task_ins_list) == 0:
-        return None
-
-    # Only evaluate the first message
-    task_ins: TaskIns = pull_task_ins_response.task_ins_list[0]
-
-    return task_ins