Examples with ProblemsViewScope com.google.idea.blaze.base.scope.scopes.ProblemsViewScope used on opensource projects

Example 1 with ProblemsViewScope

use of com.google.idea.blaze.base.scope.scopes.ProblemsViewScope in project intellij by bazelbuild.

the class BlazeBeforeRunCommandHelper method runBlazeCommand.

/**
 * Kicks off the blaze task, returning a corresponding {@link ListenableFuture}.
 */
public static ListenableFuture<BuildResult> runBlazeCommand(BlazeCommandName commandName, BlazeCommandRunConfiguration configuration, BuildResultHelper buildResultHelper, List<String> requiredExtraBlazeFlags, List<String> overridableExtraBlazeFlags, BlazeInvocationContext invocationContext, String progressMessage) {
    Project project = configuration.getProject();
    BlazeCommandRunConfigurationCommonState handlerState = (BlazeCommandRunConfigurationCommonState) configuration.getHandler().getState();
    WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
    ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
    String binaryPath = handlerState.getBlazeBinaryState().getBlazeBinary() != null ? handlerState.getBlazeBinaryState().getBlazeBinary() : Blaze.getBuildSystemProvider(project).getBinaryPath(project);
    return ProgressiveTaskWithProgressIndicator.builder(project, TASK_TITLE).submitTaskWithResult(new ScopedTask<BuildResult>() {

        @Override
        protected BuildResult execute(BlazeContext context) {
            context.push(new ToolWindowScope.Builder(project, new Task(TASK_TITLE, Task.Type.BLAZE_BEFORE_RUN)).setPopupBehavior(BlazeUserSettings.getInstance().getShowBlazeConsoleOnRun()).setIssueParsers(BlazeIssueParser.defaultIssueParsers(project, workspaceRoot, invocationContext.type())).build()).push(new ProblemsViewScope(project, BlazeUserSettings.getInstance().getShowProblemsViewOnRun())).push(new BlazeConsoleScope.Builder(project).setPopupBehavior(BlazeUserSettings.getInstance().getShowBlazeConsoleOnRun()).addConsoleFilters(new IssueOutputFilter(project, workspaceRoot, invocationContext.type(), true)).build());
            context.output(new StatusOutput(progressMessage));
            BlazeCommand.Builder command = BlazeCommand.builder(binaryPath, commandName).addTargets(configuration.getTargets()).addBlazeFlags(overridableExtraBlazeFlags).addBlazeFlags(BlazeFlags.blazeFlags(project, projectViewSet, BlazeCommandName.BUILD, invocationContext)).addBlazeFlags(handlerState.getBlazeFlagsState().getFlagsForExternalProcesses()).addBlazeFlags(requiredExtraBlazeFlags).addBlazeFlags(buildResultHelper.getBuildFlags());
            int exitCode = ExternalTask.builder(workspaceRoot).addBlazeCommand(command.build()).context(context).stderr(LineProcessingOutputStream.of(BlazeConsoleLineProcessorProvider.getAllStderrLineProcessors(context))).build().run();
            return BuildResult.fromExitCode(exitCode);
        }
    });
}

Example 2 with ProblemsViewScope

use of com.google.idea.blaze.base.scope.scopes.ProblemsViewScope in project intellij by bazelbuild.

the class BlazeJavaRunProfileState method startProcess.

@Override
protected ProcessHandler startProcess() throws ExecutionException {
    Project project = getConfiguration().getProject();
    BlazeCommand.Builder blazeCommand;
    BlazeTestUiSession testUiSession = useTestUi() ? TestUiSessionProvider.getInstance(project).getTestUiSession(getConfiguration().getTargets()) : null;
    if (testUiSession != null) {
        blazeCommand = getBlazeCommandBuilder(project, getConfiguration(), testUiSession.getBlazeFlags(), getExecutorType());
        setConsoleBuilder(new TextConsoleBuilderImpl(project) {

            @Override
            protected ConsoleView createConsole() {
                return SmRunnerUtils.getConsoleView(project, getConfiguration(), getEnvironment().getExecutor(), testUiSession);
            }
        });
    } else {
        blazeCommand = getBlazeCommandBuilder(project, getConfiguration(), ImmutableList.of(), getExecutorType());
    }
    addConsoleFilters(new BlazeTargetFilter(true), new IssueOutputFilter(project, WorkspaceRoot.fromProject(project), BlazeInvocationContext.ContextType.RunConfiguration, false));
    List<String> command;
    if (HotSwapUtils.canHotSwap(getEnvironment())) {
        try {
            command = HotSwapCommandBuilder.getBashCommandsToRunScript(project, blazeCommand);
        } catch (IOException e) {
            logger.warn("Failed to create script path. Hot swap will be disabled.", e);
            command = blazeCommand.build().toList();
        }
    } else {
        command = blazeCommand.build().toList();
    }
    WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
    return new ScopedBlazeProcessHandler(project, command, workspaceRoot, new ScopedBlazeProcessHandler.ScopedProcessHandlerDelegate() {

        @Override
        public void onBlazeContextStart(BlazeContext context) {
            context.push(new ProblemsViewScope(project, BlazeUserSettings.getInstance().getShowProblemsViewOnRun())).push(new IdeaLogScope());
        }

        @Override
        public ImmutableList<ProcessListener> createProcessListeners(BlazeContext context) {
            LineProcessingOutputStream outputStream = LineProcessingOutputStream.of(BlazeConsoleLineProcessorProvider.getAllStderrLineProcessors(context));
            return ImmutableList.of(new LineProcessingProcessAdapter(outputStream));
        }
    });
}

