blob: 40874f33616aab7cb19fc8c50d2068c6a7b06a44 [file] [log] [blame]
// Copyright 2015 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.runtime;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.eventbus.EventBus;
import com.google.devtools.build.lib.actions.PackageRootResolver;
import com.google.devtools.build.lib.actions.cache.ActionCache;
import com.google.devtools.build.lib.analysis.AnalysisOptions;
import com.google.devtools.build.lib.analysis.BlazeDirectories;
import com.google.devtools.build.lib.analysis.SkyframePackageRootResolver;
import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.events.Reporter;
import com.google.devtools.build.lib.packages.StarlarkSemanticsOptions;
import com.google.devtools.build.lib.pkgcache.PackageCacheOptions;
import com.google.devtools.build.lib.pkgcache.PackageManager;
import com.google.devtools.build.lib.pkgcache.PathPackageLocator;
import com.google.devtools.build.lib.pkgcache.TargetPatternPreloader;
import com.google.devtools.build.lib.profiler.Profiler;
import com.google.devtools.build.lib.profiler.ProfilerTask;
import com.google.devtools.build.lib.profiler.SilentCloseable;
import com.google.devtools.build.lib.runtime.proto.InvocationPolicyOuterClass.InvocationPolicy;
import com.google.devtools.build.lib.skyframe.SkyframeBuildView;
import com.google.devtools.build.lib.skyframe.SkyframeExecutor;
import com.google.devtools.build.lib.util.AbruptExitException;
import com.google.devtools.build.lib.util.ExitCode;
import com.google.devtools.build.lib.util.io.OutErr;
import com.google.devtools.build.lib.util.io.TimestampGranularityMonitor;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import com.google.devtools.build.lib.vfs.OutputService;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.common.options.OptionsParsingResult;
import com.google.devtools.common.options.OptionsProvider;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicReference;
import javax.annotation.Nullable;
/**
* Encapsulates the state needed for a single command. The environment is dropped when the current
* command is done and all corresponding objects are garbage collected.
*/
public final class CommandEnvironment {
private final BlazeRuntime runtime;
private final BlazeWorkspace workspace;
private final BlazeDirectories directories;
private final UUID commandId; // Unique identifier for the command being run
private final String buildRequestId; // Unique identifier for the build being run
private final Reporter reporter;
private final EventBus eventBus;
private final BlazeModule.ModuleEnvironment blazeModuleEnvironment;
private final Map<String, String> clientEnv;
private final Set<String> visibleActionEnv = new TreeSet<>();
private final Set<String> visibleTestEnv = new TreeSet<>();
private final Map<String, String> actionClientEnv = new TreeMap<>();
private final TimestampGranularityMonitor timestampGranularityMonitor;
private final Thread commandThread;
private final Command command;
private final OptionsParsingResult options;
private final PathPackageLocator packageLocator;
private String[] crashData;
private PathFragment relativeWorkingDirectory = PathFragment.EMPTY_FRAGMENT;
private long commandStartTime;
private OutputService outputService;
private Path workingDirectory;
private String workspaceName;
private AtomicReference<AbruptExitException> pendingException = new AtomicReference<>();
private class BlazeModuleEnvironment implements BlazeModule.ModuleEnvironment {
@Override
public Path getFileFromWorkspace(Label label) {
Path buildFile = getPackageManager().getBuildFileForPackage(label.getPackageIdentifier());
if (buildFile == null) {
return null;
}
return buildFile.getParentDirectory().getRelative(label.getName());
}
@Override
public void exit(AbruptExitException exception) {
Preconditions.checkNotNull(exception);
Preconditions.checkNotNull(exception.getExitCode());
if (pendingException.compareAndSet(null, exception)) {
// There was no exception, so we're the first one to ask for an exit. Interrupt the command.
commandThread.interrupt();
}
}
}
/**
* Creates a new command environment which can be used for executing commands for the given
* runtime in the given workspace, which will publish events on the given eventBus. The
* commandThread passed is interrupted when a module requests an early exit.
*
* @param warnings will be filled with any warnings from command environment initialization.
*/
CommandEnvironment(
BlazeRuntime runtime,
BlazeWorkspace workspace,
EventBus eventBus,
Thread commandThread,
Command command,
OptionsParsingResult options,
List<String> warnings) {
this.runtime = runtime;
this.workspace = workspace;
this.directories = workspace.getDirectories();
this.reporter = new Reporter(eventBus);
this.eventBus = eventBus;
this.commandThread = commandThread;
this.command = command;
this.options = options;
this.blazeModuleEnvironment = new BlazeModuleEnvironment();
this.timestampGranularityMonitor = new TimestampGranularityMonitor(runtime.getClock());
// Record the command's starting time again, for use by
// TimestampGranularityMonitor.waitForTimestampGranularity().
// This should be done as close as possible to the start of
// the command's execution.
timestampGranularityMonitor.setCommandStartTime();
// TODO(ulfjack): We don't call beforeCommand() in tests, but rely on workingDirectory being set
// in setupPackageCache(). This leads to NPE if we don't set it here.
Path workspacePath = directories.getWorkspace();
this.setWorkingDirectory(workspacePath);
this.workspaceName = null;
// If this command supports --package_path we initialize the package locator scoped
// to the command environment
if (commandHasPackageOptions(command) && workspacePath != null) {
this.packageLocator =
workspace
.getSkyframeExecutor()
.createPackageLocator(
reporter,
options.getOptions(PackageCacheOptions.class).packagePath,
workingDirectory);
} else {
this.packageLocator = null;
}
workspace.getSkyframeExecutor().setEventBus(eventBus);
ClientOptions clientOptions =
Preconditions.checkNotNull(
options.getOptions(ClientOptions.class),
"CommandEnvironment needs its options provider to have ClientOptions loaded.");
CommonCommandOptions commandOptions =
Preconditions.checkNotNull(
options.getOptions(CommonCommandOptions.class),
"CommandEnvironment needs its options provider to have CommonCommandOptions loaded.");
this.clientEnv = computeClientEnv(clientOptions.clientEnv);
this.commandId = computeCommandId(commandOptions.invocationId, warnings);
this.buildRequestId = computeBuildRequestId(commandOptions.buildRequestId, warnings);
this.crashData = new String[] { commandId + " (build id)" };
// actionClientEnv contains the environment where values from actionEnvironment are overridden.
actionClientEnv.putAll(clientEnv);
if (command.builds()) {
// Compute the set of environment variables that are whitelisted on the commandline
// for inheritance.
for (Map.Entry<String, String> entry :
options.getOptions(BuildConfiguration.Options.class).actionEnvironment) {
if (entry.getValue() == null) {
visibleActionEnv.add(entry.getKey());
} else {
visibleActionEnv.remove(entry.getKey());
actionClientEnv.put(entry.getKey(), entry.getValue());
}
}
for (Map.Entry<String, String> entry :
options.getOptions(BuildConfiguration.Options.class).testEnvironment) {
if (entry.getValue() == null) {
visibleTestEnv.add(entry.getKey());
}
}
}
}
// Returns whether the given command supports --package_path
private static boolean commandHasPackageOptions(Command command) {
return commandHasPackageOptions(command, new HashSet<>());
}
private static boolean commandHasPackageOptions(Command command, Set<Command> seen) {
if (!seen.add(command)) {
return false;
}
for (int i = 0; i < command.options().length; ++i) {
if (command.options()[i] == PackageCacheOptions.class) {
return true;
}
}
for (int i = 0; i < command.inherits().length; ++i) {
Class<? extends BlazeCommand> blazeCommand = command.inherits()[i];
Command annotation = blazeCommand.getAnnotation(Command.class);
if (commandHasPackageOptions(annotation, seen)) {
return true;
}
}
return false;
}
public BlazeRuntime getRuntime() {
return runtime;
}
public BlazeWorkspace getBlazeWorkspace() {
return workspace;
}
public BlazeDirectories getDirectories() {
return directories;
}
public PathPackageLocator getPackageLocator() {
return packageLocator;
}
/**
* Returns the reporter for events.
*/
public Reporter getReporter() {
return reporter;
}
public EventBus getEventBus() {
return eventBus;
}
public BlazeModule.ModuleEnvironment getBlazeModuleEnvironment() {
return blazeModuleEnvironment;
}
/**
* Return an unmodifiable view of the blaze client's environment when it invoked the current
* command.
*/
public Map<String, String> getClientEnv() {
return clientEnv;
}
public Command getCommand() {
return command;
}
public String getCommandName() {
return command.name();
}
public OptionsParsingResult getOptions() {
return options;
}
/**
* Return an ordered version of the client environment restricted to those variables whitelisted
* by the command-line options to be inheritable by actions.
*/
public Map<String, String> getWhitelistedActionEnv() {
return filterClientEnv(visibleActionEnv);
}
/**
* Return an ordered version of the client environment restricted to those variables whitelisted
* by the command-line options to be inheritable by actions.
*/
public Map<String, String> getWhitelistedTestEnv() {
return filterClientEnv(visibleTestEnv);
}
private Map<String, String> filterClientEnv(Set<String> vars) {
Map<String, String> result = new TreeMap<>();
for (String var : vars) {
String value = clientEnv.get(var);
if (value != null) {
result.put(var, value);
}
}
return Collections.unmodifiableMap(result);
}
private Map<String, String> computeClientEnv(List<Map.Entry<String, String>> clientEnvList) {
Map<String, String> clientEnv = new TreeMap<>();
for (Map.Entry<String, String> entry : clientEnvList) {
clientEnv.put(entry.getKey(), entry.getValue());
}
return Collections.unmodifiableMap(clientEnv);
}
private UUID computeCommandId(UUID idFromOptions, List<String> warnings) {
// TODO(b/67895628): Stop reading ids from the environment after the compatibility window has
// passed.
UUID commandId = idFromOptions;
if (commandId == null) { // Try to set the clientId from the client environment.
String uuidString = clientEnv.getOrDefault("BAZEL_INTERNAL_INVOCATION_ID", "");
if (!uuidString.isEmpty()) {
try {
commandId = UUID.fromString(uuidString);
warnings.add(
"BAZEL_INTERNAL_INVOCATION_ID is set. This will soon be deprecated in favor of "
+ "--invocation_id. Please switch to using the flag.");
} catch (IllegalArgumentException e) {
// String was malformed, so we will resort to generating a random UUID
commandId = UUID.randomUUID();
}
} else {
commandId = UUID.randomUUID();
}
}
return commandId;
}
private String computeBuildRequestId(String idFromOptions, List<String> warnings) {
String buildRequestId = idFromOptions;
if (buildRequestId == null) {
String uuidString = clientEnv.getOrDefault("BAZEL_INTERNAL_BUILD_REQUEST_ID", "");
if (!uuidString.isEmpty()) {
buildRequestId = uuidString;
warnings.add(
"BAZEL_INTERNAL_BUILD_REQUEST_ID is set. This will soon be deprecated in favor of "
+ "--build_request_id. Please switch to using the flag.");
} else {
buildRequestId = UUID.randomUUID().toString();
}
}
return buildRequestId;
}
public TimestampGranularityMonitor getTimestampGranularityMonitor() {
return timestampGranularityMonitor;
}
public PackageManager getPackageManager() {
return getSkyframeExecutor().getPackageManager();
}
public PathFragment getRelativeWorkingDirectory() {
return relativeWorkingDirectory;
}
List<OutErr> getOutputListeners() {
List<OutErr> result = new ArrayList<>();
for (BlazeModule module : runtime.getBlazeModules()) {
OutErr listener = module.getOutputListener();
if (listener != null) {
result.add(listener);
}
}
return result;
}
/**
* Creates and returns a new target pattern preloader.
*/
public TargetPatternPreloader newTargetPatternPreloader() {
return getPackageManager().newTargetPatternPreloader();
}
public PackageRootResolver getPackageRootResolver() {
return new SkyframePackageRootResolver(getSkyframeExecutor(), reporter);
}
/**
* Returns the UUID that Blaze uses to identify everything logged from the current build command.
* It's also used to invalidate Skyframe nodes that are specific to a certain invocation, such as
* the build info.
*/
public UUID getCommandId() {
return commandId;
}
/**
* Returns the ID that Blaze uses to identify everything logged from the current build request.
* TODO(olaola): this should be a prefixed UUID, but some existing clients still use arbitrary
* strings, so we accept these when passed by environment variable for compatibility.
*/
public String getBuildRequestId() {
return buildRequestId;
}
public SkyframeExecutor getSkyframeExecutor() {
return workspace.getSkyframeExecutor();
}
public SkyframeBuildView getSkyframeBuildView() {
return getSkyframeExecutor().getSkyframeBuildView();
}
/**
* Returns the working directory of the server.
*
* <p>This is often the first entry on the {@code --package_path}, but not always.
* Callers should certainly not make this assumption. The Path returned may be null.
*/
public Path getWorkspace() {
return getDirectories().getWorkspace();
}
public String getWorkspaceName() {
Preconditions.checkNotNull(workspaceName);
return workspaceName;
}
public void setWorkspaceName(String workspaceName) {
Preconditions.checkState(this.workspaceName == null, "workspace name can only be set once");
this.workspaceName = workspaceName;
}
/**
* Returns if the client passed a valid workspace to be used for the build.
*/
public boolean inWorkspace() {
return getDirectories().inWorkspace();
}
/**
* Returns the output base directory associated with this Blaze server
* process. This is the base directory for shared Blaze state as well as tool
* and strategy specific subdirectories.
*/
public Path getOutputBase() {
return getDirectories().getOutputBase();
}
/**
* Returns the execution root directory associated with this Blaze server
* process. This is where all input and output files visible to the actual
* build reside.
*/
public Path getExecRoot() {
Preconditions.checkNotNull(workspaceName);
return getDirectories().getExecRoot(workspaceName);
}
/**
* Returns the directory where actions' outputs and errors will be written. Is below the directory
* returned by {@link #getExecRoot}.
*/
public Path getActionConsoleOutputDirectory() {
return getDirectories().getActionConsoleOutputDirectory(getExecRoot());
}
/**
* Returns the working directory of the {@code blaze} client process.
*
* <p>This may be equal to {@code BlazeRuntime#getWorkspace()}, or beneath it.
*
* @see #getWorkspace()
*/
public Path getWorkingDirectory() {
return workingDirectory;
}
/**
* @return the OutputService in use, or null if none.
*/
public OutputService getOutputService() {
return outputService;
}
public ActionCache getPersistentActionCache() throws IOException {
return workspace.getPersistentActionCache(reporter);
}
/**
* An array of String values useful if Blaze crashes. For now, just returns the build id as soon
* as it is determined.
*/
String[] getCrashData() {
return crashData;
}
/**
* Prevents any further interruption of this command by modules, and returns the final exit code
* from modules, or null if no modules requested an abrupt exit.
*
* <p>Always returns the same value on subsequent calls.
*/
@Nullable
private ExitCode finalizeExitCode() {
// Set the pending exception so that further calls to exit(AbruptExitException) don't lead to
// unwanted thread interrupts.
if (pendingException.compareAndSet(null, new AbruptExitException("", null))) {
return null;
}
if (Thread.currentThread() == commandThread) {
// We may have interrupted the thread in the process, so clear the interrupted bit.
// Whether the command was interrupted or not, it's about to be over, so don't interrupt later
// things happening on this thread.
Thread.interrupted();
}
// Extract the exit code (it can be null if someone has already called finalizeExitCode()).
return getPendingExitCode();
}
/**
* Hook method called by the BlazeCommandDispatcher right before the dispatch
* of each command ends (while its outcome can still be modified).
*/
ExitCode precompleteCommand(ExitCode originalExit) {
eventBus.post(new CommandPrecompleteEvent(originalExit));
return finalizeExitCode();
}
/**
* Returns the current exit code requested by modules, or null if no exit has been requested.
*/
@Nullable
public ExitCode getPendingExitCode() {
AbruptExitException exception = getPendingException();
return exception == null ? null : exception.getExitCode();
}
/**
* Retrieves the exception currently queued by a Blaze module.
*
* <p>Prefer getPendingExitCode or throwPendingException where appropriate.
*/
public AbruptExitException getPendingException() {
return pendingException.get();
}
/**
* Throws the exception currently queued by a Blaze module.
*
* <p>This should be called as often as is practical so that errors are reported as soon as
* possible. Ideally, we'd not need this, but the event bus swallows exceptions so we raise
* the exception this way.
*/
public void throwPendingException() throws AbruptExitException {
AbruptExitException exception = getPendingException();
if (exception != null) {
if (Thread.currentThread() == commandThread) {
// Throwing this exception counts as the requested interruption. Clear the interrupted bit.
Thread.interrupted();
}
throw exception;
}
}
/**
* Initializes the package cache using the given options, and syncs the package cache. Also
* injects the skylark semantics using the options for the {@link BuildConfiguration}.
*/
public void setupPackageCache(OptionsProvider options)
throws InterruptedException, AbruptExitException {
getSkyframeExecutor()
.sync(
reporter,
options.getOptions(PackageCacheOptions.class),
packageLocator,
options.getOptions(StarlarkSemanticsOptions.class),
getCommandId(),
clientEnv,
timestampGranularityMonitor,
options);
}
public void syncPackageLoading(
PackageCacheOptions packageCacheOptions, StarlarkSemanticsOptions starlarkSemanticsOptions)
throws AbruptExitException {
getSkyframeExecutor()
.syncPackageLoading(
packageCacheOptions,
packageLocator,
starlarkSemanticsOptions,
getCommandId(),
clientEnv,
timestampGranularityMonitor);
}
public void recordLastExecutionTime() {
workspace.recordLastExecutionTime(getCommandStartTime());
}
public void recordCommandStartTime(long commandStartTime) {
this.commandStartTime = commandStartTime;
}
public long getCommandStartTime() {
return commandStartTime;
}
@VisibleForTesting
public void setWorkingDirectoryForTesting(Path workingDirectory) {
setWorkingDirectory(workingDirectory);
}
private void setWorkingDirectory(Path workingDirectory) {
this.workingDirectory = workingDirectory;
if (getWorkspace() != null) {
this.relativeWorkingDirectory = workingDirectory.relativeTo(getWorkspace());
}
}
/**
* Hook method called by the BlazeCommandDispatcher prior to the dispatch of each command.
*
* @param commonOptions The CommonCommandOptions used by every command.
* @throws AbruptExitException if this command is unsuitable to be run as specified
*/
void beforeCommand(
OptionsParsingResult options,
CommonCommandOptions commonOptions,
long waitTimeInMs,
InvocationPolicy invocationPolicy)
throws AbruptExitException {
commandStartTime -= commonOptions.startupTime;
eventBus.post(
new GotOptionsEvent(runtime.getStartupOptionsProvider(), options, invocationPolicy));
throwPendingException();
outputService = null;
BlazeModule outputModule = null;
if (command.builds()) {
for (BlazeModule module : runtime.getBlazeModules()) {
OutputService moduleService = module.getOutputService();
if (moduleService != null) {
if (outputService != null) {
throw new IllegalStateException(
String.format(
"More than one module (%s and %s) returns an output service",
module.getClass(), outputModule.getClass()));
}
outputService = moduleService;
outputModule = module;
}
}
}
SkyframeExecutor skyframeExecutor = getSkyframeExecutor();
skyframeExecutor.setOutputService(outputService);
skyframeExecutor.noteCommandStart();
// Ensure that the working directory will be under the workspace directory.
Path workspace = getWorkspace();
Path workingDirectory;
if (inWorkspace()) {
workingDirectory = workspace.getRelative(commonOptions.clientCwd);
} else {
workspace = FileSystemUtils.getWorkingDirectory(getRuntime().getFileSystem());
workingDirectory = workspace;
}
this.setWorkingDirectory(workingDirectory);
// Fail fast in the case where a Blaze command forgets to install the package path correctly.
skyframeExecutor.setActive(false);
// Let skyframe figure out how much incremental state it will be keeping.
AnalysisOptions viewOptions = options.getOptions(AnalysisOptions.class);
skyframeExecutor.decideKeepIncrementalState(
runtime.getStartupOptionsProvider().getOptions(BlazeServerStartupOptions.class).batch,
commonOptions.keepStateAfterBuild, commonOptions.trackIncrementalState,
viewOptions != null && viewOptions.discardAnalysisCache,
reporter);
// Start the performance and memory profilers.
runtime.beforeCommand(this, commonOptions);
eventBus.post(new CommandStartEvent(
command.name(), getCommandId(), getClientEnv(), workingDirectory, getDirectories(),
waitTimeInMs + commonOptions.waitTime));
}
/** Returns the name of the file system we are writing output to. */
public String determineOutputFileSystem() {
// If we have a fancy OutputService, this may be different between consecutive Blaze commands
// and so we need to compute it freshly. Otherwise, we can used the immutable value that's
// precomputed by our BlazeWorkspace.
if (getOutputService() != null) {
try (SilentCloseable c =
Profiler.instance().profile(ProfilerTask.INFO, "Finding output file system")) {
return getOutputService().getFilesSystemName();
}
}
return workspace.getOutputBaseFilesystemTypeName();
}
/**
* Returns the client environment combined with all fixed env var settings from --action_env.
*/
public Map<String, String> getActionClientEnv() {
return Collections.unmodifiableMap(actionClientEnv);
}
}