org.gradle.BuildResult Java Examples

public void buildFinishedClosure(BuildResult buildResult) {
    Throwable failure = buildResult.getFailure();
    Result result = failure == null ? Result.success() : Result.failure(failure);
    logger.info("Build finished with result " + result);
    MetricsDispatcher dispatcher = dispatcherSupplier.get();
    dispatcher.result(result);

    Map<String,Object> infoBrokerPluginReports = getNebulaInfoBrokerPluginReports(buildResult.getGradle().getRootProject());
    if (infoBrokerPluginReports != null) {
        for (Map.Entry<String, Object> report : infoBrokerPluginReports.entrySet()) {
            dispatcher.report(report.getKey(), report.getValue());
        }
    }

    buildResultComplete.getAndSet(true);
    shutdownIfComplete();
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p> <p>We remove our Log4JAppender as well as our task execution listener. Lastly, we report the build
 * results.</p>
 */
public void buildFinished(BuildResult buildResult) {

    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();
    liveOutputTimer.cancel();  //stop our timer and send whatever live output we have
    sendLiveOutput();

    //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
    //or one of its dependencies). So format it as text.
    String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
    output += details;

    client.sendMessage(ProtocolConstants.EXECUTION_COMPLETED_TYPE, output, wasSuccessful);

    client.sendMessage(ProtocolConstants.EXITING, null, null);
    client.stop();
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p> <p>We remove our Log4JAppender as well as our task execution listener. Lastly, we report the build
 * results.</p>
 */
public void buildFinished(BuildResult buildResult) {

    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();
    liveOutputTimer.cancel();  //stop our timer and send whatever live output we have
    sendLiveOutput();

    //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
    //or one of its dependencies). So format it as text.
    String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
    output += details;

    client.sendMessage(ProtocolConstants.EXECUTION_COMPLETED_TYPE, output, wasSuccessful);

    client.sendMessage(ProtocolConstants.EXITING, null, null);
    client.stop();
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p> <p>We remove our Log4JAppender as well as our task execution listener. Lastly, we report the build
 * results.</p>
 */
public void buildFinished(BuildResult buildResult) {

    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();
    liveOutputTimer.cancel();  //stop our timer and send whatever live output we have
    sendLiveOutput();

    //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
    //or one of its dependencies). So format it as text.
    String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
    output += details;

    client.sendMessage(ProtocolConstants.EXECUTION_COMPLETED_TYPE, output, wasSuccessful);

    client.sendMessage(ProtocolConstants.EXITING, null, null);
    client.stop();
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p> <p>We remove our Log4JAppender as well as our task execution listener. Lastly, we report the build
 * results.</p>
 */
public void buildFinished(BuildResult buildResult) {

    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();
    liveOutputTimer.cancel();  //stop our timer and send whatever live output we have
    sendLiveOutput();

    //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
    //or one of its dependencies). So format it as text.
    String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
    output += details;

    client.sendMessage(ProtocolConstants.EXECUTION_COMPLETED_TYPE, output, wasSuccessful);

    client.sendMessage(ProtocolConstants.EXITING, null, null);
    client.stop();
}
 

private BuildResult doBuild(Stage upTo) {
    loggingManager.start();
    buildListener.buildStarted(gradle);

    Throwable failure = null;
    try {
        doBuildStages(upTo);
    } catch (Throwable t) {
        failure = exceptionAnalyser.transform(t);
    }
    BuildResult buildResult = new BuildResult(gradle, failure);
    buildListener.buildFinished(buildResult);

    // Switching Logging off is important if the Gradle factory is used to
    // run multiple Gradle builds (each one requiring a new instances of GradleLauncher).
    // Switching it off shouldn't be strictly necessary as StandardOutput capturing should
    // always be closed. But as we expose this functionality to the builds, we can't
    // guarantee this.
    loggingManager.stop();
    return buildResult;
}
 

private BuildResult doBuild(Stage upTo) {
    loggingManager.start();
    buildListener.buildStarted(gradle);

    Throwable failure = null;
    try {
        doBuildStages(upTo);
    } catch (Throwable t) {
        failure = exceptionAnalyser.transform(t);
    }
    BuildResult buildResult = new BuildResult(gradle, failure);
    buildListener.buildFinished(buildResult);

    // Switching Logging off is important if the Gradle factory is used to
    // run multiple Gradle builds (each one requiring a new instances of GradleLauncher).
    // Switching it off shouldn't be strictly necessary as StandardOutput capturing should
    // always be closed. But as we expose this functionality to the builds, we can't
    // guarantee this.
    loggingManager.stop();
    return buildResult;
}
 

@Override
protected ExecutionResult doRun() {
    OutputListenerImpl outputListener = new OutputListenerImpl();
    OutputListenerImpl errorListener = new OutputListenerImpl();
    BuildListenerImpl buildListener = new BuildListenerImpl();
    BuildResult result = doRun(outputListener, errorListener, buildListener);
    try {
        result.rethrowFailure();
    } catch (Exception e) {
        throw new UnexpectedBuildFailure(e);
    }
    return assertResult(new InProcessExecutionResult(buildListener.executedTasks, buildListener.skippedTasks,
            new OutputScrapingExecutionResult(outputListener.toString(), errorListener.toString())));
}
 

@Override
public void buildFinished(BuildResult result) {
    if(buildMetrics != null) {
        buildMetrics.setBuildFinished(clock.getCurrentTime());
        buildFinished(buildMetrics);
        buildMetrics.setSuccessful(result.getFailure() == null);
        buildMetrics = null;
    }
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p>
 *
 * @param buildResult The result of the build. Never null.
 */
@Override
public void buildFinished(BuildResult buildResult) {
    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();

    if (!wasSuccessful) //if we fail, send the results, otherwise, we'll send the projects.
    {
        //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
        //or one of its dependencies). So format it as text.
        String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
        output += details;

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_WITH_ERRORS_TYPE, output, wasSuccessful);
    } else {
        ProjectConverter buildExecuter = new ProjectConverter();
        List<ProjectView> projects = new ArrayList<ProjectView>();
        projects.addAll(buildExecuter.convertProjects(buildResult.getGradle().getRootProject()));

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_SUCCESSFULLY_TYPE, output, (Serializable) projects);
    }

    //tell the server we're going to exit.
    client.sendMessage(ProtocolConstants.EXITING, null, null);

    client.stop();
}
 

private BuildResult doBuild(Stage upTo) {
    loggingManager.start();
    buildListener.buildStarted(gradle);

    Throwable failure = null;
    try {
        doBuildStages(upTo);
    } catch (Throwable t) {
        failure = exceptionAnalyser.transform(t);
    }
    BuildResult buildResult = new BuildResult(gradle, failure);
    buildListener.buildFinished(buildResult);

    return buildResult;
}
 

public void buildFinished(BuildResult result) {
    buildProfile.setBuildFinished(timeProvider.getCurrentTime());
    buildProfile.setSuccessful(result.getFailure() == null);
    try {
        listener.buildFinished(buildProfile);
    } finally {
        buildProfile = null;
    }
}
 

@Override
public void buildFinished(BuildResult result) {
  try {
    logger.lifecycle("Draining metrics to Stackdriver.");
    Thread.sleep(sleepDuration);
  } catch (InterruptedException e) {
    // Restore the interrupted status
    Thread.currentThread().interrupt();
  }
}
 

@Override
protected ExecutionResult doRun() {
    OutputListenerImpl outputListener = new OutputListenerImpl();
    OutputListenerImpl errorListener = new OutputListenerImpl();
    BuildListenerImpl buildListener = new BuildListenerImpl();
    BuildResult result = doRun(outputListener, errorListener, buildListener);
    try {
        result.rethrowFailure();
    } catch (Exception e) {
        throw new UnexpectedBuildFailure(e);
    }
    return assertResult(new InProcessExecutionResult(buildListener.executedTasks, buildListener.skippedTasks,
            new OutputScrapingExecutionResult(outputListener.toString(), errorListener.toString())));
}
 

@Override
protected ExecutionResult doRun() {
    OutputListenerImpl outputListener = new OutputListenerImpl();
    OutputListenerImpl errorListener = new OutputListenerImpl();
    BuildListenerImpl buildListener = new BuildListenerImpl();
    BuildResult result = doRun(outputListener, errorListener, buildListener);
    try {
        result.rethrowFailure();
    } catch (Exception e) {
        throw new UnexpectedBuildFailure(e);
    }
    return assertResult(new InProcessExecutionResult(buildListener.executedTasks, buildListener.skippedTasks,
            new OutputScrapingExecutionResult(outputListener.toString(), errorListener.toString())));
}
 

private GradleInternal check(BuildResult buildResult) {
    state = State.Completed;
    if (buildResult.getFailure() != null) {
        throw new ReportedException(buildResult.getFailure());
    }
    return (GradleInternal) buildResult.getGradle();
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p>
 *
 * @param buildResult The result of the build. Never null.
 */
@Override
public void buildFinished(BuildResult buildResult) {
    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();

    if (!wasSuccessful) //if we fail, send the results, otherwise, we'll send the projects.
    {
        //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
        //or one of its dependencies). So format it as text.
        String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
        output += details;

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_WITH_ERRORS_TYPE, output, wasSuccessful);
    } else {
        ProjectConverter buildExecuter = new ProjectConverter();
        List<ProjectView> projects = new ArrayList<ProjectView>();
        projects.addAll(buildExecuter.convertProjects(buildResult.getGradle().getRootProject()));

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_SUCCESSFULLY_TYPE, output, (Serializable) projects);
    }

    //tell the server we're going to exit.
    client.sendMessage(ProtocolConstants.EXITING, null, null);

    client.stop();
}
 

@Override
protected ExecutionResult doRun() {
    OutputListenerImpl outputListener = new OutputListenerImpl();
    OutputListenerImpl errorListener = new OutputListenerImpl();
    BuildListenerImpl buildListener = new BuildListenerImpl();
    BuildResult result = doRun(outputListener, errorListener, buildListener);
    try {
        result.rethrowFailure();
    } catch (Exception e) {
        throw new UnexpectedBuildFailure(e);
    }
    return assertResult(new InProcessExecutionResult(buildListener.executedTasks, buildListener.skippedTasks,
            new OutputScrapingExecutionResult(outputListener.toString(), errorListener.toString())));
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p>
 *
 * @param buildResult The result of the build. Never null.
 */
@Override
public void buildFinished(BuildResult buildResult) {
    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();

    if (!wasSuccessful) //if we fail, send the results, otherwise, we'll send the projects.
    {
        //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
        //or one of its dependencies). So format it as text.
        String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
        output += details;

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_WITH_ERRORS_TYPE, output, wasSuccessful);
    } else {
        ProjectConverter buildExecuter = new ProjectConverter();
        List<ProjectView> projects = new ArrayList<ProjectView>();
        projects.addAll(buildExecuter.convertProjects(buildResult.getGradle().getRootProject()));

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_SUCCESSFULLY_TYPE, output, (Serializable) projects);
    }

    //tell the server we're going to exit.
    client.sendMessage(ProtocolConstants.EXITING, null, null);

    client.stop();
}
 

private BuildResult doBuild(Stage upTo) {
    loggingManager.start();
    buildListener.buildStarted(gradle);

    Throwable failure = null;
    try {
        doBuildStages(upTo);
    } catch (Throwable t) {
        failure = exceptionAnalyser.transform(t);
    }
    BuildResult buildResult = new BuildResult(gradle, failure);
    buildListener.buildFinished(buildResult);

    return buildResult;
}
 

public void buildFinished(BuildResult result) {
    buildProfile.setBuildFinished(timeProvider.getCurrentTime());
    buildProfile.setSuccessful(result.getFailure() == null);
    try {
        listener.buildFinished(buildProfile);
    } finally {
        buildProfile = null;
    }
}
 

protected void createAndRegisterGradleBuildMetricsCollector(Gradle gradle, BuildMetrics buildMetrics) {
    //Using internal API to retrieve build start time but still storing it in our own data structure
    BuildStartedTime buildStartedTime = BuildStartedTime.startingAt(buildInvocationDetails.getBuildStartedTime());
    final GradleBuildMetricsCollector gradleCollector = new GradleBuildMetricsCollector(dispatcherSupplier, buildStartedTime, gradle, buildMetrics, clock);
    gradle.addListener(gradleCollector);
    gradle.buildFinished(new Closure(null) {
        protected Object doCall(Object arguments) {
            gradleCollector.buildFinishedClosure((BuildResult)arguments);
            return null;
        }
    });
}
 

/**
 * <p>Called when the build is completed. All selected tasks have been executed.</p>
 *
 * @param buildResult The result of the build. Never null.
 */
@Override
public void buildFinished(BuildResult buildResult) {
    boolean wasSuccessful = buildResult.getFailure() == null;
    String output = allOutputText.toString();

    if (!wasSuccessful) //if we fail, send the results, otherwise, we'll send the projects.
    {
        //we can't send the exception itself because it might not be serializable (it can include anything from anywhere inside gradle
        //or one of its dependencies). So format it as text.
        String details = GradlePluginLord.getGradleExceptionMessage(buildResult.getFailure(), gradle.getStartParameter().getShowStacktrace());
        output += details;

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_WITH_ERRORS_TYPE, output, wasSuccessful);
    } else {
        ProjectConverter buildExecuter = new ProjectConverter();
        List<ProjectView> projects = new ArrayList<ProjectView>();
        projects.addAll(buildExecuter.convertProjects(buildResult.getGradle().getRootProject()));

        client.sendMessage(ProtocolConstants.TASK_LIST_COMPLETED_SUCCESSFULLY_TYPE, output, (Serializable) projects);
    }

    //tell the server we're going to exit.
    client.sendMessage(ProtocolConstants.EXITING, null, null);

    client.stop();
}
 

