Google is committed to advancing racial equity for Black communities. See how.

Implement a synchronous FIDL client in Rust

Prerequisites

This tutorial assumes that you are familiar with writing and running a Fuchsia component and with implementing a FIDL server, which are both covered in the FIDL server tutorial. For the full set of FIDL tutorials, refer to the overview.

Overview

This tutorial implements a client for a FIDL protocol and runs it against the server created in the previous tutorial. The client in this tutorial is synchronous. There is an alternate tutorial for asynchronous clients.

If you want to write the code yourself, delete the following directories:

rm -r examples/fidl/rust/client_sync/*

Create the component

Create a new component project at examples/fidl/rust/client_sync:

  1. Add a main() function to examples/fidl/rust/client_sync/src/main.rs:

    fn main() {
      println!("Hello, world!");
    }
    
  2. Declare a target for the client in examples/fidl/rust/client_sync/BUILD.gn:

    import("//build/components.gni")
    import("//build/rust/rustc_binary.gni")
    
    
    # Declare an executable for the client.
    rustc_binary("bin") {
      name = "fidl_echo_rust_client_sync"
      edition = "2018"
    
      sources = [ "src/main.rs" ]
    }
    
    fuchsia_component("echo-client") {
      component_name = "echo_client"
      manifest = "meta/client.cml"
      deps = [ ":bin" ]
    }
    
  3. Add a component manifest in examples/fidl/rust/client_sync/meta/client.cml:

    {
        include: [
            "syslog/client.shard.cml",
            "syslog/elf_stdio.shard.cml",
        ],
    
        // Information about the program to run.
        program: {
            // Use the built-in ELF runner.
            runner: "elf",
    
            // The binary to run for this component.
            binary: "bin/fidl_echo_rust_client_sync",
        },
    
        // Capabilities used by this component.
        use: [
            { protocol: "fuchsia.examples.Echo" },
        ],
    }
    
    
  4. Once you have created your component, ensure that you can add it to the build configuration:

    fx set core.qemu-x64 --with //examples/fidl/rust/client_sync:echo-client
    
  5. Build the Fuchsia image:

    fx build
    

Edit GN dependencies

  1. Add the following dependencies to the rustc_binary:

      deps = [
        "//examples/fidl/fuchsia.examples:fuchsia.examples-rustc",
        "//src/lib/fuchsia-component",
        "//src/lib/zircon/rust:fuchsia-zircon",
        "//third_party/rust_crates:anyhow",
      ]
    
    
  2. Then, import them in main.rs:

    use anyhow::{Context as _, Error};
    use fidl_fuchsia_examples::{EchoEvent, EchoMarker, EchoSynchronousProxy};
    use fuchsia_component::client::connect_channel_to_protocol;
    use fuchsia_zircon::{self as zx, prelude::*};
    

These dependencies are explained in the server tutorial.

The one new dependency is fuchsia-zircon, which is a crate containing type safe bindings for making Zircon kernel syscalls. In this example, the crate is used to create a channel.

Connect to the server

The steps in this section explain how to add code to the main() function that connects the client to the server and makes requests to it.

Initialize a channel

fn main() -> Result<(), Error> {
    // Initialize a channel, and label the two ends as the server_end and client_end
    let (server_end, client_end) = zx::Channel::create()?;
    // Connect an implementation of the Echo protocol to the server end
    connect_channel_to_protocol::<EchoMarker>(server_end)
        .context("Failed to connect to echo service")?;
    // Create a synchronous proxy using the client end
    let echo = EchoSynchronousProxy::new(client_end);

    // Make an EchoString request, with a timeout of 1 second for receiving the response
    let res = echo.echo_string("hello", zx::Time::after(1.second()))?;
    println!("response: {:?}", res);

    // Make a SendString request
    echo.send_string("hi")?;
    // Wait for a single OnString event.
    let EchoEvent::OnString { response } =
        echo.wait_for_event(zx::Time::after(1.second())).context("error receiving events")?;
    println!("Received OnString event for string {:?}", response);

    Ok(())
}

This channel will be used to communicate between the client and server.

Connect to the server

fn main() -> Result<(), Error> {
    // Initialize a channel, and label the two ends as the server_end and client_end
    let (server_end, client_end) = zx::Channel::create()?;
    // Connect an implementation of the Echo protocol to the server end
    connect_channel_to_protocol::<EchoMarker>(server_end)
        .context("Failed to connect to echo service")?;
    // Create a synchronous proxy using the client end
    let echo = EchoSynchronousProxy::new(client_end);

    // Make an EchoString request, with a timeout of 1 second for receiving the response
    let res = echo.echo_string("hello", zx::Time::after(1.second()))?;
    println!("response: {:?}", res);

    // Make a SendString request
    echo.send_string("hi")?;
    // Wait for a single OnString event.
    let EchoEvent::OnString { response } =
        echo.wait_for_event(zx::Time::after(1.second())).context("error receiving events")?;
    println!("Received OnString event for string {:?}", response);

    Ok(())
}

connect_channel_to_service will bind the provided channel end to the specified service. Under the hood, this call triggers a sequence of events that starts on the client and traces through the server code from the previous tutorial:

  • Makes a request to the component framework containing the name of the service to connect to, and the other end of the channel. The name of the service is obtained implicitly using the SERVICE_NAME of EchoMarker template argument, similarly to how the service path is determined on the server end.
  • This client object is returned from connect_to_protocol.

In the background, the request to the component framework gets routed to the server:

  • When this request is received in the server process, it wakes up the async::Executor executor and tells it that the ServiceFs task can now make progress and should be run.
  • The ServiceFs wakes up, sees the request available on the startup handle of the process, and looks up the name of the requested service in the list of (service_name, service_startup_func) provided through calls to add_service, add_fidl_service, etc. If a matching service_name exists, it calls service_startup_func with the provided channel to connect to the new service.
  • IncomingService::Echo is called with a RequestStream (typed-channel) of the Echo FIDL protocol that is registered with add_fidl_service. The incoming request channel is stored in IncomingService::Echo and is added to the stream of incoming requests. for_each_concurrent consumes the ServiceFs into a [Stream] of type IncomingService. A handler is run for each entry in the stream, which matches over the incoming requests and dispatches to the run_echo_server. The resulting futures from each call to run_echo_server are run concurrently when the ServiceFs stream is awaited.
  • When a request is sent on the channel, the channel the Echo service is becomes readable, which wakes up the asynchronous code in the body of run_echo_server.

Send requests to the server

The code makes two requests to the server:

  • An EchoString request
  • A SendString request
#[fuchsia::component]
async fn main() -> Result<(), Error> {
    // Connect to the Echo protocol, which is assumed to be in the component's environment
    let echo = connect_to_protocol::<EchoMarker>().context("Failed to connect to echo service")?;

    // Make an EchoString request and wait for the response
    let res = echo.echo_string("hello").await?;
    println!("response: {:?}", res);

    // Make a SendString request
    echo.send_string("hi")?;
    // Wait for a single OnString event
    let EchoEvent::OnString { response } =
        echo.take_event_stream().next().await.context("error receiving events")??;
    println!("Received OnString event for string {:?}", response);

    Ok(())
}

The call to echo_string will block until a response is received from the server, and therefore it takes a timeout argument as the last parameter.

On the other hand, the call to send_string does not have a timeout parameter since SendString does not have a response. With the current server implementation, an OnString event will be sent to the client after this request is received. However, the synchronous Rust bindings do not have support for handling events.

The [bindings reference][bindings-ref] describes how these methods are generated, and the [Fuchsia rustdoc][rustdoc] includes documentation for the generated FIDL crates.

Run the client

In order for the client and server to communicate using the Echo protocol, component framework must route the fuchsia.examples.Echo capability from the server to the client. For this tutorial, a realm component is provided to declare the appropriate capabilities and routes.

  1. Configure your build to include the provided package that includes the echo realm, server, and client:

    fx set core.qemu-x64 --with //examples/fidl/rust:echo-rust-client-sync
    
  2. Build the Fuchsia image:

    fx build
    
  3. Run the echo_realm component. This creates the client and server component instances and routes the capabilities:

    ffx component run fuchsia-pkg://fuchsia.com/echo-rust-client-sync#meta/echo_realm.cm
    
  4. Start the echo_client instance:

    ffx component bind /core/ffx-laboratory:echo_realm/echo_client
    

The server component starts when the client attempts to connect to the Echo protocol. You should see the following output using fx log:

[echo_server] INFO: Listening for incoming connections...
[echo_server] INFO: Received EchoString request for string "hello"
[echo_server] INFO: Response sent successfully
[echo_client] INFO: response: "hello"
[echo_server] INFO: Received SendString request for string "hi"
[echo_server] INFO: Event sent successfully
[echo_client] INFO: Received OnString event for string "hi"

Terminate the realm component to stop execution and clean up the component instances:

ffx component destroy /core/ffx-laboratory:echo_realm