Example 3 with ProblemsViewScope

use of com.google.idea.blaze.base.scope.scopes.ProblemsViewScope in project intellij by bazelbuild.

the class SyncPhaseCoordinator method setupScopes.

/**
 * Sets up the root {@link BlazeContext} for the given {@link SyncPhase}.
 */
private void setupScopes(BlazeSyncParams syncParams, BlazeContext context, ProgressIndicator indicator, SyncPhase phase, Task task, boolean startTaskOnScopeBegin) {
    boolean clearProblems = phase != SyncPhase.PROJECT_UPDATE;
    boolean notifyFinished = phase != SyncPhase.BUILD;
    context.push(new ExperimentScope());
    if (BlazeUserSettings.getInstance().getShowPerformanceWarnings()) {
        context.push(new PerformanceWarningScope());
    }
    context.push(new ProgressIndicatorScope(indicator));
    BlazeUserSettings userSettings = BlazeUserSettings.getInstance();
    context.push(new ToolWindowScope.Builder(project, task).setStartTaskOnScopeBegin(startTaskOnScopeBegin).setProgressIndicator(indicator).setPopupBehavior(syncParams.backgroundSync() ? FocusBehavior.NEVER : userSettings.getShowBlazeConsoleOnSync()).setIssueParsers(BlazeIssueParser.defaultIssueParsers(project, WorkspaceRoot.fromProject(project), ContextType.Sync)).build()).push(new BlazeConsoleScope.Builder(project, indicator).setPopupBehavior(syncParams.backgroundSync() ? FocusBehavior.NEVER : userSettings.getShowBlazeConsoleOnSync()).addConsoleFilters(new IssueOutputFilter(project, WorkspaceRoot.fromProject(project), ContextType.Sync, true)).setClearPreviousState(clearProblems).build()).push(new ProblemsViewScope(project, syncParams.backgroundSync() ? FocusBehavior.NEVER : userSettings.getShowProblemsViewOnSync(), /* resetProblemsContext= */
    clearProblems)).push(new IdeaLogScope());
    if (notifyFinished && !syncParams.backgroundSync() && syncParams.syncMode() != SyncMode.NO_BUILD) {
        context.push(new NotificationScope(project, "Sync", "Sync project", "Sync successful", "Sync failed"));
    }
    context.output(new StatusOutput(String.format("Syncing project: %s...", syncParams)));
}

Example 4 with ProblemsViewScope

use of com.google.idea.blaze.base.scope.scopes.ProblemsViewScope in project intellij by bazelbuild.

the class BlazeAndroidRunConfigurationRunner method executeBeforeRunTask.

