Examples with VersionedEntry org.hibernate.cache.infinispan.util.VersionedEntry used on opensource projects

Example 1 with VersionedEntry

use of org.hibernate.cache.infinispan.util.VersionedEntry in project hibernate-orm by hibernate.

the class VersionedTest method testCollectionUpdate.

@Test
public void testCollectionUpdate() throws Exception {
    // the first insert puts VersionedEntry(null, null, timestamp), so we have to wait a while to cache the entry
    TIME_SERVICE.advance(1);
    withTxSession(s -> {
        Item item = s.load(Item.class, itemId);
        OtherItem otherItem = new OtherItem();
        otherItem.setName("Other 1");
        s.persist(otherItem);
        item.addOtherItem(otherItem);
    });
    withTxSession(s -> {
        Item item = s.load(Item.class, itemId);
        Set<OtherItem> otherItems = item.getOtherItems();
        assertFalse(otherItems.isEmpty());
        otherItems.remove(otherItems.iterator().next());
    });
    AdvancedCache collectionCache = ((BaseTransactionalDataRegion) sessionFactory().getSecondLevelCacheRegion(Item.class.getName() + ".otherItems")).getCache();
    CountDownLatch putFromLoadLatch = new CountDownLatch(1);
    AtomicBoolean committing = new AtomicBoolean(false);
    CollectionUpdateTestInterceptor collectionUpdateTestInterceptor = new CollectionUpdateTestInterceptor(putFromLoadLatch);
    AnotherCollectionUpdateTestInterceptor anotherInterceptor = new AnotherCollectionUpdateTestInterceptor(putFromLoadLatch, committing);
    collectionCache.addInterceptor(collectionUpdateTestInterceptor, collectionCache.getInterceptorChain().size() - 1);
    collectionCache.addInterceptor(anotherInterceptor, 0);
    TIME_SERVICE.advance(1);
    Future<Boolean> addFuture = executor.submit(() -> withTxSessionApply(s -> {
        collectionUpdateTestInterceptor.updateLatch.await();
        Item item = s.load(Item.class, itemId);
        OtherItem otherItem = new OtherItem();
        otherItem.setName("Other 2");
        s.persist(otherItem);
        item.addOtherItem(otherItem);
        committing.set(true);
        return true;
    }));
    Future<Boolean> readFuture = executor.submit(() -> withTxSessionApply(s -> {
        Item item = s.load(Item.class, itemId);
        assertTrue(item.getOtherItems().isEmpty());
        return true;
    }));
    addFuture.get();
    readFuture.get();
    collectionCache.removeInterceptor(CollectionUpdateTestInterceptor.class);
    collectionCache.removeInterceptor(AnotherCollectionUpdateTestInterceptor.class);
    withTxSession(s -> assertFalse(s.load(Item.class, itemId).getOtherItems().isEmpty()));
}

Example 2 with VersionedEntry

use of org.hibernate.cache.infinispan.util.VersionedEntry in project hibernate-orm by hibernate.

the class NonStrictAccessDelegate method putFromLoad.

@Override
public boolean putFromLoad(SharedSessionContractImplementor session, Object key, Object value, long txTimestamp, Object version, boolean minimalPutOverride) throws CacheException {
    long lastRegionInvalidation = region.getLastRegionInvalidation();
    if (txTimestamp < lastRegionInvalidation) {
        log.tracef("putFromLoad not executed since tx started at %d, before last region invalidation finished = %d", txTimestamp, lastRegionInvalidation);
        return false;
    }
    assert version != null;
    if (minimalPutOverride) {
        Object prev = cache.get(key);
        if (prev != null) {
            Object oldVersion = getVersion(prev);
            if (oldVersion != null) {
                if (versionComparator.compare(version, oldVersion) <= 0) {
                    if (trace) {
                        log.tracef("putFromLoad not executed since version(%s) <= oldVersion(%s)", version, oldVersion);
                    }
                    return false;
                }
            } else if (prev instanceof VersionedEntry && txTimestamp <= ((VersionedEntry) prev).getTimestamp()) {
                if (trace) {
                    log.tracef("putFromLoad not executed since tx started at %d and entry was invalidated at %d", txTimestamp, ((VersionedEntry) prev).getTimestamp());
                }
                return false;
            }
        }
    }
    // we can't use putForExternalRead since the PFER flag means that entry is not wrapped into context
    // when it is present in the container. TombstoneCallInterceptor will deal with this.
    // Even if value is instanceof CacheEntry, we have to wrap it in VersionedEntry and add transaction timestamp.
    // Otherwise, old eviction record wouldn't be overwritten.
    putFromLoadCache.put(key, new VersionedEntry(value, version, txTimestamp));
    return true;
}

