Attachment #193919 for bug #343256




 *******************************************************************************/
package org.eclipse.core.internal.events;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.jobs.ISchedulingRule;

import org.eclipse.core.resources.IBuildConfiguration;

import java.util.*;
import org.eclipse.core.internal.dtree.DeltaDataTree;
import org.eclipse.core.internal.resources.*;

			// For incremental builds, grab a pointer to the current state before computing the delta
			currentTree = ((trigger == IncrementalProjectBuilder.FULL_BUILD) || clean) ? null : workspace.getElementTree();
			int depth = -1;
			ISchedulingRule rule = null;
			try {
				//short-circuit if none of the projects this builder cares about have changed.
				if (!needsBuild(currentBuilder, trigger)) {

					monitor.done();
					return;
				}
				rule = builder.getRule(trigger, args);
				String name = currentBuilder.getLabel();
				String message;
				if (name != null)

					message = NLS.bind(Messages.events_invoking_1, builder.getProject().getFullPath());
				monitor.subTask(message);
				hookStartBuild(builder, trigger);
				// Make the current tree immutable before releasing the WS lock
				if (rule != null && currentTree != null)
					workspace.newWorkingTree();
				//release workspace lock while calling builders
				depth = getWorkManager().beginUnprotected();
				// Acquire the rule required for running this builder
				if (rule != null) {
					Job.getJobManager().beginRule(rule, monitor);
					// Now that we've acquired the rule, changes may have been made concurrently, ensure we're pointing at the 
					// correct currentTree so delta contains concurrent changes made in areas guarded by the scheduling rule
					if (currentTree != null)
						currentTree = workspace.getElementTree();
				}
				//do the build
				SafeRunner.run(getSafeRunnable(trigger, args, status, monitor));
			} finally {
				// Re-acquire the WS lock, then release the scheduling rule
				if (depth >= 0)
					getWorkManager().endUnprotected(depth);
				if (rule != null)
					Job.getJobManager().endRule(rule);
				// Be sure to clean up after ourselves.
				if (clean || currentBuilder.wasForgetStateRequested()) {
					currentBuilder.setLastBuiltTree(null);




	 * reads and concurrent writes, write access to the tree is governed
	 * by {@link WorkManager}.
	 */
	protected volatile ElementTree tree;

	/**
	 * This field is used to control access to the workspace tree during

	 */
	private void buildInternal(IBuildConfiguration[] configs, int trigger, boolean buildReferences, IProgressMonitor monitor) throws CoreException {
		monitor = Policy.monitorFor(monitor);
		// Bug 343256 use a relaxed scheduling rule if the config we're building uses a relaxed rule.
		// Otherwise fall-back to WR.
		boolean relaxed = false;
		if (Job.getJobManager().currentRule() == null && configs.length > 0) {
			relaxed = true;
			for (IBuildConfiguration config : configs) {
				ISchedulingRule requested = getBuildManager().getRule(config, trigger, null, null);
				if (requested != null && requested.contains(getRoot())) {
					relaxed = false;
					break;
				}
			}
		}

		// PRE + POST_BUILD, and the build itself are allowed to modify resources, so require the current thread's scheduling rule
		// to either contain the WR or be null. Therefore, if not null, ensure it contains the WR rule...
		final ISchedulingRule rule = relaxed ? null : getRuleFactory().buildRule();
		try {
			monitor.beginTask("", Policy.opWork); //$NON-NLS-1$
			try {




 *******************************************************************************/
package org.eclipse.core.tests.internal.builders;

import java.io.ByteArrayInputStream;
import java.util.*;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.*;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.tests.harness.TestBarrier;
import org.eclipse.core.tests.internal.builders.TestBuilder.BuilderRuleCallback;


		tb2.waitForStatus(TestBarrier.STATUS_DONE);
	}

	private HashSet<ISchedulingRule> getRulesAsSet(ISchedulingRule rule) {
		HashSet<ISchedulingRule> rules = new HashSet<ISchedulingRule>();
		if (rule == null)
			return rules;
		if (rule instanceof MultiRule)
			rules.addAll(Arrays.asList(((MultiRule) rule).getChildren()));
		else
			rules.add(rule);
		return rules;
	}

	/**
	 * As the builder is run with a relaxed scheduling rule, we ensure that any changes made before
	 * the build is actually run are present in the delta.
	 * Acquiring the scheduling rule must be done outside of the WS lock, so this tests that
	 * a change which sneaks in during the window or the build thread acquiring its scheduling 
	 * rule, is correctly present in the builder's delta.
	 * @throws Exception
	 */
	public void testBuilderDeltaUsingRelaxedRuleBug343256() throws Exception {
		String name = "testBuildDeltaUsingRelaxedRuleBug343256";
		setAutoBuilding(false);
		final IProject project = getWorkspace().getRoot().getProject(name);
		final IFile foo = project.getFile("foo");
		create(project, false);

		IProjectDescription desc = project.getDescription();
		desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1")});
		project.setDescription(desc, getMonitor());

		// Ensure the builder is instantiated
		project.build(IncrementalProjectBuilder.FULL_BUILD, getMonitor());

		final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

		// Create a builder set a null scheduling rule
		EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();

		// Set the rule call-back
		builder.setRuleCallback(new BuilderRuleCallback() {

			boolean called = false;

			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map args) {
				// Remove once Bug 331187 is fixed.
				// Currently #getRule is called twice when building a specific build configuration (so as to minimized change in 
				// 3.7 end-game.  As this test is trying to provoke a bug in the window between fetching a rule and applying it
				// to the build, we don't want to run the first time #getRule is called (in Workspace#build)
				if (!called) {
					called = true;
					return project;
				}
				// REMOVE
				tb1.setStatus(TestBarrier.STATUS_START);
				tb1.waitForStatus(TestBarrier.STATUS_WAIT_FOR_RUN);
				try {
					// Give the resource modification time be queued
					Thread.sleep(10);
				} catch (InterruptedException e) {
					fail();
				}
				return project;
			}

			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
				// shared scheduling rule
				assertTrue(Job.getJobManager().currentRule().equals(project));
				// assert that the delta contains the file foo
				IResourceDelta delta = getDelta(project);
				assertNotNull("1.1", delta);
				assertTrue("1.2", delta.getAffectedChildren().length == 1);
				assertTrue("1.3", delta.getAffectedChildren()[0].getResource().equals(foo));
				tb1.setStatus(TestBarrier.STATUS_DONE);
				return super.build(kind, args, monitor);
			}
		});

		// Run the incremental build
		Job j = new Job("IProject.build()") {
			protected IStatus run(IProgressMonitor monitor) {
				try {
					getWorkspace().build(new IBuildConfiguration[] {project.getActiveBuildConfig()}, IncrementalProjectBuilder.INCREMENTAL_BUILD, true, monitor);
				} catch (CoreException e) {
					fail();
				}
				return Status.OK_STATUS;
			}
		};
		j.schedule();

		// Wait for the build to transition to getRule
		tb1.waitForStatus(TestBarrier.STATUS_START);
		// Modify a file in the project
		j = new Job("IProject.build()") {
			protected IStatus run(IProgressMonitor monitor) {
				tb1.setStatus(TestBarrier.STATUS_WAIT_FOR_RUN);
				ensureExistsInWorkspace(foo, new ByteArrayInputStream(new byte[0]));
				return Status.OK_STATUS;
			}
		};
		j.schedule();
		tb1.waitForStatus(TestBarrier.STATUS_DONE);
	}

	/**
	 * Tests for regression in running the build with reduced scheduling rules.
	 * @throws Exception
	 */
	public void testBug343256() throws Exception {
		String name = "testBug343256";
		setAutoBuilding(false);
		final IProject project = getWorkspace().getRoot().getProject(name);
		create(project, false);

		IProjectDescription desc = project.getDescription();
		desc.setBuildSpec(new ICommand[] {createCommand(desc, EmptyDeltaBuilder.BUILDER_NAME, "Project1Build1"), createCommand(desc, EmptyDeltaBuilder2.BUILDER_NAME, "Project1Build2")});
		project.setDescription(desc, getMonitor());

		// Ensure the builder is instantiated
		project.build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());

		final TestBarrier tb1 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);
		final TestBarrier tb2 = new TestBarrier(TestBarrier.STATUS_WAIT_FOR_START);

		// Scheduling rules to returng from #getRule
		final ISchedulingRule[] getRules = new ISchedulingRule[2];
		final ISchedulingRule[] buildRules = new ISchedulingRule[2];

		// Create a builder set a null scheduling rule
		EmptyDeltaBuilder builder = EmptyDeltaBuilder.getInstance();
		EmptyDeltaBuilder2 builder2 = EmptyDeltaBuilder2.getInstance();

		// Set the rule call-back
		builder.setRuleCallback(new BuilderRuleCallback() {
			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map args) {
				tb1.waitForStatus(TestBarrier.STATUS_START);
				return getRules[0];
			}

			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
				HashSet<ISchedulingRule> h1 = getRulesAsSet(Job.getJobManager().currentRule());
				HashSet<ISchedulingRule> h2 = getRulesAsSet(buildRules[0]);
				// shared scheduling rule
				assertTrue(h1.equals(h2));
				tb1.setStatus(TestBarrier.STATUS_DONE);
				return super.build(kind, args, monitor);
			}
		});
		// Set the rule call-back
		builder2.setRuleCallback(new BuilderRuleCallback() {
			public ISchedulingRule getRule(String name, IncrementalProjectBuilder builder, int trigger, Map<String, String> args) {
				tb2.waitForStatus(TestBarrier.STATUS_START);
				return getRules[1];
			}

			public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
				HashSet<ISchedulingRule> h1 = getRulesAsSet(Job.getJobManager().currentRule());
				HashSet<ISchedulingRule> h2 = getRulesAsSet(buildRules[1]);
				assertTrue(h1.equals(h2));
				tb2.setStatus(TestBarrier.STATUS_DONE);
				return super.build(kind, args, monitor);
			}
		});

		Job j;

		// Enable for Bug 331187 
		//		// IProject.build()
		//		j = new Job("IProject.build()") {
		//			protected IStatus run(IProgressMonitor monitor) {
		//				try {
		//					project.build(IncrementalProjectBuilder.FULL_BUILD, monitor);
		//				} catch (CoreException e) {
		//					fail(e.toString());
		//				}
		//				return Status.OK_STATUS;
		//			}
		//		};
		//		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

		//		// IWorkspace.build()
		//		j = new Job("IWorkspace.build()") {
		//			protected IStatus run(IProgressMonitor monitor) {
		//				try {
		//					getWorkspace().build(IncrementalProjectBuilder.FULL_BUILD, monitor);
		//				} catch (CoreException e) {
		//					fail(e.toString());
		//				}
		//				return Status.OK_STATUS;
		//			}
		//		};
		//		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

		// IWorkspace.build(IBuildConfiguration[],...)
		j = new Job("IWorkspace.build(IBuildConfiguration[],...)") {
			protected IStatus run(IProgressMonitor monitor) {
				try {
					getWorkspace().build(new IBuildConfiguration[] {project.getActiveBuildConfig()}, IncrementalProjectBuilder.FULL_BUILD, true, monitor);
				} catch (CoreException e) {
					fail(e.toString());
				}
				return Status.OK_STATUS;
			}
		};
		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);

		// Test Auto-build
		//		j = new Job("Auto-build") {
		//			protected IStatus run(IProgressMonitor monitor) {
		//				try {
		//					getWorkspace().build(IncrementalProjectBuilder.CLEAN_BUILD, getMonitor());
		//				} catch (CoreException e) {
		//					fail(e.toString());
		//				}
		//				return Status.OK_STATUS;
		//			}
		//		};
		//		// Auto-build
		//		setAutoBuilding(true);
		//		// Wait for the build to transition
		//		invokeTestBug343256(project, getRules, buildRules, tb1, tb2, j);
	}

	/**
	 * Helper method do invoke a set of tests on Bug343256 using the different sets of builder API
	 */
	private void invokeTestBug343256(IProject project, ISchedulingRule[] getRules, ISchedulingRule[] buildRules, TestBarrier tb1, TestBarrier tb2, Job j) {
		// Test 1 - build project sched rule
		getRules[0] = getRules[1] = project;
		buildRules[0] = buildRules[1] = new MultiRule(new ISchedulingRule[] {getRules[0]});
		tb1.setStatus(TestBarrier.STATUS_START);
		tb2.setStatus(TestBarrier.STATUS_START);
		j.schedule();
		tb1.waitForStatus(TestBarrier.STATUS_DONE);
		tb2.waitForStatus(TestBarrier.STATUS_DONE);

		// Test 2 - build null rule
		getRules[0] = getRules[1] = null;
		buildRules[0] = buildRules[1] = null;
		tb1.setStatus(TestBarrier.STATUS_START);
		tb2.setStatus(TestBarrier.STATUS_START);
		j.schedule();
		tb1.waitForStatus(TestBarrier.STATUS_DONE);
		tb2.waitForStatus(TestBarrier.STATUS_DONE);

		// Test 3 - build mixed projects
		getRules[0] = buildRules[0] = project;
		getRules[1] = buildRules[1] = getWorkspace().getRoot().getProject("other");
		tb1.setStatus(TestBarrier.STATUS_START);
		tb2.setStatus(TestBarrier.STATUS_START);
		j.schedule();
		tb1.waitForStatus(TestBarrier.STATUS_DONE);
		tb2.waitForStatus(TestBarrier.STATUS_DONE);

		// Test 4 - build project + null
		getRules[0] = buildRules[0] = project;
		getRules[1] = buildRules[1] = null;
		// TODO: Fixed in Bug 331187 ; BuildManager#getRule is pessimistic when there's a mixed resource and null rule
		buildRules[0] = buildRules[1] = getWorkspace().getRoot();
		tb1.setStatus(TestBarrier.STATUS_START);
		tb2.setStatus(TestBarrier.STATUS_START);
		j.schedule();
		tb1.waitForStatus(TestBarrier.STATUS_DONE);
		tb2.waitForStatus(TestBarrier.STATUS_DONE);
	}
}