private GradleInternal check(BuildResult buildResult) {
    state = State.Completed;
    if (buildResult.getFailure() != null) {
        throw new ReportedException(buildResult.getFailure());
    }
    return (GradleInternal) buildResult.getGradle();
}
 

private BuildResult doRun(final OutputListenerImpl outputListener, OutputListenerImpl errorListener, BuildListenerImpl listener) {
    // Capture the current state of things that we will change during execution
    InputStream originalStdIn = System.in;
    Properties originalSysProperties = new Properties();
    originalSysProperties.putAll(System.getProperties());
    File originalUserDir = new File(originalSysProperties.getProperty("user.dir"));
    Map<String, String> originalEnv = new HashMap<String, String>(System.getenv());

    // Augment the environment for the execution
    System.setIn(getStdin());
    processEnvironment.maybeSetProcessDir(getWorkingDir());
    for (Map.Entry<String, String> entry : getEnvironmentVars().entrySet()) {
        processEnvironment.maybeSetEnvironmentVariable(entry.getKey(), entry.getValue());
    }
    Map<String, String> implicitJvmSystemProperties = getImplicitJvmSystemProperties();
    System.getProperties().putAll(implicitJvmSystemProperties);

    StartParameter parameter = new StartParameter();
    parameter.setCurrentDir(getWorkingDir());
    parameter.setShowStacktrace(ShowStacktrace.ALWAYS);

    CommandLineParser parser = new CommandLineParser();
    DefaultCommandLineConverter converter = new DefaultCommandLineConverter();
    converter.configure(parser);
    ParsedCommandLine parsedCommandLine = parser.parse(getAllArgs());

    BuildLayoutParameters layout = converter.getLayoutConverter().convert(parsedCommandLine);

    Map<String, String> properties = new HashMap<String, String>();
    new LayoutToPropertiesConverter().convert(layout, properties);
    converter.getSystemPropertiesConverter().convert(parsedCommandLine, properties);

    new PropertiesToStartParameterConverter().convert(properties, parameter);
    converter.convert(parsedCommandLine, parameter);

    DefaultGradleLauncherFactory factory = DeprecationLogger.whileDisabled(new Factory<DefaultGradleLauncherFactory>() {
        public DefaultGradleLauncherFactory create() {
            return (DefaultGradleLauncherFactory) GradleLauncher.getFactory();
        }
    });
    factory.addListener(listener);
    GradleLauncher gradleLauncher = factory.newInstance(parameter);
    gradleLauncher.addStandardOutputListener(outputListener);
    gradleLauncher.addStandardErrorListener(errorListener);
    try {
        return gradleLauncher.run();
    } finally {
        // Restore the environment
        System.setProperties(originalSysProperties);
        processEnvironment.maybeSetProcessDir(originalUserDir);
        for (String envVar: getEnvironmentVars().keySet()) {
            String oldValue = originalEnv.get(envVar);
            if (oldValue != null) {
                processEnvironment.maybeSetEnvironmentVariable(envVar, oldValue);
            } else {
                processEnvironment.maybeRemoveEnvironmentVariable(envVar);
            }
        }
        factory.removeListener(listener);
        System.setIn(originalStdIn);
    }
}
 

private void check(BuildResult buildResult) {
    if (buildResult.getFailure() != null) {
        throw new ReportedException(buildResult.getFailure());
    }
}
 

public void buildFinished(BuildResult result) {
    if (result.getGradle() == gradle) {
        gradle = null;
        logger.buildFinished();
    }
}
 

public void buildFinished(BuildResult result) {
    buildProfile.setSuccessful(result.getFailure() == null);
}
 

@Override
public void buildFinished(BuildResult result) {
    buildStack.remove(result.getGradle());
}
 

@Override
public void buildFinished(BuildResult result) {
    buildStack.remove(result.getGradle());
}