Attachment #128848 for bug #266982

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 41-46 Link Here

(-)src/org/eclipse/emf/cdo/tests/AllTestsAllConfigs.java (+2 lines)
41	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_260764_Test;	41	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_260764_Test;
42	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;	42	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_261218_Test;
43	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_265114_Test;	43	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_265114_Test;
		44	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_266982_Test;
44	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;	45	import org.eclipse.emf.cdo.tests.config.impl.ConfigTest;
45	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;	46	import org.eclipse.emf.cdo.tests.config.impl.ConfigTestSuite;
46		47
Lines 128-133 Link Here
128	testClasses.add(Bugzilla_260764_Test.class);	129	testClasses.add(Bugzilla_260764_Test.class);
129	testClasses.add(Bugzilla_261218_Test.class);	130	testClasses.add(Bugzilla_261218_Test.class);
130	testClasses.add(Bugzilla_265114_Test.class);	131	testClasses.add(Bugzilla_265114_Test.class);
		132	testClasses.add(Bugzilla_266982_Test.class);
131		133
132	// TODO testClasses.add(NonCDOResourceTest.class);	134	// TODO testClasses.add(NonCDOResourceTest.class);
133	// TODO testClasses.add(GeneratedEcoreTest.class);	135	// TODO testClasses.add(GeneratedEcoreTest.class);




/**
 * Copyright (c) 2004 - 2009 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *    Simon McDuff - initial API and implementation
 */
package org.eclipse.emf.cdo.tests.bugzilla;

import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.session.CDOSession;
import org.eclipse.emf.cdo.tests.AbstractCDOTest;
import org.eclipse.emf.cdo.tests.model1.Customer;
import org.eclipse.emf.cdo.transaction.CDOTransaction;
import org.eclipse.emf.cdo.util.CDOUtil;

import junit.framework.Assert;

/**
 * IllegalStateException in CDOStore.getRevision
 * <p>
 * See https://bugs.eclipse.org/266982
 * 
 * @author Simon McDuff
 */
public class Bugzilla_266982_Test extends AbstractCDOTest
{
  public void testBugzilla_266982() throws Exception
  {
    final Customer customer = getModel1Factory().createCustomer();
    final boolean done[] = new boolean[1];
    final Exception exception[] = new Exception[1];
    done[0] = false;
    customer.setName("customer");

    CDOSession session = openModel1Session();
    CDOTransaction transaction = session.openTransaction();
    CDOResource resource = transaction.createResource("/test1");
    resource.getContents().add(customer);
    transaction.commit();

    Runnable changeObjects = new Runnable()
    {
      public void run()
      {
        try
        {
          CDOSession session = openModel1Session();
          CDOTransaction transaction = session.openTransaction();
          Customer customerToLoad = (Customer)transaction.getObject(CDOUtil.getCDOObject(customer).cdoID());
          while (!done[0])
          {
            // Could fail if the attach is not thread safe
            customerToLoad.getName();
          }
          transaction.close();
          session.close();
        }
        catch (Exception ex)
        {
          exception[0] = ex;
        }
      }
    };

    new Thread(changeObjects).start();

    for (int i = 0; i < 500 && exception[0] == null; i++)
    {
      customer.setName("Ottawa" + i);
      transaction.commit();
    }

    done[0] = true;
    if (exception[0] != null)
    {
      exception[0].printStackTrace();
      Assert.fail(exception[0].getMessage());
    }

    session.close();
  }
}




