Examples with UserExecException com.google.devtools.build.lib.actions.UserExecException used on opensource projects

Example 6 with UserExecException

use of com.google.devtools.build.lib.actions.UserExecException in project bazel by bazelbuild.

the class StandaloneSpawnStrategy method actuallyExec.

/**
   * Executes the given {@code spawn}.
   */
private void actuallyExec(Spawn spawn, ActionExecutionContext actionExecutionContext) throws ExecException {
    Executor executor = actionExecutionContext.getExecutor();
    if (executor.reportsSubcommands()) {
        executor.reportSubcommand(spawn);
    }
    int timeoutSeconds = Spawns.getTimeoutSeconds(spawn);
    // We must wrap the subprocess with process-wrapper to kill the process tree.
    // All actions therefore depend on the process-wrapper file. Since it's embedded,
    // we don't bother with declaring it as an input.
    List<String> args = new ArrayList<>();
    if (OS.getCurrent() != OS.WINDOWS) {
        // TODO(bazel-team): process-wrapper seems to work on Windows, but requires
        // additional setup as it is an msys2 binary, so it needs msys2 DLLs on %PATH%.
        // Disable it for now to make the setup easier and to avoid further PATH hacks.
        // Ideally we should have a native implementation of process-wrapper for Windows.
        args.add(processWrapper.getPathString());
        args.add(Integer.toString(timeoutSeconds));
        args.add("5");
        /* kill delay: give some time to print stacktraces and whatnot. */
        // TODO(bazel-team): use process-wrapper redirection so we don't have to
        // pass test logs through the Java heap.
        args.add("-");
        /* stdout. */
        args.add("-");
    /* stderr. */
    }
    args.addAll(spawn.getArguments());
    String cwd = executor.getExecRoot().getPathString();
    Command cmd = new Command(args.toArray(new String[] {}), locallyDeterminedEnv(execRoot, productName, spawn.getEnvironment()), new File(cwd), OS.getCurrent() == OS.WINDOWS && timeoutSeconds >= 0 ? timeoutSeconds * 1000 : -1);
    FileOutErr outErr = actionExecutionContext.getFileOutErr();
    try {
        cmd.execute(/* stdin */
        new byte[] {}, Command.NO_OBSERVER, outErr.getOutputStream(), outErr.getErrorStream(), /*killSubprocessOnInterrupt*/
        true);
    } catch (AbnormalTerminationException e) {
        TerminationStatus status = e.getResult().getTerminationStatus();
        boolean timedOut = !status.exited() && (status.timedout() || status.getTerminatingSignal() == 14);
        String message = CommandFailureUtils.describeCommandFailure(verboseFailures, spawn.getArguments(), spawn.getEnvironment(), cwd);
        throw new UserExecException(String.format("%s: %s", message, e), timedOut);
    } catch (CommandException e) {
        String message = CommandFailureUtils.describeCommandFailure(verboseFailures, spawn.getArguments(), spawn.getEnvironment(), cwd);
        throw new UserExecException(message, e);
    }
}

Example 7 with UserExecException

use of com.google.devtools.build.lib.actions.UserExecException in project bazel by bazelbuild.

the class WorkerSpawnStrategy method execInWorker.

