001package org.eclipse.aether.connector.basic;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 * 
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 * 
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import javax.inject.Inject;
023import javax.inject.Named;
024
025import org.eclipse.aether.RepositorySystemSession;
026import org.eclipse.aether.repository.RemoteRepository;
027import org.eclipse.aether.spi.connector.RepositoryConnector;
028import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
029import org.eclipse.aether.spi.connector.checksum.ChecksumPolicyProvider;
030import org.eclipse.aether.spi.connector.layout.RepositoryLayoutProvider;
031import org.eclipse.aether.spi.connector.transport.TransporterProvider;
032import org.eclipse.aether.spi.io.FileProcessor;
033import org.eclipse.aether.spi.locator.Service;
034import org.eclipse.aether.spi.locator.ServiceLocator;
035import org.eclipse.aether.spi.log.Logger;
036import org.eclipse.aether.spi.log.LoggerFactory;
037import org.eclipse.aether.spi.log.NullLoggerFactory;
038import org.eclipse.aether.transfer.NoRepositoryConnectorException;
039
040/**
041 * A repository connector factory that employs pluggable
042 * {@link org.eclipse.aether.spi.connector.transport.TransporterFactory transporters} and
043 * {@link org.eclipse.aether.spi.connector.layout.RepositoryLayoutFactory repository layouts} for the transfers.
044 */
045@Named( "basic" )
046public final class BasicRepositoryConnectorFactory
047    implements RepositoryConnectorFactory, Service
048{
049
050    private Logger logger = NullLoggerFactory.LOGGER;
051
052    private TransporterProvider transporterProvider;
053
054    private RepositoryLayoutProvider layoutProvider;
055
056    private ChecksumPolicyProvider checksumPolicyProvider;
057
058    private FileProcessor fileProcessor;
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    public BasicRepositoryConnectorFactory()
068    {
069        // enables default constructor
070    }
071
072    @Inject
073    BasicRepositoryConnectorFactory( TransporterProvider transporterProvider, RepositoryLayoutProvider layoutProvider,
074                                     ChecksumPolicyProvider checksumPolicyProvider, FileProcessor fileProcessor,
075                                     LoggerFactory loggerFactory )
076    {
077        setTransporterProvider( transporterProvider );
078        setRepositoryLayoutProvider( layoutProvider );
079        setChecksumPolicyProvider( checksumPolicyProvider );
080        setFileProcessor( fileProcessor );
081        setLoggerFactory( loggerFactory );
082    }
083
084    public void initService( ServiceLocator locator )
085    {
086        setLoggerFactory( locator.getService( LoggerFactory.class ) );
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    }
092
093    /**
094     * Sets the logger factory to use for this component.
095     * 
096     * @param loggerFactory The logger factory to use, may be {@code null} to disable logging.
097     * @return This component for chaining, never {@code null}.
098     */
099    public BasicRepositoryConnectorFactory setLoggerFactory( LoggerFactory loggerFactory )
100    {
101        this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, BasicRepositoryConnector.class );
102        return this;
103    }
104
105    /**
106     * Sets the transporter provider to use for this component.
107     * 
108     * @param transporterProvider The transporter provider to use, must not be {@code null}.
109     * @return This component for chaining, never {@code null}.
110     */
111    public BasicRepositoryConnectorFactory setTransporterProvider( TransporterProvider transporterProvider )
112    {
113        if ( transporterProvider == null )
114        {
115            throw new IllegalArgumentException( "transporter provider has not been specified" );
116        }
117        this.transporterProvider = transporterProvider;
118        return this;
119    }
120
121    /**
122     * Sets the repository layout provider to use for this component.
123     * 
124     * @param layoutProvider The repository layout provider to use, must not be {@code null}.
125     * @return This component for chaining, never {@code null}.
126     */
127    public BasicRepositoryConnectorFactory setRepositoryLayoutProvider( RepositoryLayoutProvider layoutProvider )
128    {
129        if ( layoutProvider == null )
130        {
131            throw new IllegalArgumentException( "repository layout provider has not been specified" );
132        }
133        this.layoutProvider = layoutProvider;
134        return this;
135    }
136
137    /**
138     * Sets the checksum policy provider to use for this component.
139     * 
140     * @param checksumPolicyProvider The checksum policy provider to use, must not be {@code null}.
141     * @return This component for chaining, never {@code null}.
142     */
143    public BasicRepositoryConnectorFactory setChecksumPolicyProvider( ChecksumPolicyProvider checksumPolicyProvider )
144    {
145        if ( checksumPolicyProvider == null )
146        {
147            throw new IllegalArgumentException( "checksum policy provider has not been specified" );
148        }
149        this.checksumPolicyProvider = checksumPolicyProvider;
150        return this;
151    }
152
153    /**
154     * Sets the file processor to use for this component.
155     * 
156     * @param fileProcessor The file processor to use, must not be {@code null}.
157     * @return This component for chaining, never {@code null}.
158     */
159    public BasicRepositoryConnectorFactory setFileProcessor( FileProcessor fileProcessor )
160    {
161        if ( fileProcessor == null )
162        {
163            throw new IllegalArgumentException( "file processor has not been specified" );
164        }
165        this.fileProcessor = fileProcessor;
166        return this;
167    }
168
169    public float getPriority()
170    {
171        return priority;
172    }
173
174    /**
175     * Sets the priority of this component.
176     * 
177     * @param priority The priority.
178     * @return This component for chaining, never {@code null}.
179     */
180    public BasicRepositoryConnectorFactory setPriority( float priority )
181    {
182        this.priority = priority;
183        return this;
184    }
185
186    public RepositoryConnector newInstance( RepositorySystemSession session, RemoteRepository repository )
187        throws NoRepositoryConnectorException
188    {
189        return new BasicRepositoryConnector( session, repository, transporterProvider, layoutProvider,
190                                             checksumPolicyProvider, fileProcessor, logger );
191    }
192
193}