下面列出了com.google.common.base.Throwables#throwIfInstanceOf ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Override
public HashCode getForArchiveMember(Path archiveRelativePath, Path memberPath)
throws IOException {
Path relativeFilePath = archiveRelativePath.normalize();
try {
JarHashCodeAndFileType fileHashCodeAndFileType =
(JarHashCodeAndFileType) loadingCache.get(relativeFilePath);
HashCodeAndFileType memberHashCodeAndFileType =
fileHashCodeAndFileType.getContents().get(memberPath);
if (memberHashCodeAndFileType == null) {
throw new NoSuchFileException(archiveRelativePath.toString());
}
return memberHashCodeAndFileType.getHashCode();
} catch (ExecutionException e) {
Throwables.throwIfInstanceOf(e.getCause(), IOException.class);
throw new RuntimeException(e.getCause());
}
}
@Override
public final DynamicExecutionResult call() throws InterruptedException {
taskFinished.register();
try {
List<SpawnResult> spawnResults = callImpl();
return DynamicExecutionResult.create(strategyIdentifier, fileOutErr, null, spawnResults);
} catch (Exception e) {
Throwables.throwIfInstanceOf(e, InterruptedException.class);
return DynamicExecutionResult.create(
strategyIdentifier,
fileOutErr,
e instanceof ExecException
? (ExecException) e
: new UserExecException(
e, createFailureDetail(Strings.nullToEmpty(e.getMessage()), Code.RUN_FAILURE)),
/*spawnResults=*/ ImmutableList.of());
} finally {
try {
fileOutErr.close();
} catch (IOException ignored) {
// Nothing we can do here.
}
taskFinished.arriveAndDeregister();
}
}
private S3Client getSyncClient(String bucket) throws IOException {
try {
return syncClientCache.get(bucket);
} catch (ExecutionException | SdkClientException e ) {
final Throwable cause = e.getCause();
final Throwable toChain;
if (cause == null) {
toChain = e;
} else {
Throwables.throwIfInstanceOf(cause, UserException.class);
Throwables.throwIfInstanceOf(cause, IOException.class);
toChain = cause;
}
throw new IOException(String.format("Unable to create a sync S3 client for bucket %s", bucket), toChain);
}
}
private <T extends AddsToRuleKey> void initialize(T instance, ClassInfo<? super T> classInfo)
throws IOException {
if (classInfo.getSuperInfo().isPresent()) {
initialize(instance, classInfo.getSuperInfo().get());
}
ImmutableCollection<FieldInfo<?>> fields = classInfo.getFieldInfos();
for (FieldInfo<?> info : fields) {
try {
Object value = createForField(info);
setField(info.getField(), instance, value);
} catch (Exception e) {
Throwables.throwIfInstanceOf(e, IOException.class);
throw new BuckUncheckedExecutionException(
e,
"When trying to initialize %s.%s.",
instance.getClass().getName(),
info.getField().getName());
}
}
}
/**
* Returns the {@link OptionsData} associated with the given list of options classes.
*/
static synchronized OptionsData getOptionsDataInternal(
List<Class<? extends OptionsBase>> optionsClasses) throws ConstructionException {
ImmutableList<Class<? extends OptionsBase>> immutableOptionsClasses =
ImmutableList.copyOf(optionsClasses);
OptionsData result = optionsData.get(immutableOptionsClasses);
if (result == null) {
try {
result = OptionsData.from(immutableOptionsClasses);
} catch (Exception e) {
Throwables.throwIfInstanceOf(e, ConstructionException.class);
throw new ConstructionException(e.getMessage(), e);
}
optionsData.put(immutableOptionsClasses, result);
}
return result;
}
/**
* Execute a {@link Callable}, retrying execution in case of failure and returning the result in
* case of success.
*
* <p>{@link InterruptedException} is not retried.
*
* @param call the {@link Callable} to execute.
* @throws Exception if the {@code call} didn't succeed within the framework specified by {@code
* backoffSupplier} and {@code shouldRetry}.
* @throws CircuitBreakerException in case a call was rejected because the circuit breaker
* tripped.
* @throws InterruptedException if the {@code call} throws an {@link InterruptedException} or the
* current thread's interrupted flag is set.
*/
public <T> T execute(Callable<T> call) throws Exception {
final Backoff backoff = newBackoff();
while (true) {
final State circuitState;
circuitState = circuitBreaker.state();
if (State.REJECT_CALLS.equals(circuitState)) {
throw new CircuitBreakerException();
}
try {
if (Thread.interrupted()) {
throw new InterruptedException();
}
T r = call.call();
circuitBreaker.recordSuccess();
return r;
} catch (Exception e) {
circuitBreaker.recordFailure();
Throwables.throwIfInstanceOf(e, InterruptedException.class);
if (State.TRIAL_CALL.equals(circuitState)) {
throw e;
}
if (!shouldRetry.test(e)) {
throw e;
}
final long delayMillis = backoff.nextDelayMillis();
if (delayMillis < 0) {
throw e;
}
sleeper.sleep(delayMillis);
}
}
}
public static EtcdClient getClient(EtcdClusterConfig config) throws IOException, CertificateException {
try {
return clientCache.get(new CacheKey(config), config::newClient);
} catch (ExecutionException ee) {
Throwables.throwIfInstanceOf(ee.getCause(), IOException.class);
Throwables.throwIfInstanceOf(ee.getCause(), CertificateException.class);
Throwables.throwIfUnchecked(ee.getCause());
throw new RuntimeException(ee.getCause());
}
}
@Override
public void encrypt(String sourceFile, String targetFile, Collection<Key> recipients,
ProgressHandler optionalProgressHandler, InputStreamSupervisor optionalInputStreamSupervisor,
OutputStreamSupervisor optionalOutputStreamSupervisor) throws UserRequestedCancellationException {
try {
InputStreamSupervisor inputStreamSupervisor = optionalInputStreamSupervisor != null
? optionalInputStreamSupervisor
: new InputStreamSupervisorImpl();
OutputStreamSupervisor outputStreamSupervisor = optionalOutputStreamSupervisor != null
? optionalOutputStreamSupervisor
: new OutputStreamSupervisorImpl();
Updater progress = null;
if (optionalProgressHandler != null) {
progress = Progress.create("action.encrypt", optionalProgressHandler);
progress.updateStepInfo("progress.preparingKeys");
}
PGPEncryptedDataGenerator dataGenerator = buildEncryptedDataGenerator(
buildKeysListForEncryption(recipients));
OutputStream out = new BufferedOutputStream(outputStreamSupervisor.get(targetFile));
InputStream in = inputStreamSupervisor.get(sourceFile);
doEncryptFile(in, SourceInfo.fromFile(sourceFile), out, dataGenerator, progress, PGPLiteralData.BINARY);
out.close();
in.close();
} catch (Throwable t) {
File fileToDelete = new File(targetFile);
if (fileToDelete.exists() && !fileToDelete.delete()) {
log.warn("Failed to delete file after failed encryption: " + targetFile);
}
Throwables.throwIfInstanceOf(t, UserRequestedCancellationException.class);
throw new RuntimeException("Encryption failed", t);
}
}
/**
* Throws an appropriate exception when all attempts failed.
*
* @param e the retry exception
* @param actionDescription a description of the action being performed
* @throws InterruptedException if the action was interrupted
* @throws E if the action timed out
*/
private static <E extends CcmException> void handleAllAttemptsFailed(
RetryException e, String actionDescription, Class<E> exceptionClass, Supplier<E> exceptionSupplier, Logger logger) throws InterruptedException, E {
logger.info("Failed to {}", actionDescription);
Attempt<?> lastFailedAttempt = e.getLastFailedAttempt();
if (lastFailedAttempt.hasException()) {
Throwable cause = lastFailedAttempt.getExceptionCause();
Throwables.throwIfInstanceOf(cause, exceptionClass);
Throwables.throwIfInstanceOf(cause, InterruptedException.class);
Throwables.throwIfUnchecked(cause);
throw new IllegalStateException(cause);
} else {
throw exceptionSupplier.get();
}
}
private void runDxCommands(ExecutionContext context, Multimap<Path, Path> outputToInputs)
throws StepFailedException, InterruptedException {
// Invoke dx commands in parallel for maximum thread utilization. In testing, dx revealed
// itself to be CPU (and not I/O) bound making it a good candidate for parallelization.
Stream<ImmutableList<Step>> dxSteps = generateDxCommands(filesystem, outputToInputs);
ImmutableList<Callable<Unit>> callables =
dxSteps
.map(
steps ->
(Callable<Unit>)
() -> {
for (Step step : steps) {
StepRunner.runStep(context, step, Optional.of(buildTarget));
}
return Unit.UNIT;
})
.collect(ImmutableList.toImmutableList());
try {
MoreFutures.getAll(executorService, callables);
} catch (ExecutionException e) {
Throwable cause = e.getCause();
Throwables.throwIfInstanceOf(cause, StepFailedException.class);
// Programmer error. Boo-urns.
throw new RuntimeException(cause);
}
}
@Override
public void sendOverStream(PublishBuildToolEventStreamRequest buildEvent)
throws InterruptedException {
throwIfInterrupted();
try {
stream.onNext(buildEvent);
} catch (StatusRuntimeException e) {
Throwables.throwIfInstanceOf(Throwables.getRootCause(e), InterruptedException.class);
streamStatus.set(Status.fromThrowable(e));
}
}
/**
* Given a list of {@code requestedSelectables}, returns all features that are enabled by the
* toolchain configuration.
*
* <p>A requested feature will not be enabled if the toolchain does not support it (which may
* depend on other requested features).
*
* <p>Additional features will be enabled if the toolchain supports them and they are implied by
* requested features.
*
* <p>If multiple threads call this method we may do additional work in initializing the cache.
* This reinitialization is benign.
*/
public FeatureConfiguration getFeatureConfiguration(ImmutableSet<String> requestedSelectables)
throws CollidingProvidesException {
try {
if (configurationCache == null) {
configurationCache = buildConfigurationCache();
}
return configurationCache.get(requestedSelectables);
} catch (ExecutionException e) {
Throwables.throwIfInstanceOf(e.getCause(), CollidingProvidesException.class);
Throwables.throwIfUnchecked(e.getCause());
throw new IllegalStateException("Unexpected checked exception encountered", e);
}
}
@Override
public Key createNewKey(CreateKeyParams params) throws FieldValidationException {
try {
Preconditions.checkArgument(params != null, "params must not be null");
assertParamsValid(params);
// Create Master key
KeyPair masterKey = getOrGenerateKeyPair(getMasterKeyParameters());
PGPKeyPair masterKeyBc = new JcaPGPKeyPair(algorithmNameToTag(masterKeyPurpose), masterKey, new Date());
BcPGPContentSignerBuilder keySignerBuilderBc = new BcPGPContentSignerBuilder(
algorithmNameToTag(masterKeyPurpose), hashAlgorithmNameToTag(masterKeySignerHashingAlgorithm));
// Setup seret key encryption
PGPDigestCalculator digestCalc = new BcPGPDigestCalculatorProvider()
.get(hashAlgorithmNameToTag(secretKeyHashingAlgorithm));
BcPBESecretKeyEncryptorBuilder encryptorBuilderBC = new BcPBESecretKeyEncryptorBuilder(
symmetricKeyAlgorithmNameToTag(secretKeyEncryptionAlgorithm), digestCalc);
PBESecretKeyEncryptor keyEncryptorBc = encryptorBuilderBC.build(params.getPassphrase().toCharArray());
// Key pair generator
String userName = params.getFullName() + " <" + params.getEmail() + ">";
PGPKeyRingGenerator keyPairGeneratorBc = new PGPKeyRingGenerator(PGPSignature.POSITIVE_CERTIFICATION,
masterKeyBc, userName, digestCalc, null, null, keySignerBuilderBc, keyEncryptorBc);
// Add Sub-key for encryption
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(encryptionKeyAlgorithm, PROVIDER);
if ("ELGAMAL".equals(encryptionKeyAlgorithm)) {
keyPairGenerator.initialize(new DHParameterSpec(dhParamsPrimeModulus, dhParamsBaseGenerator));
} else if ("RSA".equals(encryptionKeyAlgorithm)) {
// Re-using master key size.
keyPairGenerator.initialize(new RSAKeyGenParameterSpec(masterKeySize, RSAKeyGenParameterSpec.F4));
} else {
throw new IllegalArgumentException(
"Hanlding of parameter creation for " + encryptionKeyAlgorithm + " is not implemented");
}
KeyPair encryptionSubKey = keyPairGenerator.generateKeyPair();
PGPKeyPair encryptionSubKeyBc = new JcaPGPKeyPair(algorithmNameToTag(encryptionKeyPurpose),
encryptionSubKey, new Date());
keyPairGeneratorBc.addSubKey(encryptionSubKeyBc);
// TBD-191: Also add a sub-key for signing
// KeyPair signatureSubKey = keyPairGenerator.generateKeyPair();
// PGPKeyPair signatureSubKeyBc = new
// TBD-191: RSA_SIGN must not be hardcoded
// JcaPGPKeyPair(algorithmNameToTag("RSA_SIGN"), signatureSubKey,
// new Date());
// keyPairGeneratorBc.addSubKey(signatureSubKeyBc);
// building ret
return buildKey(keyPairGeneratorBc);
} catch (Throwable t) {
Throwables.throwIfInstanceOf(t, FieldValidationException.class);
throw new RuntimeException("Failed to generate key", t);
}
}
@Override
public void extractSwigIncludes(
Set<Artifact> includes,
ActionExecutionMetadata actionExecutionMetadata,
ActionExecutionContext actionExecContext,
Artifact source,
ImmutableSet<Artifact> legalOutputPaths,
ImmutableList<PathFragment> swigIncludePaths,
Artifact grepIncludes)
throws IOException, ExecException, InterruptedException {
SwigIncludeScanner scanner =
new SwigIncludeScanner(
includePool.get(),
spawnScannerSupplier.get(),
cache,
swigIncludePaths,
env.getDirectories(),
env.getSkyframeBuildView().getArtifactFactory(),
env.getExecRoot(),
useAsyncIncludeScanner);
ImmutableMap.Builder<PathFragment, Artifact> pathToLegalOutputArtifact =
ImmutableMap.builder();
for (Artifact path : legalOutputPaths) {
pathToLegalOutputArtifact.put(path.getExecPath(), path);
}
try {
scanner
.processAsync(
source,
ImmutableList.of(source),
// For Swig include scanning just point to the output file in the map.
new IncludeScanningHeaderData.Builder(
pathToLegalOutputArtifact.build(), /*modularHeaders=*/ ImmutableSet.of())
.build(),
ImmutableList.of(),
includes,
actionExecutionMetadata,
actionExecContext,
grepIncludes)
.get();
} catch (ExecutionException e) {
Throwables.throwIfInstanceOf(e.getCause(), ExecException.class);
Throwables.throwIfInstanceOf(e.getCause(), InterruptedException.class);
if (e.getCause() instanceof IORuntimeException) {
throw ((IORuntimeException) e.getCause()).getCauseIOException();
}
Throwables.throwIfUnchecked(e.getCause());
throw new IllegalStateException(e.getCause());
}
}
private void waitForBuildEventTransportsToClose(
Map<BuildEventTransport, ListenableFuture<Void>> transportFutures,
boolean besUploadModeIsSynchronous)
throws AbruptExitException {
final ScheduledExecutorService executor =
Executors.newSingleThreadScheduledExecutor(
new ThreadFactoryBuilder().setNameFormat("bes-notify-ui-%d").build());
ScheduledFuture<?> waitMessageFuture = null;
try {
// Notify the UI handler when a transport finished closing.
transportFutures.forEach(
(bepTransport, closeFuture) ->
closeFuture.addListener(
() -> {
reporter.post(new BuildEventTransportClosedEvent(bepTransport));
},
executor));
try (AutoProfiler p = GoogleAutoProfilerUtils.logged("waiting for BES close")) {
Uninterruptibles.getUninterruptibly(Futures.allAsList(transportFutures.values()));
}
} catch (ExecutionException e) {
// Futures.withTimeout wraps the TimeoutException in an ExecutionException when the future
// times out.
if (isTimeoutException(e)) {
throw createAbruptExitException(
e,
"The Build Event Protocol upload timed out.",
ExitCode.TRANSIENT_BUILD_EVENT_SERVICE_UPLOAD_ERROR,
BuildProgress.Code.BES_UPLOAD_TIMEOUT_ERROR);
}
Throwables.throwIfInstanceOf(e.getCause(), AbruptExitException.class);
throw new RuntimeException(
String.format(
"Unexpected Exception '%s' when closing BEP transports, this is a bug.",
e.getCause().getMessage()));
} finally {
if (besUploadModeIsSynchronous) {
cancelAndResetPendingUploads();
}
if (waitMessageFuture != null) {
waitMessageFuture.cancel(/* mayInterruptIfRunning= */ true);
}
executor.shutdown();
}
}
@Subscribe
public void invalidateBasedOn(WatchmanPathEvent event) {
LOG.verbose("Parser watched event %s %s", event.getKind(), event.getPath());
filesChangedCounter.inc();
RelPath path = event.getPath();
AbsPath fullPath = event.getCellPath().resolve(event.getPath());
// We only care about creation and deletion events because modified should result in a
// rule key change. For parsing, these are the only events we need to care about.
if (isPathCreateOrDeleteEvent(event)) {
try (AutoCloseableLock readLock = cellStateLock.readLock()) {
for (DaemonicCellState state : cellPathToDaemonicState.values()) {
try {
Cell cell = state.getCell();
BuildFileTree buildFiles = buildFileTrees.get(cell);
if (fullPath.endsWith(cell.getBuckConfigView(ParserConfig.class).getBuildFileName())) {
LOG.debug(
"Build file %s changed, invalidating build file tree for cell %s",
fullPath, cell);
// If a build file has been added or removed, reconstruct the build file tree.
buildFileTrees.invalidate(cell);
}
// Added or removed files can affect globs, so invalidate the package build file
// "containing" {@code path} unless its filename matches a temp file pattern.
if (!cell.getFilesystem().isIgnored(path)) {
invalidateContainingBuildFile(state, cell, buildFiles, path);
} else {
LOG.debug(
"Not invalidating the owning build file of %s because it is a temporary file.",
fullPath);
}
} catch (ExecutionException | UncheckedExecutionException e) {
try {
Throwables.throwIfInstanceOf(e, BuildFileParseException.class);
Throwables.throwIfUnchecked(e);
throw new RuntimeException(e);
} catch (BuildFileParseException bfpe) {
LOG.warn("Unable to parse already parsed build file.", bfpe);
}
}
}
}
}
if (configurationBuildFiles.contains(fullPath) || configurationRulesDependOn(path.getPath())) {
invalidateAllCaches();
} else {
invalidatePath(fullPath);
}
}
/**
* Returns the configurations corresponding to the given sets of build options. Output order is
* the same as input order.
*
* @throws InvalidConfigurationException if any build options produces an invalid configuration
*/
// TODO(ulfjack): Remove this legacy method after switching to the Skyframe-based implementation.
private ImmutableList<BuildConfiguration> getConfigurations(
ExtendedEventHandler eventHandler,
List<BuildOptions> optionsList,
BuildOptions referenceBuildOptions,
boolean keepGoing)
throws InvalidConfigurationException {
Preconditions.checkArgument(!Iterables.isEmpty(optionsList));
// Prepare the Skyframe inputs.
// TODO(gregce): support trimmed configs.
ImmutableSortedSet<Class<? extends Fragment>> allFragments =
ruleClassProvider.getConfigurationFragments().stream()
.map(factory -> factory.creates())
.collect(
ImmutableSortedSet.toImmutableSortedSet(BuildConfiguration.lexicalFragmentSorter));
PlatformMappingValue platformMappingValue =
getPlatformMappingValue(eventHandler, referenceBuildOptions);
ImmutableList.Builder<SkyKey> configSkyKeysBuilder = ImmutableList.builder();
for (BuildOptions options : optionsList) {
configSkyKeysBuilder.add(toConfigurationKey(platformMappingValue, allFragments, options));
}
ImmutableList<SkyKey> configSkyKeys = configSkyKeysBuilder.build();
// Skyframe-evaluate the configurations and throw errors if any.
EvaluationResult<SkyValue> evalResult = evaluateSkyKeys(eventHandler, configSkyKeys, keepGoing);
if (evalResult.hasError()) {
Map.Entry<SkyKey, ErrorInfo> firstError = Iterables.get(evalResult.errorMap().entrySet(), 0);
ErrorInfo error = firstError.getValue();
Throwable e = error.getException();
// Wrap loading failed exceptions
if (e instanceof NoSuchThingException) {
e = new InvalidConfigurationException(e);
} else if (e == null && !error.getCycleInfo().isEmpty()) {
getCyclesReporter().reportCycles(error.getCycleInfo(), firstError.getKey(), eventHandler);
e =
new InvalidConfigurationException(
"cannot load build configuration because of this cycle");
}
if (e != null) {
Throwables.throwIfInstanceOf(e, InvalidConfigurationException.class);
}
throw new IllegalStateException("Unknown error during configuration creation evaluation", e);
}
// Prepare and return the results.
return configSkyKeys.stream()
.map(key -> ((BuildConfigurationValue) evalResult.get(key)).getConfiguration())
.collect(ImmutableList.toImmutableList());
}
@Override
@SuppressWarnings("PMD")
public TargetGraph build() throws TimeoutException, InterruptedException, VersionException {
LOG.debug(
"Starting version target graph transformation (nodes %d)",
unversionedTargetGraphCreationResult.getTargetGraph().getNodes().size());
long start = System.currentTimeMillis();
ImmutableSet<VersionTargetGraphKey> rootKeys =
RichStream.from(
unversionedTargetGraphCreationResult
.getTargetGraph()
.getAll(unversionedTargetGraphCreationResult.getBuildTargets()))
.map(ImmutableVersionTargetGraphKey::of)
.collect(ImmutableSet.toImmutableSet());
ImmutableMap<VersionTargetGraphKey, Future<TargetNode<?>>> results =
asyncTransformationEngine.computeAll(rootKeys);
// Wait for actions to complete.
for (Future<TargetNode<?>> futures : results.values()) {
try {
futures.get(timeout, timeUnit);
} catch (ExecutionException e) {
Throwable rootCause = Throwables.getRootCause(e);
Throwables.throwIfInstanceOf(rootCause, VersionException.class);
Throwables.throwIfInstanceOf(rootCause, TimeoutException.class);
Throwables.throwIfInstanceOf(rootCause, RuntimeException.class);
throw new IllegalStateException(
String.format("Unexpected exception: %s: %s", e.getClass(), e.getMessage()), e);
}
}
asyncTransformationEngine.close();
versionInfoAsyncTransformationEngine.close();
long end = System.currentTimeMillis();
VersionedTargetGraph graph = versionedTargetGraphTransformer.targetGraphBuilder.build();
LOG.debug(
"Finished version target graph transformation in %.2f (nodes %d, roots: %d)",
(end - start) / 1000.0, graph.getSize(), versionedTargetGraphTransformer.roots.get());
return graph;
}
/**
* Compute the BzlLoadValue for all given keys by "inlining" the BzlLoadFunction and bypassing
* traditional Skyframe evaluation, returning {@code null} if Skyframe deps were missing and have
* been requested.
*/
@Nullable
private static List<BzlLoadValue> computeBzlLoadsWithInlining(
Environment env, List<BzlLoadValue.Key> keys, BzlLoadFunction bzlLoadFunctionForInlining)
throws InterruptedException, BzlLoadFailedException, InconsistentFilesystemException {
List<BzlLoadValue> bzlLoads = Lists.newArrayListWithExpectedSize(keys.size());
Exception deferredException = null;
boolean valuesMissing = false;
// Compute BzlLoadValue for each key, sharing the same inlining state, i.e. cache of loaded
// modules. This ensures that each .bzl is loaded only once, regardless of diamond dependencies
// or cache eviction. (Multiple loads of the same .bzl would screw up identity equality of some
// Starlark symbols -- see comments in BzlLoadFunction#computeInline.)
BzlLoadFunction.InliningState inliningState = BzlLoadFunction.InliningState.create();
for (BzlLoadValue.Key key : keys) {
SkyValue skyValue;
try {
// Will complete right away if it's already cached in inliningState.
skyValue = bzlLoadFunctionForInlining.computeInline(key, env, inliningState);
} catch (BzlLoadFailedException | InconsistentFilesystemException e) {
// For determinism's sake while inlining, preserve the first exception and continue to run
// subsequently listed loads to completion/exception, loading all transitive deps anyway.
deferredException = MoreObjects.firstNonNull(deferredException, e);
continue;
}
if (skyValue == null) {
checkState(env.valuesMissing(), "no starlark load value for %s", key);
// We continue making inline calls even if some requested values are missing, to
// maximize the number of dependent (non-inlined) SkyFunctions that are requested, thus
// avoiding a quadratic number of restarts.
valuesMissing = true;
} else {
bzlLoads.add((BzlLoadValue) skyValue);
}
}
if (deferredException != null) {
Throwables.throwIfInstanceOf(deferredException, BzlLoadFailedException.class);
Throwables.throwIfInstanceOf(deferredException, InconsistentFilesystemException.class);
throw new IllegalStateException(
"caught a checked exception of unexpected type", deferredException);
}
return valuesMissing ? null : bzlLoads;
}
/**
* Traverse exception chain by recursively calling {@code getCause()} and throws it if initial
* exception (the one at the bottom of the stack) is an instance of {@code declaredType}.
* Example usage:
*
* <pre>
* try {
* future.get()
* } catch (ExecutionException) {
* MoreThrowables.throwIfInitialCauseInstanceOf(t, BarException.class);
* }
*/
public static <X extends Throwable> void throwIfInitialCauseInstanceOf(
Throwable throwable, Class<X> declaredType) throws X {
Throwable cause = getInitialCause(throwable);
Throwables.throwIfInstanceOf(cause, declaredType);
}