Attachment 289217 Details for Bug 329657 – Patch proposal

[patch] Patch proposal

BuildActionFilter.java (text/plain), 17.21 KB, created by Muhammad Arsalan

on 2023-10-29 06:47:22 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Muhammad Arsalan

Created: 2023-10-29 06:47:22 EDT

Size: 17.21 KB

patch

obsolete

>package org.eclipse.ui.actions;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.ui.internal.actions.BuildState;
>
>/**
> * A filter that selects which actions should be blocked during the build
> * process.
> */
>public class BuildActionFilter {
>
>    private static final String RUN_LAUNCH_ACTION_ID = "org.eclipse.debug.ui.runAction";
>    private static final String SAVE_ACTION_ID = "org.eclipse.ui.file.save";
>    private static final String COMMIT_ACTION_ID = "org.eclipse.team.ui.commitAction";
>
>    /**
>     * Checks if the given action should be blocked during the build process.
>     *
>     * @param action the action to be checked
>     * @param buildState the current state of the build process
>     * @return `true` if the action should be blocked, `false` otherwise
>     */
>    public static boolean shouldBlock(Action action, BuildState buildState) {
>        String actionId = action.getId();
>
>        if (actionId.equals(RUN_LAUNCH_ACTION_ID)) {
>            return buildState != BuildState.COMPLETE;
>        } else if (actionId.equals(SAVE_ACTION_ID) || actionId.equals(COMMIT_ACTION_ID)) {
>            return buildState == BuildState.BUILDING;
>        } else {
>            return false;
>        }
>    }
>
>    /**
>     * Waits for the current build process to finish.
>     */
>    public static void waitForBuildToFinish() {
>        Job buildJob = Job.getJobManager().find(BuildJob.class);
>        if (buildJob != null && buildJob.getState() == Job.RUNNING) {
>            buildJob.join();
>        }
>    }
>}
>
>
>
>
>
>package org.eclipse.ui.internal.actions;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.ui.actions.BuildActionFilter;
>import org.eclipse.ui.actions.BuildState;
>
>/**
> * The multithreaded build process.
> */
>public class BuildProcess {
>
>    private static BuildState buildState = BuildState.IDLE;
>
>    /**
>     * Starts the build process.
>     */
>    public static void startBuild() {
>        buildState = BuildState.BUILDING;
>
>        // Start the build job.
>        Job buildJob = new Job("Build") {
>            @Override
>            protected IStatus run(IProgressMonitor monitor) {
>                // Perform the build process here.
>                // ...
>
>                return Status.OK_STATUS;
>            }
>        };
>        buildJob.schedule();
>    }
>
>    /**
>     * Checks if the build process is complete.
>     *
>     * @return `true` if the build process is complete, `false` otherwise
>     */
>    public static boolean isComplete() {
>        return buildState == BuildState.COMPLETE;
>    }
>
>    /**
>     * Gets the next action to be executed.
>     *
>     * @return the next action to be executed, or `null` if there are no more actions to be executed
>     */
>    public static Action getNextAction() {
>        // Get the next action from the action queue.
>        Action action = ActionFactory.find(BuildActionFactory.ID_BUILD_ACTION_QUEUE).getQueue().poll();
>
>        // If the action is not blocked, then return it.
>        if (!BuildActionFilter.shouldBlock(action, buildState)) {
>            return action;
>        } else {
>            // If the action is blocked, then wait for the build process to finish.
>            BuildActionFilter.waitForBuildToFinish();
>
>            // Return the next action from the action queue.
>            return ActionFactory.find(BuildActionFactory.ID_BUILD_ACTION_QUEUE).getQueue().poll();
>        }
>    }
>
>    /**
>     * Blocks the given action.
>     *
>     * @param action the action to be blocked
>     */
>    public static void blockAction(Action action) {
>        // Add the action to the blocked action queue.
>        ActionFactory.find(BuildActionFactory.ID_BUILD_ACTION_QUEUE).getBlockedQueue().add(action);
>    }
>
>    /**
>     * Executes the given action.
>     *
>     * @param action the action to be executed
>     */
>    public static void executeAction(Action action) {
>        try {
>            action.runWithEvent(null);
>        } catch (Exception e) {
>            e.printStackTrace();
>        }
>    }
>
>    /**
>     * Finishes the build process.
>     */
>    public static void finishBuild() {
>        buildState = BuildState.COMPLETE;
>
>        // Execute all of the blocked actions.
>        while (!ActionFactory.find(BuildActionFactory.ID_BUILD_ACTION_QUEUE).getBlockedQueue().isEmpty()) {
>            Action action = ActionFactory.find(BuildActionFactory.ID_BUILD_ACTION_QUEUE).getBlockedQueue().poll();
>            executeAction(action);
>        }
>    }
>}
>
>
>
>
>
>
>
>
>
>package org.eclipse.ui.internal.actions;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.ui.actions.BuildActionFilter;
>import org.eclipse.ui.actions.BuildState;
>
>/**
> * The action context class.
> */
>public class ActionContext {
>
>    private final BuildState buildState;
>
>    /**
>     * Creates a new action context.
>     *
>     * @param buildState the current state of the build process
>     */
>    public ActionContext(BuildState buildState) {
>        this.buildState = buildState;
>    }
>
>    /**
>     * Gets the current state of the build process.
>     *
>     * @return the current state of the build process
>     */
>    public BuildState getBuildState() {
>        return buildState;
>    }
>
>    /**
>     * Checks if the current build process is blocked.
>     *
>     * @return `true` if the current build process is blocked, `false` otherwise
>     */
>    public boolean isBuildBlocked() {
>        return buildState == BuildState.BLOCKED;
>    }
>
>    /**
>     * Blocks the current build process.
>     */
>    public void blockBuild() {
>        buildState = BuildState.BLOCKED;
>    }
>
>    /**
>     * Unblocks the current build process.
>     */
>    public void unblockBuild() {
>        buildState = BuildState.RUNNING;
>    }
>
>    /**
>     * Waits for the current build process to finish.
>     */
>    public void waitForBuildToFinish() {
>        Job buildJob = Job.getJobManager().find(BuildJob.class);
>        if (buildJob != null && buildJob.getState() == Job.RUNNING) {
>            buildJob.join();
>        }
>    }
>}
>
>
>
>
>
>
>
>
>
>package org.eclipse.ui.internal.actions;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.ui.actions.ActionContext;
>import org.eclipse.ui.actions.BuildActionFilter;
>import org.eclipse.ui.actions.BuildState;
>
>/**
> * The Run/Launch action.
> */
>public class RunLaunchAction extends Action {
>
>    @Override
>    public void runWithEvent(IEvent event) {
>        ActionContext actionContext = new ActionContext(BuildState.RUNNING);
>
>        // Check if the build process is blocked.
>        if (BuildActionFilter.shouldBlock(this, actionContext.getBuildState())) {
>            // Block the build process.
>            actionContext.blockBuild();
>
>            // Wait for the build process to finish.
>            actionContext.waitForBuildToFinish();
>
>            // Unblock the build process.
>            actionContext.unblockBuild();
>        }
>
>        // Execute the Run/Launch action.
>        // ...
>    }
>}
>
>
>
>
>
>
>
>package org.eclipse.ui.internal.actions;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.ui.actions.ActionContext;
>import org.eclipse.ui.actions.BuildActionFilter;
>import org.eclipse.ui.actions.BuildState;
>
>/**
> * The Save action.
> */
>public class SaveAction extends Action {
>
>    @Override
>    public void runWithEvent(IEvent event) {
>        ActionContext actionContext = new ActionContext(BuildState.RUNNING);
>
>        // Check if the build process is blocked.
>        if (BuildActionFilter.shouldBlock(this, actionContext.getBuildState())) {
>            // Block the build process.
>            actionContext.blockBuild();
>
>            // Wait for the build process to finish.
>            actionContext.waitForBuildToFinish();
>
>            // Unblock the build process.
>            actionContext.unblockBuild();
>        }
>
>        // Save the file.
>        // ...
>    }
>}
>
>
>
>
>
>
>
>
>
>package org.eclipse.ui.internal.actions;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.ui.actions.ActionContext;
>import org.eclipse.ui.actions.BuildActionFilter;
>import org.eclipse.ui.actions.BuildState;
>
>/**
> * The Commit action.
> */
>public class CommitAction extends Action {
>
>    @Override
>    public void runWithEvent(IEvent event) {
>        ActionContext actionContext = new ActionContext(BuildState.RUNNING);
>
>        // Check if the build process is blocked.
>        if (BuildActionFilter.shouldBlock(this, actionContext.getBuildState())) {
>            // Block the build process.
>            actionContext.blockBuild();
>
>            // Wait for the build process to finish.
>            actionContext.waitForBuildToFinish();
>
>            // Unblock the build process.
>            actionContext.unblockBuild();
>        }
>
>        // Commit the changes.
>        // ...
>    }
>}
>
>
>
>
>
>
>
>
>
>
>
>
>package org.eclipse.core.internal.events;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.core.resources.ResourcesPlugin;
>import org.eclipse.core.resources.Workspace;
>
>/**
> * The AutoBuildJob is responsible for automatically building the workspace
> * after changes have been made to the resources.
> */
>public class AutoBuildJob extends Job {
>
>    /**
>     * The delay in milliseconds before the autobuild job is scheduled.
>     */
>    private static final int AUTOBUILD_DELAY = 500;
>
>    /**
>     * Creates a new AutoBuildJob.
>     */
>    public AutoBuildJob() {
>        super("Autobuild");
>        setSystem(true);
>    }
>
>    @Override
>    protected IStatus run(IProgressMonitor monitor) {
>        // Check if autobuild is enabled.
>        if (!ResourcesPlugin.getWorkspace().isAutoBuilding()) {
>            return Status.OK_STATUS;
>        }
>
>        // Build the workspace.
>        Workspace workspace = ResourcesPlugin.getWorkspace();
>        workspace.build(IncrementalProjectBuilder.AUTO_BUILD, monitor);
>
>        return Status.OK_STATUS;
>    }
>
>    /**
>     * Schedules the autobuild job to run after the specified delay.
>     *
>     * @param delay the delay in milliseconds
>     */
>    public static void schedule(int delay) {
>        AutoBuildJob job = new AutoBuildJob();
>        job.schedule(delay);
>    }
>}
>
>
>
>
>
>
>
>
>
>
>
>package org.eclipse.core.tests.internal.builders;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.core.resources.IncrementalProjectBuilder;
>import org.eclipse.core.resources.ResourcesPlugin;
>import org.eclipse.core.tests.harness.AbstractBuilderTest;
>
>/**
> * Tests the BuilderTest.build() method.
> */
>public class BuilderTest extends AbstractBuilderTest {
>
>    /**
>     * Tests that the build() method blocks the autobuild job.
>     */
>    public void testBuildBlocksAutobuildJob() throws Exception {
>        // Register a listener to be notified when the autobuild job starts.
>        final boolean[] autobuildStarted = new boolean[] {false};
>        ResourcesPlugin.getWorkspace().addResourceChangeListener(new IResourceChangeListener() {
>            @Override
>            public void resourceChanged(IResourceChangeEvent event) {
>                if (event.getType() == IResourceChangeEvent.POST_CHANGE) {
>                    autobuildStarted[0] = true;
>                }
>            }
>        });
>
>        // Start the autobuild job.
>        AutoBuildJob.schedule(AUTOBUILD_DELAY);
>
>        // Build the workspace.
>        build();
>
>        // Wait for the autobuild job to start.
>        while (!autobuildStarted[0]) {
>            Thread.sleep(10);
>        }
>
>        // Assert that the autobuild job is blocked.
>        Job autobuildJob = (Job) ResourcesPlugin.getWorkspace().getProperty(AutoBuildJob.PROPERTY_AUTOBUILD_JOB);
>        assertTrue(autobuildJob.getState() == Job.WAITING);
>
>        // Wait for the build to finish.
>        waitForBuildToFinish();
>
>        // Assert that the autobuild job is now running.
>        assertTrue(autobuildJob.getState() == Job.RUNNING);
>    }
>}
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>package org.eclipse.core.tests.internal.builders;
>
>import org.eclipse.core.resources.IncrementalProjectBuilder;
>
>public class BuilderWithCallback extends IncrementalProjectBuilder {
>
>    private Runnable callback;
>
>    public BuilderWithCallback(Runnable callback) {
>        this.callback = callback;
>    }
>
>    @Override
>    protected IProjectBuilderResult build(int kind, IProgressMonitor monitor) throws CoreException {
>        if (callback != null) {
>            callback.run();
>        }
>        return super.build(kind, monitor);
>    }
>}
>
>
>
>
>
>
>
>
>
>
>
>
>
>package org.eclipse.ui.actions;
>
>import org.eclipse.core.runtime.IProgressMonitor;
>import org.eclipse.core.runtime.jobs.Job;
>import org.eclipse.ui.actions.ActionContext;
>import org.eclipse.ui.actions.BuildActionFilter;
>import org.eclipse.ui.actions.BuildState;
>
>/**
> * A factory for creating workbench actions.
> */
>public class ActionFactory {
>
>    /**
>     * The ID of the build action queue.
>     */
>    public static final String ID_BUILD_ACTION_QUEUE = "org.eclipse.ui.actions.buildActionQueue";
>
>    /**
>     * Registers a new action filter with the action factory.
>     *
>     * @param actionFilter the action filter to register
>     */
>    public static void registerActionFilter(BuildActionFilter actionFilter) {
>    // Get the list of registered action filters.
>    List<BuildActionFilter> actionFilters = getRegisteredActionFilters();
>
>    // Add the new action filter to the list of registered action filters.
>    actionFilters.add(actionFilter);
>
>    // Set the list of registered action filters.
>    setRegisteredActionFilters(actionFilters);
>}
>
>
>    /**
>     * Creates a new Run/Launch action.
>     *
>     * @param window the workbench window
>     * @return a new Run/Launch action
>     */
>    public static Action createRunLaunchAction(IWorkbenchWindow window) {
>        RunLaunchAction action = new RunLaunchAction();
>        action.runWithEvent(null);
>        return action;
>    }
>
>    /**
>     * Creates a new Save action.
>     *
>     * @param window the workbench window
>     * @return a new Save action
>     */
>    public static Action createSaveAction(IWorkbenchWindow window) {
>        SaveAction action = new SaveAction();
>        action.runWithEvent(null);
>        return action;
>    }
>
>    /**
>     * Creates a new Commit action.
>     *
>     * @param window the workbench window
>     * @return a new Commit action
>     */
>    public static Action createCommitAction(IWorkbenchWindow window) {
>        CommitAction action = new CommitAction();
>        action.runWithEvent(null);
>        return action;
>    }
>}
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>public class MyPlugin {
>
>    public static void main(String[] args) {
>        // Register the BuildActionFilter class with the action factory.
>        myRegisterActionFilter(new BuildActionFilter());
>
>        // Register any other plugins here.
>
>        // Start the workbench.
>        PlatformUI.createAndRunWorkbench(null);
>    }
>
>    
>}
>
>
>
>
>
>
>
>
><?xml version="1.0" encoding="UTF-8"?>
><?eclipse version="3.0"?>
><plugin id="org.eclipse.core.tests.resources" name="Eclipse Core Resources Tests" version="3.1.0" provider-name="Eclipse.org">
>  <requires>
>    <import plugin="org.eclipse.core.resources"/>
>    <import plugin="org.eclipse.core.runtime"/>
>    <import plugin="org.eclipse.core.runtime.compatibility"/>
>    <import plugin="org.eclipse.core.tests.harness"/>
>    <import plugin="org.eclipse.junit"/>
>    <import plugin="org.eclipse.equinox.jobs"/>
>  </requires>
>  <runtime>
>    <library name="testresources.jar">
>      <export name="*"/>
>    </library>
>  </runtime>
>  <extension-point name="org.eclipse.core.runtime.preferences">
>    <scope name="tests">
>      <class>org.eclipse.core.internal.resources.TestsScope</class>
>    </scope>
>  </extension-point>
>  <extension-point name="org.eclipse.core.runtime.contentTypes">
>    <content-type id="org.eclipse.core.tests.resources.content">.content</content-type>
>    <content-type base-type="org.eclipse.core.tests.resources.content" id="org.eclipse.core.tests.resources.binaryContent">.binaryContent</content-type>
>  </extension-point>
>  <extension-point name="org.eclipse.core.runtime.contentTypes">
>    <file-association content-type="org.eclipse.core.tests.resources.content" file-patterns="*.content"/>
>    <file-association content-type="org.eclipse.core.tests.resources.binaryContent" file-patterns="*.binaryContent"/>
>  </extension-point>
>  <extension point="org.eclipse.core.runtime.jobs">
>    <job name="AutoBuildJob" class="org.eclipse.core.internal.events.AutoBuildJob"/>
>  </extension>
>  <extension point="org.eclipse.core.tests.harness.tests">
>    <test id="AutoBuildJobTest">
>      <run class="org.eclipse.core.tests.resources.AutoBuildJobTest"/>
>    </test>
>  </extension>
></plugin>

Actions: View | Diff

Attachments on bug 329657: 198950 | 238867 | 283869 | 289217