@Override
public boolean executeBeforeRunTask(ExecutionEnvironment env) {
    final Project project = env.getProject();
    BlazeUserSettings settings = BlazeUserSettings.getInstance();
    return Scope.root(context -> {
        context.push(new ProblemsViewScope(project, settings.getShowProblemsViewOnRun())).push(new ExperimentScope()).push(new BlazeConsoleScope.Builder(project).setPopupBehavior(settings.getShowBlazeConsoleOnRun()).addConsoleFilters(new IssueOutputFilter(project, WorkspaceRoot.fromProject(project), BlazeInvocationContext.ContextType.BeforeRunTask, true)).build()).push(new ToolWindowScope.Builder(project, new Task("Build apk", Task.Type.BLAZE_BEFORE_RUN)).setPopupBehavior(settings.getShowBlazeConsoleOnRun()).setIssueParsers(BlazeIssueParser.defaultIssueParsers(project, WorkspaceRoot.fromProject(project), ContextType.BeforeRunTask)).build()).push(new IdeaLogScope());
        BlazeAndroidRunContext runContext = env.getCopyableUserData(RUN_CONTEXT_KEY);
        if (runContext == null) {
            IssueOutput.error("Could not find run context. Please try again").submit(context);
            return false;
        }
        BlazeAndroidDeviceSelector.DeviceSession deviceSession = env.getCopyableUserData(DEVICE_SESSION_KEY);
        ApkBuildStep buildStep = runContext.getBuildStep();
        ScopedTask<Void> buildTask = new ScopedTask<Void>(context) {

            @Override
            protected Void execute(BlazeContext context) {
                buildStep.build(context, deviceSession);
                return null;
            }
        };
        try {
            ListenableFuture<Void> buildFuture = ProgressiveTaskWithProgressIndicator.builder(project, String.format("Executing %s apk build", Blaze.buildSystemName(project))).submitTaskWithResult(buildTask);
            Futures.getChecked(buildFuture, ExecutionException.class);
        } catch (ExecutionException e) {
            context.setHasError();
        } catch (CancellationException e) {
            context.setCancelled();
        } catch (Exception e) {
            LOG.error(e);
            return false;
        }
        return context.shouldContinue();
    });
}

Example 5 with ProblemsViewScope

use of com.google.idea.blaze.base.scope.scopes.ProblemsViewScope in project intellij by bazelbuild.

the class BlazeBuildService method buildTargetExpressions.

private static void buildTargetExpressions(Project project, ProjectViewSet projectView, BlazeProjectData projectData, ScopedFunction<List<TargetExpression>> targetsFunction, NotificationScope notificationScope, String taskName) {
    if (ApplicationManager.getApplication().isUnitTestMode()) {
        // this never being called *and* relied on PROJECT_LAST_BUILD_TIMESTAMP_KEY being set
        return;
    }
    FocusBehavior problemsViewFocus = BlazeUserSettings.getInstance().getShowProblemsViewOnRun();
    // go/futurereturn-lsc
    @SuppressWarnings("unused") Future<?> possiblyIgnoredError = ProgressiveTaskWithProgressIndicator.builder(project, "Building targets").submitTaskWithResult(new ScopedTask<Void>() {

        @Override
        public Void execute(BlazeContext context) {
            Task task = new Task(taskName, Task.Type.BLAZE_MAKE);
            context.push(new ToolWindowScope.Builder(project, task).setIssueParsers(BlazeIssueParser.defaultIssueParsers(project, WorkspaceRoot.fromProject(project), BlazeInvocationContext.ContextType.Sync)).build()).push(new ExperimentScope()).push(new BlazeConsoleScope.Builder(project).addConsoleFilters(new IssueOutputFilter(project, WorkspaceRoot.fromProject(project), BlazeInvocationContext.ContextType.Sync, true)).build()).push(new ProblemsViewScope(project, problemsViewFocus)).push(new IdeaLogScope()).push(new TimingScope("Make", EventType.BlazeInvocation)).push(notificationScope);
            List<TargetExpression> targets = targetsFunction.execute(context);
            if (targets == null) {
                return null;
            }
            BlazeBuildParams buildParams = BlazeBuildParams.fromProject(project);
            WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
            SaveUtil.saveAllFiles();
            BlazeBuildListener.EP_NAME.extensions().forEach(e -> e.buildStarting(project));
            ShardedTargetsResult shardedTargets = BlazeBuildTargetSharder.expandAndShardTargets(project, context, workspaceRoot, buildParams, projectView, projectData.getWorkspacePathResolver(), targets);
            if (shardedTargets.buildResult.status == BuildResult.Status.FATAL_ERROR) {
                return null;
            }
            BlazeBuildOutputs buildOutputs = BlazeIdeInterface.getInstance().build(project, context, workspaceRoot, projectData.getBlazeVersionData(), buildParams, projectView, projectData.getBlazeInfo(), shardedTargets.shardedTargets, projectData.getWorkspaceLanguageSettings(), ImmutableSet.of(OutputGroup.COMPILE));
            refreshFileCachesAndNotifyListeners(context, buildOutputs, project);
            if (buildOutputs.buildResult.status != BuildResult.Status.SUCCESS) {
                context.setHasError();
            }
            return null;
        }
    });
}