private WorkResponse execInWorker(EventHandler eventHandler, WorkerKey key, WorkRequest request, int retriesLeft, AtomicReference<Class<? extends SpawnActionContext>> writeOutputFiles) throws IOException, InterruptedException, UserExecException {
    Worker worker = null;
    WorkResponse response = null;
    try {
        worker = workers.borrowObject(key);
        worker.prepareExecution(key);
        request.writeDelimitedTo(worker.getOutputStream());
        worker.getOutputStream().flush();
        RecordingInputStream recordingStream = new RecordingInputStream(worker.getInputStream());
        recordingStream.startRecording(4096);
        try {
            response = WorkResponse.parseDelimitedFrom(recordingStream);
        } catch (IOException e2) {
            // If protobuf couldn't parse the response, try to print whatever the failing worker wrote
            // to stdout - it's probably a stack trace or some kind of error message that will help the
            // user figure out why the compiler is failing.
            recordingStream.readRemaining();
            String data = recordingStream.getRecordedDataAsString(Charsets.UTF_8);
            eventHandler.handle(Event.warn("Worker process returned an unparseable WorkResponse:\n" + data));
            throw e2;
        }
        if (writeOutputFiles != null && !writeOutputFiles.compareAndSet(null, WorkerSpawnStrategy.class)) {
            throw new InterruptedException();
        }
        worker.finishExecution(key);
        if (response == null) {
            throw new UserExecException("Worker process did not return a WorkResponse. This is probably caused by a " + "bug in the worker, writing unexpected other data to stdout.");
        }
    } catch (IOException e) {
        if (worker != null) {
            workers.invalidateObject(key, worker);
            worker = null;
        }
        if (retriesLeft > 0) {
            // worker.
            if (workerVerbose) {
                eventHandler.handle(Event.warn(key.getMnemonic() + " worker failed (" + Throwables.getStackTraceAsString(e) + "), invalidating and retrying with new worker..."));
            } else {
                eventHandler.handle(Event.warn(key.getMnemonic() + " worker failed, invalidating and retrying with new worker..."));
            }
            return execInWorker(eventHandler, key, request, retriesLeft - 1, writeOutputFiles);
        } else {
            throw e;
        }
    } finally {
        if (worker != null) {
            workers.returnObject(key, worker);
        }
    }
    return response;
}

Example 8 with UserExecException

use of com.google.devtools.build.lib.actions.UserExecException in project bazel by bazelbuild.

the class WorkerSpawnStrategy method actuallyExec.

private void actuallyExec(Spawn spawn, ActionExecutionContext actionExecutionContext, AtomicReference<Class<? extends SpawnActionContext>> writeOutputFiles) throws ExecException, InterruptedException {
    Executor executor = actionExecutionContext.getExecutor();
    EventHandler eventHandler = executor.getEventHandler();
    if (executor.reportsSubcommands()) {
        executor.reportSubcommand(spawn);
    }
    // We assume that the spawn to be executed always gets at least one @flagfile.txt or
    // --flagfile=flagfile.txt argument, which contains the flags related to the work itself (as
    // opposed to start-up options for the executed tool). Thus, we can extract those elements from
    // its args and put them into the WorkRequest instead.
    List<String> flagfiles = new ArrayList<>();
    List<String> startupArgs = new ArrayList<>();
    for (String arg : spawn.getArguments()) {
        if (FLAG_FILE_PATTERN.matcher(arg).matches()) {
            flagfiles.add(arg);
        } else {
            startupArgs.add(arg);
        }
    }
    if (flagfiles.isEmpty()) {
        throw new UserExecException(String.format(ERROR_MESSAGE_PREFIX + REASON_NO_FLAGFILE, spawn.getMnemonic()));
    }
    if (Iterables.isEmpty(spawn.getToolFiles())) {
        throw new UserExecException(String.format(ERROR_MESSAGE_PREFIX + REASON_NO_TOOLS, spawn.getMnemonic()));
    }
    FileOutErr outErr = actionExecutionContext.getFileOutErr();
    ImmutableList<String> args = ImmutableList.<String>builder().addAll(startupArgs).add("--persistent_worker").addAll(MoreObjects.firstNonNull(extraFlags.get(spawn.getMnemonic()), ImmutableList.<String>of())).build();
    ImmutableMap<String, String> env = spawn.getEnvironment();
    try {
        ActionInputFileCache inputFileCache = actionExecutionContext.getActionInputFileCache();
        HashCode workerFilesHash = WorkerFilesHash.getWorkerFilesHash(spawn.getToolFiles(), actionExecutionContext);
        Map<PathFragment, Path> inputFiles = new SpawnHelpers(execRoot).getMounts(spawn, actionExecutionContext);
        Set<PathFragment> outputFiles = SandboxHelpers.getOutputFiles(spawn);
        WorkerKey key = new WorkerKey(args, env, execRoot, spawn.getMnemonic(), workerFilesHash, inputFiles, outputFiles, writeOutputFiles != null);
        WorkRequest.Builder requestBuilder = WorkRequest.newBuilder();
        for (String flagfile : flagfiles) {
            expandArgument(requestBuilder, flagfile);
        }
        List<ActionInput> inputs = ActionInputHelper.expandArtifacts(spawn.getInputFiles(), actionExecutionContext.getArtifactExpander());
        for (ActionInput input : inputs) {
            byte[] digestBytes = inputFileCache.getDigest(input);
            ByteString digest;
            if (digestBytes == null) {
                digest = ByteString.EMPTY;
            } else {
                digest = ByteString.copyFromUtf8(HashCode.fromBytes(digestBytes).toString());
            }
            requestBuilder.addInputsBuilder().setPath(input.getExecPathString()).setDigest(digest).build();
        }
        WorkResponse response = execInWorker(eventHandler, key, requestBuilder.build(), maxRetries, writeOutputFiles);
        outErr.getErrorStream().write(response.getOutputBytes().toByteArray());
        if (response.getExitCode() != 0) {
            throw new UserExecException(String.format("Worker process sent response with exit code: %d.", response.getExitCode()));
        }
    } catch (IOException e) {
        String message = CommandFailureUtils.describeCommandFailure(verboseFailures, spawn.getArguments(), env, execRoot.getPathString());
        throw new UserExecException(message, e);
    }
}