import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Eike Stepper

   */
  public void attach(InternalCDOObject object, InternalCDOTransaction transaction)
  {
    ReentrantLock viewLock = transaction.getStateLock();
    viewLock.lock();
    attach2(object);

    try
    {
      List<InternalCDOObject> contents = new ArrayList<InternalCDOObject>();
      attach1(object, new Pair<InternalCDOTransaction, List<InternalCDOObject>>(transaction, contents));
      attach2(object);

      for (InternalCDOObject content : contents)
      {
        attach2(content);
      }
    }
    finally
    {
      viewLock.unlock();
    }
  }


   */
  public void detach(InternalCDOObject object)
  {
    ReentrantLock viewLock = object.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      if (TRACER.isEnabled())
      {
        trace(object, CDOEvent.DETACH);
      }

      List<InternalCDOObject> objectsToDetach = new ArrayList<InternalCDOObject>();
      InternalCDOTransaction transaction = (InternalCDOTransaction)object.cdoView();

      // Accumulate objects that needs to be detached
      // If we have an error, we will keep the graph exactly like it was before.
      process(object, CDOEvent.DETACH, objectsToDetach);

      // postDetach requires the object to be TRANSIENT
      for (InternalCDOObject content : objectsToDetach)
      {
        CDOState oldState = content.cdoInternalSetState(CDOState.TRANSIENT);
        content.cdoInternalPostDetach();
        content.cdoInternalSetState(oldState);
      }

      // detachObject needs to know the state before we change the object to TRANSIENT
      for (InternalCDOObject content : objectsToDetach)
      {
        transaction.detachObject(content);
        content.cdoInternalSetState(CDOState.TRANSIENT);

        content.cdoInternalSetView(null);
        content.cdoInternalSetID(null);
        content.cdoInternalSetRevision(null);
      }
    }
    finally
    {
      viewLock.unlock();
    }
  }


   */
  public void read(InternalCDOObject object)
  {
    ReentrantLock viewLock = object.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      if (TRACER.isEnabled())
      {
        trace(object, CDOEvent.READ);
      }

      process(object, CDOEvent.READ, null);
    }
    finally
    {
      viewLock.unlock();
    }
  }

  /**

   */
  public void write(InternalCDOObject object, CDOFeatureDelta featureDelta)
  {
    ReentrantLock viewLock = object.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      if (TRACER.isEnabled())
      {
        trace(object, CDOEvent.WRITE);
      }

      process(object, CDOEvent.WRITE, featureDelta);
    }
    finally
    {
      viewLock.unlock();
    }
  }

  /**


    if (view != null)
    {
      ReentrantLock viewLock = ((InternalCDOView)view).getStateLock();
      viewLock.lock();

      try
      for (InternalCDORevision revision : revisions)
      {
        InternalCDOSession session = (InternalCDOSession)view.getSession();
        revisions = session.getSessionProtocol().verifyRevision(revisions);

        revisions.addAll(revised);
        for (InternalCDORevision revision : revisions)
        {
          InternalCDOObject object = ids.get(revision.getID());
          if (TRACER.isEnabled())
          {
            trace(object, CDOEvent.RELOAD);
          }

          process(object, CDOEvent.RELOAD, null);
        }
      }
      finally
      {
        viewLock.unlock();
      }
    }
  }

   */
  public void invalidate(InternalCDOObject object, int version)
  {
    ReentrantLock viewLock = object.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      if (TRACER.isEnabled())
      {
        trace(object, CDOEvent.INVALIDATE);
      }

      process(object, CDOEvent.INVALIDATE, version);
    }
    finally
    {
      viewLock.unlock();
    }
  }

  /**

   */
  public void detachRemote(InternalCDOObject object)
  {
    ReentrantLock viewLock = object.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      if (TRACER.isEnabled())
      {
        trace(object, CDOEvent.DETACH_REMOTE);
      }

      process(object, CDOEvent.DETACH_REMOTE, CDORevision.UNSPECIFIED_VERSION);
    }
    finally
    {
      viewLock.unlock();
    }
  }

  /**

   */
  public void commit(InternalCDOObject object, CommitTransactionResult result)
  {
    ReentrantLock viewLock = object.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      if (TRACER.isEnabled())
      {
        trace(object, CDOEvent.COMMIT);
      }

      process(object, CDOEvent.COMMIT, result);
    }
    finally
    {
      viewLock.unlock();
    }
  }

  /**

   */
  public void rollback(InternalCDOObject object)
  {
    ReentrantLock viewLock = object.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      if (TRACER.isEnabled())
      {
        trace(object, CDOEvent.ROLLBACK);
      }

      process(object, CDOEvent.ROLLBACK, null);
    }
    finally
    {
      viewLock.unlock();
    }
  }

  @Override





import java.text.MessageFormat;
import java.util.Collection;
import java.util.concurrent.locks.ReentrantLock;

