@Override
public void process(
KeyFilter<? super K> filter,
final CacheLoaderTask<K, V> task,
Executor executor,
final boolean fetchValue,
final boolean fetchMetadata) {
filter = PersistenceUtil.notNull(filter);
ArrayList<KeyValuePair<K, FileEntry>> keysToLoad = new ArrayList<>(entries.size());
synchronized (entries) {
for (Map.Entry<K, FileEntry> e : entries.entrySet()) {
if (filter.accept(e.getKey())) keysToLoad.add(new KeyValuePair<>(e.getKey(), e.getValue()));
}
Collections.sort(
keysToLoad,
new Comparator<KeyValuePair<K, FileEntry>>() {
@Override
public int compare(KeyValuePair<K, FileEntry> o1, KeyValuePair<K, FileEntry> o2) {
long offset1 = o1.getValue().offset;
long offset2 = o2.getValue().offset;
return offset1 < offset2 ? -1 : offset1 == offset2 ? 0 : 1;
}
});
// keysToLoad values (i.e. FileEntries) must not be used past this point
}
ExecutorAllCompletionService eacs = new ExecutorAllCompletionService(executor);
final TaskContextImpl taskContext = new TaskContextImpl();
for (KeyValuePair<K, FileEntry> e : keysToLoad) {
if (taskContext.isStopped()) break;
final K key = e.getKey();
eacs.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
try {
final MarshalledEntry marshalledEntry = _load(key, fetchValue, fetchMetadata);
if (marshalledEntry != null) {
task.processEntry(marshalledEntry, taskContext);
}
return null;
} catch (Exception e) {
log.errorExecutingParallelStoreTask(e);
throw e;
}
}
});
}
eacs.waitUntilAllCompleted();
if (eacs.isExceptionThrown()) {
throw new PersistenceException("Execution exception!", eacs.getFirstException());
}
}
@Override
public void process(
KeyFilter filter,
final CacheLoaderTask task,
Executor executor,
final boolean fetchValue,
final boolean fetchMetadata) {
if (true) return;
filter = PersistenceUtil.notNull(filter);
Set<Object> keysToLoad = new HashSet<Object>(ctx.getCache().keySet());
ExecutorAllCompletionService eacs = new ExecutorAllCompletionService(executor);
final TaskContextImpl taskContext = new TaskContextImpl();
for (final Object key : keysToLoad) {
if (taskContext.isStopped()) break;
eacs.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
try {
final MarshalledEntry marshalledEntry = _load(key, fetchValue, fetchMetadata);
if (marshalledEntry != null) {
Debug.line(task, marshalledEntry, fetchValue, fetchMetadata);
task.processEntry(marshalledEntry, taskContext);
}
return null;
} catch (Exception e) {
log.errorExecutingParallelStoreTask(e);
throw e;
}
}
});
}
eacs.waitUntilAllCompleted();
if (eacs.isExceptionThrown()) {
throw new PersistenceException("Execution exception!", eacs.getFirstException());
}
}
@Override
public void purge(Executor threadPool, final PurgeListener listener) {
ExecutorAllCompletionService eacs = new ExecutorAllCompletionService(threadPool);
EntityManager em = emf.createEntityManager();
try {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<MetadataEntity> cq = cb.createQuery(MetadataEntity.class);
Root root = cq.from(MetadataEntity.class);
long currentTime = timeService.wallClockTime();
cq.where(cb.le(root.get(MetadataEntity.EXPIRATION), currentTime));
for (MetadataEntity metadata : em.createQuery(cq).getResultList()) {
EntityTransaction txn = em.getTransaction();
final Object key;
try {
key = marshaller.objectFromByteBuffer(metadata.name);
} catch (Exception e) {
throw new JpaStoreException("Cannot unmarshall key", e);
}
long txnBegin = timeService.time();
txn.begin();
try {
long metadataFindBegin = timeService.time();
metadata = em.find(MetadataEntity.class, metadata.name);
stats.addMetadataFind(timeService.time() - metadataFindBegin);
// check for transaction - I hope write skew check is done here
if (metadata.expiration > currentTime) {
txn.rollback();
continue;
}
long entityFindBegin = timeService.time();
Object entity = em.find(configuration.entityClass(), key);
stats.addEntityFind(timeService.time() - entityFindBegin);
if (entity != null) { // the entry may have been removed
long entityRemoveBegin = timeService.time();
em.remove(entity);
stats.addEntityRemove(timeService.time() - entityRemoveBegin);
}
long metadataRemoveBegin = timeService.time();
em.remove(metadata);
stats.addMetadataRemove(timeService.time() - metadataRemoveBegin);
txn.commit();
stats.addRemoveTxCommitted(timeService.time() - txnBegin);
if (trace) log.trace("Expired " + key + " -> " + entity + "(" + toString(metadata) + ")");
if (listener != null) {
eacs.submit(
new Runnable() {
@Override
public void run() {
listener.entryPurged(key);
}
},
null);
}
} catch (RuntimeException e) {
stats.addRemoveTxFailed(timeService.time() - txnBegin);
throw e;
} finally {
if (txn != null && txn.isActive()) {
txn.rollback();
}
}
}
} finally {
em.close();
}
eacs.waitUntilAllCompleted();
if (eacs.isExceptionThrown()) {
throw new JpaStoreException(eacs.getFirstException());
}
}
@Override
public void process(
KeyFilter filter,
final CacheLoaderTask task,
Executor executor,
boolean fetchValue,
final boolean fetchMetadata) {
ExecutorAllCompletionService eacs = new ExecutorAllCompletionService(executor);
final TaskContextImpl taskContext = new TaskContextImpl();
EntityManager em = emf.createEntityManager();
try {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery cq = cb.createQuery();
Root root = cq.from(configuration.entityClass());
Type idType = root.getModel().getIdType();
SingularAttribute idAttr = root.getModel().getId(idType.getJavaType());
cq.select(root.get(idAttr));
for (final Object key : em.createQuery(cq).getResultList()) {
if (taskContext.isStopped()) break;
if (filter != null && !filter.shouldLoadKey(key)) {
if (trace) log.trace("Key " + key + " filtered");
continue;
}
EntityTransaction txn = em.getTransaction();
Object tempEntity = null;
InternalMetadata tempMetadata = null;
boolean loaded = false;
txn.begin();
try {
do {
try {
tempEntity = fetchValue ? em.find(configuration.entityClass(), key) : null;
tempMetadata = fetchMetadata ? getMetadata(em, key) : null;
} finally {
try {
txn.commit();
loaded = true;
} catch (Exception e) {
log.trace("Failed to load once", e);
}
}
} while (!loaded);
} finally {
if (txn != null && txn.isActive()) txn.rollback();
}
final Object entity = tempEntity;
final InternalMetadata metadata = tempMetadata;
if (trace) log.trace("Processing " + key + " -> " + entity + "(" + metadata + ")");
if (metadata != null && metadata.isExpired(timeService.wallClockTime())) continue;
eacs.submit(
new Callable<Void>() {
@Override
public Void call() throws Exception {
try {
final MarshalledEntry marshalledEntry =
marshallerEntryFactory.newMarshalledEntry(key, entity, metadata);
if (marshalledEntry != null) {
task.processEntry(marshalledEntry, taskContext);
}
return null;
} catch (Exception e) {
log.errorExecutingParallelStoreTask(e);
throw e;
}
}
});
}
eacs.waitUntilAllCompleted();
if (eacs.isExceptionThrown()) {
throw new org.infinispan.persistence.spi.PersistenceException(
"Execution exception!", eacs.getFirstException());
}
} finally {
em.close();
}
}