| /* |
| * Copyright 2000-2010 JetBrains s.r.o. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.jetbrains.idea.maven.utils.library; |
| |
| import com.intellij.CommonBundle; |
| import com.intellij.notification.Notification; |
| import com.intellij.notification.NotificationType; |
| import com.intellij.notification.Notifications; |
| import com.intellij.openapi.application.AccessToken; |
| import com.intellij.openapi.application.ApplicationManager; |
| import com.intellij.openapi.application.WriteAction; |
| import com.intellij.openapi.progress.ProgressIndicator; |
| import com.intellij.openapi.progress.ProgressManager; |
| import com.intellij.openapi.progress.Task; |
| import com.intellij.openapi.project.Project; |
| import com.intellij.openapi.roots.JavadocOrderRootType; |
| import com.intellij.openapi.roots.OrderRootType; |
| import com.intellij.openapi.roots.libraries.NewLibraryConfiguration; |
| import com.intellij.openapi.roots.libraries.ui.OrderRoot; |
| import com.intellij.openapi.roots.ui.configuration.libraryEditor.LibraryEditor; |
| import com.intellij.openapi.ui.DialogWrapper; |
| import com.intellij.openapi.ui.Messages; |
| import com.intellij.openapi.util.Condition; |
| import com.intellij.openapi.util.Pair; |
| import com.intellij.openapi.util.Ref; |
| import com.intellij.openapi.util.io.FileUtil; |
| import com.intellij.openapi.vfs.VfsUtil; |
| import com.intellij.openapi.vfs.VirtualFile; |
| import com.intellij.openapi.vfs.VirtualFileManager; |
| import com.intellij.util.PairProcessor; |
| import com.intellij.util.Processor; |
| import com.intellij.util.SmartList; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| import org.jetbrains.idea.maven.execution.SoutMavenConsole; |
| import org.jetbrains.idea.maven.importing.MavenExtraArtifactType; |
| import org.jetbrains.idea.maven.model.*; |
| import org.jetbrains.idea.maven.project.MavenEmbeddersManager; |
| import org.jetbrains.idea.maven.project.MavenProjectsManager; |
| import org.jetbrains.idea.maven.server.MavenEmbedderWrapper; |
| import org.jetbrains.idea.maven.services.MavenRepositoryServicesManager; |
| import org.jetbrains.idea.maven.utils.MavenLog; |
| import org.jetbrains.idea.maven.utils.MavenProcessCanceledException; |
| import org.jetbrains.idea.maven.utils.MavenProgressIndicator; |
| import org.jetbrains.idea.maven.utils.RepositoryAttachDialog; |
| |
| import javax.swing.*; |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.util.*; |
| import java.util.concurrent.atomic.AtomicBoolean; |
| |
| /** |
| * @author Gregory.Shrago |
| */ |
| public class RepositoryAttachHandler { |
| |
| @Nullable |
| public static NewLibraryConfiguration chooseLibraryAndDownload(final @NotNull Project project, |
| final @Nullable String initialFilter, |
| JComponent parentComponent) { |
| RepositoryAttachDialog dialog = new RepositoryAttachDialog(project, initialFilter); |
| dialog.setTitle("Download Library From Maven Repository"); |
| dialog.show(); |
| if (dialog.getExitCode() != DialogWrapper.OK_EXIT_CODE) { |
| return null; |
| } |
| |
| String copyTo = dialog.getDirectoryPath(); |
| String coord = dialog.getCoordinateText(); |
| boolean attachJavaDoc = dialog.getAttachJavaDoc(); |
| boolean attachSources = dialog.getAttachSources(); |
| List<MavenRepositoryInfo> repositories = dialog.getRepositories(); |
| NewLibraryConfiguration configuration = resolveAndDownload(project, coord, attachJavaDoc, attachSources, copyTo, repositories); |
| if (configuration == null) { |
| Messages.showErrorDialog(parentComponent, "No files were downloaded for " + coord, CommonBundle.getErrorTitle()); |
| } |
| return configuration; |
| } |
| |
| public static NewLibraryConfiguration resolveAndDownload(final Project project, |
| final String coord, |
| boolean attachJavaDoc, |
| boolean attachSources, |
| @Nullable final String copyTo, |
| List<MavenRepositoryInfo> repositories) { |
| final SmartList<MavenExtraArtifactType> extraTypes = new SmartList<MavenExtraArtifactType>(); |
| if (attachSources) extraTypes.add(MavenExtraArtifactType.SOURCES); |
| if (attachJavaDoc) extraTypes.add(MavenExtraArtifactType.DOCS); |
| final Ref<NewLibraryConfiguration> result = Ref.create(null); |
| resolveLibrary(project, coord, extraTypes, repositories, new Processor<List<MavenArtifact>>() { |
| public boolean process(final List<MavenArtifact> artifacts) { |
| if (!artifacts.isEmpty()) { |
| AccessToken accessToken = WriteAction.start(); |
| try { |
| final List<OrderRoot> roots = createRoots(artifacts, copyTo); |
| result.set(new NewLibraryConfiguration(coord, RepositoryLibraryType.getInstance(), new RepositoryLibraryProperties(coord)) { |
| @Override |
| public void addRoots(@NotNull LibraryEditor editor) { |
| editor.addRoots(roots); |
| } |
| }); |
| } |
| finally { |
| accessToken.finish(); |
| } |
| notifyArtifactsDownloaded(project, artifacts); |
| } |
| return true; |
| } |
| }); |
| return result.get(); |
| } |
| |
| public static void notifyArtifactsDownloaded(Project project, List<MavenArtifact> artifacts) { |
| final StringBuilder sb = new StringBuilder(); |
| final String title = "The following files were downloaded:"; |
| sb.append("<ol>"); |
| for (MavenArtifact each : artifacts) { |
| sb.append("<li>"); |
| sb.append(each.getFile().getName()); |
| final String scope = each.getScope(); |
| if (scope != null) { |
| sb.append(" ("); |
| sb.append(scope); |
| sb.append(")"); |
| } |
| sb.append("</li>"); |
| } |
| sb.append("</ol>"); |
| Notifications.Bus.notify(new Notification("Repository", title, sb.toString(), NotificationType.INFORMATION), project); |
| } |
| |
| public static List<OrderRoot> createRoots(@NotNull Collection<MavenArtifact> artifacts, @Nullable String copyTo) { |
| final List<OrderRoot> result = new ArrayList<OrderRoot>(); |
| final VirtualFileManager manager = VirtualFileManager.getInstance(); |
| for (MavenArtifact each : artifacts) { |
| try { |
| File repoFile = each.getFile(); |
| File toFile = repoFile; |
| if (copyTo != null) { |
| toFile = new File(copyTo, repoFile.getName()); |
| if (repoFile.exists()) { |
| FileUtil.copy(repoFile, toFile); |
| } |
| } |
| // search for jar file first otherwise lib root won't be found! |
| manager.refreshAndFindFileByUrl(VfsUtil.pathToUrl(FileUtil.toSystemIndependentName(toFile.getPath()))); |
| final String url = VfsUtil.getUrlForLibraryRoot(toFile); |
| final VirtualFile file = manager.refreshAndFindFileByUrl(url); |
| if (file != null) { |
| OrderRootType rootType; |
| if (MavenExtraArtifactType.DOCS.getDefaultClassifier().equals(each.getClassifier())) { |
| rootType = JavadocOrderRootType.getInstance(); |
| } |
| else if (MavenExtraArtifactType.SOURCES.getDefaultClassifier().equals(each.getClassifier())) { |
| rootType = OrderRootType.SOURCES; |
| } |
| else { |
| rootType = OrderRootType.CLASSES; |
| } |
| result.add(new OrderRoot(file, rootType)); |
| } |
| } |
| catch (MalformedURLException e) { |
| MavenLog.LOG.warn(e); |
| } |
| catch (IOException e) { |
| MavenLog.LOG.warn(e); |
| } |
| } |
| return result; |
| } |
| |
| public static void searchArtifacts(final Project project, String coord, |
| final PairProcessor<Collection<Pair<MavenArtifactInfo, MavenRepositoryInfo>>, Boolean> resultProcessor) { |
| if (coord == null || coord.length() == 0) return; |
| final MavenArtifactInfo template; |
| if (coord.indexOf(':') == -1 && Character.isUpperCase(coord.charAt(0))) { |
| template = new MavenArtifactInfo(null, null, null, "jar", null, coord, null); |
| } |
| else { |
| template = new MavenArtifactInfo(getMavenId(coord), "jar", null); |
| } |
| ProgressManager.getInstance().run(new Task.Backgroundable(project, "Maven", false) { |
| |
| public void run(@NotNull ProgressIndicator indicator) { |
| String[] urls = MavenRepositoryServicesManager.getServiceUrls(); |
| boolean tooManyResults = false; |
| final AtomicBoolean proceedFlag = new AtomicBoolean(true); |
| |
| for (int i = 0, length = urls.length; i < length; i++) { |
| if (!proceedFlag.get()) break; |
| final List<Pair<MavenArtifactInfo, MavenRepositoryInfo>> resultList = new ArrayList<Pair<MavenArtifactInfo, MavenRepositoryInfo>>(); |
| try { |
| String serviceUrl = urls[i]; |
| final List<MavenArtifactInfo> artifacts; |
| artifacts = MavenRepositoryServicesManager.findArtifacts(template, serviceUrl); |
| if (!artifacts.isEmpty()) { |
| if (!proceedFlag.get()) break; |
| final List<MavenRepositoryInfo> repositories = MavenRepositoryServicesManager.getRepositories(serviceUrl); |
| final HashMap<String, MavenRepositoryInfo> map = new HashMap<String, MavenRepositoryInfo>(); |
| for (MavenRepositoryInfo repository : repositories) { |
| map.put(repository.getId(), repository); |
| } |
| for (MavenArtifactInfo artifact : artifacts) { |
| if (artifact == null) { |
| tooManyResults = true; |
| } |
| else { |
| MavenRepositoryInfo repository = map.get(artifact.getRepositoryId()); |
| // if the artifact is provided by an unsupported repository just skip it |
| // because it won't be resolved anyway |
| if (repository == null) continue; |
| resultList.add(Pair.create(artifact, repository)); |
| } |
| } |
| } |
| } |
| catch (Exception e) { |
| MavenLog.LOG.error(e); |
| } |
| finally { |
| if (!proceedFlag.get()) break; |
| final Boolean aBoolean = i == length - 1 ? tooManyResults : null; |
| ApplicationManager.getApplication().invokeLater( |
| new Runnable() { |
| public void run() { |
| proceedFlag.set(resultProcessor.process(resultList, aBoolean)); |
| } |
| }, new Condition() { |
| @Override |
| public boolean value(Object o) { |
| return !proceedFlag.get(); |
| } |
| }); |
| } |
| } |
| } |
| }); |
| } |
| |
| public static void searchRepositories(final Project project, |
| final Collection<String> nexusUrls, |
| final Processor<Collection<MavenRepositoryInfo>> resultProcessor) { |
| ProgressManager.getInstance().run(new Task.Backgroundable(project, "Maven", false) { |
| |
| public void run(@NotNull ProgressIndicator indicator) { |
| final Ref<List<MavenRepositoryInfo>> result = Ref.create(Collections.<MavenRepositoryInfo>emptyList()); |
| try { |
| final ArrayList<MavenRepositoryInfo> repoList = new ArrayList<MavenRepositoryInfo>(); |
| for (String nexusUrl : nexusUrls) { |
| final List<MavenRepositoryInfo> repositories; |
| try { |
| repositories = MavenRepositoryServicesManager.getRepositories(nexusUrl); |
| } |
| catch (Exception ex) { |
| MavenLog.LOG.warn("Accessing Service at: " + nexusUrl, ex); |
| continue; |
| } |
| repoList.addAll(repositories); |
| } |
| result.set(repoList); |
| } |
| catch (Exception e) { |
| MavenLog.LOG.error(e); |
| } |
| finally { |
| ApplicationManager.getApplication().invokeLater(new Runnable() { |
| public void run() { |
| resultProcessor.process(result.get()); |
| } |
| }); |
| } |
| } |
| }); |
| } |
| |
| private static void resolveLibrary(final Project project, |
| final String coord, |
| final List<MavenExtraArtifactType> extraTypes, |
| final Collection<MavenRepositoryInfo> repositories, |
| final Processor<List<MavenArtifact>> resultProcessor) { |
| final MavenId mavenId = getMavenId(coord); |
| final Task task = new Task.Modal(project, "Maven", false) { |
| public void run(@NotNull ProgressIndicator indicator) { |
| doResolveInner(project, mavenId, extraTypes, repositories, resultProcessor, indicator); |
| } |
| }; |
| ProgressManager.getInstance().run(task); |
| } |
| |
| private static void doResolveInner(Project project, |
| MavenId mavenId, |
| List<MavenExtraArtifactType> extraTypes, |
| Collection<MavenRepositoryInfo> repositories, |
| final Processor<List<MavenArtifact>> resultProcessor, |
| ProgressIndicator indicator) { |
| doResolveInner(project, Collections.<MavenId>singletonList(mavenId), extraTypes, repositories, resultProcessor, indicator); |
| } |
| |
| public static void doResolveInner(Project project, |
| List<MavenId> mavenIds, |
| List<MavenExtraArtifactType> extraTypes, |
| Collection<MavenRepositoryInfo> repositories, |
| final Processor<List<MavenArtifact>> resultProcessor, |
| ProgressIndicator indicator) { |
| boolean cancelled = false; |
| final Collection<MavenArtifact> result = new LinkedHashSet<MavenArtifact>(); |
| MavenEmbeddersManager manager = MavenProjectsManager.getInstance(project).getEmbeddersManager(); |
| MavenEmbedderWrapper embedder = manager.getEmbedder(MavenEmbeddersManager.FOR_DOWNLOAD); |
| try { |
| embedder.customizeForResolve(new SoutMavenConsole(), new MavenProgressIndicator(indicator)); |
| List<MavenRemoteRepository> remoteRepositories = convertRepositories(repositories); |
| List<MavenArtifactInfo> artifacts = new ArrayList<MavenArtifactInfo>(mavenIds.size()); |
| for (MavenId id : mavenIds) { |
| artifacts.add(new MavenArtifactInfo(id, "jar", null)); |
| } |
| final List<MavenArtifact> firstResult = embedder.resolveTransitively(artifacts, remoteRepositories); |
| for (MavenArtifact artifact : firstResult) { |
| if (!artifact.isResolved()) continue; |
| if (MavenConstants.SCOPE_TEST.equals(artifact.getScope())) continue; |
| result.add(artifact); |
| } |
| // download docs & sources |
| if (!extraTypes.isEmpty()) { |
| final HashSet<String> allowedClassifiers = new HashSet<String>(); |
| final Collection<MavenArtifactInfo> resolve = new LinkedHashSet<MavenArtifactInfo>(); |
| for (MavenExtraArtifactType extraType : extraTypes) { |
| allowedClassifiers.add(extraType.getDefaultClassifier()); |
| for (MavenId id : mavenIds) { |
| resolve.add(new MavenArtifactInfo(id, extraType.getDefaultExtension(), extraType.getDefaultClassifier())); |
| } |
| // skip sources/javadoc for dependencies |
| } |
| final List<MavenArtifact> secondResult = |
| embedder.resolveTransitively(new ArrayList<MavenArtifactInfo>(resolve), remoteRepositories); |
| for (MavenArtifact artifact : secondResult) { |
| if (!artifact.isResolved()) continue; |
| if (MavenConstants.SCOPE_TEST.equals(artifact.getScope())) continue; |
| if (!allowedClassifiers.contains(artifact.getClassifier())) continue; |
| result.add(artifact); |
| } |
| } |
| } |
| catch (MavenProcessCanceledException e) { |
| cancelled = true; |
| } |
| finally { |
| manager.release(embedder); |
| if (!cancelled) { |
| ApplicationManager.getApplication().invokeAndWait(new Runnable() { |
| public void run() { |
| resultProcessor.process(new ArrayList<MavenArtifact>(result)); |
| } |
| }, indicator.getModalityState()); |
| } |
| } |
| } |
| |
| private static List<MavenRemoteRepository> convertRepositories(Collection<MavenRepositoryInfo> infos) { |
| List<MavenRemoteRepository> result = new ArrayList<MavenRemoteRepository>(infos.size()); |
| for (MavenRepositoryInfo each : infos) { |
| if (each.getUrl() != null) { |
| result.add(new MavenRemoteRepository(each.getId(), each.getName(), each.getUrl(), null, null, null)); |
| } |
| } |
| return result; |
| } |
| |
| public static MavenId getMavenId(final String coord) { |
| final String[] parts = coord.split(":"); |
| return new MavenId(parts.length > 0 ? parts[0] : null, |
| parts.length > 1 ? parts[1] : null, |
| parts.length > 2 ? parts[2] : null); |
| } |
| } |
