RPC Update. WIP

beacon_node/eth2-libp2p/src/rpc/codec/base.rs

@@ -0,0 +1,140 @@
+//! This handles the various supported encoding mechanism for the Eth 2.0 RPC.
+
+use crate::rpc::{ErrorMessage, RPCErrorResponse, RPCRequest, RPCResponse};
+use bytes::BufMut;
+use bytes::BytesMut;
+use tokio::codec::{Decoder, Encoder};
+
+pub(crate) trait OutboundCodec: Encoder + Decoder {
+    type ErrorType;
+
+    fn decode_error(
+        &mut self,
+        src: &mut BytesMut,
+    ) -> Result<Option<Self::ErrorType>, <Self as Decoder>::Error>;
+}
+
+pub(crate) struct BaseInboundCodec<TCodec>
+where
+    TCodec: Encoder + Decoder,
+{
+    /// Inner codec for handling various encodings
+    inner: TCodec,
+}
+
+impl<TCodec> BaseInboundCodec<TCodec>
+where
+    TCodec: Encoder + Decoder,
+{
+    pub fn new(codec: TCodec) -> Self {
+        BaseInboundCodec { inner: codec }
+    }
+}
+
+pub(crate) struct BaseOutboundCodec<TOutboundCodec>
+where
+    TOutboundCodec: OutboundCodec,
+{
+    /// Inner codec for handling various encodings
+    inner: TOutboundCodec,
+    /// Optimisation for decoding. True if the response code has been read and we are awaiting a
+    /// response.
+    response_code: Option<u8>,
+}
+
+impl<TOutboundCodec> BaseOutboundCodec<TOutboundCodec>
+where
+    TOutboundCodec: OutboundCodec,
+{
+    pub fn new(codec: TOutboundCodec) -> Self {
+        BaseOutboundCodec {
+            inner: codec,
+            response_code: None,
+        }
+    }
+}
+
+impl<TCodec> Encoder for BaseInboundCodec<TCodec>
+where
+    TCodec: Decoder + Encoder<Item = RPCErrorResponse>,
+{
+    type Item = RPCErrorResponse;
+    type Error = <TCodec as Encoder>::Error;
+
+    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        dst.clear();
+        dst.reserve(1);
+        dst.put_u8(item.as_u8());
+        return self.inner.encode(item, dst);
+    }
+}
+
+impl<TCodec> Decoder for BaseInboundCodec<TCodec>
+where
+    TCodec: Encoder + Decoder<Item = RPCRequest>,
+{
+    type Item = RPCRequest;
+    type Error = <TCodec as Decoder>::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        self.inner.decode(src)
+    }
+}
+
+impl<TCodec> Encoder for BaseOutboundCodec<TCodec>
+where
+    TCodec: OutboundCodec + Encoder<Item = RPCRequest>,
+{
+    type Item = RPCRequest;
+    type Error = <TCodec as Encoder>::Error;
+
+    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        self.inner.encode(item, dst)
+    }
+}
+
+impl<TCodec> Decoder for BaseOutboundCodec<TCodec>
+where
+    TCodec: OutboundCodec<ErrorType = ErrorMessage> + Decoder<Item = RPCResponse>,
+{
+    type Item = RPCErrorResponse;
+    type Error = <TCodec as Decoder>::Error;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        let response_code = {
+            if let Some(resp_code) = self.response_code {
+                resp_code
+            } else {
+                // buffer should not be empty
+                debug_assert!(!src.is_empty());
+
+                let resp_byte = src.split_to(1);
+                let resp_code_byte = [0; 1];
+                resp_code_byte.copy_from_slice(&resp_byte);
+
+                let resp_code = u8::from_be_bytes(resp_code_byte);
+
+                if let Some(response) = RPCErrorResponse::internal_data(resp_code) {
+                    self.response_code = None;
+                    return Ok(Some(response));
+                }
+                self.response_code = Some(resp_code);
+                resp_code
+            }
+        };
+
+        if RPCErrorResponse::is_response(response_code) {
+            // decode an actual response
+            return self
+                .inner
+                .decode(src)
+                .map(|r| r.map(|resp| RPCErrorResponse::Success(resp)));
+        } else {
+            // decode an error
+            return self
+                .inner
+                .decode_error(src)
+                .map(|r| r.map(|resp| RPCErrorResponse::from_error(response_code, resp)));
+        }
+    }
+}

