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

Example 1 with DependencyResolutionException

use of org.eclipse.aether.resolution.DependencyResolutionException in project byte-buddy by raphw.

the class ClassLoaderResolverTest method testResolutionFailure.

@Test(expected = MojoExecutionException.class)
public void testResolutionFailure() throws Exception {
    when(repositorySystem.resolveDependencies(eq(repositorySystemSession), any(DependencyRequest.class))).thenThrow(new DependencyResolutionException(new DependencyResult(new DependencyRequest(root, mock(DependencyFilter.class))), new Throwable()));
    classLoaderResolver.resolve(new MavenCoordinate(FOO, BAR, QUX));
}

Example 2 with DependencyResolutionException

use of org.eclipse.aether.resolution.DependencyResolutionException in project BIMserver by opensourceBIM.

the class PluginManager method loadDependencies.

private PublicFindClassClassLoader loadDependencies(Set<org.bimserver.plugins.Dependency> bimServerDependencies, Model model, PublicFindClassClassLoader previous) throws FileNotFoundException, IOException {
    List<org.apache.maven.model.Dependency> dependencies = model.getDependencies();
    Iterator<org.apache.maven.model.Dependency> it = dependencies.iterator();
    Path workspaceDir = Paths.get("..");
    bimServerDependencies.add(new org.bimserver.plugins.Dependency(workspaceDir.resolve("PluginBase/target/classes")));
    bimServerDependencies.add(new org.bimserver.plugins.Dependency(workspaceDir.resolve("Shared/target/classes")));
    while (it.hasNext()) {
        org.apache.maven.model.Dependency depend = it.next();
        try {
            if (depend.getGroupId().equals("org.opensourcebim") && (depend.getArtifactId().equals("shared") || depend.getArtifactId().equals("pluginbase"))) {
                // TODO we might want to check the version though
                continue;
            }
            if (depend.isOptional() || "test".equals(depend.getScope())) {
                continue;
            }
            Dependency dependency2 = new Dependency(new DefaultArtifact(depend.getGroupId() + ":" + depend.getArtifactId() + ":jar:" + depend.getVersion()), "compile");
            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 {
                        // TODO error?
                        }
                    } catch (ArtifactResolutionException e) {
                        e.printStackTrace();
                    }
                }
            } else {
                // Snapshot projects linked in Eclipse
                ArtifactRequest request = new ArtifactRequest();
                if ((!"test".equals(dependency2.getScope()) && !dependency2.getArtifact().isSnapshot())) {
                    request.setArtifact(dependency2.getArtifact());
                    request.setRepositories(mavenPluginRepository.getLocalRepositories());
                    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 {
                        // TODO error?
                        }
                    } catch (Exception e) {
                        LOGGER.info(dependency2.getArtifact().toString());
                        e.printStackTrace();
                    }
                // bimServerDependencies.add(new
                // org.bimserver.plugins.Dependency(resolveArtifact.getArtifact().getFile().toPath()));
                }
            }
            ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
            descriptorRequest.setArtifact(dependency2.getArtifact());
            descriptorRequest.setRepositories(mavenPluginRepository.getRepositories());
            ArtifactDescriptorResult descriptorResult = mavenPluginRepository.getSystem().readArtifactDescriptor(mavenPluginRepository.getSession(), descriptorRequest);
            CollectRequest collectRequest = new CollectRequest();
            collectRequest.setRootArtifact(descriptorResult.getArtifact());
            collectRequest.setDependencies(descriptorResult.getDependencies());
            collectRequest.setManagedDependencies(descriptorResult.getManagedDependencies());
            collectRequest.setRepositories(descriptorResult.getRepositories());
            DependencyNode node = mavenPluginRepository.getSystem().collectDependencies(mavenPluginRepository.getSession(), collectRequest).getRoot();
            DependencyRequest dependencyRequest = new DependencyRequest();
            dependencyRequest.setRoot(node);
            CollectResult collectResult = mavenPluginRepository.getSystem().collectDependencies(mavenPluginRepository.getSession(), collectRequest);
            PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
            // collectResult.getRoot().accept(new
            // ConsoleDependencyGraphDumper());
            collectResult.getRoot().accept(nlg);
            try {
                mavenPluginRepository.getSystem().resolveDependencies(mavenPluginRepository.getSession(), dependencyRequest);
            } catch (DependencyResolutionException e) {
            // Ignore
            }
            for (DependencyNode dependencyNode : nlg.getNodes()) {
                ArtifactRequest newRequest = new ArtifactRequest(dependencyNode);
                newRequest.setRepositories(mavenPluginRepository.getRepositories());
                ArtifactResult resolveArtifact = mavenPluginRepository.getSystem().resolveArtifact(mavenPluginRepository.getSession(), newRequest);
                Artifact artifact = resolveArtifact.getArtifact();
                Path jarFile = Paths.get(artifact.getFile().getAbsolutePath());
                loadDependencies(jarFile, depDelLoader);
                Artifact versionArtifact = new DefaultArtifact(artifact.getGroupId(), artifact.getArtifactId(), "pom", artifact.getVersion());
                ArtifactRequest request = new ArtifactRequest();
                request.setArtifact(versionArtifact);
                request.setRepositories(mavenPluginRepository.getRepositories());
                // try {
                // ArtifactResult resolveArtifact =
                // mavenPluginRepository.getSystem().resolveArtifact(mavenPluginRepository.getSession(),
                // request);
                // File depPomFile =
                // resolveArtifact.getArtifact().getFile();
                // if (depPomFile != null) {
                // MavenXpp3Reader mavenreader = new MavenXpp3Reader();
                // Model depModel = null;
                // try (FileReader reader = new FileReader(depPomFile)) {
                // try {
                // depModel = mavenreader.read(reader);
                // } catch (XmlPullParserException e) {
                // e.printStackTrace();
                // }
                // }
                // previous = loadDependencies(bimServerDependencies,
                // depModel, previous);
                // } else {
                // LOGGER.info("Artifact not found " + versionArtifact);
                // }
                // } catch (ArtifactResolutionException e1) {
                // LOGGER.error(e1.getMessage());
                // }
                // EclipsePluginClassloader depLoader = new
                // EclipsePluginClassloader(depDelLoader, projectRoot);
                bimServerDependencies.add(new org.bimserver.plugins.Dependency(jarFile));
            }
            previous = depDelLoader;
        } catch (DependencyCollectionException e) {
            e.printStackTrace();
        } catch (ArtifactDescriptorException e2) {
            e2.printStackTrace();
        } catch (ArtifactResolutionException e) {
            e.printStackTrace();
        }
    }
    return previous;
}

