Java ProgressLogger.completed方法代码示例

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public ConsumerConnection create(Distribution distribution, ProgressLoggerFactory progressLoggerFactory, ConnectionParameters connectionParameters, BuildCancellationToken cancellationToken) {
    if (lock.tryLock()) {
        try {
            return delegate.create(distribution, progressLoggerFactory, connectionParameters, cancellationToken);
        } finally {
            lock.unlock();
        }
    }
    ProgressLogger logger = progressLoggerFactory.newOperation(SynchronizedToolingImplementationLoader.class);
    logger.setDescription("Wait for the other thread to finish acquiring the distribution");
    logger.started();
    lock.lock();
    try {
        return delegate.create(distribution, progressLoggerFactory, connectionParameters, cancellationToken);
    } finally {
        lock.unlock();
        logger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public <T> T run(ConsumerAction<T> action) throws UnsupportedOperationException, IllegalStateException {
    ConsumerOperationParameters parameters = action.getParameters();
    ProgressListenerAdapter listener = new ProgressListenerAdapter(parameters.getProgressListener());
    ListenerManager listenerManager = loggingProvider.getListenerManager();
    listenerManager.addListener(listener);
    try {
        ProgressLogger progressLogger = loggingProvider.getProgressLoggerFactory().newOperation(ProgressLoggingConsumerActionExecutor.class);
        progressLogger.setDescription("Build");
        progressLogger.started();
        try {
            return actionExecutor.run(action);
        } finally {
            progressLogger.completed();
        }
    } finally {
        listenerManager.removeListener(listener);
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public ConsumerConnection create(Distribution distribution, ProgressLoggerFactory progressLoggerFactory, ConnectionParameters connectionParameters) {
    if (lock.tryLock()) {
        try {
            return delegate.create(distribution, progressLoggerFactory, connectionParameters);
        } finally {
            lock.unlock();
        }
    }
    ProgressLogger logger = progressLoggerFactory.newOperation(SynchronizedToolingImplementationLoader.class);
    logger.setDescription("Wait for the other thread to finish acquiring the distribution");
    logger.started();
    lock.lock();
    try {
        return delegate.create(distribution, progressLoggerFactory, connectionParameters);
    } finally {
        lock.unlock();
        logger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public void download(URI address, File destination) throws Exception {
  ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
  progressLogger.setDescription(String.format("Download %s", address));
  progressLogger.started();
  try {
    new Download(new Logger(false), "Gradle Tooling API", GradleVersion.current().getVersion()).download(address, destination);
  } finally {
    progressLogger.completed();
  }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public ClassPath getToolingImplementationClasspath(ProgressLoggerFactory progressLoggerFactory,
                                                   File userHomeDir,
                                                   BuildCancellationToken cancellationToken) {
  ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
  progressLogger.setDescription("Validate distribution");
  progressLogger.started();
  try {
    return getToolingImpl();
  }
  finally {
    progressLogger.completed();
  }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public void download(URI address, File destination) throws Exception {
    ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
    progressLogger.setDescription(String.format("Download %s", address));
    progressLogger.started();
    try {
        new Download("Gradle Tooling API", GradleVersion.current().getVersion()).download(address, destination);
    } finally {
        progressLogger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public ClassPath getToolingImplementationClasspath(ProgressLoggerFactory progressLoggerFactory, File userHomeDir, BuildCancellationToken cancellationToken) {
    ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
    progressLogger.setDescription("Validate distribution");
    progressLogger.started();
    try {
        return getToolingImpl();
    } finally {
        progressLogger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public void afterResolve(ResolvableDependencies dependencies) {
    LinkedList<ProgressLogger> loggers = progressLoggers.get();
    if (loggers.isEmpty()) {
        throw new IllegalStateException("Logging operation was not started or it has already completed.");
    }
    ProgressLogger logger = loggers.removeLast();
    logger.completed();
    if (loggers.isEmpty()) {
        progressLoggers.remove();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public void execute(PersistentCache cache) {
    ProgressLogger op = progressLoggerFactory.newOperation(FileCacheBackedScriptClassCompiler.class)
            .start("Compile script into cache", "Compiling script into cache");
    try {
        delegate.execute(cache);
    } finally {
        op.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public void buildFinished() {
    for (ProgressLogger l : projectConfigurationProgress.values()) {
        l.completed();
    }
    if (configurationProgress != null) {
        configurationProgress.completed();
    }
    buildProgress.completed();
    buildProgress = null;
    buildProgressFormatter = null;
    configurationProgress = null;
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public void afterEvaluate(String projectPath) {
    if (configurationProgress != null) {
        ProgressLogger logger = projectConfigurationProgress.remove(projectPath);
        if (logger == null) {
            throw new IllegalStateException("Unexpected afterEvaluate event received without beforeEvaluate");
        }
        logger.completed();
        configurationProgress.progress(configurationProgressFormatter.incrementAndGetProgress());
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public ClassPath getToolingImplementationClasspath(ProgressLoggerFactory progressLoggerFactory, File userHomeDir) {
    ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
    progressLogger.setDescription("Validate distribution");
    progressLogger.started();
    try {
        return getToolingImpl();
    } finally {
        progressLogger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入方法依赖的package包/类
public void afterExecute(Task task, TaskState state) {
    ProgressLogger currentTask = currentTasks.remove(task);
    String taskMessage = state.getFailure() != null ? "FAILED" : state.getSkipMessage();
    currentTask.completed(taskMessage);
}