mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-05-31 04:01:02 +00:00
Alexandru Gheorghe
2bc4ed1153
As discovered during investigation of https://github.com/paritytech/polkadot-sdk/issues/3314 and https://github.com/paritytech/polkadot-sdk/issues/3673 there are active validators which accidentally might change their network key during restart, that's not a safe operation when you are in the active set because of distributed nature of DHT, so the old records would still exist in the network until they expire 36h, so unless they have a good reason validators should avoid changing their key when they restart their nodes. There is an effort in parallel to improve this situation https://github.com/paritytech/polkadot-sdk/pull/3786, but those changes are way more intrusive and will need more rigorous testing, additionally they will reduce the time to less than 36h, but the propagation won't be instant anyway, so not changing your network during restart should be the safest way to run your node, unless you have a really good reason to change it. ## Proposal 1. Do not auto-generate the network if the network file does not exist in the provided path. Nodes where the key file does not exist will get the following error: ``` Error: 0: Starting an authorithy without network key in /home/alexggh/.local/share/polkadot/chains/ksmcc3/network/secret_ed25519. This is not a safe operation because the old identity still lives in the dht for 36 hours. Because of it your node might suffer from not being properly connected to other nodes for validation purposes. If it is the first time running your node you could use one of the following methods. 1. Pass --unsafe-force-node-key-generation and make sure you remove it for subsequent node restarts 2. Separetly generate the key with: polkadot key generate-node-key --file <YOUR_PATH_TO_NODE_KEY> ``` 2. Add an explicit parameters for nodes that do want to change their network despite the warnings or if they run the node for the first time. `--unsafe-force-node-key-generation` 3. For `polkadot key generate-node-key` add two new mutually exclusive parameters `base_path` and `default_base_path` to help with the key generation in the same path the polkadot main command would expect it. 4. Modify the installation scripts to auto-generate a key in default path if one was not present already there, this should help with making the executable work out of the box after an instalation. ## Notes Nodes that do not have already the key persisted will fail to start after this change, however I do consider that better than the current situation where they start but they silently hide that they might not be properly connected to their peers. ## TODO - [x] Make sure only nodes that are authorities on producation chains will be affected by this restrictions. - [x] Proper PRDOC, to make sure node operators are aware this is coming. --------- Signed-off-by: Alexandru Gheorghe <alexandru.gheorghe@parity.io> Co-authored-by: Dmitry Markin <dmitry@markin.tech> Co-authored-by: s0me0ne-unkn0wn <48632512+s0me0ne-unkn0wn@users.noreply.github.com> Co-authored-by: Bastian Köcher <git@kchr.de>
102 lines
3.0 KiB
Rust
102 lines
3.0 KiB
Rust
// Copyright (C) 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/>.
|
|
|
|
// Unix only since it uses signals.
|
|
#![cfg(unix)]
|
|
|
|
use assert_cmd::cargo::cargo_bin;
|
|
use common::run_with_timeout;
|
|
use nix::{
|
|
sys::signal::{kill, Signal::SIGINT},
|
|
unistd::Pid,
|
|
};
|
|
use std::{
|
|
path::Path,
|
|
process::{self, Command},
|
|
result::Result,
|
|
time::Duration,
|
|
};
|
|
use tempfile::tempdir;
|
|
|
|
pub mod common;
|
|
|
|
static RUNTIMES: &[&str] = &["westend", "rococo"];
|
|
|
|
/// `benchmark block` works for all dev runtimes using the wasm executor.
|
|
#[tokio::test]
|
|
async fn benchmark_block_works() {
|
|
for runtime in RUNTIMES {
|
|
run_with_timeout(Duration::from_secs(10 * 60), async move {
|
|
let tmp_dir = tempdir().expect("could not create a temp dir");
|
|
let base_path = tmp_dir.path();
|
|
let runtime = format!("{}-dev", runtime);
|
|
|
|
// Build a chain with a single block.
|
|
build_chain(&runtime, base_path).await;
|
|
// Benchmark the one block.
|
|
benchmark_block(&runtime, base_path, 1).unwrap();
|
|
})
|
|
.await
|
|
}
|
|
}
|
|
|
|
/// Builds a chain with one block for the given runtime and base path.
|
|
async fn build_chain(runtime: &str, base_path: &Path) {
|
|
let mut cmd = Command::new(cargo_bin("polkadot"))
|
|
.stdout(process::Stdio::piped())
|
|
.stderr(process::Stdio::piped())
|
|
.args([
|
|
"--chain",
|
|
runtime,
|
|
"--force-authoring",
|
|
"--alice",
|
|
"--unsafe-force-node-key-generation",
|
|
])
|
|
.arg("-d")
|
|
.arg(base_path)
|
|
.arg("--no-hardware-benchmarks")
|
|
.spawn()
|
|
.unwrap();
|
|
|
|
let (ws_url, _) = common::find_ws_url_from_output(cmd.stderr.take().unwrap());
|
|
|
|
// Wait for the chain to produce one block.
|
|
common::wait_n_finalized_blocks(1, &ws_url).await;
|
|
// Send SIGINT to node.
|
|
kill(Pid::from_raw(cmd.id().try_into().unwrap()), SIGINT).unwrap();
|
|
assert!(cmd.wait().unwrap().success());
|
|
}
|
|
|
|
/// Benchmarks the given block with the wasm executor.
|
|
fn benchmark_block(runtime: &str, base_path: &Path, block: u32) -> Result<(), String> {
|
|
// Invoke `benchmark block` with all options to make sure that they are valid.
|
|
let status = Command::new(cargo_bin("polkadot"))
|
|
.args(["benchmark", "block", "--chain", runtime])
|
|
.arg("-d")
|
|
.arg(base_path)
|
|
.args(["--from", &block.to_string(), "--to", &block.to_string()])
|
|
.args(["--repeat", "1"])
|
|
.args(["--wasm-execution", "compiled"])
|
|
.status()
|
|
.map_err(|e| format!("command failed: {:?}", e))?;
|
|
|
|
if !status.success() {
|
|
return Err("Command failed".into())
|
|
}
|
|
|
|
Ok(())
|
|
}
|