/**
 * CDORevision needs to follow these rules:<br>


  private static InternalCDORevision getRevisionForReading(InternalCDOObject cdoObject)
  {
    ReentrantLock viewLock = cdoObject.cdoView().getStateLock();
    viewLock.lock();

    try
    {
      CDOStateMachine.INSTANCE.read(cdoObject);
      return getRevision(cdoObject);
    }
    finally
    {
      viewLock.unlock();
    }
  }

  private static InternalCDORevision getRevisionForWriting(InternalCDOObject cdoObject, CDOFeatureDelta delta)

Lines 30-35 Link Here

(-)src/org/eclipse/emf/spi/cdo/InternalCDOView.java (+3 lines)
30		30
31	import java.util.Collection;	31	import java.util.Collection;
32	import java.util.Set;	32	import java.util.Set;
		33	import java.util.concurrent.locks.ReentrantLock;
33		34
34	/**	35	/**
35	* @author Eike Stepper	36	* @author Eike Stepper
Lines 98-101 Link Here
98	public void unsubscribe(EObject eObject, Adapter adapter);	99	public void unsubscribe(EObject eObject, Adapter adapter);
99		100
100	public boolean hasSubscription(CDOID id);	101	public boolean hasSubscription(CDOID id);
		102
		103	public ReentrantLock getStateLock();
101	}	104	}

Lines 125-130 Link Here

(-)src/org/eclipse/emf/internal/cdo/view/CDOViewImpl.java (+10 lines)
125		125
126	private ReentrantLock lock = new ReentrantLock(true);	126	private ReentrantLock lock = new ReentrantLock(true);
127		127
		128	private ReentrantLock stateLock = new ReentrantLock(true);
		129
128	private CDOResourceImpl rootResource;	130	private CDOResourceImpl rootResource;
129		131
130	private ChangeSubscriptionManager changeSubscriptionManager = createChangeSubscriptionManager();	132	private ChangeSubscriptionManager changeSubscriptionManager = createChangeSubscriptionManager();
Lines 260-265 Link Here
260	}	262	}
261		263
262	/**	264	/**
		265	* @since 2.0
		266	*/
		267	public ReentrantLock getStateLock()
		268	{
		269	return stateLock;
		270	}
		271
		272	/**
263	* @throws InterruptedException	273	* @throws InterruptedException
264	* @since 2.0	274	* @since 2.0
265	*/	275	*/

Return to bug 266982

Lines 52-57 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOStore.java (-2 / +13 lines)
52		52
53	import java.text.MessageFormat;	53	import java.text.MessageFormat;
54	import java.util.Collection;	54	import java.util.Collection;
		55	import java.util.concurrent.locks.ReentrantLock;
