Initial work on stage repo-based purging.

* The repository definition for stage will need to be:
** Discrete from other repositories.
** Discrete from any nexus 'mirror' id set in a mirror definition.

Maven's 'enhanced' local repo managers (aether, if you really want to get pendantic) like to cache source repositories by repo (server) "Id", not by URI base path.
This has the consequence of: If you use an authenticated mirror for your 'central' proxy (to say, public/groups in nexus 2 parlance), and you give that mirror an 'id'...

For argument sake, let's say that's 'corporate-nexus-proxy', and then define your credentials for 'coroporate-nexus-proxy'.

Running maven and having dependencies resolve from that mirror, will get them recorded in the local repo as having come from 'corporate-nexus-proxy'.

If you use that same 'id' as part of your stage repository definition:

`<stageDeploymentRepository>corporate-nexus-proxy::foo::bar::false</stageDeploymentRepository>`

Then any non-snapshot dependency will look like it came from the 'stage' repository, and the 'update-stage-dependencies' will purge all your local non-snapshot dependencies and re-resolve them. Yick.

If you use a discrete id for the `stageDeploymentRepository` (a good idea, from a security standpoint, in fact), this won't happen, and only things which were actually resolved from the stage repo's id into your local will become elligable for purging.

This is doubly awesome, in that once a thing locally resolved from stage gets purged, and then reresolved from 'release' (due it having been you know, promoted) your local repo will stop purging them, since the remote ID wouldn't match the stage repo Id anymore.

It's a bit convoluted, but I'll update the docs and readmes in due-course.. and I may move this behavior to the extension (if I can reliably inject the necessary bits) to purge earlier in the build cycle.

Author: bvarner

src/main/java/com/e_gineering/maven/gitflowhelper/AbstractGitflowBasedRepositoryMojo.java

@@ -9,11 +9,14 @@
 import org.apache.maven.plugins.annotations.Parameter;
 import org.apache.maven.project.MavenProjectHelper;
 import org.codehaus.plexus.util.FileUtils;
+import org.eclipse.aether.DefaultRepositorySystemSession;
 import org.eclipse.aether.RepositorySystemSession;
 import org.eclipse.aether.artifact.DefaultArtifact;
 import org.eclipse.aether.impl.ArtifactResolver;
+import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
 import org.eclipse.aether.repository.LocalRepository;
 import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.repository.RepositoryPolicy;
 import org.eclipse.aether.resolution.ArtifactRequest;
 import org.eclipse.aether.resolution.ArtifactResolutionException;
 import org.eclipse.aether.resolution.ArtifactResult;
@@ -27,7 +30,6 @@
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.lang.reflect.Field;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.util.ArrayList;
@@ -54,7 +56,10 @@ public abstract class AbstractGitflowBasedRepositoryMojo extends AbstractGitflow
     protected String snapshotDeploymentRepository;
 
     @Parameter(defaultValue = "${repositorySystemSession}", required = true)
-    private RepositorySystemSession session;
+    protected RepositorySystemSession session;
+
+    @Component
+    protected EnhancedLocalRepositoryManagerFactory localRepositoryManagerFactory;
 
     @Parameter(defaultValue = "${project.build.directory}", required = true)
     protected File buildDirectory;
@@ -109,7 +114,7 @@ protected ArtifactRepository getDeploymentRepository(final String altRepository)
      * @throws MojoExecutionException
      * @throws MojoFailureException
      */
