*         {@code null}.
     * @throws ProjectBuildingException If an error was encountered during building of any project.
     *             {@link ProjectBuildingException#getResults()} provides access to the details of the problems.
     */
    List<ProjectBuildingResult> build(List<File> pomFiles, boolean recursive, ProjectBuildingRequest request)
            throws ProjectBuildingException;

                localProject = pomResult.getRepository() instanceof WorkspaceRepository;
            } catch (org.eclipse.aether.resolution.ArtifactResolutionException e) {
                if (e.getResults().get(0).isMissing() && allowStubModel) {
                    return build(null, createStubModelSource(artifact));
                }
                throw new ProjectBuildingException(

            result.setDependencyGraph(node);
        } catch (DependencyCollectionException e) {
            result.setDependencyGraph(e.getResult().getRoot());
            result.setCollectionErrors(e.getResult().getExceptions());

            throw new DependencyResolutionException(
                    result, "Could not resolve dependencies for project " + project.getId() + ": " + e.getMessage(), e);

            validateOptionalProjects(request, session);
            validateOptionalProfiles(session, request.getProfileActivation());

            if (session.getResult().hasExceptions()) {
                addExceptionToResult(result, session.getResult().getExceptions().get(0));
                persistResumptionData(result, session);
                return result;
            } else {

        this.reactorBuildStatus = reactorBuildStatus;
    }

    public ReactorBuildStatus getReactorBuildStatus() {
        return reactorBuildStatus;
    }

    public MavenExecutionResult getResult() {
        return result;
    }

    public ClassLoader getOriginalContextClassLoader() {
        return originalContextClassLoader;
    }

        eventCatapult.fire(ExecutionEvent.Type.SessionStarted, session, null);

        ReactorContext reactorContext = null;
        ProjectBuildList projectBuilds = null;
        MavenExecutionResult result = session.getResult();

        try {
            if (buildExecutionRequiresProject(session) && projectIsNotPresent(session)) {
                throw new MissingProjectException("The goal you specified requires a project to execute"

        if (resolvedArtifacts instanceof ProjectArtifactsCache.ArtifactsSetWithResult) {
            return ((ProjectArtifactsCache.ArtifactsSetWithResult) resolvedArtifacts).getResult();
        } else {
            throw new IllegalStateException();
        }
    }

    public Set<Artifact> resolveProjectArtifacts(
            MavenProject project,

            projectExecutionListener.afterProjectExecutionSuccess(
                    new ProjectExecutionEvent(session, currentProject, mojoExecutions));

            reactorContext.getResult().addBuildSummary(new BuildSuccess(currentProject, buildEndTime - buildStartTime));

            eventCatapult.fire(ExecutionEvent.Type.ProjectSucceeded, session, null);
        } catch (Throwable t) {

    /**
     * Gets the interim result of the model building up to the point where it failed.
     *
     * @return The interim model building result or {@code null} if not available.
     */
    public ModelBuilderResult getResult() {
        return result;
    }

    /**
     * Gets the identifier of the POM whose effective model could not be built. The general format of the identifier is

        final MavenSession ms = nonNull(getMavenSession());
        final MavenSession mss;
        if (repoSession != ms.getRepositorySession()) {
            mss = new MavenSession(repoSession, ms.getRequest(), ms.getResult());
        } else {
            mss = ms;
        }
        return newSession(mss, repositories);
    }

    protected Session newSession(MavenSession mavenSession, List<RemoteRepository> repositories) {