Examples with ArtifactResolutionException org.eclipse.aether.resolution.ArtifactResolutionException used on opensource projects

Example 16 with ArtifactResolutionException

use of org.eclipse.aether.resolution.ArtifactResolutionException in project gate-core by GateNLP.

the class PackageGappTask method execute.

@Override
public void execute() throws BuildException {
    // process the hints
    for (MappingHint h : hintTasks) {
        h.perform();
    }
    // map to store the necessary file copy operations
    Map<URL, URL> fileCopyMap = new HashMap<URL, URL>();
    Map<URL, URL> dirCopyMap = new HashMap<URL, URL>();
    TreeMap<URL, URL> pluginCopyMap = new TreeMap<URL, URL>(PATH_COMPARATOR);
    log("Packaging gapp file " + src);
    // do the work
    GappModel gappModel = null;
    URL newFileURL = null;
    try {
        URL gateHomeURL = null;
        // convert gateHome to a URL, if it was provided
        if (gateHome != null) {
            gateHomeURL = gateHome.toURI().toURL();
        }
        URL resourcesHomeURL = null;
        // convert resourcesHome to a URL, if it was provided
        if (resourcesHome != null) {
            resourcesHomeURL = resourcesHome.toURI().toURL();
        }
        gappModel = new GappModel(src.toURI().toURL(), gateHomeURL, resourcesHomeURL);
        newFileURL = destFile.toURI().toURL();
        gappModel.setGappFileURL(newFileURL);
    } catch (MalformedURLException e) {
        throw new BuildException("Couldn't convert src or dest file to URL", e, getLocation());
    }
    // we use TreeSet for these sets so we will process the paths
    // higher up the directory tree before paths pointing to their
    // subdirectories.
    Set<URL> plugins = new TreeSet<URL>(PATH_COMPARATOR);
    plugins.addAll(gappModel.getPluginURLs());
    Set<URL> resources = new TreeSet<URL>(PATH_COMPARATOR);
    resources.addAll(gappModel.getResourceURLs());
    // process the extraresourcespath elements (if any)
    processExtraResourcesPaths(resources);
    // first look at the explicit mapping hints
    if (mappingHints != null && !mappingHints.isEmpty()) {
        Iterator<URL> resourcesIt = resources.iterator();
        while (resourcesIt.hasNext()) {
            URL resource = resourcesIt.next();
            for (URL hint : mappingHints.keySet()) {
                String hintString = hint.toExternalForm();
                if (resource.equals(hint) || (hintString.endsWith("/") && resource.toExternalForm().startsWith(hintString))) {
                    // found this resource under this hint
                    log("Found resource " + resource + " under mapping hint URL " + hint, Project.MSG_VERBOSE);
                    String hintTarget = mappingHints.get(hint);
                    URL newResourceURL = null;
                    if (hintTarget == null) {
                        // hint asks to map to an absolute URL
                        log("  Converting to absolute URL", Project.MSG_VERBOSE);
                        newResourceURL = resource;
                    } else {
                        // construct the new URL relative to the hint target
                        try {
                            URL mappedHint = new URL(newFileURL, hintTarget);
                            String resourceRelpath = PersistenceManager.getRelativePath(hint, resource);
                            newResourceURL = new URL(mappedHint, resourceRelpath);
                            fileCopyMap.put(resource, newResourceURL);
                            if (copyResourceDirs) {
                                dirCopyMap.put(new URL(resource, "."), new URL(newResourceURL, "."));
                            }
                        } catch (MalformedURLException e) {
                            throw new BuildException("Couldn't construct URL relative to " + hintTarget + " for " + resource, e, getLocation());
                        }
                        log("  Relocating to " + newResourceURL, Project.MSG_VERBOSE);
                    }
                    // do the relocation
                    gappModel.updatePathForURL(resource, newResourceURL, hintTarget != null);
                    // we've now dealt with this resource, so don't need to
                    // handle it later
                    resourcesIt.remove();
                    break;
                }
            }
        }
    }
    // Any resources that aren't covered by the hints, try and
    // resolve them relative to the plugins referenced by the
    // application.
    Iterator<URL> pluginsIt = plugins.iterator();
    while (pluginsIt.hasNext()) {
        URL pluginURL = pluginsIt.next();
        pluginsIt.remove();
        URL newPluginURL = null;
        String pluginName = pluginURL.getFile();
        log("Processing plugin " + pluginName, Project.MSG_VERBOSE);
        // first check whether this plugin is a subdirectory of another plugin
        // we have already processed
        SortedMap<URL, URL> possibleAncestors = pluginCopyMap.headMap(pluginURL);
        URL ancestorPlugin = null;
        if (!possibleAncestors.isEmpty())
            ancestorPlugin = possibleAncestors.lastKey();
        if (ancestorPlugin != null && pluginURL.toExternalForm().startsWith(ancestorPlugin.toExternalForm())) {
            // this plugin is under one we have already dealt with
            log("  Plugin is located under another plugin " + ancestorPlugin, Project.MSG_VERBOSE);
            String relPath = PersistenceManager.getRelativePath(ancestorPlugin, pluginURL);
            try {
                newPluginURL = new URL(pluginCopyMap.get(ancestorPlugin), relPath);
            } catch (MalformedURLException e) {
                throw new BuildException("Couldn't construct URL relative to plugins/" + " for " + pluginURL, e, getLocation());
            }
        } else {
            // normal case, this plugin is not a subdir of another plugin
            boolean addSlash = false;
            // we will map the plugin whose directory name is X to plugins/X
            if (pluginName.endsWith("/")) {
                addSlash = true;
                pluginName = pluginName.substring(pluginName.lastIndexOf('/', pluginName.length() - 2) + 1, pluginName.length() - 1);
            } else {
                pluginName = pluginName.substring(pluginName.lastIndexOf('/') + 1);
            }
            log("  Plugin name is " + pluginName, Project.MSG_VERBOSE);
            try {
                newPluginURL = new URL(newFileURL, "plugins/" + pluginName + (addSlash ? "/" : ""));
                // until we find one that is available.
                if (pluginCopyMap.containsValue(newPluginURL)) {
                    int index = 2;
                    do {
                        newPluginURL = new URL(newFileURL, "plugins/" + pluginName + "-" + (index++) + (addSlash ? "/" : ""));
                    } while (pluginCopyMap.containsValue(newPluginURL));
                }
            } catch (MalformedURLException e) {
                throw new BuildException("Couldn't construct URL relative to plugins/" + " for " + pluginURL, e, getLocation());
            }
        }
        log("  Relocating to " + newPluginURL, Project.MSG_VERBOSE);
        // deal with the plugin URL itself (in the urlList)
        gappModel.updatePathForURL(pluginURL, newPluginURL, true);
        pluginCopyMap.put(pluginURL, newPluginURL);
        // now look for resources located under that plugin
        String pluginUri = pluginURL.toExternalForm();
        if (!pluginUri.endsWith("/")) {
            pluginUri += "/";
        }
        Iterator<URL> resourcesIt = resources.iterator();
        while (resourcesIt.hasNext()) {
            URL resourceURL = resourcesIt.next();
            try {
                if (resourceURL.toExternalForm().startsWith(pluginUri)) {
                    // found a resource under this plugin, so relocate it to be
                    // under the re-located plugin dir
                    resourcesIt.remove();
                    String resourceRelpath = PersistenceManager.getRelativePath(pluginURL, resourceURL);
                    log("    Found resource " + resourceURL, Project.MSG_VERBOSE);
                    URL newResourceURL = null;
                    newResourceURL = new URL(newPluginURL, resourceRelpath);
                    log("    Relocating to " + newResourceURL, Project.MSG_VERBOSE);
                    gappModel.updatePathForURL(resourceURL, newResourceURL, true);
                    fileCopyMap.put(resourceURL, newResourceURL);
                    if (copyResourceDirs) {
                        dirCopyMap.put(new URL(resourceURL, "."), new URL(newResourceURL, "."));
                    }
                }
            } catch (MalformedURLException e) {
                throw new BuildException("Couldn't construct URL relative to " + newPluginURL + " for " + resourceURL, e, getLocation());
            }
        }
    }
    // anything left over, handle according to onUnresolved
    if (!resources.isEmpty()) {
        switch(onUnresolved) {
            case fail:
                // easy case - fail the build
                log("There were unresolved resources:", Project.MSG_ERR);
                for (URL res : resources) {
                    log(res.toExternalForm(), Project.MSG_ERR);
                }
                log("Either set onUnresolved=\"absolute|recover\" or add the " + "relevant mapping hints", Project.MSG_ERR);
                throw new BuildException("There were unresolved resources", getLocation());
            case absolute:
                // convert all unresolved resources to absolute URLs
                log("There were unresolved resources, which have been made absolute", Project.MSG_WARN);
                for (URL res : resources) {
                    gappModel.updatePathForURL(res, res, false);
                    log(res.toExternalForm(), Project.MSG_VERBOSE);
                }
                break;
            case recover:
                // the clever case - recover by putting all the unresolved
                // resources into subdirectories of an "application-resources"
                // directory under the output dir
                URL unresolvedResourcesDir = null;
                try {
                    unresolvedResourcesDir = new URL(newFileURL, "application-resources/");
                } catch (MalformedURLException e) {
                    throw new BuildException("Can't construct URL relative to " + newFileURL + " for application-resources", e, getLocation());
                }
                // map to track where under application-resources we should map
                // each directory that contains unresolved resources
                TreeMap<URL, URL> unresolvedResourcesSubDirs = new TreeMap<URL, URL>(PATH_COMPARATOR);
                log("There were unresolved resources, which have been gathered into " + unresolvedResourcesDir, Project.MSG_INFO);
                for (URL res : resources) {
                    URL resourceDir = null;
                    try {
                        resourceDir = new URL(res, ".");
                    } catch (MalformedURLException e) {
                        throw new BuildException("Can't construct URL to parent directory of " + res, e, getLocation());
                    }
                    URL targetDir = getUnresolvedResourcesTarget(unresolvedResourcesSubDirs, unresolvedResourcesDir, resourceDir);
                    String resName = res.getFile();
                    resName = resName.substring(resName.lastIndexOf('/') + 1);
                    URL newResourceURL = null;
                    try {
                        newResourceURL = new URL(targetDir, resName);
                    } catch (MalformedURLException e) {
                        throw new BuildException("Can't construct URL relative to " + unresolvedResourcesDir + " for " + resName, e, getLocation());
                    }
                    gappModel.updatePathForURL(res, newResourceURL, true);
                    fileCopyMap.put(res, newResourceURL);
                    if (copyResourceDirs) {
                        dirCopyMap.put(resourceDir, targetDir);
                    }
                }
                break;
            default:
                throw new BuildException("Unrecognised UnresolvedAction", getLocation());
        }
    }
    // write out the fixed GAPP file
    try {
        log("Writing modified gapp to " + destFile);
        gappModel.write();
    } catch (IOException e) {
        throw new BuildException("Error writing out modified GAPP file", e, getLocation());
    }
    // now copy the files that it references
    if (fileCopyMap.size() > 0) {
        log("Copying " + fileCopyMap.size() + " resources");
    }
    for (Map.Entry<URL, URL> resEntry : fileCopyMap.entrySet()) {
        File source = Files.fileFromURL(resEntry.getKey());
        File dest = Files.fileFromURL(resEntry.getValue());
        if (source.isDirectory()) {
            // source URL points to a directory, so create a corresponding
            // directory dest
            dest.mkdirs();
        } else {
            // source URL doesn't point to a directory, so
            // ensure parent directory exists
            dest.getParentFile().mkdirs();
            if (source.isFile()) {
                // source URL points to an existing file, copy it
                try {
                    log("Copying " + source + " to " + dest, Project.MSG_VERBOSE);
                    FileUtils.getFileUtils().copyFile(source, dest);
                } catch (IOException e) {
                    throw new BuildException("Error copying file " + source + " to " + dest, e, getLocation());
                }
            }
        }
    }
    // handle the plugins
    if (pluginCopyMap.size() > 0) {
        log("Copying " + pluginCopyMap.size() + " plugins");
        if (copyPlugins) {
            log("Also copying complete plugin contents", Project.MSG_VERBOSE);
        }
        copyDirectories(pluginCopyMap, !copyPlugins);
    }
    // handle extra directories
    if (dirCopyMap.size() > 0) {
        log("Copying " + dirCopyMap.size() + " resource directories");
        copyDirectories(dirCopyMap, false);
    }
    if (mavenCache != null) {
        List<GappModel.MavenPlugin> mavenPlugins = gappModel.getMavenPlugins();
        if (!mavenPlugins.isEmpty()) {
            log("Creating Maven cache at " + mavenCache.getAbsolutePath());
            SimpleMavenCache smc = new SimpleMavenCache(mavenCache);
            for (GappModel.MavenPlugin plugin : mavenPlugins) {
                log("  Cacheing " + plugin.group + ":" + plugin.artifact + ":" + plugin.version, Project.MSG_VERBOSE);
                Artifact pluginArtifact = new DefaultArtifact(plugin.group, plugin.artifact, "jar", plugin.version);
                try {
                    smc.cacheArtifact(pluginArtifact);
                } catch (DependencyCollectionException | DependencyResolutionException | ArtifactResolutionException | IOException | SettingsBuildingException | ModelBuildingException e) {
                    throw new BuildException("Error cacheing plugin " + plugin.group + ":" + plugin.artifact + ":" + plugin.version, e);
                }
                // and the matching creole.jar if there is one
                try {
                    smc.cacheArtifact(new SubArtifact(pluginArtifact, "creole", "jar"));
                } catch (DependencyCollectionException | DependencyResolutionException | ArtifactResolutionException | IOException | SettingsBuildingException | ModelBuildingException e) {
                    log("    Could not cache " + plugin.group + ":" + plugin.artifact + "-" + plugin.version + "-creole.jar -  cache will still work but will " + "print warnings at runtime");
                }
            }
        }
    }
}

