How to use

ArtifactResolutionException

in

org.eclipse.aether.resolution

@Override
public ModelSource resolveModel( String groupId, String artifactId, String version )
  throws UnresolvableModelException
{
  Artifact pomArtifact = new DefaultArtifact( groupId, artifactId, "", "pom", version );
  try
  {
    ArtifactRequest request = new ArtifactRequest( pomArtifact, repositories, context );
    request.setTrace( trace );
    pomArtifact = resolver.resolveArtifact( session, request ).getArtifact();
  }
  catch ( ArtifactResolutionException e )
  {
    throw new UnresolvableModelException( e.getMessage(), groupId, artifactId, version, e );
  }
  File pomFile = pomArtifact.getFile();
  return new FileModelSource( pomFile );
}

  VersionResult versionResult = versionResolver.resolveVersion( session, versionRequest );
  a = a.setVersion( versionResult.getVersion() );
  versionResult = versionResolver.resolveVersion( session, versionRequest );
  pomArtifact = pomArtifact.setVersion( versionResult.getVersion() );
if ( !visited.add( a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getBaseVersion() ) )
    new ArtifactRequest( pomArtifact, request.getRepositories(), request.getRequestContext() );
  resolveRequest.setTrace( trace );
  resolveResult = artifactResolver.resolveArtifact( session, resolveRequest );
  pomArtifact = resolveResult.getArtifact();
  result.setRepository( resolveResult.getRepository() );
  if ( e.getCause() instanceof ArtifactNotFoundException )
    missingDescriptor( session, trace, a, (Exception) e.getCause() );
    if ( ( getPolicy( session, a, request ) & ArtifactDescriptorPolicy.IGNORE_MISSING ) != 0 )
                               versionRangeResolver, remoteRepositoryManager,
                               request.getRepositories() ) );
  if ( resolveResult.getRepository() instanceof WorkspaceRepository )
    modelRequest.setPomFile( pomArtifact.getFile() );

  ArtifactRequest pomRequest = new ArtifactRequest();
  pomRequest.setArtifact( pomArtifact );
  pomRequest.setRepositories( config.repositories );
  ArtifactResult pomResult = repoSystem.resolveArtifact( config.session, pomRequest );
  pomArtifact = pomResult.getArtifact();
  localProject = pomResult.getRepository() instanceof WorkspaceRepository;
  if ( e.getResults().get( 0 ).isMissing() && allowStubModel )
                    "Error resolving project artifact: " + e.getMessage(), e );
File pomFile = pomArtifact.getFile();
  artifact.selectVersion( pomArtifact.getVersion() );
  artifact.setFile( pomFile );
  artifact.setResolved( true );

  ArtifactRequest artifactRequest = new ArtifactRequest();
  artifactRequest.setArtifact( RepositoryUtils.toArtifact( artifact ) );
  artifactRequest.setRepositories( RepositoryUtils.toRepos( remoteRepositories ) );
  if ( e.getCause() instanceof org.eclipse.aether.transfer.ArtifactNotFoundException )
    throw new ArtifactNotFoundException( e.getMessage(), artifact, remoteRepositories, e );
    throw new ArtifactResolutionException( e.getMessage(), artifact, remoteRepositories, e );
artifact.selectVersion( result.getArtifact().getVersion() );
artifact.setFile( result.getArtifact().getFile() );
artifact.setResolved( true );

protected File resolveArtifact(Artifact artifact) throws MojoExecutionException, DependencyCollectionException {
 ArtifactRequest request = new ArtifactRequest();
 request.setArtifact(artifact);
 request.setRepositories(remoteRepos);
 ArtifactResult result;
 try {
   result = repositorySystem.resolveArtifact(repoSession, request);
 } catch (ArtifactResolutionException e) {
   throw new MojoExecutionException(e.getMessage(), e);
 }
 return result.getArtifact().getFile();
}

