Merge current master and fix ssz-fuzzing

beacon_node/rpc/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "rpc"
+version = "0.1.0"
+authors = ["Age Manning <Age@AgeManning.com>"]
+edition = "2018"
+
+[dependencies]
+bls = { path = "../../eth2/utils/bls" }
+beacon_chain = { path = "../beacon_chain" }
+
+protos = { path = "../../protos" }
+grpcio = { version = "0.4", default-features = false, features = ["protobuf-codec"] }
+protobuf = "2.0.2"
+clap = "2.32.0"
+db = { path = "../db" }
+dirs = "1.0.3"
+futures = "0.1.23"
+slog = "^2.2.3"
+slot_clock = { path = "../../eth2/utils/slot_clock" }
+slog-term = "^2.4.0"
+slog-async = "^2.3.0"
+types = { path = "../../eth2/types" }
+ssz = { path = "../../eth2/utils/ssz" }

beacon_node/rpc/src/beacon_block.rs

@@ -0,0 +1,57 @@
+use futures::Future;
+use grpcio::{RpcContext, UnarySink};
+use protos::services::{
+    BeaconBlock as BeaconBlockProto, ProduceBeaconBlockRequest, ProduceBeaconBlockResponse,
+    PublishBeaconBlockRequest, PublishBeaconBlockResponse,
+};
+use protos::services_grpc::BeaconBlockService;
+use slog::Logger;
+
+#[derive(Clone)]
+pub struct BeaconBlockServiceInstance {
+    pub log: Logger,
+}
+
+impl BeaconBlockService for BeaconBlockServiceInstance {
+    /// Produce a `BeaconBlock` for signing by a validator.
+    fn produce_beacon_block(
+        &mut self,
+        ctx: RpcContext,
+        req: ProduceBeaconBlockRequest,
+        sink: UnarySink<ProduceBeaconBlockResponse>,
+    ) {
+        println!("producing at slot {}", req.get_slot());
+
+        // TODO: build a legit block.
+        let mut block = BeaconBlockProto::new();
+        block.set_slot(req.get_slot());
+        block.set_block_root(b"cats".to_vec());
+
+        let mut resp = ProduceBeaconBlockResponse::new();
+        resp.set_block(block);
+
+        let f = sink
+            .success(resp)
+            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+
+    /// Accept some fully-formed `BeaconBlock`, process and publish it.
+    fn publish_beacon_block(
+        &mut self,
+        ctx: RpcContext,
+        req: PublishBeaconBlockRequest,
+        sink: UnarySink<PublishBeaconBlockResponse>,
+    ) {
+        println!("publishing {:?}", req.get_block());
+
+        // TODO: actually process the block.
+        let mut resp = PublishBeaconBlockResponse::new();
+        resp.set_success(true);
+
+        let f = sink
+            .success(resp)
+            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+}

beacon_node/rpc/src/config.rs

@@ -0,0 +1,22 @@
+use std::net::Ipv4Addr;
+
+/// RPC Configuration
+#[derive(Debug, Clone)]
+pub struct Config {
+    /// Enable the RPC server.
+    pub enabled: bool,
+    /// The IPv4 address the RPC will listen on.
+    pub listen_address: Ipv4Addr,
+    /// The port the RPC will listen on.
+    pub port: u16,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Config {
+            enabled: false, // rpc disabled by default
+            listen_address: Ipv4Addr::new(127, 0, 0, 1),
+            port: 5051,
+        }
+    }
+}

beacon_node/rpc/src/lib.rs

@@ -0,0 +1,38 @@
+mod beacon_block;
+pub mod config;
+mod validator;
+
+use self::beacon_block::BeaconBlockServiceInstance;
+use self::validator::ValidatorServiceInstance;
+pub use config::Config as RPCConfig;
+use grpcio::{Environment, Server, ServerBuilder};
+use protos::services_grpc::{create_beacon_block_service, create_validator_service};
+use std::sync::Arc;
+
+use slog::{info, o};
+
+pub fn start_server(config: &RPCConfig, log: &slog::Logger) -> Server {
+    let log = log.new(o!("Service"=>"RPC"));
+    let env = Arc::new(Environment::new(1));
+
+    let beacon_block_service = {
+        let instance = BeaconBlockServiceInstance { log: log.clone() };
+        create_beacon_block_service(instance)
+    };
+    let validator_service = {
+        let instance = ValidatorServiceInstance { log: log.clone() };
+        create_validator_service(instance)
+    };
+
+    let mut server = ServerBuilder::new(env)
+        .register_service(beacon_block_service)
+        .register_service(validator_service)
+        .bind(config.listen_address.to_string(), config.port)
+        .build()
+        .unwrap();
+    server.start();
+    for &(ref host, port) in server.bind_addrs() {
+        info!(log, "gRPC listening on {}:{}", host, port);
+    }
+    server
+}

beacon_node/rpc/src/validator.rs

@@ -0,0 +1,64 @@
+use bls::PublicKey;
+use futures::Future;
+use grpcio::{RpcContext, RpcStatus, RpcStatusCode, UnarySink};
+use protos::services::{
+    IndexResponse, ProposeBlockSlotRequest, ProposeBlockSlotResponse, PublicKey as PublicKeyRequest,
+};
+use protos::services_grpc::ValidatorService;
+use slog::{debug, Logger};
+use ssz::decode;
+
+#[derive(Clone)]
+pub struct ValidatorServiceInstance {
+    pub log: Logger,
+}
+
+impl ValidatorService for ValidatorServiceInstance {
+    fn validator_index(
+        &mut self,
+        ctx: RpcContext,
+        req: PublicKeyRequest,
+        sink: UnarySink<IndexResponse>,
+    ) {
+        if let Ok(public_key) = decode::<PublicKey>(req.get_public_key()) {
+            debug!(self.log, "RPC request"; "endpoint" => "ValidatorIndex", "public_key" => public_key.concatenated_hex_id());
+
+            let mut resp = IndexResponse::new();
+
+            // TODO: return a legit value.
+            resp.set_index(1);
+
+            let f = sink
+                .success(resp)
+                .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+            ctx.spawn(f)
+        } else {
+            let f = sink
+                .fail(RpcStatus::new(
+                    RpcStatusCode::InvalidArgument,
+                    Some("Invalid public_key".to_string()),
+                ))
+                .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+            ctx.spawn(f)
+        }
+    }
+
+    fn propose_block_slot(
+        &mut self,
+        ctx: RpcContext,
+        req: ProposeBlockSlotRequest,
+        sink: UnarySink<ProposeBlockSlotResponse>,
+    ) {
+        debug!(self.log, "RPC request"; "endpoint" => "ProposeBlockSlot", "epoch" => req.get_epoch(), "validator_index" => req.get_validator_index());
+
+        let mut resp = ProposeBlockSlotResponse::new();
+
+        // TODO: return a legit value.
+        resp.set_slot(1);
+
+        let f = sink
+            .success(resp)
+            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+}