Example 17 with ArtifactResolutionException

use of org.eclipse.aether.resolution.ArtifactResolutionException in project spring-cloud-deployer by spring-cloud.

the class MavenArtifactResolver method resolve.

/**
 * Resolve an artifact and return its location in the local repository. Aether performs the normal
 * Maven resolution process ensuring that the latest update is cached to the local repository.
 * In addition, if the {@link MavenProperties#resolvePom} flag is <code>true</code>,
 * the POM is also resolved and cached.
 * @param resource the {@link MavenResource} representing the artifact
 * @return a {@link FileSystemResource} representing the resolved artifact in the local repository
 * @throws IllegalStateException if the artifact does not exist or the resolution fails
 */
Resource resolve(MavenResource resource) {
    Assert.notNull(resource, "MavenResource must not be null");
    validateCoordinates(resource);
    RepositorySystemSession session = newRepositorySystemSession(this.repositorySystem, this.properties.getLocalRepository());
    ArtifactResult resolvedArtifact;
    try {
        List<ArtifactRequest> artifactRequests = new ArrayList<>(2);
        if (properties.isResolvePom()) {
            artifactRequests.add(new ArtifactRequest(toPomArtifact(resource), this.remoteRepositories, JavaScopes.RUNTIME));
        }
        artifactRequests.add(new ArtifactRequest(toJarArtifact(resource), this.remoteRepositories, JavaScopes.RUNTIME));
        List<ArtifactResult> results = this.repositorySystem.resolveArtifacts(session, artifactRequests);
        resolvedArtifact = results.get(results.size() - 1);
    } catch (ArtifactResolutionException e) {
        ChoiceFormat pluralizer = new ChoiceFormat(new double[] { 0d, 1d, ChoiceFormat.nextDouble(1d) }, new String[] { "repositories: ", "repository: ", "repositories: " });
        MessageFormat messageFormat = new MessageFormat("Failed to resolve MavenResource: {0}. Configured remote {1}: {2}");
        messageFormat.setFormat(1, pluralizer);
        String repos = properties.getRemoteRepositories().isEmpty() ? "none" : StringUtils.collectionToDelimitedString(properties.getRemoteRepositories().keySet(), ",", "[", "]");
        throw new IllegalStateException(messageFormat.format(new Object[] { resource, properties.getRemoteRepositories().size(), repos }), e);
    }
    return toResource(resolvedArtifact);
}

