fidl_next_bind/

server.rs

// Copyright 2024 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use core::future::Future;
use core::marker::PhantomData;
use core::ops::Deref;

use fidl_next_codec::Encode;
use fidl_next_protocol::{self as protocol, ProtocolError, ServerHandler, Transport};

use crate::{Method, Protocol, SendFuture, ServerEnd};

/// A strongly typed server sender.
#[repr(transparent)]
pub struct ServerSender<
    P,
    #[cfg(feature = "fuchsia")] T: Transport = zx::Channel,
    #[cfg(not(feature = "fuchsia"))] T: Transport,
> {
    sender: protocol::ServerSender<T>,
    _protocol: PhantomData<P>,
}

unsafe impl<P, T> Send for ServerSender<P, T>
where
    protocol::ServerSender<T>: Send,
    T: Transport,
{
}

impl<P, T: Transport> ServerSender<P, T> {
    /// Wraps an untyped sender reference, returning a typed sender reference.
    pub fn wrap_untyped(client: &protocol::ServerSender<T>) -> &Self {
        unsafe { &*(client as *const protocol::ServerSender<T>).cast() }
    }

    /// Closes the channel from the server end.
    pub fn close(&self) {
        self.sender.close();
    }

    /// Closes the channel from the server end without sending an epitaph.
    pub fn close_with_epitaph(&self, epitaph: i32) {
        self.sender.close_with_epitaph(epitaph);
    }
}

impl<P, T: Transport> Clone for ServerSender<P, T> {
    fn clone(&self) -> Self {
        Self { sender: self.sender.clone(), _protocol: PhantomData }
    }
}

impl<P: Protocol<T>, T: Transport> Deref for ServerSender<P, T> {
    type Target = P::ServerSender;

    fn deref(&self) -> &Self::Target {
        // SAFETY: `P::ServerSender` is a `#[repr(transparent)]` wrapper around `ServerSender<T>`.
        unsafe { &*(self as *const Self).cast::<P::ServerSender>() }
    }
}

/// A protocol which dispatches incoming server messages to a handler.
pub trait DispatchServerMessage<
    H,
    #[cfg(feature = "fuchsia")] T: Transport = zx::Channel,
    #[cfg(not(feature = "fuchsia"))] T: Transport,
>: Sized + 'static
{
    /// Handles a received server one-way message with the given handler.
    fn on_one_way(
        handler: &mut H,
        sender: &ServerSender<Self, T>,
        ordinal: u64,
        buffer: T::RecvBuffer,
    ) -> impl Future<Output = ()> + Send;

    /// Handles a received server two-way message with the given handler.
    fn on_two_way(
        handler: &mut H,
        sender: &ServerSender<Self, T>,
        ordinal: u64,
        buffer: T::RecvBuffer,
        responder: protocol::Responder,
    ) -> impl Future<Output = ()> + Send;
}

/// An adapter for a server protocol handler.
pub struct ServerHandlerAdapter<P, H> {
    handler: H,
    _protocol: PhantomData<P>,
}

unsafe impl<P, H> Send for ServerHandlerAdapter<P, H> where H: Send {}

impl<P, H> ServerHandlerAdapter<P, H> {
    /// Creates a new protocol server handler from a supported handler.
    pub fn from_untyped(handler: H) -> Self {
        Self { handler, _protocol: PhantomData }
    }
}

impl<P, H, T> ServerHandler<T> for ServerHandlerAdapter<P, H>
where
    P: DispatchServerMessage<H, T>,
    T: Transport,
{
    fn on_one_way(
        &mut self,
        server: &protocol::ServerSender<T>,
        ordinal: u64,
        buffer: T::RecvBuffer,
    ) -> impl Future<Output = ()> + Send {
        P::on_one_way(&mut self.handler, ServerSender::wrap_untyped(server), ordinal, buffer)
    }

    fn on_two_way(
        &mut self,
        server: &protocol::ServerSender<T>,
        ordinal: u64,
        buffer: <T as Transport>::RecvBuffer,
        responder: protocol::Responder,
    ) -> impl Future<Output = ()> + Send {
        P::on_two_way(
            &mut self.handler,
            ServerSender::wrap_untyped(server),
            ordinal,
            buffer,
            responder,
        )
    }
}

/// A strongly typed server.
pub struct Server<
    P,
    #[cfg(feature = "fuchsia")] T: Transport = zx::Channel,
    #[cfg(not(feature = "fuchsia"))] T: Transport,
> {
    server: protocol::Server<T>,
    _protocol: PhantomData<P>,
}

unsafe impl<P, T> Send for Server<P, T>
where
    protocol::Server<T>: Send,
    T: Transport,
{
}

impl<P, T: Transport> Server<P, T> {
    /// Creates a new server from a server end.
    pub fn new(server_end: ServerEnd<P, T>) -> Self {
        Self { server: protocol::Server::new(server_end.into_untyped()), _protocol: PhantomData }
    }

    /// Returns the sender for the server.
    pub fn sender(&self) -> &ServerSender<P, T> {
        ServerSender::wrap_untyped(self.server.sender())
    }

    /// Creates a new server from an untyped server.
    pub fn from_untyped(server: protocol::Server<T>) -> Self {
        Self { server, _protocol: PhantomData }
    }

    /// Runs the server with the provided handler.
    pub async fn run<H>(self, handler: H) -> Result<H, ProtocolError<T::Error>>
    where
        P: DispatchServerMessage<H, T>,
        H: Send,
    {
        self.server
            .run(ServerHandlerAdapter { handler, _protocol: PhantomData::<P> })
            .await
            .map(|adapter| adapter.handler)
    }
}

/// A strongly typed `Responder`.
#[must_use]
pub struct Responder<M> {
    responder: protocol::Responder,
    _method: PhantomData<M>,
}

impl<M> Responder<M> {
    /// Creates a new responder.
    pub fn from_untyped(responder: protocol::Responder) -> Self {
        Self { responder, _method: PhantomData }
    }

    /// Responds to the client.
    pub fn respond<'s, P, T, R>(
        self,
        sender: &'s ServerSender<P, T>,
        response: R,
    ) -> SendFuture<'s, T>
    where
        T: Transport,
        M: Method<Protocol = P>,
        R: Encode<T::SendBuffer, Encoded = M::Response>,
    {
        SendFuture::from_untyped(sender.sender.send_response(self.responder, M::ORDINAL, response))
    }
}