001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, 013 * software distributed under the License is distributed on an 014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 015 * KIND, either express or implied. See the License for the 016 * specific language governing permissions and limitations 017 * under the License. 018 */ 019package org.eclipse.aether.connector.basic; 020 021import javax.inject.Inject; 022import javax.inject.Named; 023 024import java.util.Collections; 025import java.util.Map; 026 027import org.eclipse.aether.RepositorySystemSession; 028import org.eclipse.aether.repository.RemoteRepository; 029import org.eclipse.aether.spi.checksums.ProvidedChecksumsSource; 030import org.eclipse.aether.spi.connector.RepositoryConnector; 031import org.eclipse.aether.spi.connector.RepositoryConnectorFactory; 032import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider; 033import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider; 034import org.eclipse.aether.spi.connector.transport.TransporterProvider; 035import org.eclipse.aether.spi.io.FileProcessor; 036import org.eclipse.aether.spi.locator.Service; 037import org.eclipse.aether.spi.locator.ServiceLocator; 038import org.eclipse.aether.transfer.NoRepositoryConnectorException; 039 040import static java.util.Objects.requireNonNull; 041 042/** 043 * A repository connector factory that employs pluggable 044 * {@link org.eclipse.aether.spi.connector.transport.TransporterFactory transporters} and 045 * {@link org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory repository layouts} for the transfers. 046 */ 047@Named(BasicRepositoryConnectorFactory.NAME) 048public final class BasicRepositoryConnectorFactory implements RepositoryConnectorFactory, Service { 049 public static final String NAME = "basic"; 050 private TransporterProvider transporterProvider; 051 052 private RepositoryLayoutProvider layoutProvider; 053 054 private ChecksumPolicyProvider checksumPolicyProvider; 055 056 private FileProcessor fileProcessor; 057 058 private Map<String, ProvidedChecksumsSource> providedChecksumsSources; 059 060 private float priority; 061 062 /** 063 * Creates an (uninitialized) instance of this connector factory. <em>Note:</em> In case of manual instantiation by 064 * clients, the new factory needs to be configured via its various mutators before first use or runtime errors will 065 * occur. 066 */ 067 @Deprecated 068 public BasicRepositoryConnectorFactory() { 069 // enables default constructor 070 } 071 072 @Inject 073 public BasicRepositoryConnectorFactory( 074 TransporterProvider transporterProvider, 075 RepositoryLayoutProvider layoutProvider, 076 ChecksumPolicyProvider checksumPolicyProvider, 077 FileProcessor fileProcessor, 078 Map<String, ProvidedChecksumsSource> providedChecksumsSources) { 079 setTransporterProvider(transporterProvider); 080 setRepositoryLayoutProvider(layoutProvider); 081 setChecksumPolicyProvider(checksumPolicyProvider); 082 setFileProcessor(fileProcessor); 083 setProvidedChecksumSources(providedChecksumsSources); 084 } 085 086 public void initService(ServiceLocator locator) { 087 setTransporterProvider(locator.getService(TransporterProvider.class)); 088 setRepositoryLayoutProvider(locator.getService(RepositoryLayoutProvider.class)); 089 setChecksumPolicyProvider(locator.getService(ChecksumPolicyProvider.class)); 090 setFileProcessor(locator.getService(FileProcessor.class)); 091 setProvidedChecksumSources(Collections.emptyMap()); 092 } 093 094 /** 095 * Sets the transporter provider to use for this component. 096 * 097 * @param transporterProvider The transporter provider to use, must not be {@code null}. 098 * @return This component for chaining, never {@code null}. 099 */ 100 public BasicRepositoryConnectorFactory setTransporterProvider(TransporterProvider transporterProvider) { 101 this.transporterProvider = requireNonNull(transporterProvider, "transporter provider cannot be null"); 102 return this; 103 } 104 105 /** 106 * Sets the repository layout provider to use for this component. 107 * 108 * @param layoutProvider The repository layout provider to use, must not be {@code null}. 109 * @return This component for chaining, never {@code null}. 110 */ 111 public BasicRepositoryConnectorFactory setRepositoryLayoutProvider(RepositoryLayoutProvider layoutProvider) { 112 this.layoutProvider = requireNonNull(layoutProvider, "repository layout provider cannot be null"); 113 return this; 114 } 115 116 /** 117 * Sets the checksum policy provider to use for this component. 118 * 119 * @param checksumPolicyProvider The checksum policy provider to use, must not be {@code null}. 120 * @return This component for chaining, never {@code null}. 121 */ 122 public BasicRepositoryConnectorFactory setChecksumPolicyProvider(ChecksumPolicyProvider checksumPolicyProvider) { 123 this.checksumPolicyProvider = requireNonNull(checksumPolicyProvider, "checksum policy provider cannot be null"); 124 return this; 125 } 126 127 /** 128 * Sets the file processor to use for this component. 129 * 130 * @param fileProcessor The file processor to use, must not be {@code null}. 131 * @return This component for chaining, never {@code null}. 132 */ 133 public BasicRepositoryConnectorFactory setFileProcessor(FileProcessor fileProcessor) { 134 this.fileProcessor = requireNonNull(fileProcessor, "file processor cannot be null"); 135 return this; 136 } 137 138 /** 139 * Sets the provided checksum sources to use for this component. 140 * 141 * @param providedChecksumsSources The provided checksum sources to use, must not be {@code null}. 142 * @return This component for chaining, never {@code null}. 143 * @since 1.8.0 144 */ 145 public BasicRepositoryConnectorFactory setProvidedChecksumSources( 146 Map<String, ProvidedChecksumsSource> providedChecksumsSources) { 147 this.providedChecksumsSources = 148 requireNonNull(providedChecksumsSources, "provided checksum sources cannot be null"); 149 return this; 150 } 151 152 public float getPriority() { 153 return priority; 154 } 155 156 /** 157 * Sets the priority of this component. 158 * 159 * @param priority The priority. 160 * @return This component for chaining, never {@code null}. 161 */ 162 public BasicRepositoryConnectorFactory setPriority(float priority) { 163 this.priority = priority; 164 return this; 165 } 166 167 public RepositoryConnector newInstance(RepositorySystemSession session, RemoteRepository repository) 168 throws NoRepositoryConnectorException { 169 requireNonNull(session, "session cannot be null"); 170 requireNonNull(repository, "repository cannot be null"); 171 172 return new BasicRepositoryConnector( 173 session, 174 repository, 175 transporterProvider, 176 layoutProvider, 177 checksumPolicyProvider, 178 fileProcessor, 179 providedChecksumsSources); 180 } 181}