release_tool/target/

maven_reactor.rs

use super::{PreparedDependencies, TargetAdapter};
use crate::command::{CommandRequest, CommandRunner};
use crate::config::{MavenAttachment, TargetConfig};
use crate::domain::{
    ArtifactIdentity, ArtifactManifest, PreparedArtifact, ReleaseCandidate, TargetPlan,
};
use anyhow::{Context, Result, bail};
use roxmltree::{Document, Node};
use sha2::{Digest, Sha256};
use std::collections::{HashMap, HashSet};
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;

pub struct MavenReactorTarget {
    root: PathBuf,
    name: String,
    publisher: String,
    wrapper: PathBuf,
    pom: PathBuf,
    projects: Vec<String>,
    also_make: bool,
    remote_check: Vec<String>,
    attachments: Vec<MavenAttachment>,
    runner: Arc<dyn CommandRunner>,
}

#[derive(Clone, Debug)]
struct MavenProject {
    relative_path: String,
    directory: PathBuf,
    group_id: String,
    artifact_id: String,
    version: String,
    packaging: String,
    dependencies: Vec<(String, String)>,
}

impl MavenReactorTarget {
    pub fn new(
        root: impl Into<PathBuf>,
        config: &TargetConfig,
        runner: Arc<dyn CommandRunner>,
    ) -> Result<Self> {
        let TargetConfig::MavenReactor {
            name,
            publisher,
            wrapper,
            pom,
            projects,
            also_make,
            remote_check,
            attachments,
            ..
        } = config
        else {
            bail!("MavenReactorTarget requires a maven_reactor target config");
        };
        Ok(Self {
            root: root.into(),
            name: name.clone(),
            publisher: publisher.clone(),
            wrapper: wrapper.clone(),
            pom: pom.clone(),
            projects: projects.clone(),
            also_make: *also_make,
            remote_check: remote_check.clone(),
            attachments: attachments.clone(),
            runner,
        })
    }

    pub fn wrapper(&self) -> &Path {
        &self.wrapper
    }

    pub fn remote_check(&self) -> &[String] {
        &self.remote_check
    }

    fn selected_projects(&self, version: &str) -> Result<Vec<MavenProject>> {
        let root_pom = self.root.join(&self.pom);
        let root_source = fs::read_to_string(&root_pom)
            .with_context(|| format!("failed to read {}", root_pom.display()))?;
        let root_document = Document::parse(&root_source)
            .with_context(|| format!("invalid Maven POM {}", root_pom.display()))?;
        let root_project = root_document.root_element();
        let module_names = direct_child(root_project, "modules")
            .map(|modules| {
                direct_children(modules, "module")
                    .filter_map(|module| module.text().map(str::trim).map(str::to_owned))
                    .collect::<Vec<_>>()
            })
            .unwrap_or_default();
        let mut modules = Vec::new();
        for module in &module_names {
            modules.push(read_project(&self.root, module, version)?);
        }
        for selected in &self.projects {
            if !modules
                .iter()
                .any(|project| project.relative_path == *selected)
            {
                modules.push(read_project(&self.root, selected, version)?);
            }
        }

        let mut by_ga = HashMap::new();
        for (index, project) in modules.iter().enumerate() {
            let coordinates = (project.group_id.clone(), project.artifact_id.clone());
            if by_ga.insert(coordinates.clone(), index).is_some() {
                bail!(
                    "Maven reactor contains duplicate coordinates {}:{}",
                    coordinates.0,
                    coordinates.1
                );
            }
        }
        let mut selected_indices = HashSet::new();
        for selected in &self.projects {
            let index = modules
                .iter()
                .position(|project| project.relative_path == *selected)
                .with_context(|| format!("Maven project `{selected}` is not in the reactor"))?;
            include_project(
                index,
                &modules,
                &by_ga,
                self.also_make,
                &mut selected_indices,
            );
        }
        let selected = modules
            .into_iter()
            .enumerate()
            .filter_map(|(index, project)| selected_indices.contains(&index).then_some(project))
            .collect::<Vec<_>>();
        for attachment in &self.attachments {
            if !selected
                .iter()
                .any(|project| project.relative_path == attachment.project)
            {
                bail!(
                    "Maven attachment project `{}` is not selected (including also_make dependencies)",
                    attachment.project
                );
            }
        }
        Ok(selected)
    }

