@NotNull
@Override
public List<MavenArtifact> resolveTransitively(
@NotNull List<MavenArtifactInfo> artifacts,
@NotNull List<MavenRemoteRepository> remoteRepositories)
throws RemoteException, MavenServerProcessCanceledException {
try {
Set<Artifact> toResolve = new LinkedHashSet<Artifact>();
for (MavenArtifactInfo each : artifacts) {
toResolve.add(createArtifact(each));
}
Artifact project =
getComponent(ArtifactFactory.class).createBuildArtifact("temp", "temp", "666", "pom");
Set<Artifact> res =
getComponent(ArtifactResolver.class)
.resolveTransitively(
toResolve,
project,
Collections.EMPTY_MAP,
myLocalRepository,
convertRepositories(remoteRepositories),
getComponent(ArtifactMetadataSource.class))
.getArtifacts();
return MavenModelConverter.convertArtifacts(
res, new THashMap<Artifact, MavenArtifact>(), getLocalRepositoryFile());
} catch (ArtifactResolutionException e) {
Maven3ServerGlobals.getLogger().info(e);
} catch (ArtifactNotFoundException e) {
Maven3ServerGlobals.getLogger().info(e);
} catch (Exception e) {
throw rethrowException(e);
}
return Collections.emptyList();
}
@NotNull
private MavenServerExecutionResult createExecutionResult(
File file, MavenExecutionResult result, DependencyNode rootNode) throws RemoteException {
Collection<MavenProjectProblem> problems = MavenProjectProblem.createProblemsList();
THashSet<MavenId> unresolvedArtifacts = new THashSet<MavenId>();
validate(file, result.getExceptions(), problems, unresolvedArtifacts);
MavenProject mavenProject = result.getMavenProject();
if (mavenProject == null)
return new MavenServerExecutionResult(null, problems, unresolvedArtifacts);
MavenModel model =
MavenModelConverter.convertModel(
mavenProject.getModel(),
mavenProject.getCompileSourceRoots(),
mavenProject.getTestCompileSourceRoots(),
mavenProject.getArtifacts(),
(rootNode == null ? Collections.emptyList() : rootNode.getChildren()),
mavenProject.getExtensionArtifacts(),
getLocalRepositoryFile());
RemoteNativeMavenProjectHolder holder = new RemoteNativeMavenProjectHolder(mavenProject);
try {
UnicastRemoteObject.exportObject(holder, 0);
} catch (RemoteException e) {
throw new RuntimeException(e);
}
Collection<String> activatedProfiles = collectActivatedProfiles(mavenProject);
MavenServerExecutionResult.ProjectData data =
new MavenServerExecutionResult.ProjectData(
model,
MavenModelConverter.convertToMap(mavenProject.getModel()),
holder,
activatedProfiles);
return new MavenServerExecutionResult(data, problems, unresolvedArtifacts);
}
@Override
public Collection<MavenArtifact> resolvePlugin(
@NotNull MavenPlugin plugin,
@NotNull List<MavenRemoteRepository> repositories,
int nativeMavenProjectId,
boolean transitive)
throws RemoteException, MavenServerProcessCanceledException {
try {
Plugin mavenPlugin = new Plugin();
mavenPlugin.setGroupId(plugin.getGroupId());
mavenPlugin.setArtifactId(plugin.getArtifactId());
mavenPlugin.setVersion(plugin.getVersion());
MavenProject project = RemoteNativeMavenProjectHolder.findProjectById(nativeMavenProjectId);
MavenExecutionRequest request =
createRequest(
null,
Collections.<String>emptyList(),
Collections.<String>emptyList(),
Collections.<String>emptyList());
DefaultMaven maven = (DefaultMaven) getComponent(Maven.class);
RepositorySystemSession repositorySystemSession = maven.newRepositorySession(request);
if (plugin.getVersion() == null) {
PluginVersionRequest versionRequest =
new DefaultPluginVersionRequest(
mavenPlugin, repositorySystemSession, project.getRemotePluginRepositories());
mavenPlugin.setVersion(
getComponent(PluginVersionResolver.class).resolve(versionRequest).getVersion());
}
PluginDescriptor result =
getComponent(MavenPluginManager.class)
.getPluginDescriptor(
mavenPlugin, project.getRemotePluginRepositories(), repositorySystemSession);
Map<MavenArtifactInfo, MavenArtifact> resolvedArtifacts =
new THashMap<MavenArtifactInfo, MavenArtifact>();
Artifact pluginArtifact = result.getPluginArtifact();
MavenArtifactInfo artifactInfo =
new MavenArtifactInfo(
pluginArtifact.getGroupId(),
pluginArtifact.getArtifactId(),
pluginArtifact.getVersion(),
pluginArtifact.getType(),
null);
resolveIfNecessary(artifactInfo, repositories, resolvedArtifacts);
if (transitive) {
// todo try to use parallel downloading
for (Artifact each : result.getIntroducedDependencyArtifacts()) {
resolveIfNecessary(
new MavenArtifactInfo(
each.getGroupId(), each.getArtifactId(), each.getVersion(), each.getType(), null),
repositories,
resolvedArtifacts);
}
for (ComponentDependency each : result.getDependencies()) {
resolveIfNecessary(
new MavenArtifactInfo(
each.getGroupId(), each.getArtifactId(), each.getVersion(), each.getType(), null),
repositories,
resolvedArtifacts);
}
}
return new THashSet<MavenArtifact>(resolvedArtifacts.values());
} catch (Exception e) {
Maven3ServerGlobals.getLogger().info(e);
return Collections.emptyList();
}
}
private static MavenExecutionResult handleException(Throwable e) {
if (e instanceof RuntimeException) throw (RuntimeException) e;
if (e instanceof Error) throw (Error) e;
return new MavenExecutionResult(null, Collections.singletonList((Exception) e));
}
@NotNull
public MavenExecutionResult doResolveProject(
@NotNull final File file,
@NotNull final List<String> activeProfiles,
final List<ResolutionListener> listeners)
throws RemoteException {
final MavenExecutionRequest request =
createRequest(
file, activeProfiles, Collections.<String>emptyList(), Collections.<String>emptyList());
final AtomicReference<MavenExecutionResult> ref = new AtomicReference<MavenExecutionResult>();
executeWithMavenSession(
request,
new Runnable() {
@Override
public void run() {
try {
// copied from DefaultMavenProjectBuilder.buildWithDependencies
ProjectBuilder builder = getComponent(ProjectBuilder.class);
ProjectBuildingResult buildingResult =
builder.build(new File(file.getPath()), request.getProjectBuildingRequest());
// builder.calculateConcreteState(project, config, false);
MavenProject project = buildingResult.getProject();
// copied from DefaultLifecycleExecutor.execute
// findExtensions(project);
// end copied from DefaultLifecycleExecutor.execute
// Artifact projectArtifact = project.getArtifact();
// Map managedVersions = project.getManagedVersionMap();
// ArtifactMetadataSource metadataSource = getComponent(ArtifactMetadataSource.class);
project.setDependencyArtifacts(
project.createArtifacts(getComponent(ArtifactFactory.class), null, null));
//
ArtifactResolver resolver = getComponent(ArtifactResolver.class);
ArtifactResolutionRequest resolutionRequest = new ArtifactResolutionRequest();
resolutionRequest.setArtifactDependencies(project.getDependencyArtifacts());
resolutionRequest.setArtifact(project.getArtifact());
resolutionRequest.setManagedVersionMap(project.getManagedVersionMap());
resolutionRequest.setLocalRepository(myLocalRepository);
resolutionRequest.setRemoteRepositories(project.getRemoteArtifactRepositories());
resolutionRequest.setListeners(listeners);
resolutionRequest.setResolveRoot(false);
resolutionRequest.setResolveTransitively(true);
RepositorySystemSession repositorySession =
getComponent(LegacySupport.class).getRepositorySession();
if (repositorySession instanceof DefaultRepositorySystemSession) {
((DefaultRepositorySystemSession) repositorySession)
.setTransferListener(new TransferListenerAdapter(myCurrentIndicator));
if (myWorkspaceMap != null) {
((DefaultRepositorySystemSession) repositorySession)
.setWorkspaceReader(new Maven3WorkspaceReader(myWorkspaceMap));
}
}
ArtifactResolutionResult result = resolver.resolve(resolutionRequest);
project.setArtifacts(result.getArtifacts());
// end copied from DefaultMavenProjectBuilder.buildWithDependencies
ref.set(new MavenExecutionResult(project, new ArrayList<Exception>()));
} catch (Exception e) {
ref.set(handleException(e));
}
}
});
return ref.get();
}