Example 9 with UserExecException

use of com.google.devtools.build.lib.actions.UserExecException in project bazel by bazelbuild.

the class SymlinkTreeHelper method createSymlinks.

/**
   * Creates symlink tree using appropriate method. At this time tree
   * always created using build-runfiles helper application.
   *
   * Note: method may try to acquire resources - meaning that it would
   * block for undetermined period of time. If it is interrupted during
   * that wait, ExecException will be thrown but interrupted bit will be
   * preserved.
   * @param action action instance that requested symlink tree creation
   * @param actionExecutionContext Services that are in the scope of the action.
   * @param enableRunfiles
   */
public void createSymlinks(AbstractAction action, ActionExecutionContext actionExecutionContext, BinTools binTools, ImmutableMap<String, String> shellEnvironment, boolean enableRunfiles) throws ExecException, InterruptedException {
    if (enableRunfiles) {
        List<String> args = getSpawnArgumentList(actionExecutionContext.getExecutor().getExecRoot(), binTools);
        actionExecutionContext.getExecutor().getSpawnActionContext(action.getMnemonic()).exec(new BaseSpawn.Local(args, shellEnvironment, action, RESOURCE_SET), actionExecutionContext);
    } else {
        // Pretend we created the runfiles tree by copying the manifest
        try {
            FileSystemUtils.createDirectoryAndParents(symlinkTreeRoot);
            FileSystemUtils.copyFile(inputManifest, symlinkTreeRoot.getChild("MANIFEST"));
        } catch (IOException e) {
            throw new UserExecException(e.getMessage(), e);
        }
    }
}

Example 10 with UserExecException

use of com.google.devtools.build.lib.actions.UserExecException in project bazel by bazelbuild.

the class RemoteSpawnStrategy method exec.

