feat: instantiate tanssi container chains

crates/pop-common/src/errors.rs

@@ -27,4 +27,6 @@ pub enum Error {
 	UnsupportedCommand(String),
 	#[error("Unsupported platform: {arch} {os}")]
 	UnsupportedPlatform { arch: &'static str, os: &'static str },
+	#[error("Toml error: {0}")]
+	TomlError(#[from] toml_edit::TomlError),
 }

crates/pop-common/src/manifest.rs

@@ -4,11 +4,29 @@ use crate::Error;
 use anyhow;
 pub use cargo_toml::{Dependency, Manifest};
 use std::{
+	collections::HashSet,
 	fs::{read_to_string, write},
 	path::{Path, PathBuf},
 };
 use toml_edit::{value, Array, DocumentMut, Item, Value};
 
+/// Collects the dependencies of the given manifests in a HashMap.
+///
+/// # Arguments
+/// * `manifests`: List of manifests to collect dependencies from.
+fn collect_manifest_dependencies(manifests: &[&Manifest]) -> anyhow::Result<HashSet<String>> {
+	let mut dependencies = HashSet::new();
+	for m in manifests {
+		for d in &m.dependencies {
+			dependencies.insert(d.0.into());
+		}
+		for d in &m.build_dependencies {
+			dependencies.insert(d.0.into());
+		}
+	}
+	Ok(dependencies)
+}
+
 /// Parses the contents of a `Cargo.toml` manifest.
 ///
 /// # Arguments
@@ -98,6 +116,88 @@ pub fn add_crate_to_workspace(workspace_toml: &Path, crate_path: &Path) -> anyho
 	Ok(())
 }
 
