Examples with Traceable org.apache.sling.provisioning.model.Traceable used on opensource projects

Example 6 with Traceable

use of org.apache.sling.provisioning.model.Traceable in project sling by apache.

the class ModelPreprocessor method searchSlingstartDependencies.

/**
     * Search for dependent slingstart/slingfeature artifacts and remove them from the effective model.
     * @throws MavenExecutionException
     */
private List<Model> searchSlingstartDependencies(final Environment env, final ProjectInfo info, final Model rawModel, final Model effectiveModel) throws MavenExecutionException {
    // slingstart or slingfeature
    final List<Model> dependencies = new ArrayList<>();
    for (final Feature feature : effectiveModel.getFeatures()) {
        for (final RunMode runMode : feature.getRunModes()) {
            for (final ArtifactGroup group : runMode.getArtifactGroups()) {
                final List<org.apache.sling.provisioning.model.Artifact> removeList = new ArrayList<>();
                for (final org.apache.sling.provisioning.model.Artifact a : group) {
                    if (a.getType().equals(BuildConstants.PACKAGING_SLINGSTART) || a.getType().equals(BuildConstants.PACKAGING_PARTIAL_SYSTEM)) {
                        final Dependency dep = new Dependency();
                        dep.setGroupId(a.getGroupId());
                        dep.setArtifactId(a.getArtifactId());
                        dep.setVersion(a.getVersion());
                        dep.setType(BuildConstants.PACKAGING_PARTIAL_SYSTEM);
                        if (a.getType().equals(BuildConstants.PACKAGING_SLINGSTART)) {
                            dep.setClassifier(BuildConstants.PACKAGING_PARTIAL_SYSTEM);
                        } else {
                            dep.setClassifier(a.getClassifier());
                        }
                        dep.setScope(Artifact.SCOPE_PROVIDED);
                        env.logger.debug("- adding dependency " + ModelUtils.toString(dep));
                        info.project.getDependencies().add(dep);
                        // if it's a project from the current reactor build, we can't resolve it right now
                        final String key = a.getGroupId() + ":" + a.getArtifactId();
                        final ProjectInfo depInfo = env.modelProjects.get(key);
                        if (depInfo != null) {
                            env.logger.debug("Found reactor " + a.getType() + " dependency : " + a);
                            final Model model = addDependencies(env, depInfo);
                            if (model == null) {
                                throw new MavenExecutionException("Recursive model dependency list including project " + info.project, (File) null);
                            }
                            dependencies.add(model);
                            info.includedModels.put(a, depInfo.localModel);
                        } else {
                            env.logger.debug("Found external " + a.getType() + " dependency: " + a);
                            // "external" dependency, we can already resolve it
                            final File modelFile = resolveSlingstartArtifact(env, info.project, dep);
                            FileReader r = null;
                            try {
                                r = new FileReader(modelFile);
                                final Model model = ModelReader.read(r, modelFile.getAbsolutePath());
                                info.includedModels.put(a, model);
                                final Map<Traceable, String> errors = ModelUtility.validate(model);
                                if (errors != null) {
                                    throw new MavenExecutionException("Unable to read model file from " + modelFile + " : " + errors, modelFile);
                                }
                                final Model fullModel = processSlingstartDependencies(env, info, dep, model);
                                dependencies.add(fullModel);
                            } catch (final IOException ioe) {
                                throw new MavenExecutionException("Unable to read model file from " + modelFile, ioe);
                            } finally {
                                try {
                                    if (r != null) {
                                        r.close();
                                    }
                                } catch (final IOException io) {
                                // ignore
                                }
                            }
                        }
                        removeList.add(a);
                    }
                }
                for (final org.apache.sling.provisioning.model.Artifact r : removeList) {
                    group.remove(r);
                    final Feature localModelFeature = rawModel.getFeature(feature.getName());
                    if (localModelFeature != null) {
                        final RunMode localRunMode = localModelFeature.getRunMode(runMode.getNames());
                        if (localRunMode != null) {
                            final ArtifactGroup localAG = localRunMode.getArtifactGroup(group.getStartLevel());
                            if (localAG != null) {
                                localAG.remove(r);
                            }
                        }
                    }
                }
            }
        }
    }
    return dependencies;
}

Example 7 with Traceable

use of org.apache.sling.provisioning.model.Traceable in project sling by apache.

the class ModelPreprocessor method addDependencies.

/**
     * Add dependencies for a single project.
     * @param env The environment with all maven settings and projects
     * @param info The project to process.
     * @throws MavenExecutionException If anything goes wrong.
     */
