You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openjpa.apache.org by jr...@apache.org on 2010/12/06 17:09:09 UTC
svn commit: r1042698 - in /openjpa/trunk:
openjpa-kernel/src/main/java/org/apache/openjpa/datacache/
openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/
openjpa-persistence/src/main/java/org/apache/openjpa/persistence/
Author: jrbauer
Date: Mon Dec 6 16:09:08 2010
New Revision: 1042698
URL: http://svn.apache.org/viewvc?rev=1042698&view=rev
Log:
OPENJPA-1884 Updated entity manager impl to process cache store mode property provided on refresh method and updated data cache manager to refresh the L2 properly when a store mode is provided.
Added:
openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
Modified:
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/datacache/DataCacheStoreManager.java
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerImpl.java
Modified: openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/datacache/DataCacheStoreManager.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/datacache/DataCacheStoreManager.java?rev=1042698&r1=1042697&r2=1042698&view=diff
==============================================================================
--- openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/datacache/DataCacheStoreManager.java (original)
+++ openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/datacache/DataCacheStoreManager.java Mon Dec 6 16:09:08 2010
@@ -24,7 +24,6 @@ import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
@@ -437,8 +436,13 @@ public class DataCacheStoreManager
public boolean load(OpenJPAStateManager sm, BitSet fields,
FetchConfiguration fetch, int lockLevel, Object edata) {
DataCache cache = _mgr.selectCache(sm);
- if (cache == null || sm.isEmbedded() || bypass(fetch, StoreManager.FORCE_LOAD_NONE))
- return super.load(sm, fields, fetch, lockLevel, edata);
+
+ boolean found = false;
+ if (cache == null || sm.isEmbedded() || bypass(fetch, StoreManager.FORCE_LOAD_NONE)) {
+ found = super.load(sm, fields, fetch, lockLevel, edata);
+ updateDataCache(found, sm, fetch);
+ return found;
+ }
CacheStatistics stats = cache.getStatistics();
DataCachePCData data = cache.get(sm.getObjectId());
@@ -454,20 +458,59 @@ public class DataCacheStoreManager
// load from store manager; clone the set of still-unloaded fields
// so that if the store manager decides to modify it it won't affect us
- if (!super.load(sm, (BitSet) fields.clone(), fetch, lockLevel, edata))
- return false;
- if (_ctx.getPopulateDataCache()) {
- cacheStateManager(cache, sm, data);
+ found = super.load(sm, (BitSet) fields.clone(), fetch, lockLevel, edata);
+
+ // Get new instance of cache after DB load since it may have changed
+ updateDataCache(found, sm, fetch);
+
+ return found;
+ }
+
+ /**
+ * Updates or inserts and item into the data cache. If storeMode=USE and not in the cache,
+ * the item is inserted. If storeMode=REFRESH the item is inserted, updated, or if found=false,
+ * removed from the cache.
+ * @param found whether the entity was found by the store manager
+ * @param sm the state manager
+ * @param fetch fetch configuration
+ */
+ private void updateDataCache(boolean found, OpenJPAStateManager sm, FetchConfiguration fetch) {
+
+ if (!_ctx.getPopulateDataCache() || sm == null || fetch.getCacheStoreMode() == DataCacheStoreMode.BYPASS) {
+ return;
+ }
+
+ DataCache cache = _mgr.selectCache(sm);
+ if (cache == null) {
+ return;
}
- return true;
+ DataCachePCData data = cache.get(sm.getObjectId());
+ boolean alreadyCached = data != null;
+
+ if ((fetch.getCacheStoreMode() == DataCacheStoreMode.USE && !alreadyCached) ||
+ fetch.getCacheStoreMode() == DataCacheStoreMode.REFRESH) {
+ // If not found in the DB and the item is in the cache, and not locking remove the item
+ if (!found && data != null && !isLocking(fetch)) {
+ cache.remove(sm.getObjectId());
+ return;
+ }
+ // Update or insert the item into the cache
+ if (found) {
+ cacheStateManager(cache, sm, data);
+ CacheStatistics stats = cache.getStatistics();
+ if (stats.isEnabled()) {
+ ((CacheStatisticsSPI) stats).newPut(sm.getMetaData().getDescribedType());
+ }
+ }
+ }
}
public Collection<Object> loadAll(Collection<OpenJPAStateManager> sms, PCState state, int load,
- FetchConfiguration fetch, Object edata) {
- if (bypass(fetch, load)) {
- return super.loadAll(sms, state, load, fetch, edata);
- }
+ FetchConfiguration fetch, Object edata) {
+ if (bypass(fetch, load)) {
+ return super.loadAll(sms, state, load, fetch, edata);
+ }
Map<OpenJPAStateManager, BitSet> unloaded = null;
List<OpenJPAStateManager> smList = null;
Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java?rev=1042698&view=auto
==============================================================================
--- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java (added)
+++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/cache/jpa/TestMultiEMFCacheModes.java Mon Dec 6 16:09:08 2010
@@ -0,0 +1,223 @@
+/*
+ * 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.cache.jpa;
+
+import java.util.Random;
+
+import javax.persistence.Cache;
+import javax.persistence.CacheStoreMode;
+import javax.persistence.EntityManager;
+import javax.persistence.EntityManagerFactory;
+import javax.persistence.EntityNotFoundException;
+import javax.persistence.LockModeType;
+
+
+import org.apache.openjpa.persistence.cache.jpa.model.CacheableEntity;
+import org.apache.openjpa.persistence.test.SingleEMFTestCase;
+
+/**
+ * Verifies L2 operations using multiple entity manager factories. The EMF which
+ * does updates does not have the data cache enabled thus, it does not send
+ * sjvm updates upon commit.
+ */
+public class TestMultiEMFCacheModes extends SingleEMFTestCase {
+
+ public void setUp() {
+ setUp( CLEAR_TABLES, CacheableEntity.class,
+ "openjpa.ConnectionFactoryProperties", "PrintParameters=true",
+ "openjpa.DataCache", "true");
+ }
+
+ /**
+ * Verifies that the data cache us updated via a em.refresh operation when
+ * javax.persistence.cache.storeMode = CacheStoreMode.REFRESH and the
+ * entity is updated in the database.
+ */
+ public void testCacheRefreshModeRefresh() {
+
+ EntityManager em = emf.createEntityManager();
+
+ // Create a new cacheable entity
+ CacheableEntity ce = createEntity(em);
+ int ceid = ce.getId();
+
+ // Clear the L1
+ em.clear();
+
+ // Clear the L2 cache
+ Cache cache = emf.getCache();
+ cache.evictAll();
+ assertFalse(cache.contains(CacheableEntity.class, ceid));
+
+ // Find the entity, reloading it into the L2
+ em.getTransaction().begin();
+ ce = em.find(CacheableEntity.class, ceid);
+ assertTrue(em.contains(ce));
+ assertTrue(cache.contains(CacheableEntity.class, ceid));
+ assertTrue(em.getLockMode(ce) == LockModeType.NONE);
+ assertEquals(ce.getName(), "Cached Entity");
+ assertEquals(ce.getVersion(), 1);
+ em.getTransaction().commit();
+
+ // Create a new EMF -WITHOUT- the L2 enabled. If the L2 was enabled, the
+ // sjvm remote commit provider would evict the entity upon update, throwing
+ // off the intent of this variation.
+ EntityManagerFactory emf2 = this.createEMF(CacheableEntity.class,
+ "openjpa.LockManager", "mixed",
+ "openjpa.ConnectionFactoryProperties", "PrintParameters=true");
+ EntityManager em2 = emf2.createEntityManager();
+
+ // Find + lock, then update the entity and commit
+ em2.getTransaction().begin();
+ CacheableEntity ce2 = em2.find(CacheableEntity.class, ceid, LockModeType.PESSIMISTIC_FORCE_INCREMENT);
+ ce2.setName("Updated Cached Entity");
+ em2.getTransaction().commit();
+ em2.close();
+ emf2.close();
+
+ // Refresh the entity - this will load the entity into the L1 and with storeMode=REFRESH,
+ // should also refresh it in the L2
+ java.util.Map<String, Object> cacheStoreModeMap = new java.util.HashMap<String, Object>();
+ cacheStoreModeMap.put("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH);
+ em.refresh(ce, cacheStoreModeMap);
+
+ // Verify the entity was updated
+ verifyUpdatedEntity(ce, ceid);
+
+ // Verify loading from the L1
+ ce = em.find(CacheableEntity.class, ceid);
+
+ // Verify the entity was updated
+ verifyUpdatedEntity(ce, ceid);
+
+ // Clear the L1
+ em.clear();
+
+ // Assert the L2 contains the entity
+ assertTrue(cache.contains(CacheableEntity.class, ceid));
+
+ // Reload the entity from the L2
+ ce = em.find(CacheableEntity.class, ceid);
+
+ // Verify the entity in the L2 was updated
+ verifyUpdatedEntity(ce, ceid);
+
+ em.close();
+ }
+
+ /**
+ * Verifies that the data cache us updated via a em.refresh operation when
+ * javax.persistence.cache.storeMode = CacheStoreMode.REFRESH and the
+ * record is removed from the database.
+ */
+ public void testCacheRefreshModeRefreshDelete() {
+
+ EntityManager em = emf.createEntityManager();
+
+ // Create a new cachable entity
+ CacheableEntity ce = createEntity(em);
+ int ceid = ce.getId();
+
+ // Clear the L2 cache
+ Cache cache = emf.getCache();
+ cache.evictAll();
+ assertFalse(cache.contains(CacheableEntity.class, ceid));
+
+ // Find the entity, reloading it into the L2
+ em.getTransaction().begin();
+ ce = em.find(CacheableEntity.class, ceid);
+ assertTrue(em.contains(ce));
+ assertTrue(cache.contains(CacheableEntity.class, ceid));
+ assertTrue(em.getLockMode(ce) == LockModeType.NONE);
+ assertEquals(ce.getName(), "Cached Entity");
+ assertEquals(ce.getVersion(), 1);
+ em.getTransaction().commit();
+
+ // Create a new EMF -WITHOUT- the L2 enabled. If the L2 was enabled, the
+ // sjvm remote commit provider would evict the entity upon delete, throwing
+ // off the intent of this variation.
+ EntityManagerFactory emf2 = this.createEMF(CacheableEntity.class,
+ "openjpa.LockManager", "mixed",
+ "openjpa.ConnectionFactoryProperties", "PrintParameters=true");
+ EntityManager em2 = emf2.createEntityManager();
+
+ // Find and delete the entity in a separate context with no L2 configured
+ em2.getTransaction().begin();
+ CacheableEntity ce2 = em2.find(CacheableEntity.class, ceid);
+ assertNotNull(ce2);
+ em2.remove(ce2);
+ em2.getTransaction().commit();
+ em2.close();
+ emf2.close();
+
+ // Refresh the entity with storeMode=REFRESH. The entity has been deleted so it will be
+ // purged from the L2 cache when the DB load fails.
+ java.util.Map<String, Object> cacheStoreModeMap = new java.util.HashMap<String, Object>();
+ cacheStoreModeMap.put("javax.persistence.cache.storeMode", CacheStoreMode.REFRESH);
+ try {
+ em.refresh(ce, cacheStoreModeMap);
+ fail("Refresh operation should have thrown an exception");
+ } catch (EntityNotFoundException e) {
+ // expected exception
+ }
+
+ // Try loading from the L1 - OpenJPA will detect the entity was
+ // removed in another transaction.
+ try {
+ ce = em.find(CacheableEntity.class, ceid);
+ fail("OpenJPA should have detected the removed entity");
+ } catch (EntityNotFoundException e) {
+ // expected exception
+ }
+
+ // Clear the L1
+ em.clear();
+
+ // Assert the L2 no longer contains the entity
+ assertFalse(cache.contains(CacheableEntity.class, ceid));
+
+ // Attempt to reload entity from the L2 or database
+ ce = em.find(CacheableEntity.class, ceid);
+
+ // Verify the entity was removed from L2 and DB
+ assertNull(ce);
+
+ em.close();
+ }
+
+ private CacheableEntity createEntity(EntityManager em) {
+ CacheableEntity ce = new CacheableEntity();
+ int ceid = new Random().nextInt();
+ ce.setId(ceid);
+ ce.setName("Cached Entity");
+
+ // Persist the new cachable entity
+ em.getTransaction().begin();
+ em.persist(ce);
+ em.getTransaction().commit();
+ em.clear();
+ return ce;
+ }
+
+ private void verifyUpdatedEntity(CacheableEntity ce, int id) {
+ assertEquals(id, ce.getId());
+ assertEquals("Updated Cached Entity", ce.getName());
+ assertEquals(2, ce.getVersion());
+ }
+}
Modified: openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerImpl.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerImpl.java?rev=1042698&r1=1042697&r2=1042698&view=diff
==============================================================================
--- openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerImpl.java (original)
+++ openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/EntityManagerImpl.java Mon Dec 6 16:09:08 2010
@@ -761,7 +761,8 @@ public class EntityManagerImpl
assertValidAttchedEntity(REFRESH, entity);
_broker.assertWriteOperation();
- configureCurrentFetchPlan(pushFetchPlan(), properties, mode, true);
+ configureCurrentCacheModes(pushFetchPlan(), properties);
+ configureCurrentFetchPlan(getFetchPlan(), properties, mode, true);
DataCacheRetrieveMode rmode = getFetchPlan().getCacheRetrieveMode();
if (DataCacheRetrieveMode.USE.equals(rmode) || rmode == null) {
getFetchPlan().setCacheRetrieveMode(DataCacheRetrieveMode.BYPASS);