You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by cs...@apache.org on 2024/01/24 08:40:06 UTC
(maven-resolver) branch master updated: [MRESOLVER-467][MRESOLVER-468] Pull out shared HTTP stuff (#410)
This is an automated email from the ASF dual-hosted git repository.
cstamas pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-resolver.git
The following commit(s) were added to refs/heads/master by this push:
new ef406022 [MRESOLVER-467][MRESOLVER-468] Pull out shared HTTP stuff (#410)
ef406022 is described below
commit ef4060229133884a1fbff779ca5364685d83cf72
Author: Tamas Cservenak <ta...@cservenak.net>
AuthorDate: Wed Jan 24 09:40:01 2024 +0100
[MRESOLVER-467][MRESOLVER-468] Pull out shared HTTP stuff (#410)
Currently we have 3 HTTP transports and each have quite some overlap. Pull these out. Included checksums in all three, but Jetty and JDK transports also redefine same constants as well.
Another issue touched here is "stabilizing" (and exposing intermediate components) on RepositorySystem supplier.
---
https://issues.apache.org/jira/browse/MRESOLVER-467
https://issues.apache.org/jira/browse/MRESOLVER-468
---
.../supplier/SupplierRepositorySystemFactory.java | 8 +-
.../transport/http/DefaultChecksumExtractor.java | 56 ++
.../impl/transport/http/Nx2ChecksumExtractor.java | 52 +
.../impl/transport/http/XChecksumExtractor.java | 69 ++
.../transport/http/ChecksumExtractor.java | 41 +
.../transport/http/ChecksumExtractorStrategy.java | 42 +
.../connector/transport/http/HttpConstants.java | 57 ++
.../aether/supplier/RepositorySystemSupplier.java | 1023 +++++++++++++-------
.../supplier/RepositorySystemSupplierTest.java | 31 +-
.../test/util/http/HttpTransporterTest.java | 14 +-
maven-resolver-transport-apache/pom.xml | 5 -
.../aether/transport/apache/ApacheTransporter.java | 72 +-
.../transport/apache/ApacheTransporterFactory.java | 11 +-
.../transport/apache/ApacheTransporterTest.java | 2 +-
maven-resolver-transport-classpath/pom.xml | 6 +-
maven-resolver-transport-file/pom.xml | 14 +-
.../aether/transport/jdk/JdkTransporter.java | 91 +-
.../transport/jdk/JdkTransporterFactory.java | 11 +-
.../aether/transport/jdk/JdkTransporterTest.java | 4 +-
.../aether/transport/jetty/JettyTransporter.java | 83 +-
.../transport/jetty/JettyTransporterFactory.java | 11 +-
.../transport/jetty/JettyTransporterTest.java | 2 +-
maven-resolver-transport-wagon/pom.xml | 6 +-
23 files changed, 1113 insertions(+), 598 deletions(-)
diff --git a/maven-resolver-demos/maven-resolver-demo-snippets/src/main/java/org/apache/maven/resolver/examples/supplier/SupplierRepositorySystemFactory.java b/maven-resolver-demos/maven-resolver-demo-snippets/src/main/java/org/apache/maven/resolver/examples/supplier/SupplierRepositorySystemFactory.java
index 699e8409..3980a9fb 100644
--- a/maven-resolver-demos/maven-resolver-demo-snippets/src/main/java/org/apache/maven/resolver/examples/supplier/SupplierRepositorySystemFactory.java
+++ b/maven-resolver-demos/maven-resolver-demo-snippets/src/main/java/org/apache/maven/resolver/examples/supplier/SupplierRepositorySystemFactory.java
@@ -33,10 +33,10 @@ public class SupplierRepositorySystemFactory {
public static RepositorySystem newRepositorySystem() {
return new RepositorySystemSupplier() {
@Override
- protected Map<String, TransporterFactory> getTransporterFactories() {
- Map<String, TransporterFactory> result = super.getTransporterFactories();
- result.put(JdkTransporterFactory.NAME, new JdkTransporterFactory());
- result.put(JettyTransporterFactory.NAME, new JettyTransporterFactory());
+ protected Map<String, TransporterFactory> createTransporterFactories() {
+ Map<String, TransporterFactory> result = super.createTransporterFactories();
+ result.put(JdkTransporterFactory.NAME, new JdkTransporterFactory(getChecksumExtractor()));
+ result.put(JettyTransporterFactory.NAME, new JettyTransporterFactory(getChecksumExtractor()));
return result;
}
}.get();
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/DefaultChecksumExtractor.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/DefaultChecksumExtractor.java
new file mode 100644
index 00000000..0760f132
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/DefaultChecksumExtractor.java
@@ -0,0 +1,56 @@
+/*
+ * 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.
+ */
+package org.eclipse.aether.internal.impl.transport.http;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Singleton;
+
+import java.util.Map;
+import java.util.function.Function;
+
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Checksum extractor.
+ */
+@Singleton
+@Named
+public final class DefaultChecksumExtractor implements ChecksumExtractor {
+ private final Map<String, ChecksumExtractorStrategy> strategies;
+
+ @Inject
+ public DefaultChecksumExtractor(Map<String, ChecksumExtractorStrategy> strategies) {
+ this.strategies = requireNonNull(strategies, "strategies");
+ }
+
+ @Override
+ public Map<String, String> extractChecksums(Function<String, String> headerGetter) {
+ for (ChecksumExtractorStrategy strategy : strategies.values()) {
+ Map<String, String> extracted = strategy.extractChecksums(headerGetter);
+ if (extracted != null && !extracted.isEmpty()) {
+ return extracted;
+ }
+ }
+ return null;
+ }
+}
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/Nx2ChecksumExtractor.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/Nx2ChecksumExtractor.java
new file mode 100644
index 00000000..caa557bc
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/Nx2ChecksumExtractor.java
@@ -0,0 +1,52 @@
+/*
+ * 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.
+ */
+package org.eclipse.aether.internal.impl.transport.http;
+
+import javax.inject.Named;
+import javax.inject.Singleton;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.function.Function;
+
+import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
+import org.eclipse.aether.spi.connector.transport.http.HttpConstants;
+
+/**
+ * Sonatype Nexus2 checksum extractor.
+ */
+@Singleton
+@Named(Nx2ChecksumExtractor.NAME)
+public final class Nx2ChecksumExtractor extends ChecksumExtractorStrategy {
+ public static final String NAME = "nx2";
+
+ @Override
+ public Map<String, String> extractChecksums(Function<String, String> headerGetter) {
+ // Nexus-style, ETag: "{SHA1{d40d68ba1f88d8e9b0040f175a6ff41928abd5e7}}"
+ String etag = headerGetter.apply(HttpConstants.ETAG);
+ if (etag != null) {
+ int start = etag.indexOf("SHA1{"), end = etag.indexOf("}", start + 5);
+ if (start >= 0 && end > start) {
+ return Collections.singletonMap(Sha1ChecksumAlgorithmFactory.NAME, etag.substring(start + 5, end));
+ }
+ }
+ return null;
+ }
+}
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/XChecksumExtractor.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/XChecksumExtractor.java
new file mode 100644
index 00000000..08e6cecf
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/transport/http/XChecksumExtractor.java
@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+package org.eclipse.aether.internal.impl.transport.http;
+
+import javax.inject.Named;
+import javax.inject.Singleton;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
+import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
+
+/**
+ * Generic checksum extractor that goes for "X-" headers.
+ */
+@Singleton
+@Named(XChecksumExtractor.NAME)
+public final class XChecksumExtractor extends ChecksumExtractorStrategy {
+ public static final String NAME = "xChecksum";
+
+ @Override
+ public Map<String, String> extractChecksums(Function<String, String> headerGetter) {
+ String value;
+ HashMap<String, String> result = new HashMap<>();
+ // Central style: x-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
+ value = headerGetter.apply("x-checksum-sha1");
+ if (value != null) {
+ result.put(Sha1ChecksumAlgorithmFactory.NAME, value);
+ }
+ // Central style: x-checksum-md5: 9ad0d8e3482767c122e85f83567b8ce6
+ value = headerGetter.apply("x-checksum-md5");
+ if (value != null) {
+ result.put(Md5ChecksumAlgorithmFactory.NAME, value);
+ }
+ if (!result.isEmpty()) {
+ return result;
+ }
+ // Google style: x-goog-meta-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
+ value = headerGetter.apply("x-goog-meta-checksum-sha1");
+ if (value != null) {
+ result.put(Sha1ChecksumAlgorithmFactory.NAME, value);
+ }
+ // Central style: x-goog-meta-checksum-sha1: 9ad0d8e3482767c122e85f83567b8ce6
+ value = headerGetter.apply("x-goog-meta-checksum-md5");
+ if (value != null) {
+ result.put(Md5ChecksumAlgorithmFactory.NAME, value);
+ }
+ return result.isEmpty() ? null : result;
+ }
+}
diff --git a/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/ChecksumExtractor.java b/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/ChecksumExtractor.java
new file mode 100644
index 00000000..f0700422
--- /dev/null
+++ b/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/ChecksumExtractor.java
@@ -0,0 +1,41 @@
+/*
+ * 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.
+ */
+package org.eclipse.aether.spi.connector.transport.http;
+
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * Checksum extractor. Uses all known {@link ChecksumExtractorStrategy} components to extract included checksums,
+ * first extractor returning non-empty value wins.
+ *
+ * @since 2.0.0
+ */
+public interface ChecksumExtractor {
+ /**
+ * Extract checksums using given getter, if possible, or {@code null}.
+ * <p>
+ * The supplied {@code headerGetter} function should provide access to given transport response HTTP Headers in
+ * some common way, like for example returning first header value, or {@code null} if header not present.
+ *
+ * @param headerGetter A function that provides access to response HTTP Headers, never {@code null}.
+ * @return Map of extracted checksums, or {@code null} if none extracted.
+ */
+ Map<String, String> extractChecksums(Function<String, String> headerGetter);
+}
diff --git a/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/ChecksumExtractorStrategy.java b/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/ChecksumExtractorStrategy.java
new file mode 100644
index 00000000..15cbdf4e
--- /dev/null
+++ b/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/ChecksumExtractorStrategy.java
@@ -0,0 +1,42 @@
+/*
+ * 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.
+ */
+package org.eclipse.aether.spi.connector.transport.http;
+
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * Checksum extractor strategy, that aims for given type of included checksum.
+ *
+ * @since 2.0.0
+ */
+public abstract class ChecksumExtractorStrategy {
+ /**
+ * Extract checksums using given getter, if possible, or {@code null}.
+ * <p>
+ * The supplied {@code headerGetter} function should provide access to given transport response HTTP Headers in
+ * some common way, like for example returning first header value, or {@code null} if header not present.
+ *
+ * @param headerGetter A function that provides access to response HTTP Headers, never {@code null}.
+ * @return Map of extracted checksums, or {@code null} if none extracted.
+ */
+ public Map<String, String> extractChecksums(Function<String, String> headerGetter) {
+ return null;
+ }
+}
diff --git a/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/HttpConstants.java b/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/HttpConstants.java
new file mode 100644
index 00000000..1a61e4ff
--- /dev/null
+++ b/maven-resolver-spi/src/main/java/org/eclipse/aether/spi/connector/transport/http/HttpConstants.java
@@ -0,0 +1,57 @@
+/*
+ * 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.
+ */
+package org.eclipse.aether.spi.connector.transport.http;
+
+import java.util.regex.Pattern;
+
+/**
+ * Some shared HTTP constants.
+ *
+ * @since 2.0.0
+ */
+public final class HttpConstants {
+ private HttpConstants() {}
+
+ public static final int MULTIPLE_CHOICES = 300;
+
+ public static final int NOT_FOUND = 404;
+
+ public static final int PRECONDITION_FAILED = 412;
+
+ public static final String ACCEPT_ENCODING = "Accept-Encoding";
+
+ public static final String CACHE_CONTROL = "Cache-Control";
+
+ public static final String CONTENT_LENGTH = "Content-Length";
+
+ public static final String CONTENT_RANGE = "Content-Range";
+
+ public static final String ETAG = "ETag";
+
+ public static final String IF_UNMODIFIED_SINCE = "If-Unmodified-Since";
+
+ public static final String RANGE = "Range";
+
+ public static final String USER_AGENT = "User-Agent";
+
+ public static final String LAST_MODIFIED = "Last-Modified";
+
+ public static final Pattern CONTENT_RANGE_PATTERN =
+ Pattern.compile("\\s*bytes\\s+([0-9]+)\\s*-\\s*([0-9]+)\\s*/.*");
+}
diff --git a/maven-resolver-supplier/src/main/java/org/eclipse/aether/supplier/RepositorySystemSupplier.java b/maven-resolver-supplier/src/main/java/org/eclipse/aether/supplier/RepositorySystemSupplier.java
index 85d2b49c..7e180790 100644
--- a/maven-resolver-supplier/src/main/java/org/eclipse/aether/supplier/RepositorySystemSupplier.java
+++ b/maven-resolver-supplier/src/main/java/org/eclipse/aether/supplier/RepositorySystemSupplier.java
@@ -21,6 +21,7 @@ package org.eclipse.aether.supplier;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Supplier;
import org.apache.maven.model.building.DefaultModelBuilderFactory;
@@ -49,32 +50,7 @@ import org.eclipse.aether.impl.UpdateCheckManager;
import org.eclipse.aether.impl.UpdatePolicyAnalyzer;
import org.eclipse.aether.impl.VersionRangeResolver;
import org.eclipse.aether.impl.VersionResolver;
-import org.eclipse.aether.internal.impl.DefaultArtifactResolver;
-import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
-import org.eclipse.aether.internal.impl.DefaultDeployer;
-import org.eclipse.aether.internal.impl.DefaultFileProcessor;
-import org.eclipse.aether.internal.impl.DefaultInstaller;
-import org.eclipse.aether.internal.impl.DefaultLocalPathComposer;
-import org.eclipse.aether.internal.impl.DefaultLocalPathPrefixComposerFactory;
-import org.eclipse.aether.internal.impl.DefaultLocalRepositoryProvider;
-import org.eclipse.aether.internal.impl.DefaultMetadataResolver;
-import org.eclipse.aether.internal.impl.DefaultOfflineController;
-import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;
-import org.eclipse.aether.internal.impl.DefaultRepositoryConnectorProvider;
-import org.eclipse.aether.internal.impl.DefaultRepositoryEventDispatcher;
-import org.eclipse.aether.internal.impl.DefaultRepositoryLayoutProvider;
-import org.eclipse.aether.internal.impl.DefaultRepositorySystem;
-import org.eclipse.aether.internal.impl.DefaultRepositorySystemLifecycle;
-import org.eclipse.aether.internal.impl.DefaultTrackingFileManager;
-import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
-import org.eclipse.aether.internal.impl.DefaultUpdateCheckManager;
-import org.eclipse.aether.internal.impl.DefaultUpdatePolicyAnalyzer;
-import org.eclipse.aether.internal.impl.EnhancedLocalRepositoryManagerFactory;
-import org.eclipse.aether.internal.impl.LocalPathComposer;
-import org.eclipse.aether.internal.impl.LocalPathPrefixComposerFactory;
-import org.eclipse.aether.internal.impl.Maven2RepositoryLayoutFactory;
-import org.eclipse.aether.internal.impl.SimpleLocalRepositoryManagerFactory;
-import org.eclipse.aether.internal.impl.TrackingFileManager;
+import org.eclipse.aether.internal.impl.*;
import org.eclipse.aether.internal.impl.checksum.DefaultChecksumAlgorithmFactorySelector;
import org.eclipse.aether.internal.impl.checksum.Md5ChecksumAlgorithmFactory;
import org.eclipse.aether.internal.impl.checksum.Sha1ChecksumAlgorithmFactory;
@@ -96,6 +72,9 @@ import org.eclipse.aether.internal.impl.synccontext.named.NameMapper;
import org.eclipse.aether.internal.impl.synccontext.named.NameMappers;
import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactory;
import org.eclipse.aether.internal.impl.synccontext.named.NamedLockFactoryAdapterFactoryImpl;
+import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor;
+import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor;
+import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor;
import org.eclipse.aether.named.NamedLockFactory;
import org.eclipse.aether.named.providers.FileLockNamedLockFactory;
import org.eclipse.aether.named.providers.LocalReadWriteLockNamedLockFactory;
@@ -112,6 +91,8 @@ import org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory;
import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
import org.eclipse.aether.spi.connector.transport.TransporterFactory;
import org.eclipse.aether.spi.connector.transport.TransporterProvider;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractorStrategy;
import org.eclipse.aether.spi.io.FileProcessor;
import org.eclipse.aether.spi.localrepo.LocalRepositoryManagerFactory;
import org.eclipse.aether.spi.resolution.ArtifactResolverPostProcessor;
@@ -122,52 +103,177 @@ import org.eclipse.aether.util.version.GenericVersionScheme;
import org.eclipse.aether.version.VersionScheme;
/**
- * A simple {@link Supplier} of {@link org.eclipse.aether.RepositorySystem} instances, that on each call supplies newly
- * constructed instance. For proper shut down, use {@link RepositorySystem#shutdown()} method on supplied instance(s).
+ * A simple memorizing {@link Supplier} of {@link org.eclipse.aether.RepositorySystem} instance, that on first call
+ * supplies lazily constructed instance, and on each subsequent call same instance. Hence, this instance should be
+ * thrown away immediately once repository system was created and there is no need for more instances. If new
+ * repository system instance needed, new instance of this class must be created. For proper shut down of returned
+ * repository system instance(s) use {@link RepositorySystem#shutdown()} method on supplied instance(s).
* <p>
- * Extend this class and override methods to customize, if needed.
+ * Since Resolver 2.0 this class offers access to various components via public getters, and allows even partial object
+ * graph construction.
+ * <p>
+ * Extend this class {@code createXXX()} methods and override to customize, if needed. The contract of this class makes
+ * sure that these (potentially overridden) methods are invoked only once, and instance created by those methods are
+ * memorized and kept as long as supplier instance is kept open.
+ * <p>
+ * This class is not thread safe and must be used from one thread only, while the constructed {@link RepositorySystem}
+ * is thread safe.
+ * <p>
+ * Important: Given the instance of supplier memorizes the supplier {@link RepositorySystem} instance it supplies,
+ * their lifecycle is shared as well: once supplied repository system is shut-down, this instance becomes closed as
+ * well. Any subsequent {@code getXXX} method invocation attempt will fail with {@link IllegalStateException}.
*
* @since 1.9.15
*/
public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
- protected FileProcessor getFileProcessor() {
+ private final AtomicBoolean closed = new AtomicBoolean(false);
+
+ public RepositorySystemSupplier() {}
+
+ private void checkClosed() {
+ if (closed.get()) {
+ throw new IllegalStateException("Supplier is closed");
+ }
+ }
+
+ private FileProcessor fileProcessor;
+
+ public final FileProcessor getFileProcessor() {
+ checkClosed();
+ if (fileProcessor == null) {
+ fileProcessor = createFileProcessor();
+ }
+ return fileProcessor;
+ }
+
+ protected FileProcessor createFileProcessor() {
return new DefaultFileProcessor();
}
- protected TrackingFileManager getTrackingFileManager() {
+ private TrackingFileManager trackingFileManager;
+
+ public final TrackingFileManager getTrackingFileManager() {
+ checkClosed();
+ if (trackingFileManager == null) {
+ trackingFileManager = createTrackingFileManager();
+ }
+ return trackingFileManager;
+ }
+
+ protected TrackingFileManager createTrackingFileManager() {
return new DefaultTrackingFileManager();
}
- protected LocalPathComposer getLocalPathComposer() {
+ private LocalPathComposer localPathComposer;
+
+ public final LocalPathComposer getLocalPathComposer() {
+ checkClosed();
+ if (localPathComposer == null) {
+ localPathComposer = createLocalPathComposer();
+ }
+ return localPathComposer;
+ }
+
+ protected LocalPathComposer createLocalPathComposer() {
return new DefaultLocalPathComposer();
}
- protected LocalPathPrefixComposerFactory getLocalPathPrefixComposerFactory() {
+ private LocalPathPrefixComposerFactory localPathPrefixComposerFactory;
+
+ public final LocalPathPrefixComposerFactory getLocalPathPrefixComposerFactory() {
+ checkClosed();
+ if (localPathPrefixComposerFactory == null) {
+ localPathPrefixComposerFactory = createLocalPathPrefixComposerFactory();
+ }
+ return localPathPrefixComposerFactory;
+ }
+
+ protected LocalPathPrefixComposerFactory createLocalPathPrefixComposerFactory() {
return new DefaultLocalPathPrefixComposerFactory();
}
- protected RepositorySystemLifecycle getRepositorySystemLifecycle() {
+ private RepositorySystemLifecycle repositorySystemLifecycle;
+
+ public final RepositorySystemLifecycle getRepositorySystemLifecycle() {
+ checkClosed();
+ if (repositorySystemLifecycle == null) {
+ repositorySystemLifecycle = createRepositorySystemLifecycle();
+ repositorySystemLifecycle.addOnSystemEndedHandler(() -> closed.set(true));
+ }
+ return repositorySystemLifecycle;
+ }
+
+ protected RepositorySystemLifecycle createRepositorySystemLifecycle() {
return new DefaultRepositorySystemLifecycle();
}
- protected OfflineController getOfflineController() {
+ private OfflineController offlineController;
+
+ public final OfflineController getOfflineController() {
+ checkClosed();
+ if (offlineController == null) {
+ offlineController = createOfflineController();
+ }
+ return offlineController;
+ }
+
+ protected OfflineController createOfflineController() {
return new DefaultOfflineController();
}
- protected UpdatePolicyAnalyzer getUpdatePolicyAnalyzer() {
+ private UpdatePolicyAnalyzer updatePolicyAnalyzer;
+
+ public final UpdatePolicyAnalyzer getUpdatePolicyAnalyzer() {
+ checkClosed();
+ if (updatePolicyAnalyzer == null) {
+ updatePolicyAnalyzer = createUpdatePolicyAnalyzer();
+ }
+ return updatePolicyAnalyzer;
+ }
+
+ protected UpdatePolicyAnalyzer createUpdatePolicyAnalyzer() {
return new DefaultUpdatePolicyAnalyzer();
}
- protected ChecksumPolicyProvider getChecksumPolicyProvider() {
+ private ChecksumPolicyProvider checksumPolicyProvider;
+
+ public final ChecksumPolicyProvider getChecksumPolicyProvider() {
+ checkClosed();
+ if (checksumPolicyProvider == null) {
+ checksumPolicyProvider = createChecksumPolicyProvider();
+ }
+ return checksumPolicyProvider;
+ }
+
+ protected ChecksumPolicyProvider createChecksumPolicyProvider() {
return new DefaultChecksumPolicyProvider();
}
- protected UpdateCheckManager getUpdateCheckManager(
- TrackingFileManager trackingFileManager, UpdatePolicyAnalyzer updatePolicyAnalyzer) {
- return new DefaultUpdateCheckManager(trackingFileManager, updatePolicyAnalyzer);
+ private UpdateCheckManager updateCheckManager;
+
+ public final UpdateCheckManager getUpdateCheckManager() {
+ checkClosed();
+ if (updateCheckManager == null) {
+ updateCheckManager = createUpdateCheckManager();
+ }
+ return updateCheckManager;
}
- protected Map<String, NamedLockFactory> getNamedLockFactories() {
+ protected UpdateCheckManager createUpdateCheckManager() {
+ return new DefaultUpdateCheckManager(getTrackingFileManager(), getUpdatePolicyAnalyzer());
+ }
+
+ private Map<String, NamedLockFactory> namedLockFactories;
+
+ public final Map<String, NamedLockFactory> getNamedLockFactories() {
+ checkClosed();
+ if (namedLockFactories == null) {
+ namedLockFactories = createNamedLockFactories();
+ }
+ return namedLockFactories;
+ }
+
+ protected Map<String, NamedLockFactory> createNamedLockFactories() {
HashMap<String, NamedLockFactory> result = new HashMap<>();
result.put(NoopNamedLockFactory.NAME, new NoopNamedLockFactory());
result.put(LocalReadWriteLockNamedLockFactory.NAME, new LocalReadWriteLockNamedLockFactory());
@@ -176,7 +282,17 @@ public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
return result;
}
- protected Map<String, NameMapper> getNameMappers() {
+ private Map<String, NameMapper> nameMappers;
+
+ public final Map<String, NameMapper> getNameMappers() {
+ checkClosed();
+ if (nameMappers == null) {
+ nameMappers = createNameMappers();
+ }
+ return nameMappers;
+ }
+
+ protected Map<String, NameMapper> createNameMappers() {
HashMap<String, NameMapper> result = new HashMap<>();
result.put(NameMappers.STATIC_NAME, NameMappers.staticNameMapper());
result.put(NameMappers.GAV_NAME, NameMappers.gavNameMapper());
@@ -186,18 +302,46 @@ public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
return result;
}
- protected NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory(
- Map<String, NamedLockFactory> namedLockFactories,
- Map<String, NameMapper> nameMappers,
- RepositorySystemLifecycle repositorySystemLifecycle) {
- return new NamedLockFactoryAdapterFactoryImpl(namedLockFactories, nameMappers, repositorySystemLifecycle);
+ private NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory;
+
+ public final NamedLockFactoryAdapterFactory getNamedLockFactoryAdapterFactory() {
+ checkClosed();
+ if (namedLockFactoryAdapterFactory == null) {
+ namedLockFactoryAdapterFactory = createNamedLockFactoryAdapterFactory();
+ }
+ return namedLockFactoryAdapterFactory;
}
- protected SyncContextFactory getSyncContextFactory(NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory) {
- return new DefaultSyncContextFactory(namedLockFactoryAdapterFactory);
+ protected NamedLockFactoryAdapterFactory createNamedLockFactoryAdapterFactory() {
+ return new NamedLockFactoryAdapterFactoryImpl(
+ getNamedLockFactories(), getNameMappers(), getRepositorySystemLifecycle());
}
- protected Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
+ private SyncContextFactory syncContextFactory;
+
+ public final SyncContextFactory getSyncContextFactory() {
+ checkClosed();
+ if (syncContextFactory == null) {
+ syncContextFactory = createSyncContextFactory();
+ }
+ return syncContextFactory;
+ }
+
+ protected SyncContextFactory createSyncContextFactory() {
+ return new DefaultSyncContextFactory(getNamedLockFactoryAdapterFactory());
+ }
+
+ private Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories;
+
+ public final Map<String, ChecksumAlgorithmFactory> getChecksumAlgorithmFactories() {
+ checkClosed();
+ if (checksumAlgorithmFactories == null) {
+ checksumAlgorithmFactories = createChecksumAlgorithmFactories();
+ }
+ return checksumAlgorithmFactories;
+ }
+
+ protected Map<String, ChecksumAlgorithmFactory> createChecksumAlgorithmFactories() {
HashMap<String, ChecksumAlgorithmFactory> result = new HashMap<>();
result.put(Sha512ChecksumAlgorithmFactory.NAME, new Sha512ChecksumAlgorithmFactory());
result.put(Sha256ChecksumAlgorithmFactory.NAME, new Sha256ChecksumAlgorithmFactory());
@@ -206,165 +350,356 @@ public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
return result;
}
- protected ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector(
- Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories) {
- return new DefaultChecksumAlgorithmFactorySelector(checksumAlgorithmFactories);
+ private ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector;
+
+ public final ChecksumAlgorithmFactorySelector getChecksumAlgorithmFactorySelector() {
+ checkClosed();
+ if (checksumAlgorithmFactorySelector == null) {
+ checksumAlgorithmFactorySelector = createChecksumAlgorithmFactorySelector();
+ }
+ return checksumAlgorithmFactorySelector;
}
- protected Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories(
- ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector) {
+ protected ChecksumAlgorithmFactorySelector createChecksumAlgorithmFactorySelector() {
+ return new DefaultChecksumAlgorithmFactorySelector(getChecksumAlgorithmFactories());
+ }
+
+ private Map<String, RepositoryLayoutFactory> repositoryLayoutFactories;
+
+ public final Map<String, RepositoryLayoutFactory> getRepositoryLayoutFactories() {
+ checkClosed();
+ if (repositoryLayoutFactories == null) {
+ repositoryLayoutFactories = createRepositoryLayoutFactories();
+ }
+ return repositoryLayoutFactories;
+ }
+
+ protected Map<String, RepositoryLayoutFactory> createRepositoryLayoutFactories() {
HashMap<String, RepositoryLayoutFactory> result = new HashMap<>();
result.put(
Maven2RepositoryLayoutFactory.NAME,
- new Maven2RepositoryLayoutFactory(checksumAlgorithmFactorySelector));
+ new Maven2RepositoryLayoutFactory(getChecksumAlgorithmFactorySelector()));
return result;
}
- protected RepositoryLayoutProvider getRepositoryLayoutProvider(
- Map<String, RepositoryLayoutFactory> repositoryLayoutFactories) {
- return new DefaultRepositoryLayoutProvider(repositoryLayoutFactories);
+ private RepositoryLayoutProvider repositoryLayoutProvider;
+
+ public final RepositoryLayoutProvider getRepositoryLayoutProvider() {
+ checkClosed();
+ if (repositoryLayoutProvider == null) {
+ repositoryLayoutProvider = createRepositoryLayoutProvider();
+ }
+ return repositoryLayoutProvider;
+ }
+
+ protected RepositoryLayoutProvider createRepositoryLayoutProvider() {
+ return new DefaultRepositoryLayoutProvider(getRepositoryLayoutFactories());
}
- protected LocalRepositoryProvider getLocalRepositoryProvider(
- LocalPathComposer localPathComposer,
- TrackingFileManager trackingFileManager,
- LocalPathPrefixComposerFactory localPathPrefixComposerFactory) {
+ private LocalRepositoryProvider localRepositoryProvider;
+
+ public final LocalRepositoryProvider getLocalRepositoryProvider() {
+ checkClosed();
+ if (localRepositoryProvider == null) {
+ localRepositoryProvider = createLocalRepositoryProvider();
+ }
+ return localRepositoryProvider;
+ }
+
+ protected LocalRepositoryProvider createLocalRepositoryProvider() {
+ LocalPathComposer localPathComposer = getLocalPathComposer();
HashMap<String, LocalRepositoryManagerFactory> localRepositoryProviders = new HashMap<>(2);
localRepositoryProviders.put(
SimpleLocalRepositoryManagerFactory.NAME, new SimpleLocalRepositoryManagerFactory(localPathComposer));
localRepositoryProviders.put(
EnhancedLocalRepositoryManagerFactory.NAME,
new EnhancedLocalRepositoryManagerFactory(
- localPathComposer, trackingFileManager, localPathPrefixComposerFactory));
+ localPathComposer, getTrackingFileManager(), getLocalPathPrefixComposerFactory()));
return new DefaultLocalRepositoryProvider(localRepositoryProviders);
}
- protected RemoteRepositoryManager getRemoteRepositoryManager(
- UpdatePolicyAnalyzer updatePolicyAnalyzer, ChecksumPolicyProvider checksumPolicyProvider) {
- return new DefaultRemoteRepositoryManager(updatePolicyAnalyzer, checksumPolicyProvider);
+ private RemoteRepositoryManager remoteRepositoryManager;
+
+ public final RemoteRepositoryManager getRemoteRepositoryManager() {
+ checkClosed();
+ if (remoteRepositoryManager == null) {
+ remoteRepositoryManager = createRemoteRepositoryManager();
+ }
+ return remoteRepositoryManager;
}
- protected Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources(
- RepositorySystemLifecycle repositorySystemLifecycle, RepositoryLayoutProvider repositoryLayoutProvider) {
+ protected RemoteRepositoryManager createRemoteRepositoryManager() {
+ return new DefaultRemoteRepositoryManager(getUpdatePolicyAnalyzer(), getChecksumPolicyProvider());
+ }
+
+ private Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
+
+ public final Map<String, RemoteRepositoryFilterSource> getRemoteRepositoryFilterSources() {
+ checkClosed();
+ if (remoteRepositoryFilterSources == null) {
+ remoteRepositoryFilterSources = createRemoteRepositoryFilterSources();
+ }
+ return remoteRepositoryFilterSources;
+ }
+
+ protected Map<String, RemoteRepositoryFilterSource> createRemoteRepositoryFilterSources() {
HashMap<String, RemoteRepositoryFilterSource> result = new HashMap<>();
result.put(
GroupIdRemoteRepositoryFilterSource.NAME,
- new GroupIdRemoteRepositoryFilterSource(repositorySystemLifecycle));
+ new GroupIdRemoteRepositoryFilterSource(getRepositorySystemLifecycle()));
result.put(
PrefixesRemoteRepositoryFilterSource.NAME,
- new PrefixesRemoteRepositoryFilterSource(repositoryLayoutProvider));
+ new PrefixesRemoteRepositoryFilterSource(getRepositoryLayoutProvider()));
return result;
}
- protected RemoteRepositoryFilterManager getRemoteRepositoryFilterManager(
- Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources) {
- return new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
+ private RemoteRepositoryFilterManager remoteRepositoryFilterManager;
+
+ public final RemoteRepositoryFilterManager getRemoteRepositoryFilterManager() {
+ checkClosed();
+ if (remoteRepositoryFilterManager == null) {
+ remoteRepositoryFilterManager = createRemoteRepositoryFilterManager();
+ }
+ return remoteRepositoryFilterManager;
+ }
+
+ protected RemoteRepositoryFilterManager createRemoteRepositoryFilterManager() {
+ return new DefaultRemoteRepositoryFilterManager(getRemoteRepositoryFilterSources());
+ }
+
+ private Map<String, RepositoryListener> repositoryListeners;
+
+ public final Map<String, RepositoryListener> getRepositoryListeners() {
+ checkClosed();
+ if (repositoryListeners == null) {
+ repositoryListeners = createRepositoryListeners();
+ }
+ return repositoryListeners;
}
- protected Map<String, RepositoryListener> getRepositoryListeners() {
+ protected Map<String, RepositoryListener> createRepositoryListeners() {
return new HashMap<>();
}
- protected RepositoryEventDispatcher getRepositoryEventDispatcher(
- Map<String, RepositoryListener> repositoryListeners) {
- return new DefaultRepositoryEventDispatcher(repositoryListeners);
+ private RepositoryEventDispatcher repositoryEventDispatcher;
+
+ public final RepositoryEventDispatcher getRepositoryEventDispatcher() {
+ checkClosed();
+ if (repositoryEventDispatcher == null) {
+ repositoryEventDispatcher = createRepositoryEventDispatcher();
+ }
+ return repositoryEventDispatcher;
+ }
+
+ protected RepositoryEventDispatcher createRepositoryEventDispatcher() {
+ return new DefaultRepositoryEventDispatcher(getRepositoryListeners());
+ }
+
+ private Map<String, TrustedChecksumsSource> trustedChecksumsSources;
+
+ public final Map<String, TrustedChecksumsSource> getTrustedChecksumsSources() {
+ checkClosed();
+ if (trustedChecksumsSources == null) {
+ trustedChecksumsSources = createTrustedChecksumsSources();
+ }
+ return trustedChecksumsSources;
}
- protected Map<String, TrustedChecksumsSource> getTrustedChecksumsSources(
- FileProcessor fileProcessor,
- LocalPathComposer localPathComposer,
- RepositorySystemLifecycle repositorySystemLifecycle) {
+ protected Map<String, TrustedChecksumsSource> createTrustedChecksumsSources() {
HashMap<String, TrustedChecksumsSource> result = new HashMap<>();
result.put(
SparseDirectoryTrustedChecksumsSource.NAME,
- new SparseDirectoryTrustedChecksumsSource(fileProcessor, localPathComposer));
+ new SparseDirectoryTrustedChecksumsSource(getFileProcessor(), getLocalPathComposer()));
result.put(
SummaryFileTrustedChecksumsSource.NAME,
- new SummaryFileTrustedChecksumsSource(localPathComposer, repositorySystemLifecycle));
+ new SummaryFileTrustedChecksumsSource(getLocalPathComposer(), getRepositorySystemLifecycle()));
return result;
}
- protected Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources(
- Map<String, TrustedChecksumsSource> trustedChecksumsSources) {
+ private Map<String, ProvidedChecksumsSource> providedChecksumsSources;
+
+ public final Map<String, ProvidedChecksumsSource> getProvidedChecksumsSources() {
+ checkClosed();
+ if (providedChecksumsSources == null) {
+ providedChecksumsSources = createProvidedChecksumsSources();
+ }
+ return providedChecksumsSources;
+ }
+
+ protected Map<String, ProvidedChecksumsSource> createProvidedChecksumsSources() {
HashMap<String, ProvidedChecksumsSource> result = new HashMap<>();
result.put(
TrustedToProvidedChecksumsSourceAdapter.NAME,
- new TrustedToProvidedChecksumsSourceAdapter(trustedChecksumsSources));
+ new TrustedToProvidedChecksumsSourceAdapter(getTrustedChecksumsSources()));
return result;
}
- protected Map<String, TransporterFactory> getTransporterFactories() {
+ private Map<String, ChecksumExtractorStrategy> checksumExtractorStrategies;
+
+ public final Map<String, ChecksumExtractorStrategy> getChecksumExtractorStrategies() {
+ checkClosed();
+ if (checksumExtractorStrategies == null) {
+ checksumExtractorStrategies = createChecksumExtractorStrategies();
+ }
+ return checksumExtractorStrategies;
+ }
+
+ protected Map<String, ChecksumExtractorStrategy> createChecksumExtractorStrategies() {
+ HashMap<String, ChecksumExtractorStrategy> result = new HashMap<>();
+ result.put(XChecksumExtractor.NAME, new XChecksumExtractor());
+ result.put(Nx2ChecksumExtractor.NAME, new Nx2ChecksumExtractor());
+ return result;
+ }
+
+ private ChecksumExtractor checksumExtractor;
+
+ public final ChecksumExtractor getChecksumExtractor() {
+ checkClosed();
+ if (checksumExtractor == null) {
+ checksumExtractor = createChecksumExtractor();
+ }
+ return checksumExtractor;
+ }
+
+ protected ChecksumExtractor createChecksumExtractor() {
+ return new DefaultChecksumExtractor(getChecksumExtractorStrategies());
+ }
+
+ private Map<String, TransporterFactory> transporterFactories;
+
+ public final Map<String, TransporterFactory> getTransporterFactories() {
+ checkClosed();
+ if (transporterFactories == null) {
+ transporterFactories = createTransporterFactories();
+ }
+ return transporterFactories;
+ }
+
+ protected Map<String, TransporterFactory> createTransporterFactories() {
HashMap<String, TransporterFactory> result = new HashMap<>();
result.put(FileTransporterFactory.NAME, new FileTransporterFactory());
- result.put(ApacheTransporterFactory.NAME, new ApacheTransporterFactory());
+ result.put(ApacheTransporterFactory.NAME, new ApacheTransporterFactory(getChecksumExtractor()));
return result;
}
- protected TransporterProvider getTransporterProvider(Map<String, TransporterFactory> transporterFactories) {
- return new DefaultTransporterProvider(transporterFactories);
+ private TransporterProvider transporterProvider;
+
+ public final TransporterProvider getTransporterProvider() {
+ checkClosed();
+ if (transporterProvider == null) {
+ transporterProvider = createTransporterProvider();
+ }
+ return transporterProvider;
+ }
+
+ protected TransporterProvider createTransporterProvider() {
+ return new DefaultTransporterProvider(getTransporterFactories());
}
- protected BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory(
- TransporterProvider transporterProvider,
- RepositoryLayoutProvider repositoryLayoutProvider,
- ChecksumPolicyProvider checksumPolicyProvider,
- FileProcessor fileProcessor,
- Map<String, ProvidedChecksumsSource> providedChecksumsSources) {
+ private BasicRepositoryConnectorFactory basicRepositoryConnectorFactory;
+
+ public final BasicRepositoryConnectorFactory getBasicRepositoryConnectorFactory() {
+ checkClosed();
+ if (basicRepositoryConnectorFactory == null) {
+ basicRepositoryConnectorFactory = createBasicRepositoryConnectorFactory();
+ }
+ return basicRepositoryConnectorFactory;
+ }
+
+ protected BasicRepositoryConnectorFactory createBasicRepositoryConnectorFactory() {
return new BasicRepositoryConnectorFactory(
- transporterProvider,
- repositoryLayoutProvider,
- checksumPolicyProvider,
- fileProcessor,
- providedChecksumsSources);
+ getTransporterProvider(),
+ getRepositoryLayoutProvider(),
+ getChecksumPolicyProvider(),
+ getFileProcessor(),
+ getProvidedChecksumsSources());
+ }
+
+ private Map<String, RepositoryConnectorFactory> repositoryConnectorFactories;
+
+ public final Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories() {
+ checkClosed();
+ if (repositoryConnectorFactories == null) {
+ repositoryConnectorFactories = createRepositoryConnectorFactories();
+ }
+ return repositoryConnectorFactories;
}
- protected Map<String, RepositoryConnectorFactory> getRepositoryConnectorFactories(
- BasicRepositoryConnectorFactory basicRepositoryConnectorFactory) {
+ protected Map<String, RepositoryConnectorFactory> createRepositoryConnectorFactories() {
HashMap<String, RepositoryConnectorFactory> result = new HashMap<>();
- result.put(BasicRepositoryConnectorFactory.NAME, basicRepositoryConnectorFactory);
+ result.put(BasicRepositoryConnectorFactory.NAME, getBasicRepositoryConnectorFactory());
return result;
}
- protected RepositoryConnectorProvider getRepositoryConnectorProvider(
- Map<String, RepositoryConnectorFactory> repositoryConnectorFactories,
- RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
- return new DefaultRepositoryConnectorProvider(repositoryConnectorFactories, remoteRepositoryFilterManager);
+ private RepositoryConnectorProvider repositoryConnectorProvider;
+
+ public final RepositoryConnectorProvider getRepositoryConnectorProvider() {
+ checkClosed();
+ if (repositoryConnectorProvider == null) {
+ repositoryConnectorProvider = createRepositoryConnectorProvider();
+ }
+ return repositoryConnectorProvider;
+ }
+
+ protected RepositoryConnectorProvider createRepositoryConnectorProvider() {
+ return new DefaultRepositoryConnectorProvider(
+ getRepositoryConnectorFactories(), getRemoteRepositoryFilterManager());
}
- protected Installer getInstaller(
- FileProcessor fileProcessor,
- RepositoryEventDispatcher repositoryEventDispatcher,
- Map<String, MetadataGeneratorFactory> metadataGeneratorFactories,
- SyncContextFactory syncContextFactory) {
+ private Installer installer;
+
+ public final Installer getInstaller() {
+ checkClosed();
+ if (installer == null) {
+ installer = createInstaller();
+ }
+ return installer;
+ }
+
+ protected Installer createInstaller() {
return new DefaultInstaller(
- fileProcessor, repositoryEventDispatcher, metadataGeneratorFactories, syncContextFactory);
- }
-
- @SuppressWarnings("checkstyle:parameternumber")
- protected Deployer getDeployer(
- FileProcessor fileProcessor,
- RepositoryEventDispatcher repositoryEventDispatcher,
- RepositoryConnectorProvider repositoryConnectorProvider,
- RemoteRepositoryManager remoteRepositoryManager,
- UpdateCheckManager updateCheckManager,
- Map<String, MetadataGeneratorFactory> metadataGeneratorFactories,
- SyncContextFactory syncContextFactory,
- OfflineController offlineController) {
+ getFileProcessor(),
+ getRepositoryEventDispatcher(),
+ getMetadataGeneratorFactories(),
+ getSyncContextFactory());
+ }
+
+ private Deployer deployer;
+
+ public final Deployer getDeployer() {
+ checkClosed();
+ if (deployer == null) {
+ deployer = createDeployer();
+ }
+ return deployer;
+ }
+
+ protected Deployer createDeployer() {
return new DefaultDeployer(
- fileProcessor,
- repositoryEventDispatcher,
- repositoryConnectorProvider,
- remoteRepositoryManager,
- updateCheckManager,
- metadataGeneratorFactories,
- syncContextFactory,
- offlineController);
- }
-
- protected Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates(
- RemoteRepositoryManager remoteRepositoryManager,
- ArtifactDescriptorReader artifactDescriptorReader,
- VersionRangeResolver versionRangeResolver) {
+ getFileProcessor(),
+ getRepositoryEventDispatcher(),
+ getRepositoryConnectorProvider(),
+ getRemoteRepositoryManager(),
+ getUpdateCheckManager(),
+ getMetadataGeneratorFactories(),
+ getSyncContextFactory(),
+ getOfflineController());
+ }
+
+ private Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates;
+
+ public final Map<String, DependencyCollectorDelegate> getDependencyCollectorDelegates() {
+ checkClosed();
+ if (dependencyCollectorDelegates == null) {
+ dependencyCollectorDelegates = createDependencyCollectorDelegates();
+ }
+ return dependencyCollectorDelegates;
+ }
+
+ protected Map<String, DependencyCollectorDelegate> createDependencyCollectorDelegates() {
+ RemoteRepositoryManager remoteRepositoryManager = getRemoteRepositoryManager();
+ ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader();
+ VersionRangeResolver versionRangeResolver = getVersionRangeResolver();
HashMap<String, DependencyCollectorDelegate> result = new HashMap<>();
result.put(
DfDependencyCollector.NAME,
@@ -375,72 +710,111 @@ public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
return result;
}
- protected DependencyCollector getDependencyCollector(
- Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates) {
- return new DefaultDependencyCollector(dependencyCollectorDelegates);
+ private DependencyCollector dependencyCollector;
+
+ public final DependencyCollector getDependencyCollector() {
+ checkClosed();
+ if (dependencyCollector == null) {
+ dependencyCollector = createDependencyCollector();
+ }
+ return dependencyCollector;
+ }
+
+ protected DependencyCollector createDependencyCollector() {
+ return new DefaultDependencyCollector(getDependencyCollectorDelegates());
}
- protected Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors(
- ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector,
- Map<String, TrustedChecksumsSource> trustedChecksumsSources) {
+ private Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors;
+
+ public final Map<String, ArtifactResolverPostProcessor> getArtifactResolverPostProcessors() {
+ checkClosed();
+ if (artifactResolverPostProcessors == null) {
+ artifactResolverPostProcessors = createArtifactResolverPostProcessors();
+ }
+ return artifactResolverPostProcessors;
+ }
+
+ protected Map<String, ArtifactResolverPostProcessor> createArtifactResolverPostProcessors() {
HashMap<String, ArtifactResolverPostProcessor> result = new HashMap<>();
result.put(
TrustedChecksumsArtifactResolverPostProcessor.NAME,
new TrustedChecksumsArtifactResolverPostProcessor(
- checksumAlgorithmFactorySelector, trustedChecksumsSources));
+ getChecksumAlgorithmFactorySelector(), getTrustedChecksumsSources()));
return result;
}
- @SuppressWarnings("checkstyle:parameternumber")
- protected ArtifactResolver getArtifactResolver(
- FileProcessor fileProcessor,
- RepositoryEventDispatcher repositoryEventDispatcher,
- VersionResolver versionResolver,
- UpdateCheckManager updateCheckManager,
- RepositoryConnectorProvider repositoryConnectorProvider,
- RemoteRepositoryManager remoteRepositoryManager,
- SyncContextFactory syncContextFactory,
- OfflineController offlineController,
- Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors,
- RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
+ private ArtifactResolver artifactResolver;
+
+ public final ArtifactResolver getArtifactResolver() {
+ checkClosed();
+ if (artifactResolver == null) {
+ artifactResolver = createArtifactResolver();
+ }
+ return artifactResolver;
+ }
+
+ protected ArtifactResolver createArtifactResolver() {
return new DefaultArtifactResolver(
- fileProcessor,
- repositoryEventDispatcher,
- versionResolver,
- updateCheckManager,
- repositoryConnectorProvider,
- remoteRepositoryManager,
- syncContextFactory,
- offlineController,
- artifactResolverPostProcessors,
- remoteRepositoryFilterManager);
- }
-
- protected MetadataResolver getMetadataResolver(
- RepositoryEventDispatcher repositoryEventDispatcher,
- UpdateCheckManager updateCheckManager,
- RepositoryConnectorProvider repositoryConnectorProvider,
- RemoteRepositoryManager remoteRepositoryManager,
- SyncContextFactory syncContextFactory,
- OfflineController offlineController,
- RemoteRepositoryFilterManager remoteRepositoryFilterManager) {
+ getFileProcessor(),
+ getRepositoryEventDispatcher(),
+ getVersionResolver(),
+ getUpdateCheckManager(),
+ getRepositoryConnectorProvider(),
+ getRemoteRepositoryManager(),
+ getSyncContextFactory(),
+ getOfflineController(),
+ getArtifactResolverPostProcessors(),
+ getRemoteRepositoryFilterManager());
+ }
+
+ private MetadataResolver metadataResolver;
+
+ public final MetadataResolver getMetadataResolver() {
+ checkClosed();
+ if (metadataResolver == null) {
+ metadataResolver = createMetadataResolver();
+ }
+ return metadataResolver;
+ }
+
+ protected MetadataResolver createMetadataResolver() {
return new DefaultMetadataResolver(
- repositoryEventDispatcher,
- updateCheckManager,
- repositoryConnectorProvider,
- remoteRepositoryManager,
- syncContextFactory,
- offlineController,
- remoteRepositoryFilterManager);
+ getRepositoryEventDispatcher(),
+ getUpdateCheckManager(),
+ getRepositoryConnectorProvider(),
+ getRemoteRepositoryManager(),
+ getSyncContextFactory(),
+ getOfflineController(),
+ getRemoteRepositoryFilterManager());
}
- protected VersionScheme getVersionScheme() {
+ private VersionScheme versionScheme;
+
+ public final VersionScheme getVersionScheme() {
+ checkClosed();
+ if (versionScheme == null) {
+ versionScheme = createVersionScheme();
+ }
+ return versionScheme;
+ }
+
+ protected VersionScheme createVersionScheme() {
return new GenericVersionScheme();
}
// Maven provided
- protected Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
+ private Map<String, MetadataGeneratorFactory> metadataGeneratorFactories;
+
+ public final Map<String, MetadataGeneratorFactory> getMetadataGeneratorFactories() {
+ checkClosed();
+ if (metadataGeneratorFactories == null) {
+ metadataGeneratorFactories = createMetadataGeneratorFactories();
+ }
+ return metadataGeneratorFactories;
+ }
+
+ protected Map<String, MetadataGeneratorFactory> createMetadataGeneratorFactories() {
// from maven-resolver-provider
HashMap<String, MetadataGeneratorFactory> result = new HashMap<>();
result.put(PluginsMetadataGeneratorFactory.NAME, new PluginsMetadataGeneratorFactory());
@@ -449,7 +823,17 @@ public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
return result;
}
- protected LinkedHashMap<String, MavenArtifactRelocationSource> getMavenArtifactRelocationSource() {
+ private LinkedHashMap<String, MavenArtifactRelocationSource> artifactRelocationSources;
+
+ public final LinkedHashMap<String, MavenArtifactRelocationSource> getMavenArtifactRelocationSources() {
+ checkClosed();
+ if (artifactRelocationSources == null) {
+ artifactRelocationSources = createMavenArtifactRelocationSources();
+ }
+ return artifactRelocationSources;
+ }
+
+ protected LinkedHashMap<String, MavenArtifactRelocationSource> createMavenArtifactRelocationSources() {
// from maven-resolver-provider
LinkedHashMap<String, MavenArtifactRelocationSource> result = new LinkedHashMap<>();
result.put(UserPropertiesArtifactRelocationSource.NAME, new UserPropertiesArtifactRelocationSource());
@@ -459,188 +843,119 @@ public class RepositorySystemSupplier implements Supplier<RepositorySystem> {
return result;
}
- @SuppressWarnings("checkstyle:parameternumber")
- protected ArtifactDescriptorReader getArtifactDescriptorReader(
- RemoteRepositoryManager remoteRepositoryManager,
- VersionResolver versionResolver,
- VersionRangeResolver versionRangeResolver,
- ArtifactResolver artifactResolver,
- ModelBuilder modelBuilder,
- RepositoryEventDispatcher repositoryEventDispatcher,
- ModelCacheFactory modelCacheFactory,
- LinkedHashMap<String, MavenArtifactRelocationSource> artifactRelocationSources) {
+ private ArtifactDescriptorReader artifactDescriptorReader;
+
+ public final ArtifactDescriptorReader getArtifactDescriptorReader() {
+ checkClosed();
+ if (artifactDescriptorReader == null) {
+ artifactDescriptorReader = createArtifactDescriptorReader();
+ }
+ return artifactDescriptorReader;
+ }
+
+ protected ArtifactDescriptorReader createArtifactDescriptorReader() {
// from maven-resolver-provider
return new DefaultArtifactDescriptorReader(
- remoteRepositoryManager,
- versionResolver,
- versionRangeResolver,
- artifactResolver,
- modelBuilder,
- repositoryEventDispatcher,
- modelCacheFactory,
- artifactRelocationSources);
- }
-
- protected VersionResolver getVersionResolver(
- MetadataResolver metadataResolver,
- SyncContextFactory syncContextFactory,
- RepositoryEventDispatcher repositoryEventDispatcher) {
+ getRemoteRepositoryManager(),
+ getVersionResolver(),
+ getVersionRangeResolver(),
+ getArtifactResolver(),
+ getModelBuilder(),
+ getRepositoryEventDispatcher(),
+ getModelCacheFactory(),
+ getMavenArtifactRelocationSources());
+ }
+
+ private VersionResolver versionResolver;
+
+ public final VersionResolver getVersionResolver() {
+ checkClosed();
+ if (versionResolver == null) {
+ versionResolver = createVersionResolver();
+ }
+ return versionResolver;
+ }
+
+ protected VersionResolver createVersionResolver() {
// from maven-resolver-provider
- return new DefaultVersionResolver(metadataResolver, syncContextFactory, repositoryEventDispatcher);
+ return new DefaultVersionResolver(
+ getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher());
+ }
+
+ private VersionRangeResolver versionRangeResolver;
+
+ public final VersionRangeResolver getVersionRangeResolver() {
+ checkClosed();
+ if (versionRangeResolver == null) {
+ versionRangeResolver = createVersionRangeResolver();
+ }
+ return versionRangeResolver;
}
- protected VersionRangeResolver getVersionRangeResolver(
- MetadataResolver metadataResolver,
- SyncContextFactory syncContextFactory,
- RepositoryEventDispatcher repositoryEventDispatcher,
- VersionScheme versionScheme) {
+ protected VersionRangeResolver createVersionRangeResolver() {
// from maven-resolver-provider
return new DefaultVersionRangeResolver(
- metadataResolver, syncContextFactory, repositoryEventDispatcher, versionScheme);
+ getMetadataResolver(), getSyncContextFactory(), getRepositoryEventDispatcher(), getVersionScheme());
}
- protected ModelBuilder getModelBuilder() {
+ private ModelBuilder modelBuilder;
+
+ public final ModelBuilder getModelBuilder() {
+ checkClosed();
+ if (modelBuilder == null) {
+ modelBuilder = createModelBuilder();
+ }
+ return modelBuilder;
+ }
+
+ protected ModelBuilder createModelBuilder() {
// from maven-model-builder
return new DefaultModelBuilderFactory().newInstance();
}
- protected ModelCacheFactory getModelCacheFactory() {
+ private ModelCacheFactory modelCacheFactory;
+
+ public final ModelCacheFactory getModelCacheFactory() {
+ checkClosed();
+ if (modelCacheFactory == null) {
+ modelCacheFactory = createModelCacheFactory();
+ }
+ return modelCacheFactory;
+ }
+
+ protected ModelCacheFactory createModelCacheFactory() {
// from maven-resolver-provider
return new DefaultModelCacheFactory();
}
- @Override
- public RepositorySystem get() {
- FileProcessor fileProcessor = getFileProcessor();
- TrackingFileManager trackingFileManager = getTrackingFileManager();
- LocalPathComposer localPathComposer = getLocalPathComposer();
- LocalPathPrefixComposerFactory localPathPrefixComposerFactory = getLocalPathPrefixComposerFactory();
- RepositorySystemLifecycle repositorySystemLifecycle = getRepositorySystemLifecycle();
- OfflineController offlineController = getOfflineController();
- UpdatePolicyAnalyzer updatePolicyAnalyzer = getUpdatePolicyAnalyzer();
- ChecksumPolicyProvider checksumPolicyProvider = getChecksumPolicyProvider();
-
- UpdateCheckManager updateCheckManager = getUpdateCheckManager(trackingFileManager, updatePolicyAnalyzer);
-
- Map<String, NamedLockFactory> namedLockFactories = getNamedLockFactories();
- Map<String, NameMapper> nameMappers = getNameMappers();
- NamedLockFactoryAdapterFactory namedLockFactoryAdapterFactory =
- getNamedLockFactoryAdapterFactory(namedLockFactories, nameMappers, repositorySystemLifecycle);
- SyncContextFactory syncContextFactory = getSyncContextFactory(namedLockFactoryAdapterFactory);
-
- Map<String, ChecksumAlgorithmFactory> checksumAlgorithmFactories = getChecksumAlgorithmFactories();
- ChecksumAlgorithmFactorySelector checksumAlgorithmFactorySelector =
- getChecksumAlgorithmFactorySelector(checksumAlgorithmFactories);
-
- Map<String, RepositoryLayoutFactory> repositoryLayoutFactories =
- getRepositoryLayoutFactories(checksumAlgorithmFactorySelector);
- RepositoryLayoutProvider repositoryLayoutProvider = getRepositoryLayoutProvider(repositoryLayoutFactories);
-
- LocalRepositoryProvider localRepositoryProvider =
- getLocalRepositoryProvider(localPathComposer, trackingFileManager, localPathPrefixComposerFactory);
-
- RemoteRepositoryManager remoteRepositoryManager =
- getRemoteRepositoryManager(updatePolicyAnalyzer, checksumPolicyProvider);
- Map<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources =
- getRemoteRepositoryFilterSources(repositorySystemLifecycle, repositoryLayoutProvider);
- RemoteRepositoryFilterManager remoteRepositoryFilterManager =
- getRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
-
- Map<String, RepositoryListener> repositoryListeners = getRepositoryListeners();
- RepositoryEventDispatcher repositoryEventDispatcher = getRepositoryEventDispatcher(repositoryListeners);
-
- Map<String, TrustedChecksumsSource> trustedChecksumsSources =
- getTrustedChecksumsSources(fileProcessor, localPathComposer, repositorySystemLifecycle);
- Map<String, ProvidedChecksumsSource> providedChecksumsSources =
- getProvidedChecksumsSources(trustedChecksumsSources);
-
- Map<String, TransporterFactory> transporterFactories = getTransporterFactories();
- TransporterProvider transporterProvider = getTransporterProvider(transporterFactories);
-
- BasicRepositoryConnectorFactory basic = getBasicRepositoryConnectorFactory(
- transporterProvider,
- repositoryLayoutProvider,
- checksumPolicyProvider,
- fileProcessor,
- providedChecksumsSources);
- Map<String, RepositoryConnectorFactory> repositoryConnectorFactories = getRepositoryConnectorFactories(basic);
- RepositoryConnectorProvider repositoryConnectorProvider =
- getRepositoryConnectorProvider(repositoryConnectorFactories, remoteRepositoryFilterManager);
-
- Map<String, MetadataGeneratorFactory> metadataGeneratorFactories = getMetadataGeneratorFactories();
-
- Installer installer =
- getInstaller(fileProcessor, repositoryEventDispatcher, metadataGeneratorFactories, syncContextFactory);
- Deployer deployer = getDeployer(
- fileProcessor,
- repositoryEventDispatcher,
- repositoryConnectorProvider,
- remoteRepositoryManager,
- updateCheckManager,
- metadataGeneratorFactories,
- syncContextFactory,
- offlineController);
-
- MetadataResolver metadataResolver = getMetadataResolver(
- repositoryEventDispatcher,
- updateCheckManager,
- repositoryConnectorProvider,
- remoteRepositoryManager,
- syncContextFactory,
- offlineController,
- remoteRepositoryFilterManager);
-
- VersionScheme versionScheme = getVersionScheme();
- VersionResolver versionResolver =
- getVersionResolver(metadataResolver, syncContextFactory, repositoryEventDispatcher);
- VersionRangeResolver versionRangeResolver =
- getVersionRangeResolver(metadataResolver, syncContextFactory, repositoryEventDispatcher, versionScheme);
-
- Map<String, ArtifactResolverPostProcessor> artifactResolverPostProcessors =
- getArtifactResolverPostProcessors(checksumAlgorithmFactorySelector, trustedChecksumsSources);
- ArtifactResolver artifactResolver = getArtifactResolver(
- fileProcessor,
- repositoryEventDispatcher,
- versionResolver,
- updateCheckManager,
- repositoryConnectorProvider,
- remoteRepositoryManager,
- syncContextFactory,
- offlineController,
- artifactResolverPostProcessors,
- remoteRepositoryFilterManager);
-
- ModelBuilder modelBuilder = getModelBuilder();
- ModelCacheFactory modelCacheFactory = getModelCacheFactory();
- LinkedHashMap<String, MavenArtifactRelocationSource> mavenArtifactRelocationSources =
- getMavenArtifactRelocationSource();
-
- ArtifactDescriptorReader artifactDescriptorReader = getArtifactDescriptorReader(
- remoteRepositoryManager,
- versionResolver,
- versionRangeResolver,
- artifactResolver,
- modelBuilder,
- repositoryEventDispatcher,
- modelCacheFactory,
- mavenArtifactRelocationSources);
-
- Map<String, DependencyCollectorDelegate> dependencyCollectorDelegates = getDependencyCollectorDelegates(
- remoteRepositoryManager, artifactDescriptorReader, versionRangeResolver);
- DependencyCollector dependencyCollector = getDependencyCollector(dependencyCollectorDelegates);
+ private RepositorySystem repositorySystem;
+
+ public final RepositorySystem getRepositorySystem() {
+ checkClosed();
+ if (repositorySystem == null) {
+ repositorySystem = createRepositorySystem();
+ }
+ return repositorySystem;
+ }
+ protected RepositorySystem createRepositorySystem() {
return new DefaultRepositorySystem(
- versionResolver,
- versionRangeResolver,
- artifactResolver,
- metadataResolver,
- artifactDescriptorReader,
- dependencyCollector,
- installer,
- deployer,
- localRepositoryProvider,
- syncContextFactory,
- remoteRepositoryManager,
- repositorySystemLifecycle);
+ getVersionResolver(),
+ getVersionRangeResolver(),
+ getArtifactResolver(),
+ getMetadataResolver(),
+ getArtifactDescriptorReader(),
+ getDependencyCollector(),
+ getInstaller(),
+ getDeployer(),
+ getLocalRepositoryProvider(),
+ getSyncContextFactory(),
+ getRemoteRepositoryManager(),
+ getRepositorySystemLifecycle());
+ }
+
+ @Override
+ public RepositorySystem get() {
+ return getRepositorySystem();
}
}
diff --git a/maven-resolver-supplier/src/test/java/org/eclipse/aether/supplier/RepositorySystemSupplierTest.java b/maven-resolver-supplier/src/test/java/org/eclipse/aether/supplier/RepositorySystemSupplierTest.java
index fb430114..77e793ca 100644
--- a/maven-resolver-supplier/src/test/java/org/eclipse/aether/supplier/RepositorySystemSupplierTest.java
+++ b/maven-resolver-supplier/src/test/java/org/eclipse/aether/supplier/RepositorySystemSupplierTest.java
@@ -26,20 +26,20 @@ import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession.CloseableSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
+import org.eclipse.aether.impl.Deployer;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.resolution.VersionRangeRequest;
import org.eclipse.aether.resolution.VersionRangeResult;
+import org.eclipse.aether.spi.io.FileProcessor;
import org.eclipse.aether.version.Version;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
public class RepositorySystemSupplierTest {
- private final RepositorySystemSupplier subject = new RepositorySystemSupplier();
-
@Test
void smoke() throws Exception {
- try (RepositorySystem system = subject.get();
+ try (RepositorySystem system = new RepositorySystemSupplier().get();
CloseableSession session = new SessionBuilderSupplier(system)
.get()
.withLocalRepositoryBaseDirectories(new File("target/local-repo"))
@@ -58,4 +58,29 @@ public class RepositorySystemSupplierTest {
System.out.println("Available " + versions.size() + " versions: " + versions);
}
}
+
+ @Test
+ void closed() {
+ RepositorySystemSupplier systemSupplier = new RepositorySystemSupplier();
+ systemSupplier.get().close(); // get an instance and immediately shut it down, this closes supplier as well
+ assertThrows(IllegalStateException.class, systemSupplier::get);
+ assertThrows(IllegalStateException.class, systemSupplier::getRepositorySystem);
+ assertThrows(IllegalStateException.class, systemSupplier::getFileProcessor);
+ }
+
+ @Test
+ void memorizing() {
+ RepositorySystemSupplier systemSupplier = new RepositorySystemSupplier();
+ FileProcessor fileProcessor = systemSupplier.getFileProcessor();
+ Deployer deployer = systemSupplier.getDeployer();
+ try (RepositorySystem repositorySystem = systemSupplier.get()) {
+ assertSame(systemSupplier.get(), repositorySystem);
+ assertSame(systemSupplier.getFileProcessor(), fileProcessor);
+ assertSame(systemSupplier.getDeployer(), deployer);
+ }
+ assertThrows(IllegalStateException.class, systemSupplier::get);
+ assertThrows(IllegalStateException.class, systemSupplier::getRepositorySystem);
+ assertThrows(IllegalStateException.class, systemSupplier::getDeployer);
+ assertThrows(IllegalStateException.class, systemSupplier::getFileProcessor);
+ }
}
diff --git a/maven-resolver-test-http/src/main/java/org/eclipse/aether/internal/test/util/http/HttpTransporterTest.java b/maven-resolver-test-http/src/main/java/org/eclipse/aether/internal/test/util/http/HttpTransporterTest.java
index 4cfe7017..0b0a74af 100644
--- a/maven-resolver-test-http/src/main/java/org/eclipse/aether/internal/test/util/http/HttpTransporterTest.java
+++ b/maven-resolver-test-http/src/main/java/org/eclipse/aether/internal/test/util/http/HttpTransporterTest.java
@@ -36,6 +36,9 @@ import org.eclipse.aether.ConfigurationProperties;
import org.eclipse.aether.DefaultRepositoryCache;
import org.eclipse.aether.DefaultRepositorySystemSession;
import org.eclipse.aether.DefaultSessionData;
+import org.eclipse.aether.internal.impl.transport.http.DefaultChecksumExtractor;
+import org.eclipse.aether.internal.impl.transport.http.Nx2ChecksumExtractor;
+import org.eclipse.aether.internal.impl.transport.http.XChecksumExtractor;
import org.eclipse.aether.internal.test.util.TestFileUtils;
import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
import org.eclipse.aether.repository.Authentication;
@@ -45,9 +48,7 @@ import org.eclipse.aether.spi.connector.transport.GetTask;
import org.eclipse.aether.spi.connector.transport.PeekTask;
import org.eclipse.aether.spi.connector.transport.PutTask;
import org.eclipse.aether.spi.connector.transport.Transporter;
-import org.eclipse.aether.spi.connector.transport.http.HttpTransporter;
-import org.eclipse.aether.spi.connector.transport.http.HttpTransporterException;
-import org.eclipse.aether.spi.connector.transport.http.HttpTransporterFactory;
+import org.eclipse.aether.spi.connector.transport.http.*;
import org.eclipse.aether.transfer.NoTransporterException;
import org.eclipse.aether.transfer.TransferCancelledException;
import org.eclipse.aether.util.repository.AuthenticationBuilder;
@@ -124,6 +125,13 @@ public class HttpTransporterTest {
}
}
+ protected static ChecksumExtractor standardChecksumExtractor() {
+ HashMap<String, ChecksumExtractorStrategy> strategies = new HashMap<>();
+ strategies.put("1", new Nx2ChecksumExtractor());
+ strategies.put("2", new XChecksumExtractor());
+ return new DefaultChecksumExtractor(strategies);
+ }
+
protected RemoteRepository newRepo(String url) {
return new RemoteRepository.Builder("test", "default", url)
.setAuthentication(auth)
diff --git a/maven-resolver-transport-apache/pom.xml b/maven-resolver-transport-apache/pom.xml
index ba6a19b9..2f95d473 100644
--- a/maven-resolver-transport-apache/pom.xml
+++ b/maven-resolver-transport-apache/pom.xml
@@ -99,11 +99,6 @@
<artifactId>junit-jupiter-api</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>com.google.inject</groupId>
- <artifactId>guice</artifactId>
- <scope>test</scope>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
diff --git a/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporter.java b/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporter.java
index 56ab1ea8..fea00f06 100644
--- a/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporter.java
+++ b/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporter.java
@@ -34,13 +34,12 @@ import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.FileTime;
import java.util.Collections;
import java.util.Date;
-import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.function.Function;
import java.util.regex.Matcher;
-import java.util.regex.Pattern;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
@@ -93,6 +92,7 @@ import org.eclipse.aether.spi.connector.transport.GetTask;
import org.eclipse.aether.spi.connector.transport.PeekTask;
import org.eclipse.aether.spi.connector.transport.PutTask;
import org.eclipse.aether.spi.connector.transport.TransportTask;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporter;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporterException;
import org.eclipse.aether.transfer.NoTransporterException;
@@ -103,6 +103,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static java.util.Objects.requireNonNull;
+import static org.eclipse.aether.spi.connector.transport.http.HttpConstants.CONTENT_RANGE_PATTERN;
import static org.eclipse.aether.transport.apache.ApacheTransporterConfigurationKeys.CONFIG_PROP_HTTP_RETRY_HANDLER_NAME;
import static org.eclipse.aether.transport.apache.ApacheTransporterConfigurationKeys.CONFIG_PROP_HTTP_RETRY_HANDLER_REQUEST_SENT_ENABLED;
import static org.eclipse.aether.transport.apache.ApacheTransporterConfigurationKeys.CONFIG_PROP_USE_SYSTEM_PROPERTIES;
@@ -115,11 +116,10 @@ import static org.eclipse.aether.transport.apache.ApacheTransporterConfiguration
* A transporter for HTTP/HTTPS.
*/
final class ApacheTransporter extends AbstractTransporter implements HttpTransporter {
- private static final Pattern CONTENT_RANGE_PATTERN =
- Pattern.compile("\\s*bytes\\s+([0-9]+)\\s*-\\s*([0-9]+)\\s*/.*");
-
private static final Logger LOGGER = LoggerFactory.getLogger(ApacheTransporter.class);
+ private final ChecksumExtractor checksumExtractor;
+
private final AuthenticationContext repoAuthContext;
private final AuthenticationContext proxyAuthContext;
@@ -143,10 +143,12 @@ final class ApacheTransporter extends AbstractTransporter implements HttpTranspo
private final boolean supportWebDav;
@SuppressWarnings("checkstyle:methodlength")
- ApacheTransporter(RemoteRepository repository, RepositorySystemSession session) throws NoTransporterException {
+ ApacheTransporter(RemoteRepository repository, RepositorySystemSession session, ChecksumExtractor checksumExtractor)
+ throws NoTransporterException {
if (!"http".equalsIgnoreCase(repository.getProtocol()) && !"https".equalsIgnoreCase(repository.getProtocol())) {
throw new NoTransporterException(repository);
}
+ this.checksumExtractor = checksumExtractor;
try {
this.baseUri = new URI(repository.getUrl()).parseServerAuthority();
if (baseUri.isOpaque()) {
@@ -679,62 +681,18 @@ final class ApacheTransporter extends AbstractTransporter implements HttpTranspo
}
private void extractChecksums(CloseableHttpResponse response) {
- Map<String, String> checksums = extractXChecksums(response);
- if (checksums == null) {
- checksums = extractNx2Checksums(response);
- }
- if (checksums != null) {
+ Map<String, String> checksums = checksumExtractor.extractChecksums(headerGetter(response));
+ if (checksums != null && !checksums.isEmpty()) {
checksums.forEach(task::setChecksum);
}
}
}
- private static Map<String, String> extractNx2Checksums(HttpResponse response) {
- // Nexus-style, ETag: "{SHA1{d40d68ba1f88d8e9b0040f175a6ff41928abd5e7}}"
- Header header = response.getFirstHeader(HttpHeaders.ETAG);
- String etag = header != null ? header.getValue() : null;
- if (etag != null) {
- int start = etag.indexOf("SHA1{"), end = etag.indexOf("}", start + 5);
- if (start >= 0 && end > start) {
- return Collections.singletonMap("SHA-1", etag.substring(start + 5, end));
- }
- }
- return null;
- }
-
- private static Map<String, String> extractXChecksums(HttpResponse response) {
- String value;
- HashMap<String, String> result = new HashMap<>();
- // Central style: x-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
- value = extractXChecksum(response, "x-checksum-sha1");
- if (value != null) {
- result.put("SHA-1", value);
- }
- // Central style: x-checksum-md5: 9ad0d8e3482767c122e85f83567b8ce6
- value = extractXChecksum(response, "x-checksum-md5");
- if (value != null) {
- result.put("MD5", value);
- }
- if (!result.isEmpty()) {
- return result;
- }
- // Google style: x-goog-meta-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
- value = extractXChecksum(response, "x-goog-meta-checksum-sha1");
- if (value != null) {
- result.put("SHA-1", value);
- }
- // Central style: x-goog-meta-checksum-sha1: 9ad0d8e3482767c122e85f83567b8ce6
- value = extractXChecksum(response, "x-goog-meta-checksum-md5");
- if (value != null) {
- result.put("MD5", value);
- }
-
- return result.isEmpty() ? null : result;
- }
-
- private static String extractXChecksum(HttpResponse response, String name) {
- Header header = response.getFirstHeader(name);
- return header != null ? header.getValue() : null;
+ private static Function<String, String> headerGetter(CloseableHttpResponse closeableHttpResponse) {
+ return s -> {
+ Header header = closeableHttpResponse.getFirstHeader(s);
+ return header != null ? header.getValue() : null;
+ };
}
private class PutTaskEntity extends AbstractHttpEntity {
diff --git a/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporterFactory.java b/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporterFactory.java
index 621188ee..73fd4b9e 100644
--- a/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporterFactory.java
+++ b/maven-resolver-transport-apache/src/main/java/org/eclipse/aether/transport/apache/ApacheTransporterFactory.java
@@ -18,10 +18,12 @@
*/
package org.eclipse.aether.transport.apache;
+import javax.inject.Inject;
import javax.inject.Named;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporter;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporterFactory;
import org.eclipse.aether.transfer.NoTransporterException;
@@ -38,6 +40,13 @@ public final class ApacheTransporterFactory implements HttpTransporterFactory {
private float priority = 5.0f;
+ private final ChecksumExtractor checksumExtractor;
+
+ @Inject
+ public ApacheTransporterFactory(ChecksumExtractor checksumExtractor) {
+ this.checksumExtractor = requireNonNull(checksumExtractor, "checksumExtractor");
+ }
+
@Override
public float getPriority() {
return priority;
@@ -60,6 +69,6 @@ public final class ApacheTransporterFactory implements HttpTransporterFactory {
requireNonNull(session, "session cannot be null");
requireNonNull(repository, "repository cannot be null");
- return new ApacheTransporter(repository, session);
+ return new ApacheTransporter(repository, session, checksumExtractor);
}
}
diff --git a/maven-resolver-transport-apache/src/test/java/org/eclipse/aether/transport/apache/ApacheTransporterTest.java b/maven-resolver-transport-apache/src/test/java/org/eclipse/aether/transport/apache/ApacheTransporterTest.java
index d0bce405..a3a8d2ed 100644
--- a/maven-resolver-transport-apache/src/test/java/org/eclipse/aether/transport/apache/ApacheTransporterTest.java
+++ b/maven-resolver-transport-apache/src/test/java/org/eclipse/aether/transport/apache/ApacheTransporterTest.java
@@ -42,7 +42,7 @@ import static org.junit.jupiter.api.Assertions.*;
class ApacheTransporterTest extends HttpTransporterTest {
public ApacheTransporterTest() {
- super(ApacheTransporterFactory::new);
+ super(() -> new ApacheTransporterFactory(standardChecksumExtractor()));
}
@Test
diff --git a/maven-resolver-transport-classpath/pom.xml b/maven-resolver-transport-classpath/pom.xml
index 5d13c007..872ee90d 100644
--- a/maven-resolver-transport-classpath/pom.xml
+++ b/maven-resolver-transport-classpath/pom.xml
@@ -55,11 +55,7 @@
<scope>provided</scope>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.inject</groupId>
- <artifactId>guice</artifactId>
- <scope>test</scope>
- </dependency>
+
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
diff --git a/maven-resolver-transport-file/pom.xml b/maven-resolver-transport-file/pom.xml
index 5664ea7f..1f19bdf5 100644
--- a/maven-resolver-transport-file/pom.xml
+++ b/maven-resolver-transport-file/pom.xml
@@ -45,17 +45,17 @@
<groupId>org.apache.maven.resolver</groupId>
<artifactId>maven-resolver-spi</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ </dependency>
<dependency>
<groupId>javax.inject</groupId>
<artifactId>javax.inject</artifactId>
<scope>provided</scope>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.inject</groupId>
- <artifactId>guice</artifactId>
- <scope>test</scope>
- </dependency>
+
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
@@ -66,10 +66,6 @@
<artifactId>maven-resolver-test-util</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
diff --git a/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporter.java b/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporter.java
index 99688950..29b4e24a 100644
--- a/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporter.java
+++ b/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporter.java
@@ -44,9 +44,9 @@ import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.concurrent.Semaphore;
+import java.util.function.Function;
import java.util.function.Supplier;
import java.util.regex.Matcher;
-import java.util.regex.Pattern;
import org.eclipse.aether.ConfigurationProperties;
import org.eclipse.aether.RepositorySystemSession;
@@ -57,6 +57,7 @@ import org.eclipse.aether.spi.connector.transport.GetTask;
import org.eclipse.aether.spi.connector.transport.PeekTask;
import org.eclipse.aether.spi.connector.transport.PutTask;
import org.eclipse.aether.spi.connector.transport.TransportTask;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporter;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporterException;
import org.eclipse.aether.transfer.NoTransporterException;
@@ -65,6 +66,7 @@ import org.eclipse.aether.util.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import static org.eclipse.aether.spi.connector.transport.http.HttpConstants.*;
import static org.eclipse.aether.transport.jdk.JdkTransporterConfigurationKeys.*;
/**
@@ -80,32 +82,9 @@ final class JdkTransporter extends AbstractTransporter implements HttpTransporte
"EEE, dd MMM yyyy HH:mm:ss z", Locale.ENGLISH)
.withZone(ZoneId.of("GMT"));
- private static final int MULTIPLE_CHOICES = 300;
-
- private static final int NOT_FOUND = 404;
-
- private static final int PRECONDITION_FAILED = 412;
-
private static final long MODIFICATION_THRESHOLD = 60L * 1000L;
- private static final String ACCEPT_ENCODING = "Accept-Encoding";
-
- private static final String CACHE_CONTROL = "Cache-Control";
-
- private static final String CONTENT_LENGTH = "Content-Length";
-
- private static final String CONTENT_RANGE = "Content-Range";
-
- private static final String IF_UNMODIFIED_SINCE = "If-Unmodified-Since";
-
- private static final String RANGE = "Range";
-
- private static final String USER_AGENT = "User-Agent";
-
- private static final String LAST_MODIFIED = "Last-Modified";
-
- private static final Pattern CONTENT_RANGE_PATTERN =
- Pattern.compile("\\s*bytes\\s+([0-9]+)\\s*-\\s*([0-9]+)\\s*/.*");
+ private final ChecksumExtractor checksumExtractor;
private final URI baseUri;
@@ -119,8 +98,13 @@ final class JdkTransporter extends AbstractTransporter implements HttpTransporte
private final Semaphore maxConcurrentRequests;
- JdkTransporter(RepositorySystemSession session, RemoteRepository repository, int javaVersion)
+ JdkTransporter(
+ RepositorySystemSession session,
+ RemoteRepository repository,
+ int javaVersion,
+ ChecksumExtractor checksumExtractor)
throws NoTransporterException {
+ this.checksumExtractor = checksumExtractor;
try {
URI uri = new URI(repository.getUrl()).parseServerAuthority();
if (uri.isOpaque()) {
@@ -324,13 +308,8 @@ final class JdkTransporter extends AbstractTransporter implements HttpTransporte
}
}
}
- Map<String, String> checksums = extractXChecksums(response);
- if (checksums != null) {
- checksums.forEach(task::setChecksum);
- return;
- }
- checksums = extractNexus2Checksums(response);
- if (checksums != null) {
+ Map<String, String> checksums = checksumExtractor.extractChecksums(headerGetter(response));
+ if (checksums != null && !checksums.isEmpty()) {
checksums.forEach(task::setChecksum);
}
} finally {
@@ -338,6 +317,10 @@ final class JdkTransporter extends AbstractTransporter implements HttpTransporte
}
}
+ private static Function<String, String> headerGetter(HttpResponse<?> response) {
+ return s -> response.headers().firstValue(s).orElse(null);
+ }
+
private void closeBody(HttpResponse<InputStream> streamHttpResponse) throws IOException {
if (streamHttpResponse != null) {
InputStream body = streamHttpResponse.body();
@@ -385,48 +368,6 @@ final class JdkTransporter extends AbstractTransporter implements HttpTransporte
// no-op
}
- private Map<String, String> extractXChecksums(HttpResponse<?> response) {
- String value;
- HashMap<String, String> result = new HashMap<>();
- // Central style: x-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
- value = response.headers().firstValue("x-checksum-sha1").orElse(null);
- if (value != null) {
- result.put("SHA-1", value);
- }
- // Central style: x-checksum-md5: 9ad0d8e3482767c122e85f83567b8ce6
- value = response.headers().firstValue("x-checksum-md5").orElse(null);
- if (value != null) {
- result.put("MD5", value);
- }
- if (!result.isEmpty()) {
- return result;
- }
- // Google style: x-goog-meta-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
- value = response.headers().firstValue("x-goog-meta-checksum-sha1").orElse(null);
- if (value != null) {
- result.put("SHA-1", value);
- }
- // Central style: x-goog-meta-checksum-sha1: 9ad0d8e3482767c122e85f83567b8ce6
- value = response.headers().firstValue("x-goog-meta-checksum-md5").orElse(null);
- if (value != null) {
- result.put("MD5", value);
- }
-
- return result.isEmpty() ? null : result;
- }
-
- private Map<String, String> extractNexus2Checksums(HttpResponse<?> response) {
- // Nexus-style, ETag: "{SHA1{d40d68ba1f88d8e9b0040f175a6ff41928abd5e7}}"
- String etag = response.headers().firstValue("ETag").orElse(null);
- if (etag != null) {
- int start = etag.indexOf("SHA1{"), end = etag.indexOf("}", start + 5);
- if (start >= 0 && end > start) {
- return Collections.singletonMap("SHA-1", etag.substring(start + 5, end));
- }
- }
- return null;
- }
-
private InetAddress getHttpLocalAddress(RepositorySystemSession session, RemoteRepository repository) {
String bindAddress = ConfigUtils.getString(
session,
diff --git a/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporterFactory.java b/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporterFactory.java
index 988fd65b..2d048a79 100644
--- a/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporterFactory.java
+++ b/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/main/java/org/eclipse/aether/transport/jdk/JdkTransporterFactory.java
@@ -18,10 +18,12 @@
*/
package org.eclipse.aether.transport.jdk;
+import javax.inject.Inject;
import javax.inject.Named;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporter;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporterFactory;
import org.eclipse.aether.transfer.NoTransporterException;
@@ -39,6 +41,13 @@ public final class JdkTransporterFactory implements HttpTransporterFactory {
private float priority = 10.0f;
+ private final ChecksumExtractor checksumExtractor;
+
+ @Inject
+ public JdkTransporterFactory(ChecksumExtractor checksumExtractor) {
+ this.checksumExtractor = requireNonNull(checksumExtractor, "checksumExtractor");
+ }
+
@Override
public float getPriority() {
return priority;
@@ -59,7 +68,7 @@ public final class JdkTransporterFactory implements HttpTransporterFactory {
throw new NoTransporterException(repository, "Only HTTP/HTTPS is supported");
}
- return new JdkTransporter(session, repository, javaVersion());
+ return new JdkTransporter(session, repository, javaVersion(), checksumExtractor);
}
private static int javaVersion() {
diff --git a/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/test/java/org/eclipse/aether/transport/jdk/JdkTransporterTest.java b/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/test/java/org/eclipse/aether/transport/jdk/JdkTransporterTest.java
index 72a2b759..3dc2eaed 100644
--- a/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/test/java/org/eclipse/aether/transport/jdk/JdkTransporterTest.java
+++ b/maven-resolver-transport-jdk-parent/maven-resolver-transport-jdk-11/src/test/java/org/eclipse/aether/transport/jdk/JdkTransporterTest.java
@@ -84,14 +84,14 @@ class JdkTransporterTest extends HttpTransporterTest {
protected void testPut_Authenticated_ExpectContinueRejected_ExplicitlyConfiguredHeader() {}
public JdkTransporterTest() {
- super(JdkTransporterFactory::new);
+ super(() -> new JdkTransporterFactory(standardChecksumExtractor()));
}
@Test
void enhanceConnectExceptionMessages() {
String uri = "https://localhost:12345/";
RemoteRepository remoteRepository = new RemoteRepository.Builder("central", "default", uri).build();
- JdkTransporterFactory factory = new JdkTransporterFactory();
+ JdkTransporterFactory factory = new JdkTransporterFactory(s -> null);
try (Transporter transporter = factory.newInstance(TestUtils.newSession(), remoteRepository)) {
transporter.peek(new PeekTask(URI.create("repo/file.txt")));
diff --git a/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporter.java b/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporter.java
index 398feda6..6050d884 100644
--- a/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporter.java
+++ b/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporter.java
@@ -37,8 +37,8 @@ import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
import java.util.regex.Matcher;
-import java.util.regex.Pattern;
import org.eclipse.aether.ConfigurationProperties;
import org.eclipse.aether.RepositorySystemSession;
@@ -49,6 +49,7 @@ import org.eclipse.aether.spi.connector.transport.GetTask;
import org.eclipse.aether.spi.connector.transport.PeekTask;
import org.eclipse.aether.spi.connector.transport.PutTask;
import org.eclipse.aether.spi.connector.transport.TransportTask;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporter;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporterException;
import org.eclipse.aether.transfer.NoTransporterException;
@@ -72,36 +73,17 @@ import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import static org.eclipse.aether.spi.connector.transport.http.HttpConstants.*;
+
/**
* A transporter for HTTP/HTTPS.
*
* @since 2.0.0
*/
final class JettyTransporter extends AbstractTransporter implements HttpTransporter {
- private static final int MULTIPLE_CHOICES = 300;
-
- private static final int NOT_FOUND = 404;
-
- private static final int PRECONDITION_FAILED = 412;
-
private static final long MODIFICATION_THRESHOLD = 60L * 1000L;
- private static final String ACCEPT_ENCODING = "Accept-Encoding";
-
- private static final String CONTENT_LENGTH = "Content-Length";
-
- private static final String CONTENT_RANGE = "Content-Range";
-
- private static final String LAST_MODIFIED = "Last-Modified";
-
- private static final String IF_UNMODIFIED_SINCE = "If-Unmodified-Since";
-
- private static final String RANGE = "Range";
-
- private static final String USER_AGENT = "User-Agent";
-
- private static final Pattern CONTENT_RANGE_PATTERN =
- Pattern.compile("\\s*bytes\\s+([0-9]+)\\s*-\\s*([0-9]+)\\s*/.*");
+ private final ChecksumExtractor checksumExtractor;
private final URI baseUri;
@@ -119,7 +101,9 @@ final class JettyTransporter extends AbstractTransporter implements HttpTranspor
private final BasicAuthentication.BasicResult basicProxyAuthenticationResult;
- JettyTransporter(RepositorySystemSession session, RemoteRepository repository) throws NoTransporterException {
+ JettyTransporter(RepositorySystemSession session, RemoteRepository repository, ChecksumExtractor checksumExtractor)
+ throws NoTransporterException {
+ this.checksumExtractor = checksumExtractor;
try {
URI uri = new URI(repository.getUrl()).parseServerAuthority();
if (uri.isOpaque()) {
@@ -321,57 +305,14 @@ final class JettyTransporter extends AbstractTransporter implements HttpTranspor
}
}
}
- Map<String, String> checksums = extractXChecksums(response);
- if (checksums != null) {
+ Map<String, String> checksums = checksumExtractor.extractChecksums(headerGetter(response));
+ if (checksums != null && !checksums.isEmpty()) {
checksums.forEach(task::setChecksum);
- return;
}
- checksums = extractNexus2Checksums(response);
- if (checksums != null) {
- checksums.forEach(task::setChecksum);
- }
- }
-
- private static Map<String, String> extractXChecksums(Response response) {
- String value;
- HashMap<String, String> result = new HashMap<>();
- // Central style: x-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
- value = response.getHeaders().get("x-checksum-sha1");
- if (value != null) {
- result.put("SHA-1", value);
- }
- // Central style: x-checksum-md5: 9ad0d8e3482767c122e85f83567b8ce6
- value = response.getHeaders().get("x-checksum-md5");
- if (value != null) {
- result.put("MD5", value);
- }
- if (!result.isEmpty()) {
- return result;
- }
- // Google style: x-goog-meta-checksum-sha1: c74edb60ca2a0b57ef88d9a7da28f591e3d4ce7b
- value = response.getHeaders().get("x-goog-meta-checksum-sha1");
- if (value != null) {
- result.put("SHA-1", value);
- }
- // Central style: x-goog-meta-checksum-sha1: 9ad0d8e3482767c122e85f83567b8ce6
- value = response.getHeaders().get("x-goog-meta-checksum-md5");
- if (value != null) {
- result.put("MD5", value);
- }
-
- return result.isEmpty() ? null : result;
}
- private static Map<String, String> extractNexus2Checksums(Response response) {
- // Nexus-style, ETag: "{SHA1{d40d68ba1f88d8e9b0040f175a6ff41928abd5e7}}"
- String etag = response.getHeaders().get("ETag");
- if (etag != null) {
- int start = etag.indexOf("SHA1{"), end = etag.indexOf("}", start + 5);
- if (start >= 0 && end > start) {
- return Collections.singletonMap("SHA-1", etag.substring(start + 5, end));
- }
- }
- return null;
+ private static Function<String, String> headerGetter(Response response) {
+ return s -> response.getHeaders().get(s);
}
@Override
diff --git a/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporterFactory.java b/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporterFactory.java
index 216d3309..901d82d7 100644
--- a/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporterFactory.java
+++ b/maven-resolver-transport-jetty/src/main/java/org/eclipse/aether/transport/jetty/JettyTransporterFactory.java
@@ -18,10 +18,12 @@
*/
package org.eclipse.aether.transport.jetty;
+import javax.inject.Inject;
import javax.inject.Named;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.spi.connector.transport.http.ChecksumExtractor;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporter;
import org.eclipse.aether.spi.connector.transport.http.HttpTransporterFactory;
import org.eclipse.aether.transfer.NoTransporterException;
@@ -39,6 +41,13 @@ public final class JettyTransporterFactory implements HttpTransporterFactory {
private float priority = 15.0f;
+ private final ChecksumExtractor checksumExtractor;
+
+ @Inject
+ public JettyTransporterFactory(ChecksumExtractor checksumExtractor) {
+ this.checksumExtractor = requireNonNull(checksumExtractor, "checksumExtractor");
+ }
+
@Override
public float getPriority() {
return priority;
@@ -59,6 +68,6 @@ public final class JettyTransporterFactory implements HttpTransporterFactory {
throw new NoTransporterException(repository);
}
- return new JettyTransporter(session, repository);
+ return new JettyTransporter(session, repository, checksumExtractor);
}
}
diff --git a/maven-resolver-transport-jetty/src/test/java/org/eclipse/aether/transport/jetty/JettyTransporterTest.java b/maven-resolver-transport-jetty/src/test/java/org/eclipse/aether/transport/jetty/JettyTransporterTest.java
index 3eb92656..483f203f 100644
--- a/maven-resolver-transport-jetty/src/test/java/org/eclipse/aether/transport/jetty/JettyTransporterTest.java
+++ b/maven-resolver-transport-jetty/src/test/java/org/eclipse/aether/transport/jetty/JettyTransporterTest.java
@@ -58,6 +58,6 @@ class JettyTransporterTest extends HttpTransporterTest {
protected void testPut_Authenticated_ExpectContinueRejected_ExplicitlyConfiguredHeader() {}
public JettyTransporterTest() {
- super(JettyTransporterFactory::new);
+ super(() -> new JettyTransporterFactory(standardChecksumExtractor()));
}
}
diff --git a/maven-resolver-transport-wagon/pom.xml b/maven-resolver-transport-wagon/pom.xml
index d3037346..11ef0121 100644
--- a/maven-resolver-transport-wagon/pom.xml
+++ b/maven-resolver-transport-wagon/pom.xml
@@ -81,11 +81,7 @@
<artifactId>org.eclipse.sisu.plexus</artifactId>
<optional>true</optional>
</dependency>
- <dependency>
- <groupId>com.google.inject</groupId>
- <artifactId>guice</artifactId>
- <scope>test</scope>
- </dependency>
+
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>