public String getLatestVersionString() {
  Artifact lastArt = new DefaultArtifact(groupId, artifactId, "jar", "LATEST");
  ArtifactRequest request = new ArtifactRequest();
  request.setArtifact(lastArt);
  request.setRepositories(mavenPluginRepository.getRepositories());
  
  try {
    ArtifactResult resolveArtifact = mavenPluginRepository.getSystem().resolveArtifact(mavenPluginRepository.getSession(), request);
    return resolveArtifact.getArtifact().getVersion();
  } catch (ArtifactResolutionException e1) {
    e1.printStackTrace();
  }
  return null;
}

  DelegatingClassLoader depDelLoader = new DelegatingClassLoader(previous);
  if (!dependency2.getArtifact().isSnapshot()) {
    if (dependency2.getArtifact().getFile() != null) {
      bimServerDependencies.add(new org.bimserver.plugins.Dependency(dependency2.getArtifact().getFile().toPath()));
      loadDependencies(dependency2.getArtifact().getFile().toPath(), depDelLoader);
    } else {
      ArtifactRequest request = new ArtifactRequest();
      request.setArtifact(dependency2.getArtifact());
      request.setRepositories(mavenPluginRepository.getRepositories());
      try {
        ArtifactResult resolveArtifact = mavenPluginRepository.getSystem().resolveArtifact(mavenPluginRepository.getSession(), request);
        if (resolveArtifact.getArtifact().getFile() != null) {
          bimServerDependencies.add(new org.bimserver.plugins.Dependency(resolveArtifact.getArtifact().getFile().toPath()));
          loadDependencies(resolveArtifact.getArtifact().getFile().toPath(), depDelLoader);
        } else {
        e.printStackTrace();
  e2.printStackTrace();
} catch (ArtifactResolutionException e) {
  e.printStackTrace();

private File resolve( List<LocalRepository> defaultRepos,
           List<RemoteRepository> remoteRepos,
           Artifact artifact ) throws IOException {
  if (artifact.getExtension().isEmpty()) {
    artifact = new DefaultArtifact(
        artifact.getGroupId(),
        artifact.getArtifactId(),
        artifact.getClassifier(),
        "jar",
        try {
          return m_repoSystem
              .resolveArtifact(session, new ArtifactRequest(artifact, null, null))
              .getArtifact().getFile();
    artifact = resolveLatestVersionRange( session, remoteRepos, artifact );
    ArtifactResult result = m_repoSystem
        .resolveArtifact( session, new ArtifactRequest( artifact, remoteRepos, null ) );
    File resolved = result.getArtifact().getFile();
    LOG.debug( "Resolved ({}) as {}", artifact.toString(), resolved.getAbsolutePath() );
    return resolved;
    LOG.warn( "Error resolving artifact" + artifact.toString() + ":" + e.getMessage(), e );
    throw new IOException( "Error resolving artifact " + artifact.toString() + ": "
        + e.getMessage() );

@Override
public File lookupBundle(BundleDependency bundleDependency) {
 try {
  if (remoteRepositories.isEmpty()) {
   throw new RepositoryServiceDisabledException("Repository service has not been configured so it's disabled. "
     + "To enable it you must configure the set of repositories to use using the system property: "
     + MULE_REMOTE_REPOSITORIES_PROPERTY);
  }
  DefaultArtifact artifact = toArtifact(bundleDependency);
  ArtifactRequest getArtifactRequest = new ArtifactRequest();
  getArtifactRequest.setRepositories(remoteRepositories);
  getArtifactRequest.setArtifact(artifact);
  ArtifactResult artifactResult = repositorySystem.resolveArtifact(repositorySystemSession, getArtifactRequest);
  return artifactResult.getArtifact().getFile();
 } catch (ArtifactResolutionException e) {
  if (e.getCause() instanceof ArtifactNotFoundException) {
   throw new BundleNotFoundException(e);
  } else {
   throw new RepositoryConnectionException("There was a problem connecting to one of the repositories", e);
  }
 }
}

ArtifactRequest request = new ArtifactRequest();
request.setArtifact(RepositoryUtils.toArtifact(artifact));
request.setRepositories(RepositoryUtils.toRepos(_remoteRepositories));
  result = repoSystem.resolveArtifact(createRepositorySession(executionRequest), request);
} catch (ArtifactResolutionException ex) {
  result = ex.getResults().get(0);
if (result.isResolved()) {
  artifact.selectVersion(result.getArtifact().getVersion());
  artifact.setFile(result.getArtifact().getFile());
  artifact.setResolved(true);
} else {

@Override
public File getArtifactFileFromRepository(final GAV gav) {
  ArtifactRequest request = createArtifactRequest(gav);
  ArtifactResult result = null;
  try {
    result = Aether.getAether().getSystem().resolveArtifact(
        Aether.getAether().getSession(),
        request);
  } catch (ArtifactResolutionException e) {
    logger.warn(e.getMessage(),
          e);
  }
  if (result == null) {
    return null;
  }
  File artifactFile = null;
  if (result.isResolved() && !result.isMissing()) {
    artifactFile = result.getArtifact().getFile();
  }
  return artifactFile;
}

private File resolve(final String group, final String artifact, final String version, final String classifier) {
  final DefaultArtifact art = new DefaultArtifact(group, artifact, classifier, "jar", version);
  final ArtifactRequest artifactRequest = new ArtifactRequest().setArtifact(art).setRepositories(remoteRepositories);
  final LocalRepositoryManager lrm = session.getLocalRepositoryManager();
  art.setFile(new File(lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact(artifactRequest.getArtifact())));
  try {
    final ArtifactResult result = repositorySystem.resolveArtifact(session, artifactRequest);
    if (result.isMissing()) {
      throw new IllegalStateException("Can't find commons-cli, please add it to the pom.");
    }
    return result.getArtifact().getFile();
  } catch (final ArtifactResolutionException e) {
    throw new IllegalStateException(e.getMessage(), e);
  }
}

                     gav.getVersion() );
ArtifactRequest artifactRequest = new ArtifactRequest();
artifactRequest.setArtifact( artifact );
artifactRequest.addRepository( sourceRepository );
  logger.info( "Retrieved " + artifactResult.getArtifact().getFile() );
  failedRetrievals.add( e.getMessage() );

@Override
public ArtifactSpec resolve(ArtifactSpec spec) {
  if (spec.file == null) {
    final DefaultArtifact artifact = new DefaultArtifact(spec.groupId(), spec.artifactId(), spec.classifier(),
        spec.type(), spec.version());
    final LocalArtifactResult localResult = this.session.getLocalRepositoryManager()
        .find(this.session, new LocalArtifactRequest(artifact, this.remoteRepositories, null));
    if (localResult.isAvailable()) {
      spec.file = localResult.getFile();
    } else {
      try {
        final ArtifactResult result = resolver.resolveArtifact(this.session,
            new ArtifactRequest(artifact,
                this.remoteRepositories,
                null));
        if (result.isResolved()) {
          spec.file = result.getArtifact().getFile();
        }
      } catch (ArtifactResolutionException e) {
        System.err.println("ERR " + e);
        e.printStackTrace();
      }
    }
  }
  return spec.file != null ? spec : null;
}

try {
  ArtifactResult modelArtifactResult = artifactProvider.getArtifact(new DefaultArtifact(groupId, artifactId, null, "pom", version));
  Artifact resolvedModelArtifact = modelArtifactResult.getArtifact();
  MavenRepositoryDescriptor repositoryDescriptor = artifactProvider.getRepositoryDescriptor();
  MavenPomXmlDescriptor modelDescriptor = findModel(repositoryDescriptor, resolvedModelArtifact);
  if (modelDescriptor == null) {
    File modelArtifactFile = resolvedModelArtifact.getFile();
    context.push(PomModelBuilder.class, pomModelBuilder);
    try {
    repositoryDescriptor.getContainedModels().add(modelDescriptor);
  if (scanArtifacts && !artifact.getExtension().equals("pom")) {
    ArtifactResult artifactResult = artifactProvider.getArtifact(artifact);
    File artifactFile = artifactResult.getArtifact().getFile();
    Descriptor descriptor;
    try {
  LOGGER.warn(e.getMessage());

ArtifactRequest request = new ArtifactRequest();
request.setArtifact(artifact);
request.setRepositories(Lists.newArrayList(remoteRepo));
e.printStackTrace();

private org.apache.maven.shared.transfer.artifact.resolve.ArtifactResult resolveArtifact( ProjectBuildingRequest buildingRequest,
                                         Artifact aetherArtifact )
                                           throws ArtifactResolverException
// CHECKSTYLE_ON: LineLength
{
  @SuppressWarnings( "unchecked" )
  List<RemoteRepository> aetherRepositories =
    (List<RemoteRepository>) Invoker.invoke( RepositoryUtils.class, "toRepos", List.class,
                         buildingRequest.getRemoteRepositories() );
  RepositorySystemSession session =
    (RepositorySystemSession) Invoker.invoke( buildingRequest, "getRepositorySession" );
  try
  {
    // use descriptor to respect relocation
    ArtifactDescriptorRequest descriptorRequest =
      new ArtifactDescriptorRequest( aetherArtifact, aetherRepositories, null );
    ArtifactDescriptorResult descriptorResult =
      repositorySystem.readArtifactDescriptor( session, descriptorRequest );
    ArtifactRequest request = new ArtifactRequest( descriptorResult.getArtifact(), aetherRepositories, null );
    return new Maven31ArtifactResult( repositorySystem.resolveArtifact( session, request ) );
  }
  catch ( ArtifactDescriptorException e )
  {
    throw new ArtifactResolverException( e.getMessage(), e );
  }
  catch ( ArtifactResolutionException e )
  {
    throw new ArtifactResolverException( e.getMessage(), e );
  }
}

for ( ArtifactResult result : results )
  if ( !result.isResolved() )
    buffer.append( result.getRequest().getArtifact() );
    sep = ", ";
Throwable cause = getCause( results );
if ( cause != null )

/**
 * Creates a new exception with the specified results.
 * 
 * @param results The resolution results at the point the exception occurred, may be {@code null}.
 */
public ArtifactResolutionException( List<ArtifactResult> results )
{
  super( getMessage( results ), getCause( results ) );
  this.results = ( results != null ) ? results : Collections.<ArtifactResult> emptyList();
}

private ArtifactResult resolveArtifactRequest(ArtifactRequest request) {
  ArtifactResult result = null;
  try {
    result = system.resolveArtifact(session, request);
  } catch (ArtifactResolutionException e) {
    LOG.warn("Cannot resolve artifact: " + request.getArtifact());
    if (LOG.isDebugEnabled()) LOG.debug(e.getMessage(), e);
  }
  return result;
}