    fn identities(&self, project: &MavenProject, version: &str) -> Vec<ArtifactIdentity> {
        let mut artifacts = Vec::new();
        if project.packaging != "pom" {
            artifacts.push(identity(project, version, &project.packaging, None));
        }
        artifacts.push(identity(project, version, "pom", None));
        for attachment in &self.attachments {
            if attachment.project == project.relative_path {
                artifacts.push(identity(
                    project,
                    version,
                    &attachment.extension,
                    Some(attachment.classifier.clone()),
                ));
            }
        }
        artifacts
    }

    fn run_build(&self, version: &str) -> Result<()> {
        let mut arguments = vec![
            "-f".to_owned(),
            self.pom.display().to_string(),
            "-pl".to_owned(),
            self.projects.join(","),
        ];
        if self.also_make {
            arguments.push("-am".to_owned());
        }
        arguments.extend([
            format!("-Drevision={version}"),
            "--batch-mode".to_owned(),
            "--no-transfer-progress".to_owned(),
            "clean".to_owned(),
            "verify".to_owned(),
        ]);
        let request =
            CommandRequest::new(self.wrapper.display().to_string(), arguments, &self.root);
        self.runner
            .execute_inheriting_output(&request)?
            .require_success("prepare Maven reactor artifacts")?;
        Ok(())
    }
}

impl TargetAdapter for MavenReactorTarget {
    fn resolve(&self, release: &ReleaseCandidate) -> Result<TargetPlan> {
        let version = release.tag.to_string();
        let projects = self.selected_projects(&version)?;
        let mut artifacts = Vec::new();
        for project in projects {
            if project.version != version {
                bail!(
                    "Maven project {} resolves version {}, expected release version {version}",
                    project.relative_path,
                    project.version
                );
            }
            artifacts.extend(self.identities(&project, &version));
        }
        Ok(TargetPlan {
            name: self.name.clone(),
            publisher: self.publisher.clone(),
            release: release.clone(),
            artifacts,
        })
    }

    fn prepare(
        &self,
        plan: &TargetPlan,
        dependencies: &PreparedDependencies,
        staging: &Path,
    ) -> Result<ArtifactManifest> {
        if !dependencies.is_empty() {
            bail!("Maven reactor targets do not accept target dependencies");
        }
        if plan.name != self.name || plan.publisher != self.publisher {
            bail!(
                "target plan does not belong to Maven target `{}`",
                self.name
            );
        }
        fs::create_dir_all(staging)
            .with_context(|| format!("failed to create staging directory {}", staging.display()))?;
        let version = plan.release.tag.to_string();
        let projects = self.selected_projects(&version)?;
        self.run_build(&version)?;
        let mut prepared = Vec::new();
        for project in projects {
            if project.version != version {
                bail!(
                    "Maven project {} resolves version {}, expected release version {version}",
                    project.relative_path,
                    project.version
                );
            }
            let destination = staging
                .join(project.group_id.replace('.', "/"))
                .join(&project.artifact_id)
                .join(&version);
            fs::create_dir_all(&destination)?;
            for artifact in self.identities(&project, &version) {
                let file_name = artifact.maven_file_name()?;
                let path = destination.join(&file_name);
                if matches!(&artifact, ArtifactIdentity::MavenPackage { extension, classifier: None, .. } if extension == "pom")
                {
                    let flattened = project.directory.join("target/flattened-pom.xml");
                    let source = if flattened.is_file() {
                        flattened
                    } else {
                        project.directory.join("pom.xml")
                    };
                    let pom_source = fs::read_to_string(&source)
                        .with_context(|| {
                            format!("failed to read prepared POM {}", source.display())
                        })?
                        .replace("${revision}", &version);
                    fs::write(&path, pom_source)?;
                } else {
                    let source = project.directory.join("target").join(&file_name);
                    fs::copy(&source, &path).with_context(|| {
                        format!(
                            "failed to copy prepared Maven artifact {}",
                            source.display()
                        )
                    })?;
                }
                prepared.push(PreparedArtifact {
                    identity: artifact,
                    sha256: sha256(&path)?,
                    path,
                });
            }
        }
        if prepared
            .iter()
            .map(|artifact| &artifact.identity)
            .ne(plan.artifacts.iter())
        {
            bail!("prepared Maven artifact inventory differs from ReleasePlan");
        }
        Ok(ArtifactManifest {
            target: self.name.clone(),
            publisher: self.publisher.clone(),
            release: plan.release.clone(),
            artifacts: prepared,
        })
    }
}

