src/main/java/org/apache/maven/buildcache/DefaultNormalizedModelProvider.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.buildcache;

import javax.inject.Inject;
import javax.inject.Named;

import java.util.Collection;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;

import org.apache.maven.SessionScoped;
import org.apache.maven.buildcache.xml.CacheConfig;
import org.apache.maven.lifecycle.internal.builder.BuilderCommon;
import org.apache.maven.model.Build;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.Model;
import org.apache.maven.model.Plugin;
import org.apache.maven.model.PluginExecution;
import org.apache.maven.project.MavenProject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@SessionScoped
@Named
public class DefaultNormalizedModelProvider implements NormalizedModelProvider {

    private static final String NORMALIZED_VERSION = "cache-extension-version";

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultNormalizedModelProvider.class);

    private final CacheConfig cacheConfig;
    private final MultiModuleSupport multiModuleSupport;
    private final ConcurrentMap<String, Model> modelCache = new ConcurrentHashMap<>();

    @Inject
    public DefaultNormalizedModelProvider(MultiModuleSupport multiModuleSupport, CacheConfig cacheConfig) {
        this.multiModuleSupport = multiModuleSupport;
        this.cacheConfig = cacheConfig;
    }

    @Override
    public Model normalizedModel(MavenProject project) {
        MavenProject validatedProject = Objects.requireNonNull(project, "project");
        return modelCache.computeIfAbsent(
                BuilderCommon.getKey(validatedProject), k -> normalizedModelInner(validatedProject));
    }

    private Model normalizedModelInner(MavenProject project) {
        // prefer project from multimodule than reactor because effective pom of reactor project
        // could be built with maven local/remote dependencies but not with artifacts from cache
        MavenProject projectToNormalize = multiModuleSupport
                .tryToResolveProject(project.getGroupId(), project.getArtifactId(), project.getVersion())
                .orElse(project);
        Model prototype = projectToNormalize.getModel();

        // TODO validate status of the model - it should be in resolved state
        Model resultModel = new Model();

        resultModel.setGroupId(prototype.getGroupId());
        resultModel.setArtifactId(prototype.getArtifactId());
        // does not make sense to add project version to calculate hash
        resultModel.setVersion(NORMALIZED_VERSION);
        resultModel.setModules(prototype.getModules());

        resultModel.setDependencies(normalizeDependencies(prototype.getDependencies()));

        org.apache.maven.model.Build protoBuild = prototype.getBuild();
        if (protoBuild == null) {
            return resultModel;
        }

        Build build = new Build();
        List<Plugin> plugins = prototype.getBuild().getPlugins();
        build.setPlugins(normalizePlugins(plugins));
        resultModel.setBuild(build);
        return resultModel;
    }

    private List<Dependency> normalizeDependencies(Collection<Dependency> source) {
        return source.stream()
                .map(it -> {
                    if (!multiModuleSupport.isPartOfMultiModule(it.getGroupId(), it.getArtifactId(), it.getVersion())) {
                        return it;
                    }
                    Dependency cloned = it.clone();
                    cloned.setVersion(NORMALIZED_VERSION);
                    return cloned;
                })
                .sorted(DefaultNormalizedModelProvider::compareDependencies)
                .collect(Collectors.toList());
    }

    private List<Plugin> normalizePlugins(List<Plugin> plugins) {
        if (plugins.isEmpty()) {
            return plugins;
        }

        return plugins.stream()
                .map(plugin -> {
                    Plugin copy = plugin.clone();
                    List<String> excludeProperties = cacheConfig.getEffectivePomExcludeProperties(copy);
                    if (!excludeProperties.isEmpty()) {
                        CacheUtils.debugPrintCollection(
                                LOGGER,
                                excludeProperties,
                                String.format("List of excluded properties for %s", copy.getArtifactId()),
                                "Excluded property");
                        removeBlacklistedAttributes(copy.getConfiguration(), excludeProperties);
                        for (PluginExecution execution : copy.getExecutions()) {
                            removeBlacklistedAttributes(execution.getConfiguration(), excludeProperties);
                        }
                    }

                    copy.setDependencies(normalizeDependencies(copy.getDependencies().stream()
                            .sorted(DefaultNormalizedModelProvider::compareDependencies)
                            .collect(Collectors.toList())));
                    if (multiModuleSupport.isPartOfMultiModule(
                            copy.getGroupId(), copy.getArtifactId(), copy.getVersion())) {
                        copy.setVersion(NORMALIZED_VERSION);
                    }
                    return copy;
                })
                .collect(Collectors.toList());
    }

    private void removeBlacklistedAttributes(Object node, List<String> excludeProperties) {
        if (node == null) {
            return;
        }

        Object[] children = Xpp3DomUtils.getChildren(node);
        int indexToRemove = 0;
        for (Object child : children) {
            if (excludeProperties.contains(Xpp3DomUtils.getName(child))) {
                Xpp3DomUtils.removeChild(node, indexToRemove);
                continue;
            }
            indexToRemove++;
            removeBlacklistedAttributes(child, excludeProperties);
        }
    }

    private static int compareDependencies(Dependency d1, Dependency d2) {
        return d1.getArtifactId().compareTo(d2.getArtifactId());
    }
}