maven-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jvan...@apache.org
Subject maven git commit: Add a ProjectArtifactsCache similar to PluginArtifactsCache
Date Fri, 20 May 2016 00:56:43 GMT
Repository: maven
Updated Branches:
  refs/heads/master 4b35102f0 -> 7277a8464


Add a ProjectArtifactsCache similar to PluginArtifactsCache

Signed-off-by: Jason van Zyl <jason@vanzyl.ca>

closes #82


Project: http://git-wip-us.apache.org/repos/asf/maven/repo
Commit: http://git-wip-us.apache.org/repos/asf/maven/commit/7277a846
Tree: http://git-wip-us.apache.org/repos/asf/maven/tree/7277a846
Diff: http://git-wip-us.apache.org/repos/asf/maven/diff/7277a846

Branch: refs/heads/master
Commit: 7277a8464ba453aeacb82b22ffd966c9fb17c620
Parents: 4b35102
Author: Anton Tanasenko <atg.sleepless@gmail.com>
Authored: Wed May 18 18:40:28 2016 +0300
Committer: Jason van Zyl <jason@vanzyl.ca>
Committed: Thu May 19 20:40:10 2016 -0400

----------------------------------------------------------------------
 .../internal/LifecycleDependencyResolver.java   |  34 ++-
 .../plugin/DefaultProjectArtifactsCache.java    | 256 +++++++++++++++++++
 .../maven/plugin/ProjectArtifactsCache.java     |  90 +++++++
 3 files changed, 377 insertions(+), 3 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/maven/blob/7277a846/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java
----------------------------------------------------------------------
diff --git a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java
index 0947ed3..d83a8f4 100644
--- a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java
+++ b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleDependencyResolver.java
@@ -37,6 +37,7 @@ import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.eventspy.internal.EventSpyDispatcher;
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.lifecycle.LifecycleExecutionException;
+import org.apache.maven.plugin.ProjectArtifactsCache;
 import org.apache.maven.project.DefaultDependencyResolutionRequest;
 import org.apache.maven.project.DependencyResolutionException;
 import org.apache.maven.project.DependencyResolutionResult;
@@ -75,6 +76,9 @@ public class LifecycleDependencyResolver
 
     @Inject
     private EventSpyDispatcher eventSpyDispatcher;
+    
+    @Inject
+    private ProjectArtifactsCache projectArtifactsCache;
 
     public LifecycleDependencyResolver()
     {
@@ -123,9 +127,33 @@ public class LifecycleDependencyResolver
                     throw new LifecycleExecutionException( e );
                 }
             }
-
-            Set<Artifact> artifacts =
-                getDependencies( project, scopesToCollect, scopesToResolve, session, aggregating,
projectArtifacts );
+            
+            Set<Artifact> artifacts;
+            ProjectArtifactsCache.Key cacheKey = projectArtifactsCache.createKey( project,
 scopesToCollect, 
+                scopesToResolve, aggregating, session.getRepositorySession() );
+            ProjectArtifactsCache.CacheRecord recordArtifacts;
+            recordArtifacts = projectArtifactsCache.get( cacheKey );
+            
+            if ( recordArtifacts != null )
+            {
+                artifacts = recordArtifacts.artifacts;
+            }
+            else
+            {
+                try
+                {
+                    artifacts = getDependencies( project, scopesToCollect, scopesToResolve,
session, aggregating, 
+                        projectArtifacts );
+                    recordArtifacts = projectArtifactsCache.put( cacheKey, artifacts );
+                }
+                catch ( LifecycleExecutionException e )
+                {
+                  projectArtifactsCache.put( cacheKey, e );
+                  projectArtifactsCache.register( project, cacheKey, recordArtifacts );
+                    throw e;
+                }
+            }
+            projectArtifactsCache.register( project, cacheKey, recordArtifacts );
 
             project.setResolvedArtifacts( artifacts );
 

