package org.infinispan.transaction.xa;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import org.infinispan.commands.write.WriteCommand;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.entries.MVCCEntry;
import org.infinispan.container.versioning.EntryVersion;
import org.infinispan.container.versioning.EntryVersionsMap;
import org.infinispan.context.InvocationContext;
import org.infinispan.util.KeyValuePair;
/**
* Defines the state a infinispan transaction should have.
*
* @author Mircea.Markus@jboss.com
* @since 4.0
*/
public interface CacheTransaction {
/**
* Returns the transaction identifier.
*/
GlobalTransaction getGlobalTransaction();
/**
* Returns the modifications visible within the current transaction. Any modifications using Flag#CACHE_MODE_LOCAL are excluded.
* The returned list is never null.
*/
List<WriteCommand> getModifications();
/**
* Returns all the modifications visible within the current transaction, including those using Flag#CACHE_MODE_LOCAL.
* The returned list is never null.
*/
List<WriteCommand> getAllModifications();
/**
* Checks if a modification of the given class (or subclass) is present in this transaction. Any modifications using Flag#CACHE_MODE_LOCAL are ignored.
*
* @param modificationClass the modification type to look for
* @return true if found, false otherwise
*/
boolean hasModification(Class<?> modificationClass);
CacheEntry lookupEntry(Object key);
Map<Object, CacheEntry> getLookedUpEntries();
void putLookedUpEntry(Object key, CacheEntry e);
void putLookedUpEntries(Map<Object, CacheEntry> entries);
void removeLookedUpEntry(Object key);
void clearLookedUpEntries();
boolean ownsLock(Object key);
void clearLockedKeys();
Set<Object> getLockedKeys();
int getTopologyId();
Set<Object> getBackupLockedKeys();
void addBackupLockForKey(Object key);
/**
* @see org.infinispan.interceptors.locking.AbstractTxLockingInterceptor#checkPendingAndLockKey(InvocationContext, Object, long)
*/
void notifyOnTransactionFinished();
/**
* Checks if this transaction holds a lock on the given key and then waits until the transaction completes or until
* the timeout expires and returns <code>true</code> if the transaction is complete or <code>false</code> otherwise.
* If the key is not locked or if the transaction is already completed it returns <code>true</code> immediately.
* <p/>
* This method is subject to spurious returns in a way similar to {@link java.lang.Object#wait()}. It can sometimes return
* before the specified time has elapsed and without guaranteeing that this transaction is complete. The caller is
* responsible to call the method again if transaction completion was not reached and the time budget was not spent.
*
* @see org.infinispan.interceptors.locking.AbstractTxLockingInterceptor#checkPendingAndLockKey(InvocationContext, Object, long)
*/
@Deprecated
boolean waitForLockRelease(long lockAcquisitionTimeout) throws InterruptedException;
@Deprecated
boolean containsLockOrBackupLock(Object key);
@Deprecated
Object findAnyLockedOrBackupLocked(Collection<Object> keys);
@Deprecated
boolean areLocksReleased();
EntryVersionsMap getUpdatedEntryVersions();
void setUpdatedEntryVersions(EntryVersionsMap updatedEntryVersions);
/**
* @deprecated since 9.0
*/
@Deprecated
default void putLookedUpRemoteVersion(Object key, EntryVersion version) {}
/**
* @deprecated since 9.0
*/
@Deprecated
default EntryVersion getLookedUpRemoteVersion(Object key) { return null; }
/**
* @deprecated since 9.1 Use {@link MVCCEntry#isRead()} instead
*/
@Deprecated
boolean keyRead(Object key);
/**
* @deprecated since 9.1 Use {@link MVCCEntry#setRead()} instead
*/
@Deprecated
void addReadKey(Object key);
boolean isMarkedForRollback();
void markForRollback(boolean markForRollback);
/**
* Sets the version read for this key. The version is only set at the first time, i.e. multiple invocation of this
* method will not change the state.
* <p/>
* Note: used in Repeatable Read + Write Skew + Clustering + Versioning.
*/
void addVersionRead(Object key, EntryVersion version);
/**
* Sets the version read fr this key, replacing the old version if it exists, i.e each invocation updates the version
* of the key. This method is used when a remote get is performed for the key.
* <p/>
* Note: used in Repeatable Read + Write Skew + Clustering + Versioning.
* @deprecated since 9.0
*/
@Deprecated
default void replaceVersionRead(Object key, EntryVersion version) { addVersionRead(key, version);}
/**
* Note: used in Repeatable Read + Write Skew + Clustering + Versioning.
*
* @return a non-null map between key and version. The map represents the version read for that key. If no version
* exists, the key has not been read.
*/
EntryVersionsMap getVersionsRead();
long getCreationTime();
void addListener(TransactionCompletedListener listener);
interface TransactionCompletedListener {
void onCompletion();
}
/**
* Prevent new modifications after prepare or commit started.
*/
void freezeModifications();
/**
* It returns a {@link CompletableFuture} that completes when the lock for the {@code key} is released.
*
* If the {@code key} is not locked by this transaction, it returns {@code null}.
*
* @param key the key.
* @return the {@link CompletableFuture} or {@link null} if the key is not locked by this transaction.
*/
CompletableFuture<Void> getReleaseFutureForKey(Object key);
/**
* Same as {@link #getReleaseFutureForKey(Object)} but it returns a pair with the key and the future.
*/
KeyValuePair<Object, CompletableFuture<Void>> getReleaseFutureForKeys(Collection<Object> keys);
/**
* It cleans up the backup locks for this transaction.
*/
void cleanupBackupLocks();
}