Refactor: Rename Request & Response to Ping & Pong

1. These two variants will be modified in an upcoming commit
   to be each other's response.
2. The names are updated to better fit their new roles.

diff --git a/lightning/src/onion_message/functional_tests.rs b/lightning/src/onion_message/functional_tests.rs
index 03356b434a3aeb92fa521c97984bfbe5aa503aa7..fe2b3799e72032524e348776d7d07d28a2f147e0 100644 (file)
--- a/lightning/src/onion_message/functional_tests.rs
+++ b/lightning/src/onion_message/functional_tests.rs
@@ -81,20 +81,20 @@ impl OffersMessageHandler for TestOffersMessageHandler {
 
 #[derive(Clone, Debug, PartialEq)]
 enum TestCustomMessage {
-       Request,
-       Response,
+       Ping,
+       Pong,
 }
 
-const CUSTOM_REQUEST_MESSAGE_TYPE: u64 = 4242;
-const CUSTOM_RESPONSE_MESSAGE_TYPE: u64 = 4343;
-const CUSTOM_REQUEST_MESSAGE_CONTENTS: [u8; 32] = [42; 32];
-const CUSTOM_RESPONSE_MESSAGE_CONTENTS: [u8; 32] = [43; 32];
+const CUSTOM_PING_MESSAGE_TYPE: u64 = 4242;
+const CUSTOM_PONG_MESSAGE_TYPE: u64 = 4343;
+const CUSTOM_PING_MESSAGE_CONTENTS: [u8; 32] = [42; 32];
+const CUSTOM_PONG_MESSAGE_CONTENTS: [u8; 32] = [43; 32];
 
 impl OnionMessageContents for TestCustomMessage {
        fn tlv_type(&self) -> u64 {
                match self {
-                       TestCustomMessage::Request => CUSTOM_REQUEST_MESSAGE_TYPE,
-                       TestCustomMessage::Response => CUSTOM_RESPONSE_MESSAGE_TYPE,
+                       TestCustomMessage::Ping => CUSTOM_PING_MESSAGE_TYPE,
+                       TestCustomMessage::Pong => CUSTOM_PONG_MESSAGE_TYPE,
                }
        }
        fn msg_type(&self) -> &'static str {
@@ -105,8 +105,8 @@ impl OnionMessageContents for TestCustomMessage {
 impl Writeable for TestCustomMessage {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
                match self {
-                       TestCustomMessage::Request => Ok(CUSTOM_REQUEST_MESSAGE_CONTENTS.write(w)?),
-                       TestCustomMessage::Response => Ok(CUSTOM_RESPONSE_MESSAGE_CONTENTS.write(w)?),
+                       TestCustomMessage::Ping => Ok(CUSTOM_PING_MESSAGE_CONTENTS.write(w)?),
+                       TestCustomMessage::Pong => Ok(CUSTOM_PONG_MESSAGE_CONTENTS.write(w)?),
                }
        }
 }
@@ -144,8 +144,8 @@ impl CustomOnionMessageHandler for TestCustomMessageHandler {
                        None => panic!("Unexpected message: {:?}", msg),
                }
                let response_option = match msg {
-                       TestCustomMessage::Request => Some(TestCustomMessage::Response),
-                       TestCustomMessage::Response => None,
+                       TestCustomMessage::Ping => Some(TestCustomMessage::Pong),
+                       TestCustomMessage::Pong => None,
                };
                if let (Some(response), Some(responder)) = (response_option, responder) {
                        responder.respond(response)
@@ -155,15 +155,15 @@ impl CustomOnionMessageHandler for TestCustomMessageHandler {
        }
        fn read_custom_message<R: io::Read>(&self, message_type: u64, buffer: &mut R) -> Result<Option<Self::CustomMessage>, DecodeError> where Self: Sized {
                match message_type {
-                       CUSTOM_REQUEST_MESSAGE_TYPE => {
+                       CUSTOM_PING_MESSAGE_TYPE => {
                                let buf = read_to_end(buffer)?;
-                               assert_eq!(buf, CUSTOM_REQUEST_MESSAGE_CONTENTS);
-                               Ok(Some(TestCustomMessage::Request))
+                               assert_eq!(buf, CUSTOM_PING_MESSAGE_CONTENTS);
+                               Ok(Some(TestCustomMessage::Ping))
                        },
-                       CUSTOM_RESPONSE_MESSAGE_TYPE => {
+                       CUSTOM_PONG_MESSAGE_TYPE => {
                                let buf = read_to_end(buffer)?;
-                               assert_eq!(buf, CUSTOM_RESPONSE_MESSAGE_CONTENTS);
-                               Ok(Some(TestCustomMessage::Response))
+                               assert_eq!(buf, CUSTOM_PONG_MESSAGE_CONTENTS);
+                               Ok(Some(TestCustomMessage::Pong))
                        },
                        _ => Ok(None),
                }
@@ -298,18 +298,18 @@ fn pass_along_path(path: &Vec<MessengerNode>) {
 #[test]
 fn one_unblinded_hop() {
        let nodes = create_nodes(2);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let destination = Destination::Node(nodes[1].node_id);
        nodes[0].messenger.send_onion_message(test_msg, destination, None).unwrap();
-       nodes[1].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[1].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&nodes);
 }
 
 #[test]
 fn two_unblinded_hops() {
        let nodes = create_nodes(3);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let path = OnionMessagePath {
                intermediate_nodes: vec![nodes[1].node_id],
@@ -318,27 +318,27 @@ fn two_unblinded_hops() {
        };
 
        nodes[0].messenger.send_onion_message_using_path(path, test_msg, None).unwrap();
-       nodes[2].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[2].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&nodes);
 }
 
 #[test]
 fn one_blinded_hop() {
        let nodes = create_nodes(2);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let secp_ctx = Secp256k1::new();
        let blinded_path = BlindedPath::new_for_message(&[], nodes[1].node_id, &*nodes[1].entropy_source, &secp_ctx).unwrap();
        let destination = Destination::BlindedPath(blinded_path);
        nodes[0].messenger.send_onion_message(test_msg, destination, None).unwrap();
-       nodes[1].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[1].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&nodes);
 }
 
 #[test]
 fn two_unblinded_two_blinded() {
        let nodes = create_nodes(5);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let secp_ctx = Secp256k1::new();
        let intermediate_nodes = [ForwardNode { node_id: nodes[3].node_id, short_channel_id: None }];
@@ -350,14 +350,14 @@ fn two_unblinded_two_blinded() {
        };
 
        nodes[0].messenger.send_onion_message_using_path(path, test_msg, None).unwrap();
-       nodes[4].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[4].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&nodes);
 }
 
 #[test]
 fn three_blinded_hops() {
        let nodes = create_nodes(4);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let secp_ctx = Secp256k1::new();
        let intermediate_nodes = [
@@ -368,7 +368,7 @@ fn three_blinded_hops() {
        let destination = Destination::BlindedPath(blinded_path);
 
        nodes[0].messenger.send_onion_message(test_msg, destination, None).unwrap();
-       nodes[3].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[3].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&nodes);
 }
 
@@ -382,7 +382,7 @@ fn async_response_over_one_blinded_hop() {
        let bob = &nodes[1];
 
        // 2. Define the message sent from Bob to Alice.
-       let message = TestCustomMessage::Request;
+       let message = TestCustomMessage::Ping;
        let path_id = Some([2; 32]);
 
        // 3. Simulate the creation of a Blinded Reply path provided by Bob.
@@ -402,7 +402,7 @@ fn async_response_over_one_blinded_hop() {
                Ok(Some(SendSuccess::Buffered)),
        );
 
-       bob.custom_message_handler.expect_message(TestCustomMessage::Response);
+       bob.custom_message_handler.expect_message(TestCustomMessage::Pong);
 
        pass_along_path(&nodes);
 }
@@ -411,7 +411,7 @@ fn async_response_over_one_blinded_hop() {
 fn too_big_packet_error() {
        // Make sure we error as expected if a packet is too big to send.
        let nodes = create_nodes(2);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let hop_node_id = nodes[1].node_id;
        let hops = vec![hop_node_id; 400];
@@ -429,7 +429,7 @@ fn we_are_intro_node() {
        // If we are sending straight to a blinded path and we are the introduction node, we need to
        // advance the blinded path by 1 hop so the second hop is the new introduction node.
        let mut nodes = create_nodes(3);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let secp_ctx = Secp256k1::new();
        let intermediate_nodes = [
@@ -440,7 +440,7 @@ fn we_are_intro_node() {
        let destination = Destination::BlindedPath(blinded_path);
 
        nodes[0].messenger.send_onion_message(test_msg.clone(), destination, None).unwrap();
-       nodes[2].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[2].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&nodes);
 
        // Try with a two-hop blinded path where we are the introduction node.
@@ -448,7 +448,7 @@ fn we_are_intro_node() {
        let blinded_path = BlindedPath::new_for_message(&intermediate_nodes, nodes[1].node_id, &*nodes[1].entropy_source, &secp_ctx).unwrap();
        let destination = Destination::BlindedPath(blinded_path);
        nodes[0].messenger.send_onion_message(test_msg, destination, None).unwrap();
-       nodes[1].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[1].custom_message_handler.expect_message(TestCustomMessage::Pong);
        nodes.remove(2);
        pass_along_path(&nodes);
 }
@@ -457,7 +457,7 @@ fn we_are_intro_node() {
 fn invalid_blinded_path_error() {
        // Make sure we error as expected if a provided blinded path has 0 hops.
        let nodes = create_nodes(3);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let secp_ctx = Secp256k1::new();
        let intermediate_nodes = [ForwardNode { node_id: nodes[1].node_id, short_channel_id: None }];
@@ -471,7 +471,7 @@ fn invalid_blinded_path_error() {
 #[test]
 fn reply_path() {
        let mut nodes = create_nodes(4);
-       let test_msg = TestCustomMessage::Request;
+       let test_msg = TestCustomMessage::Ping;
        let secp_ctx = Secp256k1::new();
 
        // Destination::Node
@@ -486,10 +486,10 @@ fn reply_path() {
        ];
        let reply_path = BlindedPath::new_for_message(&intermediate_nodes, nodes[0].node_id, &*nodes[0].entropy_source, &secp_ctx).unwrap();
        nodes[0].messenger.send_onion_message_using_path(path, test_msg.clone(), Some(reply_path)).unwrap();
-       nodes[3].custom_message_handler.expect_message(TestCustomMessage::Request);
+       nodes[3].custom_message_handler.expect_message(TestCustomMessage::Ping);
        pass_along_path(&nodes);
        // Make sure the last node successfully decoded the reply path.
-       nodes[0].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[0].custom_message_handler.expect_message(TestCustomMessage::Pong);
        nodes.reverse();
        pass_along_path(&nodes);
 
@@ -507,11 +507,11 @@ fn reply_path() {
        let reply_path = BlindedPath::new_for_message(&intermediate_nodes, nodes[0].node_id, &*nodes[0].entropy_source, &secp_ctx).unwrap();
 
        nodes[0].messenger.send_onion_message(test_msg, destination, Some(reply_path)).unwrap();
-       nodes[3].custom_message_handler.expect_message(TestCustomMessage::Request);
+       nodes[3].custom_message_handler.expect_message(TestCustomMessage::Ping);
        pass_along_path(&nodes);
 
        // Make sure the last node successfully decoded the reply path.
-       nodes[0].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[0].custom_message_handler.expect_message(TestCustomMessage::Pong);
        nodes.reverse();
        pass_along_path(&nodes);
 }
@@ -545,7 +545,7 @@ fn invalid_custom_message_type() {
 #[test]
 fn peer_buffer_full() {
        let nodes = create_nodes(2);
-       let test_msg = TestCustomMessage::Request;
+       let test_msg = TestCustomMessage::Ping;
        let destination = Destination::Node(nodes[1].node_id);
        for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
                nodes[0].messenger.send_onion_message(test_msg.clone(), destination.clone(), None).unwrap();
@@ -560,7 +560,7 @@ fn many_hops() {
        // of size [`crate::onion_message::packet::BIG_PACKET_HOP_DATA_LEN`].
        let num_nodes: usize = 25;
        let nodes = create_nodes(num_nodes as u8);
-       let test_msg = TestCustomMessage::Response;
+       let test_msg = TestCustomMessage::Pong;
 
        let mut intermediate_nodes = vec![];
        for i in 1..(num_nodes-1) {
@@ -573,14 +573,14 @@ fn many_hops() {
                first_node_addresses: None,
        };
        nodes[0].messenger.send_onion_message_using_path(path, test_msg, None).unwrap();
-       nodes[num_nodes-1].custom_message_handler.expect_message(TestCustomMessage::Response);
+       nodes[num_nodes-1].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&nodes);
 }
 
 #[test]
 fn requests_peer_connection_for_buffered_messages() {
        let nodes = create_nodes(3);
-       let message = TestCustomMessage::Request;
+       let message = TestCustomMessage::Ping;
        let secp_ctx = Secp256k1::new();
        add_channel_to_graph(&nodes[0], &nodes[1], &secp_ctx, 42);
 
@@ -618,7 +618,7 @@ fn requests_peer_connection_for_buffered_messages() {
 #[test]
 fn drops_buffered_messages_waiting_for_peer_connection() {
        let nodes = create_nodes(3);
-       let message = TestCustomMessage::Request;
+       let message = TestCustomMessage::Ping;
        let secp_ctx = Secp256k1::new();
        add_channel_to_graph(&nodes[0], &nodes[1], &secp_ctx, 42);
 
@@ -670,7 +670,7 @@ fn intercept_offline_peer_oms() {
                }
        }
 
-       let message = TestCustomMessage::Response;
+       let message = TestCustomMessage::Pong;
        let secp_ctx = Secp256k1::new();
        let intermediate_nodes = [ForwardNode { node_id: nodes[1].node_id, short_channel_id: None }];
        let blinded_path = BlindedPath::new_for_message(
@@ -710,7 +710,7 @@ fn intercept_offline_peer_oms() {
        }
 
        nodes[1].messenger.forward_onion_message(onion_message, &final_node_vec[0].node_id).unwrap();
-       final_node_vec[0].custom_message_handler.expect_message(TestCustomMessage::Response);
+       final_node_vec[0].custom_message_handler.expect_message(TestCustomMessage::Pong);
        pass_along_path(&vec![nodes.remove(1), final_node_vec.remove(0)]);
 }