Split out validator index gRPC call

beacon_node/src/rpc/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("cats".as_bytes().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/src/rpc/mod.rs

@@ -1,73 +1,30 @@
+mod beacon_block;
+mod validator;
+
+use self::beacon_block::BeaconBlockServiceInstance;
+use self::validator::ValidatorServiceInstance;
+use grpcio::{Environment, Server, ServerBuilder};
+use protos::services_grpc::{create_beacon_block_service, create_validator_service};
 use std::sync::Arc;
 
-use futures::Future;
-use grpcio::{Environment, RpcContext, Server, ServerBuilder, UnarySink};
-
-use protos::services::{
-    BeaconBlock as BeaconBlockProto, ProduceBeaconBlockRequest, ProduceBeaconBlockResponse,
-    PublishBeaconBlockRequest, PublishBeaconBlockResponse,
-};
-use protos::services_grpc::{create_beacon_block_service, BeaconBlockService};
-
 use slog::{info, Logger};
 
-#[derive(Clone)]
-struct BeaconBlockServiceInstance {
-    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("cats".as_bytes().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)
-    }
-}
-
 pub fn start_server(log: Logger) -> Server {
     let log_clone = log.clone();
-
     let env = Arc::new(Environment::new(1));
-    let instance = BeaconBlockServiceInstance { log };
-    let service = create_beacon_block_service(instance);
+
+    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(service)
+        .register_service(beacon_block_service)
+        .register_service(validator_service)
         .bind("127.0.0.1", 50_051)
         .build()
         .unwrap();

beacon_node/src/rpc/validator.rs

@@ -0,0 +1,52 @@
+use futures::Future;
+use grpcio::{RpcContext, UnarySink};
+use protos::services::{
+    IndexResponse, ProposeBlockSlotRequest, ProposeBlockSlotResponse, PublicKey as PublicKeyRequest,
+};
+use protos::services_grpc::ValidatorService;
+use slog::{debug, Logger};
+
+#[derive(Clone)]
+pub struct ValidatorServiceInstance {
+    pub log: Logger,
+}
+
+impl ValidatorService for ValidatorServiceInstance {
+    fn validator_index(
+        &mut self,
+        ctx: RpcContext,
+        req: PublicKeyRequest,
+        sink: UnarySink<IndexResponse>,
+    ) {
+        debug!(self.log, "RPC got ValidatorIndex"; "public_key" => format!("{:x?}", req.get_public_key()));
+
+        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)
+    }
+
+    fn propose_block_slot(
+        &mut self,
+        ctx: RpcContext,
+        req: ProposeBlockSlotRequest,
+        sink: UnarySink<ProposeBlockSlotResponse>,
+    ) {
+        debug!(self.log, "RPC got 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)
+    }
+}