}
}
protected TargetPlatform doResolvePlatform(final MavenSession session, final MavenProject project,
List<ReactorProject> reactorProjects, List<Dependency> dependencies, P2Resolver resolver) {
TargetPlatformConfiguration configuration = (TargetPlatformConfiguration) project
.getContextValue(TychoConstants.CTX_TARGET_PLATFORM_CONFIGURATION);
resolver.setRepositoryCache(repositoryCache);
resolver.setOffline(session.isOffline());
resolver.setLogger(new P2Logger() {
public void debug(String message) {
if (message != null && message.length() > 0) {
getLogger().info(message); // TODO
}
}
public void info(String message) {
if (message != null && message.length() > 0) {
getLogger().info(message);
}
}
public boolean isDebugEnabled() {
return getLogger().isDebugEnabled() && DebugUtils.isDebugEnabled(session, project);
}
});
Map<File, ReactorProject> projects = new HashMap<File, ReactorProject>();
resolver.setLocalRepositoryLocation(new File(session.getLocalRepository().getBasedir()));
resolver.setEnvironments(getEnvironments(configuration));
for (ReactorProject otherProject : reactorProjects) {
if (getLogger().isDebugEnabled()) {
getLogger().debug("P2resolver.addMavenProject " + otherProject.getId());
}
projects.put(otherProject.getBasedir(), otherProject);
resolver.addReactorArtifact(new ReactorArtifactFacade(otherProject, null));
Map<String, Set<Object>> dependencyMetadata = otherProject.getDependencyMetadata();
if (dependencyMetadata != null) {
for (String classifier : dependencyMetadata.keySet()) {
resolver.addReactorArtifact(new ReactorArtifactFacade(otherProject, classifier));
}
}
}
if (dependencies != null) {
for (Dependency dependency : dependencies) {
resolver.addDependency(dependency.getType(), dependency.getArtifactId(), dependency.getVersion());
}
}
if (TargetPlatformConfiguration.POM_DEPENDENCIES_CONSIDER.equals(configuration.getPomDependencies())) {
Set<String> projectIds = new HashSet<String>();
for (ReactorProject p : reactorProjects) {
String key = ArtifactUtils.key(p.getGroupId(), p.getArtifactId(), p.getVersion());
projectIds.add(key);
}
ArrayList<String> scopes = new ArrayList<String>();
scopes.add(Artifact.SCOPE_COMPILE);
Collection<Artifact> artifacts;
try {
artifacts = projectDependenciesResolver.resolve(project, scopes, session);
} catch (MultipleArtifactsNotFoundException e) {
Collection<Artifact> missing = new HashSet<Artifact>(e.getMissingArtifacts());
for (Iterator<Artifact> it = missing.iterator(); it.hasNext();) {
Artifact a = it.next();
String key = ArtifactUtils.key(a.getGroupId(), a.getArtifactId(), a.getBaseVersion());
if (projectIds.contains(key)) {
it.remove();
}
}
if (!missing.isEmpty()) {
throw new RuntimeException("Could not resolve project dependencies", e);
}
artifacts = e.getResolvedArtifacts();
artifacts.removeAll(e.getMissingArtifacts());
} catch (AbstractArtifactResolutionException e) {
throw new RuntimeException("Could not resolve project dependencies", e);
}
for (Artifact artifact : artifacts) {
String key = ArtifactUtils.key(artifact.getGroupId(), artifact.getArtifactId(),
artifact.getBaseVersion());
if (projectIds.contains(key)) {
// resolved to an older snapshot from the repo, we only want the current project in the reactor
continue;
}
if (getLogger().isDebugEnabled()) {
getLogger().debug("P2resolver.addMavenArtifact " + artifact.toString());
}
resolver.addMavenArtifact(new ArtifactFacade(artifact));
}
}
for (ArtifactRepository repository : project.getRemoteArtifactRepositories()) {
try {
URI uri = new URL(repository.getUrl()).toURI();
if (repository.getLayout() instanceof P2ArtifactRepositoryLayout) {
if (session.isOffline()) {
getLogger().debug(
"Offline mode, using local cache only for repository " + repository.getId() + " ("
+ repository.getUrl() + ")");
}
try {
Authentication auth = repository.getAuthentication();
if (auth != null) {
resolver.setCredentials(uri, auth.getUsername(), auth.getPassword());
}
resolver.addP2Repository(uri);
getLogger().debug(
"Added p2 repository " + repository.getId() + " (" + repository.getUrl() + ")");
} catch (Exception e) {
String msg = "Failed to access p2 repository " + repository.getId() + " ("
+ repository.getUrl() + "), will try to use local cache. Reason: " + e.getMessage();
if (getLogger().isDebugEnabled()) {
getLogger().warn(msg, e);
} else {
getLogger().warn(msg);
}
}
} else {
if (!configuration.isIgnoreTychoRepositories() && !session.isOffline()) {
try {
MavenRepositoryReader reader = plexus.lookup(MavenRepositoryReader.class);
reader.setArtifactRepository(repository);
reader.setLocalRepository(session.getLocalRepository());
String repositoryKey = getRepositoryKey(repository);
TychoRepositoryIndex index = repositoryCache.getRepositoryIndex(repositoryKey);
if (index == null) {
index = new DefaultTychoRepositoryIndex(reader);
repositoryCache.putRepositoryIndex(repositoryKey, index);
}
resolver.addMavenRepository(uri, index, reader);
getLogger().debug(
"Added Maven repository " + repository.getId() + " (" + repository.getUrl() + ")");
} catch (FileNotFoundException e) {
// it happens
} catch (Exception e) {
getLogger().debug("Unable to initialize remote Tycho repository", e);
}
} else {
String msg = "Ignoring Maven repository " + repository.getId() + " (" + repository.getUrl()
+ ")";
if (session.isOffline()) {
msg += " while in offline mode";
}
getLogger().debug(msg);
}
}
} catch (MalformedURLException e) {
getLogger().warn("Could not parse repository URL", e);
} catch (URISyntaxException e) {
getLogger().warn("Could not parse repository URL", e);
}
}
Target target = configuration.getTarget();
if (target != null) {
Set<URI> uris = new HashSet<URI>();
for (Target.Location location : target.getLocations()) {
String type = location.getType();
if (!"InstallableUnit".equalsIgnoreCase(type)) {
getLogger().warn("Target location type: " + type + " is not supported");
continue;
}
for (Target.Repository repository : location.getRepositories()) {
try {
URI uri = new URI(getMirror(repository, session.getRequest().getMirrors()));
if (uris.add(uri)) {
if (session.isOffline()) {
getLogger().debug("Ignored repository " + uri + " while in offline mode");
} else {
String id = repository.getId();
if (id != null) {
Server server = session.getSettings().getServer(id);
if (server != null) {
resolver.setCredentials(uri, server.getUsername(), server.getPassword());
} else {
getLogger().info(
"Unknown server id=" + id + " for repository location="
+ repository.getLocation());
}
}
try {
resolver.addP2Repository(uri);
} catch (Exception e) {
String msg = "Failed to access p2 repository " + uri
+ ", will try to use local cache. Reason: " + e.getMessage();
if (getLogger().isDebugEnabled()) {
getLogger().warn(msg, e);
} else {
getLogger().warn(msg);
}
}
}
}
} catch (URISyntaxException e) {
getLogger().debug("Could not parse repository URL", e);
}
}
for (Target.Unit unit : location.getUnits()) {
String versionRange;
if ("0.0.0".equals(unit.getVersion())) {
versionRange = unit.getVersion();
} else {
// perfect version match
versionRange = "[" + unit.getVersion() + "," + unit.getVersion() + "]";
}
resolver.addDependency(P2Resolver.TYPE_INSTALLABLE_UNIT, unit.getId(), versionRange);
}
}
}
if (!isAllowConflictingDependencies(project, configuration)) {
List<P2ResolutionResult> results = resolver.resolveProject(project.getBasedir());
MultiEnvironmentTargetPlatform multiPlatform = new MultiEnvironmentTargetPlatform();
// FIXME this is just wrong
for (int i = 0; i < configuration.getEnvironments().size(); i++) {
TargetEnvironment environment = configuration.getEnvironments().get(i);
P2ResolutionResult result = results.get(i);
DefaultTargetPlatform platform = newDefaultTargetPlatform(session, projects, result);
// addProjects( session, platform );