/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openjpa.persistence.kernel;
import javax.persistence.EntityManager;
import javax.persistence.LockModeType;
import org.apache.openjpa.jdbc.conf.JDBCConfiguration;
import org.apache.openjpa.jdbc.sql.DB2Dictionary;
import org.apache.openjpa.jdbc.sql.DBDictionary;
import org.apache.openjpa.jdbc.sql.OracleDictionary;
import org.apache.openjpa.persistence.OpenJPAEntityManager;
import org.apache.openjpa.persistence.OpenJPAPersistence;
import org.apache.openjpa.persistence.PessimisticLockException;
import org.apache.openjpa.persistence.test.SQLListenerTestCase;
public class TestPessimisticLockException extends SQLListenerTestCase {
int pKey = 1;
static boolean doSleep = true;
@Override
public void setUp() throws Exception {
super.setUp(PessimisticLockEntity.class);
}
/*
* This test has only been verified on DB2 and Oracle.
*/
protected boolean skipTest() {
if (emf.getConfiguration() instanceof JDBCConfiguration) {
DBDictionary inst = ((JDBCConfiguration) emf.getConfiguration()).getDBDictionaryInstance();
return !((inst instanceof DB2Dictionary) || (inst instanceof OracleDictionary));
}
return true;
}
/*
* This test will verify that two threads get a an appropriate pessimistic lock
* when they both request one at the same time. See JIRA OPENJPA-2547 for a more
* detailed description of this test.
*/
public void testPessimisticLockException() {
if (!skipTest()) {
populate();
TestThread t1 = new TestThread();
TestThread t2 = new TestThread();
t1.start();
t2.start();
while ((t1.isAlive() || t2.isAlive())) {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
}
// One, and only one, thread should get a PersistenceException
if (t1.gotPLEx && t2.gotPLEx) {
fail("Both threads got a PersistenceLockException! "
+ "Only one thread should have received a PersistenceLockException");
} else if (t1.gotPLEx == false && t2.gotPLEx == false) {
fail("Neither thread got a PersistenceLockException! "
+ "One thread should have received a PersistenceLockException");
} else if (t1.count < 2 && t2.count < 2) {
fail("PersistenceLockException was received, but not the expected number of times! "
+ "One thread should have received a PersistenceLockException at least twice.");
}
}
}
private class TestThread extends Thread {
boolean gotPLEx = false;
int count = 0;
public synchronized void run() {
OpenJPAEntityManager oem = OpenJPAPersistence.cast(emf.createEntityManager());
oem.getTransaction().begin();
PessimisticLockEntity entity = oem.find(PessimisticLockEntity.class, pKey);
boolean locked = false;
while (!locked) {
try {
oem.getFetchPlan().setLockTimeout(5000);
oem.lock(entity, LockModeType.PESSIMISTIC_READ);
locked = true;
} catch (PessimisticLockException ple) {
gotPLEx = true;
count++;
try {
Thread.sleep(100);
} catch (final InterruptedException ie) {
}
oem.refresh(entity);
} catch (Throwable pe) {
pe.printStackTrace();
fail("Caught an unexepected exception: " + pe);
}
// Only one thread needs to sleep (don't care about synchronization of 'doSleep' at this
// point - if both threads happen to get here at the same time we will test for that later.)
if (doSleep) {
doSleep = false;
try {
// Sleep log enough to ensure the other thread times out at least two times.
Thread.sleep(15000);
} catch (final InterruptedException ie) {
}
}
if (!oem.getTransaction().getRollbackOnly()) {
oem.getTransaction().commit();
}
}
}
}
/*
* This test verifies the correct number of SQL statements when using a pessimistic
* lock (See JIRA OPENJPA-2449). Prior to OPENJPA-2449, when requesting a pessimistic lock
* we would do a 'select' to get the entity, and turn around and do another select to get a
* Pessimistic lock...in other words, we'd generate (on DB2) these two SQL statements for the refresh:
*
* SELECT t0.name FROM PessimisticLockEntity t0 WHERE t0.id = ?
* SELECT t0.name FROM PessimisticLockEntity t0 WHERE t0.id = ? FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS
*
* With the fix of OPENJPA-2449, we generate only one select, as follows:
*
* SELECT t0.name FROM PessimisticLockEntity t0 WHERE t0.id = ? FOR READ ONLY WITH RR USE AND KEEP UPDATE LOCKS
*
* Not only does this save an SQL, but more importantly, the few millisecond delay between the two selects
* won't occur.....in a multi-threaded env this delay could cause another thread to get the lock over this
* one when the refresh occurs at the same time.
*/
public void testSQLCount() {
if (!skipTest()) {
populate();
resetSQL();
EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
PessimisticLockEntity plEnt = em.find(PessimisticLockEntity.class, pKey);
em.refresh(plEnt, LockModeType.PESSIMISTIC_WRITE);
plEnt.setName("test");
em.getTransaction().commit();
em.close();
assertEquals("There should only be 3 SQL statements", 3, getSQLCount());
}
}
public void populate() {
EntityManager em = emf.createEntityManager();
em.getTransaction().begin();
PessimisticLockEntity pt = new PessimisticLockEntity();
pt.setId(pKey);
em.persist(pt);
em.getTransaction().commit();
em.close();
}
}