55		56
56	/**	57	/**
57	* CDORevision needs to follow these rules:<br>	58	* CDORevision needs to follow these rules:<br>
Lines 566-573 Link Here
566		567
567	private static InternalCDORevision getRevisionForReading(InternalCDOObject cdoObject)	568	private static InternalCDORevision getRevisionForReading(InternalCDOObject cdoObject)
568	{	569	{
569	CDOStateMachine.INSTANCE.read(cdoObject);	570	ReentrantLock viewLock = cdoObject.cdoView().getStateLock();
570	return getRevision(cdoObject);	571	viewLock.lock();
		572
		573	try
		574	{
		575	CDOStateMachine.INSTANCE.read(cdoObject);
		576	return getRevision(cdoObject);
		577	}
		578	finally
		579	{
		580	viewLock.unlock();
		581	}
571	}	582	}
572		583
573	private static InternalCDORevision getRevisionForWriting(InternalCDOObject cdoObject, CDOFeatureDelta delta)	584	private static InternalCDORevision getRevisionForWriting(InternalCDOObject cdoObject, CDOFeatureDelta delta)

Added Link Here

(-)src/org/eclipse/emf/cdo/tests/bugzilla/Bugzilla_266982_Test.java (+86 lines)
1	/**
2	* Copyright (c) 2004 - 2009 Eike Stepper (Berlin, Germany) and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Simon McDuff - initial API and implementation
10	*/
11	package org.eclipse.emf.cdo.tests.bugzilla;
12
13	import org.eclipse.emf.cdo.eresource.CDOResource;
14	import org.eclipse.emf.cdo.session.CDOSession;
15	import org.eclipse.emf.cdo.tests.AbstractCDOTest;
16	import org.eclipse.emf.cdo.tests.model1.Customer;
17	import org.eclipse.emf.cdo.transaction.CDOTransaction;
18	import org.eclipse.emf.cdo.util.CDOUtil;
19
20	import junit.framework.Assert;
21
22	/**
23	* IllegalStateException in CDOStore.getRevision
24	* <p>
25	* See https://bugs.eclipse.org/266982
26	*
27	* @author Simon McDuff
28	*/
29	public class Bugzilla_266982_Test extends AbstractCDOTest
30	{
31	public void testBugzilla_266982() throws Exception
32	{
33	final Customer customer = getModel1Factory().createCustomer();
34	final boolean done[] = new boolean[1];
35	final Exception exception[] = new Exception[1];
36	done[0] = false;
37	customer.setName("customer");
38
39	CDOSession session = openModel1Session();
40	CDOTransaction transaction = session.openTransaction();
41	CDOResource resource = transaction.createResource("/test1");
42	resource.getContents().add(customer);
43	transaction.commit();
44
45	Runnable changeObjects = new Runnable()
46	{
47	public void run()
48	{
49	try
50	{
51	CDOSession session = openModel1Session();
52	CDOTransaction transaction = session.openTransaction();
53	Customer customerToLoad = (Customer)transaction.getObject(CDOUtil.getCDOObject(customer).cdoID());
54	while (!done[0])
55	{
56	// Could fail if the attach is not thread safe
57	customerToLoad.getName();
58	}
59	transaction.close();
60	session.close();
61	}
62	catch (Exception ex)
63	{
64	exception[0] = ex;
65	}
66	}
67	};
68
69	new Thread(changeObjects).start();
70
71	for (int i = 0; i < 500 && exception[0] == null; i++)
72	{
73	customer.setName("Ottawa" + i);
74	transaction.commit();
75	}
76
77	done[0] = true;
78	if (exception[0] != null)
79	{
80	exception[0].printStackTrace();
81	Assert.fail(exception[0].getMessage());
82	}
83
84	session.close();
85	}
86	}

Lines 47-52 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOStateMachine.java (-61 / +152 lines)
47	import java.util.Iterator;	47	import java.util.Iterator;
48	import java.util.List;	48	import java.util.List;
49	import java.util.Map;	49	import java.util.Map;
		50	import java.util.concurrent.locks.ReentrantLock;