beacon_node/eth2-libp2p/src/rpc/codec/mod.rs

@@ -0,0 +1,2 @@
+pub(crate) mod base;
+pub(crate) mod ssz;

beacon_node/eth2-libp2p/src/rpc/codec/ssz.rs

@@ -0,0 +1,239 @@
+use crate::rpc::methods::*;
+use crate::rpc::{
+    codec::base::OutboundCodec,
+    protocol::{ProtocolId, RPCError},
+};
+use crate::rpc::{ErrorMessage, RPCErrorResponse, RPCRequest, RPCResponse};
+use bytes::{Bytes, BytesMut};
+use ssz::{Decode, Encode};
+use tokio::codec::{Decoder, Encoder};
+use unsigned_varint::codec::UviBytes;
+
+/* Inbound Codec */
+
+pub struct SSZInboundCodec {
+    inner: UviBytes,
+    protocol: ProtocolId,
+}
+
+impl SSZInboundCodec {
+    pub fn new(protocol: ProtocolId, max_packet_size: usize) -> Self {
+        let uvi_codec = UviBytes::default();
+        uvi_codec.set_max_len(max_packet_size);
+
+        // this encoding only applies to ssz.
+        debug_assert!(protocol.encoding.as_str() == "ssz");
+
+        SSZInboundCodec {
+            inner: uvi_codec,
+            protocol,
+        }
+    }
+}
+
+// Encoder for inbound
+impl Encoder for SSZInboundCodec {
+    type Item = RPCErrorResponse;
+    type Error = RPCError;
+
+    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        let bytes = match item {
+            RPCErrorResponse::Success(resp) => {
+                match resp {
+                    RPCResponse::Hello(res) => res.as_ssz_bytes(),
+                    RPCResponse::Goodbye => unreachable!(),
+                    RPCResponse::BeaconBlockRoots(res) => res.as_ssz_bytes(),
+                    RPCResponse::BeaconBlockHeaders(res) => res.headers, // already raw bytes
+                    RPCResponse::BeaconBlockBodies(res) => res.block_bodies, // already raw bytes
+                    RPCResponse::BeaconChainState(res) => res.as_ssz_bytes(),
+                }
+            }
+            RPCErrorResponse::EncodingError => vec![],
+            RPCErrorResponse::InvalidRequest(err) => err.as_ssz_bytes(),
+            RPCErrorResponse::ServerError(err) => err.as_ssz_bytes(),
+            RPCErrorResponse::Unknown(err) => err.as_ssz_bytes(),
+        };
+
+        if !bytes.is_empty() {
+            // length-prefix and return
+            return self
+                .inner
+                .encode(Bytes::from(bytes), dst)
+                .map_err(RPCError::from);
+        }
+        Ok(())
+    }
+}
+
+// Decoder for inbound
+impl Decoder for SSZInboundCodec {
+    type Item = RPCRequest;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        match self.inner.decode(src).map_err(RPCError::from) {
+            Ok(Some(packet)) => match self.protocol.message_name.as_str() {
+                "hello" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCRequest::Hello(HelloMessage::from_ssz_bytes(
+                        &packet,
+                    )?))),
+                    _ => Err(RPCError::InvalidProtocol("Unknown HELLO version")),
+                },
+                "goodbye" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCRequest::Goodbye(Goodbye::from_ssz_bytes(&packet)?))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown GOODBYE version.as_str()",
+                    )),
+                },
+                "beacon_block_roots" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCRequest::BeaconBlockRoots(
+                        BeaconBlockRootsRequest::from_ssz_bytes(&packet)?,
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_BLOCK_ROOTS version.",
+                    )),
+                },
+                "beacon_block_headers" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCRequest::BeaconBlockHeaders(
+                        BeaconBlockHeadersRequest::from_ssz_bytes(&packet)?,
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_BLOCK_HEADERS version.",
+                    )),
+                },
+                "beacon_block_bodies" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCRequest::BeaconBlockBodies(
+                        BeaconBlockBodiesRequest::from_ssz_bytes(&packet)?,
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_BLOCK_BODIES version.",
+                    )),
+                },
+                "beacon_chain_state" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCRequest::BeaconChainState(
+                        BeaconChainStateRequest::from_ssz_bytes(&packet)?,
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_CHAIN_STATE version.",
+                    )),
+                },
+            },
+            Ok(None) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+/* Outbound Codec */
+
+pub struct SSZOutboundCodec {
+    inner: UviBytes,
+    protocol: ProtocolId,
+}
+
+impl SSZOutboundCodec {
+    pub fn new(protocol: ProtocolId, max_packet_size: usize) -> Self {
+        let uvi_codec = UviBytes::default();
+        uvi_codec.set_max_len(max_packet_size);
+
+        // this encoding only applies to ssz.
+        debug_assert!(protocol.encoding.as_str() == "ssz");
+
+        SSZOutboundCodec {
+            inner: uvi_codec,
+            protocol,
+        }
+    }
+}
+
+// Encoder for outbound
+impl Encoder for SSZOutboundCodec {
+    type Item = RPCRequest;
+    type Error = RPCError;
+
+    fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
+        let bytes = match item {
+            RPCRequest::Hello(req) => req.as_ssz_bytes(),
+            RPCRequest::Goodbye(req) => req.as_ssz_bytes(),
+            RPCRequest::BeaconBlockRoots(req) => req.as_ssz_bytes(),
+            RPCRequest::BeaconBlockHeaders(req) => req.as_ssz_bytes(),
+            RPCRequest::BeaconBlockBodies(req) => req.as_ssz_bytes(),
+            RPCRequest::BeaconChainState(req) => req.as_ssz_bytes(),
+        };
+        // length-prefix
+        self.inner
+            .encode(bytes::Bytes::from(bytes), dst)
+            .map_err(RPCError::from)
+    }
+}
+
+// Decoder for outbound
+impl Decoder for SSZOutboundCodec {
+    type Item = RPCResponse;
+    type Error = RPCError;
+
+    fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
+        match self.inner.decode(src).map_err(RPCError::from) {
+            Ok(Some(packet)) => match self.protocol.message_name.as_str() {
+                "hello" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCResponse::Hello(HelloMessage::from_ssz_bytes(
+                        &packet,
+                    )?))),
+                    _ => Err(RPCError::InvalidProtocol("Unknown HELLO version.")),
+                },
+                "goodbye" => Err(RPCError::InvalidProtocol("GOODBYE doesn't have a response")),
+                "beacon_block_roots" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCResponse::BeaconBlockRoots(
+                        BeaconBlockRootsResponse::from_ssz_bytes(&packet)?,
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_BLOCK_ROOTS version.",
+                    )),
+                },
+                "beacon_block_headers" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCResponse::BeaconBlockHeaders(
+                        BeaconBlockHeadersResponse {
+                            headers: packet.to_vec(),
+                        },
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_BLOCK_HEADERS version.",
+                    )),
+                },
+                "beacon_block_bodies" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCResponse::BeaconBlockBodies(
+                        BeaconBlockBodiesResponse {
+                            block_bodies: packet.to_vec(),
+                        },
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_BLOCK_BODIES version.",
+                    )),
+                },
+                "beacon_chain_state" => match self.protocol.version.as_str() {
+                    "1.0.0" => Ok(Some(RPCResponse::BeaconChainState(
+                        BeaconChainStateResponse::from_ssz_bytes(&packet)?,
+                    ))),
+                    _ => Err(RPCError::InvalidProtocol(
+                        "Unknown BEACON_CHAIN_STATE version.",
+                    )),
+                },
+                _ => Err(RPCError::InvalidProtocol("Unknown method")),
+            },
+            Ok(None) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+impl OutboundCodec for SSZOutboundCodec {
+    type ErrorType = ErrorMessage;
+
+    fn decode_error(&mut self, src: &mut BytesMut) -> Result<Option<Self::ErrorType>, RPCError> {
+        match self.inner.decode(src).map_err(RPCError::from) {
+            Ok(Some(packet)) => Ok(Some(ErrorMessage::from_ssz_bytes(&packet)?)),
+            Ok(None) => Ok(None),
+            Err(e) => Err(e),
+        }
+    }
+}