Rename requests according to responses

Author: stanislav-tkach

p2p/src/message.rs

@@ -21,13 +21,13 @@ use common::{
 use serialization::{Decode, Encode};
 
 #[derive(Debug, Encode, Decode, Clone, PartialEq, Eq)]
-pub struct HeaderRequest {
+pub struct HeaderListRequest {
     locator: Locator,
 }
 
-impl HeaderRequest {
+impl HeaderListRequest {
     pub fn new(locator: Locator) -> Self {
-        HeaderRequest { locator }
+        HeaderListRequest { locator }
     }
 
     pub fn locator(&self) -> &Locator {
@@ -40,11 +40,11 @@ impl HeaderRequest {
 }
 
 #[derive(Debug, Encode, Decode, Clone, PartialEq, Eq)]
-pub struct BlockRequest {
+pub struct BlockListRequest {
     block_ids: Vec<Id<Block>>,
 }
 
-impl BlockRequest {
+impl BlockListRequest {
     pub fn new(block_ids: Vec<Id<Block>>) -> Self {
         Self { block_ids }
     }
@@ -61,9 +61,9 @@ impl BlockRequest {
 #[derive(Debug, Encode, Decode, Clone, PartialEq, Eq)]
 pub enum Request {
     #[codec(index = 0)]
-    HeaderRequest(HeaderRequest),
+    HeaderListRequest(HeaderListRequest),
     #[codec(index = 1)]
-    BlockRequest(BlockRequest),
+    BlockListRequest(BlockListRequest),
 }
 
 #[derive(Debug, Encode, Decode, Clone, PartialEq, Eq)]
@@ -107,9 +107,9 @@ impl BlockListResponse {
 #[derive(Debug, Encode, Decode, Clone, PartialEq, Eq)]
 pub enum Response {
     #[codec(index = 0)]
-    HeaderResponse(HeaderListResponse),
+    HeaderListResponse(HeaderListResponse),
     #[codec(index = 1)]
-    BlockResponse(BlockListResponse),
+    BlockListResponse(BlockListResponse),
 }
 
 #[derive(Debug, Encode, Decode, Clone, PartialEq, Eq)]

p2p/src/net/mock/peer.rs

@@ -395,9 +395,11 @@ mod tests {
 
         assert!(socket2.recv().now_or_never().is_none());
         socket2
-            .send(types::Message::Request(message::Request::HeaderRequest(
-                message::HeaderRequest::new(Locator::new(vec![])),
-            )))
+            .send(types::Message::Request(
+                message::Request::HeaderListRequest(message::HeaderListRequest::new(Locator::new(
+                    vec![],
+                ))),
+            ))
             .await
             .unwrap();
 

p2p/src/net/mock/socket.rs

@@ -136,7 +136,7 @@ mod tests {
         let mut server_socket = MockSocket::new(res1.unwrap().0);
         let mut peer_socket = MockSocket::new(res2.unwrap());
 
-        let msg = Message::Request(Request::BlockRequest(BlockRequest::new(vec![])));
+        let msg = Message::Request(Request::BlockListRequest(BlockListRequest::new(vec![])));
         peer_socket.send(msg.clone()).await.unwrap();
 
         assert_eq!(server_socket.recv().await.unwrap().unwrap(), msg);

p2p/src/sync/mod.rs

@@ -513,7 +513,7 @@ where
                         request_id,
                         request,
                     } => match request {
-                        message::Request::HeaderRequest(request) => {
+                        message::Request::HeaderListRequest(request) => {
                             log::debug!(
                                 "process header request (id {:?}) from peer {}",
                                 request_id, peer_id
@@ -527,7 +527,7 @@ where
                             ).await;
                             self.handle_error(peer_id, result).await?;
                         }
-                        message::Request::BlockRequest(request) => {
+                        message::Request::BlockListRequest(request) => {
                             log::debug!(
                                 "process block request (id {:?}) from peer {}",
                                 request_id, peer_id
@@ -547,7 +547,7 @@ where
                         request_id,
                         response,
                     } => match response {
-                        message::Response::HeaderResponse(response) => {
+                        message::Response::HeaderListResponse(response) => {
                             log::debug!(
                                 "process header response (id {:?}) from peer {}",
                                 request_id, peer_id
@@ -557,7 +557,7 @@ where
                             let result = self.process_header_response(peer_id, response.into_headers()).await;
                             self.handle_error(peer_id, result).await?;
                         }
-                        message::Response::BlockResponse(response) => {
+                        message::Response::BlockListResponse(response) => {
                             log::debug!(
                                 "process block response (id {:?}) from peer {}",
                                 request_id, peer_id

p2p/src/sync/request.rs

@@ -52,7 +52,7 @@ where
     /// * `block_ids` - IDs of the blocks that are requested
     pub fn make_block_request(&self, block_ids: Vec<Id<Block>>) -> (message::Request, RequestType) {
         (
-            message::Request::BlockRequest(message::BlockRequest::new(block_ids.clone())),
+            message::Request::BlockListRequest(message::BlockListRequest::new(block_ids.clone())),
             RequestType::GetBlocks(block_ids),
         )
     }
@@ -66,7 +66,7 @@ where
     /// * `locator` - locator object that shows the state of the local node
     pub fn make_header_request(&self, locator: Locator) -> (message::Request, RequestType) {
         (
-            message::Request::HeaderRequest(message::HeaderRequest::new(locator)),
+            message::Request::HeaderListRequest(message::HeaderListRequest::new(locator)),
             RequestType::GetHeaders,
         )
     }
@@ -76,15 +76,15 @@ where
     /// # Arguments
     /// * `headers` - the headers that were requested
     pub fn make_header_response(&self, headers: Vec<BlockHeader>) -> message::Response {
-        message::Response::HeaderResponse(message::HeaderListResponse::new(headers))
+        message::Response::HeaderListResponse(message::HeaderListResponse::new(headers))
     }
 
     /// Make block response
     ///
     /// # Arguments
     /// * `blocks` - the blocks that were requested
     pub fn make_block_response(&self, blocks: Vec<Block>) -> message::Response {
-        message::Response::BlockResponse(message::BlockListResponse::new(blocks))
+        message::Response::BlockListResponse(message::BlockListResponse::new(blocks))
     }
 
     /// Helper function for sending a request to remote

p2p/src/sync/tests/request_response.rs

@@ -32,7 +32,7 @@ async fn test_request_response() {
     mgr1.peer_sync_handle
         .send_request(
             *conn2.peer_id(),
-            Request::HeaderRequest(HeaderRequest::new(Locator::new(vec![]))),
+            Request::HeaderListRequest(HeaderListRequest::new(Locator::new(vec![]))),
         )
         .await
         .unwrap();
@@ -45,13 +45,13 @@ async fn test_request_response() {
     {
         assert_eq!(
             request,
-            Request::HeaderRequest(HeaderRequest::new(Locator::new(vec![])))
+            Request::HeaderListRequest(HeaderListRequest::new(Locator::new(vec![])))
         );
 
         mgr2.peer_sync_handle
             .send_response(
                 request_id,
-                Response::HeaderResponse(HeaderListResponse::new(vec![])),
+                Response::HeaderListResponse(HeaderListResponse::new(vec![])),
             )
             .await
             .unwrap();
@@ -75,7 +75,7 @@ async fn test_multiple_requests_and_responses() {
         .peer_sync_handle
         .send_request(
             *conn2.peer_id(),
-            Request::HeaderRequest(HeaderRequest::new(Locator::new(vec![]))),
+            Request::HeaderListRequest(HeaderListRequest::new(Locator::new(vec![]))),
         )
         .await
         .unwrap();
@@ -85,7 +85,7 @@ async fn test_multiple_requests_and_responses() {
         .peer_sync_handle
         .send_request(
             *conn2.peer_id(),
-            Request::HeaderRequest(HeaderRequest::new(Locator::new(vec![]))),
+            Request::HeaderListRequest(HeaderListRequest::new(Locator::new(vec![]))),
         )
         .await
         .unwrap();
@@ -100,7 +100,7 @@ async fn test_multiple_requests_and_responses() {
                     mgr2.peer_sync_handle
                         .send_response(
                             request_id,
-                            Response::HeaderResponse(HeaderListResponse::new(vec![])),
+                            Response::HeaderListResponse(HeaderListResponse::new(vec![])),
                         )
                         .await
                         .unwrap();