Example 3 with DependencyResolutionException

use of org.eclipse.aether.resolution.DependencyResolutionException in project atlasmap by atlasmap.

the class GenerateInspectionsMojo method resolveClasspath.

private List<URL> resolveClasspath(List<String> artifacts) throws MojoFailureException {
    final List<URL> urls = new ArrayList<>();
    try {
        for (String gav : artifacts) {
            Artifact artifact = new DefaultArtifact(gav);
            getLog().debug("Resolving dependencies for artifact: " + artifact);
            CollectRequest collectRequest = new CollectRequest();
            collectRequest.setRoot(new Dependency(artifact, ""));
            collectRequest.setRepositories(remoteRepos);
            DependencyRequest dependencyRequest = new DependencyRequest();
            dependencyRequest.setCollectRequest(collectRequest);
            DependencyResult dependencyResult = system.resolveDependencies(repoSession, dependencyRequest);
            PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
            dependencyResult.getRoot().accept(nlg);
            Iterator<DependencyNode> it = nlg.getNodes().iterator();
            while (it.hasNext()) {
                DependencyNode node = it.next();
                if (node.getDependency() != null) {
                    Artifact x = node.getDependency().getArtifact();
                    if (x.getFile() != null) {
                        getLog().debug("Found dependency: " + x + " for artifact: " + artifact);
                        urls.add(x.getFile().toURI().toURL());
                    }
                }
            }
        }
    } catch (IllegalArgumentException e) {
        throw new MojoFailureException(e.getMessage(), e);
    } catch (DependencyResolutionException e) {
        throw new MojoFailureException(e.getMessage(), e);
    } catch (MalformedURLException e) {
        throw new MojoFailureException(e.getMessage(), e);
    }
    return urls;
}

