Implement validation data refactor (#1585)

* update primitives

* correct parent_head field

* make hrmp field pub

* refactor validation data: runtime

* refactor validation data: messages

* add arguments to full_validation_data runtime API

* port runtime API

* mostly port over candidate validation

* remove some parameters from ValidationParams

* guide: update candidate validation

* update candidate outputs

* update ValidationOutputs in primitives

* port over candidate validation

* add a new test for no-transient behavior

* update util runtime API wrappers

* candidate backing

* fix missing imports

* change some fields of validation data around

* runtime API impl

* update candidate validation

* fix backing tests

* grumbles from review

* fix av-store tests

* fix some more crates

* fix provisioner tests

* fix availability distribution tests

* port collation-generation to new validation data

* fix overseer tests

* Update roadmap/implementers-guide/src/node/utility/candidate-validation.md

Co-authored-by: Peter Goodspeed-Niklaus <coriolinus@users.noreply.github.com>

Co-authored-by: Peter Goodspeed-Niklaus <coriolinus@users.noreply.github.com>
This commit is contained in:
Robert Habermeier
2020-08-18 14:41:40 +02:00
committed by GitHub
parent 3395044402
commit 262574fc49
36 changed files with 619 additions and 1153 deletions
@@ -72,10 +72,8 @@ pub fn execute_good_on_parent() {
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: None,
hrmp_mqc_heads: Vec::new(),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
@@ -112,10 +110,8 @@ fn execute_good_chain_on_parent() {
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: number as RelayChainBlockNumber + 1,
code_upgrade_allowed: None,
hrmp_mqc_heads: Vec::new(),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
@@ -153,10 +149,8 @@ fn execute_bad_on_parent() {
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: None,
hrmp_mqc_heads: Vec::new(),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
@@ -1,217 +0,0 @@
// Copyright 2017-2020 Parity Technologies (UK) Ltd.
// This file is part of Polkadot.
// Polkadot is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Polkadot is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
//! Basic parachain that adds a number as part of its state.
use parachain::primitives::{
BlockData as GenericBlockData,
HeadData as GenericHeadData,
ValidationParams, ValidationCode,
};
use codec::{Decode, Encode};
use code_upgrader::{hash_state, HeadData, BlockData, State};
#[test]
pub fn execute_good_no_upgrade() {
let pool = parachain::wasm_executor::ValidationPool::new();
let parent_head = HeadData {
number: 0,
parent_hash: [0; 32],
post_state: hash_state(&State::default()),
};
let block_data = BlockData {
state: State::default(),
new_validation_code: None,
};
let ret = parachain::wasm_executor::validate_candidate(
code_upgrader::wasm_binary_unwrap(),
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: None,
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
).unwrap();
let new_head = HeadData::decode(&mut &ret.head_data.0[..]).unwrap();
assert!(ret.new_validation_code.is_none());
assert_eq!(new_head.number, 1);
assert_eq!(new_head.parent_hash, parent_head.hash());
assert_eq!(new_head.post_state, hash_state(&State::default()));
}
#[test]
pub fn execute_good_with_upgrade() {
let pool = parachain::wasm_executor::ValidationPool::new();
let parent_head = HeadData {
number: 0,
parent_hash: [0; 32],
post_state: hash_state(&State::default()),
};
let block_data = BlockData {
state: State::default(),
new_validation_code: Some(ValidationCode(vec![1, 2, 3])),
};
let ret = parachain::wasm_executor::validate_candidate(
code_upgrader::wasm_binary_unwrap(),
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: Some(20),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
).unwrap();
let new_head = HeadData::decode(&mut &ret.head_data.0[..]).unwrap();
assert_eq!(ret.new_validation_code.unwrap(), ValidationCode(vec![1, 2, 3]));
assert_eq!(new_head.number, 1);
assert_eq!(new_head.parent_hash, parent_head.hash());
assert_eq!(
new_head.post_state,
hash_state(&State {
code: ValidationCode::default(),
pending_code: Some((ValidationCode(vec![1, 2, 3]), 20)),
}),
);
}
#[test]
#[should_panic]
pub fn code_upgrade_not_allowed() {
let pool = parachain::wasm_executor::ValidationPool::new();
let parent_head = HeadData {
number: 0,
parent_hash: [0; 32],
post_state: hash_state(&State::default()),
};
let block_data = BlockData {
state: State::default(),
new_validation_code: Some(ValidationCode(vec![1, 2, 3])),
};
parachain::wasm_executor::validate_candidate(
code_upgrader::wasm_binary_unwrap(),
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: None,
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
).unwrap();
}
#[test]
pub fn applies_code_upgrade_after_delay() {
let pool = parachain::wasm_executor::ValidationPool::new();
let (new_head, state) = {
let parent_head = HeadData {
number: 0,
parent_hash: [0; 32],
post_state: hash_state(&State::default()),
};
let block_data = BlockData {
state: State::default(),
new_validation_code: Some(ValidationCode(vec![1, 2, 3])),
};
let ret = parachain::wasm_executor::validate_candidate(
code_upgrader::wasm_binary_unwrap(),
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: Some(2),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
).unwrap();
let new_head = HeadData::decode(&mut &ret.head_data.0[..]).unwrap();
let parent_hash = parent_head.hash();
let state = State {
code: ValidationCode::default(),
pending_code: Some((ValidationCode(vec![1, 2, 3]), 2)),
};
assert_eq!(ret.new_validation_code.unwrap(), ValidationCode(vec![1, 2, 3]));
assert_eq!(new_head.number, 1);
assert_eq!(new_head.parent_hash, parent_hash);
assert_eq!(new_head.post_state, hash_state(&state));
(new_head, state)
};
{
let parent_head = new_head;
let block_data = BlockData {
state,
new_validation_code: None,
};
let ret = parachain::wasm_executor::validate_candidate(
code_upgrader::wasm_binary_unwrap(),
ValidationParams {
parent_head: GenericHeadData(parent_head.encode()),
block_data: GenericBlockData(block_data.encode()),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 2,
code_upgrade_allowed: None,
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
).unwrap();
let new_head = HeadData::decode(&mut &ret.head_data.0[..]).unwrap();
assert!(ret.new_validation_code.is_none());
assert_eq!(new_head.number, 2);
assert_eq!(new_head.parent_hash, parent_head.hash());
assert_eq!(
new_head.post_state,
hash_state(&State {
code: ValidationCode(vec![1, 2, 3]),
pending_code: None,
}),
);
}
}
@@ -15,7 +15,6 @@
// along with Polkadot. If not, see <http://www.gnu.org/licenses/>.
mod adder;
mod code_upgrader;
mod wasm_executor;
use parachain::wasm_executor::run_worker;
@@ -31,10 +31,8 @@ fn terminates_on_timeout() {
ValidationParams {
block_data: BlockData(Vec::new()),
parent_head: Default::default(),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: None,
hrmp_mqc_heads: Vec::new(),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),
@@ -61,10 +59,8 @@ fn parallel_execution() {
ValidationParams {
block_data: BlockData(Vec::new()),
parent_head: Default::default(),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: None,
hrmp_mqc_heads: Vec::new(),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool2),
sp_core::testing::TaskExecutor::new(),
@@ -74,10 +70,8 @@ fn parallel_execution() {
ValidationParams {
block_data: BlockData(Vec::new()),
parent_head: Default::default(),
max_code_size: 1024,
max_head_data_size: 1024,
relay_chain_height: 1,
code_upgrade_allowed: None,
hrmp_mqc_heads: Vec::new(),
},
parachain::wasm_executor::ExecutionMode::RemoteTest(&pool),
sp_core::testing::TaskExecutor::new(),