1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
// Copyright 2015 Google Inc. 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.collect.ImmutableSet;
import com.google.common.eventbus.EventBus;
import com.google.devtools.build.lib.actions.cache.ActionCache;
import com.google.devtools.build.lib.analysis.BlazeDirectories;
import com.google.devtools.build.lib.analysis.BuildView;
import com.google.devtools.build.lib.analysis.config.BuildConfigurationCollection;
import com.google.devtools.build.lib.analysis.config.BuildOptions;
import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException;
import com.google.devtools.build.lib.events.Reporter;
import com.google.devtools.build.lib.packages.NoSuchThingException;
import com.google.devtools.build.lib.packages.Target;
import com.google.devtools.build.lib.pkgcache.LoadedPackageProvider;
import com.google.devtools.build.lib.pkgcache.PackageManager;
import com.google.devtools.build.lib.skyframe.SkyframeExecutor;
import com.google.devtools.build.lib.syntax.Label;
import com.google.devtools.build.lib.util.AbruptExitException;
import com.google.devtools.build.lib.util.ExitCode;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.common.options.OptionsProvider;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicReference;
/**
* 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 Reporter reporter;
private final EventBus eventBus;
private final BlazeModule.ModuleEnvironment blazeModuleEnvironment;
private final Map<String, String> clientEnv = new HashMap<>();
private AtomicReference<AbruptExitException> pendingException = new AtomicReference<>();
private class BlazeModuleEnvironment implements BlazeModule.ModuleEnvironment {
@Override
public Path getFileFromDepot(Label label)
throws NoSuchThingException, InterruptedException, IOException {
Target target = getPackageManager().getTarget(reporter, label);
return (runtime.getOutputService() != null)
? runtime.getOutputService().stageTool(target)
: target.getPackage().getPackageDirectory().getRelative(target.getName());
}
@Override
public void exit(AbruptExitException exception) {
pendingException.compareAndSet(null, exception);
}
}
public CommandEnvironment(BlazeRuntime runtime, Reporter reporter, EventBus eventBus) {
this.runtime = runtime;
this.reporter = reporter;
this.eventBus = eventBus;
this.blazeModuleEnvironment = new BlazeModuleEnvironment();
}
public BlazeRuntime getRuntime() {
return runtime;
}
public BlazeDirectories getDirectories() {
return runtime.getDirectories();
}
/**
* 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 Collections.unmodifiableMap(clientEnv);
}
@VisibleForTesting
void updateClientEnv(List<Map.Entry<String, String>> clientEnvList, boolean ignoreClientEnv) {
Preconditions.checkState(clientEnv.isEmpty());
Collection<Map.Entry<String, String>> env =
ignoreClientEnv ? System.getenv().entrySet() : clientEnvList;
for (Map.Entry<String, String> entry : env) {
clientEnv.put(entry.getKey(), entry.getValue());
}
}
public PackageManager getPackageManager() {
return runtime.getPackageManager();
}
public BuildView getView() {
return runtime.getView();
}
public UUID getCommandId() {
return runtime.getCommandId();
}
public SkyframeExecutor getSkyframeExecutor() {
return runtime.getSkyframeExecutor();
}
public Path getWorkingDirectory() {
return runtime.getWorkingDirectory();
}
public ActionCache getPersistentActionCache() throws IOException {
return runtime.getPersistentActionCache(reporter);
}
/**
* This method only exists for the benefit of InfoCommand, which needs to construct a {@link
* BuildConfigurationCollection} without running a full loading phase. Don't add any more clients;
* instead, we should change info so that it doesn't need the configuration.
*/
public BuildConfigurationCollection getConfigurations(OptionsProvider optionsProvider)
throws InvalidConfigurationException, InterruptedException {
BuildOptions buildOptions = runtime.createBuildOptions(optionsProvider);
boolean keepGoing = optionsProvider.getOptions(BuildView.Options.class).keepGoing;
LoadedPackageProvider loadedPackageProvider =
runtime.getLoadingPhaseRunner().loadForConfigurations(reporter,
ImmutableSet.copyOf(buildOptions.getAllLabels().values()),
keepGoing);
if (loadedPackageProvider == null) {
throw new InvalidConfigurationException("Configuration creation failed");
}
return getSkyframeExecutor().createConfigurations(runtime.getConfigurationFactory(),
buildOptions, runtime.getDirectories(), ImmutableSet.<String>of(), keepGoing);
}
/**
* 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));
// If Blaze did not suffer an infrastructure failure, check for errors in modules.
ExitCode exitCode = originalExit;
AbruptExitException exception = pendingException.get();
if (!originalExit.isInfrastructureFailure() && exception != null) {
exitCode = exception.getExitCode();
}
return exitCode;
}
/**
* 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 = pendingException.get();
if (exception != null) {
throw exception;
}
}
}
|
