001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.eclipse.aether.supplier; 020 021import java.util.Arrays; 022import java.util.Locale; 023import java.util.function.Supplier; 024 025import org.apache.maven.utils.Os; 026import org.eclipse.aether.RepositorySystem; 027import org.eclipse.aether.RepositorySystemSession.CloseableSession; 028import org.eclipse.aether.RepositorySystemSession.SessionBuilder; 029import org.eclipse.aether.artifact.ArtifactTypeRegistry; 030import org.eclipse.aether.artifact.DefaultArtifactType; 031import org.eclipse.aether.collection.DependencyGraphTransformer; 032import org.eclipse.aether.collection.DependencyManager; 033import org.eclipse.aether.collection.DependencySelector; 034import org.eclipse.aether.collection.DependencyTraverser; 035import org.eclipse.aether.internal.impl.scope.ManagedDependencyContextRefiner; 036import org.eclipse.aether.internal.impl.scope.ManagedScopeDeriver; 037import org.eclipse.aether.internal.impl.scope.ManagedScopeSelector; 038import org.eclipse.aether.internal.impl.scope.OptionalDependencySelector; 039import org.eclipse.aether.internal.impl.scope.ScopeDependencySelector; 040import org.eclipse.aether.internal.impl.scope.ScopeManagerImpl; 041import org.eclipse.aether.resolution.ArtifactDescriptorPolicy; 042import org.eclipse.aether.util.artifact.DefaultArtifactTypeRegistry; 043import org.eclipse.aether.util.graph.manager.ClassicDependencyManager; 044import org.eclipse.aether.util.graph.selector.AndDependencySelector; 045import org.eclipse.aether.util.graph.selector.ExclusionDependencySelector; 046import org.eclipse.aether.util.graph.transformer.ChainedDependencyGraphTransformer; 047import org.eclipse.aether.util.graph.transformer.ConfigurableVersionSelector; 048import org.eclipse.aether.util.graph.transformer.ConflictResolver; 049import org.eclipse.aether.util.graph.transformer.SimpleOptionalitySelector; 050import org.eclipse.aether.util.graph.traverser.FatArtifactTraverser; 051import org.eclipse.aether.util.repository.SimpleArtifactDescriptorPolicy; 052 053import static java.util.Objects.requireNonNull; 054 055/** 056 * A simple {@link Supplier} of {@link SessionBuilder} instances, that on each call supplies newly 057 * constructed instance. To create session out of builder, use {@link SessionBuilder#build()}. For proper closing 058 * of sessions, use {@link CloseableSession#close()} method on built instance(s). 059 * <p> 060 * Extend this class and override methods to customize, if needed. 061 * <p> 062 * Resolver created as this is NOT using {@link org.eclipse.aether.scope.ScopeManager}! 063 * 064 * @since 2.0.0 065 */ 066public class SessionBuilderSupplier implements Supplier<SessionBuilder> { 067 protected final RepositorySystem repositorySystem; 068 protected final ScopeManagerImpl scopeManager; 069 070 public SessionBuilderSupplier(RepositorySystem repositorySystem) { 071 this.repositorySystem = requireNonNull(repositorySystem); 072 this.scopeManager = new ScopeManagerImpl(Maven3ScopeManagerConfiguration.INSTANCE); 073 } 074 075 protected void configureSessionBuilder(SessionBuilder session) { 076 session.setSystemProperties(System.getProperties()); 077 boolean caseSensitive = !Os.IS_WINDOWS; 078 System.getenv().forEach((key, value) -> { 079 key = "env." + (caseSensitive ? key : key.toUpperCase(Locale.ENGLISH)); 080 session.setSystemProperty(key, value); 081 }); 082 session.setScopeManager(scopeManager); 083 session.setDependencyTraverser(getDependencyTraverser()); 084 session.setDependencyManager(getDependencyManager()); 085 session.setDependencySelector(getDependencySelector()); 086 session.setDependencyGraphTransformer(getDependencyGraphTransformer()); 087 session.setArtifactTypeRegistry(getArtifactTypeRegistry()); 088 session.setArtifactDescriptorPolicy(getArtifactDescriptorPolicy()); 089 } 090 091 protected DependencyTraverser getDependencyTraverser() { 092 return new FatArtifactTraverser(); 093 } 094 095 protected DependencyManager getDependencyManager() { 096 return new ClassicDependencyManager(false, scopeManager); 097 } 098 099 protected DependencySelector getDependencySelector() { 100 return new AndDependencySelector( 101 ScopeDependencySelector.legacy( 102 null, 103 Arrays.asList( 104 Maven3ScopeManagerConfiguration.DS_TEST, Maven3ScopeManagerConfiguration.DS_PROVIDED)), 105 OptionalDependencySelector.fromDirect(), 106 new ExclusionDependencySelector()); 107 } 108 109 protected DependencyGraphTransformer getDependencyGraphTransformer() { 110 return new ChainedDependencyGraphTransformer( 111 new ConflictResolver( 112 new ConfigurableVersionSelector(), 113 new ManagedScopeSelector(this.scopeManager), 114 new SimpleOptionalitySelector(), 115 new ManagedScopeDeriver(this.scopeManager)), 116 new ManagedDependencyContextRefiner(this.scopeManager)); 117 } 118 119 protected ArtifactTypeRegistry getArtifactTypeRegistry() { 120 DefaultArtifactTypeRegistry stereotypes = new DefaultArtifactTypeRegistry(); 121 stereotypes.add(new DefaultArtifactType("pom")); 122 stereotypes.add(new DefaultArtifactType("maven-plugin", "jar", "", "java")); 123 stereotypes.add(new DefaultArtifactType("jar", "jar", "", "java")); 124 stereotypes.add(new DefaultArtifactType("ejb", "jar", "", "java")); 125 stereotypes.add(new DefaultArtifactType("ejb-client", "jar", "client", "java")); 126 stereotypes.add(new DefaultArtifactType("test-jar", "jar", "tests", "java")); 127 stereotypes.add(new DefaultArtifactType("javadoc", "jar", "javadoc", "java")); 128 stereotypes.add(new DefaultArtifactType("java-source", "jar", "sources", "java", false, false)); 129 stereotypes.add(new DefaultArtifactType("war", "war", "", "java", false, true)); 130 stereotypes.add(new DefaultArtifactType("ear", "ear", "", "java", false, true)); 131 stereotypes.add(new DefaultArtifactType("rar", "rar", "", "java", false, true)); 132 stereotypes.add(new DefaultArtifactType("par", "par", "", "java", false, true)); 133 return stereotypes; 134 } 135 136 protected ArtifactDescriptorPolicy getArtifactDescriptorPolicy() { 137 return new SimpleArtifactDescriptorPolicy(true, true); 138 } 139 140 /** 141 * Creates a new Maven-like repository system session by initializing the session with values typical for 142 * Maven-based resolution. In more detail, this method configures settings relevant for the processing of dependency 143 * graphs, most other settings remain at their generic default value. Use the various setters to further configure 144 * the session with authentication, mirror, proxy and other information required for your environment. At least, 145 * local repository manager needs to be configured to make session be able to create session instance. 146 * 147 * @return SessionBuilder configured with minimally required things for "Maven-based resolution". At least LRM must 148 * be set on builder to make it able to create session instances. 149 */ 150 @Override 151 public SessionBuilder get() { 152 SessionBuilder builder = repositorySystem.createSessionBuilder(); 153 configureSessionBuilder(builder); 154 return builder; 155 } 156}