@Test(expected = PrimaryBucketException.class) public void lockedKeysAreRemoved() throws Exception { RemoveAllPRMessage message = spy(new RemoveAllPRMessage(bucketId, 1, false, false, true, null)); message.addEntry(entryData); doReturn(keys).when(message).getKeysToBeLocked(); when(bucketRegion.waitUntilLocked(keys)).thenReturn(true); when(bucketRegion.doLockForPrimary(false)).thenThrow(new PrimaryBucketException()); message.doLocalRemoveAll(partitionedRegion, mock(InternalDistributedMember.class), true); verify(bucketRegion).removeAndNotifyKeys(eq(keys)); }
@Override protected boolean mayAddToMultipleSerialGateways(ClusterDistributionManager dm) { return _mayAddToMultipleSerialGateways(dm); }
@Test public void shouldBeMockable() throws Exception { RemoveAllPRMessage mockRemoveAllPRMessage = mock(RemoveAllPRMessage.class); StringBuilder stringBuilder = new StringBuilder(); mockRemoveAllPRMessage.appendFields(stringBuilder); verify(mockRemoveAllPRMessage, times(1)).appendFields(stringBuilder); }
/** * This method is called upon receipt and make the desired changes to the PartitionedRegion Note: * It is very important that this message does NOT cause any deadlocks as the sender will wait * indefinitely for the acknowledgement */ @Override protected boolean operateOnPartitionedRegion(ClusterDistributionManager dm, PartitionedRegion r, long startTime) throws EntryExistsException, ForceReattemptException, DataLocationException { boolean sendReply = true; InternalDistributedMember eventSender = getSender(); try { result = doLocalRemoveAll(r, eventSender, true); } catch (ForceReattemptException fre) { sendReply(getSender(), getProcessorId(), dm, new ReplyException(fre), r, startTime); return false; } if (sendReply) { sendReply(getSender(), getProcessorId(), dm, null, r, startTime); } return false; }
/** * Create RemoveAllPRMessage for notify only (to adjunct nodes) * * @param bucketId create message to send to this bucket */ public RemoveAllPRMessage createPRMessagesNotifyOnly(int bucketId) { final EntryEventImpl event = getBaseEvent(); RemoveAllPRMessage prMsg = new RemoveAllPRMessage(bucketId, removeAllDataSize, true, event.isPossibleDuplicate(), !event.isGenerateCallbacks(), event.getCallbackArgument()); if (event.getContext() != null) { prMsg.setBridgeContext(event.getContext()); } // will not recover event id here for (int i = 0; i < removeAllDataSize; i++) { prMsg.addEntry(removeAllData[i]); } return prMsg; }
RemoveAllPRMessage prMsg = prMsgMap.get(bucketId); if (prMsg == null) { prMsg = new RemoveAllPRMessage(bucketId.intValue(), removeAllDataSize, false, event.isPossibleDuplicate(), !event.isGenerateCallbacks(), event.getCallbackArgument()); prMsg .setTransactionDistributed(event.getRegion().getCache().getTxManager().isDistributed()); prMsg.setBridgeContext(event.getContext()); prMsg.addEntry(removeAllData[i]); prMsgMap.put(bucketId, prMsg);
prMsg.initMessage(this, null, false, null); putResult = prMsg.doLocalRemoveAll(this, this.getDistributionManager().getDistributionManagerId(), true); versions = prMsg.getVersions(); } else { RemoveAllPRMessage.RemoveAllResponse response = (RemoveAllPRMessage.RemoveAllResponse) prMsg.send(currentTarget, this); RemoveAllPRMessage.RemoveAllResult pr = null; if (response != null) {
Object[] keys = getKeysToBeLocked(); EntryEventImpl ev = getEventFromEntry(r, myId, eventSender, i, removeAllPRData, notificationOnly, bridgeContext, posDup, skipCallbacks); try { doPostRemoveAll(r, op, bucketRegion, lockedForPrimary); EntryEventImpl ev = getEventFromEntry(r, myId, eventSender, i, removeAllPRData, notificationOnly, bridgeContext, posDup, skipCallbacks); try {
@Test public void doPostRemoveAllCallsCheckReadinessBeforeAndAfter() throws Exception { DistributedRemoveAllOperation distributedRemoveAllOperation = mock(DistributedRemoveAllOperation.class); InternalDataView internalDataView = mock(InternalDataView.class); when(bucketRegion.getDataView()).thenReturn(internalDataView); RemoveAllPRMessage removeAllPRMessage = new RemoveAllPRMessage(); removeAllPRMessage.doPostRemoveAll(partitionedRegion, distributedRemoveAllOperation, bucketRegion, true); InOrder inOrder = inOrder(partitionedRegion, internalDataView); inOrder.verify(partitionedRegion).checkReadiness(); inOrder.verify(internalDataView).postRemoveAll(any(), any(), any()); inOrder.verify(partitionedRegion).checkReadiness(); }
versions.saveVersions(keyToVersionMap); } else if (!this.getConcurrencyChecksEnabled()) { // no keys returned if not versioned Set keys = prMsg.getKeys(); partialKeys.addKeys(keys); EntryEventImpl firstEvent = prMsg.getFirstEvent(this); try { partialKeys.saveFailedKey(firstEvent.getKey(), ex);
private VersionedObjectList sendMsgByBucket(final Integer bucketId, RemoveAllPRMessage prMsg) { EntryEventImpl event = prMsg.getFirstEvent(this); try { RetryTimeKeeper retryTime = null; prMsg.setPossibleDuplicate(true);
@Override @SuppressWarnings("synthetic-access") public void run() { InternalDistributedMember myId = r.getDistributionManager().getDistributionManagerId(); for (int i = 0; i < removeAllDataCount; ++i) { @Released EntryEventImpl ev = RemoveAllPRMessage.getEventFromEntry(r, myId, eventSender, i, removeAllData, false, bridgeContext, posDup, false); try { ev.setRemoveAllOperation(op); if (logger.isDebugEnabled()) { logger.debug("invoking basicDestroy with {}", ev); } try { dr.basicDestroy(ev, true, null); } catch (EntryNotFoundException ignore) { } removeAllData[i].versionTag = ev.getVersionTag(); versions.addKeyAndVersion(removeAllData[i].getKey(), ev.getVersionTag()); } finally { ev.release(); } } } }, baseEvent.getEventId());
private VersionedObjectList sendMsgByBucket(final Integer bucketId, RemoveAllPRMessage prMsg, PartitionedRegion pr) { // retry the put remotely until it finds the right node managing the bucket InternalDistributedMember currentTarget = pr.getOrCreateNodeForBucketWrite(bucketId.intValue(), null); if (!currentTarget.equals(this.state.getTarget())) { @Released EntryEventImpl firstEvent = prMsg.getFirstEvent(pr); try { throw new TransactionDataNotColocatedException( String.format("Key %s is not colocated with transaction", firstEvent.getKey())); } finally { firstEvent.release(); } } try { return pr.tryToSendOneRemoveAllMessage(prMsg, currentTarget); } catch (ForceReattemptException prce) { pr.checkReadiness(); throw new TransactionDataNotColocatedException(prce.getMessage()); } catch (PrimaryBucketException notPrimary) { RuntimeException re = new TransactionDataRebalancedException( "Transactional data moved, due to rebalancing."); re.initCause(notPrimary); throw re; } catch (DataLocationException dle) { throw new TransactionException(dle); } }
@Override public void run() { InternalDistributedMember myId = theRegion.getDistributionManager().getDistributionManagerId(); for (int i = 0; i < op.removeAllDataSize; ++i) { @Released EntryEventImpl ev = RemoveAllPRMessage.getEventFromEntry(theRegion, myId, myId, i, op.removeAllData, false, op.getBaseEvent().getContext(), false, !op.getBaseEvent().isGenerateCallbacks()); ev.setRemoveAllOperation(op); try { theRegion.basicDestroy(ev, true/* should we invoke cacheWriter? */, null); } catch (EntryNotFoundException ignore) { } finally { ev.release(); } successfulOps.addKeyAndVersion(op.removeAllData[i].key, null); } } }, op.getBaseEvent().getEventId());
EntryEventImpl firstEvent = prMsg.getFirstEvent(pr); try { partialKeys.saveFailedKey(firstEvent.getKey(), ex);
@Test public void removeAndNotifyKeysIsNotInvokedIfKeysNotLocked() throws Exception { RemoveAllPRMessage message = spy(new RemoveAllPRMessage(bucketId, 1, false, false, true, null)); message.addEntry(entryData); doReturn(keys).when(message).getKeysToBeLocked(); RegionDestroyedException regionDestroyedException = new RegionDestroyedException("", ""); when(bucketRegion.waitUntilLocked(keys)).thenThrow(regionDestroyedException); message.doLocalRemoveAll(partitionedRegion, mock(InternalDistributedMember.class), true); verify(bucketRegion, never()).removeAndNotifyKeys(eq(keys)); verify(dataStore).checkRegionDestroyedOnBucket(eq(bucketRegion), eq(true), eq(regionDestroyedException)); } }
for (int i = 0; i < op.removeAllDataSize; ++i) { @Released EntryEventImpl ev = RemoveAllPRMessage.getEventFromEntry(theRegion, myId, myId, i, op.removeAllData, false, op.getBaseEvent().getContext(), false, !op.getBaseEvent().isGenerateCallbacks());