fn read_project(root: &Path, relative_path: &str, revision: &str) -> Result<MavenProject> {
    let directory = root.join(relative_path);
    let path = directory.join("pom.xml");
    let source = fs::read_to_string(&path)
        .with_context(|| format!("failed to read Maven project {}", path.display()))?;
    let document = Document::parse(&source)
        .with_context(|| format!("invalid Maven POM {}", path.display()))?;
    let project = document.root_element();
    let parent = direct_child(project, "parent");
    let group_id = direct_text(project, "groupId")
        .or_else(|| parent.and_then(|parent| direct_text(parent, "groupId")))
        .with_context(|| format!("Maven project `{relative_path}` has no groupId"))?;
    let artifact_id = direct_text(project, "artifactId")
        .with_context(|| format!("Maven project `{relative_path}` has no artifactId"))?;
    let version = direct_text(project, "version")
        .or_else(|| parent.and_then(|parent| direct_text(parent, "version")))
        .with_context(|| format!("Maven project `{relative_path}` has no version"))?;
    let group_id = resolve_model_value(&group_id, revision, relative_path, "groupId")?;
    let artifact_id = resolve_model_value(&artifact_id, revision, relative_path, "artifactId")?;
    let version = resolve_model_value(&version, revision, relative_path, "version")?;
    let packaging = resolve_model_value(
        &direct_text(project, "packaging").unwrap_or_else(|| "jar".to_owned()),
        revision,
        relative_path,
        "packaging",
    )?;
    if !matches!(packaging.as_str(), "jar" | "pom") {
        bail!(
            "Maven project `{relative_path}` uses unsupported packaging `{packaging}`; first release supports exact jar/pom inventories only"
        );
    }
    let mut dependencies = Vec::new();
    if let Some(container) = direct_child(project, "dependencies") {
        for dependency in direct_children(container, "dependency") {
            let scope = direct_text(dependency, "scope");
            if matches!(scope.as_deref(), Some("test") | Some("provided")) {
                continue;
            }
            let dependency_group = direct_text(dependency, "groupId")
                .with_context(|| format!("Maven dependency in `{relative_path}` has no groupId"))?;
            let dependency_artifact = direct_text(dependency, "artifactId").with_context(|| {
                format!("Maven dependency in `{relative_path}` has no artifactId")
            })?;
            dependencies.push((
                resolve_model_value(
                    &dependency_group,
                    revision,
                    relative_path,
                    "dependency groupId",
                )?,
                resolve_model_value(
                    &dependency_artifact,
                    revision,
                    relative_path,
                    "dependency artifactId",
                )?,
            ));
        }
    }
    Ok(MavenProject {
        relative_path: relative_path.trim_end_matches('/').to_owned(),
        directory,
        group_id,
        artifact_id,
        version,
        packaging,
        dependencies,
    })
}

fn resolve_model_value(value: &str, revision: &str, project: &str, field: &str) -> Result<String> {
    let resolved = value.replace("${revision}", revision);
    if resolved.contains("${") {
        bail!("Maven project `{project}` has an unresolved expression in {field}: `{value}`");
    }
    Ok(resolved)
}

fn include_project(
    index: usize,
    projects: &[MavenProject],
    by_ga: &HashMap<(String, String), usize>,
    include_dependencies: bool,
    selected: &mut HashSet<usize>,
) {
    if !selected.insert(index) || !include_dependencies {
        return;
    }
    for dependency in &projects[index].dependencies {
        if let Some(dependency_index) = by_ga.get(dependency) {
            include_project(
                *dependency_index,
                projects,
                by_ga,
                include_dependencies,
                selected,
            );
        }
    }
}

fn identity(
    project: &MavenProject,
    version: &str,
    extension: &str,
    classifier: Option<String>,
) -> ArtifactIdentity {
    ArtifactIdentity::MavenPackage {
        group_id: project.group_id.clone(),
        artifact_id: project.artifact_id.clone(),
        version: version.to_owned(),
        extension: extension.to_owned(),
        classifier,
    }
}

fn direct_child<'a, 'input>(node: Node<'a, 'input>, name: &str) -> Option<Node<'a, 'input>> {
    node.children()
        .find(|child| child.is_element() && child.tag_name().name() == name)
}

fn direct_children<'a, 'input>(
    node: Node<'a, 'input>,
    name: &'a str,
) -> impl Iterator<Item = Node<'a, 'input>> + 'a {
    node.children()
        .filter(move |child| child.is_element() && child.tag_name().name() == name)
}

fn direct_text(node: Node<'_, '_>, name: &str) -> Option<String> {
    direct_child(node, name)
        .and_then(|child| child.text())
        .map(str::trim)
        .filter(|text| !text.is_empty())
        .map(str::to_owned)
}

fn sha256(path: &Path) -> Result<String> {
    let bytes = fs::read(path).with_context(|| format!("failed to read {}", path.display()))?;
    Ok(hex::encode(Sha256::digest(bytes)))
}