+/// Extends `target` cargo manifest with dependencies from `dependencies_from`
+/// using versions from `source`.
+///
+/// It is useful when the list of dependencies is compiled from some external crates,
+/// but there is interest on using a separate manifest as the source of truth for their versions.
+///
+/// # Arguments
+/// * `source`: Manifest used as reference for the dependency versions.
+/// * `target`: Manifest to be modified.
+/// * `tag`: Version to use when transforming local dependencies from `source`.
+/// * `dependencies_from`: List of `Manifest`s used to extend `target`.
+/// * `local_exceptions`: List of dependencies that need to be reference a local path.
+pub fn extend_dependencies_from_manifests_with_version_source(
+	source: Manifest,
+	target: &mut Manifest,
+	tag: Option<String>,
+	dependencies_from: &[&Manifest],
+	local_exceptions: Option<&[(String, String)]>,
+) -> Result<(), Error> {
+	let mut target_manifest_workspace = target.workspace.clone().ok_or_else(|| {
+		Error::ManifestError(cargo_toml::Error::WorkspaceIntegrity(
+			"Could not parse manifest's workspace.".into(),
+		))
+	})?;
+
+	let source_manifest_workspace = source.workspace.clone().ok_or_else(|| {
+		Error::ManifestError(cargo_toml::Error::WorkspaceIntegrity(
+			"Could not parse manifest's workspace.".into(),
+		))
+	})?;
+
+	// Collect dependencies.
+	let dependencies = collect_manifest_dependencies(dependencies_from)?;
+
+	// Update dependencies.
+	let updated_dependencies: Vec<_> = dependencies
+		.into_iter()
+		.filter_map(|k| {
+			if let Some(dependency) = source_manifest_workspace.dependencies.get(&k) {
+				if let Some(d) = dependency.detail() {
+					let mut detail = d.clone();
+					if d.path.is_some() {
+						detail.path = None;
+						detail.git = source_manifest_workspace
+							.package
+							.clone()
+							.expect("Dependencies exist in source manifest.")
+							.repository;
+						if let Some(tag) = &tag {
+							match tag.as_str() {
+								"master" => detail.branch = Some("master".to_string()),
+								_ => detail.tag = Some(tag.to_string()),
+							}
+						};
+					}
+					Some((k, Dependency::Detailed(Box::from(detail))))
+				} else {
+					Some((k, dependency.clone()))
+				}
+			} else {
+				None
+			}
+		})
+		.collect();
+
+	target_manifest_workspace.dependencies.extend(updated_dependencies);
+
+	// Address local exceptions.
+	if let Some(local_exceptions) = local_exceptions {
+		for (dependency, path) in local_exceptions {
+			let d =
+				target_manifest_workspace.dependencies.get_mut(dependency).unwrap().detail_mut();
+			d.git = None;
+			d.tag = None;
+			d.branch = None;
+			d.path = Some(path.to_owned());
+		}
+	}
+	target.workspace = Some(target_manifest_workspace);
+	Ok(())
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;

crates/pop-common/src/templates/extractor.rs

@@ -17,14 +17,24 @@ pub fn extract_template_files(
 	target_directory: &Path,
 	ignore_directories: Option<Vec<String>>,
 ) -> Result<()> {
-	let template_directory = repo_directory.join(template_name);
-	// Recursively copy all directories and files within. Ignores the specified ones.
-	copy_dir_all(
-		&template_directory,
-		target_directory,
-		&ignore_directories.unwrap_or_else(|| vec![]),
-	)?;
-	Ok(())
+	let template_directory = repo_directory.join(&template_name);
+	if template_directory.is_dir() {
+		// Recursively copy all directories and files within. Ignores the specified ones.
+		copy_dir_all(
+			&template_directory,
+			target_directory,
+			&ignore_directories.unwrap_or_else(|| vec![]),
+		)?;
+		return Ok(());
+	} else {
+		// If not a dir, just copy the file.
+		let dst = target_directory.join(&template_name);
+		// In case the first file being pulled is not a directory,
+		// Make sure the target directory exists.
+		fs::create_dir_all(&target_directory)?;
+		fs::copy(template_directory, &dst)?;
+		Ok(())
+	}
 }
 
 /// Recursively copy a directory and its files.

crates/pop-parachains/src/generator/container.rs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: GPL-3.0
+
+use askama::Template;
+
+#[derive(Template)]
+#[template(path = "container/network.templ", escape = "none")]
+pub(crate) struct Network {
+	pub(crate) node: String,
+}
+
+#[derive(Template)]
+#[template(path = "container/Cargo.templ", escape = "none")]
+pub(crate) struct Cargo {}

crates/pop-parachains/src/generator/mod.rs

@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: GPL-3.0
 
+pub mod container;
 pub mod pallet;
 pub mod parachain;

crates/pop-parachains/src/new_parachain.rs

@@ -1,18 +1,27 @@
 // SPDX-License-Identifier: GPL-3.0
 
-use crate::{
-	generator::parachain::{ChainSpec, Network},
-	utils::helpers::{sanitize, write_to_file},
-	Config, Parachain, Provider,
-};
+use std::{fs, path::Path};
+
 use anyhow::Result;
 use pop_common::{
 	git::Git,
-	templates::{Template, Type},
+	manifest::{extend_dependencies_from_manifests_with_version_source, from_path},
+	templates::{extractor::extract_template_files, Template, Type},
 };
-use std::{fs, path::Path};
 use walkdir::WalkDir;
 
+use crate::{
+	generator::{
+		container::{Cargo as ContainerCargo, Network as ContainerNetwork},
+		parachain::{ChainSpec, Network},
+	},
+	utils::helpers::{sanitize, write_to_file},
+	Config, Parachain, Provider,
+};
+
+// Type alias for tanssi specific parachain.
+type ContainerChain = Parachain;
+
 /// Create a new parachain.
 ///
 /// # Arguments
@@ -32,6 +41,9 @@ pub fn instantiate_template_dir(
 	if Provider::Pop.provides(&template) {
 		return instantiate_standard_template(template, target, config, tag_version);
 	}
+	if Provider::Tanssi.provides(&template) {
+		return instantiate_tanssi_template(template, target, tag_version);
+	}
 	let tag = Git::clone_and_degit(template.repository_url()?, target, tag_version)?;
 	Ok(tag)
 }
@@ -75,12 +87,125 @@ pub fn instantiate_standard_template(
 	Ok(tag)
 }
 
+/// Create a new Tanssi compatible container chain.
+///
+/// # Arguments
+///
+/// * `template` - template to generate the container-chain from.
+/// * `target` - location where the parachain will be created.
+/// * `tag_version` - version to use (`None` to use latest).
+fn instantiate_tanssi_template(
+	template: &ContainerChain,
+	target: &Path,
+	tag_version: Option<String>,
+) -> Result<Option<String>> {
+	let temp_dir = ::tempfile::TempDir::new_in(std::env::temp_dir())?;
+	let source = temp_dir.path();
+	let tag = Git::clone_and_degit(template.repository_url()?, &source, tag_version)?;
+
+	// Relevant files to extract.
+	let files = template.extractable_files().unwrap();
+	for file in files {
+		extract_template_files(file.to_string(), temp_dir.path(), target, None)?;
+	}
+
+	let owned_target = target.to_owned().to_path_buf();
+
+	// Templates are located in Tanssi's repo as follows:
+	// │
+	// ├┐ container-chains
+	// │├┬ nodes
+	// ││└ <template node directories>
+	// │└┬ runtime-templates
+	// │ └ <template runtime directories>
+
+	// Step 1: extract template node.
+	let template_path = format!(
+		"{}/{}",
+		template.node_directory().unwrap(),
+		template.template_name_without_provider()
+	);
+	extract_template_files(
+		template_path,
+		temp_dir.path(),
+		&owned_target.join("node").as_path(),
+		None,
+	)?;
+	// Step 2: extract template runtime.
+	let template_path = format!(
+		"{}/{}",
+		template.runtime_directory().unwrap(),
+		template.template_name_without_provider()
+	);
+	extract_template_files(
+		template_path,
+		temp_dir.path(),
+		&owned_target.join("runtime").as_path(),
+		None,
+	)?;
+
+	// Add network configuration.
+	use askama::Template;
+	let network = ContainerNetwork {
+		node: format!("container-chain-{}-node", template.template_name_without_provider()),
+	};
+	write_to_file(&target.join("network.toml"), network.render().expect("infallible").as_ref())?;
+
+	// Ready project manifest.
+	let target_manifest = ContainerCargo {};
+	write_to_file(
+		&target.join("Cargo.toml"),
+		target_manifest.render().expect("infallible").as_ref(),
+	)?;
+
+	// Dependencies that should remain with local references.
+	let local_dependencies = [(
+		format!("container-chain-template-{}-runtime", template.template_name_without_provider()),
+		"runtime".to_string(),
+	)];
+
+	let node_manifest = from_path(Some(
+		&source
+			.join(&format!("container-chains/nodes/{}", template.template_name_without_provider()))
+			.join("Cargo.toml"),
+	))?;
+	let runtime_manifest = from_path(Some(
+		&source
+			.join(&format!(
+				"container-chains/runtime-templates/{}",
+				template.template_name_without_provider()
+			))
+			.join("Cargo.toml"),
+	))?;
+	let dependencies_from = [&node_manifest, &runtime_manifest];
+
+	if dependencies_from.len() > 0 {
+		// Update versions to follow source.
+		let source_manifest = from_path(Some(source))?;
+		let mut target_manifest = from_path(Some(&target))?;
+		extend_dependencies_from_manifests_with_version_source(
+			source_manifest,
+			&mut target_manifest,
+			tag.clone(),
+			&dependencies_from,
+			Some(&local_dependencies),
+		)?;
+
+		let target_manifest = toml_edit::ser::to_string_pretty(&target_manifest)?;
+		fs::write(&target.join("Cargo.toml"), target_manifest)?;
+	}
+
+	Ok(tag)
+}
+
 #[cfg(test)]
 mod tests {
-	use super::*;
-	use anyhow::Result;
 	use std::{env::current_dir, fs};
 
+	use anyhow::Result;
+
+	use super::*;
+
 	fn setup_template_and_instantiate() -> Result<tempfile::TempDir> {
 		let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
 		let config = Config {
@@ -92,8 +217,14 @@ mod tests {
 		Ok(temp_dir)
 	}
 
+	fn setup_tanssi_template() -> Result<tempfile::TempDir> {
+		let temp_dir = tempfile::tempdir().expect("Failed to create temp dir");
+		instantiate_tanssi_template(&Parachain::TanssiSimple, temp_dir.path(), None)?;
+		Ok(temp_dir)
+	}
+
 	#[test]
-	fn test_parachain_instantiate_standard_template() -> Result<()> {
+	fn parachain_instantiate_standard_template_works() -> Result<()> {
 		let temp_dir =
 			setup_template_and_instantiate().expect("Failed to setup template and instantiate");
 
@@ -120,4 +251,20 @@ mod tests {
 
 		Ok(())
 	}
+
+	#[test]
+	fn instantiate_tanssi_template_works() -> Result<()> {
+		let temp_dir = setup_tanssi_template().expect("Failed to instantiate container chain");
+		let node_manifest =
+			pop_common::manifest::from_path(Some(&temp_dir.path().join("node/Cargo.toml")))
+				.expect("Failed to read file");
+		assert_eq!("container-chain-simple-node", node_manifest.package().name());
+
+		let node_manifest =
+			pop_common::manifest::from_path(Some(&temp_dir.path().join("runtime/Cargo.toml")))
+				.expect("Failed to read file");
+		assert_eq!("container-chain-template-simple-runtime", node_manifest.package().name());
+
+		Ok(())
+	}
 }