org.hibernate.cache.infinispan.access.TombstoneCallInterceptor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of hibernate-infinispan
A module of the Hibernate Core project
There is a newer version: 5.6.15.Final
/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or .
 */
package org.hibernate.cache.infinispan.access;

import org.hibernate.cache.infinispan.impl.BaseTransactionalDataRegion;
import org.hibernate.cache.infinispan.util.FutureUpdate;
import org.hibernate.cache.infinispan.util.TombstoneUpdate;
import org.hibernate.cache.infinispan.util.Tombstone;
import org.infinispan.AdvancedCache;
import org.infinispan.commands.read.SizeCommand;
import org.infinispan.commands.write.PutKeyValueCommand;
import org.infinispan.commands.write.ValueMatcher;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.util.CloseableIterable;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.entries.MVCCEntry;
import org.infinispan.context.Flag;
import org.infinispan.context.InvocationContext;
import org.infinispan.factories.annotations.Inject;
import org.infinispan.factories.annotations.Start;
import org.infinispan.filter.NullValueConverter;
import org.infinispan.interceptors.CallInterceptor;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.metadata.Metadata;

import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * Note that this does not implement all commands, only those appropriate for {@link TombstoneAccessDelegate}
 * and {@link org.hibernate.cache.infinispan.impl.BaseTransactionalDataRegion}
 *
 * The behaviour here also breaks notifications, which are not used for 2LC caches.
 *
 * @author Radim Vansa <[email protected]>
 */
public class TombstoneCallInterceptor extends CallInterceptor {
	private static final Log log = LogFactory.getLog(TombstoneCallInterceptor.class);
	private static final UUID ZERO = new UUID(0, 0);

	private final BaseTransactionalDataRegion region;
	private final Metadata expiringMetadata;
	private Metadata defaultMetadata;
	private AdvancedCache cache;

	public TombstoneCallInterceptor(BaseTransactionalDataRegion region) {
		this.region = region;
		expiringMetadata = new EmbeddedMetadata.Builder().lifespan(region.getTombstoneExpiration(), TimeUnit.MILLISECONDS).build();
	}

	@Inject
	public void injectDependencies(AdvancedCache cache) {
		this.cache = cache;
	}

	@Start
	public void start() {
		defaultMetadata = new EmbeddedMetadata.Builder()
			.lifespan(cacheConfiguration.expiration().lifespan())
			.maxIdle(cacheConfiguration.expiration().maxIdle()).build();
	}

	@Override
	public Object visitPutKeyValueCommand(InvocationContext ctx, PutKeyValueCommand command) throws Throwable {
		MVCCEntry e = (MVCCEntry) ctx.lookupEntry(command.getKey());
		if (e == null) {
			return null;
		}
		log.tracef("In cache %s(%d) applying update %s to %s", cache.getName(), region.getLastRegionInvalidation(), command.getValue(), e.getValue());
		try {
			Object value = command.getValue();
			if (value instanceof TombstoneUpdate) {
				return handleTombstoneUpdate(e, (TombstoneUpdate) value, command);
			}
			else if (value instanceof Tombstone) {
				return handleTombstone(e, (Tombstone) value);
			}
			else if (value instanceof FutureUpdate) {
				return handleFutureUpdate(e, (FutureUpdate) value, command);
			}
			else {
				return super.visitPutKeyValueCommand(ctx, command);
			}
		}
		finally {
			log.tracef("Result is %s", e.getValue());
		}
	}

	private Object handleFutureUpdate(MVCCEntry e, FutureUpdate futureUpdate, PutKeyValueCommand command) {
		Object storedValue = e.getValue();
		if (storedValue instanceof Tombstone) {
			// Note that the update has to keep tombstone even if the transaction was unsuccessful;
			// before write we have removed the value and we have to protect the entry against stale putFromLoads
			Tombstone tombstone = (Tombstone) storedValue;
			setValue(e, tombstone.applyUpdate(futureUpdate.getUuid(), futureUpdate.getTimestamp(), futureUpdate.getValue()));

		}
		else {
			// This is an async future update, and it's timestamp may be vastly outdated
			// We need to first execute the async update and then local one, because if we're on the primary
			// owner the local future update would fail the async one.
			// TODO: There is some discrepancy with TombstoneUpdate handling which does not fail the update
			setFailed(command);
		}
		return null;
	}

	private Object handleTombstone(MVCCEntry e, Tombstone tombstone) {
		// Tombstones always come with lifespan in metadata
		Object storedValue = e.getValue();
		if (storedValue instanceof Tombstone) {
			setValue(e, ((Tombstone) storedValue).merge(tombstone));
		}
		else {
			setValue(e, tombstone);
		}
		return null;
	}

	protected Object handleTombstoneUpdate(MVCCEntry e, TombstoneUpdate tombstoneUpdate, PutKeyValueCommand command) {
		Object storedValue = e.getValue();
		Object value = tombstoneUpdate.getValue();

		if (value == null) {
			// eviction
			if (storedValue == null || storedValue instanceof Tombstone) {
				setFailed(command);
			}
			else {
				// We have to keep Tombstone, because otherwise putFromLoad could insert a stale entry
				// (after it has been already updated and *then* evicted)
				setValue(e, new Tombstone(ZERO, tombstoneUpdate.getTimestamp()));
			}
		}
		else if (storedValue instanceof Tombstone) {
			Tombstone tombstone = (Tombstone) storedValue;
			if (tombstone.getLastTimestamp() < tombstoneUpdate.getTimestamp()) {
				setValue(e, value);
			}
		}
		else if (storedValue == null) {
			// async putFromLoads shouldn't cross the invalidation timestamp
			if (region.getLastRegionInvalidation() < tombstoneUpdate.getTimestamp()) {
				setValue(e, value);
			}
		}
		else {
			// Don't do anything locally. This could be the async remote write, though, when local
			// value has been already updated: let it propagate to remote nodes, too
		}
		return null;
	}

	private Object setValue(MVCCEntry e, Object value) {
		if (e.isRemoved()) {
			e.setRemoved(false);
			e.setCreated(true);
			e.setValid(true);
		}
		else {
			e.setChanged(true);
		}
		if (value instanceof Tombstone) {
			e.setMetadata(expiringMetadata);
		}
		else {
			e.setMetadata(defaultMetadata);
		}
		return e.setValue(value);
	}

	private void setFailed(PutKeyValueCommand command) {
		// This sets command to be unsuccessful, since we don't want to replicate it to backup owner
		command.setValueMatcher(ValueMatcher.MATCH_NEVER);
		try {
			command.perform(null);
		}
		catch (Throwable ignored) {
		}
	}

	@Override
	public Object visitSizeCommand(InvocationContext ctx, SizeCommand command) throws Throwable {
		Set flags = command.getFlags();
		int size = 0;
		AdvancedCache decoratedCache = cache.getAdvancedCache();
		if (flags != null) {
			decoratedCache = decoratedCache.withFlags(flags.toArray(new Flag[flags.size()]));
		}
		// In non-transactional caches we don't care about context
		CloseableIterable> iterable = decoratedCache
				.filterEntries(Tombstone.EXCLUDE_TOMBSTONES).converter(NullValueConverter.getInstance());
		try {
			for (CacheEntry entry : iterable) {
				if (size++ == Integer.MAX_VALUE) {
					return Integer.MAX_VALUE;
				}
			}
		}
		finally {
			iterable.close();
		}
		return size;
	}
}