/** Executes the given {@code spawn}. */
@Override
public void exec(Spawn spawn, ActionExecutionContext actionExecutionContext) throws ExecException, InterruptedException {
    ActionKey actionKey = null;
    String mnemonic = spawn.getMnemonic();
    Executor executor = actionExecutionContext.getExecutor();
    EventHandler eventHandler = executor.getEventHandler();
    RemoteActionCache actionCache = null;
    RemoteWorkExecutor workExecutor = null;
    if (spawn.isRemotable()) {
        // action to enable server-side parallelism (need a different gRPC channel per action).
        try {
            if (ConcurrentMapFactory.isRemoteCacheOptions(options)) {
                actionCache = new ConcurrentMapActionCache(ConcurrentMapFactory.create(options));
            } else if (GrpcActionCache.isRemoteCacheOptions(options)) {
                actionCache = new GrpcActionCache(options);
            }
            if (actionCache != null && RemoteWorkExecutor.isRemoteExecutionOptions(options)) {
                workExecutor = new RemoteWorkExecutor(options);
            }
        } catch (InvalidConfigurationException e) {
            eventHandler.handle(Event.warn(e.toString()));
        }
    }
    if (!spawn.isRemotable() || actionCache == null) {
        standaloneStrategy.exec(spawn, actionExecutionContext);
        return;
    }
    if (workExecutor == null) {
        execLocally(spawn, actionExecutionContext, actionCache, actionKey);
        return;
    }
    if (executor.reportsSubcommands()) {
        executor.reportSubcommand(spawn);
    }
    executor.getEventBus().post(ActionStatusMessage.runningStrategy(spawn.getResourceOwner(), "remote"));
    try {
        // Temporary hack: the TreeNodeRepository should be created and maintained upstream!
        TreeNodeRepository repository = new TreeNodeRepository(execRoot);
        List<ActionInput> inputs = ActionInputHelper.expandArtifacts(spawn.getInputFiles(), actionExecutionContext.getArtifactExpander());
        TreeNode inputRoot = repository.buildFromActionInputs(inputs);
        repository.computeMerkleDigests(inputRoot);
        Command command = buildCommand(spawn.getArguments(), spawn.getEnvironment());
        Action action = buildAction(spawn.getOutputFiles(), ContentDigests.computeDigest(command), repository.getMerkleDigest(inputRoot));
        // Look up action cache, and reuse the action output if it is found.
        actionKey = ContentDigests.computeActionKey(action);
        ActionResult result = this.options.remoteAcceptCached ? actionCache.getCachedActionResult(actionKey) : null;
        boolean acceptCachedResult = this.options.remoteAcceptCached;
        if (result != null) {
            // just update the TreeNodeRepository and continue the build.
            try {
                actionCache.downloadAllResults(result, execRoot);
                return;
            } catch (CacheNotFoundException e) {
                // Retry the action remotely and invalidate the results.
                acceptCachedResult = false;
            }
        }
        // Upload the command and all the inputs into the remote cache.
        actionCache.uploadBlob(command.toByteArray());
        // TODO(olaola): this should use the ActionInputFileCache for SHA1 digests!
        actionCache.uploadTree(repository, execRoot, inputRoot);
        // TODO(olaola): set BuildInfo and input total bytes as well.
        ExecuteRequest.Builder request = ExecuteRequest.newBuilder().setAction(action).setAcceptCached(acceptCachedResult).setTotalInputFileCount(inputs.size()).setTimeoutMillis(1000 * Spawns.getTimeoutSeconds(spawn, 120));
        // TODO(olaola): set sensible local and remote timouts.
        ExecuteReply reply = workExecutor.executeRemotely(request.build());
        ExecutionStatus status = reply.getStatus();
        result = reply.getResult();
        // action.
        if (status.getSucceeded()) {
            passRemoteOutErr(actionCache, result, actionExecutionContext.getFileOutErr());
            actionCache.downloadAllResults(result, execRoot);
            return;
        }
        if (status.getError() == ExecutionStatus.ErrorCode.EXEC_FAILED || !options.remoteAllowLocalFallback) {
            passRemoteOutErr(actionCache, result, actionExecutionContext.getFileOutErr());
            throw new UserExecException(status.getErrorDetail());
        }
        // For now, we retry locally on all other remote errors.
        // TODO(olaola): add remote retries on cache miss errors.
        execLocally(spawn, actionExecutionContext, actionCache, actionKey);
    } catch (IOException e) {
        throw new UserExecException("Unexpected IO error.", e);
    } catch (InterruptedException e) {
        eventHandler.handle(Event.warn(mnemonic + " remote work interrupted (" + e + ")"));
        Thread.currentThread().interrupt();
        throw e;
    } catch (StatusRuntimeException e) {
        String stackTrace = "";
        if (verboseFailures) {
            stackTrace = "\n" + Throwables.getStackTraceAsString(e);
        }
        eventHandler.handle(Event.warn(mnemonic + " remote work failed (" + e + ")" + stackTrace));
        if (options.remoteAllowLocalFallback) {
            execLocally(spawn, actionExecutionContext, actionCache, actionKey);
        } else {
            throw new UserExecException(e);
        }
    } catch (CacheNotFoundException e) {
        eventHandler.handle(Event.warn(mnemonic + " remote work results cache miss (" + e + ")"));
        if (options.remoteAllowLocalFallback) {
            execLocally(spawn, actionExecutionContext, actionCache, actionKey);
        } else {
            throw new UserExecException(e);
        }
    } catch (UnsupportedOperationException e) {
        eventHandler.handle(Event.warn(mnemonic + " unsupported operation for action cache (" + e + ")"));
    }
}