@Override
public void clear() {
EntityManager em = emf.createEntityManager();
EntityTransaction txn = em.getTransaction();
try {
// the clear operation often deadlocks - let's try several times
for (int i = 0; ; ++i) {
txn.begin();
try {
log.trace("Clearing JPA Store");
String entityTable = em.getMetamodel().entity(configuration.entityClass()).getName();
@SuppressWarnings("unchecked")
List<Object> items = em.createQuery("FROM " + entityTable).getResultList();
for (Object o : items) em.remove(o);
if (configuration.storeMetadata()) {
String metadataTable = em.getMetamodel().entity(MetadataEntity.class).getName();
Query clearMetadata = em.createQuery("DELETE FROM " + metadataTable);
clearMetadata.executeUpdate();
}
txn.commit();
em.clear();
break;
} catch (Exception e) {
log.trace("Failed to clear store", e);
if (i >= 10) throw new JpaStoreException("Exception caught in clear()", e);
} finally {
if (txn != null && txn.isActive()) txn.rollback();
}
}
} finally {
em.close();
}
}
public Xid[] recover(int flag) throws XAException {
if (!configuration.isTransactionRecoveryEnabled()) {
log.recoveryIgnored();
return RecoveryManager.RecoveryIterator.NOTHING;
}
if (trace) log.trace("recover called: " + flag);
if (isFlag(flag, TMSTARTRSCAN)) {
recoveryIterator = recoveryManager.getPreparedTransactionsFromCluster();
if (trace) log.tracef("Fetched a new recovery iterator: %s", recoveryIterator);
}
if (isFlag(flag, TMENDRSCAN)) {
if (trace) log.trace("Flushing the iterator");
return recoveryIterator.all();
} else {
// as per the spec: "TMNOFLAGS this flag must be used when no other flags are specified."
if (!isFlag(flag, TMSTARTRSCAN) && !isFlag(flag, TMNOFLAGS))
throw new IllegalArgumentException(
"TMNOFLAGS this flag must be used when no other flags are specified."
+ " Received "
+ flag);
return recoveryIterator.hasNext()
? recoveryIterator.next()
: RecoveryManager.RecoveryIterator.NOTHING;
}
}
public void commit(Xid xid, boolean isOnePhase) throws XAException {
// always call prepare() - even if this is just a 1PC!
if (isOnePhase) prepare(xid);
if (trace) log.trace("committing TransactionXaAdapter: " + globalTx);
try {
LocalTxInvocationContext ctx = icc.createTxInvocationContext();
ctx.setXaCache(this);
if (configuration.isOnePhaseCommit()) {
checkMarkedForRollback();
if (trace) log.trace("Doing an 1PC prepare call on the interceptor chain");
PrepareCommand command = commandsFactory.buildPrepareCommand(globalTx, modifications, true);
try {
invoker.invoke(ctx, command);
} catch (Throwable e) {
log.error("Error while processing 1PC PrepareCommand", e);
throw new XAException(XAException.XAER_RMERR);
}
} else {
CommitCommand commitCommand = commandsFactory.buildCommitCommand(globalTx);
try {
invoker.invoke(ctx, commitCommand);
} catch (Throwable e) {
log.error("Error while processing 1PC PrepareCommand", e);
throw new XAException(XAException.XAER_RMERR);
}
}
} finally {
txTable.removeLocalTransaction(transaction);
this.modifications = null;
}
}
/**
* Method that skips invocation if: - No store defined or, - The context contains
* Flag.SKIP_CACHE_STORE or,
*/
@Override
protected boolean skip(InvocationContext ctx, FlagAffectedCommand command) {
if (skip(ctx)) return true;
if (command.hasFlag(Flag.SKIP_CACHE_STORE)) {
log.trace("Skipping cache store since the call contain a skip cache store flag");
return true;
}
if (loaderConfig.shared() && command.hasFlag(Flag.SKIP_SHARED_CACHE_STORE)) {
log.trace(
"Skipping cache store since it is shared and the call contain a skip shared cache store flag");
}
return false;
}
@Override
public String[] getChildrenNames(ITransaction transaction, String uri) throws WebdavException {
uri = normalizeURI(uri);
log.tracef("GridStore.getChildrenNames(%s)", uri);
File file = fs.getFile(root, uri);
try {
String[] childrenNames = null;
if (file.isDirectory()) {
File[] children = file.listFiles();
if (children == null) throw new WebdavException("IO error while listing files for " + file);
List<String> childList = new ArrayList<String>();
for (int i = 0; i < children.length; i++) {
String name = children[i].getName();
childList.add(name);
log.trace("Child " + i + ": " + name);
}
childrenNames = new String[childList.size()];
childrenNames = childList.toArray(childrenNames);
}
return childrenNames;
} catch (Exception e) {
log.error("GridStore.getChildrenNames(" + uri + ") failed", e);
throw new WebdavException(e);
}
}
protected void updateStateOnNodesLeaving(Collection<Address> leavers) {
Set<GlobalTransaction> toKill = new HashSet<GlobalTransaction>();
for (GlobalTransaction gt : remoteTransactions.keySet()) {
if (leavers.contains(gt.getAddress())) toKill.add(gt);
}
if (toKill.isEmpty())
log.tracef(
"No global transactions pertain to originator(s) %s who have left the cluster.", leavers);
else
log.tracef(
"%s global transactions pertain to leavers list %s and need to be killed",
toKill.size(), leavers);
for (GlobalTransaction gtx : toKill) {
log.tracef("Killing remote transaction originating on leaver %s", gtx);
RollbackCommand rc = new RollbackCommand(cacheName, gtx);
rc.init(invoker, icc, TransactionTable.this);
try {
rc.perform(null);
log.tracef("Rollback of transaction %s complete.", gtx);
} catch (Throwable e) {
log.unableToRollbackGlobalTx(gtx, e);
}
}
log.trace("Completed cleaning transactions originating on leavers");
}
private boolean isPutForExternalRead(FlagAffectedCommand command) {
if (command.hasFlag(Flag.PUT_FOR_EXTERNAL_READ)) {
log.trace("Put for external read called. Suppressing clustered invalidation.");
return true;
}
return false;
}
private void tryRollback() {
try {
if (transactionManager != null) transactionManager.rollback();
} catch (Throwable t) {
if (trace) log.trace("Could not rollback", t); // best effort
}
}
public void addModification(WriteCommand mod) {
if (trace) log.trace("Adding modification {0}. Mod list is {1}", mod, modifications);
if (modifications == null) {
modifications = new ArrayList<WriteCommand>(8);
}
modifications.add(mod);
}
/**
* If this is a transactional cache and autoCommit is set to true then starts a transaction if
* this is not a transactional call.
*/
private InvocationContext getInvocationContextWithImplicitTransaction(
EnumSet<Flag> explicitFlags, ClassLoader explicitClassLoader) {
InvocationContext invocationContext;
boolean txInjected = false;
if (config.isTransactionalCache()) {
Transaction transaction = getOngoingTransaction();
if (transaction == null && config.isTransactionAutoCommit()) {
try {
transactionManager.begin();
transaction = transactionManager.getTransaction();
txInjected = true;
if (trace) log.trace("Implicit transaction started!");
} catch (Exception e) {
throw new CacheException("Could not start transaction", e);
}
}
invocationContext = getInvocationContext(transaction, explicitFlags, explicitClassLoader);
} else {
invocationContext = getInvocationContextForWrite(explicitFlags, explicitClassLoader);
}
if (txInjected) {
((TxInvocationContext) invocationContext).setImplicitTransaction(true);
if (trace) log.tracef("Marked tx as implicit.");
}
return invocationContext;
}
@Override
protected final Transaction suspendIfNeeded() {
if (transactionManager == null) {
return null;
}
try {
switch (transactionManager.getStatus()) {
case Status.STATUS_ACTIVE:
case Status.STATUS_NO_TRANSACTION:
return null;
case Status.STATUS_MARKED_ROLLBACK:
case Status.STATUS_PREPARED:
case Status.STATUS_COMMITTED:
case Status.STATUS_ROLLEDBACK:
case Status.STATUS_UNKNOWN:
case Status.STATUS_PREPARING:
case Status.STATUS_COMMITTING:
case Status.STATUS_ROLLING_BACK:
default:
// suspend in default and in unknown status to be safer
return transactionManager.suspend();
}
} catch (Exception e) {
if (log.isTraceEnabled()) {
log.trace("An error occurred while trying to suspend a transaction.", e);
}
return null;
}
}
private boolean isPutForExternalRead(InvocationContext ctx) {
if (ctx.hasFlag(Flag.PUT_FOR_EXTERNAL_READ)) {
log.trace("Put for external read called. Suppressing clustered invalidation.");
return true;
}
return false;
}
public NotifyingNotifiableFuture<Object> flushCache(
Collection<Object> keys, Object retval, Address origin) {
if (trace) log.tracef("Invalidating L1 caches for keys %s", keys);
NotifyingNotifiableFuture<Object> future = new AggregatingNotifyingFutureImpl(retval, 2);
Collection<Address> invalidationAddresses = buildInvalidationAddressList(keys, origin);
int nodes = invalidationAddresses.size();
if (nodes > 0) {
// No need to invalidate at all if there is no one to invalidate!
boolean multicast = isUseMulticast(nodes);
if (trace)
log.tracef(
"There are %s nodes involved in invalidation. Threshold is: %s; using multicast: %s",
nodes, threshold, multicast);
if (multicast) {
if (trace) log.tracef("Invalidating keys %s via multicast", keys);
InvalidateCommand ic = commandsFactory.buildInvalidateFromL1Command(origin, false, keys);
rpcManager.broadcastRpcCommandInFuture(ic, future);
} else {
InvalidateCommand ic = commandsFactory.buildInvalidateFromL1Command(origin, false, keys);
// Ask the caches who have requested from us to remove
if (trace) log.tracef("Keys %s needs invalidation on %s", keys, invalidationAddresses);
rpcManager.invokeRemotelyInFuture(
invalidationAddresses, ic, true, future, rpcTimeout, true);
return future;
}
} else if (trace) log.trace("No L1 caches to invalidate");
return future;
}
public static void waitForRehashToComplete(Cache... caches) {
// give it 1 second to start rehashing
// TODO Should look at the last committed view instead and check if it contains all the caches
LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
int gracetime = 30000; // 30 seconds?
long giveup = System.currentTimeMillis() + gracetime;
for (Cache c : caches) {
CacheViewsManager cacheViewsManager =
TestingUtil.extractGlobalComponent(c.getCacheManager(), CacheViewsManager.class);
RpcManager rpcManager = TestingUtil.extractComponent(c, RpcManager.class);
while (cacheViewsManager.getCommittedView(c.getName()).getMembers().size() != caches.length) {
if (System.currentTimeMillis() > giveup) {
String message =
String.format(
"Timed out waiting for rehash to complete on node %s, expected member list is %s, current member list is %s!",
rpcManager.getAddress(),
Arrays.toString(caches),
cacheViewsManager.getCommittedView(c.getName()));
log.error(message);
throw new RuntimeException(message);
}
LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
}
log.trace("Node " + rpcManager.getAddress() + " finished rehash task.");
}
}
@Override
public Object perform(InvocationContext ctx) throws Throwable {
// It's not worth looking up the entry if we're never going to apply the change.
if (valueMatcher == ValueMatcher.MATCH_NEVER) {
successful = false;
return null;
}
MVCCEntry e = (MVCCEntry) ctx.lookupEntry(key);
if (e == null || e.isNull() || e.isRemoved()) {
nonExistent = true;
if (valueMatcher.matches(e, value, null, valueEquivalence)) {
if (e != null) {
e.setChanged(true);
e.setRemoved(true);
}
return isConditional() ? true : null;
} else {
log.trace("Nothing to remove since the entry doesn't exist in the context or it is null");
successful = false;
return false;
}
}
if (!valueMatcher.matches(e, value, null, valueEquivalence)) {
successful = false;
return false;
}
if (this instanceof EvictCommand) {
e.setEvicted(true);
}
return performRemove(e, ctx);
}
@Override
public boolean contains(Object key) {
if (!isValidKeyType(key)) {
return false;
}
EntityManager em = emf.createEntityManager();
try {
EntityTransaction txn = em.getTransaction();
long txnBegin = timeService.time();
txn.begin();
try {
long entityFindBegin = timeService.time();
Object entity = em.find(configuration.entityClass(), key);
stats.addEntityFind(timeService.time() - entityFindBegin);
if (trace) log.trace("Entity " + key + " -> " + entity);
try {
if (entity == null) return false;
if (configuration.storeMetadata()) {
byte[] keyBytes;
try {
keyBytes = marshaller.objectToByteBuffer(key);
} catch (Exception e) {
throw new JpaStoreException("Cannot marshall key", e);
}
long metadataFindBegin = timeService.time();
MetadataEntity metadata = em.find(MetadataEntity.class, keyBytes);
stats.addMetadataFind(timeService.time() - metadataFindBegin);
if (trace) log.trace("Metadata " + key + " -> " + toString(metadata));
return metadata == null || metadata.expiration > timeService.wallClockTime();
} else {
return true;
}
} finally {
txn.commit();
stats.addReadTxCommitted(timeService.time() - txnBegin);
}
} catch (RuntimeException e) {
stats.addReadTxFailed(timeService.time() - txnBegin);
throw e;
} finally {
if (txn != null && txn.isActive()) txn.rollback();
}
} finally {
em.close();
}
}
public void finishObjectOutput(ObjectOutput oo) {
try {
if (log.isTraceEnabled()) log.trace("Stop marshaller");
((org.jboss.marshalling.Marshaller) oo).finish();
} catch (IOException ignored) {
}
}
public void finishObjectInput(ObjectInput oi) {
try {
if (log.isTraceEnabled()) log.trace("Stop unmarshaller");
if (oi != null) ((Unmarshaller) oi).finish();
} catch (IOException ignored) {
}
}
public void invokeRemotelyInFuture(
Collection<Address> recipients,
ReplicableCommand rpc,
NotifyingNotifiableFuture<Object> future) {
log.trace("ControlledRpcManager.invokeRemotelyInFuture1");
aboutToInvokeRpc(rpc);
realOne.invokeRemotelyInFuture(recipients, rpc, future);
}
public void broadcastRpcCommandInFuture(
ReplicableCommand rpcCommand, NotifyingNotifiableFuture<Object> future) {
log.trace("ControlledRpcManager.broadcastRpcCommandInFuture1");
failIfNeeded(rpcCommand);
waitBefore(rpcCommand);
realOne.broadcastRpcCommandInFuture(rpcCommand, future);
waitAfter(rpcCommand);
}
public void broadcastRpcCommand(ReplicableCommand rpcCommand, boolean sync, boolean totalOrder)
throws RpcException {
log.trace("ControlledRpcManager.broadcastRpcCommand1");
failIfNeeded(rpcCommand);
waitBefore(rpcCommand);
realOne.broadcastRpcCommand(rpcCommand, sync, totalOrder);
waitAfter(rpcCommand);
}
@Override
public AtomicHashMapDelta readObject(ObjectInput input)
throws IOException, ClassNotFoundException {
AtomicHashMapDelta delta = new AtomicHashMapDelta();
delta.changeLog = (List<Operation>) input.readObject();
if (trace) log.trace("Deserialized changeLog " + delta.changeLog);
return delta;
}
private void logAfter(Connection connection, boolean checkout) {
if (log.isTraceEnabled()) {
String operation = checkout ? "checkout" : "release";
try {
log.trace(
"DataSource after "
+ operation
+ " (NumBusyConnectionsAllUsers) : "
+ pooledDataSource.getNumBusyConnectionsAllUsers()
+ ", (NumConnectionsAllUsers) : "
+ pooledDataSource.getNumConnectionsAllUsers());
} catch (SQLException e) {
log.warn("Unexpected", e);
}
log.trace("Connection " + operation + " : " + connection);
}
}
@Stop(priority = 13) // Stop after global marshaller
public void stop() {
started = false;
writers.clear();
readers.clear();
log.trace(
"Externalizer reader and writer maps have been cleared and constant object table was stopped");
}
@Override
public void write(MarshalledEntry entry) {
EntityManager em = emf.createEntityManager();
Object entity = entry.getValue();
MetadataEntity metadata =
configuration.storeMetadata()
? new MetadataEntity(
entry.getKeyBytes(),
entry.getMetadataBytes(),
entry.getMetadata() == null ? Long.MAX_VALUE : entry.getMetadata().expiryTime())
: null;
try {
if (!configuration.entityClass().isAssignableFrom(entity.getClass())) {
throw new JpaStoreException(
String.format(
"This cache is configured with JPA CacheStore to only store values of type %s - cannot write %s = %s",
configuration.entityClass().getName(), entity, entity.getClass().getName()));
} else {
EntityTransaction txn = em.getTransaction();
Object id = emf.getPersistenceUnitUtil().getIdentifier(entity);
if (!entry.getKey().equals(id)) {
throw new JpaStoreException(
"Entity id value must equal to key of cache entry: "
+ "key = ["
+ entry.getKey()
+ "], id = ["
+ id
+ "]");
}
long txnBegin = timeService.time();
try {
if (trace) log.trace("Writing " + entity + "(" + toString(metadata) + ")");
txn.begin();
long entityMergeBegin = timeService.time();
em.merge(entity);
stats.addEntityMerge(timeService.time() - entityMergeBegin);
if (metadata != null && metadata.hasBytes()) {
long metadataMergeBegin = timeService.time();
em.merge(metadata);
stats.addMetadataMerge(timeService.time() - metadataMergeBegin);
}
txn.commit();
stats.addWriteTxCommited(timeService.time() - txnBegin);
} catch (Exception e) {
stats.addWriteTxFailed(timeService.time() - txnBegin);
throw new JpaStoreException("Exception caught in write()", e);
} finally {
if (txn != null && txn.isActive()) txn.rollback();
}
}
} finally {
em.close();
}
}
@Override
public MarshalledEntry load(Object key) {
if (!isValidKeyType(key)) {
return null;
}
EntityManager em = emf.createEntityManager();
try {
EntityTransaction txn = em.getTransaction();
long txnBegin = timeService.time();
txn.begin();
try {
long entityFindBegin = timeService.time();
Object entity = em.find(configuration.entityClass(), key);
stats.addEntityFind(timeService.time() - entityFindBegin);
try {
if (entity == null) return null;
InternalMetadata m = null;
if (configuration.storeMetadata()) {
byte[] keyBytes;
try {
keyBytes = marshaller.objectToByteBuffer(key);
} catch (Exception e) {
throw new JpaStoreException("Failed to marshall key", e);
}
long metadataFindBegin = timeService.time();
MetadataEntity metadata = em.find(MetadataEntity.class, keyBytes);
stats.addMetadataFind(timeService.time() - metadataFindBegin);
if (metadata != null && metadata.getMetadata() != null) {
try {
m = (InternalMetadata) marshaller.objectFromByteBuffer(metadata.getMetadata());
} catch (Exception e) {
throw new JpaStoreException("Failed to unmarshall metadata", e);
}
if (m.isExpired(timeService.wallClockTime())) {
return null;
}
}
}
if (trace) log.trace("Loaded " + entity + " (" + m + ")");
return marshallerEntryFactory.newMarshalledEntry(key, entity, m);
} finally {
try {
txn.commit();
stats.addReadTxCommitted(timeService.time() - txnBegin);
} catch (Exception e) {
stats.addReadTxFailed(timeService.time() - txnBegin);
throw new JpaStoreException("Failed to load entry", e);
}
}
} finally {
if (txn != null && txn.isActive()) txn.rollback();
}
} finally {
em.close();
}
}
private String toString(MetadataEntity metadata) {
if (metadata == null || !metadata.hasBytes()) return "<no metadata>";
try {
return marshaller.objectFromByteBuffer(metadata.getMetadata()).toString();
} catch (Exception e) {
log.trace("Failed to unmarshall metadata", e);
return "<metadata: " + e + ">";
}
}
public Map<Address, Response> invokeRemotely(
Collection<Address> recipients,
ReplicableCommand rpcCommand,
ResponseMode mode,
long timeout) {
log.trace("invokeRemotely3");
aboutToInvokeRpc(rpcCommand);
return realOne.invokeRemotely(recipients, rpcCommand, mode, timeout);
}
/**
* Method that skips invocation if: - The store is a shared one and node storing the key is not
* the 1st owner of the key or, - This is an L1 put operation.
*/
@Override
protected boolean skipKey(Object key) {
if (loaderConfig.shared()) {
if (!dm.getPrimaryLocation(key).equals(address)) {
log.trace(
"Skipping cache store since the cache loader is shared "
+ "and the caller is not the first owner of the key");
return true;
}
} else {
List<Address> addresses = dm.locate(key);
if (isL1Put(addresses)) {
log.trace("Skipping cache store since this is an L1 put");
return true;
}
}
return false;
}
@Override
public String readString() {
byte[] strContent = readArray();
String readString = new String(strContent, HotRodConstants.HOTROD_STRING_CHARSET);
if (log.isTraceEnabled()) {
log.trace("Read string is: " + readString);
}
return readString;
}