-    private RemoteRepository getRepository(final String altRepository) throws MojoExecutionException, MojoFailureException {
+    protected RemoteRepository getRepository(final String altRepository) throws MojoExecutionException, MojoFailureException {
         if (getLog().isDebugEnabled()) {
             getLog().debug("Creating remote Aether repository (to resolve remote artifacts) for: " + altRepository);
         }
@@ -137,15 +142,14 @@ private RemoteRepository getRepository(final String altRepository) throws MojoEx
     }
 
     private String getCoordinates(ArtifactResult result) {
-        StringBuilder buffer = new StringBuilder( 128 );
-        buffer.append( result.getArtifact().getGroupId() );
-        buffer.append( ':' ).append( result.getArtifact().getArtifactId() );
-        buffer.append( ':' ).append( result.getArtifact().getExtension() );
-        if ( result.getArtifact().getClassifier().length() > 0 )
-        {
-            buffer.append( ':' ).append( result.getArtifact().getClassifier() );
+        StringBuilder buffer = new StringBuilder(128);
+        buffer.append(result.getArtifact().getGroupId());
+        buffer.append(':').append(result.getArtifact().getArtifactId());
+        buffer.append(':').append(result.getArtifact().getExtension());
+        if (result.getArtifact().getClassifier().length() > 0) {
+            buffer.append(':').append(result.getArtifact().getClassifier());
         }
-        buffer.append( ':' ).append( result.getArtifact().getBaseVersion() );
+        buffer.append(':').append(result.getArtifact().getBaseVersion());
         return buffer.toString();
     }
 
@@ -183,47 +187,46 @@ private String getCoordinates(org.apache.maven.artifact.Artifact artifact) {
      * group:artifact:type:classifier:version
      */
     protected void attachArtifactCatalog() throws MojoExecutionException {
-            getLog().info("Cataloging Artifacts for promotion & reattachment: " + project.getBuild().getDirectory());
+        getLog().info("Cataloging Artifacts for promotion & reattachment: " + project.getBuild().getDirectory());
 
-            File catalog = new File(buildDirectory, project.getArtifact().getArtifactId() + ".txt");
+        File catalog = new File(buildDirectory, project.getArtifact().getArtifactId() + ".txt");
 
-            PrintWriter writer = null;
+        PrintWriter writer = null;
 
-            try {
-                catalog.delete();
-                buildDirectory.mkdirs();
-                writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(catalog), Charset.forName("UTF-8")));
-
-                if (project.getArtifact() != null && project.getArtifact().getFile() != null &&
-                        project.getArtifact().getFile().exists() && !project.getArtifact().getFile().isDirectory())
-                {
-                    String coords = getCoordinates(project.getArtifact());
-                    if (!coords.isEmpty()){
-                        getLog().info("Cataloging: " + coords);
-                        writer.println(coords);
-                    }
-                } else {
-                    getLog().info("No primary artifact to catalog, cataloging attached artifacts instead.");
+        try {
+            catalog.delete();
+            buildDirectory.mkdirs();
+            writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(catalog), Charset.forName("UTF-8")));
+
+            if (project.getArtifact() != null && project.getArtifact().getFile() != null &&
+                    project.getArtifact().getFile().exists() && !project.getArtifact().getFile().isDirectory()) {
+                String coords = getCoordinates(project.getArtifact());
+                if (!coords.isEmpty()) {
+                    getLog().info("Cataloging: " + coords);
+                    writer.println(coords);
                 }
+            } else {
+                getLog().info("No primary artifact to catalog, cataloging attached artifacts instead.");
+            }
 
-                // Iterate the attached artifacts.
-                for (org.apache.maven.artifact.Artifact artifact : project.getAttachedArtifacts()) {
-                    String coords = getCoordinates(artifact);
-                    if (!coords.isEmpty()) {
-                        getLog().info("Cataloging: " + coords);
-                        writer.println(coords);
-                    }
+            // Iterate the attached artifacts.
+            for (org.apache.maven.artifact.Artifact artifact : project.getAttachedArtifacts()) {
+                String coords = getCoordinates(artifact);
+                if (!coords.isEmpty()) {
+                    getLog().info("Cataloging: " + coords);
+                    writer.println(coords);
                 }
+            }
 
-                getLog().info("Attaching catalog artifact: " + catalog);
-                projectHelper.attachArtifact(project, "txt", "catalog", catalog);
-            } catch (IOException ioe) {
-                throw new MojoExecutionException("Failed to create catalog of artifacts", ioe);
-            } finally {
-                if (writer != null) {
-                    writer.close();
-                }
+            getLog().info("Attaching catalog artifact: " + catalog);
+            projectHelper.attachArtifact(project, "txt", "catalog", catalog);
+        } catch (IOException ioe) {
+            throw new MojoExecutionException("Failed to create catalog of artifacts", ioe);
+        } finally {
+            if (writer != null) {
+                writer.close();
             }
+        }
     }
 
     /**
@@ -250,35 +253,30 @@ protected void attachExistingArtifacts(final String sourceRepository, final bool
         // A place to store our resolved files...
         List<ArtifactResult> resolvedArtifacts = new ArrayList<ArtifactResult>();
 
-        // Keep track of the original base directory.
-        Field localBaseDir = null;
-        File originalBaseDir = session.getLocalRepositoryManager().getRepository().getBasedir();
 
-        // Disable the local repository - using a bit of reflection that I wish we didn't need to use.
+        // Use a custom repository session, setup to force a few behaviors we like.
+        DefaultRepositorySystemSession tempSession = new DefaultRepositorySystemSession(session);
+        tempSession.setUpdatePolicy(RepositoryPolicy.UPDATE_POLICY_ALWAYS);
+
         File tempRepo = null;
         if (disableLocal) {
-            getLog().info("Disabling local repository @ " + session.getLocalRepository().getBasedir());
+            getLog().info("Disabling local repository @ " + tempSession.getLocalRepository().getBasedir());
             try {
-                localBaseDir = LocalRepository.class.getDeclaredField("basedir");
-                localBaseDir.setAccessible(true);
-
-                // Generate a new temp directory.
                 tempRepo = Files.createTempDirectory("gitflow-helper-maven-plugin-repo").toFile();
 
                 getLog().info("Using temporary local repository @ " + tempRepo.getAbsolutePath());
-                localBaseDir.set(session.getLocalRepositoryManager().getRepository(), tempRepo);
+                tempSession.setLocalRepositoryManager(localRepositoryManagerFactory.newInstance(tempSession, new LocalRepository(tempRepo)));
             } catch (Exception ex) {
                 getLog().warn("Failed to disable local repository path.", ex);
             }
         }
 
-
         List<ArtifactRequest> requiredArtifacts = new ArrayList<ArtifactRequest>();
 
         // Locate our text catalog classifier file. :-)
         BufferedReader reader = null;
         try {
-            ArtifactResult catalogResult = artifactResolver.resolveArtifact(session, new ArtifactRequest(new DefaultArtifact(project.getGroupId(), project.getArtifactId(), "catalog", "txt", project.getVersion()), remoteRepositories, null));
+            ArtifactResult catalogResult = artifactResolver.resolveArtifact(tempSession, new ArtifactRequest(new DefaultArtifact(project.getGroupId(), project.getArtifactId(), "catalog", "txt", project.getVersion()), remoteRepositories, null));
             resolvedArtifacts.add(catalogResult);
 
             if (catalogResult.isResolved()) {
@@ -301,14 +299,15 @@ protected void attachExistingArtifacts(final String sourceRepository, final bool
             if (reader != null) {
                 try {
                     reader.close();
-                } catch (IOException ioe) {}
+                } catch (IOException ioe) {
+                }
             }
         }
 
 
         // Resolve the artifacts from the catalog (if there are any)
         try {
-            resolvedArtifacts.addAll(artifactResolver.resolveArtifacts(session, requiredArtifacts));
+            resolvedArtifacts.addAll(artifactResolver.resolveArtifacts(tempSession, requiredArtifacts));
         } catch (ArtifactResolutionException are) {
             throw new MojoExecutionException("Failed to resolve the required project files from: " + sourceRepository, are);
         }
@@ -339,12 +338,6 @@ protected void attachExistingArtifacts(final String sourceRepository, final bool
 
         // Restore the local repository, again using reflection.
         if (disableLocal) {
-            try {
-                localBaseDir.set(session.getLocalRepositoryManager().getRepository(), originalBaseDir);
-                localBaseDir.setAccessible(false);
-            } catch (Exception ex) {
-                getLog().warn("Failed to restore original local repository path.", ex);
-            }
             if (tempRepo != null) {
                 try {
                     FileUtils.deleteDirectory(tempRepo);

src/main/java/com/e_gineering/maven/gitflowhelper/UpdateStageDependenciesMojo.java

@@ -0,0 +1,92 @@
+package com.e_gineering.maven.gitflowhelper;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.maven.plugin.MojoExecutionException;
+import org.apache.maven.plugin.MojoFailureException;
+import org.apache.maven.plugins.annotations.Component;
+import org.apache.maven.plugins.annotations.LifecyclePhase;
+import org.apache.maven.plugins.annotations.Mojo;
+import org.apache.maven.project.DefaultDependencyResolutionRequest;
+import org.apache.maven.project.DependencyResolutionException;
+import org.apache.maven.project.DependencyResolutionResult;
+import org.apache.maven.project.ProjectDependenciesResolver;
+import org.eclipse.aether.DefaultRepositoryCache;
+import org.eclipse.aether.DefaultRepositorySystemSession;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.repository.LocalArtifactRequest;
+import org.eclipse.aether.repository.LocalArtifactResult;
+import org.eclipse.aether.repository.LocalRepositoryManager;
+import org.eclipse.aether.repository.RemoteRepository;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Forces a re-resolution of all dependency artifacts which were resolved from the 'stage' remote repository.
+ */
+@Mojo(name = "update-stage-dependencies", defaultPhase = LifecyclePhase.INITIALIZE)
+public class UpdateStageDependenciesMojo extends AbstractGitflowBasedRepositoryMojo {
+
+    @Component
+    ProjectDependenciesResolver dependenciesResolver;
+
+    @Override
+    protected void execute(GitBranchType type, String gitBranch, String branchPattern) throws MojoExecutionException, MojoFailureException {
+        getLog().debug("update-stage-dependencies setting up Repository session...");
+
+        DefaultRepositorySystemSession reresolveSession = new DefaultRepositorySystemSession(session);
+        reresolveSession.setUpdatePolicy(org.eclipse.aether.repository.RepositoryPolicy.UPDATE_POLICY_ALWAYS);
+        reresolveSession.setCache(new DefaultRepositoryCache());
+
+        LocalRepositoryManager localRepositoryManager = reresolveSession.getLocalRepositoryManager();
+
+        getLog().debug("configuring stage as the remote repository for artifact resolution requests...");
+        List<RemoteRepository> stageRepo = Arrays.asList(getRepository(stageDeploymentRepository));
+
+        boolean itemsPurged = false;
+
+        try {
+            DependencyResolutionResult depencencyResult = dependenciesResolver.resolve(
+                    new DefaultDependencyResolutionRequest(project, reresolveSession));
+
+            for (Dependency dependency : depencencyResult.getResolvedDependencies()) {
+                if (!dependency.getArtifact().isSnapshot()) {
+                    // Find the artifact in the local repo, and if it came from the 'stageRepo', populate that info
+                    // as the 'repository' on the artifact.
+                    LocalArtifactResult localResult = localRepositoryManager.find(reresolveSession,
+                            new LocalArtifactRequest(dependency.getArtifact(), stageRepo, null));
+
+                    // If the result has a file... and the getRepository() matched the stage repo id...
+                    if (localResult.getFile() != null && localResult.getRepository() != null) {
+                        getLog().info("Dependency: " + dependency + " from remote repository: " + localResult.getRepository() + " will be purged and re-resolved.");
+                        File deleteTarget = new File(localRepositoryManager.getRepository().getBasedir(), localRepositoryManager.getPathForLocalArtifact(dependency.getArtifact()));
+
+                        if (deleteTarget.isDirectory()) {
+                            try {
+                                FileUtils.deleteDirectory(deleteTarget);
+                            } catch (IOException ioe) {
+                                getLog().warn("Failed to purge stage artifact from local repository: " + deleteTarget, ioe);
+                            }
+                        } else if (!deleteTarget.delete()) {
+                            getLog().warn("Failed to purge stage artifact from local repository: " + deleteTarget);
+                        }
+                        itemsPurged = true;
+                    }
+                }
+            }
+        } catch (DependencyResolutionException dre) {
+            throw new MojoExecutionException("Initial dependency resolution to resolve dependencies which may have been provided by the 'stage' repository failed.", dre);
+        }
+
+
+        if (itemsPurged) {
+            try {
+                dependenciesResolver.resolve(new DefaultDependencyResolutionRequest(project, reresolveSession));
+            } catch (DependencyResolutionException e) {
+                throw new MojoExecutionException("Post-purge dependency resolution failed!", e);
+            }
+        }
+    }
+}