Add rs/bitcoin/service to the protobuf lint checker

rumenov · rumenov · commit 38819820359a · 2022-04-20T12:23:54.000Z
diff --git a/buf.yaml b/buf.yaml
@@ -1,6 +1,7 @@
 version: v1beta1
 build:
   roots:
+    - rs/bitcoin/service/proto
     - rs/crypto/internal/crypto_service_provider/proto
     - rs/nns/common/proto
     - rs/nns/gtc/proto Temporarily removed because a PR was reverted and then un-reverted
diff --git a/rs/Cargo.lock b/rs/Cargo.lock
diff --git a/rs/Cargo.toml b/rs/Cargo.toml
@@ -5,7 +5,7 @@ members = [
   "artifact_pool",
   "async_utils",
   "bitcoin/adapter",
-  "bitcoin/adapter_service",
+  "bitcoin/service",
   "bitcoin/canister",
   "bitcoin/consensus",
   "bitcoin/validation",
diff --git a/rs/bitcoin/adapter/Cargo.toml b/rs/bitcoin/adapter/Cargo.toml
@@ -12,7 +12,7 @@ futures = "0.3.17"
 hashlink = "0.8.0"
 hex = "0.4.2"
 ic-async-utils = { path = "../../async_utils" }
-ic-btc-adapter-service = { path = "../adapter_service" }
+ic-btc-service = { path = "../service" }
 ic-btc-validation = { path = "../validation" }
 ic-config = { path = "../../config" }
 ic-logger = { path = "../../monitoring/logger" }
diff --git a/rs/bitcoin/adapter/src/rpc_server.rs b/rs/bitcoin/adapter/src/rpc_server.rs
@@ -6,25 +6,25 @@ use bitcoin::{consensus::Encodable, hashes::Hash, BlockHash};
 use ic_async_utils::{
     ensure_single_systemd_socket, incoming_from_first_systemd_socket, incoming_from_path,
 };
-use ic_btc_adapter_service::{
-    btc_adapter_server::{BtcAdapter, BtcAdapterServer},
-    GetSuccessorsRpcRequest, GetSuccessorsRpcResponse, SendTransactionRpcRequest,
-    SendTransactionRpcResponse,
+use ic_btc_service::{
+    btc_service_server::{BtcService, BtcServiceServer},
+    BtcServiceGetSuccessorsRequest, BtcServiceGetSuccessorsResponse,
+    BtcServiceSendTransactionRequest, BtcServiceSendTransactionResponse,
 };
 use std::convert::{TryFrom, TryInto};
 use tokio::sync::mpsc::UnboundedSender;
 use tonic::{transport::Server, Request, Response, Status};
 
-struct BtcAdapterImpl {
+struct BtcServiceImpl {
     adapter_state: AdapterState,
     get_successors_handler: GetSuccessorsHandler,
     transaction_manager_tx: UnboundedSender<TransactionManagerRequest>,
 }
 
-impl TryFrom<GetSuccessorsRpcRequest> for GetSuccessorsRequest {
+impl TryFrom<BtcServiceGetSuccessorsRequest> for GetSuccessorsRequest {
     type Error = Status;
 
-    fn try_from(request: GetSuccessorsRpcRequest) -> Result<Self, Self::Error> {
+    fn try_from(request: BtcServiceGetSuccessorsRequest) -> Result<Self, Self::Error> {
         let anchor = BlockHash::from_slice(request.anchor.as_slice())
             .map_err(|_| Status::internal("Failed to parse anchor hash!"))?;
 
@@ -44,7 +44,7 @@ impl TryFrom<GetSuccessorsRpcRequest> for GetSuccessorsRequest {
     }
 }
 
-impl TryFrom<GetSuccessorsResponse> for GetSuccessorsRpcResponse {
+impl TryFrom<GetSuccessorsResponse> for BtcServiceGetSuccessorsResponse {
     type Error = Status;
     fn try_from(response: GetSuccessorsResponse) -> Result<Self, Self::Error> {
         let mut blocks = vec![];
@@ -64,19 +64,19 @@ impl TryFrom<GetSuccessorsResponse> for GetSuccessorsRpcResponse {
                 .map_err(|_| Status::internal("Failed to encode block header!"))?;
             next.push(encoded_block_header);
         }
-        Ok(GetSuccessorsRpcResponse { blocks, next })
+        Ok(BtcServiceGetSuccessorsResponse { blocks, next })
     }
 }
 
 #[tonic::async_trait]
-impl BtcAdapter for BtcAdapterImpl {
+impl BtcService for BtcServiceImpl {
     async fn get_successors(
         &self,
-        request: Request<GetSuccessorsRpcRequest>,
-    ) -> Result<Response<GetSuccessorsRpcResponse>, Status> {
+        request: Request<BtcServiceGetSuccessorsRequest>,
+    ) -> Result<Response<BtcServiceGetSuccessorsResponse>, Status> {
         self.adapter_state.received_now();
         let request = request.into_inner().try_into()?;
-        match GetSuccessorsRpcResponse::try_from(
+        match BtcServiceGetSuccessorsResponse::try_from(
             self.get_successors_handler.get_successors(request).await,
         ) {
             Ok(res) => Ok(Response::new(res)),
@@ -86,16 +86,16 @@ impl BtcAdapter for BtcAdapterImpl {
 
     async fn send_transaction(
         &self,
-        request: Request<SendTransactionRpcRequest>,
-    ) -> Result<Response<SendTransactionRpcResponse>, Status> {
+        request: Request<BtcServiceSendTransactionRequest>,
+    ) -> Result<Response<BtcServiceSendTransactionResponse>, Status> {
         self.adapter_state.received_now();
         let transaction = request.into_inner().transaction;
         self.transaction_manager_tx
             .send(TransactionManagerRequest::SendTransaction(transaction))
             .expect(
                 "Sending should not fail because we never close the receiving part of the channel.",
             );
-        Ok(Response::new(SendTransactionRpcResponse {}))
+        Ok(Response::new(BtcServiceSendTransactionResponse {}))
     }
 }
 
@@ -110,7 +110,7 @@ pub fn spawn_grpc_server(
     if config.incoming_source == IncomingSource::Systemd {
         ensure_single_systemd_socket();
     }
-    let btc_adapter_impl = BtcAdapterImpl {
+    let btc_adapter_impl = BtcServiceImpl {
         adapter_state,
         get_successors_handler,
         transaction_manager_tx,
@@ -119,14 +119,14 @@ pub fn spawn_grpc_server(
         match config.incoming_source {
             IncomingSource::Path(uds_path) => {
                 Server::builder()
-                    .add_service(BtcAdapterServer::new(btc_adapter_impl))
+                    .add_service(BtcServiceServer::new(btc_adapter_impl))
                     .serve_with_incoming(incoming_from_path(uds_path))
                     .await
                     .expect("gRPC server crashed");
             }
             IncomingSource::Systemd => {
                 Server::builder()
-                    .add_service(BtcAdapterServer::new(btc_adapter_impl))
+                    .add_service(BtcServiceServer::new(btc_adapter_impl))
                     .serve_with_incoming(incoming_from_first_systemd_socket())
                     .await
                     .expect("gRPC server crashed");
diff --git a/rs/bitcoin/adapter/src/stress_test.rs b/rs/bitcoin/adapter/src/stress_test.rs
@@ -2,8 +2,9 @@ use std::{convert::TryFrom, path::PathBuf, time::Duration};
 
 use bitcoin::{blockdata::constants::genesis_block, consensus::Decodable, Block, BlockHash};
 use clap::Parser;
-use ic_btc_adapter_service::{
-    btc_adapter_client::BtcAdapterClient, GetSuccessorsRpcRequest, GetSuccessorsRpcResponse,
+use ic_btc_service::{
+    btc_service_client::BtcServiceClient, BtcServiceGetSuccessorsRequest,
+    BtcServiceGetSuccessorsResponse,
 };
 use tokio::{
     net::UnixStream,
@@ -24,9 +25,9 @@ async fn setup_channel(uds_path: PathBuf) -> Channel {
         .expect("failed to connect to socket")
 }
 
-async fn setup_client(uds_path: PathBuf) -> BtcAdapterClient<Channel> {
+async fn setup_client(uds_path: PathBuf) -> BtcServiceClient<Channel> {
     let channel = setup_channel(uds_path).await;
-    BtcAdapterClient::new(channel)
+    BtcServiceClient::new(channel)
 }
 
 #[tokio::main]
@@ -49,17 +50,17 @@ async fn main() {
     let total_timer = Instant::now();
 
     loop {
-        let mut request = tonic::Request::new(GetSuccessorsRpcRequest {
+        let mut request = tonic::Request::new(BtcServiceGetSuccessorsRequest {
             processed_block_hashes: processed_block_hashes.iter().map(|h| h.to_vec()).collect(),
             anchor: current_anchor.to_vec(),
         });
         request.set_timeout(request_timeout_ms);
 
         let instant = Instant::now();
 
-        let response: Result<tonic::Response<GetSuccessorsRpcResponse>, tonic::Status> =
+        let response: Result<tonic::Response<BtcServiceGetSuccessorsResponse>, tonic::Status> =
             rpc_client.get_successors(request).await;
-        let inner: GetSuccessorsRpcResponse = match response {
+        let inner: BtcServiceGetSuccessorsResponse = match response {
             Ok(response) => response.into_inner(),
             Err(status) => match status.code() {
                 tonic::Code::Cancelled => continue,
diff --git a/rs/bitcoin/adapter_service/build.rs b/rs/bitcoin/adapter_service/build.rs
diff --git a/rs/bitcoin/adapter_service/src/lib.rs b/rs/bitcoin/adapter_service/src/lib.rs
diff --git a/rs/bitcoin/service/Cargo.toml b/rs/bitcoin/service/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "ic-btc-adapter-service"
+name = "ic-btc-service"
 version = "0.1.0"
 edition = "2021"
 
diff --git a/rs/bitcoin/service/build.rs b/rs/bitcoin/service/build.rs
@@ -0,0 +1,5 @@
+use std::io::Result;
+fn main() -> Result<()> {
+    tonic_build::configure().compile(&["proto/btc_service/v1/proto.proto"], &["proto/"])?;
+    Ok(())
+}
diff --git a/rs/bitcoin/service/proto/btc_service/v1/proto.proto b/rs/bitcoin/service/proto/btc_service/v1/proto.proto
@@ -1,8 +1,8 @@
 syntax = "proto3";
 
-package btc_adapter;
+package btc_service.v1;
 
-message GetSuccessorsRpcRequest {
+message BtcServiceGetSuccessorsRequest {
   // Used by the adapter to filter out previously sent blocks from its
   // `GetSuccessorsResponse`. 
   repeated bytes processed_block_hashes = 1;
@@ -12,7 +12,7 @@ message GetSuccessorsRpcRequest {
   bytes anchor = 2;
 }
 
-message GetSuccessorsRpcResponse {
+message BtcServiceGetSuccessorsResponse {
   // The blocks that the adapter has knowledge of based on the anchor and
   // processed block hashes provided in the `GetSuccessorsRequest`.
   repeated bytes blocks = 1;
@@ -21,13 +21,13 @@ message GetSuccessorsRpcResponse {
   repeated bytes next = 2;
 }
 
-message SendTransactionRpcRequest {
+message BtcServiceSendTransactionRequest {
   bytes transaction = 1;
 }
 
-message SendTransactionRpcResponse {};
+message BtcServiceSendTransactionResponse {};
 
-service BtcAdapter {
-    rpc GetSuccessors(GetSuccessorsRpcRequest) returns (GetSuccessorsRpcResponse);
-    rpc SendTransaction(SendTransactionRpcRequest) returns (SendTransactionRpcResponse);
+service BtcService {
+    rpc GetSuccessors(BtcServiceGetSuccessorsRequest) returns (BtcServiceGetSuccessorsResponse);
+    rpc SendTransaction(BtcServiceSendTransactionRequest) returns (BtcServiceSendTransactionResponse);
 }
diff --git a/rs/bitcoin/service/src/lib.rs b/rs/bitcoin/service/src/lib.rs
@@ -0,0 +1 @@
+tonic::include_proto!("btc_service.v1");
diff --git a/rs/replica/Cargo.toml b/rs/replica/Cargo.toml
@@ -9,7 +9,7 @@ base64 = "0.11.0"
 bitcoin = "0.27.1"
 clap = { version = "3.1.6", features = ["derive"] }
 hex = "0.4.2"
-ic-btc-adapter-service = { path = "../bitcoin/adapter_service" }
+ic-btc-service = { path = "../bitcoin/service" }
 ic-btc-types-internal = { path = "../bitcoin/types/internal" }
 ic-async-utils = { path = "../async_utils" }
 ic-btc-consensus = { path = "../bitcoin/consensus" }
diff --git a/rs/replica/src/setup_bitcoin_client.rs b/rs/replica/src/setup_bitcoin_client.rs
@@ -1,6 +1,7 @@
 use bitcoin::consensus::Decodable;
-use ic_btc_adapter_service::{
-    btc_adapter_client::BtcAdapterClient, GetSuccessorsRpcRequest, SendTransactionRpcRequest,
+use ic_btc_service::{
+    btc_service_client::BtcServiceClient, BtcServiceGetSuccessorsRequest,
+    BtcServiceSendTransactionRequest,
 };
 use ic_btc_types_internal::{
     BitcoinAdapterRequestWrapper, BitcoinAdapterResponseWrapper, Block as InternalBlock,
@@ -25,12 +26,12 @@ fn convert_tonic_error(status: tonic::Status) -> RpcError {
 
 struct BitcoinAdapterClientImpl {
     rt_handle: tokio::runtime::Handle,
-    client: BtcAdapterClient<Channel>,
+    client: BtcServiceClient<Channel>,
 }
 
 impl BitcoinAdapterClientImpl {
     fn new(rt_handle: tokio::runtime::Handle, channel: Channel) -> Self {
-        let client = BtcAdapterClient::new(channel);
+        let client = BtcServiceClient::new(channel);
         Self { rt_handle, client }
     }
 }
@@ -96,7 +97,7 @@ impl BitcoinAdapterClient for BitcoinAdapterClientImpl {
         self.rt_handle.block_on(async move {
             match request {
                 BitcoinAdapterRequestWrapper::GetSuccessorsRequest(r) => {
-                    let get_successors_request = GetSuccessorsRpcRequest {
+                    let get_successors_request = BtcServiceGetSuccessorsRequest {
                         processed_block_hashes: r.processed_block_hashes,
                         anchor: r.anchor,
                     };
@@ -129,7 +130,7 @@ impl BitcoinAdapterClient for BitcoinAdapterClientImpl {
                         .map_err(convert_tonic_error)
                 }
                 BitcoinAdapterRequestWrapper::SendTransactionRequest(r) => {
-                    let send_transaction_request = SendTransactionRpcRequest {
+                    let send_transaction_request = BtcServiceSendTransactionRequest {
                         transaction: r.transaction,
                     };
                     let mut tonic_request = tonic::Request::new(send_transaction_request);
