1use std::{
2 cell::RefCell,
3 collections::HashSet,
4 fs,
5 marker::PhantomData,
6 path::{Path, PathBuf},
7 rc::Rc,
8};
9
10use anyhow::anyhow;
11use regex::{Captures, Regex};
12use serde::{Deserialize, Serialize};
13use support::{
14 constants::{NO_ERR_DEF_BUILDER, RELAY_NOT_NONE, THIS_IS_A_BUG, VALID_REGEX},
15 replacer::apply_env_replacements,
16};
17use tracing::trace;
18
19use crate::{
20 custom_process,
21 global_settings::{GlobalSettings, GlobalSettingsBuilder},
22 hrmp_channel::{self, HrmpChannelConfig, HrmpChannelConfigBuilder},
23 jamchain::{self, JamchainConfig, JamchainConfigBuilder},
24 parachain::{self, ParachainConfig, ParachainConfigBuilder},
25 relaychain::{self, RelaychainConfig, RelaychainConfigBuilder},
26 shared::{
27 errors::{ConfigError, ValidationError},
28 helpers::{generate_unique_node_name_from_names, merge_errors, merge_errors_vecs},
29 macros::states,
30 node::{GroupNodeConfig, NodeConfig},
31 types::{Arg, AssetLocation, Chain, Command, Image, ValidationContext},
32 },
33 types::ParaId,
34 CustomProcess, CustomProcessBuilder, RegistrationStrategy,
35};
36
37#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
43pub struct NetworkConfig {
44 #[serde(rename = "settings", default = "GlobalSettings::default")]
45 global_settings: GlobalSettings,
46 relaychain: Option<RelaychainConfig>,
47 jamchain: Option<JamchainConfig>,
48 #[serde(skip_serializing_if = "std::vec::Vec::is_empty", default)]
49 parachains: Vec<ParachainConfig>,
50 #[serde(skip_serializing_if = "std::vec::Vec::is_empty", default)]
51 hrmp_channels: Vec<HrmpChannelConfig>,
52 #[serde(skip_serializing_if = "std::vec::Vec::is_empty", default)]
53 custom_processes: Vec<CustomProcess>,
54}
55
56impl NetworkConfig {
57 pub fn global_settings(&self) -> &GlobalSettings {
59 &self.global_settings
60 }
61
62 pub fn relaychain(&self) -> &RelaychainConfig {
64 self.relaychain
65 .as_ref()
66 .expect(&format!("{RELAY_NOT_NONE}, {THIS_IS_A_BUG}"))
67 }
68
69 pub fn try_relaychain(&self) -> Option<&RelaychainConfig> {
71 self.relaychain.as_ref()
72 }
73
74 pub fn jamchain(&self) -> Option<&JamchainConfig> {
76 if let Some(jamconfig) = &self.jamchain {
77 Some(jamconfig)
78 } else {
79 None
80 }
81 }
82
83 pub fn parachains(&self) -> Vec<&ParachainConfig> {
85 self.parachains.iter().collect::<Vec<_>>()
86 }
87
88 pub fn hrmp_channels(&self) -> Vec<&HrmpChannelConfig> {
90 self.hrmp_channels.iter().collect::<Vec<_>>()
91 }
92
93 pub fn custom_processes(&self) -> Vec<&CustomProcess> {
95 self.custom_processes.iter().collect::<Vec<_>>()
96 }
97
98 fn set_parachains(&mut self, parachains: Vec<ParachainConfig>) {
100 self.parachains = parachains;
101 }
102
103 pub fn dump_to_toml(&self) -> Result<String, toml::ser::Error> {
105 let re = Regex::new(r#""U128%(?<u128_value>\d+)""#)
107 .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
108 let toml_string = toml::to_string_pretty(&self)?;
109
110 Ok(re.replace_all(&toml_string, "$u128_value").to_string())
111 }
112
113 pub fn load_from_toml_with_settings(
115 path: &str,
116 settings: &GlobalSettings,
117 ) -> Result<NetworkConfig, anyhow::Error> {
118 let mut network_config = NetworkConfig::load_from_toml(path)?;
119 network_config.global_settings = settings.clone();
120 Ok(network_config)
121 }
122
123 pub fn load_from_toml(path: &str) -> Result<NetworkConfig, anyhow::Error> {
125 let file_path = PathBuf::from(path).canonicalize()?;
126 let network_definition_dir = file_path
127 .parent()
128 .ok_or(anyhow!("should have a base dir"))?;
129 trace!(
130 "file_dir for replacer: {:?}",
131 network_definition_dir.as_os_str()
132 );
133 let file_str = fs::read_to_string(path)
134 .map_err(|e| anyhow!("Failed to read configuration file '{}': {}", path, e))?;
135
136 Self::load_from_toml_string_with_base_dir(&file_str, network_definition_dir)
137 }
138
139 pub fn load_from_toml_string(toml_data: &str) -> Result<NetworkConfig, anyhow::Error> {
146 let base_dir = std::env::current_dir()?;
147
148 Self::load_from_toml_string_with_base_dir(toml_data, &base_dir)
149 }
150
151 pub fn load_from_toml_string_with_base_dir(
154 toml_text: &str,
155 base_dir: &Path,
156 ) -> Result<NetworkConfig, anyhow::Error> {
157 let re: Regex = Regex::new(r"(?<field_name>(initial_)?balance)\s+=\s+(?<u128_value>\d+)")
158 .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
159
160 let re_paths: Regex = Regex::new(r#"(?<field_name>(default_)?(command|db_snapshot|chain_spec_path|genesis_wasm_path|genesis_state_path))\s+=\s+\"(?<value_string>[a-zA-Z0-9\.\/]+)\""#)
161 .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
162 let re_local_paths: Regex = Regex::new(
164 r#"(?m)(?<field_name>(?:^|[\s{,])local_path)\s*=\s*"(?<value_string>[^"]+)""#,
165 )
166 .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
167
168 let path_replacer = |caps: &Captures| {
169 trace!("cmd replacer captures: {:?}", caps);
170 let cmd = maybe_absolute(&caps["value_string"], base_dir);
171 let line = format!("{} = \"{cmd}\"", &caps["field_name"]);
172 trace!("line after replacer: {line}");
173 line
174 };
175
176 let toml_text = re.replace_all(toml_text, "$field_name = \"$u128_value\"");
177 let toml_text = re_paths.replace_all(&toml_text, &path_replacer);
178 let toml_text = re_local_paths.replace_all(&toml_text, &path_replacer);
179
180 trace!("toml text to parse: {}", toml_text);
181 let toml_text = apply_env_replacements(&toml_text);
183 trace!("toml text after replacements: {}", toml_text);
184 let mut network_config: NetworkConfig = toml::from_str(&toml_text)?;
185 trace!("parsed config {network_config:#?}");
186
187 if network_config.relaychain.is_none() && network_config.jamchain.is_none() {
189 Err(anyhow!("Relay chain or Jam definition does not exist."))?
190 }
191
192 if let Some(jamchain) = network_config.jamchain.as_mut() {
193 if let Some(error) = jamchain.spec_source_errors().into_iter().next() {
194 return Err(ConfigError::Jamchain(error).into());
195 }
196 jamchain.resolve_relative_paths(base_dir);
197 }
198
199 let mut names = HashSet::new();
202
203 if let Some(relaychain) = network_config.relaychain.as_mut() {
204 let mut relaychain_default_command: Option<Command> =
206 relaychain.default_command().cloned();
207
208 if relaychain_default_command.is_none() {
209 relaychain_default_command = relaychain.command().cloned();
210 }
211
212 let relaychain_default_image: Option<Image> = relaychain.default_image().cloned();
213
214 let relaychain_default_db_snapshot: Option<AssetLocation> =
215 relaychain.default_db_snapshot().cloned();
216
217 let default_args: Vec<Arg> = relaychain.default_args().into_iter().cloned().collect();
218
219 let mut nodes: Vec<NodeConfig> = relaychain.nodes().into_iter().cloned().collect();
220
221 let group_nodes: Vec<GroupNodeConfig> = relaychain
222 .group_node_configs()
223 .into_iter()
224 .cloned()
225 .collect();
226
227 if let Some(group) = group_nodes.iter().find(|n| n.count == 0) {
228 return Err(anyhow!(
229 "Group node '{}' must have a count greater than 0.",
230 group.base_config.name()
231 ));
232 }
233
234 TryInto::<Chain>::try_into(relaychain.chain().as_str())?;
236 if let Some(default_image) = &relaychain_default_image {
237 TryInto::<Image>::try_into(default_image.clone())?;
238 }
239 if let Some(default_command) = &relaychain_default_command {
240 TryInto::<Command>::try_into(default_command.clone())?;
241 }
242
243 for node in nodes.iter_mut() {
244 if relaychain_default_command.is_some() {
245 if node.command.is_none() {
247 node.command.clone_from(&relaychain_default_command);
248 }
249 }
250
251 if relaychain_default_image.is_some() && node.image.is_none() {
252 node.image.clone_from(&relaychain_default_image);
253 }
254
255 if relaychain_default_db_snapshot.is_some() && node.db_snapshot.is_none() {
256 node.db_snapshot.clone_from(&relaychain_default_db_snapshot);
257 }
258
259 if !default_args.is_empty() && node.args().is_empty() {
260 node.set_args(default_args.clone());
261 }
262
263 let unique_name = generate_unique_node_name_from_names(node.name(), &mut names);
264 node.name = unique_name;
265 }
266
267 relaychain.set_nodes(nodes);
268 }
269
270 let mut parachains: Vec<ParachainConfig> =
271 network_config.parachains().into_iter().cloned().collect();
272
273 for para in parachains.iter_mut() {
274 let parachain_default_command: Option<Command> = para.default_command().cloned();
276
277 let parachain_default_image: Option<Image> = para.default_image().cloned();
278
279 let parachain_default_db_snapshot: Option<AssetLocation> =
280 para.default_db_snapshot().cloned();
281
282 let default_args: Vec<Arg> = para.default_args().into_iter().cloned().collect();
283
284 let group_collators: Vec<GroupNodeConfig> = para
285 .group_collators_configs()
286 .into_iter()
287 .cloned()
288 .collect();
289
290 if let Some(group) = group_collators.iter().find(|n| n.count == 0) {
291 return Err(anyhow!(
292 "Group node '{}' must have a count greater than 0.",
293 group.base_config.name()
294 ));
295 }
296
297 let mut collators: Vec<NodeConfig> = para.collators.clone();
298
299 for collator in collators.iter_mut() {
300 populate_collator_with_defaults(
301 collator,
302 ¶chain_default_command,
303 ¶chain_default_image,
304 ¶chain_default_db_snapshot,
305 &default_args,
306 );
307 let unique_name = generate_unique_node_name_from_names(collator.name(), &mut names);
308 collator.name = unique_name;
309 }
310
311 para.collators = collators;
312
313 if let Some(mut collator) = para.collator.clone() {
314 populate_collator_with_defaults(
315 &mut collator,
316 ¶chain_default_command,
317 ¶chain_default_image,
318 ¶chain_default_db_snapshot,
319 &default_args,
320 );
321 let unique_name = generate_unique_node_name_from_names(collator.name(), &mut names);
322 collator.name = unique_name;
323 para.collator = Some(collator);
324 }
325 }
326
327 network_config.set_parachains(parachains);
328
329 network_config.parachains().iter().for_each(|parachain| {
331 if let Some(default_image) = parachain.default_image() {
332 let _ = TryInto::<Image>::try_into(default_image.as_str());
333 }
334 if let Some(default_command) = parachain.default_command() {
335 let _ = TryInto::<Command>::try_into(default_command.as_str());
336 }
337 });
338
339 let mut errors: Vec<String> = vec![];
343 for process in &network_config.custom_processes {
344 if names.contains(process.name()) {
345 errors.push(format!(
346 "custom_processes['{}'].name: already used by a node or custom process",
347 process.name()
348 ));
349 }
350 names.insert(process.name().to_string());
351 if let Err(port_errors) = process.validate() {
352 errors.extend(
353 port_errors
354 .into_iter()
355 .map(|e| format!("custom_processes['{}'].{e}", process.name())),
356 );
357 }
358 }
359 if let Err(dependency_errors) =
360 custom_process::validate_custom_processes(&network_config.custom_processes)
361 {
362 errors.extend(dependency_errors);
363 }
364 if !errors.is_empty() {
365 Err(anyhow!(errors.join("\n")))?
366 }
367
368 Ok(network_config)
369 }
370}
371
372fn maybe_absolute(cmd: &str, base_dir: &Path) -> String {
373 if cmd.starts_with(".") {
374 let mut full = PathBuf::from(base_dir);
375 full.push(cmd);
376 trace!("full_path: {:?}", full);
377 std::path::absolute(&full)
378 .expect(&format!(
379 "absolute path shoud be valid: {:?}",
380 full.as_os_str()
381 ))
382 .to_string_lossy()
383 .to_string()
384 } else {
385 cmd.to_string()
386 }
387}
388
389fn populate_collator_with_defaults(
390 collator: &mut NodeConfig,
391 parachain_default_command: &Option<Command>,
392 parachain_default_image: &Option<Image>,
393 parachain_default_db_snapshot: &Option<AssetLocation>,
394 default_args: &[Arg],
395) {
396 if parachain_default_command.is_some() {
397 if collator.command.is_none() {
399 collator.command.clone_from(parachain_default_command);
400 }
401 }
402
403 if parachain_default_image.is_some() && collator.image.is_none() {
404 collator.image.clone_from(parachain_default_image);
405 }
406
407 if parachain_default_db_snapshot.is_some() && collator.db_snapshot.is_none() {
408 collator
409 .db_snapshot
410 .clone_from(parachain_default_db_snapshot);
411 }
412
413 if !default_args.is_empty() && collator.args().is_empty() {
414 collator.set_args(default_args.to_owned());
415 }
416}
417
418states! {
419 Initial,
420 Buildable
421}
422
423pub struct NetworkConfigBuilder<State> {
493 config: NetworkConfig,
494 validation_context: Rc<RefCell<ValidationContext>>,
495 errors: Vec<anyhow::Error>,
496 _state: PhantomData<State>,
497}
498
499impl Default for NetworkConfigBuilder<Initial> {
500 fn default() -> Self {
501 Self {
502 config: NetworkConfig {
503 global_settings: GlobalSettingsBuilder::new()
504 .build()
505 .expect(&format!("{NO_ERR_DEF_BUILDER}, {THIS_IS_A_BUG}")),
506 relaychain: None,
507 jamchain: None,
508 parachains: vec![],
509 hrmp_channels: vec![],
510 custom_processes: vec![],
511 },
512 validation_context: Default::default(),
513 errors: vec![],
514 _state: PhantomData,
515 }
516 }
517}
518
519impl<A> NetworkConfigBuilder<A> {
520 fn transition<B>(
521 config: NetworkConfig,
522 validation_context: Rc<RefCell<ValidationContext>>,
523 errors: Vec<anyhow::Error>,
524 ) -> NetworkConfigBuilder<B> {
525 NetworkConfigBuilder {
526 config,
527 errors,
528 validation_context,
529 _state: PhantomData,
530 }
531 }
532
533 fn setup_tiny_jamchain(self) -> NetworkConfigBuilder<Buildable> {
540 let mut builder = JamchainConfigBuilder::new(self.validation_context.clone())
541 .with_id("dev")
542 .with_validator(|n| n.with_name("jam0"));
543
544 for i in 1..6 {
545 builder = builder.with_validator(|n| n.with_name(&format!("jam{i}")));
546 }
547
548 let builder = builder.with_ordinary(|n| n.with_name("jam-or"));
549
550 match builder.build() {
551 Ok(jamchain) => Self::transition(
552 NetworkConfig {
553 jamchain: Some(jamchain),
554 ..self.config
555 },
556 self.validation_context,
557 self.errors,
558 ),
559 Err(errors) => Self::transition(self.config, self.validation_context, errors),
560 }
561 }
562}
563
564impl NetworkConfigBuilder<Initial> {
565 pub fn new() -> NetworkConfigBuilder<Initial> {
566 Self::default()
567 }
568
569 pub fn with_chain_and_nodes(
573 relay_name: &str,
574 node_names: Vec<String>,
575 ) -> NetworkConfigBuilder<Buildable> {
576 let network_config = NetworkConfigBuilder::new().with_relaychain(|relaychain| {
577 let mut relaychain_with_node =
578 relaychain.with_chain(relay_name).with_validator(|node| {
579 node.with_name(node_names.first().unwrap_or(&"".to_string()))
580 });
581
582 for node_name in node_names.iter().skip(1) {
583 relaychain_with_node = relaychain_with_node
584 .with_validator(|node_builder| node_builder.with_name(node_name));
585 }
586 relaychain_with_node
587 });
588
589 Self::transition(
590 network_config.config,
591 network_config.validation_context,
592 network_config.errors,
593 )
594 }
595
596 pub fn with_relaychain(
598 self,
599 f: impl FnOnce(
600 RelaychainConfigBuilder<relaychain::Initial>,
601 ) -> RelaychainConfigBuilder<relaychain::WithAtLeastOneNode>,
602 ) -> NetworkConfigBuilder<Buildable> {
603 match f(RelaychainConfigBuilder::new(
604 self.validation_context.clone(),
605 ))
606 .build()
607 {
608 Ok(relaychain) => Self::transition(
609 NetworkConfig {
610 relaychain: Some(relaychain),
611 ..self.config
612 },
613 self.validation_context,
614 self.errors,
615 ),
616 Err(errors) => Self::transition(self.config, self.validation_context, errors),
617 }
618 }
619
620 pub fn with_jamchain(
622 self,
623 f: impl FnOnce(
624 JamchainConfigBuilder<jamchain::Initial>,
625 ) -> JamchainConfigBuilder<jamchain::WithAtLeastOneNode>,
626 ) -> NetworkConfigBuilder<Buildable> {
627 match f(JamchainConfigBuilder::new(self.validation_context.clone())).build() {
628 Ok(jamchain) => Self::transition(
629 NetworkConfig {
630 jamchain: Some(jamchain),
631 ..self.config
632 },
633 self.validation_context,
634 self.errors,
635 ),
636 Err(errors) => Self::transition(self.config, self.validation_context, errors),
637 }
638 }
639
640 pub fn with_tiny_jamchain(self) -> NetworkConfigBuilder<Buildable> {
643 self.setup_tiny_jamchain()
644 }
645}
646
647impl NetworkConfigBuilder<Buildable> {
648 pub fn with_relaychain(
652 self,
653 f: impl FnOnce(
654 RelaychainConfigBuilder<relaychain::Initial>,
655 ) -> RelaychainConfigBuilder<relaychain::WithAtLeastOneNode>,
656 ) -> NetworkConfigBuilder<Buildable> {
657 match f(RelaychainConfigBuilder::new(
658 self.validation_context.clone(),
659 ))
660 .build()
661 {
662 Ok(relaychain) => Self::transition(
663 NetworkConfig {
664 relaychain: Some(relaychain),
665 ..self.config
666 },
667 self.validation_context,
668 self.errors,
669 ),
670 Err(errors) => Self::transition(self.config, self.validation_context, errors),
671 }
672 }
673
674 pub fn with_jamchain(
676 self,
677 f: impl FnOnce(
678 JamchainConfigBuilder<jamchain::Initial>,
679 ) -> JamchainConfigBuilder<jamchain::WithAtLeastOneNode>,
680 ) -> NetworkConfigBuilder<Buildable> {
681 match f(JamchainConfigBuilder::new(self.validation_context.clone())).build() {
682 Ok(jamchain) => Self::transition(
683 NetworkConfig {
684 jamchain: Some(jamchain),
685 ..self.config
686 },
687 self.validation_context,
688 self.errors,
689 ),
690 Err(errors) => Self::transition(self.config, self.validation_context, errors),
691 }
692 }
693
694 pub fn with_tiny_jamchain(self) -> NetworkConfigBuilder<Buildable> {
697 self.setup_tiny_jamchain()
698 }
699
700 pub fn with_global_settings(
702 self,
703 f: impl FnOnce(GlobalSettingsBuilder) -> GlobalSettingsBuilder,
704 ) -> Self {
705 match f(GlobalSettingsBuilder::new()).build() {
706 Ok(global_settings) => Self::transition(
707 NetworkConfig {
708 global_settings,
709 ..self.config
710 },
711 self.validation_context,
712 self.errors,
713 ),
714 Err(errors) => Self::transition(
715 self.config,
716 self.validation_context,
717 merge_errors_vecs(self.errors, errors),
718 ),
719 }
720 }
721
722 pub fn with_parachain(
724 self,
725 f: impl FnOnce(
726 ParachainConfigBuilder<parachain::states::Initial, parachain::states::Bootstrap>,
727 ) -> ParachainConfigBuilder<
728 parachain::states::WithAtLeastOneCollator,
729 parachain::states::Bootstrap,
730 >,
731 ) -> Self {
732 match f(ParachainConfigBuilder::new(self.validation_context.clone())).build() {
733 Ok(parachain) => Self::transition(
734 NetworkConfig {
735 parachains: [self.config.parachains, vec![parachain]].concat(),
736 ..self.config
737 },
738 self.validation_context,
739 self.errors,
740 ),
741 Err(errors) => Self::transition(
742 self.config,
743 self.validation_context,
744 merge_errors_vecs(self.errors, errors),
745 ),
746 }
747 }
748
749 pub fn with_parachain_id_and_collators(self, id: u32, collator_names: Vec<String>) -> Self {
757 if collator_names.is_empty() {
758 return Self::transition(
759 self.config,
760 self.validation_context,
761 merge_errors(
762 self.errors,
763 ConfigError::Parachain(id, ValidationError::CantBeEmpty().into()).into(),
764 ),
765 );
766 }
767
768 self.with_parachain(|parachain| {
769 let mut parachain_config = parachain.with_id(id).with_collator(|collator| {
770 collator
771 .with_name(collator_names.first().unwrap_or(&"".to_string()))
772 .validator(true)
773 });
774
775 for collator_name in collator_names.iter().skip(1) {
776 parachain_config = parachain_config
777 .with_collator(|collator| collator.with_name(collator_name).validator(true));
778 }
779 parachain_config
780 })
781
782 }
785
786 pub fn with_hrmp_channel(
788 self,
789 f: impl FnOnce(
790 HrmpChannelConfigBuilder<hrmp_channel::Initial>,
791 ) -> HrmpChannelConfigBuilder<hrmp_channel::WithRecipient>,
792 ) -> Self {
793 let new_hrmp_channel = f(HrmpChannelConfigBuilder::new()).build();
794
795 Self::transition(
796 NetworkConfig {
797 hrmp_channels: [self.config.hrmp_channels, vec![new_hrmp_channel]].concat(),
798 ..self.config
799 },
800 self.validation_context,
801 self.errors,
802 )
803 }
804
805 pub fn with_custom_process(
812 self,
813 f: impl FnOnce(
814 CustomProcessBuilder<custom_process::WithOutName, custom_process::WithOutCmd>,
815 )
816 -> CustomProcessBuilder<custom_process::WithName, custom_process::WithCmd>,
817 ) -> Self {
818 match f(CustomProcessBuilder::new()).build() {
819 Ok(custom_process) => {
820 let taken = !self
824 .validation_context
825 .borrow_mut()
826 .used_nodes_names
827 .insert(custom_process.name().to_string());
828 if taken {
829 return Self::transition(
830 self.config,
831 self.validation_context,
832 merge_errors(
833 self.errors,
834 ConfigError::CustomProcess(
835 custom_process.name().to_string(),
836 anyhow!("name: already used by a node or custom process"),
837 )
838 .into(),
839 ),
840 );
841 }
842 Self::transition(
843 NetworkConfig {
844 custom_processes: [self.config.custom_processes, vec![custom_process]]
845 .concat(),
846 ..self.config
847 },
848 self.validation_context,
849 self.errors,
850 )
851 },
852 Err((name, errors)) => Self::transition(
853 self.config,
854 self.validation_context,
855 merge_errors_vecs(
856 self.errors,
857 errors
858 .into_iter()
859 .map(|error| ConfigError::CustomProcess(name.clone(), error).into())
860 .collect::<Vec<_>>(),
861 ),
862 ),
863 }
864 }
865
866 pub fn build(self) -> Result<NetworkConfig, Vec<anyhow::Error>> {
868 let mut paras_to_register: HashSet<ParaId> = Default::default();
869 let mut num_of_requested_cores = 0;
870
871 let mut errs: Vec<anyhow::Error> = self
872 .config
873 .parachains
874 .iter()
875 .filter_map(|para| {
876 if let Some(cores) = para.num_cores() {
877 num_of_requested_cores += cores;
878 } else if let Some(RegistrationStrategy::InGenesis) = para.registration_strategy() {
879 num_of_requested_cores += 1;
881 }
882
883 if let Some(RegistrationStrategy::Manual) = para.registration_strategy() {
884 return None;
885 };
886
887 if paras_to_register.insert(para.id()) {
888 None
889 } else {
890 Some(anyhow!(
892 "ParaId {} already set to be registered, only one should be.",
893 para.id()
894 ))
895 }
896 })
897 .collect();
898
899 if let Err(dependency_errors) =
900 custom_process::validate_custom_processes(&self.config.custom_processes)
901 {
902 errs.extend(dependency_errors.into_iter().map(|e| anyhow!(e)));
903 }
904
905 if let Some(rc_config) = self.config.relaychain.as_ref() {
907 let mut num_validators = rc_config.nodes().iter().fold(0u32, |mut acc, node| {
909 if node.is_validator {
910 acc += 1;
911 }
912
913 acc
914 });
915
916 let node_groups = rc_config.group_node_configs();
917 for ng in &node_groups {
918 if ng.base_config.is_validator {
919 num_validators += ng.count as u32;
920 }
921 }
922
923 if num_validators < num_of_requested_cores {
924 errs.push(anyhow!("Number of assigned cores at genesis {num_of_requested_cores} is greater than validators ({num_validators})"));
925 }
926 }
927
928 if !self.errors.is_empty() || !errs.is_empty() {
929 let mut ret_errs = self.errors;
930 ret_errs.append(&mut errs);
931 return Err(ret_errs);
932 }
933
934 Ok(self.config)
935 }
936}
937
938#[cfg(test)]
939mod tests {
940 use std::path::PathBuf;
941
942 use super::*;
943 use crate::{
944 parachain::RegistrationStrategy, types::JamNodeMode, DependencyCondition, ProcessEnvVar,
945 };
946
947 #[test]
948 fn network_config_builder_should_succeeds_and_returns_a_network_config() {
949 let network_config = NetworkConfigBuilder::new()
950 .with_relaychain(|relaychain| {
951 relaychain
952 .with_chain("polkadot")
953 .with_random_nominators_count(10)
954 .with_validator(|node| node.with_name("node").with_command("command"))
955 .with_validator(|node| node.with_name("node-1").with_command("command"))
956 })
957 .with_parachain(|parachain| {
958 parachain
959 .with_id(1)
960 .with_chain("myparachain1")
961 .with_initial_balance(100_000)
962 .with_collator(|collator| {
963 collator
964 .with_name("collator1")
965 .with_command("command1")
966 .validator(true)
967 })
968 })
969 .with_parachain(|parachain| {
970 parachain
971 .with_id(2)
972 .with_chain("myparachain2")
973 .with_initial_balance(0)
974 .with_collator(|collator| {
975 collator
976 .with_name("collator2")
977 .with_command("command2")
978 .validator(true)
979 })
980 })
981 .with_hrmp_channel(|hrmp_channel1| {
982 hrmp_channel1
983 .with_sender(1)
984 .with_recipient(2)
985 .with_max_capacity(200)
986 .with_max_message_size(500)
987 })
988 .with_hrmp_channel(|hrmp_channel2| {
989 hrmp_channel2
990 .with_sender(2)
991 .with_recipient(1)
992 .with_max_capacity(100)
993 .with_max_message_size(250)
994 })
995 .with_global_settings(|global_settings| {
996 global_settings
997 .with_network_spawn_timeout(1200)
998 .with_node_spawn_timeout(240)
999 })
1000 .build()
1001 .unwrap();
1002
1003 assert_eq!(network_config.relaychain().chain().as_str(), "polkadot");
1005 assert_eq!(network_config.relaychain().nodes().len(), 2);
1006 let &node = network_config.relaychain().nodes().first().unwrap();
1007 assert_eq!(node.name(), "node");
1008 assert_eq!(node.command().unwrap().as_str(), "command");
1009 assert!(node.is_validator());
1010 assert_eq!(
1011 network_config
1012 .relaychain()
1013 .random_nominators_count()
1014 .unwrap(),
1015 10
1016 );
1017
1018 assert_eq!(network_config.parachains().len(), 2);
1020
1021 let ¶chain1 = network_config.parachains().first().unwrap();
1023 assert_eq!(parachain1.id(), 1);
1024 assert_eq!(parachain1.collators().len(), 1);
1025 let &collator = parachain1.collators().first().unwrap();
1026 assert_eq!(collator.name(), "collator1");
1027 assert_eq!(collator.command().unwrap().as_str(), "command1");
1028 assert!(collator.is_validator());
1029 assert_eq!(parachain1.initial_balance(), 100_000);
1030 assert_eq!(parachain1.unique_id(), "1");
1031
1032 let ¶chain2 = network_config.parachains().last().unwrap();
1034 assert_eq!(parachain2.id(), 2);
1035 assert_eq!(parachain2.collators().len(), 1);
1036 let &collator = parachain2.collators().first().unwrap();
1037 assert_eq!(collator.name(), "collator2");
1038 assert_eq!(collator.command().unwrap().as_str(), "command2");
1039 assert!(collator.is_validator());
1040 assert_eq!(parachain2.initial_balance(), 0);
1041
1042 assert_eq!(network_config.hrmp_channels().len(), 2);
1044
1045 let &hrmp_channel1 = network_config.hrmp_channels().first().unwrap();
1047 assert_eq!(hrmp_channel1.sender(), 1);
1048 assert_eq!(hrmp_channel1.recipient(), 2);
1049 assert_eq!(hrmp_channel1.max_capacity(), 200);
1050 assert_eq!(hrmp_channel1.max_message_size(), 500);
1051
1052 let &hrmp_channel2 = network_config.hrmp_channels().last().unwrap();
1054 assert_eq!(hrmp_channel2.sender(), 2);
1055 assert_eq!(hrmp_channel2.recipient(), 1);
1056 assert_eq!(hrmp_channel2.max_capacity(), 100);
1057 assert_eq!(hrmp_channel2.max_message_size(), 250);
1058
1059 assert_eq!(
1061 network_config.global_settings().network_spawn_timeout(),
1062 1200
1063 );
1064 assert_eq!(network_config.global_settings().node_spawn_timeout(), 240);
1065 assert!(network_config.global_settings().tear_down_on_failure());
1066 }
1067
1068 #[test]
1069 fn network_config_builder_should_fails_and_returns_multiple_errors_if_relaychain_is_invalid() {
1070 let errors = NetworkConfigBuilder::new()
1071 .with_relaychain(|relaychain| {
1072 relaychain
1073 .with_chain("polkadot")
1074 .with_random_nominators_count(10)
1075 .with_default_image("invalid.image")
1076 .with_validator(|node| node.with_name("node").with_command("invalid command"))
1077 })
1078 .with_parachain(|parachain| {
1079 parachain
1080 .with_id(1)
1081 .with_chain("myparachain")
1082 .with_initial_balance(100_000)
1083 .with_collator(|collator| {
1084 collator
1085 .with_name("collator1")
1086 .with_command("command1")
1087 .validator(true)
1088 })
1089 })
1090 .build()
1091 .unwrap_err();
1092
1093 assert_eq!(errors.len(), 2);
1094 assert_eq!(
1095 errors.first().unwrap().to_string(),
1096 "relaychain.default_image: 'invalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
1097 );
1098 assert_eq!(
1099 errors.get(1).unwrap().to_string(),
1100 "relaychain.nodes['node'].command: 'invalid command' shouldn't contains whitespace"
1101 );
1102 }
1103
1104 #[test]
1105 fn network_config_builder_should_fails_and_returns_multiple_errors_if_parachain_is_invalid() {
1106 let errors = NetworkConfigBuilder::new()
1107 .with_relaychain(|relaychain| {
1108 relaychain
1109 .with_chain("polkadot")
1110 .with_random_nominators_count(10)
1111 .with_validator(|node| node.with_name("node").with_command("command"))
1112 })
1113 .with_parachain(|parachain| {
1114 parachain
1115 .with_id(1000)
1116 .with_chain("myparachain")
1117 .with_initial_balance(100_000)
1118 .with_collator(|collator| {
1119 collator
1120 .with_name("collator1")
1121 .with_command("invalid command")
1122 .with_image("invalid.image")
1123 .validator(true)
1124 })
1125 })
1126 .build()
1127 .unwrap_err();
1128
1129 assert_eq!(errors.len(), 2);
1130 assert_eq!(
1131 errors.first().unwrap().to_string(),
1132 "parachain[1000].collators['collator1'].command: 'invalid command' shouldn't contains whitespace"
1133 );
1134 assert_eq!(
1135 errors.get(1).unwrap().to_string(),
1136 "parachain[1000].collators['collator1'].image: 'invalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
1137 );
1138 }
1139
1140 #[test]
1141 fn network_config_builder_should_fails_and_returns_multiple_errors_if_multiple_parachains_are_invalid(
1142 ) {
1143 let errors = NetworkConfigBuilder::new()
1144 .with_relaychain(|relaychain| {
1145 relaychain
1146 .with_chain("polkadot")
1147 .with_random_nominators_count(10)
1148 .with_validator(|node| node.with_name("node").with_command("command"))
1149 })
1150 .with_parachain(|parachain| {
1151 parachain
1152 .with_id(1000)
1153 .with_chain("myparachain1")
1154 .with_initial_balance(100_000)
1155 .with_collator(|collator| {
1156 collator
1157 .with_name("collator1")
1158 .with_command("invalid command")
1159 })
1160 })
1161 .with_parachain(|parachain| {
1162 parachain
1163 .with_id(2000)
1164 .with_chain("myparachain2")
1165 .with_initial_balance(100_000)
1166 .with_collator(|collator| {
1167 collator
1168 .with_name("collator2")
1169 .validator(true)
1170 .with_resources(|resources| {
1171 resources
1172 .with_limit_cpu("1000m")
1173 .with_request_memory("1Gi")
1174 .with_request_cpu("invalid")
1175 })
1176 })
1177 })
1178 .build()
1179 .unwrap_err();
1180
1181 assert_eq!(errors.len(), 2);
1182 assert_eq!(
1183 errors.first().unwrap().to_string(),
1184 "parachain[1000].collators['collator1'].command: 'invalid command' shouldn't contains whitespace"
1185 );
1186 assert_eq!(
1187 errors.get(1).unwrap().to_string(),
1188 "parachain[2000].collators['collator2'].resources.request_cpu: 'invalid' doesn't match regex '^\\d+(.\\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
1189 );
1190 }
1191
1192 #[test]
1193 fn network_config_builder_should_fails_and_returns_multiple_errors_if_global_settings_is_invalid(
1194 ) {
1195 let errors = NetworkConfigBuilder::new()
1196 .with_relaychain(|relaychain| {
1197 relaychain
1198 .with_chain("polkadot")
1199 .with_random_nominators_count(10)
1200 .with_validator(|node| node.with_name("node").with_command("command"))
1201 })
1202 .with_parachain(|parachain| {
1203 parachain
1204 .with_id(1000)
1205 .with_chain("myparachain")
1206 .with_initial_balance(100_000)
1207 .with_collator(|collator| {
1208 collator
1209 .with_name("collator")
1210 .with_command("command")
1211 .validator(true)
1212 })
1213 })
1214 .with_global_settings(|global_settings| {
1215 global_settings
1216 .with_local_ip("127.0.0000.1")
1217 .with_raw_bootnodes_addresses(vec!["/ip4//tcp/45421"])
1218 })
1219 .build()
1220 .unwrap_err();
1221
1222 assert_eq!(errors.len(), 2);
1223 assert_eq!(
1224 errors.first().unwrap().to_string(),
1225 "global_settings.local_ip: invalid IP address syntax"
1226 );
1227 assert_eq!(
1228 errors.get(1).unwrap().to_string(),
1229 "global_settings.bootnodes_addresses[0]: '/ip4//tcp/45421' failed to parse: invalid IPv4 address syntax"
1230 );
1231 }
1232
1233 #[test]
1234 fn network_config_builder_should_fails_and_returns_multiple_errors_if_multiple_fields_are_invalid(
1235 ) {
1236 let errors = NetworkConfigBuilder::new()
1237 .with_relaychain(|relaychain| {
1238 relaychain
1239 .with_chain("polkadot")
1240 .with_random_nominators_count(10)
1241 .with_validator(|node| node.with_name("node").with_command("invalid command"))
1242 })
1243 .with_parachain(|parachain| {
1244 parachain
1245 .with_id(1000)
1246 .with_chain("myparachain")
1247 .with_initial_balance(100_000)
1248 .with_collator(|collator| {
1249 collator
1250 .with_name("collator")
1251 .with_command("command")
1252 .with_image("invalid.image")
1253 })
1254 })
1255 .with_global_settings(|global_settings| global_settings.with_local_ip("127.0.0000.1"))
1256 .build()
1257 .unwrap_err();
1258
1259 assert_eq!(errors.len(), 3);
1260 assert_eq!(
1261 errors.first().unwrap().to_string(),
1262 "relaychain.nodes['node'].command: 'invalid command' shouldn't contains whitespace"
1263 );
1264 assert_eq!(
1265 errors.get(1).unwrap().to_string(),
1266 "parachain[1000].collators['collator'].image: 'invalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
1267 );
1268 assert_eq!(
1269 errors.get(2).unwrap().to_string(),
1270 "global_settings.local_ip: invalid IP address syntax"
1271 );
1272 }
1273
1274 #[test]
1275 fn network_config_should_be_dumpable_to_a_toml_config_for_a_small_network() {
1276 let network_config = NetworkConfigBuilder::new()
1277 .with_relaychain(|relaychain| {
1278 relaychain
1279 .with_chain("rococo-local")
1280 .with_default_command("polkadot")
1281 .with_default_image("docker.io/parity/polkadot:latest")
1282 .with_default_args(vec![("-lparachain", "debug").into()])
1283 .with_validator(|node| node.with_name("alice"))
1284 .with_validator(|node| {
1285 node.with_name("bob")
1286 .invulnerable(false)
1287 .bootnode(true)
1288 .with_args(vec![("--database", "paritydb-experimental").into()])
1289 })
1290 })
1291 .build()
1292 .unwrap();
1293
1294 let got = network_config.dump_to_toml().unwrap();
1295 let expected = fs::read_to_string("./testing/snapshots/0000-small-network.toml").unwrap();
1296 assert_eq!(got, expected);
1297 }
1298
1299 #[test]
1300 fn network_config_should_be_dumpable_to_a_toml_config_for_a_big_network() {
1301 let network_config = NetworkConfigBuilder::new()
1302 .with_relaychain(|relaychain| {
1303 relaychain
1304 .with_chain("polkadot")
1305 .with_default_command("polkadot")
1306 .with_default_image("docker.io/parity/polkadot:latest")
1307 .with_default_resources(|resources| {
1308 resources
1309 .with_request_cpu(100000)
1310 .with_request_memory("500M")
1311 .with_limit_cpu("10Gi")
1312 .with_limit_memory("4000M")
1313 })
1314 .with_validator(|node| {
1315 node.with_name("alice")
1316 .with_initial_balance(1_000_000_000)
1317 .bootnode(true)
1318 .invulnerable(true)
1319 })
1320 .with_validator(|node| node.with_name("bob").invulnerable(true).bootnode(true))
1321 })
1322 .with_parachain(|parachain| {
1323 parachain
1324 .with_id(1000)
1325 .with_chain("myparachain")
1326 .with_chain_spec_path("/path/to/my/chain/spec.json")
1327 .with_registration_strategy(RegistrationStrategy::UsingExtrinsic)
1328 .onboard_as_parachain(false)
1329 .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1330 .with_collator(|collator| {
1331 collator
1332 .with_name("john")
1333 .bootnode(true)
1334 .invulnerable(true)
1335 .with_initial_balance(5_000_000_000)
1336 })
1337 .with_fullnode(|collator| {
1338 collator
1339 .with_name("charles")
1340 .bootnode(true)
1341 .invulnerable(true)
1342 .with_initial_balance(0)
1343 })
1344 .with_collator(|collator| {
1345 collator
1346 .with_name("frank")
1347 .invulnerable(false)
1348 .bootnode(true)
1349 .with_initial_balance(1_000_000_000)
1350 })
1351 })
1352 .with_parachain(|parachain| {
1353 parachain
1354 .with_id(2000)
1355 .with_chain("myotherparachain")
1356 .with_chain_spec_path("/path/to/my/other/chain/spec.json")
1357 .with_collator(|collator| {
1358 collator
1359 .with_name("mike")
1360 .bootnode(true)
1361 .invulnerable(true)
1362 .with_initial_balance(5_000_000_000)
1363 })
1364 .with_fullnode(|collator| {
1365 collator
1366 .with_name("georges")
1367 .bootnode(true)
1368 .invulnerable(true)
1369 .with_initial_balance(0)
1370 })
1371 .with_collator(|collator| {
1372 collator
1373 .with_name("victor")
1374 .invulnerable(false)
1375 .bootnode(true)
1376 .with_initial_balance(1_000_000_000)
1377 })
1378 })
1379 .with_hrmp_channel(|hrmp_channel| {
1380 hrmp_channel
1381 .with_sender(1000)
1382 .with_recipient(2000)
1383 .with_max_capacity(150)
1384 .with_max_message_size(5000)
1385 })
1386 .with_hrmp_channel(|hrmp_channel| {
1387 hrmp_channel
1388 .with_sender(2000)
1389 .with_recipient(1000)
1390 .with_max_capacity(200)
1391 .with_max_message_size(8000)
1392 })
1393 .with_custom_process(|c| c.with_name("eth-rpc").with_command("eth-rpc"))
1394 .build()
1395 .unwrap();
1396
1397 let got = network_config.dump_to_toml().unwrap();
1398 let expected = fs::read_to_string("./testing/snapshots/0001-big-network.toml").unwrap();
1399 assert_eq!(got, expected);
1400 }
1401
1402 #[test]
1403 fn network_config_builder_should_be_dumplable_to_a_toml_config_a_overrides_default_correctly() {
1404 let network_config = NetworkConfigBuilder::new()
1405 .with_relaychain(|relaychain| {
1406 relaychain
1407 .with_chain("polkadot")
1408 .with_default_command("polkadot")
1409 .with_default_image("docker.io/parity/polkadot:latest")
1410 .with_default_args(vec![("-name", "value").into(), "--flag".into()])
1411 .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1412 .with_default_resources(|resources| {
1413 resources
1414 .with_request_cpu(100000)
1415 .with_request_memory("500M")
1416 .with_limit_cpu("10Gi")
1417 .with_limit_memory("4000M")
1418 })
1419 .with_validator(|node| {
1420 node.with_name("alice")
1421 .with_initial_balance(1_000_000_000)
1422 .bootnode(true)
1423 .invulnerable(true)
1424 })
1425 .with_validator(|node| {
1426 node.with_name("bob")
1427 .invulnerable(true)
1428 .bootnode(true)
1429 .with_image("mycustomimage:latest")
1430 .with_command("my-custom-command")
1431 .with_db_snapshot("https://storage.com/path/to/other/db_snapshot.tgz")
1432 .with_resources(|resources| {
1433 resources
1434 .with_request_cpu(1000)
1435 .with_request_memory("250Mi")
1436 .with_limit_cpu("5Gi")
1437 .with_limit_memory("2Gi")
1438 })
1439 .with_args(vec![("-myothername", "value").into()])
1440 })
1441 })
1442 .with_parachain(|parachain| {
1443 parachain
1444 .with_id(1000)
1445 .with_chain("myparachain")
1446 .with_chain_spec_path("/path/to/my/chain/spec.json")
1447 .with_default_db_snapshot("https://storage.com/path/to/other_snapshot.tgz")
1448 .with_default_command("my-default-command")
1449 .with_default_image("mydefaultimage:latest")
1450 .with_collator(|collator| {
1451 collator
1452 .with_name("john")
1453 .bootnode(true)
1454 .invulnerable(true)
1455 .with_initial_balance(5_000_000_000)
1456 .with_command("my-non-default-command")
1457 .with_image("anotherimage:latest")
1458 })
1459 .with_fullnode(|collator| {
1460 collator
1461 .with_name("charles")
1462 .bootnode(true)
1463 .invulnerable(true)
1464 .with_initial_balance(0)
1465 })
1466 })
1467 .build()
1468 .unwrap();
1469
1470 let got = network_config.dump_to_toml().unwrap();
1471 let expected =
1472 fs::read_to_string("./testing/snapshots/0002-overridden-defaults.toml").unwrap();
1473 assert_eq!(got, expected);
1474 }
1475
1476 #[test]
1477 fn the_toml_config_with_custom_settings() {
1478 let settings = GlobalSettingsBuilder::new()
1479 .with_base_dir("/tmp/test-demo")
1480 .build()
1481 .unwrap();
1482
1483 let load_from_toml = NetworkConfig::load_from_toml_with_settings(
1484 "./testing/snapshots/0000-small-network.toml",
1485 &settings,
1486 )
1487 .unwrap();
1488
1489 assert_eq!(
1490 Some(PathBuf::from("/tmp/test-demo").as_path()),
1491 load_from_toml.global_settings.base_dir()
1492 );
1493 }
1494
1495 #[test]
1496 fn the_toml_config_should_be_imported_and_match_a_network() {
1497 let load_from_toml =
1498 NetworkConfig::load_from_toml("./testing/snapshots/0000-small-network.toml").unwrap();
1499
1500 let expected = NetworkConfigBuilder::new()
1501 .with_relaychain(|relaychain| {
1502 relaychain
1503 .with_chain("rococo-local")
1504 .with_default_command("polkadot")
1505 .with_default_image("docker.io/parity/polkadot:latest")
1506 .with_default_args(vec![("-lparachain=debug").into()])
1507 .with_validator(|node| {
1508 node.with_name("alice")
1509 .validator(true)
1510 .invulnerable(true)
1511 .bootnode(false)
1512 .with_initial_balance(2000000000000)
1513 })
1514 .with_validator(|node| {
1515 node.with_name("bob")
1516 .with_args(vec![("--database", "paritydb-experimental").into()])
1517 .invulnerable(false)
1518 .bootnode(true)
1519 .with_initial_balance(2000000000000)
1520 })
1521 })
1522 .build()
1523 .unwrap();
1524
1525 assert_eq!(
1529 expected.relaychain().chain(),
1530 load_from_toml.relaychain().chain()
1531 );
1532 assert_eq!(
1533 expected.relaychain().default_args(),
1534 load_from_toml.relaychain().default_args()
1535 );
1536 assert_eq!(
1537 expected.relaychain().default_command(),
1538 load_from_toml.relaychain().default_command()
1539 );
1540 assert_eq!(
1541 expected.relaychain().default_image(),
1542 load_from_toml.relaychain().default_image()
1543 );
1544
1545 expected
1547 .relaychain()
1548 .nodes()
1549 .iter()
1550 .zip(load_from_toml.relaychain().nodes().iter())
1551 .for_each(|(expected_node, loaded_node)| {
1552 assert_eq!(expected_node.name(), loaded_node.name());
1553 assert_eq!(expected_node.command(), loaded_node.command());
1554 assert_eq!(expected_node.args(), loaded_node.args());
1555 assert_eq!(
1556 expected_node.is_invulnerable(),
1557 loaded_node.is_invulnerable()
1558 );
1559 assert_eq!(expected_node.is_validator(), loaded_node.is_validator());
1560 assert_eq!(expected_node.is_bootnode(), loaded_node.is_bootnode());
1561 assert_eq!(
1562 expected_node.initial_balance(),
1563 loaded_node.initial_balance()
1564 );
1565 });
1566 }
1567
1568 #[test]
1569 fn the_toml_config_without_settings_should_be_imported_and_match_a_network() {
1570 let load_from_toml = NetworkConfig::load_from_toml(
1571 "./testing/snapshots/0004-small-network-without-settings.toml",
1572 )
1573 .unwrap();
1574
1575 let expected = NetworkConfigBuilder::new()
1576 .with_relaychain(|relaychain| {
1577 relaychain
1578 .with_chain("rococo-local")
1579 .with_default_command("polkadot")
1580 .with_validator(|node| node.with_name("alice"))
1581 .with_validator(|node| node.with_name("bob"))
1582 })
1583 .build()
1584 .unwrap();
1585
1586 assert_eq!(
1587 load_from_toml.global_settings().network_spawn_timeout(),
1588 expected.global_settings().network_spawn_timeout()
1589 )
1590 }
1591
1592 #[test]
1593 fn the_toml_config_should_be_imported_and_match_a_network_with_parachains() {
1594 let load_from_toml =
1595 NetworkConfig::load_from_toml("./testing/snapshots/0001-big-network.toml").unwrap();
1596
1597 let expected = NetworkConfigBuilder::new()
1598 .with_relaychain(|relaychain| {
1599 relaychain
1600 .with_chain("polkadot")
1601 .with_default_command("polkadot")
1602 .with_default_image("docker.io/parity/polkadot:latest")
1603 .with_default_resources(|resources| {
1604 resources
1605 .with_request_cpu(100000)
1606 .with_request_memory("500M")
1607 .with_limit_cpu("10Gi")
1608 .with_limit_memory("4000M")
1609 })
1610 .with_validator(|node| {
1611 node.with_name("alice")
1612 .with_initial_balance(1_000_000_000)
1613 .bootnode(true)
1614 .invulnerable(true)
1615 })
1616 .with_validator(|node| node.with_name("bob").invulnerable(true).bootnode(true))
1617 })
1618 .with_parachain(|parachain| {
1619 parachain
1620 .with_id(1000)
1621 .with_chain("myparachain")
1622 .with_chain_spec_path("/path/to/my/chain/spec.json")
1623 .with_registration_strategy(RegistrationStrategy::UsingExtrinsic)
1624 .onboard_as_parachain(false)
1625 .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1626 .with_collator(|collator| {
1627 collator
1628 .with_name("john")
1629 .bootnode(true)
1630 .invulnerable(true)
1631 .with_initial_balance(5_000_000_000)
1632 })
1633 .with_fullnode(|collator| {
1634 collator
1635 .with_name("charles")
1636 .bootnode(true)
1637 .invulnerable(true)
1638 .with_initial_balance(0)
1639 })
1640 .with_collator(|collator| {
1641 collator
1642 .with_name("frank")
1643 .invulnerable(false)
1644 .bootnode(true)
1645 .with_initial_balance(1_000_000_000)
1646 })
1647 })
1648 .with_parachain(|parachain| {
1649 parachain
1650 .with_id(2000)
1651 .with_chain("myotherparachain")
1652 .with_chain_spec_path("/path/to/my/other/chain/spec.json")
1653 .with_collator(|collator| {
1654 collator
1655 .with_name("mike")
1656 .bootnode(true)
1657 .invulnerable(true)
1658 .with_initial_balance(5_000_000_000)
1659 })
1660 .with_fullnode(|collator| {
1661 collator
1662 .with_name("georges")
1663 .bootnode(true)
1664 .invulnerable(true)
1665 .with_initial_balance(0)
1666 })
1667 .with_collator(|collator| {
1668 collator
1669 .with_name("victor")
1670 .invulnerable(false)
1671 .bootnode(true)
1672 .with_initial_balance(1_000_000_000)
1673 })
1674 })
1675 .with_hrmp_channel(|hrmp_channel| {
1676 hrmp_channel
1677 .with_sender(1000)
1678 .with_recipient(2000)
1679 .with_max_capacity(150)
1680 .with_max_message_size(5000)
1681 })
1682 .with_hrmp_channel(|hrmp_channel| {
1683 hrmp_channel
1684 .with_sender(2000)
1685 .with_recipient(1000)
1686 .with_max_capacity(200)
1687 .with_max_message_size(8000)
1688 })
1689 .build()
1690 .unwrap();
1691
1692 assert_eq!(
1694 expected.relaychain().default_resources(),
1695 load_from_toml.relaychain().default_resources()
1696 );
1697
1698 expected
1700 .relaychain()
1701 .nodes()
1702 .iter()
1703 .zip(load_from_toml.relaychain().nodes().iter())
1704 .for_each(|(expected_node, loaded_node)| {
1705 assert_eq!(expected_node.name(), loaded_node.name());
1706 assert_eq!(expected_node.command(), loaded_node.command());
1707 assert_eq!(expected_node.args(), loaded_node.args());
1708 assert_eq!(expected_node.is_validator(), loaded_node.is_validator());
1709 assert_eq!(expected_node.is_bootnode(), loaded_node.is_bootnode());
1710 assert_eq!(
1711 expected_node.initial_balance(),
1712 loaded_node.initial_balance()
1713 );
1714 assert_eq!(
1715 expected_node.is_invulnerable(),
1716 loaded_node.is_invulnerable()
1717 );
1718 });
1719
1720 expected
1721 .parachains()
1722 .iter()
1723 .zip(load_from_toml.parachains().iter())
1724 .for_each(|(expected_parachain, loaded_parachain)| {
1725 assert_eq!(expected_parachain.id(), loaded_parachain.id());
1726 assert_eq!(expected_parachain.chain(), loaded_parachain.chain());
1727 assert_eq!(
1728 expected_parachain.chain_spec_path(),
1729 loaded_parachain.chain_spec_path()
1730 );
1731 assert_eq!(
1732 expected_parachain.registration_strategy(),
1733 loaded_parachain.registration_strategy()
1734 );
1735 assert_eq!(
1736 expected_parachain.onboard_as_parachain(),
1737 loaded_parachain.onboard_as_parachain()
1738 );
1739 assert_eq!(
1740 expected_parachain.default_db_snapshot(),
1741 loaded_parachain.default_db_snapshot()
1742 );
1743 assert_eq!(
1744 expected_parachain.default_command(),
1745 loaded_parachain.default_command()
1746 );
1747 assert_eq!(
1748 expected_parachain.default_image(),
1749 loaded_parachain.default_image()
1750 );
1751 assert_eq!(
1752 expected_parachain.collators().len(),
1753 loaded_parachain.collators().len()
1754 );
1755 expected_parachain
1756 .collators()
1757 .iter()
1758 .zip(loaded_parachain.collators().iter())
1759 .for_each(|(expected_collator, loaded_collator)| {
1760 assert_eq!(expected_collator.name(), loaded_collator.name());
1761 assert_eq!(expected_collator.command(), loaded_collator.command());
1762 assert_eq!(expected_collator.image(), loaded_collator.image());
1763 assert_eq!(
1764 expected_collator.is_validator(),
1765 loaded_collator.is_validator()
1766 );
1767 assert_eq!(
1768 expected_collator.is_bootnode(),
1769 loaded_collator.is_bootnode()
1770 );
1771 assert_eq!(
1772 expected_collator.is_invulnerable(),
1773 loaded_collator.is_invulnerable()
1774 );
1775 assert_eq!(
1776 expected_collator.initial_balance(),
1777 loaded_collator.initial_balance()
1778 );
1779 });
1780 });
1781
1782 expected
1783 .hrmp_channels()
1784 .iter()
1785 .zip(load_from_toml.hrmp_channels().iter())
1786 .for_each(|(expected_hrmp_channel, loaded_hrmp_channel)| {
1787 assert_eq!(expected_hrmp_channel.sender(), loaded_hrmp_channel.sender());
1788 assert_eq!(
1789 expected_hrmp_channel.recipient(),
1790 loaded_hrmp_channel.recipient()
1791 );
1792 assert_eq!(
1793 expected_hrmp_channel.max_capacity(),
1794 loaded_hrmp_channel.max_capacity()
1795 );
1796 assert_eq!(
1797 expected_hrmp_channel.max_message_size(),
1798 loaded_hrmp_channel.max_message_size()
1799 );
1800 });
1801 }
1802
1803 #[test]
1804 fn the_toml_config_should_be_imported_and_match_a_network_with_overriden_defaults() {
1805 let load_from_toml =
1806 NetworkConfig::load_from_toml("./testing/snapshots/0002-overridden-defaults.toml")
1807 .unwrap();
1808
1809 let expected = NetworkConfigBuilder::new()
1810 .with_relaychain(|relaychain| {
1811 relaychain
1812 .with_chain("polkadot")
1813 .with_default_command("polkadot")
1814 .with_default_image("docker.io/parity/polkadot:latest")
1815 .with_default_args(vec![("-name", "value").into(), "--flag".into()])
1816 .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1817 .with_default_resources(|resources| {
1818 resources
1819 .with_request_cpu(100000)
1820 .with_request_memory("500M")
1821 .with_limit_cpu("10Gi")
1822 .with_limit_memory("4000M")
1823 })
1824 .with_validator(|node| {
1825 node.with_name("alice")
1826 .with_initial_balance(1_000_000_000)
1827 .bootnode(true)
1828 .invulnerable(true)
1829 })
1830 .with_validator(|node| {
1831 node.with_name("bob")
1832 .invulnerable(true)
1833 .bootnode(true)
1834 .with_image("mycustomimage:latest")
1835 .with_command("my-custom-command")
1836 .with_db_snapshot("https://storage.com/path/to/other/db_snapshot.tgz")
1837 .with_resources(|resources| {
1838 resources
1839 .with_request_cpu(1000)
1840 .with_request_memory("250Mi")
1841 .with_limit_cpu("5Gi")
1842 .with_limit_memory("2Gi")
1843 })
1844 .with_args(vec![("-myothername", "value").into()])
1845 })
1846 })
1847 .with_parachain(|parachain| {
1848 parachain
1849 .with_id(1000)
1850 .with_chain("myparachain")
1851 .with_chain_spec_path("/path/to/my/chain/spec.json")
1852 .with_default_db_snapshot("https://storage.com/path/to/other_snapshot.tgz")
1853 .with_default_command("my-default-command")
1854 .with_default_image("mydefaultimage:latest")
1855 .with_collator(|collator| {
1856 collator
1857 .with_name("john")
1858 .bootnode(true)
1859 .validator(true)
1860 .invulnerable(true)
1861 .with_initial_balance(5_000_000_000)
1862 .with_command("my-non-default-command")
1863 .with_image("anotherimage:latest")
1864 })
1865 .with_fullnode(|collator| {
1866 collator
1867 .with_name("charles")
1868 .bootnode(true)
1869 .invulnerable(true)
1870 .with_initial_balance(0)
1871 })
1872 })
1873 .build()
1874 .unwrap();
1875
1876 expected
1877 .parachains()
1878 .iter()
1879 .zip(load_from_toml.parachains().iter())
1880 .for_each(|(expected_parachain, loaded_parachain)| {
1881 assert_eq!(expected_parachain.id(), loaded_parachain.id());
1882 assert_eq!(expected_parachain.chain(), loaded_parachain.chain());
1883 assert_eq!(
1884 expected_parachain.chain_spec_path(),
1885 loaded_parachain.chain_spec_path()
1886 );
1887 assert_eq!(
1888 expected_parachain.registration_strategy(),
1889 loaded_parachain.registration_strategy()
1890 );
1891 assert_eq!(
1892 expected_parachain.onboard_as_parachain(),
1893 loaded_parachain.onboard_as_parachain()
1894 );
1895 assert_eq!(
1896 expected_parachain.default_db_snapshot(),
1897 loaded_parachain.default_db_snapshot()
1898 );
1899 assert_eq!(
1900 expected_parachain.default_command(),
1901 loaded_parachain.default_command()
1902 );
1903 assert_eq!(
1904 expected_parachain.default_image(),
1905 loaded_parachain.default_image()
1906 );
1907 assert_eq!(
1908 expected_parachain.collators().len(),
1909 loaded_parachain.collators().len()
1910 );
1911 expected_parachain
1912 .collators()
1913 .iter()
1914 .zip(loaded_parachain.collators().iter())
1915 .for_each(|(expected_collator, loaded_collator)| {
1916 assert_eq!(expected_collator.name(), loaded_collator.name());
1917 assert_eq!(expected_collator.command(), loaded_collator.command());
1918 assert_eq!(expected_collator.image(), loaded_collator.image());
1919 assert_eq!(
1920 expected_collator.is_validator(),
1921 loaded_collator.is_validator()
1922 );
1923 assert_eq!(
1924 expected_collator.is_bootnode(),
1925 loaded_collator.is_bootnode()
1926 );
1927 assert_eq!(
1928 expected_collator.is_invulnerable(),
1929 loaded_collator.is_invulnerable()
1930 );
1931 assert_eq!(
1932 expected_collator.initial_balance(),
1933 loaded_collator.initial_balance()
1934 );
1935 });
1936 });
1937 }
1938
1939 #[test]
1940 fn with_chain_and_nodes_works() {
1941 let network_config = NetworkConfigBuilder::with_chain_and_nodes(
1942 "rococo-local",
1943 vec!["alice".to_string(), "bob".to_string()],
1944 )
1945 .build()
1946 .unwrap();
1947
1948 assert_eq!(network_config.relaychain().chain().as_str(), "rococo-local");
1950 assert_eq!(network_config.relaychain().nodes().len(), 2);
1951 let mut node_names = network_config.relaychain().nodes().into_iter();
1952 let node1 = node_names.next().unwrap().name();
1953 assert_eq!(node1, "alice");
1954 let node2 = node_names.next().unwrap().name();
1955 assert_eq!(node2, "bob");
1956
1957 assert_eq!(network_config.parachains().len(), 0);
1959 }
1960
1961 #[test]
1962 fn with_chain_and_nodes_should_fail_with_empty_relay_name() {
1963 let errors = NetworkConfigBuilder::with_chain_and_nodes("", vec!["alice".to_string()])
1964 .build()
1965 .unwrap_err();
1966
1967 assert_eq!(
1968 errors.first().unwrap().to_string(),
1969 "relaychain.chain: can't be empty"
1970 );
1971 }
1972
1973 #[test]
1974 fn with_chain_and_nodes_should_fail_with_empty_node_list() {
1975 let errors = NetworkConfigBuilder::with_chain_and_nodes("rococo-local", vec![])
1976 .build()
1977 .unwrap_err();
1978
1979 assert_eq!(
1980 errors.first().unwrap().to_string(),
1981 "relaychain.nodes[''].name: can't be empty"
1982 );
1983 }
1984
1985 #[test]
1986 fn with_chain_and_nodes_should_fail_with_empty_node_name() {
1987 let errors = NetworkConfigBuilder::with_chain_and_nodes(
1988 "rococo-local",
1989 vec!["alice".to_string(), "".to_string()],
1990 )
1991 .build()
1992 .unwrap_err();
1993
1994 assert_eq!(
1995 errors.first().unwrap().to_string(),
1996 "relaychain.nodes[''].name: can't be empty"
1997 );
1998 }
1999
2000 #[test]
2001 fn with_parachain_id_and_collators_works() {
2002 let network_config = NetworkConfigBuilder::with_chain_and_nodes(
2003 "rococo-local",
2004 vec!["alice".to_string(), "bob".to_string()],
2005 )
2006 .with_parachain_id_and_collators(
2007 100,
2008 vec!["collator1".to_string(), "collator2".to_string()],
2009 )
2010 .build()
2011 .unwrap();
2012
2013 assert_eq!(network_config.relaychain().chain().as_str(), "rococo-local");
2015 assert_eq!(network_config.relaychain().nodes().len(), 2);
2016 let mut node_names = network_config.relaychain().nodes().into_iter();
2017 let node1 = node_names.next().unwrap().name();
2018 assert_eq!(node1, "alice");
2019 let node2 = node_names.next().unwrap().name();
2020 assert_eq!(node2, "bob");
2021
2022 assert_eq!(network_config.parachains().len(), 1);
2024 let ¶chain1 = network_config.parachains().first().unwrap();
2025 assert_eq!(parachain1.id(), 100);
2026 assert_eq!(parachain1.collators().len(), 2);
2027 let mut collator_names = parachain1.collators().into_iter();
2028 let collator1 = collator_names.next().unwrap().name();
2029 assert_eq!(collator1, "collator1");
2030 let collator2 = collator_names.next().unwrap().name();
2031 assert_eq!(collator2, "collator2");
2032
2033 assert_eq!(parachain1.initial_balance(), 2_000_000_000_000);
2034 }
2035
2036 #[test]
2037 fn with_parachain_id_and_collators_should_fail_with_empty_collator_list() {
2038 let errors =
2039 NetworkConfigBuilder::with_chain_and_nodes("polkadot", vec!["alice".to_string()])
2040 .with_parachain_id_and_collators(1, vec![])
2041 .build()
2042 .unwrap_err();
2043
2044 assert_eq!(
2045 errors.first().unwrap().to_string(),
2046 "parachain[1].can't be empty"
2047 );
2048 }
2049
2050 #[test]
2051 fn with_parachain_id_and_collators_should_fail_with_empty_collator_name() {
2052 let errors =
2053 NetworkConfigBuilder::with_chain_and_nodes("polkadot", vec!["alice".to_string()])
2054 .with_parachain_id_and_collators(1, vec!["collator1".to_string(), "".to_string()])
2055 .build()
2056 .unwrap_err();
2057
2058 assert_eq!(
2059 errors.first().unwrap().to_string(),
2060 "parachain[1].collators[''].name: can't be empty"
2061 );
2062 }
2063
2064 #[test]
2065 fn wasm_override_in_toml_should_work() {
2066 let load_from_toml = NetworkConfig::load_from_toml(
2067 "./testing/snapshots/0005-small-networl-with-wasm-override.toml",
2068 )
2069 .unwrap();
2070
2071 let expected = NetworkConfigBuilder::new()
2072 .with_relaychain(|relaychain| {
2073 relaychain
2074 .with_chain("rococo-local")
2075 .with_default_command("polkadot")
2076 .with_wasm_override("/some/path/runtime.wasm")
2077 .with_validator(|node| node.with_name("alice"))
2078 .with_validator(|node| node.with_name("bob"))
2079 })
2080 .with_parachain(|p| {
2081 p.with_id(1000)
2082 .with_wasm_override("https://some.com/runtime.wasm")
2083 .with_collator(|c| c.with_name("john"))
2084 })
2085 .build()
2086 .unwrap();
2087
2088 assert_eq!(
2089 load_from_toml.relaychain().wasm_override(),
2090 expected.relaychain().wasm_override()
2091 );
2092 assert_eq!(
2093 load_from_toml.parachains()[0].wasm_override(),
2094 expected.parachains()[0].wasm_override()
2095 );
2096 }
2097
2098 #[test]
2099 fn multiple_paras_with_same_id_should_work() {
2100 let network_config = NetworkConfigBuilder::new()
2101 .with_relaychain(|relaychain| {
2102 relaychain
2103 .with_chain("polkadot")
2104 .with_fullnode(|node| node.with_name("node").with_command("command"))
2105 .with_validator(|n| n.with_name("v"))
2106 .with_validator(|n| n.with_name("v1"))
2107 })
2108 .with_parachain(|parachain| {
2109 parachain
2110 .with_id(1)
2111 .with_chain("myparachain1")
2112 .with_collator(|collator| {
2113 collator.with_name("collator1").with_command("command1")
2114 })
2115 })
2116 .with_parachain(|parachain| {
2117 parachain
2118 .with_id(1)
2119 .with_chain("myparachain1")
2120 .with_registration_strategy(RegistrationStrategy::Manual)
2121 .with_collator(|collator| {
2122 collator.with_name("collator2").with_command("command1")
2123 })
2124 })
2125 .build()
2126 .unwrap();
2127
2128 let ¶chain2 = network_config.parachains().last().unwrap();
2129 assert_eq!(parachain2.unique_id(), "1-1");
2130 }
2131
2132 #[test]
2133 fn multiple_paras_with_same_id_both_for_register_should_fail() {
2134 let errors = NetworkConfigBuilder::new()
2135 .with_relaychain(|relaychain| {
2136 relaychain
2137 .with_chain("polkadot")
2138 .with_fullnode(|node| node.with_name("node").with_command("command"))
2139 })
2140 .with_parachain(|parachain| {
2141 parachain
2142 .with_id(1)
2143 .with_chain("myparachain1")
2144 .with_collator(|collator| {
2145 collator.with_name("collator1").with_command("command1")
2146 })
2147 })
2148 .with_parachain(|parachain| {
2149 parachain
2150 .with_id(1)
2151 .with_chain("myparachain1")
2152 .with_collator(|collator| {
2154 collator.with_name("collator2").with_command("command1")
2155 })
2156 })
2157 .build()
2158 .unwrap_err();
2159
2160 assert_eq!(
2161 errors.first().unwrap().to_string(),
2162 "ParaId 1 already set to be registered, only one should be."
2163 );
2164 }
2165
2166 #[test]
2167 fn network_config_should_work_from_toml_without_chain_name() {
2168 let loaded_from_toml =
2169 NetworkConfig::load_from_toml("./testing/snapshots/0006-without-rc-chain-name.toml")
2170 .unwrap();
2171
2172 assert_eq!(
2173 "rococo-local",
2174 loaded_from_toml.relaychain().chain().as_str()
2175 );
2176 }
2177
2178 #[test]
2179 fn network_config_should_work_from_toml_with_duplicate_name_between_collator_and_relay_node() {
2180 let loaded_from_toml = NetworkConfig::load_from_toml(
2181 "./testing/snapshots/0007-small-network_w_parachain_w_duplicate_node_names.toml",
2182 )
2183 .unwrap();
2184
2185 assert_eq!(
2186 loaded_from_toml
2187 .relaychain()
2188 .nodes()
2189 .iter()
2190 .filter(|n| n.name() == "alice")
2191 .count(),
2192 1
2193 );
2194 assert_eq!(
2195 loaded_from_toml
2196 .parachains()
2197 .iter()
2198 .flat_map(|para| para.collators())
2199 .filter(|n| n.name() == "alice-1")
2200 .count(),
2201 1
2202 );
2203 }
2204
2205 #[test]
2206 fn raw_spec_override_in_toml_should_work() {
2207 let load_from_toml = NetworkConfig::load_from_toml(
2208 "./testing/snapshots/0008-small-network-with-raw-spec-override.toml",
2209 )
2210 .unwrap();
2211
2212 let expected = NetworkConfigBuilder::new()
2213 .with_relaychain(|relaychain| {
2214 relaychain
2215 .with_chain("rococo-local")
2216 .with_default_command("polkadot")
2217 .with_raw_spec_override("/some/path/raw_spec_override.json")
2218 .with_validator(|node| node.with_name("alice"))
2219 .with_validator(|node| node.with_name("bob"))
2220 })
2221 .with_parachain(|p| {
2222 p.with_id(1000)
2223 .with_raw_spec_override("https://some.com/raw_spec_override.json")
2224 .with_collator(|c| c.with_name("john"))
2225 })
2226 .build()
2227 .unwrap();
2228
2229 assert_eq!(
2230 load_from_toml.relaychain().raw_spec_override(),
2231 expected.relaychain().raw_spec_override()
2232 );
2233 assert_eq!(
2234 load_from_toml.parachains()[0].raw_spec_override(),
2235 expected.parachains()[0].raw_spec_override()
2236 );
2237 }
2238
2239 const TOML_WITH_RELATIVE_PATHS: &str = r#"
2240[relaychain]
2241chain = "rococo-local"
2242default_command = "./bin/polkadot"
2243chain_spec_path = "./rc.json"
2244
2245[[relaychain.nodes]]
2246name = "alice"
2247validator = true
2248command = "polkadot"
2249"#;
2250
2251 #[test]
2252 fn toml_string_should_resolve_relative_paths_against_the_given_base_dir() {
2253 let config = NetworkConfig::load_from_toml_string_with_base_dir(
2254 TOML_WITH_RELATIVE_PATHS,
2255 Path::new("/tmp/some-base-dir"),
2256 )
2257 .unwrap();
2258
2259 assert_eq!(
2260 config.relaychain().default_command().unwrap().as_str(),
2261 "/tmp/some-base-dir/bin/polkadot"
2262 );
2263 assert_eq!(
2264 config.relaychain().chain_spec_path().unwrap().to_string(),
2265 "/tmp/some-base-dir/rc.json"
2266 );
2267 assert_eq!(
2269 config.relaychain().nodes()[0].command().unwrap().as_str(),
2270 "polkadot"
2271 );
2272 }
2273
2274 #[test]
2275 fn toml_string_should_resolve_relative_paths_against_the_cwd_by_default() {
2276 let from_cwd = NetworkConfig::load_from_toml_string(TOML_WITH_RELATIVE_PATHS).unwrap();
2277 let expected = NetworkConfig::load_from_toml_string_with_base_dir(
2278 TOML_WITH_RELATIVE_PATHS,
2279 &std::env::current_dir().unwrap(),
2280 )
2281 .unwrap();
2282
2283 assert_eq!(from_cwd, expected);
2284 }
2285
2286 #[test]
2287 fn toml_string_and_toml_file_should_produce_the_same_config() {
2288 let path = "./testing/snapshots/0006-without-rc-chain-name.toml";
2289 let from_file = NetworkConfig::load_from_toml(path).unwrap();
2290
2291 let file_path = PathBuf::from(path).canonicalize().unwrap();
2292 let base_dir = file_path.parent().unwrap();
2293 let from_string = NetworkConfig::load_from_toml_string_with_base_dir(
2294 &fs::read_to_string(path).unwrap(),
2295 base_dir,
2296 )
2297 .unwrap();
2298
2299 assert_eq!(from_file, from_string);
2300
2301 assert_eq!(
2303 from_string
2304 .relaychain()
2305 .chain_spec_path()
2306 .unwrap()
2307 .to_string(),
2308 base_dir.join("rc.json").to_string_lossy()
2309 );
2310 assert_eq!(
2311 from_string.parachains()[0]
2312 .chain_spec_path()
2313 .unwrap()
2314 .to_string(),
2315 base_dir.join("parachain.json").to_string_lossy()
2316 );
2317 }
2318
2319 #[test]
2320 fn with_jamchain() {
2321 let network_config = NetworkConfigBuilder::new()
2322 .with_relaychain(|relaychain| {
2323 relaychain
2324 .with_chain("westend")
2325 .with_default_command("polkadot")
2326 .with_default_image("docker.io/parity/polkadot:stable2603-3")
2327 .with_validator(|n| n.with_name("validator-0"))
2328 .with_validator(|n| n.with_name("validator-1"))
2329 })
2330 .with_parachain(|parachain| {
2331 parachain
2332 .with_id(1004)
2333 .with_chain_spec_path("https://raw.githubusercontent.com/paritytech/polkadot-sdk/104e66f7114ea3322187b4b93255bb9f3f4d5005/cumulus/zombienet/zombienet-sdk/tests/zombie_ci/statement_store/people-westend-local-spec.json")
2334 .with_collator_group(|g| {
2335 g.with_count(100)
2336 .with_base_node(|n|{
2337 n.with_name("collator")
2338 .with_command("polkadot-parachain")
2339 .with_args(vec!["--enable-statement-store".into()])
2340 .with_image("docker.io/parity/polkadot-parachain:stable2603-3")
2341 })
2342 })
2343 })
2344 .with_jamchain(|jamchain| {
2345 jamchain
2346 .with_id("dev")
2347 .with_validator(|jamnode|{
2348 jamnode.with_name("jam1")
2349 })
2350 })
2351 .build()
2352 .unwrap();
2353
2354 let toml_string = network_config.dump_to_toml().unwrap();
2355 println!("{}", toml_string);
2356 }
2357
2358 #[test]
2362 fn jamchain_removed_spec_fields_are_refused() {
2363 let cases = [
2364 (
2365 "chain_spec_command = \"polkajam\"\n",
2366 "chain_spec_command: removed",
2367 ),
2368 (
2369 "[jamchain.genesis_overrides]\nassigners = { \"0\" = 5 }\n",
2370 "genesis_overrides: removed, use `[jamchain.genesis]`",
2371 ),
2372 ];
2373 for (field, expected) in cases {
2374 let toml = format!(
2375 "[jamchain]\nid = \"dev\"\n{field}\n[[jamchain.nodes]]\nname = \"jam0\"\nmode = \"validator\"\n"
2376 );
2377
2378 let error = NetworkConfig::load_from_toml_string(&toml).unwrap_err();
2379
2380 assert!(error.to_string().contains(expected), "{error}");
2381 }
2382 }
2383
2384 #[test]
2385 fn jamchain_genesis_is_loaded_from_toml_with_paths_resolved() {
2386 let toml = r#"
2387[jamchain]
2388id = "dev"
2389
2390[jamchain.genesis]
2391bootstrap_service = "./blobs/bootstrap.jam"
2392
2393[jamchain.genesis.services.5]
2394code = "blobs/svc.jam"
2395balance = 1000
2396preimages = ["https://example.com/auth.jam"]
2397
2398[jamchain.genesis.auth_queues]
23990 = [{ code = "/abs/auth.jam" }]
24001 = ["null"]
2401
2402[jamchain.genesis.privileges]
2403assign = { 0 = 5 }
2404
2405[[jamchain.nodes]]
2406name = "jam0"
2407mode = "validator"
2408"#;
2409 let loaded =
2410 NetworkConfig::load_from_toml_string_with_base_dir(toml, Path::new("/net")).unwrap();
2411 let genesis = loaded.jamchain().unwrap().genesis().expect("a genesis");
2412
2413 assert_eq!(
2414 genesis.bootstrap_service(),
2415 Some(&AssetLocation::from("/net/./blobs/bootstrap.jam"))
2416 );
2417 let service = &genesis.services()[&5];
2418 assert_eq!(service.code(), &AssetLocation::from("/net/blobs/svc.jam"));
2419 assert_eq!(service.balance(), crate::JamBalance::Exact(1000));
2420 assert_eq!(
2421 service.preimages(),
2422 &[AssetLocation::from("https://example.com/auth.jam")]
2423 );
2424 assert_eq!(
2425 genesis.auth_queues()[&0],
2426 vec![crate::JamAuthorizer::code("/abs/auth.jam")]
2427 );
2428 assert_eq!(genesis.privileges().assign()[&0], 5);
2429
2430 let reloaded =
2431 NetworkConfig::load_from_toml_string(&loaded.dump_to_toml().unwrap()).unwrap();
2432 assert_eq!(reloaded.jamchain(), loaded.jamchain());
2433 }
2434
2435 #[test]
2436 fn the_jam_genesis_example_loads() {
2437 let config =
2438 NetworkConfig::load_from_toml("../examples/examples/configs/jam-genesis.toml").unwrap();
2439
2440 let jamchain = config.jamchain().unwrap();
2441 let genesis = jamchain.genesis().expect("the example has a genesis");
2442 let service = &genesis.services()[&5];
2443 assert!(service
2444 .code()
2445 .to_string()
2446 .ends_with("/configs/./blobs/my-service.jam"));
2447 assert_eq!(service.balance(), crate::JamBalance::MinimumPlus(1_000_000));
2448 assert_eq!(genesis.privileges().assign()[&0], 5);
2449 assert_eq!(jamchain.nodes().len(), 7);
2450 }
2451
2452 #[test]
2453 fn jamchain_toml_with_conflicting_spec_sources_is_refused() {
2454 let error = NetworkConfig::load_from_toml_string(
2455 r#"
2456[jamchain]
2457id = "dev"
2458chain_spec_path = "/specs/jam.json"
2459
2460[jamchain.genesis]
2461
2462[[jamchain.nodes]]
2463name = "jam0"
2464mode = "validator"
2465"#,
2466 )
2467 .unwrap_err();
2468
2469 assert!(
2470 error
2471 .to_string()
2472 .contains("genesis: can't be used with `chain_spec_path`"),
2473 "{error}"
2474 );
2475 }
2476
2477 #[test]
2478 fn genesis_patch_round_trips_through_toml() {
2479 let toml = r#"
2480[relaychain]
2481chain = "rococo-local"
2482default_command = "polkadot"
2483
2484[[relaychain.genesis_patch]]
2485op = "add"
2486path = "/balances/balances/-"
2487value = ["5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty", 1000000000000]
2488
2489[[relaychain.genesis_patch]]
2490op = "replace"
2491path = "/staking/minimumValidatorCount"
2492value = 7
2493
2494[[relaychain.nodes]]
2495name = "alice"
2496
2497[[parachains]]
2498id = 100
2499default_command = "polkadot-parachain"
2500
2501[[parachains.genesis_patch]]
2502op = "remove"
2503path = "/sudo"
2504
2505[[parachains.collators]]
2506name = "collator"
2507"#;
2508 let loaded = NetworkConfig::load_from_toml_string(toml).unwrap();
2509 let relay_patch = loaded.relaychain().genesis_patch().unwrap();
2510 assert_eq!(relay_patch.0.len(), 2);
2511 assert_eq!(
2512 serde_json::to_value(&relay_patch.0[1]).unwrap(),
2513 serde_json::json!({"op": "replace", "path": "/staking/minimumValidatorCount", "value": 7})
2514 );
2515 let para_patch = loaded.parachains()[0].genesis_patch().unwrap();
2516 assert_eq!(
2517 serde_json::to_value(para_patch).unwrap(),
2518 serde_json::json!([{"op": "remove", "path": "/sudo"}])
2519 );
2520
2521 let reloaded =
2522 NetworkConfig::load_from_toml_string(&loaded.dump_to_toml().unwrap()).unwrap();
2523 assert_eq!(reloaded.relaychain().genesis_patch(), Some(relay_patch));
2524 assert_eq!(reloaded.parachains()[0].genesis_patch(), Some(para_patch));
2525 }
2526
2527 #[test]
2528 fn jamchain_toml_without_relaychain_works() {
2529 let config = NetworkConfig::load_from_toml_string(
2530 r#"
2531[jamchain]
2532id = "dev"
2533default_command = "polkajam"
2534
2535[[jamchain.nodes]]
2536name = "jam0"
2537mode = "validator"
2538
2539[[jamchain.nodes]]
2540name = "jam-or"
2541mode = "ordinary"
2542"#,
2543 )
2544 .unwrap();
2545
2546 assert!(config.try_relaychain().is_none());
2547 let jamchain = config.jamchain().unwrap();
2548 assert_eq!(jamchain.id().as_str(), "dev");
2549 assert_eq!(jamchain.nodes().len(), 2);
2550 assert_eq!(jamchain.nodes()[1].mode(), &JamNodeMode::Ordinary);
2551 }
2552
2553 #[test]
2554 fn jamchain_toml_with_parachains_works() {
2555 let config = NetworkConfig::load_from_toml_string(
2556 r#"
2557[jamchain]
2558id = "dev"
2559default_command = "polkajam"
2560
2561[[jamchain.nodes]]
2562name = "jam-or"
2563mode = "ordinary"
2564
2565[[parachains]]
2566id = 1000
2567default_command = "polkadot-omni-node"
2568default_args = ["--jam-rpc-url http://{{ZOMBIE:jam-or:rpc_uri}}"]
2569
2570[[parachains.collators]]
2571name = "collator"
2572
2573[[parachains.collators]]
2574name = "collator"
2575"#,
2576 )
2577 .unwrap();
2578
2579 assert!(config.try_relaychain().is_none());
2580 assert!(config.jamchain().is_some());
2581
2582 let para = config.parachains()[0];
2583 assert_eq!(para.id(), 1000);
2584
2585 let collators = para.collators();
2587 assert_eq!(collators.len(), 2);
2588 assert_eq!(collators[0].name(), "collator");
2589 assert_eq!(collators[1].name(), "collator-1");
2590 for collator in collators {
2591 assert_eq!(collator.command().unwrap().as_str(), "polkadot-omni-node");
2592 assert_eq!(
2593 collator.args(),
2594 vec![&Arg::Option(
2595 "--jam-rpc-url".into(),
2596 "http://{{ZOMBIE:jam-or:rpc_uri}}".into()
2597 )]
2598 );
2599 }
2600 }
2601
2602 #[test]
2603 fn toml_without_relaychain_nor_jamchain_fails() {
2604 let err = NetworkConfig::load_from_toml_string(
2605 r#"
2606[[parachains]]
2607id = 1000
2608"#,
2609 )
2610 .unwrap_err();
2611
2612 assert_eq!(
2613 err.to_string(),
2614 "Relay chain or Jam definition does not exist."
2615 );
2616 }
2617
2618 #[test]
2619 fn with_tiny_jamchain() {
2620 let network_config = NetworkConfigBuilder::new()
2621 .with_relaychain(|relaychain| {
2622 relaychain
2623 .with_chain("westend")
2624 .with_default_command("polkadot")
2625 .with_default_image("docker.io/parity/polkadot:stable2603-3")
2626 .with_validator(|n| n.with_name("validator-0"))
2627 .with_validator(|n| n.with_name("validator-1"))
2628 })
2629 .with_tiny_jamchain()
2630 .build()
2631 .unwrap();
2632
2633 let toml_string = network_config.dump_to_toml().unwrap();
2634 println!("{}", toml_string);
2635 }
2636 #[test]
2637 fn demo_denis() {
2638 let network_config = NetworkConfigBuilder::new()
2639 .with_relaychain(|relaychain| {
2640 relaychain
2641 .with_chain("westend")
2642 .with_default_command("polkadot")
2643 .with_default_image("docker.io/parity/polkadot:stable2603-3")
2644 .with_validator(|n| n.with_name("validator-0"))
2645 .with_validator(|n| n.with_name("validator-1"))
2646 })
2647 .with_parachain(|parachain| {
2648 parachain
2649 .with_id(1004)
2650 .with_chain_spec_path("https://raw.githubusercontent.com/paritytech/polkadot-sdk/104e66f7114ea3322187b4b93255bb9f3f4d5005/cumulus/zombienet/zombienet-sdk/tests/zombie_ci/statement_store/people-westend-local-spec.json")
2651 .with_collator_group(|g| {
2652 g.with_count(100)
2653 .with_base_node(|n|{
2654 n.with_name("collator")
2655 .with_command("polkadot-parachain")
2656 .with_args(vec!["--enable-statement-store".into()])
2657 .with_image("docker.io/parity/polkadot-parachain:stable2603-3")
2658 })
2659 })
2660 })
2661 .build()
2662 .unwrap();
2663
2664 let toml_string = network_config.dump_to_toml().unwrap();
2665 println!("{}", toml_string);
2666 }
2667
2668 #[test]
2669 fn node_names_loaded_from_toml_are_made_valid_for_every_provider() {
2670 let network_config = NetworkConfig::load_from_toml_string(
2672 r#"
2673 [relaychain]
2674 chain = "rococo-local"
2675 default_command = "polkadot"
2676
2677 [[relaychain.nodes]]
2678 name = "Alice"
2679
2680 [[relaychain.nodes]]
2681 name = "my_node"
2682
2683 [[parachains]]
2684 id = 1000
2685 chain = "asset-hub-rococo"
2686 default_command = "polkadot-parachain"
2687
2688 [[parachains.collators]]
2689 name = "Collator-1000"
2690 "#,
2691 )
2692 .unwrap();
2693
2694 let validators: Vec<&str> = network_config
2695 .relaychain()
2696 .nodes()
2697 .iter()
2698 .map(|node| node.name())
2699 .collect();
2700 assert_eq!(validators, ["alice", "my-node"]);
2701 assert_eq!(
2702 network_config.parachains()[0].collators()[0].name(),
2703 "collator-1000"
2704 );
2705 }
2706
2707 fn load_with_processes(processes: &str) -> Result<NetworkConfig, anyhow::Error> {
2709 NetworkConfig::load_from_toml_string(&format!(
2710 r#"
2711 [relaychain]
2712 chain = "rococo-local"
2713 default_command = "polkadot"
2714
2715 [[relaychain.nodes]]
2716 name = "alice"
2717
2718 [[custom_processes]]
2719 {processes}
2720 "#
2721 ))
2722 }
2723
2724 #[test]
2725 fn custom_process_lifecycle_loads_from_toml_and_is_validated() {
2726 let config = load_with_processes(
2727 r#"
2728 name = "init"
2729 command = "sh"
2730 one_shot = true
2731 timeout = 30
2732
2733 [[custom_processes]]
2734 name = "api"
2735 command = "api"
2736 ports = [{ name = "http", port = 8080 }]
2737 ready_check = { http = { port = "http", path = "/health" }, interval = 2 }
2738 timeout = 120
2739 depends_on = ["init", { name = "cache", condition = "service_started" }]
2740
2741 [[custom_processes]]
2742 name = "cache"
2743 command = "cache"
2744 "#,
2745 )
2746 .unwrap();
2747 let processes = config.custom_processes();
2748 let api = processes[1];
2749 assert_eq!(api.timeout(), Some(120));
2750 assert_eq!(api.ready_check().unwrap().interval, 2);
2751 assert_eq!(api.depends_on().len(), 2);
2752 assert_eq!(
2753 api.depends_on()[1].condition,
2754 Some(DependencyCondition::ServiceStarted)
2755 );
2756 assert!(processes[0].one_shot());
2757 let dumped = config.dump_to_toml().unwrap();
2758 let reloaded = NetworkConfig::load_from_toml_string(&dumped).unwrap();
2759 assert_eq!(reloaded.custom_processes(), config.custom_processes());
2760
2761 let err = load_with_processes(
2763 r#"
2764 name = "api"
2765 command = "api"
2766 ports = [{ name = "http", port = 8080 }]
2767 ready_check = { http = { port = "http", path = "health" } }
2768 depends_on = [{ name = "cache", condition = "service_healthy" }]
2769
2770 [[custom_processes]]
2771 name = "cache"
2772 command = "cache"
2773 depends_on = ["api"]
2774 "#,
2775 )
2776 .unwrap_err()
2777 .to_string();
2778 assert!(
2779 err.contains("http path 'health' must start with '/'"),
2780 "{err}"
2781 );
2782 assert!(err.contains("'cache' cannot be service_healthy"), "{err}");
2783 assert!(err.contains("cycle among api, cache"), "{err}");
2784 }
2785
2786 #[test]
2787 fn custom_process_files_and_secret_env_load_from_toml_and_dump_back() {
2788 let config = load_with_processes(
2789 r#"
2790 name = "api"
2791 command = "api"
2792 env = [
2793 { name = "RUST_LOG", value = "info" },
2794 { name = "TURN_SECRET", secret = { name = "turn", key = "secret" } },
2795 ]
2796 injected_files = [
2797 { local_path = "./sql/init.sql", remote_path = "/schema/init.sql" },
2798 { local_path="./my-scripts/run_me.sh", remote_path = "/run.sh", mode = "0755" },
2799 ]
2800 "#,
2801 )
2802 .unwrap();
2803 let api = config.custom_processes()[0];
2804 assert_eq!(
2805 api.env()[1],
2806 ProcessEnvVar::from_secret("TURN_SECRET", "turn", "secret")
2807 );
2808 let run = &api.injected_files()[1];
2810 assert!(
2811 run.local_path.is_absolute() && run.local_path.ends_with("my-scripts/run_me.sh"),
2812 "{run:?}"
2813 );
2814 assert_eq!(run.remote_path.as_path(), std::path::Path::new("/run.sh"));
2815 assert_eq!(run.mode, "0755");
2816 let dumped = config.dump_to_toml().unwrap();
2817 let reloaded = NetworkConfig::load_from_toml_string(&dumped).unwrap();
2818 assert_eq!(reloaded.custom_processes(), config.custom_processes());
2819
2820 let err = load_with_processes(
2821 r#"
2822 name = "api"
2823 command = "api"
2824 injected_files = [{ local_path = "./run.sh", remote_path = "run.sh" }]
2825 "#,
2826 )
2827 .unwrap_err()
2828 .to_string();
2829 assert!(
2830 err.contains("remote_path 'run.sh' must be an absolute path"),
2831 "{err}"
2832 );
2833 }
2834
2835 #[test]
2836 fn custom_process_ports_and_resources_load_from_toml_and_dump_back() {
2837 let network_config = load_with_processes(
2838 r#"
2839 name = "ipfs"
2840 command = "ipfs"
2841 image = "docker.io/ipfs/kubo:v0.39.0"
2842 args = ["daemon"]
2843 ports = [{ name = "api", port = 5001 }, { name = "gateway", port = 8080 }]
2844
2845 [custom_processes.resources]
2846 limits = { cpu = "500m", memory = "512Mi" }
2847
2848 [[custom_processes]]
2849 name = "eth-rpc"
2850 command = "eth-rpc"
2851 "#,
2852 )
2853 .unwrap();
2854
2855 let processes = network_config.custom_processes();
2856 assert_eq!(processes.len(), 2);
2857 let ipfs = processes[0];
2858 assert_eq!(
2859 ipfs.ports()
2860 .iter()
2861 .map(|p| (p.name.as_str(), p.port))
2862 .collect::<Vec<_>>(),
2863 [("api", 5001), ("gateway", 8080)]
2864 );
2865 assert_eq!(
2866 ipfs.resources().unwrap().limit_cpu().unwrap().as_str(),
2867 "500m"
2868 );
2869 assert!(processes[1].ports().is_empty());
2870 assert!(processes[1].resources().is_none());
2871
2872 let dumped = network_config.dump_to_toml().unwrap();
2874 assert!(dumped.contains("[[custom_processes.ports]]"));
2875 let reloaded = NetworkConfig::load_from_toml_string(&dumped).unwrap();
2876 assert_eq!(
2877 reloaded.custom_processes(),
2878 network_config.custom_processes()
2879 );
2880 }
2881
2882 #[test]
2883 fn custom_processes_loaded_from_toml_are_validated() {
2884 let err = load_with_processes(
2886 r#"
2887 name = "eth-rpc"
2888 command = "eth-rpc"
2889 ports = [{ name = "json_rpc", port = 8545 }]
2890 "#,
2891 )
2892 .unwrap_err();
2893 assert!(
2894 err.to_string()
2895 .contains("custom_processes['eth-rpc'].ports: port name 'json_rpc'"),
2896 "{err}"
2897 );
2898
2899 let err = load_with_processes(
2901 r#"
2902 name = "alice"
2903 command = "eth-rpc"
2904 "#,
2905 )
2906 .unwrap_err();
2907 assert!(
2908 err.to_string()
2909 .contains("custom_processes['alice'].name: already used by a node"),
2910 "{err}"
2911 );
2912 }
2913
2914 #[test]
2915 fn a_custom_process_name_is_rejected_where_a_node_name_would_be_corrected() {
2916 let err = load_with_processes(
2917 r#"
2918 name = "eth_rpc"
2919 command = "eth-rpc"
2920 "#,
2921 )
2922 .unwrap_err();
2923 assert!(
2924 err.to_string()
2925 .contains("custom_processes['eth_rpc'].name: 'eth_rpc' must be"),
2926 "{err}"
2927 );
2928 assert!(err.to_string().contains("(e.g. 'eth-rpc')"), "{err}");
2929
2930 let err = load_with_processes(
2931 r#"
2932 name = ""
2933 command = "eth-rpc"
2934 "#,
2935 )
2936 .unwrap_err();
2937 assert!(
2938 err.to_string()
2939 .contains("custom_processes[''].name: can't be empty"),
2940 "{err}"
2941 );
2942
2943 let errors = NetworkConfigBuilder::new()
2944 .with_relaychain(|r| {
2945 r.with_chain("rococo-local")
2946 .with_default_command("polkadot")
2947 .with_validator(|node| node.with_name("alice"))
2948 })
2949 .with_custom_process(|c| c.with_name("Eth-RPC").with_command("eth-rpc"))
2950 .build()
2951 .unwrap_err();
2952 assert!(
2953 errors
2954 .iter()
2955 .any(|e| e.to_string().contains("custom_processes['Eth-RPC'].name:")),
2956 "{errors:?}"
2957 );
2958 }
2959
2960 #[test]
2961 fn a_custom_process_may_not_take_a_node_name_in_the_builder() {
2962 let errors = NetworkConfigBuilder::new()
2963 .with_relaychain(|r| {
2964 r.with_chain("rococo-local")
2965 .with_default_command("polkadot")
2966 .with_validator(|node| node.with_name("alice"))
2967 })
2968 .with_custom_process(|c| c.with_name("alice").with_command("eth-rpc"))
2969 .build()
2970 .unwrap_err();
2971 assert!(
2972 errors.iter().any(|e| e
2973 .to_string()
2974 .contains("already used by a node or custom process")),
2975 "{errors:?}"
2976 );
2977 }
2978}