org.buildforce.build.maven.plugins.RemoveDependenciesFromLocalRepositoryMojo.java Source code

Introduction

Here is the source code for org.buildforce.build.maven.plugins.RemoveDependenciesFromLocalRepositoryMojo.java

Source

/**
 * Copyright 2010 Fredhopper Research and Development
 *      http://www.fredhopper.com/
 *
 * Licensed 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.
 *
 * This code has been developed at Fredhopper.
 *
 */

package org.buildforce.build.maven.plugins;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DefaultArtifact;
import org.apache.maven.artifact.handler.DefaultArtifactHandler;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.model.Dependency;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.util.FileUtils;

import java.io.File;
import java.io.IOException;

/**
 * Remove project's artifacts from local repository. Useful to keep only one copy of large local snapshot,
 * for example: installer, for disk space optimization purpose.
 *
 * @author  <a href="carlspring@gmail.com">Martin Todorov</a>
 * @goal    remove-project-dependencies
 * @phase   clean
 */
public class RemoveDependenciesFromLocalRepositoryMojo extends AbstractMojo {

    public static final String MAVEN_METADATA_LOCAL = "maven-metadata-local.xml";

    /**
     * @parameter expression="${project}"
     * @required
     * @readonly
     */
    private MavenProject project;

    /**
     * @parameter default-value="${localRepository}"
     * @required
     * @readonly
     */
    private ArtifactRepository localRepository;

    /**
     * @parameter expression="${strict.mode}"
     */
    private boolean strictMode = false;

    /**
     * @parameter expression="${settings.offline}"
     * @readonly
     * @required
     */
    private boolean offline;

    public void execute() throws MojoExecutionException, MojoFailureException {
        if (!isOffline()) {
            getLog().info("Performing dependency cleanup...");

            for (Object o : project.getDependencies()) {
                Dependency dependency = (Dependency) o;

                getLog().debug(dependency.toString());

                Artifact artifact = convertDependencyToArtifact(dependency);

                File localArtifactFile = new File(localRepository.getBasedir(), localRepository.pathOf(artifact));
                File localArtifactDirectory = localArtifactFile.getParentFile();

                removeDependency(artifact, localArtifactDirectory);
            }

            removeAncestors();
        } else {
            getLog().info("Skipping dependency cleanup (running in offline mode).");
        }
    }

    private void removeAncestors() throws MojoExecutionException {
        MavenProject parent = project.getParent();
        MavenProject last = project;

        while (parent != null) {
            Artifact parentArtifact = last.getParentArtifact();

            File localArtifactFile = new File(localRepository.getBasedir(), localRepository.pathOf(parentArtifact));
            File localMetadataFile = new File(localArtifactFile.getParentFile(), MAVEN_METADATA_LOCAL);

            if (localMetadataFile.exists()) {
                boolean deletedSuccessfully = localMetadataFile.delete();

                if (!deletedSuccessfully)
                    throw new MojoExecutionException(
                            "Failed to remove " + localMetadataFile.getAbsolutePath() + "!");
                else
                    getLog().info("Removed maven-metadata-local.xml for parent " + parentArtifact.getGroupId() + ":"
                            + parentArtifact.getArtifactId() + ":" + parentArtifact.getVersion() + ": "
                            + localMetadataFile.getAbsolutePath());
            }

            parent = parent.getParent();
        }
    }

    private void removeDependency(Artifact artifact, File localArtifactDirectory)
            throws MojoFailureException, MojoExecutionException {
        if (strictMode) {
            try {
                getLog().info("Removing " + localArtifactDirectory.getAbsolutePath());
                FileUtils.deleteDirectory(localArtifactDirectory);
            } catch (IOException e) {
                throw new MojoFailureException("Cannot delete " + localArtifactDirectory);
            }
        } else {
            File localMetadataFile = new File(localArtifactDirectory, MAVEN_METADATA_LOCAL);
            if (localMetadataFile.exists()) {
                boolean deletedSuccessfully = localMetadataFile.delete();

                if (!deletedSuccessfully)
                    throw new MojoExecutionException(
                            "Failed to remove " + localMetadataFile.getAbsolutePath() + "!");
                else
                    getLog().info("Removed maven-metadata-local.xml for " + artifact.getGroupId() + ":"
                            + artifact.getArtifactId() + ":" + artifact.getVersion() + ": "
                            + localMetadataFile.getAbsolutePath());
            }
        }
    }

    private Artifact convertDependencyToArtifact(Dependency dependency) {
        return new DefaultArtifact(dependency.getGroupId(), dependency.getArtifactId(),
                VersionRange.createFromVersion(dependency.getVersion()), dependency.getScope(),
                dependency.getType(), dependency.getClassifier(),
                new DefaultArtifactHandler(project.getArtifact().getType()));
    }

    public boolean isOffline() {
        return offline;
    }

    public void setOffline(boolean offline) {
        this.offline = offline;
    }

}