Skip to content

Cache all interpolated models #698

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

Closed
gnodet wants to merge 2 commits into from
Closed

Cache all interpolated models #698

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
4eab8d9
Cache all interpolated models
gnodet Mar 17, 2022
b92207a
Fix some ITs
gnodet Mar 17, 2022
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
259 changes: 190 additions & 69 deletions maven-model-builder/src/main/java/org/apache/maven/model/building/DefaultModelBuilder.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -103,6 +103,36 @@
public class DefaultModelBuilder
implements ModelBuilder
{
/**
* The tag used for the file model without profile activation
* @since 4.0.0
*/
private static final ModelCacheTag<InterpolatedModel> INTERPOLATED = new ModelCacheTag<InterpolatedModel>()
{
@Override
public String getName()
{
return "interpolated";
}

@Override
public Class<InterpolatedModel> getType()
{
return InterpolatedModel.class;
}

@Override
public InterpolatedModel intoCache( InterpolatedModel data )
{
return data;
}

@Override
public InterpolatedModel fromCache( InterpolatedModel data )
{
return data;
}
};
private final ModelMerger modelMerger = new FileToRawModelMerger();

private final ModelProcessor modelProcessor;
Expand Down Expand Up @@ -517,13 +547,11 @@ private Model readEffectiveModel( final ModelBuildingRequest request, final Defa
DefaultModelProblemCollector problems )
throws ModelBuildingException
{
Model inputModel =
readRawModel( request, problems );
Model inputModel = readRawModel( request, problems );

problems.setRootModel( inputModel );

ModelData resultData = new ModelData( request.getModelSource(), inputModel );
ModelData superData = new ModelData( null, getSuperModel() );

// profile activation
DefaultProfileActivationContext profileActivationContext = getProfileActivationContext( request );
Expand All @@ -545,110 +573,166 @@ private Model readEffectiveModel( final ModelBuildingRequest request, final Defa

List<Model> lineage = new ArrayList<>();

for ( ModelData currentData = resultData; ; )
{
String modelId = currentData.getId();
result.addModelId( modelId );
getModelData( request, result, problems, profileActivationContext,
activeExternalProfiles, parentIds, lineage, resultData );

Model rawModel = currentData.getModel();
result.setRawModel( modelId, rawModel );
problems.setSource( result.getRawModel() );

profileActivationContext.setProjectProperties( rawModel.getProperties() );
problems.setSource( rawModel );
List<Profile> activePomProfiles = profileSelector.getActiveProfiles( rawModel.getProfiles(),
profileActivationContext, problems );
result.setActivePomProfiles( modelId, activePomProfiles );
Model resultModel = lineage.get( 0 );

// consider caching inherited model

Model tmpModel = rawModel.clone();
problems.setSource( resultModel );
problems.setRootModel( resultModel );

problems.setSource( tmpModel );
// model interpolation
resultModel = interpolateModel( resultModel.clone(), request, problems );

// model normalization
modelNormalizer.mergeDuplicates( tmpModel, request, problems );
// url normalization
modelUrlNormalizer.normalize( resultModel, request );

profileActivationContext.setProjectProperties( tmpModel.getProperties() );
result.setEffectiveModel( resultModel );

Map<String, Activation> interpolatedActivations = getInterpolatedActivations( rawModel,
profileActivationContext,
problems );
injectProfileActivations( tmpModel, interpolatedActivations );
// Now the fully interpolated model is available: reconfigure the resolver
configureResolver( request.getModelResolver(), resultModel, problems, true );

// profile injection
for ( Profile activeProfile : result.getActivePomProfiles( modelId ) )
{
profileInjector.injectProfile( tmpModel, activeProfile, request, problems );
}
return resultModel;
}

if ( currentData == resultData )
private void getModelData( ModelBuildingRequest request,
DefaultModelBuildingResult result,
DefaultModelProblemCollector problems,
DefaultProfileActivationContext profileActivationContext,
List<Profile> activeExternalProfiles,
Collection<String> parentIds,
List<Model> lineage,
ModelData currentData ) throws ModelBuildingException
{
ModelCache cache = request.getModelCache();
if ( cache != null )
{
InterpolatedModel interpolated =
cache.get( currentData.getSource(), INTERPOLATED );
if ( interpolated != null )
{
for ( Profile activeProfile : activeExternalProfiles )
Model model = interpolated.getModel();
if ( activeExternalProfiles != null )
{
result.setEffectiveModel( model );
}
lineage.add( model );
for ( InterpolatedModel m = interpolated; m != null; m = m.getParent() )
{
profileInjector.injectProfile( tmpModel, activeProfile, request, problems );
result.addModelId( m.getModelId() );
result.setRawModel( m.getModelId(), m.getModel() );
result.setActivePomProfiles( m.getModelId(), m.getProfiles() );
}
result.setEffectiveModel( tmpModel );
return;
}
}

String modelId = currentData.getId();
result.addModelId( modelId );

Model rawModel = currentData.getModel();
result.setRawModel( modelId, rawModel );

profileActivationContext.setProjectProperties( rawModel.getProperties() );
problems.setSource( rawModel );
List<Profile> activePomProfiles = profileSelector.getActiveProfiles( rawModel.getProfiles(),
profileActivationContext, problems );
result.setActivePomProfiles( modelId, activePomProfiles );

lineage.add( tmpModel );
Model tmpModel = rawModel.clone();

problems.setSource( tmpModel );

// model normalization
modelNormalizer.mergeDuplicates( tmpModel, request, problems );

profileActivationContext.setProjectProperties( tmpModel.getProperties() );

Map<String, Activation> interpolatedActivations = getInterpolatedActivations( rawModel,
profileActivationContext,
problems );
injectProfileActivations( tmpModel, interpolatedActivations );

// profile injection
for ( Profile activeProfile : activePomProfiles )
{
profileInjector.injectProfile( tmpModel, activeProfile, request, problems );
}

if ( currentData == superData )
if ( activeExternalProfiles != null )
{
for ( Profile activeProfile : activeExternalProfiles )
{
break;
profileInjector.injectProfile( tmpModel, activeProfile, request, problems );
}
result.setEffectiveModel( tmpModel );
}

List<Model> tmpLineage = new ArrayList<>();

tmpLineage.add( tmpModel );

InterpolatedModel parentInterpolatedModel = null;
if ( currentData.getSource() != null )
{
configureResolver( request.getModelResolver(), tmpModel, problems );

ModelData parentData =
readParent( currentData.getModel(), currentData.getSource(), request, result, problems );
readParent( currentData.getModel(), currentData.getSource(), request, result, problems );

if ( parentData == null )
{
currentData = superData;
parentData = new ModelData( null, getSuperModel() );
}
else if ( !parentIds.add( parentData.getId() ) )
if ( !parentIds.add( parentData.getId() ) )
{
StringBuilder message = new StringBuilder( "The parents form a cycle: " );
for ( String parentId : parentIds )
{
message.append( parentId ).append( " -> " );
}
message.append( parentData.getId() );

problems.add( new ModelProblemCollectorRequest( ModelProblem.Severity.FATAL, ModelProblem.Version.BASE )
.setMessage( message.toString() ) );

throw problems.newModelBuildingException();
throw newCycleException( problems, parentIds, parentData );
}
else
{
currentData = parentData;
getModelData( request, result, problems, profileActivationContext,
null, parentIds, tmpLineage, parentData );
if ( cache != null )
{
parentInterpolatedModel = cache.get( parentData.getSource(), INTERPOLATED );
}
}
}

problems.setSource( result.getRawModel() );
checkPluginVersions( lineage, request, problems );
checkPluginVersions( tmpLineage, request, problems );

// inheritance assembly
assembleInheritance( lineage, request, problems );

Model resultModel = lineage.get( 0 );
assembleInheritance( tmpLineage, request, problems );

// consider caching inherited model

problems.setSource( resultModel );
problems.setRootModel( resultModel );

// model interpolation
resultModel = interpolateModel( resultModel, request, problems );

// url normalization
modelUrlNormalizer.normalize( resultModel, request );
Model interpolated = tmpLineage.get( 0 );
lineage.add( interpolated );
if ( cache != null )
{
cache.put( currentData.getSource(), INTERPOLATED,
new InterpolatedModel( modelId, interpolated,
activePomProfiles, parentInterpolatedModel ) );
}
}

result.setEffectiveModel( resultModel );
private ModelBuildingException newCycleException( DefaultModelProblemCollector problems,
Collection<String> parentIds,
ModelData parentData )
{
StringBuilder message = new StringBuilder( "The parents form a cycle: " );
for ( String parentId : parentIds )
{
message.append( parentId ).append( " -> " );
}
message.append( parentData.getId() );

// Now the fully interpolated model is available: reconfigure the resolver
configureResolver( request.getModelResolver(), resultModel, problems, true );
problems.add( new ModelProblemCollectorRequest( Severity.FATAL, Version.BASE )
.setMessage( message.toString() ) );

return resultModel;
return problems.newModelBuildingException();
}

private Map<String, Activation> getInterpolatedActivations( Model rawModel,
Expand Down Expand Up @@ -1775,6 +1859,43 @@ protected boolean hasFatalErrors( ModelProblemCollectorExt problems )
}
}

private static class InterpolatedModel
{
private final String modelId;
private final Model model;
private final List<Profile> profiles;
private final InterpolatedModel parent;

InterpolatedModel( String modelId, Model model, List<Profile> profiles,
InterpolatedModel parent )
{
this.modelId = modelId;
this.model = model;
this.profiles = profiles;
this.parent = parent;
}

public String getModelId()
{
return modelId;
}

public Model getModel()
{
return model;
}

public List<Profile> getProfiles()
{
return profiles;
}

public InterpolatedModel getParent()
{
return parent;
}
}

/**
* Builds up the transformer context.
* After the buildplan is ready, the build()-method returns the immutable context useful during distribution.
Expand Down