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.OptionalDependencySelector; 036import org.eclipse.aether.internal.impl.scope.ScopeDependencySelector; 037import org.eclipse.aether.resolution.ArtifactDescriptorPolicy; 038import org.eclipse.aether.util.artifact.DefaultArtifactTypeRegistry; 039import org.eclipse.aether.util.artifact.JavaScopes; 040import org.eclipse.aether.util.graph.manager.ClassicDependencyManager; 041import org.eclipse.aether.util.graph.selector.AndDependencySelector; 042import org.eclipse.aether.util.graph.selector.ExclusionDependencySelector; 043import org.eclipse.aether.util.graph.transformer.ChainedDependencyGraphTransformer; 044import org.eclipse.aether.util.graph.transformer.ConfigurableVersionSelector; 045import org.eclipse.aether.util.graph.transformer.ConflictResolver; 046import org.eclipse.aether.util.graph.transformer.JavaDependencyContextRefiner; 047import org.eclipse.aether.util.graph.transformer.JavaScopeDeriver; 048import org.eclipse.aether.util.graph.transformer.JavaScopeSelector; 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 069 public SessionBuilderSupplier(RepositorySystem repositorySystem) { 070 this.repositorySystem = requireNonNull(repositorySystem); 071 } 072 073 protected void configureSessionBuilder(SessionBuilder session) { 074 session.setSystemProperties(System.getProperties()); 075 boolean caseSensitive = !Os.IS_WINDOWS; 076 System.getenv().forEach((key, value) -> { 077 key = "env." + (caseSensitive ? key : key.toUpperCase(Locale.ENGLISH)); 078 session.setSystemProperty(key, value); 079 }); 080 session.setDependencyTraverser(getDependencyTraverser()); 081 session.setDependencyManager(getDependencyManager()); 082 session.setDependencySelector(getDependencySelector()); 083 session.setDependencyGraphTransformer(getDependencyGraphTransformer()); 084 session.setArtifactTypeRegistry(getArtifactTypeRegistry()); 085 session.setArtifactDescriptorPolicy(getArtifactDescriptorPolicy()); 086 } 087 088 protected DependencyTraverser getDependencyTraverser() { 089 return new FatArtifactTraverser(); 090 } 091 092 protected DependencyManager getDependencyManager() { 093 return new ClassicDependencyManager(false, null); 094 } 095 096 protected DependencySelector getDependencySelector() { 097 return new AndDependencySelector( 098 ScopeDependencySelector.legacy(null, Arrays.asList(JavaScopes.TEST, JavaScopes.PROVIDED)), 099 OptionalDependencySelector.fromDirect(), 100 new ExclusionDependencySelector()); 101 } 102 103 protected DependencyGraphTransformer getDependencyGraphTransformer() { 104 return new ChainedDependencyGraphTransformer( 105 new ConflictResolver( 106 new ConfigurableVersionSelector(), new JavaScopeSelector(), 107 new SimpleOptionalitySelector(), new JavaScopeDeriver()), 108 new JavaDependencyContextRefiner()); 109 } 110 111 protected ArtifactTypeRegistry getArtifactTypeRegistry() { 112 DefaultArtifactTypeRegistry stereotypes = new DefaultArtifactTypeRegistry(); 113 stereotypes.add(new DefaultArtifactType("pom")); 114 stereotypes.add(new DefaultArtifactType("maven-plugin", "jar", "", "java")); 115 stereotypes.add(new DefaultArtifactType("jar", "jar", "", "java")); 116 stereotypes.add(new DefaultArtifactType("ejb", "jar", "", "java")); 117 stereotypes.add(new DefaultArtifactType("ejb-client", "jar", "client", "java")); 118 stereotypes.add(new DefaultArtifactType("test-jar", "jar", "tests", "java")); 119 stereotypes.add(new DefaultArtifactType("javadoc", "jar", "javadoc", "java")); 120 stereotypes.add(new DefaultArtifactType("java-source", "jar", "sources", "java", false, false)); 121 stereotypes.add(new DefaultArtifactType("war", "war", "", "java", false, true)); 122 stereotypes.add(new DefaultArtifactType("ear", "ear", "", "java", false, true)); 123 stereotypes.add(new DefaultArtifactType("rar", "rar", "", "java", false, true)); 124 stereotypes.add(new DefaultArtifactType("par", "par", "", "java", false, true)); 125 return stereotypes; 126 } 127 128 protected ArtifactDescriptorPolicy getArtifactDescriptorPolicy() { 129 return new SimpleArtifactDescriptorPolicy(true, true); 130 } 131 132 /** 133 * Creates a new Maven-like repository system session by initializing the session with values typical for 134 * Maven-based resolution. In more detail, this method configures settings relevant for the processing of dependency 135 * graphs, most other settings remain at their generic default value. Use the various setters to further configure 136 * the session with authentication, mirror, proxy and other information required for your environment. At least, 137 * local repository manager needs to be configured to make session be able to create session instance. 138 * 139 * @return SessionBuilder configured with minimally required things for "Maven-based resolution". At least LRM must 140 * be set on builder to make it able to create session instances. 141 */ 142 @Override 143 public SessionBuilder get() { 144 SessionBuilder builder = repositorySystem.createSessionBuilder(); 145 configureSessionBuilder(builder); 146 return builder; 147 } 148}