mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-13 21:01:05 +00:00
98.6% OF DEVELOPERS CANNOT REVIEW THIS PR! [read more...] (#7337)
* [WIP] PVF: Split out worker binaries * Address compilation problems and re-design a bit * Reorganize once more, fix tests * Reformat with new nightly to make `cargo fmt` test happy * Address `clippy` warnings * Add temporary trace to debug zombienet tests * Fix zombienet node upgrade test * Fix malus and its CI * Fix building worker binaries with malus * More fixes for malus * Remove unneeded cli subcommands * Support placing auxiliary binaries to `/usr/libexec` * Fix spelling * Spelling Co-authored-by: Marcin S. <marcin@realemail.net> * Implement review comments (mostly nits) * Fix worker node version flag * Rework getting the worker paths * Address a couple of review comments * Minor restructuring * Fix CI error * Add tests for worker binaries detection * Improve tests; try to fix CI * Move workers module into separate file * Try to fix failing test and workers not printing latest version - Tests were not finding the worker binaries - Workers were not being rebuilt when the version changed - Made some errors easier to read * Make a bunch of fixes * Rebuild nodes on version change * Fix more issues * Fix tests * Pass node version from node into dependencies to avoid recompiles - [X] get version in CLI - [X] pass it in to service - [X] pass version along to PVF - [X] remove rerun from service - [X] add rerun to CLI - [X] don’t rerun pvf/worker’s (these should be built by nodes which have rerun enabled) * Some more improvements for smoother tests - [X] Fix tests - [X] Make puppet workers pass None for version and remove rerun - [X] Make test collators self-contained * Add back rerun to PVF workers * Move worker binaries into files in cli crate As a final optimization I've separated out each worker binary from its own crate into the CLI crate. Before, the worker bin shared a crate with the worker lib, so when the binaries got recompiled so did the libs and everything transitively depending on the libs. This commit fixes this regression that was causing recompiles after every commit. * Fix bug (was passing worker version for node version) * Move workers out of cli into root src/bin/ dir - [X] Pass in node version from top-level (polkadot) - [X] Add build.rs with rerun-git-head to root dir * Add some sanity checks for workers to dockerfiles * Update malus + [X] Make it self-contained + [X] Undo multiple binary changes * Try to fix clippy errors * Address `cargo run` issue - [X] Add default-run for polkadot - [X] Add note about installation to error * Update readme (installation instructions) * Allow disabling external workers for local/testing setups + [X] cli flag to enable single-binary mode + [X] Add message to error * Revert unnecessary Cargo.lock changes * Remove unnecessary build scripts from collators * Add back missing malus commands (should fix failing ZN job) * Some minor fixes * Update Cargo.lock * Fix some build errors * Undo self-contained binaries; cli flag to disable version check + [X] Remove --dont-run-external-workers + [X] Add --disable-worker-version-check + [X] Remove PVF subcommands + [X] Redo malus changes * Try to fix failing job and add some docs for local tests --------- Co-authored-by: Dmitry Sinyavin <dmitry.sinyavin@parity.io> Co-authored-by: s0me0ne-unkn0wn <48632512+s0me0ne-unkn0wn@users.noreply.github.com> Co-authored-by: parity-processbot <>
This commit is contained in:
Marcin S
@@ -27,6 +27,8 @@ mod relay_chain_selection;
|
||||
|
||||
#[cfg(feature = "full-node")]
|
||||
pub mod overseer;
|
||||
#[cfg(feature = "full-node")]
|
||||
pub mod workers;
|
||||
|
||||
#[cfg(feature = "full-node")]
|
||||
pub use self::overseer::{OverseerGen, OverseerGenArgs, RealOverseerGen};
|
||||
@@ -73,7 +75,7 @@ pub use {
|
||||
#[cfg(feature = "full-node")]
|
||||
use polkadot_node_subsystem::jaeger;
|
||||
|
||||
use std::{sync::Arc, time::Duration};
|
||||
use std::{path::PathBuf, sync::Arc, time::Duration};
|
||||
|
||||
use prometheus_endpoint::Registry;
|
||||
#[cfg(feature = "full-node")]
|
||||
@@ -235,6 +237,26 @@ pub enum Error {
|
||||
#[cfg(feature = "full-node")]
|
||||
#[error("Expected at least one of polkadot, kusama, westend or rococo runtime feature")]
|
||||
NoRuntime,
|
||||
|
||||
#[cfg(feature = "full-node")]
|
||||
#[error("Worker binaries not executable, prepare binary: {prep_worker_path:?}, execute binary: {exec_worker_path:?}")]
|
||||
InvalidWorkerBinaries { prep_worker_path: PathBuf, exec_worker_path: PathBuf },
|
||||
|
||||
#[cfg(feature = "full-node")]
|
||||
#[error("Worker binaries could not be found, make sure polkadot was built/installed correctly. Searched given workers path ({given_workers_path:?}), polkadot binary path ({current_exe_path:?}), and lib path (/usr/lib/polkadot), workers names: {workers_names:?}")]
|
||||
MissingWorkerBinaries {
|
||||
given_workers_path: Option<PathBuf>,
|
||||
current_exe_path: PathBuf,
|
||||
workers_names: Option<(String, String)>,
|
||||
},
|
||||
|
||||
#[cfg(feature = "full-node")]
|
||||
#[error("Version of worker binary ({worker_version}) is different from node version ({node_version}), worker_path: {worker_path}. TESTING ONLY: this check can be disabled with --disable-worker-version-check")]
|
||||
WorkerBinaryVersionMismatch {
|
||||
worker_version: String,
|
||||
node_version: String,
|
||||
worker_path: PathBuf,
|
||||
},
|
||||
}
|
||||
|
||||
/// Identifies the variant of the chain.
|
||||
@@ -603,6 +625,28 @@ where
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(feature = "full-node")]
|
||||
pub struct NewFullParams<OverseerGenerator: OverseerGen> {
|
||||
pub is_collator: IsCollator,
|
||||
pub grandpa_pause: Option<(u32, u32)>,
|
||||
pub enable_beefy: bool,
|
||||
pub jaeger_agent: Option<std::net::SocketAddr>,
|
||||
pub telemetry_worker_handle: Option<TelemetryWorkerHandle>,
|
||||
/// The version of the node. TESTING ONLY: `None` can be passed to skip the node/worker version
|
||||
/// check, both on startup and in the workers.
|
||||
pub node_version: Option<String>,
|
||||
/// An optional path to a directory containing the workers.
|
||||
pub workers_path: Option<std::path::PathBuf>,
|
||||
/// Optional custom names for the prepare and execute workers.
|
||||
pub workers_names: Option<(String, String)>,
|
||||
pub overseer_enable_anyways: bool,
|
||||
pub overseer_gen: OverseerGenerator,
|
||||
pub overseer_message_channel_capacity_override: Option<usize>,
|
||||
#[allow(dead_code)]
|
||||
pub malus_finality_delay: Option<u32>,
|
||||
pub hwbench: Option<sc_sysinfo::HwBench>,
|
||||
}
|
||||
|
||||
#[cfg(feature = "full-node")]
|
||||
pub struct NewFull {
|
||||
pub task_manager: TaskManager,
|
||||
@@ -656,24 +700,30 @@ pub const AVAILABILITY_CONFIG: AvailabilityConfig = AvailabilityConfig {
|
||||
/// `overseer_enable_anyways` always enables the overseer, based on the provided `OverseerGenerator`,
|
||||
/// regardless of the role the node has. The relay chain selection (longest or disputes-aware) is
|
||||
/// still determined based on the role of the node. Likewise for authority discovery.
|
||||
///
|
||||
/// `workers_path` is used to get the path to the directory where auxiliary worker binaries reside.
|
||||
/// If not specified, the main binary's directory is searched first, then `/usr/lib/polkadot` is
|
||||
/// searched. If the path points to an executable rather then directory, that executable is used
|
||||
/// both as preparation and execution worker (supposed to be used for tests only).
|
||||
#[cfg(feature = "full-node")]
|
||||
pub fn new_full<OverseerGenerator>(
|
||||
pub fn new_full<OverseerGenerator: OverseerGen>(
|
||||
mut config: Configuration,
|
||||
is_collator: IsCollator,
|
||||
grandpa_pause: Option<(u32, u32)>,
|
||||
enable_beefy: bool,
|
||||
jaeger_agent: Option<std::net::SocketAddr>,
|
||||
telemetry_worker_handle: Option<TelemetryWorkerHandle>,
|
||||
program_path: Option<std::path::PathBuf>,
|
||||
overseer_enable_anyways: bool,
|
||||
overseer_gen: OverseerGenerator,
|
||||
overseer_message_channel_capacity_override: Option<usize>,
|
||||
_malus_finality_delay: Option<u32>,
|
||||
hwbench: Option<sc_sysinfo::HwBench>,
|
||||
) -> Result<NewFull, Error>
|
||||
where
|
||||
OverseerGenerator: OverseerGen,
|
||||
{
|
||||
NewFullParams {
|
||||
is_collator,
|
||||
grandpa_pause,
|
||||
enable_beefy,
|
||||
jaeger_agent,
|
||||
telemetry_worker_handle,
|
||||
node_version,
|
||||
workers_path,
|
||||
workers_names,
|
||||
overseer_enable_anyways,
|
||||
overseer_gen,
|
||||
overseer_message_channel_capacity_override,
|
||||
malus_finality_delay: _malus_finality_delay,
|
||||
hwbench,
|
||||
}: NewFullParams<OverseerGenerator>,
|
||||
) -> Result<NewFull, Error> {
|
||||
use polkadot_node_network_protocol::request_response::IncomingRequest;
|
||||
use sc_network_common::sync::warp::WarpSyncParams;
|
||||
|
||||
@@ -859,16 +909,24 @@ where
|
||||
slot_duration_millis: slot_duration.as_millis() as u64,
|
||||
};
|
||||
|
||||
let candidate_validation_config = CandidateValidationConfig {
|
||||
artifacts_cache_path: config
|
||||
.database
|
||||
.path()
|
||||
.ok_or(Error::DatabasePathRequired)?
|
||||
.join("pvf-artifacts"),
|
||||
program_path: match program_path {
|
||||
None => std::env::current_exe()?,
|
||||
Some(p) => p,
|
||||
},
|
||||
let candidate_validation_config = if is_collator.is_collator() {
|
||||
None
|
||||
} else {
|
||||
let (prep_worker_path, exec_worker_path) =
|
||||
workers::determine_workers_paths(workers_path, workers_names, node_version.clone())?;
|
||||
log::info!("🚀 Using prepare-worker binary at: {:?}", prep_worker_path);
|
||||
log::info!("🚀 Using execute-worker binary at: {:?}", exec_worker_path);
|
||||
|
||||
Some(CandidateValidationConfig {
|
||||
artifacts_cache_path: config
|
||||
.database
|
||||
.path()
|
||||
.ok_or(Error::DatabasePathRequired)?
|
||||
.join("pvf-artifacts"),
|
||||
node_version,
|
||||
prep_worker_path,
|
||||
exec_worker_path,
|
||||
})
|
||||
};
|
||||
|
||||
let chain_selection_config = ChainSelectionConfig {
|
||||
@@ -1278,40 +1336,21 @@ pub fn new_chain_ops(
|
||||
/// regardless of the role the node has. The relay chain selection (longest or disputes-aware) is
|
||||
/// still determined based on the role of the node. Likewise for authority discovery.
|
||||
#[cfg(feature = "full-node")]
|
||||
pub fn build_full(
|
||||
pub fn build_full<OverseerGenerator: OverseerGen>(
|
||||
config: Configuration,
|
||||
is_collator: IsCollator,
|
||||
grandpa_pause: Option<(u32, u32)>,
|
||||
enable_beefy: bool,
|
||||
jaeger_agent: Option<std::net::SocketAddr>,
|
||||
telemetry_worker_handle: Option<TelemetryWorkerHandle>,
|
||||
overseer_enable_anyways: bool,
|
||||
overseer_gen: impl OverseerGen,
|
||||
overseer_message_channel_override: Option<usize>,
|
||||
malus_finality_delay: Option<u32>,
|
||||
hwbench: Option<sc_sysinfo::HwBench>,
|
||||
mut params: NewFullParams<OverseerGenerator>,
|
||||
) -> Result<NewFull, Error> {
|
||||
let is_polkadot = config.chain_spec.is_polkadot();
|
||||
|
||||
new_full(
|
||||
config,
|
||||
is_collator,
|
||||
grandpa_pause,
|
||||
enable_beefy,
|
||||
jaeger_agent,
|
||||
telemetry_worker_handle,
|
||||
None,
|
||||
overseer_enable_anyways,
|
||||
overseer_gen,
|
||||
overseer_message_channel_override.map(move |capacity| {
|
||||
params.overseer_message_channel_capacity_override =
|
||||
params.overseer_message_channel_capacity_override.map(move |capacity| {
|
||||
if is_polkadot {
|
||||
gum::warn!("Channel capacity should _never_ be tampered with on polkadot!");
|
||||
}
|
||||
capacity
|
||||
}),
|
||||
malus_finality_delay,
|
||||
hwbench,
|
||||
)
|
||||
});
|
||||
|
||||
new_full(config, params)
|
||||
}
|
||||
|
||||
/// Reverts the node state down to at most the last finalized block.
|
||||
|
||||
@@ -114,7 +114,7 @@ where
|
||||
/// Configuration for the availability store subsystem.
|
||||
pub availability_config: AvailabilityConfig,
|
||||
/// Configuration for the candidate validation subsystem.
|
||||
pub candidate_validation_config: CandidateValidationConfig,
|
||||
pub candidate_validation_config: Option<CandidateValidationConfig>,
|
||||
/// Configuration for the chain selection subsystem.
|
||||
pub chain_selection_config: ChainSelectionConfig,
|
||||
/// Configuration for the dispute coordinator subsystem.
|
||||
|
||||
@@ -0,0 +1,520 @@
|
||||
// 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/>.
|
||||
|
||||
//! Utilities and tests for locating the PVF worker binaries.
|
||||
|
||||
use super::Error;
|
||||
use is_executable::IsExecutable;
|
||||
use std::{path::PathBuf, process::Command};
|
||||
|
||||
#[cfg(test)]
|
||||
use std::sync::{Mutex, OnceLock};
|
||||
|
||||
/// Override the workers polkadot binary directory path, used for testing.
|
||||
#[cfg(test)]
|
||||
fn workers_exe_path_override() -> &'static Mutex<Option<PathBuf>> {
|
||||
static OVERRIDE: OnceLock<Mutex<Option<PathBuf>>> = OnceLock::new();
|
||||
OVERRIDE.get_or_init(|| Mutex::new(None))
|
||||
}
|
||||
/// Override the workers lib directory path, used for testing.
|
||||
#[cfg(test)]
|
||||
fn workers_lib_path_override() -> &'static Mutex<Option<PathBuf>> {
|
||||
static OVERRIDE: OnceLock<Mutex<Option<PathBuf>>> = OnceLock::new();
|
||||
OVERRIDE.get_or_init(|| Mutex::new(None))
|
||||
}
|
||||
|
||||
/// Determines the final set of paths to use for the PVF workers.
|
||||
///
|
||||
/// 1. Get the binaries from the workers path if it is passed in, or consider all possible
|
||||
/// locations on the filesystem in order and get all sets of paths at which the binaries exist.
|
||||
///
|
||||
/// 2. If no paths exist, error out. We can't proceed without workers.
|
||||
///
|
||||
/// 3. Log a warning if more than one set of paths exists. Continue with the first set of paths.
|
||||
///
|
||||
/// 4. Check if the returned paths are executable. If not it's evidence of a borked installation
|
||||
/// so error out.
|
||||
///
|
||||
/// 5. Do the version check, if mismatch error out.
|
||||
///
|
||||
/// 6. At this point the final set of paths should be good to use.
|
||||
pub fn determine_workers_paths(
|
||||
given_workers_path: Option<PathBuf>,
|
||||
workers_names: Option<(String, String)>,
|
||||
node_version: Option<String>,
|
||||
) -> Result<(PathBuf, PathBuf), Error> {
|
||||
let mut workers_paths = list_workers_paths(given_workers_path.clone(), workers_names.clone())?;
|
||||
if workers_paths.is_empty() {
|
||||
let current_exe_path = get_exe_path()?;
|
||||
return Err(Error::MissingWorkerBinaries {
|
||||
given_workers_path,
|
||||
current_exe_path,
|
||||
workers_names,
|
||||
})
|
||||
} else if workers_paths.len() > 1 {
|
||||
log::warn!("multiple sets of worker binaries found ({:?})", workers_paths,);
|
||||
}
|
||||
|
||||
let (prep_worker_path, exec_worker_path) = workers_paths.swap_remove(0);
|
||||
if !prep_worker_path.is_executable() || !exec_worker_path.is_executable() {
|
||||
return Err(Error::InvalidWorkerBinaries { prep_worker_path, exec_worker_path })
|
||||
}
|
||||
|
||||
// Do the version check.
|
||||
if let Some(node_version) = node_version {
|
||||
let worker_version = Command::new(&prep_worker_path).args(["--version"]).output()?.stdout;
|
||||
let worker_version = std::str::from_utf8(&worker_version)
|
||||
.expect("version is printed as a string; qed")
|
||||
.trim()
|
||||
.to_string();
|
||||
if worker_version != node_version {
|
||||
return Err(Error::WorkerBinaryVersionMismatch {
|
||||
worker_version,
|
||||
node_version,
|
||||
worker_path: prep_worker_path,
|
||||
})
|
||||
}
|
||||
let worker_version = Command::new(&exec_worker_path).args(["--version"]).output()?.stdout;
|
||||
let worker_version = std::str::from_utf8(&worker_version)
|
||||
.expect("version is printed as a string; qed")
|
||||
.trim()
|
||||
.to_string();
|
||||
if worker_version != node_version {
|
||||
return Err(Error::WorkerBinaryVersionMismatch {
|
||||
worker_version,
|
||||
node_version,
|
||||
worker_path: exec_worker_path,
|
||||
})
|
||||
}
|
||||
} else {
|
||||
log::warn!("Skipping node/worker version checks. This could result in incorrect behavior in PVF workers.");
|
||||
}
|
||||
|
||||
Ok((prep_worker_path, exec_worker_path))
|
||||
}
|
||||
|
||||
/// Get list of workers paths by considering the passed-in `given_workers_path` option, or possible
|
||||
/// locations on the filesystem. See `new_full`.
|
||||
fn list_workers_paths(
|
||||
given_workers_path: Option<PathBuf>,
|
||||
workers_names: Option<(String, String)>,
|
||||
) -> Result<Vec<(PathBuf, PathBuf)>, Error> {
|
||||
if let Some(path) = given_workers_path {
|
||||
log::trace!("Using explicitly provided workers path {:?}", path);
|
||||
|
||||
if path.is_executable() {
|
||||
return Ok(vec![(path.clone(), path)])
|
||||
}
|
||||
|
||||
let (prep_worker, exec_worker) = build_worker_paths(path, workers_names);
|
||||
|
||||
// Check if both workers exist. Otherwise return an empty vector which results in an error.
|
||||
return if prep_worker.exists() && exec_worker.exists() {
|
||||
Ok(vec![(prep_worker, exec_worker)])
|
||||
} else {
|
||||
Ok(vec![])
|
||||
}
|
||||
}
|
||||
|
||||
// Workers path not provided, check all possible valid locations.
|
||||
|
||||
let mut workers_paths = vec![];
|
||||
|
||||
// Consider the polkadot binary directory.
|
||||
{
|
||||
let exe_path = get_exe_path()?;
|
||||
|
||||
let (prep_worker, exec_worker) =
|
||||
build_worker_paths(exe_path.clone(), workers_names.clone());
|
||||
|
||||
// Add to set if both workers exist. Warn on partial installs.
|
||||
let (prep_worker_exists, exec_worker_exists) = (prep_worker.exists(), exec_worker.exists());
|
||||
if prep_worker_exists && exec_worker_exists {
|
||||
log::trace!("Worker binaries found at current exe path: {:?}", exe_path);
|
||||
workers_paths.push((prep_worker, exec_worker));
|
||||
} else if prep_worker_exists {
|
||||
log::warn!("Worker binary found at {:?} but not {:?}", prep_worker, exec_worker);
|
||||
} else if exec_worker_exists {
|
||||
log::warn!("Worker binary found at {:?} but not {:?}", exec_worker, prep_worker);
|
||||
}
|
||||
}
|
||||
|
||||
// Consider the /usr/lib/polkadot/ directory.
|
||||
{
|
||||
#[allow(unused_mut)]
|
||||
let mut lib_path = PathBuf::from("/usr/lib/polkadot");
|
||||
#[cfg(test)]
|
||||
if let Some(ref path_override) = *workers_lib_path_override().lock().unwrap() {
|
||||
lib_path = path_override.clone();
|
||||
}
|
||||
|
||||
let (prep_worker, exec_worker) = build_worker_paths(lib_path, workers_names);
|
||||
|
||||
// Add to set if both workers exist. Warn on partial installs.
|
||||
let (prep_worker_exists, exec_worker_exists) = (prep_worker.exists(), exec_worker.exists());
|
||||
if prep_worker_exists && exec_worker_exists {
|
||||
log::trace!("Worker binaries found at /usr/lib/polkadot");
|
||||
workers_paths.push((prep_worker, exec_worker));
|
||||
} else if prep_worker_exists {
|
||||
log::warn!("Worker binary found at {:?} but not {:?}", prep_worker, exec_worker);
|
||||
} else if exec_worker_exists {
|
||||
log::warn!("Worker binary found at {:?} but not {:?}", exec_worker, prep_worker);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(workers_paths)
|
||||
}
|
||||
|
||||
fn get_exe_path() -> Result<PathBuf, Error> {
|
||||
let mut exe_path = std::env::current_exe()?;
|
||||
let _ = exe_path.pop(); // executable file will always have a parent directory.
|
||||
#[cfg(test)]
|
||||
if let Some(ref path_override) = *workers_exe_path_override().lock().unwrap() {
|
||||
exe_path = path_override.clone();
|
||||
}
|
||||
Ok(exe_path)
|
||||
}
|
||||
|
||||
fn build_worker_paths(
|
||||
worker_dir: PathBuf,
|
||||
workers_names: Option<(String, String)>,
|
||||
) -> (PathBuf, PathBuf) {
|
||||
let (prep_worker_name, exec_worker_name) = workers_names.unwrap_or((
|
||||
polkadot_node_core_pvf::PREPARE_BINARY_NAME.to_string(),
|
||||
polkadot_node_core_pvf::EXECUTE_BINARY_NAME.to_string(),
|
||||
));
|
||||
|
||||
let mut prep_worker = worker_dir.clone();
|
||||
prep_worker.push(prep_worker_name);
|
||||
let mut exec_worker = worker_dir;
|
||||
exec_worker.push(exec_worker_name);
|
||||
|
||||
(prep_worker, exec_worker)
|
||||
}
|
||||
|
||||
// Tests that set up a temporary directory tree according to what scenario we want to test and
|
||||
// run worker detection.
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
use assert_matches::assert_matches;
|
||||
use serial_test::serial;
|
||||
use std::{env::temp_dir, fs, os::unix::fs::PermissionsExt, path::Path};
|
||||
|
||||
const NODE_VERSION: &'static str = "v0.1.2";
|
||||
|
||||
/// Write a dummy executable to the path which satisfies the version check.
|
||||
fn write_worker_exe(path: impl AsRef<Path>) -> Result<(), Box<dyn std::error::Error>> {
|
||||
let program = get_program(NODE_VERSION);
|
||||
fs::write(&path, program)?;
|
||||
Ok(fs::set_permissions(&path, fs::Permissions::from_mode(0o744))?)
|
||||
}
|
||||
|
||||
fn write_worker_exe_invalid_version(
|
||||
path: impl AsRef<Path>,
|
||||
version: &str,
|
||||
) -> Result<(), Box<dyn std::error::Error>> {
|
||||
let program = get_program(version);
|
||||
fs::write(&path, program)?;
|
||||
Ok(fs::set_permissions(&path, fs::Permissions::from_mode(0o744))?)
|
||||
}
|
||||
|
||||
fn get_program(version: &str) -> String {
|
||||
format!(
|
||||
"#!/bin/bash
|
||||
|
||||
if [[ $# -ne 1 ]] ; then
|
||||
echo \"unexpected number of arguments: $#\"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [[ \"$1\" != \"--version\" ]] ; then
|
||||
echo \"unexpected argument: $1\"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo {}
|
||||
",
|
||||
version
|
||||
)
|
||||
}
|
||||
|
||||
/// Sets up an empty temp dir structure where the workers can be put by tests. Uses the temp dir
|
||||
/// to override the standard locations where the node searches for the workers.
|
||||
fn with_temp_dir_structure(
|
||||
f: impl FnOnce(PathBuf, PathBuf) -> Result<(), Box<dyn std::error::Error>>,
|
||||
) -> Result<(), Box<dyn std::error::Error>> {
|
||||
// Set up <tmp>/usr/lib/polkadot and <tmp>/usr/bin, both empty.
|
||||
|
||||
let tempdir = temp_dir();
|
||||
let lib_path = tempdir.join("usr/lib/polkadot");
|
||||
let _ = fs::remove_dir_all(&lib_path);
|
||||
fs::create_dir_all(&lib_path)?;
|
||||
*workers_lib_path_override().lock()? = Some(lib_path);
|
||||
|
||||
let exe_path = tempdir.join("usr/bin");
|
||||
let _ = fs::remove_dir_all(&exe_path);
|
||||
fs::create_dir_all(&exe_path)?;
|
||||
*workers_exe_path_override().lock()? = Some(exe_path.clone());
|
||||
|
||||
// Set up custom path at <tmp>/usr/local/bin.
|
||||
let custom_path = tempdir.join("usr/local/bin");
|
||||
let _ = fs::remove_dir_all(&custom_path);
|
||||
fs::create_dir_all(&custom_path)?;
|
||||
|
||||
f(tempdir, exe_path)
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn test_given_worker_path() {
|
||||
with_temp_dir_structure(|tempdir, exe_path| {
|
||||
let given_workers_path = tempdir.join("usr/local/bin");
|
||||
|
||||
// Try with provided workers path that has missing binaries.
|
||||
assert_matches!(
|
||||
determine_workers_paths(Some(given_workers_path.clone()), None, Some(NODE_VERSION.into())),
|
||||
Err(Error::MissingWorkerBinaries { given_workers_path: Some(p1), current_exe_path: p2, workers_names: None }) if p1 == given_workers_path && p2 == exe_path
|
||||
);
|
||||
|
||||
// Try with provided workers path that has non-executable binaries.
|
||||
let prepare_worker_path = given_workers_path.join("polkadot-prepare-worker");
|
||||
write_worker_exe(&prepare_worker_path)?;
|
||||
fs::set_permissions(&prepare_worker_path, fs::Permissions::from_mode(0o644))?;
|
||||
let execute_worker_path = given_workers_path.join("polkadot-execute-worker");
|
||||
write_worker_exe(&execute_worker_path)?;
|
||||
fs::set_permissions(&execute_worker_path, fs::Permissions::from_mode(0o644))?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(Some(given_workers_path.clone()), None, Some(NODE_VERSION.into())),
|
||||
Err(Error::InvalidWorkerBinaries { prep_worker_path: p1, exec_worker_path: p2 }) if p1 == prepare_worker_path && p2 == execute_worker_path
|
||||
);
|
||||
|
||||
// Try with valid workers directory path that has executable binaries.
|
||||
fs::set_permissions(&prepare_worker_path, fs::Permissions::from_mode(0o744))?;
|
||||
fs::set_permissions(&execute_worker_path, fs::Permissions::from_mode(0o744))?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(Some(given_workers_path), None, Some(NODE_VERSION.into())),
|
||||
Ok((p1, p2)) if p1 == prepare_worker_path && p2 == execute_worker_path
|
||||
);
|
||||
|
||||
// Try with valid provided workers path that is a binary file.
|
||||
let given_workers_path = tempdir.join("usr/local/bin/puppet-worker");
|
||||
write_worker_exe(&given_workers_path)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(Some(given_workers_path.clone()), None, Some(NODE_VERSION.into())),
|
||||
Ok((p1, p2)) if p1 == given_workers_path && p2 == given_workers_path
|
||||
);
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn missing_workers_paths_throws_error() {
|
||||
with_temp_dir_structure(|tempdir, exe_path| {
|
||||
// Try with both binaries missing.
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Err(Error::MissingWorkerBinaries { given_workers_path: None, current_exe_path: p, workers_names: None }) if p == exe_path
|
||||
);
|
||||
|
||||
// Try with only prep worker (at bin location).
|
||||
let prepare_worker_path = tempdir.join("usr/bin/polkadot-prepare-worker");
|
||||
write_worker_exe(&prepare_worker_path)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Err(Error::MissingWorkerBinaries { given_workers_path: None, current_exe_path: p, workers_names: None }) if p == exe_path
|
||||
);
|
||||
|
||||
// Try with only exec worker (at bin location).
|
||||
fs::remove_file(&prepare_worker_path)?;
|
||||
let execute_worker_path = tempdir.join("usr/bin/polkadot-execute-worker");
|
||||
write_worker_exe(&execute_worker_path)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Err(Error::MissingWorkerBinaries { given_workers_path: None, current_exe_path: p, workers_names: None }) if p == exe_path
|
||||
);
|
||||
|
||||
// Try with only prep worker (at lib location).
|
||||
fs::remove_file(&execute_worker_path)?;
|
||||
let prepare_worker_path = tempdir.join("usr/lib/polkadot/polkadot-prepare-worker");
|
||||
write_worker_exe(&prepare_worker_path)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Err(Error::MissingWorkerBinaries { given_workers_path: None, current_exe_path: p, workers_names: None }) if p == exe_path
|
||||
);
|
||||
|
||||
// Try with only exec worker (at lib location).
|
||||
fs::remove_file(&prepare_worker_path)?;
|
||||
let execute_worker_path = tempdir.join("usr/lib/polkadot/polkadot-execute-worker");
|
||||
write_worker_exe(execute_worker_path)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Err(Error::MissingWorkerBinaries { given_workers_path: None, current_exe_path: p, workers_names: None }) if p == exe_path
|
||||
);
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn should_find_workers_at_all_locations() {
|
||||
with_temp_dir_structure(|tempdir, _| {
|
||||
let prepare_worker_bin_path = tempdir.join("usr/bin/polkadot-prepare-worker");
|
||||
write_worker_exe(&prepare_worker_bin_path)?;
|
||||
|
||||
let execute_worker_bin_path = tempdir.join("usr/bin/polkadot-execute-worker");
|
||||
write_worker_exe(&execute_worker_bin_path)?;
|
||||
|
||||
let prepare_worker_lib_path = tempdir.join("usr/lib/polkadot/polkadot-prepare-worker");
|
||||
write_worker_exe(&prepare_worker_lib_path)?;
|
||||
|
||||
let execute_worker_lib_path = tempdir.join("usr/lib/polkadot/polkadot-execute-worker");
|
||||
write_worker_exe(&execute_worker_lib_path)?;
|
||||
|
||||
assert_matches!(
|
||||
list_workers_paths(None, None),
|
||||
Ok(v) if v == vec![(prepare_worker_bin_path, execute_worker_bin_path), (prepare_worker_lib_path, execute_worker_lib_path)]
|
||||
);
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn should_find_workers_with_custom_names_at_all_locations() {
|
||||
with_temp_dir_structure(|tempdir, _| {
|
||||
let (prep_worker_name, exec_worker_name) = ("test-prepare", "test-execute");
|
||||
|
||||
let prepare_worker_bin_path = tempdir.join("usr/bin").join(prep_worker_name);
|
||||
write_worker_exe(&prepare_worker_bin_path)?;
|
||||
|
||||
let execute_worker_bin_path = tempdir.join("usr/bin").join(exec_worker_name);
|
||||
write_worker_exe(&execute_worker_bin_path)?;
|
||||
|
||||
let prepare_worker_lib_path = tempdir.join("usr/lib/polkadot").join(prep_worker_name);
|
||||
write_worker_exe(&prepare_worker_lib_path)?;
|
||||
|
||||
let execute_worker_lib_path = tempdir.join("usr/lib/polkadot").join(exec_worker_name);
|
||||
write_worker_exe(&execute_worker_lib_path)?;
|
||||
|
||||
assert_matches!(
|
||||
list_workers_paths(None, Some((prep_worker_name.into(), exec_worker_name.into()))),
|
||||
Ok(v) if v == vec![(prepare_worker_bin_path, execute_worker_bin_path), (prepare_worker_lib_path, execute_worker_lib_path)]
|
||||
);
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn workers_version_mismatch_throws_error() {
|
||||
let bad_version = "v9.9.9.9";
|
||||
|
||||
with_temp_dir_structure(|tempdir, _| {
|
||||
// Workers at bin location return bad version.
|
||||
let prepare_worker_bin_path = tempdir.join("usr/bin/polkadot-prepare-worker");
|
||||
let execute_worker_bin_path = tempdir.join("usr/bin/polkadot-execute-worker");
|
||||
write_worker_exe_invalid_version(&prepare_worker_bin_path, bad_version)?;
|
||||
write_worker_exe(&execute_worker_bin_path)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Err(Error::WorkerBinaryVersionMismatch { worker_version: v1, node_version: v2, worker_path: p }) if v1 == bad_version && v2 == NODE_VERSION && p == prepare_worker_bin_path
|
||||
);
|
||||
|
||||
// Workers at lib location return bad version.
|
||||
fs::remove_file(prepare_worker_bin_path)?;
|
||||
fs::remove_file(execute_worker_bin_path)?;
|
||||
let prepare_worker_lib_path = tempdir.join("usr/lib/polkadot/polkadot-prepare-worker");
|
||||
let execute_worker_lib_path = tempdir.join("usr/lib/polkadot/polkadot-execute-worker");
|
||||
write_worker_exe(&prepare_worker_lib_path)?;
|
||||
write_worker_exe_invalid_version(&execute_worker_lib_path, bad_version)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Err(Error::WorkerBinaryVersionMismatch { worker_version: v1, node_version: v2, worker_path: p }) if v1 == bad_version && v2 == NODE_VERSION && p == execute_worker_lib_path
|
||||
);
|
||||
|
||||
// Workers at provided workers location return bad version.
|
||||
let given_workers_path = tempdir.join("usr/local/bin");
|
||||
let prepare_worker_path = given_workers_path.join("polkadot-prepare-worker");
|
||||
let execute_worker_path = given_workers_path.join("polkadot-execute-worker");
|
||||
write_worker_exe_invalid_version(&prepare_worker_path, bad_version)?;
|
||||
write_worker_exe_invalid_version(&execute_worker_path, bad_version)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(Some(given_workers_path), None, Some(NODE_VERSION.into())),
|
||||
Err(Error::WorkerBinaryVersionMismatch { worker_version: v1, node_version: v2, worker_path: p }) if v1 == bad_version && v2 == NODE_VERSION && p == prepare_worker_path
|
||||
);
|
||||
|
||||
// Given worker binary returns bad version.
|
||||
let given_workers_path = tempdir.join("usr/local/bin/puppet-worker");
|
||||
write_worker_exe_invalid_version(&given_workers_path, bad_version)?;
|
||||
assert_matches!(
|
||||
determine_workers_paths(Some(given_workers_path.clone()), None, Some(NODE_VERSION.into())),
|
||||
Err(Error::WorkerBinaryVersionMismatch { worker_version: v1, node_version: v2, worker_path: p }) if v1 == bad_version && v2 == NODE_VERSION && p == given_workers_path
|
||||
);
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[serial]
|
||||
fn should_find_valid_workers() {
|
||||
// Test bin location.
|
||||
with_temp_dir_structure(|tempdir, _| {
|
||||
let prepare_worker_bin_path = tempdir.join("usr/bin/polkadot-prepare-worker");
|
||||
write_worker_exe(&prepare_worker_bin_path)?;
|
||||
|
||||
let execute_worker_bin_path = tempdir.join("usr/bin/polkadot-execute-worker");
|
||||
write_worker_exe(&execute_worker_bin_path)?;
|
||||
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Ok((p1, p2)) if p1 == prepare_worker_bin_path && p2 == execute_worker_bin_path
|
||||
);
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
|
||||
// Test lib location.
|
||||
with_temp_dir_structure(|tempdir, _| {
|
||||
let prepare_worker_lib_path = tempdir.join("usr/lib/polkadot/polkadot-prepare-worker");
|
||||
write_worker_exe(&prepare_worker_lib_path)?;
|
||||
|
||||
let execute_worker_lib_path = tempdir.join("usr/lib/polkadot/polkadot-execute-worker");
|
||||
write_worker_exe(&execute_worker_lib_path)?;
|
||||
|
||||
assert_matches!(
|
||||
determine_workers_paths(None, None, Some(NODE_VERSION.into())),
|
||||
Ok((p1, p2)) if p1 == prepare_worker_lib_path && p2 == execute_worker_lib_path
|
||||
);
|
||||
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user