ModelBuildingRequest req = new DefaultModelBuildingRequest(); req.setProcessPlugins( false ); req.setPomFile( file ); req.setModelResolver( new RepositoryModelResolver( basedir, pathTranslator ) ); req.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL ); Model model; try { model = builder.build( req ).getEffectiveModel(); } catch ( ModelBuildingException e ) { ... }
public ModelValidationResult validate( Model model ) { ModelValidationResult result = new ModelValidationResult(); ModelBuildingRequest request = new DefaultModelBuildingRequest().setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MAVEN_2_0 ); SimpleModelProblemCollector problems = new SimpleModelProblemCollector( result ); modelValidator.validateEffectiveModel( model, request, problems ); return result; }
@Override public Result<? extends Model> buildRawModel( File pomFile, int validationLevel, boolean locationTracking ) { final ModelBuildingRequest request = new DefaultModelBuildingRequest().setValidationLevel( validationLevel ) .setLocationTracking( locationTracking ); final DefaultModelProblemCollector collector = new DefaultModelProblemCollector( new DefaultModelBuildingResult() ); try { return newResult( readModel( null, pomFile, request, collector ), collector.getProblems() ); } catch ( ModelBuildingException e ) { return error( collector.getProblems() ); } }
importRequest = new DefaultModelBuildingRequest(); importRequest.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL ); importRequest.setModelCache( request.getModelCache() );
private ModelBuildingRequest getModelBuildingRequest( InternalConfig config ) { ProjectBuildingRequest configuration = config.request; ModelBuildingRequest request = new DefaultModelBuildingRequest(); RequestTrace trace = RequestTrace.newChild( null, configuration ).newChild( request ); ModelResolver resolver = new ProjectModelResolver( config.session, trace, repoSystem, repositoryManager, config.repositories, configuration.getRepositoryMerging(), config.modelPool ); request.setValidationLevel( configuration.getValidationLevel() ); request.setProcessPlugins( configuration.isProcessPlugins() ); request.setProfiles( configuration.getProfiles() ); request.setActiveProfileIds( configuration.getActiveProfileIds() ); request.setInactiveProfileIds( configuration.getInactiveProfileIds() ); request.setSystemProperties( configuration.getSystemProperties() ); request.setUserProperties( configuration.getUserProperties() ); request.setBuildStartTime( configuration.getBuildStartTime() ); request.setModelResolver( resolver ); request.setModelCache( config.modelCache ); return request; }
ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest(); modelRequest.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL ); modelRequest.setProcessPlugins( false );
public void interpolateModel(MavenProject project, Model model) throws MavenException { ModelBuildingRequest request = new DefaultModelBuildingRequest(); request.setUserProperties(project.getProperties()); ModelProblemCollector problems = new ModelProblemCollector() { @Override public void add(ModelProblemCollectorRequest req) { } }; lookup(ModelInterpolator.class).interpolateModel(model, project.getBasedir(), request, problems); }
public Model resolveEffectiveModel(File pomfile) { try { return modelBuilder.build(makeModelBuildRequest(pomfile)).getEffectiveModel(); } catch (Exception e) { throw new RuntimeException(e); } } private ModelBuildingRequest makeModelBuildRequest(File artifactFile) { DefaultModelBuildingRequest mbr = new DefaultModelBuildingRequest(); mbr.setPomFile(artifactFile); mbr.setModelResolver(modelResolver); // <-- the hard-to-get modelResolver return mbr; }
DefaultArtifact artifact = new DefaultArtifact(coordinate); Artifact pomArtifact = new DefaultArtifact(artifact.getGroupId(), artifact.getArtifactId(), "pom", artifact.getVersion()); ArtifactRequest request = new ArtifactRequest(pomArtifact, Arrays.asList(aetherSession.getRemoteRepository()), null); pomArtifact = aetherSession.getRepoSystem().resolveArtifact(session, request).getArtifact(); ModelBuilder modelBuilder = new DefaultModelBuilderFactory().newInstance(); ModelBuildingRequest buildingRequest = new DefaultModelBuildingRequest(); buildingRequest.setPomFile(pomArtifact.getFile()); buildingRequest.setProcessPlugins(true); buildingRequest.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); Constructor<?> constr = Class.forName("org.apache.maven.repository.internal.DefaultModelResolver").getConstructors()[0]; constr.setAccessible(true); ModelResolver modelResolver = (ModelResolver) constr.newInstance(session, null, null, serviceLocator.getService(ArtifactResolver.class), serviceLocator.getService(VersionRangeResolver.class), serviceLocator.getService(RemoteRepositoryManager.class), request.getRepositories()); buildingRequest.setModelResolver(modelResolver); Model model = modelBuilder.build(buildingRequest).getEffectiveModel(); Xpp3Dom pluginConfiguration = (Xpp3Dom) model.getBuild().getPluginsAsMap().get("com.company.group:my-plugin").getConfiguration(); Xpp3Dom myConfig = pluginConfiguration.getChild("myConfig"); System.out.println(myConfig.getChild("somePropName").getValue()); // prints "someProp"
public Model readPom(Path pomXml) throws IOException { Model model; try { ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest(); modelRequest.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); modelRequest.setProcessPlugins(false); modelRequest.setTwoPhaseBuilding(false); modelRequest.setModelSource(new FileModelSource(pomXml.toFile())); model = modelBuilder.build(modelRequest).getEffectiveModel(); } catch (ModelBuildingException e) { throw new IOException("error reading pom.xml", e); } return model; }
private DefaultModelBuildingRequest getModelBuildingRequest() { Settings settings = container.getSettings(); RepositorySystem system = container.getRepositorySystem(); DefaultRepositorySystemSession session = container.setupRepoSession(system, settings); List<RemoteRepository> remoteRepositories = MavenRepositories.getRemoteRepositories(container, settings); MavenModelResolver resolver = new MavenModelResolver(system, session, remoteRepositories); DefaultModelBuildingRequest request = new DefaultModelBuildingRequest() .setSystemProperties(System.getProperties()) .setModelResolver(resolver) .setLocationTracking(true) .setModelCache(DefaultModelCache.newInstance(session)) .setProfiles(settings.getProfiles().stream() .map(ProfileAdapter::new) .collect(Collectors.toList())) .setActiveProfileIds(settings.getActiveProfiles()); return request; }
@Override public Model getModel(final File pomFile) throws IOException { DefaultModelBuilder builder = new DefaultModelBuilderFactory().newInstance(); ModelBuildingRequest req = new DefaultModelBuildingRequest(); req.setProcessPlugins(false); req.setPomFile(pomFile); req.setModelResolver(modelResolver); req.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); req.setSystemProperties(System.getProperties()); builder.setModelValidator(new ModelValidatorImpl()); try { return builder.build(req).getEffectiveModel(); } catch (ModelBuildingException e) { LOGGER.warn("Cannot build effective model for " + pomFile.getAbsolutePath(), e); return new EffectiveModel(rawModelBuilder.getModel(pomFile)); } }
public static Model getEffectivePomModel(File pom) throws MavenException { try { final ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest(); modelRequest.setPomFile(pom); modelRequest.setModelResolver(createModelResolver()); // This is required to avoid errors about not able to determine the Java version modelRequest.setSystemProperties(System.getProperties()); final DefaultModelBuilder modelBuilder = new DefaultModelBuilderFactory().newInstance(); ModelBuildingResult modelBuildingResult = modelBuilder.build(modelRequest); return modelBuildingResult.getEffectiveModel(); } catch (SettingsBuildingException | ModelBuildingException e) { throw new MavenException(e); } }
private ModelBuildingRequest createModelBuildingRequest( File pomFile ) { FlattenModelResolver resolver = new FlattenModelResolver( this.localRepository, this.artifactFactory, this.dependencyResolver, this.session.getProjectBuildingRequest(), this.session.getAllProjects() ); Properties userProperties = this.session.getUserProperties(); List<String> activeProfiles = this.session.getRequest().getActiveProfiles(); // @formatter:off ModelBuildingRequest buildingRequest = new DefaultModelBuildingRequest().setUserProperties( userProperties ).setSystemProperties( System.getProperties() ).setPomFile( pomFile ).setModelResolver( resolver ).setActiveProfileIds( activeProfiles ); // @formatter:on return buildingRequest; }
protected ProjectsContextImpl createProjectsContext(AtomicReference<Map<String, Object>> transformContextReference) throws Exception { DefaultModelBuilderFactory factory = new DefaultModelBuilderFactory(); DefaultModelBuilder builder = factory.newInstance(); List<ProjectContextImpl> projectContexts = new ArrayList<>(); for (File pomXml : pomXmlCollection.getFiles()) { ModelBuildingRequest req = new DefaultModelBuildingRequest(); req.setProcessPlugins(false); req.setPomFile(pomXml); req.setModelResolver(createModelResolver()); req.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); Model effectivePom = builder.build(req).getEffectiveModel(); projectContexts.add(new ProjectContextImpl(pomXml, effectivePom, transformContextReference)); } ProjectsContextImpl projectsContext = new ProjectsContextImpl(projectContexts, transformContextReference); for (ProjectContextImpl projectContext : projectContexts) { projectContext.setProjectsContext(projectsContext); } return projectsContext; }
public static Model readPomXml(File pomXml, String localMavenRepository) { ModelBuildingRequest req = new DefaultModelBuildingRequest(); req.setProcessPlugins(true); req.setPomFile(pomXml); req.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); req.setModelResolver(new RepositoryModelResolver(localMavenRepository)); DefaultModelBuilder defaultModelBuilder = new DefaultModelBuilderFactory().newInstance(); // we try to build the model, and if we fail, we try to get the raw model try { ModelBuildingResult modelBuildingResult = defaultModelBuilder.build(req); return modelBuildingResult.getEffectiveModel(); } catch (ModelBuildingException e) { LOGGER.error("Error while building complete model. The raw model will be used. Error message: " + e.getMessage()); return defaultModelBuilder.buildRawModel(pomXml, ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL, true).get(); } }
private Model createModel(File pomFile, RepositorySystemSession session) throws ModelBuildingException { // Search for parent pom in all available Aether repositories List<RemoteRepository> repositories = newResolutionRepositories(session, true); ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest(); modelRequest.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); modelRequest.setProcessPlugins(false); modelRequest.setTwoPhaseBuilding(false); modelRequest.setSystemProperties(toProperties(session.getUserProperties(), session.getSystemProperties())); modelRequest.setModelResolver(new ProjectModelResolver(session, null, this.repositorySystem, this.remoteRepositoryManager, repositories, RepositoryMerging.POM_DOMINANT, null)); modelRequest.setPomFile(pomFile); modelRequest.setActiveProfileIds(Arrays.asList("legacy")); return this.modelBuilder.build(modelRequest).getEffectiveModel(); }
@Override public Result<? extends Model> buildRawModel( File pomFile, int validationLevel, boolean locationTracking ) { final ModelBuildingRequest request = new DefaultModelBuildingRequest().setValidationLevel( validationLevel ) .setLocationTracking( locationTracking ); final DefaultModelProblemCollector collector = new DefaultModelProblemCollector( new DefaultModelBuildingResult() ); try { return newResult( readModel( null, pomFile, request, collector ), collector.getProblems() ); } catch ( ModelBuildingException e ) { return error( collector.getProblems() ); } }
/** * * @param pom * @return result object with access to effective pom model and raw models for each parent. * @throws ModelBuildingException if the POM or parents could not even be parsed; warnings are not reported */ public ModelBuildingResult executeModelBuilder(File pom) throws ModelBuildingException { ModelBuilder mb = lookupComponent(ModelBuilder.class); assert mb!=null : "ModelBuilder component not found in maven"; ModelBuildingRequest req = new DefaultModelBuildingRequest(); req.setPomFile(pom); req.setProcessPlugins(false); req.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); req.setLocationTracking(true); req.setModelResolver(new NBRepositoryModelResolver(this)); req.setSystemProperties(getSystemProperties()); req.setUserProperties(embedderConfiguration.getUserProperties()); return mb.build(req); }
public Model resolveModel(File pom) throws ModelBuildingException { RequestTrace trace = new RequestTrace(pom); ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest(); modelRequest.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL); modelRequest.setProcessPlugins(false); modelRequest.setTwoPhaseBuilding(false); modelRequest.setSystemProperties(toProperties(session.getUserProperties(), session.getSystemProperties())); // // The model cache and default model resolver should be injected // modelRequest.setModelCache(new DefaultModelCache()); modelRequest.setModelResolver(new DefaultModelResolver(session, trace.newChild(modelRequest), "bithub", artifactResolver, remoteRepositoryManager, remoteRepositories)); modelRequest.setPomFile(pom); return modelBuilder.build(modelRequest).getEffectiveModel(); }