50		51
51	/**	52	/**
52	* @author Eike Stepper	53	* @author Eike Stepper
Lines 177-189 Link Here
177	*/	178	*/
178	public void attach(InternalCDOObject object, InternalCDOTransaction transaction)	179	public void attach(InternalCDOObject object, InternalCDOTransaction transaction)
179	{	180	{
180	List<InternalCDOObject> contents = new ArrayList<InternalCDOObject>();	181	ReentrantLock viewLock = transaction.getStateLock();
181	attach1(object, new Pair<InternalCDOTransaction, List<InternalCDOObject>>(transaction, contents));	182	viewLock.lock();
182	attach2(object);
183		183
184	for (InternalCDOObject content : contents)	184	try
185	{	185	{
186	attach2(content);	186	List<InternalCDOObject> contents = new ArrayList<InternalCDOObject>();
		187	attach1(object, new Pair<InternalCDOTransaction, List<InternalCDOObject>>(transaction, contents));
		188	attach2(object);
		189
		190	for (InternalCDOObject content : contents)
		191	{
		192	attach2(content);
		193	}
		194	}
		195	finally
		196	{
		197	viewLock.unlock();
187	}	198	}
188	}	199	}
189		200
Lines 219-253 Link Here
219	*/	230	*/
220	public void detach(InternalCDOObject object)	231	public void detach(InternalCDOObject object)
221	{	232	{
222	if (TRACER.isEnabled())	233	ReentrantLock viewLock = object.cdoView().getStateLock();
		234	viewLock.lock();
		235
		236	try
223	{	237	{
224	trace(object, CDOEvent.DETACH);	238	if (TRACER.isEnabled())
225	}	239	{
		240	trace(object, CDOEvent.DETACH);
		241	}
226		242
227	List<InternalCDOObject> objectsToDetach = new ArrayList<InternalCDOObject>();	243	List<InternalCDOObject> objectsToDetach = new ArrayList<InternalCDOObject>();
228	InternalCDOTransaction transaction = (InternalCDOTransaction)object.cdoView();	244	InternalCDOTransaction transaction = (InternalCDOTransaction)object.cdoView();
229		245
230	// Accumulate objects that needs to be detached	246	// Accumulate objects that needs to be detached
231	// If we have an error, we will keep the graph exactly like it was before.	247	// If we have an error, we will keep the graph exactly like it was before.
232	process(object, CDOEvent.DETACH, objectsToDetach);	248	process(object, CDOEvent.DETACH, objectsToDetach);
233		249
234	// postDetach requires the object to be TRANSIENT	250	// postDetach requires the object to be TRANSIENT
235	for (InternalCDOObject content : objectsToDetach)	251	for (InternalCDOObject content : objectsToDetach)
236	{	252	{
237	CDOState oldState = content.cdoInternalSetState(CDOState.TRANSIENT);	253	CDOState oldState = content.cdoInternalSetState(CDOState.TRANSIENT);
238	content.cdoInternalPostDetach();	254	content.cdoInternalPostDetach();
239	content.cdoInternalSetState(oldState);	255	content.cdoInternalSetState(oldState);
240	}	256	}
241		257
242	// detachObject needs to know the state before we change the object to TRANSIENT	258	// detachObject needs to know the state before we change the object to TRANSIENT
243	for (InternalCDOObject content : objectsToDetach)	259	for (InternalCDOObject content : objectsToDetach)
244	{	260	{
245	transaction.detachObject(content);	261	transaction.detachObject(content);
246	content.cdoInternalSetState(CDOState.TRANSIENT);	262	content.cdoInternalSetState(CDOState.TRANSIENT);
247		263
248	content.cdoInternalSetView(null);	264	content.cdoInternalSetView(null);
249	content.cdoInternalSetID(null);	265	content.cdoInternalSetID(null);
250	content.cdoInternalSetRevision(null);	266	content.cdoInternalSetRevision(null);
		267	}
		268	}
		269	finally
		270	{
		271	viewLock.unlock();
251	}	272	}
252	}	273	}
253		274
Lines 256-267 Link Here
256	*/	277	*/
257	public void read(InternalCDOObject object)	278	public void read(InternalCDOObject object)
258	{	279	{
259	if (TRACER.isEnabled())	280	ReentrantLock viewLock = object.cdoView().getStateLock();
		281	viewLock.lock();
		282
		283	try
260	{	284	{
261	trace(object, CDOEvent.READ);	285	if (TRACER.isEnabled())
262	}	286	{
		287	trace(object, CDOEvent.READ);
		288	}
263		289
264	process(object, CDOEvent.READ, null);	290	process(object, CDOEvent.READ, null);
		291	}
		292	finally
		293	{
		294	viewLock.unlock();
		295	}
265	}	296	}
266		297
267	/**	298	/**
Lines 277-288 Link Here
277	*/	308	*/
278	public void write(InternalCDOObject object, CDOFeatureDelta featureDelta)	309	public void write(InternalCDOObject object, CDOFeatureDelta featureDelta)
279	{	310	{
280	if (TRACER.isEnabled())	311	ReentrantLock viewLock = object.cdoView().getStateLock();
		312	viewLock.lock();
		313
		314	try
281	{	315	{
282	trace(object, CDOEvent.WRITE);	316	if (TRACER.isEnabled())
283	}	317	{
		318	trace(object, CDOEvent.WRITE);
		319	}
284		320
285	process(object, CDOEvent.WRITE, featureDelta);	321	process(object, CDOEvent.WRITE, featureDelta);
		322	}
		323	finally
		324	{
		325	viewLock.unlock();
		326	}
286	}	327	}
287		328
288	/**	329	/**
Lines 321-339 Link Here
321		362
322	if (view != null)	363	if (view != null)
323	{	364	{
324	InternalCDOSession session = (InternalCDOSession)view.getSession();	365	ReentrantLock viewLock = ((InternalCDOView)view).getStateLock();
325	revisions = session.getSessionProtocol().verifyRevision(revisions);	366	viewLock.lock();
326		367
327	revisions.addAll(revised);	368	try
328	for (InternalCDORevision revision : revisions)
329	{	369	{
330	InternalCDOObject object = ids.get(revision.getID());	370	InternalCDOSession session = (InternalCDOSession)view.getSession();
331	if (TRACER.isEnabled())	371	revisions = session.getSessionProtocol().verifyRevision(revisions);
		372
		373	revisions.addAll(revised);
		374	for (InternalCDORevision revision : revisions)
332	{	375	{
333	trace(object, CDOEvent.RELOAD);	376	InternalCDOObject object = ids.get(revision.getID());
334	}	377	if (TRACER.isEnabled())
		378	{
		379	trace(object, CDOEvent.RELOAD);
		380	}
335		381
336	process(object, CDOEvent.RELOAD, null);	382	process(object, CDOEvent.RELOAD, null);
		383	}
		384	}
		385	finally
		386	{
		387	viewLock.unlock();
337	}	388	}
338	}	389	}
339	}	390	}
Lines 343-354 Link Here
343	*/	394	*/
344	public void invalidate(InternalCDOObject object, int version)	395	public void invalidate(InternalCDOObject object, int version)
345	{	396	{
346	if (TRACER.isEnabled())	397	ReentrantLock viewLock = object.cdoView().getStateLock();
		398	viewLock.lock();
		399
		400	try
347	{	401	{
348	trace(object, CDOEvent.INVALIDATE);	402	if (TRACER.isEnabled())
349	}	403	{
		404	trace(object, CDOEvent.INVALIDATE);
		405	}
350		406
351	process(object, CDOEvent.INVALIDATE, version);	407	process(object, CDOEvent.INVALIDATE, version);
		408	}
		409	finally
		410	{
		411	viewLock.unlock();
		412	}
352	}	413	}
353		414
354	/**	415	/**
Lines 356-367 Link Here
356	*/	417	*/
357	public void detachRemote(InternalCDOObject object)	418	public void detachRemote(InternalCDOObject object)
358	{	419	{
359	if (TRACER.isEnabled())	420	ReentrantLock viewLock = object.cdoView().getStateLock();
		421	viewLock.lock();
		422
		423	try
360	{	424	{
361	trace(object, CDOEvent.DETACH_REMOTE);	425	if (TRACER.isEnabled())
362	}	426	{
		427	trace(object, CDOEvent.DETACH_REMOTE);
		428	}
363		429
364	process(object, CDOEvent.DETACH_REMOTE, CDORevision.UNSPECIFIED_VERSION);	430	process(object, CDOEvent.DETACH_REMOTE, CDORevision.UNSPECIFIED_VERSION);
		431	}
		432	finally
		433	{
		434	viewLock.unlock();
		435	}
365	}	436	}
366		437
367	/**	438	/**
Lines 369-380 Link Here
369	*/	440	*/
370	public void commit(InternalCDOObject object, CommitTransactionResult result)	441	public void commit(InternalCDOObject object, CommitTransactionResult result)
371	{	442	{
372	if (TRACER.isEnabled())	443	ReentrantLock viewLock = object.cdoView().getStateLock();
		444	viewLock.lock();
		445
		446	try
373	{	447	{
374	trace(object, CDOEvent.COMMIT);	448	if (TRACER.isEnabled())
375	}	449	{
		450	trace(object, CDOEvent.COMMIT);
		451	}
376		452
377	process(object, CDOEvent.COMMIT, result);	453	process(object, CDOEvent.COMMIT, result);
		454	}
		455	finally
		456	{
		457	viewLock.unlock();
		458	}
378	}	459	}
379		460
380	/**	461	/**
Lines 382-393 Link Here
382	*/	463	*/
383	public void rollback(InternalCDOObject object)	464	public void rollback(InternalCDOObject object)
384	{	465	{
385	if (TRACER.isEnabled())	466	ReentrantLock viewLock = object.cdoView().getStateLock();
		467	viewLock.lock();
		468
		469	try
386	{	470	{
387	trace(object, CDOEvent.ROLLBACK);	471	if (TRACER.isEnabled())
388	}	472	{
		473	trace(object, CDOEvent.ROLLBACK);
		474	}
389		475
390	process(object, CDOEvent.ROLLBACK, null);	476	process(object, CDOEvent.ROLLBACK, null);
		477	}
		478	finally
		479	{
		480	viewLock.unlock();
		481	}
391	}	482	}
392		483
393	@Override	484	@Override