1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
package com.intellij.facet.frameworks;
import com.intellij.facet.frameworks.beans.Artifact;
import com.intellij.facet.frameworks.beans.ArtifactItem;
import com.intellij.facet.frameworks.beans.Artifacts;
import com.intellij.facet.ui.libraries.LibraryInfo;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.Condition;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.containers.HashSet;
import com.intellij.util.net.HttpConfigurable;
import com.intellij.util.xmlb.XmlSerializationException;
import com.intellij.util.xmlb.XmlSerializer;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
public class LibrariesDownloadAssistant {
private static final Logger LOG = Logger.getInstance("#com.intellij.LibrariesDownloadAssistant");
private LibrariesDownloadAssistant() {
}
@NotNull
public static Artifact[] getVersions(@NotNull String groupId, @NotNull URL... localUrls) {
final Artifact[] versions = getDownloadServiceVersions(groupId);
return versions == null ? getVersions(localUrls) : versions;
}
@Nullable
private static Artifact[] getDownloadServiceVersions(@NotNull String id) {
final URL url = createVersionsUrl(id);
if (url == null) return null;
final Artifacts allArtifacts = deserialize(url);
return allArtifacts == null ? null : allArtifacts.getArtifacts();
}
@Nullable
private static URL createVersionsUrl(@NotNull String id) {
final String serviceUrl = LibrariesDownloadConnectionService.getInstance().getServiceUrl();
if (StringUtil.isNotEmpty(serviceUrl)) {
try {
final String url = serviceUrl + "/" + id + "/";
HttpConfigurable.getInstance().prepareURL(url);
return new URL(url);
}
catch (MalformedURLException e) {
LOG.error(e);
}
catch (IOException e) {
// no route to host, unknown host, etc.
}
}
return null;
}
@NotNull
public static Artifact[] getVersions(@NotNull URL... urls) {
Set<Artifact> versions = new HashSet<Artifact>();
for (URL url : urls) {
final Artifacts allArtifacts = deserialize(url);
if (allArtifacts != null) {
final Artifact[] vers = allArtifacts.getArtifacts();
if (vers != null) {
versions.addAll(Arrays.asList(vers));
}
}
}
return versions.toArray(new Artifact[versions.size()]);
}
@Nullable
private static Artifacts deserialize(@Nullable URL url) {
if (url == null) return null;
Artifacts allArtifacts = null;
try {
allArtifacts = XmlSerializer.deserialize(url, Artifacts.class);
}
catch (XmlSerializationException e) {
final Throwable cause = e.getCause();
if (!(cause instanceof IOException)) {
LOG.error(e);
}
}
return allArtifacts;
}
@Nullable
public static Artifact findVersion(@NotNull final String versionId, @NotNull final URL... urls) {
return findVersion(getVersions(urls), versionId);
}
@Nullable
private static Artifact findVersion(@Nullable Artifact[] versions, @NotNull final String versionId) {
return versions == null ? null : ContainerUtil.find(versions, new Condition<Artifact>() {
@Override
public boolean value(final Artifact springVersion) {
return versionId.equals(springVersion.getVersion());
}
});
}
@NotNull
public static LibraryInfo[] getLibraryInfos(@NotNull final URL url, @NotNull final String versionId) {
final Artifact version = findVersion(getVersions(url), versionId);
return version != null ? getLibraryInfos(version) : LibraryInfo.EMPTY_ARRAY;
}
@NotNull
public static LibraryInfo[] getLibraryInfos(@Nullable Artifact version) {
if (version == null) return LibraryInfo.EMPTY_ARRAY;
final List<LibraryInfo> infos = convert(version.getUrlPrefix(), version.getItems());
return infos.toArray(new LibraryInfo[infos.size()]);
}
@NotNull
private static List<LibraryInfo> convert(final String urlPrefix, @NotNull ArtifactItem[] jars) {
return ContainerUtil.mapNotNull(jars, new Function<ArtifactItem, LibraryInfo>() {
@Override
public LibraryInfo fun(ArtifactItem artifactItem) {
String downloadUrl = artifactItem.getUrl();
if (urlPrefix != null) {
if (downloadUrl == null) {
downloadUrl = artifactItem.getName();
}
if (!downloadUrl.startsWith("http://")) {
downloadUrl = urlPrefix + downloadUrl;
}
}
return new LibraryInfo(artifactItem.getName(), downloadUrl, downloadUrl, artifactItem.getMD5(), artifactItem.getRequiredClasses());
}
});
}
}
|