Example 18 with ArtifactResolutionException

use of org.eclipse.aether.resolution.ArtifactResolutionException in project mule by mulesoft.

the class DefaultRepositoryService method lookupBundle.

@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);
        }
    }
}

Example 19 with ArtifactResolutionException

use of org.eclipse.aether.resolution.ArtifactResolutionException in project mule by mulesoft.

the class ExtensionModelLoaderFinder method findLoaderByProperty.

/**
 * Searches in the plugin pom.xml for the {@code testExtensionModelLoaderId} property which specifies with which loader the
 * extension must be loaded. The main use of this is for Test Extensions that don't generate a mule-artifact.json.
 */
public Optional<ExtensionModelLoader> findLoaderByProperty(Artifact plugin, DependencyResolver dependencyResolver, List<RemoteRepository> rootArtifactRemoteRepositories) {
    DefaultArtifact artifact = new DefaultArtifact(plugin.getGroupId(), plugin.getArtifactId(), "pom", plugin.getVersion());
    try {
        ArtifactResult artifactResult = dependencyResolver.resolveArtifact(artifact, rootArtifactRemoteRepositories);
        File pomFile = artifactResult.getArtifact().getFile();
        Model mavenProject = MavenModelFactory.createMavenProject(pomFile);
        String id = mavenProject.getProperties().getProperty("testExtensionModelLoaderId");
        return id != null ? Optional.ofNullable(getLoaderById(id)) : Optional.empty();
    } catch (ArtifactResolutionException e) {
        throw new RuntimeException("Cannot load extension, the artifact: [" + plugin.toString() + "] cannot be resolved", e);
    }
}

Example 20 with ArtifactResolutionException

use of org.eclipse.aether.resolution.ArtifactResolutionException in project wildfly-swarm by wildfly-swarm.

the class MavenArtifactResolvingHelper method resolve.

@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) {
                e.printStackTrace();
            }
        }
    }
    return spec.file != null ? spec : null;
}