Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Strip down ReactorRepositoryManager #3178

Merged
merged 1 commit into from
Dec 8, 2023
Merged

Strip down ReactorRepositoryManager #3178

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 6 additions & 6 deletions tycho-api/src/main/java/org/eclipse/tycho/TargetPlatform.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,7 @@ public interface TargetPlatform {
* Key under which the final target platform is stored in the reactor project instances.
*/
String FINAL_TARGET_PLATFORM_KEY = "org.eclipse.tycho.core.TychoConstants/targetPlatform";
String PRELIMINARY_TARGET_PLATFORM_KEY = "org.eclipse.tycho.core.TychoConstants/dependencyOnlyTargetPlatform";

/**
* Returns an artifact of the given type, id and matching version. The version reference string
Expand Down Expand Up @@ -77,12 +78,11 @@ ArtifactKey resolveArtifact(String type, String id, String versionRef)

default ResolvedArtifactKey resolvePackage(String packageName, String versionRef)
throws DependencyResolutionException, IllegalArtifactReferenceException {
ArtifactKey packageJar = resolveArtifact(PublisherHelper.CAPABILITY_NS_JAVA_PACKAGE, packageName,
versionRef);
File location = getArtifactLocation(new DefaultArtifactKey(ArtifactType.TYPE_ECLIPSE_PLUGIN,
packageJar.getId(), packageJar.getVersion()));
return ResolvedArtifactKey.of(ArtifactType.TYPE_ECLIPSE_PLUGIN, packageJar.getId(),
packageJar.getVersion(), location);
ArtifactKey packageJar = resolveArtifact(PublisherHelper.CAPABILITY_NS_JAVA_PACKAGE, packageName, versionRef);
File location = getArtifactLocation(
new DefaultArtifactKey(ArtifactType.TYPE_ECLIPSE_PLUGIN, packageJar.getId(), packageJar.getVersion()));
return ResolvedArtifactKey.of(ArtifactType.TYPE_ECLIPSE_PLUGIN, packageJar.getId(), packageJar.getVersion(),
location);
}

/**
Expand Down
70 changes: 69 additions & 1 deletion tycho-core/src/main/java/org/eclipse/tycho/core/resolver/DefaultTargetPlatformService.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -36,7 +36,10 @@
import org.eclipse.tycho.core.DependencyResolver;
import org.eclipse.tycho.core.osgitools.DefaultReactorProject;
import org.eclipse.tycho.p2.repository.GAV;
import org.eclipse.tycho.p2.repository.PublishingRepository;
import org.eclipse.tycho.p2.target.facade.PomDependencyCollector;
import org.eclipse.tycho.p2.target.facade.TargetPlatformFactory;
import org.eclipse.tycho.p2resolver.PreliminaryTargetPlatformImpl;
import org.eclipse.tycho.repository.registry.facade.ReactorRepositoryManager;

@Component(role = TargetPlatformService.class)
Expand All @@ -54,6 +57,10 @@ public class DefaultTargetPlatformService implements TargetPlatformService {
@Requirement
ReactorRepositoryManager repositoryManager;

@Requirement
P2ResolverFactory p2ResolverFactory;
private TargetPlatformFactory tpFactory;

@Override
public Optional<TargetPlatform> getTargetPlatform() throws DependencyResolutionException {
MavenSession session = legacySupport.getSession();
Expand Down Expand Up @@ -81,12 +88,73 @@ public Optional<TargetPlatform> getTargetPlatform(ReactorProject project) throws
List<ReactorProjectIdentities> upstreamProjects = getReferencedTychoProjects(project);
PomDependencyCollector pomDependenciesCollector = dependencyResolver.resolvePomDependencies(session,
project.adapt(MavenProject.class));
TargetPlatform finalTargetPlatform = repositoryManager.computeFinalTargetPlatform(project, upstreamProjects,
TargetPlatform finalTargetPlatform = computeFinalTargetPlatform(project, upstreamProjects,
pomDependenciesCollector);
return Optional.ofNullable(finalTargetPlatform);
}
}

/**
* Computes the (immutable) target platform with final p2 metadata and attaches it to the given
* project.
*
* @param project
* the reactor project to compute the target platform for.
* @param upstreamProjects
* Other projects in the reactor which have already been built and may be referenced
* by the given project.
*/
private TargetPlatform computeFinalTargetPlatform(ReactorProject project,
List<? extends ReactorProjectIdentities> upstreamProjects, PomDependencyCollector pomDependencyCollector) {
synchronized (project) {
PreliminaryTargetPlatformImpl preliminaryTargetPlatform = getRegisteredPreliminaryTargetPlatform(project);
if (preliminaryTargetPlatform == null) {
MavenSession session = project.adapt(MavenSession.class);
if (session == null) {
session = legacySupport.getSession();
if (session == null) {
return null;
}
}
MavenProject mavenProject = project.adapt(MavenProject.class);
if (mavenProject == null) {
return null;
}
preliminaryTargetPlatform = (PreliminaryTargetPlatformImpl) dependencyResolver
.computePreliminaryTargetPlatform(session, mavenProject, DefaultReactorProject.adapt(session));

}
List<PublishingRepository> upstreamProjectResults = getBuildResults(upstreamProjects);
TargetPlatform result = getTpFactory().createTargetPlatformWithUpdatedReactorContent(
preliminaryTargetPlatform, upstreamProjectResults, pomDependencyCollector);

project.setContextValue(TargetPlatform.FINAL_TARGET_PLATFORM_KEY, result);
return result;
}
}

private List<PublishingRepository> getBuildResults(List<? extends ReactorProjectIdentities> projects) {
List<PublishingRepository> results = new ArrayList<>(projects.size());
for (ReactorProjectIdentities project : projects) {
results.add(repositoryManager.getPublishingRepository(project));
}
return results;
}

public synchronized TargetPlatformFactory getTpFactory() {
if (tpFactory == null) {
tpFactory = p2ResolverFactory.getTargetPlatformFactory();
}
return tpFactory;
}

private PreliminaryTargetPlatformImpl getRegisteredPreliminaryTargetPlatform(ReactorProject project) {
return project.getContextValue(
TargetPlatform.PRELIMINARY_TARGET_PLATFORM_KEY) instanceof PreliminaryTargetPlatformImpl preliminaryTargetPlatformImpl
? preliminaryTargetPlatformImpl
: null;
}

private List<ReactorProjectIdentities> getReferencedTychoProjects(ReactorProject reactorProject)
throws DependencyResolutionException {
List<ReactorProjectIdentities> result = new ArrayList<>();
Expand Down
40 changes: 38 additions & 2 deletions tycho-core/src/main/java/org/eclipse/tycho/p2resolver/P2DependencyResolver.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -59,6 +59,7 @@
import org.eclipse.tycho.IDependencyMetadata;
import org.eclipse.tycho.IDependencyMetadata.DependencyMetadataType;
import org.eclipse.tycho.IllegalArtifactReferenceException;
import org.eclipse.tycho.MavenArtifactRepositoryReference;
import org.eclipse.tycho.MavenDependencyDescriptor;
import org.eclipse.tycho.MavenRepositoryLocation;
import org.eclipse.tycho.OptionalResolutionAction;
Expand Down Expand Up @@ -91,9 +92,11 @@
import org.eclipse.tycho.p2.repository.LocalRepositoryP2Indices;
import org.eclipse.tycho.p2.target.facade.PomDependencyCollector;
import org.eclipse.tycho.p2.target.facade.TargetPlatformConfigurationStub;
import org.eclipse.tycho.p2.target.facade.TargetPlatformFactory;
import org.eclipse.tycho.p2maven.repository.P2ArtifactRepositoryLayout;
import org.eclipse.tycho.repository.registry.facade.ReactorRepositoryManager;
import org.eclipse.tycho.resolver.P2MetadataProvider;
import org.eclipse.tycho.targetplatform.TargetDefinition.MavenGAVLocation;
import org.eclipse.tycho.targetplatform.TargetDefinitionFile;

@Component(role = DependencyResolver.class, hint = P2DependencyResolver.ROLE_HINT, instantiationStrategy = "per-lookup")
Expand Down Expand Up @@ -140,6 +143,8 @@ public class P2DependencyResolver extends AbstractLogEnabled implements Dependen
@Requirement
private MavenDependenciesResolver dependenciesResolver;

private TargetPlatformFactory tpFactory;

@Override
public void setupProjects(final MavenSession session, final MavenProject project,
final ReactorProject reactorProject) {
Expand Down Expand Up @@ -212,8 +217,39 @@ public TargetPlatform computePreliminaryTargetPlatform(MavenSession session, Mav
.setIgnoreLocalArtifacts(configuration.getIgnoreLocalArtifacts() == LocalArtifactHandling.ignore);
tpConfiguration.setReferencedRepositoryMode(configuration.getReferencedRepositoryMode());

return reactorRepositoryManager.computePreliminaryTargetPlatform(reactorProject, tpConfiguration, ee,
reactorProjects);
return computePreliminaryTargetPlatform(reactorProject, tpConfiguration, ee, reactorProjects);
}

/**
* Computes the target platform with dependency-only p2 metadata and attaches it to the given
* project.
*
* @param project
* the reactor project to compute the target platform for.
* @param resolvedEnvironment
*/
private TargetPlatform computePreliminaryTargetPlatform(ReactorProject project,
TargetPlatformConfigurationStub tpConfiguration, ExecutionEnvironmentConfiguration eeConfiguration,
List<ReactorProject> reactorProjects) {
//
// at this point, there is only incomplete ("dependency-only") metadata for the reactor projects
TargetPlatform result = getTpFactory().createTargetPlatform(tpConfiguration, eeConfiguration, reactorProjects,
project);
project.setContextValue(TargetPlatform.PRELIMINARY_TARGET_PLATFORM_KEY, result);

List<MavenArtifactRepositoryReference> repositoryReferences = tpConfiguration.getTargetDefinitions().stream()
.flatMap(definition -> definition.getLocations().stream()).filter(MavenGAVLocation.class::isInstance)
.map(MavenGAVLocation.class::cast).flatMap(location -> location.getRepositoryReferences().stream())
.toList();
project.setContextValue(TychoConstants.CTX_REPOSITORY_REFERENCE, repositoryReferences);
return result;
}

public synchronized TargetPlatformFactory getTpFactory() {
if (tpFactory == null) {
tpFactory = resolverFactory.getTargetPlatformFactory();
}
return tpFactory;
}

private ReactorProject getThisReactorProject(MavenSession session, MavenProject project,
Expand Down
21 changes: 17 additions & 4 deletions tycho-core/src/main/java/org/eclipse/tycho/p2resolver/PublisherServiceFactoryImpl.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -19,6 +19,7 @@
import org.eclipse.tycho.Interpolator;
import org.eclipse.tycho.ReactorProject;
import org.eclipse.tycho.TargetEnvironment;
import org.eclipse.tycho.TargetPlatform;
import org.eclipse.tycho.core.shared.MavenContext;
import org.eclipse.tycho.p2.repository.PublishingRepository;
import org.eclipse.tycho.p2.tools.publisher.PublishProductToolImpl;
Expand All @@ -40,24 +41,36 @@ public class PublisherServiceFactoryImpl implements PublisherServiceFactory {

@Override
public PublisherService createPublisher(ReactorProject project, List<TargetEnvironment> environments) {
P2TargetPlatform targetPlatform = (P2TargetPlatform) reactorRepoManager.getFinalTargetPlatform(project);
P2TargetPlatform targetPlatform = (P2TargetPlatform) getFinalTargetPlatform(project);
PublisherActionRunner publisherRunner = getPublisherRunnerForProject(targetPlatform, environments);
PublishingRepository publishingRepository = reactorRepoManager.getPublishingRepository(project.getIdentities());
PublishingRepository publishingRepository = reactorRepoManager.getPublishingRepository(project);

return new PublisherServiceImpl(publisherRunner, project.getBuildQualifier(), publishingRepository);
}

@Override
public PublishProductTool createProductPublisher(ReactorProject project, List<TargetEnvironment> environments,
String buildQualifier, Interpolator interpolator) {
P2TargetPlatform targetPlatform = (P2TargetPlatform) reactorRepoManager.getFinalTargetPlatform(project);
P2TargetPlatform targetPlatform = (P2TargetPlatform) getFinalTargetPlatform(project);
PublisherActionRunner publisherRunner = getPublisherRunnerForProject(targetPlatform, environments);
PublishingRepository publishingRepository = reactorRepoManager.getPublishingRepository(project.getIdentities());
PublishingRepository publishingRepository = reactorRepoManager.getPublishingRepository(project);

return new PublishProductToolImpl(publisherRunner, publishingRepository, targetPlatform, buildQualifier,
interpolator, mavenContext.getLogger());
}

/**
* Returns the target platform with final p2 metadata for the given project.
*/
private TargetPlatform getFinalTargetPlatform(ReactorProject project) {
TargetPlatform targetPlatform = (TargetPlatform) project
.getContextValue(TargetPlatform.FINAL_TARGET_PLATFORM_KEY);
if (targetPlatform == null) {
throw new IllegalStateException("Target platform is missing");
}
return targetPlatform;
}

private PublisherActionRunner getPublisherRunnerForProject(P2TargetPlatform targetPlatform,
List<TargetEnvironment> environments) {
checkCollaborators();
Expand Down
110 changes: 0 additions & 110 deletions tycho-core/src/main/java/org/eclipse/tycho/p2resolver/ReactorRepositoryManagerImpl.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,133 +13,23 @@
*******************************************************************************/
package org.eclipse.tycho.p2resolver;

import java.util.ArrayList;
import java.util.List;

import org.apache.maven.execution.MavenSession;
import org.apache.maven.plugin.LegacySupport;
import org.apache.maven.project.MavenProject;
import org.codehaus.plexus.component.annotations.Component;
import org.codehaus.plexus.component.annotations.Requirement;
import org.eclipse.equinox.p2.core.IProvisioningAgent;
import org.eclipse.tycho.ExecutionEnvironmentConfiguration;
import org.eclipse.tycho.MavenArtifactRepositoryReference;
import org.eclipse.tycho.ReactorProject;
import org.eclipse.tycho.ReactorProjectIdentities;
import org.eclipse.tycho.TargetPlatform;
import org.eclipse.tycho.TychoConstants;
import org.eclipse.tycho.core.DependencyResolver;
import org.eclipse.tycho.core.osgitools.DefaultReactorProject;
import org.eclipse.tycho.core.resolver.P2ResolverFactory;
import org.eclipse.tycho.p2.repository.PublishingRepository;
import org.eclipse.tycho.p2.repository.module.PublishingRepositoryImpl;
import org.eclipse.tycho.p2.target.facade.PomDependencyCollector;
import org.eclipse.tycho.p2.target.facade.TargetPlatformConfigurationStub;
import org.eclipse.tycho.p2.target.facade.TargetPlatformFactory;
import org.eclipse.tycho.repository.registry.facade.ReactorRepositoryManager;
import org.eclipse.tycho.targetplatform.TargetDefinition.MavenGAVLocation;

@Component(role = ReactorRepositoryManager.class)
public class ReactorRepositoryManagerImpl implements ReactorRepositoryManager {

private static final String PRELIMINARY_TARGET_PLATFORM_KEY = ReactorRepositoryManagerImpl.class.getName()
+ "/dependencyOnlyTargetPlatform";

@Requirement
IProvisioningAgent agent;
@Requirement
P2ResolverFactory p2ResolverFactory;

@Requirement(hint = P2DependencyResolver.ROLE_HINT)
DependencyResolver p2Resolver;

@Requirement
LegacySupport legacySupport;
private TargetPlatformFactory tpFactory;

@Override
public PublishingRepository getPublishingRepository(ReactorProjectIdentities project) {
return new PublishingRepositoryImpl(agent, project);
}

@Override
public TargetPlatform computePreliminaryTargetPlatform(ReactorProject project,
TargetPlatformConfigurationStub tpConfiguration, ExecutionEnvironmentConfiguration eeConfiguration,
List<ReactorProject> reactorProjects) {
//
// at this point, there is only incomplete ("dependency-only") metadata for the reactor projects
TargetPlatform result = getTpFactory().createTargetPlatform(tpConfiguration, eeConfiguration, reactorProjects,
project);
project.setContextValue(PRELIMINARY_TARGET_PLATFORM_KEY, result);

List<MavenArtifactRepositoryReference> repositoryReferences = tpConfiguration.getTargetDefinitions().stream()
.flatMap(definition -> definition.getLocations().stream()).filter(MavenGAVLocation.class::isInstance)
.map(MavenGAVLocation.class::cast).flatMap(location -> location.getRepositoryReferences().stream())
.toList();
project.setContextValue(TychoConstants.CTX_REPOSITORY_REFERENCE, repositoryReferences);
return result;
}

@Override
public TargetPlatform computeFinalTargetPlatform(ReactorProject project,
List<? extends ReactorProjectIdentities> upstreamProjects, PomDependencyCollector pomDependencyCollector) {
synchronized (project) {
PreliminaryTargetPlatformImpl preliminaryTargetPlatform = getRegisteredPreliminaryTargetPlatform(project);
if (preliminaryTargetPlatform == null) {
MavenSession session = project.adapt(MavenSession.class);
if (session == null) {
session = legacySupport.getSession();
if (session == null) {
return null;
}
}
MavenProject mavenProject = project.adapt(MavenProject.class);
if (mavenProject == null) {
return null;
}
preliminaryTargetPlatform = (PreliminaryTargetPlatformImpl) p2Resolver
.computePreliminaryTargetPlatform(session, mavenProject, DefaultReactorProject.adapt(session));

}
List<PublishingRepository> upstreamProjectResults = getBuildResults(upstreamProjects);
TargetPlatform result = getTpFactory().createTargetPlatformWithUpdatedReactorContent(
preliminaryTargetPlatform, upstreamProjectResults, pomDependencyCollector);

project.setContextValue(TargetPlatform.FINAL_TARGET_PLATFORM_KEY, result);
return result;
}
}

private PreliminaryTargetPlatformImpl getRegisteredPreliminaryTargetPlatform(ReactorProject project) {
return project.getContextValue(
PRELIMINARY_TARGET_PLATFORM_KEY) instanceof PreliminaryTargetPlatformImpl preliminaryTargetPlatformImpl
? preliminaryTargetPlatformImpl
: null;
}

private List<PublishingRepository> getBuildResults(List<? extends ReactorProjectIdentities> projects) {
List<PublishingRepository> results = new ArrayList<>(projects.size());
for (ReactorProjectIdentities project : projects) {
results.add(getPublishingRepository(project));
}
return results;
}

@Override
public TargetPlatform getFinalTargetPlatform(ReactorProject project) {
TargetPlatform targetPlatform = (TargetPlatform) project
.getContextValue(TargetPlatform.FINAL_TARGET_PLATFORM_KEY);
if (targetPlatform == null) {
throw new IllegalStateException("Target platform is missing");
}
return targetPlatform;
}

public synchronized TargetPlatformFactory getTpFactory() {
if (tpFactory == null) {
tpFactory = p2ResolverFactory.getTargetPlatformFactory();
}
return tpFactory;
}

}
Loading
Loading