overnet_core/proxy/handle/
event_pair.rs

Help
1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use super::signals::Collector;
6use super::{
7    IntoProxied, Message, Proxyable, ProxyableRW, ReadValue, RouterHolder, Serializer, IO,
8};
9use crate::peer::PeerConnRef;
10use anyhow::{format_err, Error};
11use fidl::{AsHandleRef, HandleBased, Peered, Signals};
12use std::task::{Context, Poll};
13use zx_status;
14
15pub(crate) struct EventPair {
16    event_pair: fidl::EventPair,
17}
18
19impl std::fmt::Debug for EventPair {
20    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21        self.event_pair.fmt(f)
22    }
23}
24
25impl Proxyable for EventPair {
26    type Message = EventPairMessage;
27
28    fn from_fidl_handle(hdl: fidl::Handle) -> Result<Self, Error> {
29        Ok(fidl::EventPair::from_handle(hdl).into_proxied()?)
30    }
31
32    fn into_fidl_handle(self) -> Result<fidl::Handle, Error> {
33        Ok(self.event_pair.into_handle())
34    }
35
36    fn signal_peer(&self, clear: Signals, set: Signals) -> Result<(), Error> {
37        self.event_pair.signal_peer(clear, set).map_err(Into::into)
38    }
39}
40
41impl<'a> ProxyableRW<'a> for EventPair {
42    type Reader = EventPairReader<'a>;
43    type Writer = EventPairWriter;
44}
45
46impl IntoProxied for fidl::EventPair {
47    type Proxied = EventPair;
48    fn into_proxied(self) -> Result<EventPair, Error> {
49        Ok(EventPair { event_pair: self })
50    }
51}
52
53#[derive(Debug, Default, PartialEq)]
54pub(crate) struct EventPairMessage;
55
56impl Message for EventPairMessage {
57    type Parser = EventPairParser;
58    type Serializer = EventPairSerializer;
59}
60
61pub(crate) struct EventPairReader<'a> {
62    collector: Collector<'a>,
63}
64
65impl<'a> IO<'a> for EventPairReader<'a> {
66    type Proxyable = EventPair;
67    type Output = ReadValue;
68    fn new() -> Self {
69        EventPairReader { collector: Default::default() }
70    }
71    fn poll_io(
72        &mut self,
73        _: &mut EventPairMessage,
74        event_pair: &'a EventPair,
75        fut_ctx: &mut Context<'_>,
76    ) -> Poll<Result<ReadValue, zx_status::Status>> {
77        // There's no such thing as an event pair message, so we just pretend to be waiting forever
78        let read_result = Poll::Pending;
79        self.collector.after_read(fut_ctx, event_pair.event_pair.as_handle_ref(), read_result, true)
80    }
81}
82
83pub(crate) struct EventPairWriter;
84
85impl IO<'_> for EventPairWriter {
86    type Proxyable = EventPair;
87    type Output = ();
88    fn new() -> Self {
89        EventPairWriter
90    }
91    fn poll_io(
92        &mut self,
93        _: &mut EventPairMessage,
94        _: &EventPair,
95        _: &mut Context<'_>,
96    ) -> Poll<Result<(), zx_status::Status>> {
97        // We always fail to parse event pair messages, therefore we can never write one to an object
98        unreachable!()
99    }
100}
101
102#[derive(Debug)]
103pub(crate) struct EventPairSerializer;
104
105impl Serializer for EventPairSerializer {
106    type Message = EventPairMessage;
107    fn new() -> EventPairSerializer {
108        EventPairSerializer
109    }
110    fn poll_ser(
111        &mut self,
112        _: &mut Self::Message,
113        _: &mut Vec<u8>,
114        _: PeerConnRef<'_>,
115        _: &mut RouterHolder<'_>,
116        _: &mut Context<'_>,
117    ) -> Poll<Result<(), Error>> {
118        // Reading from the event pair is always pending, therefore we can never serialize a message
119        unreachable!()
120    }
121}
122
123#[derive(Debug)]
124pub(crate) struct EventPairParser;
125
126impl Serializer for EventPairParser {
127    type Message = EventPairMessage;
128    fn new() -> EventPairParser {
129        EventPairParser
130    }
131    fn poll_ser(
132        &mut self,
133        _: &mut Self::Message,
134        _: &mut Vec<u8>,
135        _: PeerConnRef<'_>,
136        _: &mut RouterHolder<'_>,
137        _: &mut Context<'_>,
138    ) -> Poll<Result<(), Error>> {
139        Poll::Ready(Err(format_err!("Event pairs do not exchange message payloads")))
140    }
141}
overnet_core/proxy/handle/event_pair.rs

overnet_core/proxy/handle/
event_pair.rs