Example 3 with VersionedEntry

use of org.hibernate.cache.infinispan.util.VersionedEntry in project hibernate-orm by hibernate.

the class VersionedCallInterceptor method visitPutKeyValueCommand.

@Override
public Object visitPutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand command) throws Throwable {
    MVCCEntry e = (MVCCEntry) ctx.lookupEntry(command.getKey());
    if (e == null) {
        return null;
    }
    Object oldValue = e.getValue();
    Object oldVersion = null;
    long oldTimestamp = Long.MIN_VALUE;
    if (oldValue instanceof VersionedEntry) {
        oldVersion = ((VersionedEntry) oldValue).getVersion();
        oldTimestamp = ((VersionedEntry) oldValue).getTimestamp();
        oldValue = ((VersionedEntry) oldValue).getValue();
    } else if (oldValue instanceof org.hibernate.cache.spi.entry.CacheEntry) {
        oldVersion = ((org.hibernate.cache.spi.entry.CacheEntry) oldValue).getVersion();
    }
    Object newValue = command.getValue();
    Object newVersion;
    long newTimestamp;
    Object actualNewValue = newValue;
    boolean isRemoval = false;
    if (newValue instanceof VersionedEntry) {
        VersionedEntry ve = (VersionedEntry) newValue;
        newVersion = ve.getVersion();
        newTimestamp = ve.getTimestamp();
        if (ve.getValue() == null) {
            isRemoval = true;
        } else if (ve.getValue() instanceof org.hibernate.cache.spi.entry.CacheEntry) {
            actualNewValue = ve.getValue();
        }
    } else {
        throw new IllegalArgumentException(String.valueOf(newValue));
    }
    if (newVersion == null) {
        // eviction or post-commit removal: we'll store it with given timestamp
        setValue(e, newValue, expiringMetadata);
        return null;
    }
    if (oldVersion == null) {
        assert oldValue == null || oldTimestamp != Long.MIN_VALUE;
        if (newTimestamp <= oldTimestamp) {
            // the invalid value
            assert oldValue == null;
        } else {
            setValue(e, actualNewValue, defaultMetadata);
        }
        return null;
    }
    int compareResult = versionComparator.compare(newVersion, oldVersion);
    if (isRemoval && compareResult >= 0) {
        setValue(e, actualNewValue, expiringMetadata);
    } else if (compareResult > 0) {
        setValue(e, actualNewValue, defaultMetadata);
    }
    return null;
}

Example 4 with VersionedEntry

use of org.hibernate.cache.infinispan.util.VersionedEntry in project hibernate-orm by hibernate.

the class BaseTransactionalDataRegion method removeEntries.

private void removeEntries(boolean inTransaction, KeyValueFilter filter) {
    // If the transaction is required, we simply need it -> will create our own
    boolean startedTx = false;
    if (!inTransaction && requiresTransaction) {
        try {
            tm.begin();
            startedTx = true;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    // We can never use cache.clear() since tombstones must be kept.
    try {
        AdvancedCache localCache = Caches.localCache(cache);
        CloseableIterator<CacheEntry> it = Caches.entrySet(localCache, Tombstone.EXCLUDE_TOMBSTONES).iterator();
        long now = nextTimestamp();
        try {
            while (it.hasNext()) {
                // Cannot use it.next(); it.remove() due to ISPN-5653
                CacheEntry entry = it.next();
                switch(strategy) {
                    case TOMBSTONES:
                        localCache.remove(entry.getKey(), entry.getValue());
                        break;
                    case VERSIONED_ENTRIES:
                        localCache.put(entry.getKey(), new VersionedEntry(null, null, now), tombstoneExpiration, TimeUnit.MILLISECONDS);
                        break;
                }
            }
        } finally {
            it.close();
        }
    } finally {
        if (startedTx) {
            try {
                tm.commit();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}