http://git-wip-us.apache.org/repos/asf/maven/blob/7277a846/maven-core/src/main/java/org/apache/maven/plugin/DefaultProjectArtifactsCache.java
----------------------------------------------------------------------
diff --git a/maven-core/src/main/java/org/apache/maven/plugin/DefaultProjectArtifactsCache.java
b/maven-core/src/main/java/org/apache/maven/plugin/DefaultProjectArtifactsCache.java
new file mode 100644
index 0000000..1eaa627
--- /dev/null
+++ b/maven-core/src/main/java/org/apache/maven/plugin/DefaultProjectArtifactsCache.java
@@ -0,0 +1,256 @@
+package org.apache.maven.plugin;
+
+/*
+ * 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.
+ */
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.commons.lang3.Validate;
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.lifecycle.LifecycleExecutionException;
+import org.apache.maven.model.Plugin;
+import org.apache.maven.project.MavenProject;
+import org.codehaus.plexus.component.annotations.Component;
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.repository.LocalRepository;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.repository.WorkspaceRepository;
+
+/**
+ * @author Igor Fedorenko
+ * @author Benjamin Bentmann
+ * @author Anton Tanasenko
+ */
+@Component( role = ProjectArtifactsCache.class )
+public class DefaultProjectArtifactsCache
+    implements ProjectArtifactsCache
+{
+
+    protected static class CacheKey
+        implements Key
+    {
+
+        private final String groupId;
+        
+        private final String artifactId;
+        
+        private final String version;
+        
+        private final Set<String> dependencyArtifacts;
+
+        private final WorkspaceRepository workspace;
+
+        private final LocalRepository localRepo;
+
+        private final List<RemoteRepository> repositories;
+        
+        private final Set<String> collect;
+        
+        private final Set<String> resolve;
+        
+        private boolean aggregating;
+
+        private final int hashCode;
+
+        public CacheKey( MavenProject project, List<RemoteRepository> repositories,
+            Collection<String> scopesToCollect, Collection<String> scopesToResolve,
boolean aggregating,
+            RepositorySystemSession session )
+        {
+            
+            groupId = project.getGroupId();
+            artifactId = project.getArtifactId();
+            version = project.getVersion();
+            
+            Set<String> deps = new HashSet<>();
+            if ( project.getDependencyArtifacts() != null )
+            {
+              for ( Artifact dep: project.getDependencyArtifacts() )
+              {
+                deps.add( dep.toString() );
+              }
+            }
+            dependencyArtifacts = Collections.unmodifiableSet( deps );
+            
+            workspace = CacheUtils.getWorkspace( session );
+            this.localRepo = session.getLocalRepository();
+            this.repositories = new ArrayList<>( repositories.size() );
+            for ( RemoteRepository repository : repositories )
+            {
+                if ( repository.isRepositoryManager() )
+                {
+                    this.repositories.addAll( repository.getMirroredRepositories() );
+                }
+                else
+                {
+                    this.repositories.add( repository );
+                }
+            }
+            collect = scopesToCollect == null
+                ? Collections.<String>emptySet() 
+                : Collections.unmodifiableSet( new HashSet<>( scopesToCollect ) );
+            resolve = scopesToResolve == null 
+                ? Collections.<String>emptySet() 
+                : Collections.unmodifiableSet( new HashSet<>( scopesToResolve ) );
+            this.aggregating = aggregating;
+
+            int hash = 17;
+            hash = hash * 31 + hash( groupId );
+            hash = hash * 31 + hash( artifactId );
+            hash = hash * 31 + hash( version );
+            hash = hash * 31 + hash( dependencyArtifacts );
+            hash = hash * 31 + hash( workspace );
+            hash = hash * 31 + hash( localRepo );
+            hash = hash * 31 + CacheUtils.repositoriesHashCode( repositories );
+            hash = hash * 31 + hash( collect );
+            hash = hash * 31 + hash( resolve );
+            hash = hash * 31 + hash( aggregating );
+            this.hashCode = hash;
+        }
+
+        @Override
+        public String toString()
+        {
+            return groupId + ":" + artifactId + ":" + version;
+        }
+
+        @Override
+        public int hashCode()
+        {
+            return hashCode;
+        }
+
+        private static int hash( Object obj )
+        {
+            return obj != null ? obj.hashCode() : 0;
+        }
+
+        @Override
+        public boolean equals( Object o )
+        {
+            if ( o == this )
+            {
+                return true;
+            }
+
+            if ( !( o instanceof CacheKey ) )
+            {
+                return false;
+            }
+
+            CacheKey that = (CacheKey) o;
+
+            return eq( groupId, that.groupId ) && eq( artifactId, that.artifactId
) && eq( version, that.version ) 
+                && eq( dependencyArtifacts, that.dependencyArtifacts )
+                && eq( workspace, that.workspace ) && eq( localRepo, that.localRepo
) 
+                && CacheUtils.repositoriesEquals( repositories, that.repositories
) && eq( collect, that.collect ) 
+                && eq( resolve, that.resolve ) && aggregating == that.aggregating;
+        }
+
+        private static <T> boolean eq( T s1, T s2 )
+        {
+            return s1 != null ? s1.equals( s2 ) : s2 == null;
+        }
+
+    }
+
+    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();
+
+    public Key createKey( MavenProject project, Collection<String> scopesToCollect,
+        Collection<String> scopesToResolve, boolean aggregating, RepositorySystemSession
session )
+    {
+        return new CacheKey( project, project.getRemoteProjectRepositories(), scopesToCollect,
scopesToResolve, 
+            aggregating, session );
+    }
+
+    public CacheRecord get( Key key )
+        throws LifecycleExecutionException
+    {
+        CacheRecord cacheRecord = cache.get( key );
+
+        if ( cacheRecord != null && cacheRecord.exception != null )
+        {
+            throw cacheRecord.exception;
+        }
+
+        return cacheRecord;
+    }
+
+    public CacheRecord put( Key key, Set<Artifact> projectArtifacts )
+    {
+        Validate.notNull( projectArtifacts, "projectArtifacts cannot be null" );
+
+        assertUniqueKey( key );
+
+        CacheRecord record =
+            new CacheRecord( Collections.unmodifiableSet( new HashSet<>( projectArtifacts
) ) );
+
+        cache.put( key, record );
+
+        return record;
+    }
+
+    protected void assertUniqueKey( Key key )
+    {
+        if ( cache.containsKey( key ) )
+        {
+            throw new IllegalStateException( "Duplicate artifact resolution result for project
" + key );
+        }
+    }
+
+    public CacheRecord put( Key key, LifecycleExecutionException exception )
+    {
+        Validate.notNull( exception, "exception cannot be null" );
+
+        assertUniqueKey( key );
+
+        CacheRecord record = new CacheRecord( exception );
+
+        cache.put( key, record );
+
+        return record;
+    }
+
+    public void flush()
+    {
+        cache.clear();
+    }
+
+    protected static int pluginHashCode( Plugin plugin )
+    {
+        return CacheUtils.pluginHashCode( plugin );
+    }
+
+    protected static boolean pluginEquals( Plugin a, Plugin b )
+    {
+        return CacheUtils.pluginEquals( a, b );
+    }
+
+    public void register( MavenProject project, Key cacheKey, CacheRecord record )
+    {
+        // default cache does not track record usage
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/maven/blob/7277a846/maven-core/src/main/java/org/apache/maven/plugin/ProjectArtifactsCache.java
----------------------------------------------------------------------
diff --git a/maven-core/src/main/java/org/apache/maven/plugin/ProjectArtifactsCache.java b/maven-core/src/main/java/org/apache/maven/plugin/ProjectArtifactsCache.java
new file mode 100644
index 0000000..42a95e5
--- /dev/null
+++ b/maven-core/src/main/java/org/apache/maven/plugin/ProjectArtifactsCache.java
@@ -0,0 +1,90 @@
+package org.apache.maven.plugin;
+
+/*
+ * 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.
+ */
+
+import java.util.Collection;
+import java.util.Set;
+
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.lifecycle.LifecycleExecutionException;
+import org.apache.maven.project.MavenProject;
+import org.eclipse.aether.RepositorySystemSession;
+/**
+ * Caches project artifacts. <strong>Warning:</strong> This is an internal utility
interface that is only public for
+ * technical reasons, it is not part of the public API. In particular, this interface can
be changed or deleted without
+ * prior notice.
+ *
+ * @author Igor Fedorenko
+ * @author Benjamin Bentmann
+ * @author Anton Tanasenko
+ */
+public interface ProjectArtifactsCache
+{
+
+    /**
+     * A cache key.
+     */
+    interface Key
+    {
+        // marker interface for cache keys
+    }
+
+    static class CacheRecord
+    {
+
+        public final Set<Artifact> artifacts;
+
+        public final LifecycleExecutionException exception;
+
+        public CacheRecord( Set<Artifact> artifacts )
+        {
+            this.artifacts = artifacts;
+            this.exception = null;
+        }
+
+        public CacheRecord( LifecycleExecutionException exception )
+        {
+            this.artifacts = null;
+            this.exception = exception;
+        }
+    }
+
+    Key createKey( MavenProject project, Collection<String> scopesToCollect, Collection<String>
scopesToResolve, 
+        boolean aggregating, RepositorySystemSession session );
+
+    CacheRecord get( Key key ) throws LifecycleExecutionException;
+
+    CacheRecord put( Key key, Set<Artifact> pluginArtifacts );
+
+    CacheRecord put( Key key, LifecycleExecutionException e );
+
+    void flush();
+
+    /**
+     * Registers the specified cache record for usage with the given project. Integrators
can use the information
+     * collected from this method in combination with a custom cache implementation to dispose
unused records from the
+     * cache.
+     *
+     * @param project The project that employs the plugin realm, must not be {@code null}.
+     * @param record The cache record being used for the project, must not be {@code null}.
+     */
+    void register( MavenProject project, Key cacheKey, CacheRecord record );
+
+}


Mime
View raw message