private Model addDependencies(final Environment env, final ProjectInfo info) throws MavenExecutionException {
    if (info.done == true) {
        env.logger.debug("Return prepared model for " + info.project);
        return info.model;
    }
    // prevent recursion and multiple processing
    info.done = true;
    env.logger.debug("Processing project " + info.project);
    // read local model
    final String pattern = nodeValue(info.plugin, "modelPattern", AbstractSlingStartMojo.DEFAULT_MODEL_PATTERN);
    final String inlinedModel = nodeValue(info.plugin, "model", null);
    String scope = Artifact.SCOPE_PROVIDED;
    try {
        if (hasNodeValue(info.plugin, "modelDirectory")) {
            final String directory = nodeValue(info.plugin, "modelDirectory", null);
            info.localModel = readLocalModel(info.project, inlinedModel, new File(directory), pattern, env.logger);
        } else {
            // use multiple fallbacks here only in case the default model directory is not explicitly set
            File defaultModelDirectory = new File(info.project.getBasedir(), "src/main/provisioning");
            if (defaultModelDirectory.exists()) {
                env.logger.debug("Try to extract model from default provisioning directory " + defaultModelDirectory.getAbsolutePath());
                info.localModel = readLocalModel(info.project, inlinedModel, defaultModelDirectory, pattern, env.logger);
            } else {
                File defaultModelDirectoryInTest = new File(info.project.getBasedir(), "src/test/provisioning");
                env.logger.debug("Try to extract model from default test provisioning directory " + defaultModelDirectoryInTest.getAbsolutePath());
                info.localModel = readLocalModel(info.project, inlinedModel, defaultModelDirectoryInTest, pattern, env.logger);
                scope = Artifact.SCOPE_TEST;
            }
        }
    } catch (final IOException ioe) {
        throw new MavenExecutionException(ioe.getMessage(), ioe);
    }
    // process attachments
    processAttachments(env, info);
    // is the maven classpath supposed to be extended?
    info.extendMavenClassPath = !nodeBooleanValue(info.plugin, AbstractSlingStartMojo.CONFIGURATION_NAME_DISABLE_EXTENDING_CLASSPATH, false);
    // check for setting version
    if (nodeBooleanValue(info.plugin, "setFeatureVersions", false)) {
        for (final Feature f : info.localModel.getFeatures()) {
            if (f.getVersion() == null) {
                f.setVersion(cleanupVersion(info.project.getVersion()));
            }
        }
    }
    // prepare resolver options
    ResolverOptions resolverOptions = new ResolverOptions();
    if (nodeBooleanValue(info.plugin, "usePomVariables", false)) {
        resolverOptions.variableResolver(new PomVariableResolver(info.project));
    }
    if (nodeBooleanValue(info.plugin, "usePomDependencies", false)) {
        resolverOptions.artifactVersionResolver(new PomArtifactVersionResolver(info.project, nodeBooleanValue(info.plugin, "allowUnresolvedPomDependencies", false)));
    }
    final Model copyModel = new Model();
    this.mergeModels(copyModel, info.localModel);
    // we have to create an effective model to add the dependencies
    final Model effectiveModel = ModelUtility.getEffectiveModel(copyModel, resolverOptions);
    final List<Model> dependencies = searchSlingstartDependencies(env, info, copyModel, effectiveModel);
    info.model = new Model();
    for (final Model d : dependencies) {
        this.mergeModels(info.model, d);
    }
    this.mergeModels(info.model, copyModel);
    info.model = ModelUtility.getEffectiveModel(info.model, resolverOptions);
    final Map<Traceable, String> errors = ModelUtility.validate(info.model);
    if (errors != null) {
        throw new MavenExecutionException("Unable to create model file for " + info.project + " : " + errors, (File) null);
    }
    if (info.extendMavenClassPath) {
        addDependenciesFromModel(env, info, scope);
        env.logger.info("Extended Maven classpath (scope '" + scope + "') by the dependencies extracted from the Sling model.");
    } else {
        env.logger.debug("Do not enrich Maven classpath with Sling model!");
    }
    try {
        ProjectHelper.storeProjectInfo(info);
    } catch (final IOException ioe) {
        throw new MavenExecutionException(ioe.getMessage(), ioe);
    }
    return info.model;
}

Example 8 with Traceable

use of org.apache.sling.provisioning.model.Traceable in project sling by apache.

the class ModelPreprocessor method processSlingstartDependencies.

private Model processSlingstartDependencies(final Environment env, final ProjectInfo info, final Dependency dep, final Model rawModel) throws MavenExecutionException {
    env.logger.debug("Processing dependency " + dep);
    // we have to create an effective model to add the dependencies
    final Model effectiveModel = ModelUtility.getEffectiveModel(rawModel, new ResolverOptions());
    final List<Model> dependencies = searchSlingstartDependencies(env, info, rawModel, effectiveModel);
    Model mergingModel = new Model();
    for (final Model d : dependencies) {
        this.mergeModels(mergingModel, d);
    }
    this.mergeModels(mergingModel, rawModel);
    final Map<Traceable, String> errors = ModelUtility.validate(ModelUtility.getEffectiveModel(mergingModel, new ResolverOptions()));
    if (errors != null) {
        throw new MavenExecutionException("Unable to create model file for " + dep + " : " + errors, (File) null);
    }
    return mergingModel;
}

Example 9 with Traceable

use of org.apache.sling.provisioning.model.Traceable in project sling by apache.

the class IOTest method testReadWrite.

@Test
public void testReadWrite() throws Exception {
    final Model result = U.readCompleteTestModel();
    U.verifyTestModel(result, false);
    // Write the merged raw model
    StringWriter writer = new StringWriter();
    try {
        ModelWriter.write(writer, result);
    } finally {
        writer.close();
    }
    // read it again
    StringReader reader = new StringReader(writer.toString());
    final Model readModel = ModelReader.read(reader, "memory");
    reader.close();
    final Map<Traceable, String> readErrors = ModelUtility.validate(readModel);
    if (readErrors != null) {
        throw new Exception("Invalid read model : " + readErrors);
    }
    // and verify the result
    U.verifyTestModel(readModel, false);
    // Resolve variables and verify the result
    final Model effective = ModelUtility.getEffectiveModel(readModel);
    U.verifyTestModel(effective, true);
    // write effective model
    writer = new StringWriter();
    ModelWriter.write(writer, effective);
    writer.close();
    reader = new StringReader(writer.toString());
    final Model readModel2 = ModelReader.read(reader, "memory");
    reader.close();
    final Map<Traceable, String> readErrors2 = ModelUtility.validate(readModel2);
    if (readErrors2 != null) {
        throw new Exception("Invalid read model : " + readErrors2);
    }
    // and verify the result
    U.verifyTestModel(readModel2, true);
}