Lines 26-31 Link Here

(-)src/org/eclipse/core/tests/internal/builders/TestBuilder.java (+8 lines)
26	* A test specific call-back which can be ticked on #getRule(...) & #build(...)	26	* A test specific call-back which can be ticked on #getRule(...) & #build(...)
27	*/	27	*/
28	public static class BuilderRuleCallback {	28	public static class BuilderRuleCallback {
		29	private IncrementalProjectBuilder builder;
		30
29	public BuilderRuleCallback() {	31	public BuilderRuleCallback() {
30	}	32	}
31		33
Lines 42-47 Link Here
42	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {	44	public IProject[] build(int kind, Map<String, String> args, IProgressMonitor monitor) throws CoreException {
43	return new IProject[0];	45	return new IProject[0];
44	}	46	}
		47
		48	public IResourceDelta getDelta(IProject project) {
		49	return builder.getDelta(project);
		50	}
45	}	51	}
46		52
47	/**	53	/**
Lines 101-106 Link Here
101	logPluginLifecycleEvent(getBuildId());	107	logPluginLifecycleEvent(getBuildId());
102	if (ruleCallBack == null)	108	if (ruleCallBack == null)
103	return new IProject[0];	109	return new IProject[0];
		110	ruleCallBack.builder = this;
104	return ruleCallBack.build(kind, args, monitor);	111	return ruleCallBack.build(kind, args, monitor);
105	}	112	}
106		113
Lines 111-116 Link Here
111	public ISchedulingRule getRule(int trigger, Map<String, String> args) {	118	public ISchedulingRule getRule(int trigger, Map<String, String> args) {
112	if (ruleCallBack == null)	119	if (ruleCallBack == null)
113	return super.getRule(trigger, args);	120	return super.getRule(trigger, args);
		121	ruleCallBack.builder = this;
114	return ruleCallBack.getRule(name, this, trigger, args);	122	return ruleCallBack.getRule(name, this, trigger, args);
115	}	123	}
116		124

Return to bug 343256

Lines 163-169 Link Here

(-)src/org/eclipse/core/internal/resources/Workspace.java (-2 / +18 lines)
163	* reads and concurrent writes, write access to the tree is governed	163	* reads and concurrent writes, write access to the tree is governed
164	* by {@link WorkManager}.	164	* by {@link WorkManager}.
165	*/	165	*/
166	protected ElementTree tree;	166	protected volatile ElementTree tree;
167		167
168	/**	168	/**
169	* This field is used to control access to the workspace tree during	169	* This field is used to control access to the workspace tree during
Lines 440-446 Link Here
440	*/	440	*/
441	private void buildInternal(IBuildConfiguration[] configs, int trigger, boolean buildReferences, IProgressMonitor monitor) throws CoreException {	441	private void buildInternal(IBuildConfiguration[] configs, int trigger, boolean buildReferences, IProgressMonitor monitor) throws CoreException {
442	monitor = Policy.monitorFor(monitor);	442	monitor = Policy.monitorFor(monitor);
443	final ISchedulingRule rule = getRuleFactory().buildRule();	443	// Bug 343256 use a relaxed scheduling rule if the config we're building uses a relaxed rule.
		444	// Otherwise fall-back to WR.
		445	boolean relaxed = false;
		446	if (Job.getJobManager().currentRule() == null && configs.length > 0) {
		447	relaxed = true;
		448	for (IBuildConfiguration config : configs) {
		449	ISchedulingRule requested = getBuildManager().getRule(config, trigger, null, null);
		450	if (requested != null && requested.contains(getRoot())) {
		451	relaxed = false;
		452	break;
		453	}
		454	}
		455	}
		456
		457	// PRE + POST_BUILD, and the build itself are allowed to modify resources, so require the current thread's scheduling rule
		458	// to either contain the WR or be null. Therefore, if not null, ensure it contains the WR rule...
		459	final ISchedulingRule rule = relaxed ? null : getRuleFactory().buildRule();
444	try {	460	try {
445	monitor.beginTask("", Policy.opWork); //$NON-NLS-1$	461	monitor.beginTask("", Policy.opWork); //$NON-NLS-1$
446	try {	462	try {

Lines 14-24 Link Here

(-)src/org/eclipse/core/internal/events/BuildManager.java (-5 / +16 lines)
14	*******************************************************************************/	14	*******************************************************************************/
15	package org.eclipse.core.internal.events;	15	package org.eclipse.core.internal.events;
16		16
17	import org.eclipse.core.resources.IProject;
18	import org.eclipse.core.runtime.jobs.ISchedulingRule;
19
20	import org.eclipse.core.resources.IBuildConfiguration;
21
22	import java.util.*;	17	import java.util.*;
23	import org.eclipse.core.internal.dtree.DeltaDataTree;	18	import org.eclipse.core.internal.dtree.DeltaDataTree;
24	import org.eclipse.core.internal.resources.*;	19	import org.eclipse.core.internal.resources.*;
Lines 169-174 Link Here
169	// For incremental builds, grab a pointer to the current state before computing the delta	164	// For incremental builds, grab a pointer to the current state before computing the delta
170	currentTree = ((trigger == IncrementalProjectBuilder.FULL_BUILD) \|\| clean) ? null : workspace.getElementTree();	165	currentTree = ((trigger == IncrementalProjectBuilder.FULL_BUILD) \|\| clean) ? null : workspace.getElementTree();
171	int depth = -1;	166	int depth = -1;
		167	ISchedulingRule rule = null;
172	try {	168	try {
173	//short-circuit if none of the projects this builder cares about have changed.	169	//short-circuit if none of the projects this builder cares about have changed.
174	if (!needsBuild(currentBuilder, trigger)) {	170	if (!needsBuild(currentBuilder, trigger)) {
Lines 177-182 Link Here
177	monitor.done();	173	monitor.done();
178	return;	174	return;
179	}	175	}
		176	rule = builder.getRule(trigger, args);
180	String name = currentBuilder.getLabel();	177	String name = currentBuilder.getLabel();
181	String message;	178	String message;
182	if (name != null)	179	if (name != null)
Lines 185-197 Link Here
185	message = NLS.bind(Messages.events_invoking_1, builder.getProject().getFullPath());	182	message = NLS.bind(Messages.events_invoking_1, builder.getProject().getFullPath());
186	monitor.subTask(message);	183	monitor.subTask(message);
187	hookStartBuild(builder, trigger);	184	hookStartBuild(builder, trigger);
		185	// Make the current tree immutable before releasing the WS lock
		186	if (rule != null && currentTree != null)
		187	workspace.newWorkingTree();
188	//release workspace lock while calling builders	188	//release workspace lock while calling builders
189	depth = getWorkManager().beginUnprotected();	189	depth = getWorkManager().beginUnprotected();
		190	// Acquire the rule required for running this builder
		191	if (rule != null) {
		192	Job.getJobManager().beginRule(rule, monitor);
		193	// Now that we've acquired the rule, changes may have been made concurrently, ensure we're pointing at the
		194	// correct currentTree so delta contains concurrent changes made in areas guarded by the scheduling rule
		195	if (currentTree != null)
		196	currentTree = workspace.getElementTree();
		197	}
190	//do the build	198	//do the build
191	SafeRunner.run(getSafeRunnable(trigger, args, status, monitor));	199	SafeRunner.run(getSafeRunnable(trigger, args, status, monitor));
192	} finally {	200	} finally {
		201	// Re-acquire the WS lock, then release the scheduling rule
193	if (depth >= 0)	202	if (depth >= 0)
194	getWorkManager().endUnprotected(depth);	203	getWorkManager().endUnprotected(depth);
		204	if (rule != null)
		205	Job.getJobManager().endRule(rule);
195	// Be sure to clean up after ourselves.	206	// Be sure to clean up after ourselves.
196	if (clean \|\| currentBuilder.wasForgetStateRequested()) {	207	if (clean \|\| currentBuilder.wasForgetStateRequested()) {
197	currentBuilder.setLastBuiltTree(null);	208	currentBuilder.setLastBuiltTree(null);