Example 4 with DependencyResolutionException

use of org.eclipse.aether.resolution.DependencyResolutionException 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 5 with DependencyResolutionException

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

the class DependencyResolver method resolveDependencies.

/**
 * Resolves and filters transitive dependencies for the root and direct dependencies.
 * <p/>
 * If both a root dependency and direct dependencies are given, the direct dependencies will be merged with the direct
 * dependencies from the root dependency's artifact descriptor, giving higher priority to the dependencies from the root.
 *
 * @param root {@link Dependency} node from to collect its dependencies, may be {@code null}
 * @param directDependencies {@link List} of direct {@link Dependency} to collect its transitive dependencies, may be
 *        {@code null}
 * @param managedDependencies {@link List} of managed {@link Dependency}s to be used for resolving the depedency graph, may be
 *        {@code null}
 * @param dependencyFilter {@link DependencyFilter} to include/exclude dependency nodes during collection and resolve operation.
 *        May be {@code null} to no filter
 * @param remoteRepositories {@link RemoteRepository} to be used when resolving dependencies in addition to the ones already defined in the context.
 * @return a {@link List} of {@link File}s for each dependency resolved
 * @throws {@link DependencyCollectionException} if the dependency tree could not be built
 * @thwows {@link DependencyResolutionException} if the dependency tree could not be built or any dependency artifact could not
 *         be resolved
 */
public List<File> resolveDependencies(Dependency root, List<Dependency> directDependencies, List<Dependency> managedDependencies, DependencyFilter dependencyFilter, List<RemoteRepository> remoteRepositories) throws DependencyCollectionException, DependencyResolutionException {
    CollectRequest collectRequest = new CollectRequest();
    collectRequest.setRoot(root);
    collectRequest.setDependencies(directDependencies);
    collectRequest.setManagedDependencies(managedDependencies);
    collectRequest.setRepositories(resolutionContext.getRemoteRepositories());
    // Has to set authentication to these remote repositories as they may come from a pom descriptor
    remoteRepositories.forEach(remoteRepository -> {
        RemoteRepository authenticatedRemoteRepository = setAuthentication(remoteRepository);
        if (!collectRequest.getRepositories().contains(authenticatedRemoteRepository)) {
            collectRequest.addRepository(authenticatedRemoteRepository);
        }
    });
    DependencyNode node;
    try {
        logger.debug("Collecting dependencies for '{}'", printCollectRequest(collectRequest));
        node = repositoryState.getSystem().collectDependencies(repositoryState.getSession(), collectRequest).getRoot();
        logDependencyGraph(node, collectRequest);
        DependencyRequest dependencyRequest = new DependencyRequest();
        dependencyRequest.setRoot(node);
        dependencyRequest.setCollectRequest(collectRequest);
        if (dependencyFilter != null) {
            dependencyRequest.setFilter(dependencyFilter);
        }
        node = repositoryState.getSystem().resolveDependencies(repositoryState.getSession(), dependencyRequest).getRoot();
    } catch (DependencyResolutionException e) {
        logger.warn("Dependencies couldn't be resolved for request '{}', {}", collectRequest, e.getMessage());
        node = e.getResult().getRoot();
        logUnresolvedArtifacts(node, e);
        throw e;
    }
    List<File> files = getFiles(node);
    return files;
}