pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 20:31:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove queueing from message-lane (#352)

Browse Source 
* remove queueing from message-lane

* also remove queueing from RPCs

* another trace

* new clippy
This commit is contained in:
Svyatoslav Nikolsky
2020-09-15 15:14:52 +03:00
committed by Bastian Köcher
parent c2791c2772
commit d918bcb6f8
8 changed files with 29 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files
bridges/modules/message-lane/src/inbound_lane.rs
+13 -152
View File
@@ -16,7 +16,7 @@
//! Everything about incoming messages receival.
use bp_message_lane::{InboundLaneData, LaneId, Message, MessageKey, MessageNonce, MessageResult, OnMessageReceived};
use bp_message_lane::{InboundLaneData, LaneId, Message, MessageKey, MessageNonce, OnMessageReceived};
/// Inbound lane storage.
pub trait InboundLaneStorage {
@@ -29,12 +29,6 @@ pub trait InboundLaneStorage {
fn data(&self) -> InboundLaneData;
/// Update lane data in the storage.
fn set_data(&mut self, data: InboundLaneData);
/// Returns saved inbound message payload.
fn message(&self, nonce: &MessageNonce) -> Option<Self::Payload>;
/// Save inbound message in the storage.
fn save_message(&mut self, nonce: MessageNonce, payload: Self::Payload);
/// Remove inbound message from the storage.
fn remove_message(&mut self, nonce: &MessageNonce);
}
/// Inbound messages lane.
@@ -49,11 +43,10 @@ impl<S: InboundLaneStorage> InboundLane<S> {
}
/// Receive new message.
pub fn receive_message(
pub fn receive_message<P: OnMessageReceived<S::Payload>>(
&mut self,
nonce: MessageNonce,
payload: S::Payload,
processor: &mut impl OnMessageReceived<S::Payload>,
) -> bool {
let mut data = self.storage.data();
let is_correct_message = nonce == data.latest_received_nonce + 1;
@@ -61,70 +54,19 @@ impl<S: InboundLaneStorage> InboundLane<S> {
return false;
}
let is_process_required = is_correct_message && data.oldest_unprocessed_nonce == nonce;
data.latest_received_nonce = nonce;
self.storage.set_data(data);
let payload_to_save = match is_process_required {
true => {
let message = Message {
key: MessageKey {
lane_id: self.storage.id(),
nonce,
},
payload,
};
match processor.on_message_received(message) {
MessageResult::Processed => None,
MessageResult::NotProcessed(message) => Some(message.payload),
}
}
false => Some(payload),
};
if let Some(payload_to_save) = payload_to_save {
self.storage.save_message(nonce, payload_to_save);
}
P::on_message_received(Message {
key: MessageKey {
lane_id: self.storage.id(),
nonce,
},
payload,
});
true
}
/// Process stored lane messages.
///
/// Stops processing either when all messages are processed, or when processor returns
/// MessageResult::NotProcessed.
pub fn process_messages(&mut self, processor: &mut impl OnMessageReceived<S::Payload>) {
let mut anything_processed = false;
let mut data = self.storage.data();
while data.oldest_unprocessed_nonce <= data.latest_received_nonce {
let nonce = data.oldest_unprocessed_nonce;
let payload = self
.storage
.message(&nonce)
.expect("message is referenced by lane; referenced message is not pruned; qed");
let message = Message {
key: MessageKey {
lane_id: self.storage.id(),
nonce,
},
payload,
};
let process_result = processor.on_message_received(message);
if let MessageResult::NotProcessed(_) = process_result {
break;
}
self.storage.remove_message(&nonce);
anything_processed = true;
data.oldest_unprocessed_nonce += 1;
}
if anything_processed {
self.storage.set_data(data);
}
}
}
#[cfg(test)]
@@ -132,105 +74,24 @@ mod tests {
use super::*;
use crate::{
inbound_lane,
mock::{
run_test, TestMessageProcessor, TestPayload, TestRuntime, PAYLOAD_TO_QUEUE, REGULAR_PAYLOAD, TEST_LANE_ID,
},
mock::{run_test, TestRuntime, REGULAR_PAYLOAD, TEST_LANE_ID},
};
#[test]
fn fails_to_receive_message_with_incorrect_nonce() {
run_test(|| {
let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
assert!(!lane.receive_message(10, REGULAR_PAYLOAD, &mut TestMessageProcessor));
assert!(lane.storage.message(&10).is_none());
assert!(!lane.receive_message::<()>(10, REGULAR_PAYLOAD));
assert_eq!(lane.storage.data().latest_received_nonce, 0);
});
}
#[test]
fn correct_message_is_queued_if_some_other_messages_are_queued() {
fn correct_message_is_processed_instantly() {
run_test(|| {
let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
assert!(lane.receive_message(1, PAYLOAD_TO_QUEUE, &mut TestMessageProcessor));
assert!(lane.storage.message(&1).is_some());
assert!(lane.receive_message(2, REGULAR_PAYLOAD, &mut TestMessageProcessor));
assert!(lane.storage.message(&2).is_some());
assert_eq!(lane.storage.data().latest_received_nonce, 2);
});
}
#[test]
fn correct_message_is_queued_if_processor_wants_to_queue() {
run_test(|| {
let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
assert!(lane.receive_message(1, PAYLOAD_TO_QUEUE, &mut TestMessageProcessor));
assert!(lane.storage.message(&1).is_some());
assert!(lane.receive_message::<()>(1, REGULAR_PAYLOAD));
assert_eq!(lane.storage.data().latest_received_nonce, 1);
});
}
#[test]
fn correct_message_is_not_queued_if_processed_instantly() {
run_test(|| {
let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
assert!(lane.receive_message(1, REGULAR_PAYLOAD, &mut TestMessageProcessor));
assert!(lane.storage.message(&1).is_none());
assert_eq!(lane.storage.data().latest_received_nonce, 1);
});
}
#[test]
fn process_message_does_nothing_when_lane_is_empty() {
run_test(|| {
let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
assert_eq!(lane.storage.data().oldest_unprocessed_nonce, 1);
lane.process_messages(&mut TestMessageProcessor);
assert_eq!(lane.storage.data().oldest_unprocessed_nonce, 1);
});
}
#[test]
fn process_message_works() {
run_test(|| {
pub struct QueueByNonce(MessageNonce);
impl OnMessageReceived<TestPayload> for QueueByNonce {
fn on_message_received(&mut self, message: Message<TestPayload>) -> MessageResult<TestPayload> {
if message.key.nonce == self.0 {
MessageResult::NotProcessed(message)
} else {
MessageResult::Processed
}
}
}
let mut lane = inbound_lane::<TestRuntime, _>(TEST_LANE_ID);
assert!(lane.receive_message(1, PAYLOAD_TO_QUEUE, &mut TestMessageProcessor));
assert!(lane.receive_message(2, PAYLOAD_TO_QUEUE, &mut TestMessageProcessor));
assert!(lane.receive_message(3, PAYLOAD_TO_QUEUE, &mut TestMessageProcessor));
assert!(lane.receive_message(4, REGULAR_PAYLOAD, &mut TestMessageProcessor));
assert!(lane.storage.message(&1).is_some());
assert!(lane.storage.message(&2).is_some());
assert!(lane.storage.message(&3).is_some());
assert!(lane.storage.message(&4).is_some());
assert_eq!(lane.storage.data().oldest_unprocessed_nonce, 1);
lane.process_messages(&mut QueueByNonce(3));
assert!(lane.storage.message(&1).is_none());
assert!(lane.storage.message(&2).is_none());
assert!(lane.storage.message(&3).is_some());
assert!(lane.storage.message(&4).is_some());
assert_eq!(lane.storage.data().oldest_unprocessed_nonce, 3);
lane.process_messages(&mut QueueByNonce(10));
assert!(lane.storage.message(&1).is_none());
assert!(lane.storage.message(&2).is_none());
assert!(lane.storage.message(&3).is_none());
assert!(lane.storage.message(&4).is_none());
assert_eq!(lane.storage.data().oldest_unprocessed_nonce, 5);
});
}
}
bridges/modules/message-lane/src/lib.rs
+3 -57
View File
@@ -58,15 +58,13 @@ pub trait Trait<I = DefaultInstance>: frame_system::Trait {
/// for it.
type MaxMessagesToPruneAtOnce: Get<MessageNonce>;
/// Called when message has been received.
type OnMessageReceived: Default + OnMessageReceived<Self::Payload>;
type OnMessageReceived: OnMessageReceived<Self::Payload>;
}
decl_storage! {
trait Store for Module<T: Trait<I>, I: Instance = DefaultInstance> as MessageLane {
/// Map of lane id => inbound lane data.
InboundLanes: map hasher(blake2_128_concat) LaneId => InboundLaneData;
/// All stored (unprocessed) inbound messages.
InboundMessages: map hasher(blake2_128_concat) MessageKey => Option<T::Payload>;
/// Map of lane id => outbound lane data.
OutboundLanes: map hasher(blake2_128_concat) LaneId => OutboundLaneData;
/// All queued outbound messages.
@@ -80,10 +78,8 @@ decl_event!(
{
/// Message has been accepted and is waiting to be delivered.
MessageAccepted(LaneId, MessageNonce),
/// Messages in the inclusive range have been delivered to the bridged chain.
/// Messages in the inclusive range have been delivered and processed by the bridged chain.
MessagesDelivered(LaneId, MessageNonce, MessageNonce),
/// Messages in the inclusive range have been processed by the bridged chain.
MessagesProcessed(LaneId, MessageNonce, MessageNonce),
/// Phantom member, never used.
Dummy(PhantomData<(AccountId, I)>),
}
@@ -126,10 +122,9 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
/// will be rejected.
pub fn receive_messages(messages: Vec<Message<T::Payload>>) -> MessageNonce {
let mut correct_messages = 0;
let mut processor = T::OnMessageReceived::default();
for message in messages {
let mut lane = inbound_lane::<T, I>(message.key.lane_id);
if lane.receive_message(message.key.nonce, message.payload, &mut processor) {
if lane.receive_message::<T::OnMessageReceived>(message.key.nonce, message.payload) {
correct_messages += 1;
}
}
@@ -137,14 +132,6 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
correct_messages
}
/// Process stored lane messages.
///
/// Stops processing either when all messages are processed, or when processor returns
/// MessageResult::NotProcessed.
pub fn process_lane_messages(lane_id: &LaneId, processor: &mut impl OnMessageReceived<T::Payload>) {
inbound_lane::<T, I>(*lane_id).process_messages(processor);
}
/// Receive TRUSTED proof of message receival.
///
/// Trusted here means that the function itself doesn't check whether the bridged chain has
@@ -164,23 +151,6 @@ impl<T: Trait<I>, I: Instance> Module<T, I> {
));
}
}
/// Receive TRUSTED proof of message processing.
///
/// Trusted here means that the function itself doesn't check whether the bridged chain has
/// actually processed these messages.
pub fn confirm_processing(lane_id: &LaneId, latest_processed_nonce: MessageNonce) {
let mut lane = outbound_lane::<T, I>(*lane_id);
let processed_range = lane.confirm_processing(latest_processed_nonce);
if let Some(processed_range) = processed_range {
Self::deposit_event(RawEvent::MessagesProcessed(
*lane_id,
processed_range.0,
processed_range.1,
));
}
}
}
/// Creates new inbound lane object, backed by runtime storage.
@@ -219,30 +189,6 @@ impl<T: Trait<I>, I: Instance> InboundLaneStorage for RuntimeInboundLaneStorage<
fn set_data(&mut self, data: InboundLaneData) {
InboundLanes::<I>::insert(&self.lane_id, data)
}
fn message(&self, nonce: &MessageNonce) -> Option<Self::Payload> {
InboundMessages::<T, I>::get(MessageKey {
lane_id: self.lane_id,
nonce: *nonce,
})
}
fn save_message(&mut self, nonce: MessageNonce, payload: T::Payload) {
InboundMessages::<T, I>::insert(
MessageKey {
lane_id: self.lane_id,
nonce,
},
payload,
);
}
fn remove_message(&mut self, nonce: &MessageNonce) {
InboundMessages::<T, I>::remove(MessageKey {
lane_id: self.lane_id,
nonce: *nonce,
});
}
}
/// Runtime outbound lane storage.
bridges/modules/message-lane/src/mock.rs
+3 -20
View File
@@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with Parity Bridges Common. If not, see <http://www.gnu.org/licenses/>.
use bp_message_lane::{LaneId, Message, MessageResult, OnMessageReceived};
use bp_message_lane::LaneId;
use frame_support::{impl_outer_event, impl_outer_origin, parameter_types, weights::Weight};
use sp_core::H256;
use sp_runtime::{
@@ -89,32 +89,15 @@ impl Trait for TestRuntime {
type Event = TestEvent;
type Payload = TestPayload;
type MaxMessagesToPruneAtOnce = MaxMessagesToPruneAtOnce;
type OnMessageReceived = TestMessageProcessor;
type OnMessageReceived = ();
}
/// Lane that we're using in tests.
pub const TEST_LANE_ID: LaneId = [0, 0, 0, 1];
/// Regular message payload that is not PAYLOAD_TO_QUEUE.
/// Regular message payload.
pub const REGULAR_PAYLOAD: TestPayload = 0;
/// All messages with this payload are queued by TestMessageProcessor.
pub const PAYLOAD_TO_QUEUE: TestPayload = 42;
/// Message processor that immediately handles all messages except messages with PAYLOAD_TO_QUEUE payload.
#[derive(Debug, Default)]
pub struct TestMessageProcessor;
impl OnMessageReceived<TestPayload> for TestMessageProcessor {
fn on_message_received(&mut self, message: Message<TestPayload>) -> MessageResult<TestPayload> {
if message.payload == PAYLOAD_TO_QUEUE {
MessageResult::NotProcessed(message)
} else {
MessageResult::Processed
}
}
}
/// Run message lane test.
pub fn run_test<T>(test: impl FnOnce() -> T) -> T {
sp_io::TestExternalities::new(Default::default()).execute_with(test)
bridges/modules/message-lane/src/outbound_lane.rs
-73
View File
@@ -80,25 +80,6 @@ impl<S: OutboundLaneStorage> OutboundLane<S> {
Some((prev_latest_received_nonce + 1, latest_received_nonce))
}
/// Confirm message processing.
///
/// Returns `None` if confirmation is wrong/duplicate.
/// Returns `Some` with inclusive ranges of message nonces that have been processed.
pub fn confirm_processing(&mut self, latest_processed_nonce: MessageNonce) -> Option<(MessageNonce, MessageNonce)> {
let mut data = self.storage.data();
// wait for recieval confirmation first
if latest_processed_nonce <= data.latest_processed_nonce || latest_processed_nonce > data.latest_received_nonce
{
return None;
}
let prev_latest_processed_nonce = data.latest_processed_nonce;
data.latest_processed_nonce = latest_processed_nonce;
self.storage.set_data(data);
Some((prev_latest_processed_nonce + 1, latest_processed_nonce))
}
/// Prune at most `max_messages_to_prune` already received messages.
///
/// Returns number of pruned messages.
@@ -191,60 +172,6 @@ mod tests {
});
}
#[test]
fn confirm_processing_works() {
run_test(|| {
let mut lane = outbound_lane::<TestRuntime, _>(TEST_LANE_ID);
assert_eq!(lane.send_message(REGULAR_PAYLOAD), 1);
assert_eq!(lane.send_message(REGULAR_PAYLOAD), 2);
assert_eq!(lane.send_message(REGULAR_PAYLOAD), 3);
assert_eq!(lane.storage.data().latest_generated_nonce, 3);
assert_eq!(lane.storage.data().latest_processed_nonce, 0);
assert_eq!(lane.confirm_receival(3), Some((1, 3)));
assert_eq!(lane.confirm_processing(2), Some((1, 2)));
assert_eq!(lane.storage.data().latest_processed_nonce, 2);
assert_eq!(lane.confirm_processing(3), Some((3, 3)));
assert_eq!(lane.storage.data().latest_generated_nonce, 3);
assert_eq!(lane.storage.data().latest_processed_nonce, 3);
});
}
#[test]
fn confirm_processing_rejects_nonce_lesser_than_latest_processed() {
run_test(|| {
let mut lane = outbound_lane::<TestRuntime, _>(TEST_LANE_ID);
lane.send_message(REGULAR_PAYLOAD);
lane.send_message(REGULAR_PAYLOAD);
lane.send_message(REGULAR_PAYLOAD);
assert_eq!(lane.storage.data().latest_generated_nonce, 3);
assert_eq!(lane.storage.data().latest_processed_nonce, 0);
assert_eq!(lane.confirm_receival(3), Some((1, 3)));
assert_eq!(lane.confirm_processing(3), Some((1, 3)));
assert_eq!(lane.confirm_processing(3), None);
assert_eq!(lane.storage.data().latest_generated_nonce, 3);
assert_eq!(lane.storage.data().latest_processed_nonce, 3);
assert_eq!(lane.confirm_processing(2), None);
assert_eq!(lane.storage.data().latest_generated_nonce, 3);
assert_eq!(lane.storage.data().latest_processed_nonce, 3);
});
}
#[test]
fn confirm_processing_rejects_nonce_larger_than_last_received() {
run_test(|| {
let mut lane = outbound_lane::<TestRuntime, _>(TEST_LANE_ID);
lane.send_message(REGULAR_PAYLOAD);
lane.send_message(REGULAR_PAYLOAD);
lane.send_message(REGULAR_PAYLOAD);
assert_eq!(lane.storage.data().latest_generated_nonce, 3);
assert_eq!(lane.storage.data().latest_processed_nonce, 0);
assert_eq!(lane.confirm_processing(2), None);
assert_eq!(lane.storage.data().latest_generated_nonce, 3);
assert_eq!(lane.storage.data().latest_processed_nonce, 0);
});
}
#[test]
fn prune_messages_works() {
run_test(|| {