Source code

001package org.eclipse.aether.internal.impl;
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 java.io.File;
023import java.io.IOException;
024import java.util.ArrayList;
025import java.util.Collection;
026import java.util.Collections;
027import java.util.Iterator;
028import java.util.List;
029import static java.util.Objects.requireNonNull;
030import java.util.concurrent.atomic.AtomicBoolean;
031
032import javax.inject.Inject;
033import javax.inject.Named;
034
035import org.eclipse.aether.RepositoryEvent;
036import org.eclipse.aether.RepositoryEvent.EventType;
037import org.eclipse.aether.RepositorySystemSession;
038import org.eclipse.aether.RequestTrace;
039import org.eclipse.aether.SyncContext;
040import org.eclipse.aether.artifact.Artifact;
041import org.eclipse.aether.artifact.ArtifactProperties;
042import org.eclipse.aether.impl.ArtifactResolver;
043import org.eclipse.aether.impl.OfflineController;
044import org.eclipse.aether.impl.RemoteRepositoryManager;
045import org.eclipse.aether.impl.RepositoryConnectorProvider;
046import org.eclipse.aether.impl.RepositoryEventDispatcher;
047import org.eclipse.aether.impl.SyncContextFactory;
048import org.eclipse.aether.impl.UpdateCheck;
049import org.eclipse.aether.impl.UpdateCheckManager;
050import org.eclipse.aether.impl.VersionResolver;
051import org.eclipse.aether.repository.ArtifactRepository;
052import org.eclipse.aether.repository.LocalArtifactRegistration;
053import org.eclipse.aether.repository.LocalArtifactRequest;
054import org.eclipse.aether.repository.LocalArtifactResult;
055import org.eclipse.aether.repository.LocalRepository;
056import org.eclipse.aether.repository.LocalRepositoryManager;
057import org.eclipse.aether.repository.RemoteRepository;
058import org.eclipse.aether.repository.RepositoryPolicy;
059import org.eclipse.aether.repository.WorkspaceReader;
060import org.eclipse.aether.resolution.ArtifactRequest;
061import org.eclipse.aether.resolution.ArtifactResolutionException;
062import org.eclipse.aether.resolution.ArtifactResult;
063import org.eclipse.aether.resolution.ResolutionErrorPolicy;
064import org.eclipse.aether.resolution.VersionRequest;
065import org.eclipse.aether.resolution.VersionResolutionException;
066import org.eclipse.aether.resolution.VersionResult;
067import org.eclipse.aether.spi.connector.ArtifactDownload;
068import org.eclipse.aether.spi.connector.RepositoryConnector;
069import org.eclipse.aether.spi.io.FileProcessor;
070import org.eclipse.aether.spi.locator.Service;
071import org.eclipse.aether.spi.locator.ServiceLocator;
072import org.eclipse.aether.spi.log.Logger;
073import org.eclipse.aether.spi.log.LoggerFactory;
074import org.eclipse.aether.spi.log.NullLoggerFactory;
075import org.eclipse.aether.transfer.ArtifactNotFoundException;
076import org.eclipse.aether.transfer.ArtifactTransferException;
077import org.eclipse.aether.transfer.NoRepositoryConnectorException;
078import org.eclipse.aether.transfer.RepositoryOfflineException;
079import org.eclipse.aether.util.ConfigUtils;
080
081/**
082 */
083@Named
084public class DefaultArtifactResolver
085    implements ArtifactResolver, Service
086{
087
088    private static final String CONFIG_PROP_SNAPSHOT_NORMALIZATION = "aether.artifactResolver.snapshotNormalization";
089
090    private Logger logger = NullLoggerFactory.LOGGER;
091
092    private FileProcessor fileProcessor;
093
094    private RepositoryEventDispatcher repositoryEventDispatcher;
095
096    private VersionResolver versionResolver;
097
098    private UpdateCheckManager updateCheckManager;
099
100    private RepositoryConnectorProvider repositoryConnectorProvider;
101
102    private RemoteRepositoryManager remoteRepositoryManager;
103
104    private SyncContextFactory syncContextFactory;
105
106    private OfflineController offlineController;
107
108    public DefaultArtifactResolver()
109    {
110        // enables default constructor
111    }
112
113    @Inject
114    DefaultArtifactResolver( FileProcessor fileProcessor, RepositoryEventDispatcher repositoryEventDispatcher,
115                             VersionResolver versionResolver, UpdateCheckManager updateCheckManager,
116                             RepositoryConnectorProvider repositoryConnectorProvider,
117                             RemoteRepositoryManager remoteRepositoryManager, SyncContextFactory syncContextFactory,
118                             OfflineController offlineController, LoggerFactory loggerFactory )
119    {
120        setFileProcessor( fileProcessor );
121        setRepositoryEventDispatcher( repositoryEventDispatcher );
122        setVersionResolver( versionResolver );
123        setUpdateCheckManager( updateCheckManager );
124        setRepositoryConnectorProvider( repositoryConnectorProvider );
125        setRemoteRepositoryManager( remoteRepositoryManager );
126        setSyncContextFactory( syncContextFactory );
127        setOfflineController( offlineController );
128        setLoggerFactory( loggerFactory );
129    }
130
131    public void initService( ServiceLocator locator )
132    {
133        setLoggerFactory( locator.getService( LoggerFactory.class ) );
134        setFileProcessor( locator.getService( FileProcessor.class ) );
135        setRepositoryEventDispatcher( locator.getService( RepositoryEventDispatcher.class ) );
136        setVersionResolver( locator.getService( VersionResolver.class ) );
137        setUpdateCheckManager( locator.getService( UpdateCheckManager.class ) );
138        setRepositoryConnectorProvider( locator.getService( RepositoryConnectorProvider.class ) );
139        setRemoteRepositoryManager( locator.getService( RemoteRepositoryManager.class ) );
140        setSyncContextFactory( locator.getService( SyncContextFactory.class ) );
141        setOfflineController( locator.getService( OfflineController.class ) );
142    }
143
144    public DefaultArtifactResolver setLoggerFactory( LoggerFactory loggerFactory )
145    {
146        this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() );
147        return this;
148    }
149
150    public DefaultArtifactResolver setFileProcessor( FileProcessor fileProcessor )
151    {
152        this.fileProcessor = requireNonNull( fileProcessor, "file processor cannot be null" );
153        return this;
154    }
155
156    public DefaultArtifactResolver setRepositoryEventDispatcher( RepositoryEventDispatcher repositoryEventDispatcher )
157    {
158        this.repositoryEventDispatcher = requireNonNull( repositoryEventDispatcher, "repository event dispatcher cannot be null" );
159        return this;
160    }
161
162    public DefaultArtifactResolver setVersionResolver( VersionResolver versionResolver )
163    {
164        this.versionResolver = requireNonNull( versionResolver, "version resolver cannot be null" );
165        return this;
166    }
167
168    public DefaultArtifactResolver setUpdateCheckManager( UpdateCheckManager updateCheckManager )
169    {
170        this.updateCheckManager = requireNonNull( updateCheckManager, "update check manager cannot be null" );
171        return this;
172    }
173
174    public DefaultArtifactResolver setRepositoryConnectorProvider( RepositoryConnectorProvider repositoryConnectorProvider )
175    {
176        this.repositoryConnectorProvider = requireNonNull( repositoryConnectorProvider, "repository connector provider cannot be null" );
177        return this;
178    }
179
180    public DefaultArtifactResolver setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager )
181    {
182        this.remoteRepositoryManager = requireNonNull( remoteRepositoryManager, "remote repository provider cannot be null" );
183        return this;
184    }
185
186    public DefaultArtifactResolver setSyncContextFactory( SyncContextFactory syncContextFactory )
187    {
188        this.syncContextFactory = requireNonNull( syncContextFactory, "sync context factory cannot be null" );
189        return this;
190    }
191
192    public DefaultArtifactResolver setOfflineController( OfflineController offlineController )
193    {
194        this.offlineController = requireNonNull( offlineController, "offline controller cannot be null" );
195        return this;
196    }
197
198    public ArtifactResult resolveArtifact( RepositorySystemSession session, ArtifactRequest request )
199        throws ArtifactResolutionException
200    {
201        return resolveArtifacts( session, Collections.singleton( request ) ).get( 0 );
202    }
203
204    public List<ArtifactResult> resolveArtifacts( RepositorySystemSession session,
205                                                  Collection<? extends ArtifactRequest> requests )
206        throws ArtifactResolutionException
207    {
208        SyncContext syncContext = syncContextFactory.newInstance( session, false );
209
210        try
211        {
212            Collection<Artifact> artifacts = new ArrayList<Artifact>( requests.size() );
213            for ( ArtifactRequest request : requests )
214            {
215                if ( request.getArtifact().getProperty( ArtifactProperties.LOCAL_PATH, null ) != null )
216                {
217                    continue;
218                }
219                artifacts.add( request.getArtifact() );
220            }
221
222            syncContext.acquire( artifacts, null );
223
224            return resolve( session, requests );
225        }
226        finally
227        {
228            syncContext.close();
229        }
230    }
231
232    private List<ArtifactResult> resolve( RepositorySystemSession session,
233                                          Collection<? extends ArtifactRequest> requests )
234        throws ArtifactResolutionException
235    {
236        List<ArtifactResult> results = new ArrayList<ArtifactResult>( requests.size() );
237        boolean failures = false;
238
239        LocalRepositoryManager lrm = session.getLocalRepositoryManager();
240        WorkspaceReader workspace = session.getWorkspaceReader();
241
242        List<ResolutionGroup> groups = new ArrayList<ResolutionGroup>();
243
244        for ( ArtifactRequest request : requests )
245        {
246            RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
247
248            ArtifactResult result = new ArtifactResult( request );
249            results.add( result );
250
251            Artifact artifact = request.getArtifact();
252            List<RemoteRepository> repos = request.getRepositories();
253
254            artifactResolving( session, trace, artifact );
255
256            String localPath = artifact.getProperty( ArtifactProperties.LOCAL_PATH, null );
257            if ( localPath != null )
258            {
259                // unhosted artifact, just validate file
260                File file = new File( localPath );
261                if ( !file.isFile() )
262                {
263                    failures = true;
264                    result.addException( new ArtifactNotFoundException( artifact, null ) );
265                }
266                else
267                {
268                    artifact = artifact.setFile( file );
269                    result.setArtifact( artifact );
270                    artifactResolved( session, trace, artifact, null, result.getExceptions() );
271                }
272                continue;
273            }
274
275            VersionResult versionResult;
276            try
277            {
278                VersionRequest versionRequest = new VersionRequest( artifact, repos, request.getRequestContext() );
279                versionRequest.setTrace( trace );
280                versionResult = versionResolver.resolveVersion( session, versionRequest );
281            }
282            catch ( VersionResolutionException e )
283            {
284                result.addException( e );
285                continue;
286            }
287
288            artifact = artifact.setVersion( versionResult.getVersion() );
289
290            if ( versionResult.getRepository() != null )
291            {
292                if ( versionResult.getRepository() instanceof RemoteRepository )
293                {
294                    repos = Collections.singletonList( (RemoteRepository) versionResult.getRepository() );
295                }
296                else
297                {
298                    repos = Collections.emptyList();
299                }
300            }
301
302            if ( workspace != null )
303            {
304                File file = workspace.findArtifact( artifact );
305                if ( file != null )
306                {
307                    artifact = artifact.setFile( file );
308                    result.setArtifact( artifact );
309                    result.setRepository( workspace.getRepository() );
310                    artifactResolved( session, trace, artifact, result.getRepository(), null );
311                    continue;
312                }
313            }
314
315            LocalArtifactResult local =
316                lrm.find( session, new LocalArtifactRequest( artifact, repos, request.getRequestContext() ) );
317            if ( isLocallyInstalled( local, versionResult ) )
318            {
319                if ( local.getRepository() != null )
320                {
321                    result.setRepository( local.getRepository() );
322                }
323                else
324                {
325                    result.setRepository( lrm.getRepository() );
326                }
327                try
328                {
329                    artifact = artifact.setFile( getFile( session, artifact, local.getFile() ) );
330                    result.setArtifact( artifact );
331                    artifactResolved( session, trace, artifact, result.getRepository(), null );
332                }
333                catch ( ArtifactTransferException e )
334                {
335                    result.addException( e );
336                }
337                if ( !local.isAvailable() )
338                {
339                    /*
340                     * NOTE: Interop with simple local repository: An artifact installed by a simple local repo manager
341                     * will not show up in the repository tracking file of the enhanced local repository. If however the
342                     * maven-metadata-local.xml tells us the artifact was installed locally, we sync the repository
343                     * tracking file.
344                     */
345                    lrm.add( session, new LocalArtifactRegistration( artifact ) );
346                }
347                continue;
348            }
349            else if ( local.getFile() != null )
350            {
351                logger.debug( "Verifying availability of " + local.getFile() + " from " + repos );
352            }
353
354            AtomicBoolean resolved = new AtomicBoolean( false );
355            Iterator<ResolutionGroup> groupIt = groups.iterator();
356            for ( RemoteRepository repo : repos )
357            {
358                if ( !repo.getPolicy( artifact.isSnapshot() ).isEnabled() )
359                {
360                    continue;
361                }
362
363                try
364                {
365                    Utils.checkOffline( session, offlineController, repo );
366                }
367                catch ( RepositoryOfflineException e )
368                {
369                    Exception exception =
370                        new ArtifactNotFoundException( artifact, repo, "Cannot access " + repo.getId() + " ("
371                            + repo.getUrl() + ") in offline mode and the artifact " + artifact
372                            + " has not been downloaded from it before.", e );
373                    result.addException( exception );
374                    continue;
375                }
376
377                ResolutionGroup group = null;
378                while ( groupIt.hasNext() )
379                {
380                    ResolutionGroup t = groupIt.next();
381                    if ( t.matches( repo ) )
382                    {
383                        group = t;
384                        break;
385                    }
386                }
387                if ( group == null )
388                {
389                    group = new ResolutionGroup( repo );
390                    groups.add( group );
391                    groupIt = Collections.<ResolutionGroup>emptyList().iterator();
392                }
393                group.items.add( new ResolutionItem( trace, artifact, resolved, result, local, repo ) );
394            }
395        }
396
397        for ( ResolutionGroup group : groups )
398        {
399            performDownloads( session, group );
400        }
401
402        for ( ArtifactResult result : results )
403        {
404            ArtifactRequest request = result.getRequest();
405
406            Artifact artifact = result.getArtifact();
407            if ( artifact == null || artifact.getFile() == null )
408            {
409                failures = true;
410                if ( result.getExceptions().isEmpty() )
411                {
412                    Exception exception = new ArtifactNotFoundException( request.getArtifact(), null );
413                    result.addException( exception );
414                }
415                RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
416                artifactResolved( session, trace, request.getArtifact(), null, result.getExceptions() );
417            }
418        }
419
420        if ( failures )
421        {
422            throw new ArtifactResolutionException( results );
423        }
424
425        return results;
426    }
427
428    private boolean isLocallyInstalled( LocalArtifactResult lar, VersionResult vr )
429    {
430        if ( lar.isAvailable() )
431        {
432            return true;
433        }
434        if ( lar.getFile() != null )
435        {
436            if ( vr.getRepository() instanceof LocalRepository )
437            {
438                // resolution of (snapshot) version found locally installed artifact
439                return true;
440            }
441            else if ( vr.getRepository() == null && lar.getRequest().getRepositories().isEmpty() )
442            {
443                // resolution of version range found locally installed artifact
444                return true;
445            }
446        }
447        return false;
448    }
449
450    private File getFile( RepositorySystemSession session, Artifact artifact, File file )
451        throws ArtifactTransferException
452    {
453        if ( artifact.isSnapshot() && !artifact.getVersion().equals( artifact.getBaseVersion() )
454            && ConfigUtils.getBoolean( session, true, CONFIG_PROP_SNAPSHOT_NORMALIZATION ) )
455        {
456            String name = file.getName().replace( artifact.getVersion(), artifact.getBaseVersion() );
457            File dst = new File( file.getParent(), name );
458
459            boolean copy = dst.length() != file.length() || dst.lastModified() != file.lastModified();
460            if ( copy )
461            {
462                try
463                {
464                    fileProcessor.copy( file, dst );
465                    dst.setLastModified( file.lastModified() );
466                }
467                catch ( IOException e )
468                {
469                    throw new ArtifactTransferException( artifact, null, e );
470                }
471            }
472
473            file = dst;
474        }
475
476        return file;
477    }
478
479    private void performDownloads( RepositorySystemSession session, ResolutionGroup group )
480    {
481        List<ArtifactDownload> downloads = gatherDownloads( session, group );
482        if ( downloads.isEmpty() )
483        {
484            return;
485        }
486
487        for ( ArtifactDownload download : downloads )
488        {
489            artifactDownloading( session, download.getTrace(), download.getArtifact(), group.repository );
490        }
491
492        try
493        {
494            RepositoryConnector connector =
495                repositoryConnectorProvider.newRepositoryConnector( session, group.repository );
496            try
497            {
498                connector.get( downloads, null );
499            }
500            finally
501            {
502                connector.close();
503            }
504        }
505        catch ( NoRepositoryConnectorException e )
506        {
507            for ( ArtifactDownload download : downloads )
508            {
509                download.setException( new ArtifactTransferException( download.getArtifact(), group.repository, e ) );
510            }
511        }
512
513        evaluateDownloads( session, group );
514    }
515
516    private List<ArtifactDownload> gatherDownloads( RepositorySystemSession session, ResolutionGroup group )
517    {
518        LocalRepositoryManager lrm = session.getLocalRepositoryManager();
519        List<ArtifactDownload> downloads = new ArrayList<ArtifactDownload>();
520
521        for ( ResolutionItem item : group.items )
522        {
523            Artifact artifact = item.artifact;
524
525            if ( item.resolved.get() )
526            {
527                // resolved in previous resolution group
528                continue;
529            }
530
531            ArtifactDownload download = new ArtifactDownload();
532            download.setArtifact( artifact );
533            download.setRequestContext( item.request.getRequestContext() );
534            download.setListener( SafeTransferListener.wrap( session, logger ) );
535            download.setTrace( item.trace );
536            if ( item.local.getFile() != null )
537            {
538                download.setFile( item.local.getFile() );
539                download.setExistenceCheck( true );
540            }
541            else
542            {
543                String path =
544                    lrm.getPathForRemoteArtifact( artifact, group.repository, item.request.getRequestContext() );
545                download.setFile( new File( lrm.getRepository().getBasedir(), path ) );
546            }
547
548            boolean snapshot = artifact.isSnapshot();
549            RepositoryPolicy policy =
550                remoteRepositoryManager.getPolicy( session, group.repository, !snapshot, snapshot );
551
552            int errorPolicy = Utils.getPolicy( session, artifact, group.repository );
553            if ( ( errorPolicy & ResolutionErrorPolicy.CACHE_ALL ) != 0 )
554            {
555                UpdateCheck<Artifact, ArtifactTransferException> check =
556                    new UpdateCheck<Artifact, ArtifactTransferException>();
557                check.setItem( artifact );
558                check.setFile( download.getFile() );
559                check.setFileValid( false );
560                check.setRepository( group.repository );
561                check.setPolicy( policy.getUpdatePolicy() );
562                item.updateCheck = check;
563                updateCheckManager.checkArtifact( session, check );
564                if ( !check.isRequired() )
565                {
566                    item.result.addException( check.getException() );
567                    continue;
568                }
569            }
570
571            download.setChecksumPolicy( policy.getChecksumPolicy() );
572            download.setRepositories( item.repository.getMirroredRepositories() );
573            downloads.add( download );
574            item.download = download;
575        }
576
577        return downloads;
578    }
579
580    private void evaluateDownloads( RepositorySystemSession session, ResolutionGroup group )
581    {
582        LocalRepositoryManager lrm = session.getLocalRepositoryManager();
583
584        for ( ResolutionItem item : group.items )
585        {
586            ArtifactDownload download = item.download;
587            if ( download == null )
588            {
589                continue;
590            }
591
592            Artifact artifact = download.getArtifact();
593            if ( download.getException() == null )
594            {
595                item.resolved.set( true );
596                item.result.setRepository( group.repository );
597                try
598                {
599                    artifact = artifact.setFile( getFile( session, artifact, download.getFile() ) );
600                    item.result.setArtifact( artifact );
601
602                    lrm.add( session,
603                             new LocalArtifactRegistration( artifact, group.repository, download.getSupportedContexts() ) );
604                }
605                catch ( ArtifactTransferException e )
606                {
607                    download.setException( e );
608                    item.result.addException( e );
609                }
610            }
611            else
612            {
613                item.result.addException( download.getException() );
614            }
615
616            /*
617             * NOTE: Touch after registration with local repo to ensure concurrent resolution is not rejected with
618             * "already updated" via session data when actual update to local repo is still pending.
619             */
620            if ( item.updateCheck != null )
621            {
622                item.updateCheck.setException( download.getException() );
623                updateCheckManager.touchArtifact( session, item.updateCheck );
624            }
625
626            artifactDownloaded( session, download.getTrace(), artifact, group.repository, download.getException() );
627            if ( download.getException() == null )
628            {
629                artifactResolved( session, download.getTrace(), artifact, group.repository, null );
630            }
631        }
632    }
633
634    private void artifactResolving( RepositorySystemSession session, RequestTrace trace, Artifact artifact )
635    {
636        RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.ARTIFACT_RESOLVING );
637        event.setTrace( trace );
638        event.setArtifact( artifact );
639
640        repositoryEventDispatcher.dispatch( event.build() );
641    }
642
643    private void artifactResolved( RepositorySystemSession session, RequestTrace trace, Artifact artifact,
644                                   ArtifactRepository repository, List<Exception> exceptions )
645    {
646        RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.ARTIFACT_RESOLVED );
647        event.setTrace( trace );
648        event.setArtifact( artifact );
649        event.setRepository( repository );
650        event.setExceptions( exceptions );
651        if ( artifact != null )
652        {
653            event.setFile( artifact.getFile() );
654        }
655
656        repositoryEventDispatcher.dispatch( event.build() );
657    }
658
659    private void artifactDownloading( RepositorySystemSession session, RequestTrace trace, Artifact artifact,
660                                      RemoteRepository repository )
661    {
662        RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.ARTIFACT_DOWNLOADING );
663        event.setTrace( trace );
664        event.setArtifact( artifact );
665        event.setRepository( repository );
666
667        repositoryEventDispatcher.dispatch( event.build() );
668    }
669
670    private void artifactDownloaded( RepositorySystemSession session, RequestTrace trace, Artifact artifact,
671                                     RemoteRepository repository, Exception exception )
672    {
673        RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.ARTIFACT_DOWNLOADED );
674        event.setTrace( trace );
675        event.setArtifact( artifact );
676        event.setRepository( repository );
677        event.setException( exception );
678        if ( artifact != null )
679        {
680            event.setFile( artifact.getFile() );
681        }
682
683        repositoryEventDispatcher.dispatch( event.build() );
684    }
685
686    static class ResolutionGroup
687    {
688
689        final RemoteRepository repository;
690
691        final List<ResolutionItem> items = new ArrayList<ResolutionItem>();
692
693        ResolutionGroup( RemoteRepository repository )
694        {
695            this.repository = repository;
696        }
697
698        boolean matches( RemoteRepository repo )
699        {
700            return repository.getUrl().equals( repo.getUrl() )
701                && repository.getContentType().equals( repo.getContentType() )
702                && repository.isRepositoryManager() == repo.isRepositoryManager();
703        }
704
705    }
706
707    static class ResolutionItem
708    {
709
710        final RequestTrace trace;
711
712        final ArtifactRequest request;
713
714        final ArtifactResult result;
715
716        final LocalArtifactResult local;
717
718        final RemoteRepository repository;
719
720        final Artifact artifact;
721
722        final AtomicBoolean resolved;
723
724        ArtifactDownload download;
725
726        UpdateCheck<Artifact, ArtifactTransferException> updateCheck;
727
728        ResolutionItem( RequestTrace trace, Artifact artifact, AtomicBoolean resolved, ArtifactResult result,
729                        LocalArtifactResult local, RemoteRepository repository )
730        {
731            this.trace = trace;
732            this.artifact = artifact;
733            this.resolved = resolved;
734            this.result = result;
735            this.request = result.getRequest();
736            this.local = local;
737            this.repository = repository;
738        }
739
740    }
741
742}