public PartitionMessageWithDirectReply(Set recipients, int regionId, DirectReplyProcessor processor, EntryEventImpl event) { super(recipients, regionId, processor); this.processor = processor; this.posDup = event.isPossibleDuplicate(); }
public PartitionMessageWithDirectReply(PartitionMessageWithDirectReply original, EntryEventImpl event) { super(original); this.processor = original.processor; if (event != null) { this.posDup = event.isPossibleDuplicate(); } else { this.posDup = original.posDup; } }
/** a cloning constructor for relaying the message to listeners */ DestroyMessage(DestroyMessage original, EntryEventImpl event, Set members) { this(original); if (event != null) { this.posDup = event.isPossibleDuplicate(); this.versionTag = event.getVersionTag(); } }
private void handleMessageRetry(LocalRegion region, EntryEventImpl clientEvent) { if (clientEvent.isPossibleDuplicate()) { if (region.getAttributes().getConcurrencyChecksEnabled()) { // recover the version tag from other servers clientEvent.setRegion(region); if (!recoverVersionTagForRetriedOperation(clientEvent)) { // no-one has seen this event clientEvent.setPossibleDuplicate(false); } } } }
@Test public void putThrowsIOExceptionOnMissingRegion() throws Exception { thrown.expect(IOException.class); // Mocks with minimal implementation to ensure code path through PutMessage.toData EntryEventImpl mockEvent = mock(EntryEventImpl.class); when(mockEvent.isPossibleDuplicate()).thenReturn(false); when(mockEvent.getEventId()).thenReturn(mock(EventID.class)); when(mockEvent.getOperation()).thenReturn(Operation.UPDATE); when(mockEvent.getDeltaBytes()).thenReturn(new byte[] {}); DistributionConfig mockDistributionConfig = mock(DistributionConfig.class); when(mockDistributionConfig.getDeltaPropagation()).thenReturn(true); InternalDistributedSystem mockInternalDistributedSystem = mock(InternalDistributedSystem.class); when(mockInternalDistributedSystem.getConfig()).thenReturn(mockDistributionConfig); // Construct a put with minimum configuration needed to reach region check. PutMessage put = new PutMessage(new HashSet(), false, UNKNOWN_REGION, null, mockEvent, 0, false, false, null, false); put.setSendDelta(true); put.setInternalDs(mockInternalDistributedSystem); put.toData(new DataOutputStream(new ByteArrayOutputStream())); } }
@Override public void postRemoveAllFireEvents(DistributedRemoveAllOperation removeAllOp, VersionedObjectList successfulOps) { if (!this.getDataPolicy().withStorage() && this.getConcurrencyChecksEnabled() && removeAllOp.getBaseEvent().isBridgeEvent()) { // if there is no local storage we need to transfer version information // to the successfulOps list for transmission back to the client successfulOps.clear(); removeAllOp.fillVersionedObjectList(successfulOps); } Set successfulKeys = new HashSet(successfulOps.size()); for (Object key : successfulOps.getKeys()) { successfulKeys.add(key); } for (Iterator it = removeAllOp.eventIterator(); it.hasNext();) { @Unretained EntryEventImpl event = (EntryEventImpl) it.next(); if (successfulKeys.contains(event.getKey())) { invokeDestroyCallbacks(EnumListenerEvent.AFTER_DESTROY, event, !event.callbacksInvoked() && !event.isPossibleDuplicate(), this.isUsedForPartitionedRegionBucket /* * If this is replicated region, use "false". We must notify gateways inside RegionEntry * lock, NOT here, to preserve the order of events sent by gateways for same key. If this is * bucket region, use "true", because the event order is guaranteed */); } } }
@Override public void postPutAllFireEvents(DistributedPutAllOperation putAllOp, VersionedObjectList successfulPuts) { if (!this.getDataPolicy().withStorage() && this.getConcurrencyChecksEnabled() && putAllOp.getBaseEvent().isBridgeEvent()) { // if there is no local storage we need to transfer version information // to the successfulPuts list for transmission back to the client successfulPuts.clear(); putAllOp.fillVersionedObjectList(successfulPuts); } Set successfulKeys = new HashSet(successfulPuts.size()); for (Object key : successfulPuts.getKeys()) { successfulKeys.add(key); } for (Iterator it = putAllOp.eventIterator(); it.hasNext();) { @Unretained EntryEventImpl event = (EntryEventImpl) it.next(); if (successfulKeys.contains(event.getKey())) { EnumListenerEvent op = event.getOperation().isCreate() ? EnumListenerEvent.AFTER_CREATE : EnumListenerEvent.AFTER_UPDATE; invokePutCallbacks(op, event, !event.callbacksInvoked() && !event.isPossibleDuplicate(), this.isUsedForPartitionedRegionBucket /* * If this is replicated region, use "false". We must notify gateways inside RegionEntry * lock, NOT here, to preserve the order of events sent by gateways for same key. If this is * bucket region, use "true", because the event order is guaranteed */); } } }
@Override public void invokeTXCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event, final boolean callDispatchListenerEvent) { if (logger.isDebugEnabled()) { logger.debug("BR.invokeTXCallbacks for event {}", event); } // bucket events may make it to this point even though the bucket is still // initializing. We can't block while initializing or a GII state flush // may hang, so we avoid notifying the bucket if (this.isInitialized()) { boolean callThem = callDispatchListenerEvent; if (event.isPossibleDuplicate() && getEventTracker().isInitialImageProvider(event.getDistributedMember())) { callThem = false; } super.invokeTXCallbacks(eventType, event, callThem); } @Released final EntryEventImpl prevent = createEventForPR(event); try { this.partitionedRegion.invokeTXCallbacks(eventType, prevent, this.partitionedRegion.isInitialized() ? callDispatchListenerEvent : false); } finally { prevent.release(); } }
if (prMsg == null) { prMsg = new PutAllPRMessage(bucketId.intValue(), putAllDataSize, false, event.isPossibleDuplicate(), !event.isGenerateCallbacks(), event.getCallbackArgument()); prMsg .setTransactionDistributed(event.getRegion().getCache().getTxManager().isDistributed());
if (prMsg == null) { prMsg = new RemoveAllPRMessage(bucketId.intValue(), removeAllDataSize, false, event.isPossibleDuplicate(), !event.isGenerateCallbacks(), event.getCallbackArgument()); prMsg .setTransactionDistributed(event.getRegion().getCache().getTxManager().isDistributed());
/** * 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; }
/** * Create PutAllPRMessage for notify only (to adjunct nodes) * * @param bucketId create message to send to this bucket */ public PutAllPRMessage createPRMessagesNotifyOnly(int bucketId) { final EntryEventImpl event = getBaseEvent(); PutAllPRMessage prMsg = new PutAllPRMessage(bucketId, putAllDataSize, 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 < putAllDataSize; i++) { prMsg.addEntry(putAllData[i]); } return prMsg; }
@Override public void invokePutCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event, final boolean callDispatchListenerEvent, boolean notifyGateways) { if (logger.isTraceEnabled()) { logger.trace("invoking put callbacks on bucket for event {}", event); } // bucket events may make it to this point even though the bucket is still // initializing. We can't block while initializing or a GII state flush // may hang, so we avoid notifying the bucket if (this.isInitialized()) { boolean callThem = callDispatchListenerEvent; if (callThem && event.isPossibleDuplicate() && this.getEventTracker().isInitialImageProvider(event.getDistributedMember())) { callThem = false; } super.invokePutCallbacks(eventType, event, callThem, notifyGateways); } @Released final EntryEventImpl prevent = createEventForPR(event); try { this.partitionedRegion.invokePutCallbacks(eventType, prevent, this.partitionedRegion.isInitialized() ? callDispatchListenerEvent : false, false); } finally { prevent.release(); } }
@Override public void invokeDestroyCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event, final boolean callDispatchListenerEvent, boolean notifyGateways) { // bucket events may make it to this point even though the bucket is still // initializing. We can't block while initializing or a GII state flush // may hang, so we avoid notifying the bucket if (this.isInitialized()) { boolean callThem = callDispatchListenerEvent; if (event.isPossibleDuplicate() && this.getEventTracker().isInitialImageProvider(event.getDistributedMember())) { callThem = false; } super.invokeDestroyCallbacks(eventType, event, callThem, notifyGateways); } @Released final EntryEventImpl prevent = createEventForPR(event); try { this.partitionedRegion.invokeDestroyCallbacks(eventType, prevent, this.partitionedRegion.isInitialized() ? callDispatchListenerEvent : false, false); } finally { prevent.release(); } }
@Override public void invokeInvalidateCallbacks(final EnumListenerEvent eventType, final EntryEventImpl event, final boolean callDispatchListenerEvent) { // bucket events may make it to this point even though the bucket is still // initializing. We can't block while initializing or a GII state flush // may hang, so we avoid notifying the bucket if (this.isInitialized()) { boolean callThem = callDispatchListenerEvent; if (event.isPossibleDuplicate() && this.getEventTracker().isInitialImageProvider(event.getDistributedMember())) { callThem = false; } super.invokeInvalidateCallbacks(eventType, event, callThem); } @Released final EntryEventImpl prevent = createEventForPR(event); try { this.partitionedRegion.invokeInvalidateCallbacks(eventType, prevent, this.partitionedRegion.isInitialized() ? callDispatchListenerEvent : false); } finally { prevent.release(); } }
@Override public boolean hasSeenEvent(EntryEventImpl event) { boolean isDuplicate = false; isDuplicate = getEventTracker().hasSeenEvent(event); if (isDuplicate) { markEventAsDuplicate(event); } else { // bug #48205 - a retried PR operation may already have a version assigned to it // in another VM if (event.isPossibleDuplicate() && event.getRegion().getConcurrencyChecksEnabled() && event.getVersionTag() == null && event.getEventId() != null) { boolean isBulkOp = event.getOperation().isPutAll() || event.getOperation().isRemoveAll(); VersionTag tag = FindVersionTagOperation.findVersionTag(event.getRegion(), event.getEventId(), isBulkOp); event.setVersionTag(tag); } } return isDuplicate; }
/** * Constructor to use when preparing to send putall data out */ public PutAllEntryData(EntryEventImpl event) { this.key = event.getKey(); this.value = event.getRawNewValueAsHeapObject(); Object oldValue = event.getRawOldValueAsHeapObject(); if (oldValue == Token.NOT_AVAILABLE || Token.isRemoved(oldValue)) { this.oldValue = null; } else { this.oldValue = oldValue; } this.op = event.getOperation(); this.eventID = event.getEventId(); this.tailKey = event.getTailKey(); this.versionTag = event.getVersionTag(); setNotifyOnly(!event.getInvokePRCallbacks()); setCallbacksInvoked(event.callbacksInvoked()); setPossibleDuplicate(event.isPossibleDuplicate()); setInhibitDistribution(event.getInhibitDistribution()); }
protected void initMessage(CacheOperationMessage msg, DirectReplyProcessor p) { msg.regionPath = getRegion().getFullPath(); msg.processorId = p == null ? 0 : p.getProcessorId(); msg.processor = p; if (this.event.getOperation().isEntry()) { EntryEventImpl entryEvent = getEvent(); msg.callbackArg = entryEvent.getRawCallbackArgument(); msg.possibleDuplicate = entryEvent.isPossibleDuplicate(); VersionTag tag = entryEvent.getVersionTag(); msg.setInhibitNotificationsBit(entryEvent.inhibitAllNotifications()); if (tag != null && tag.hasValidVersion()) { msg.setVersionTag(tag); } } else { msg.callbackArg = ((RegionEventImpl) this.event).getRawCallbackArgument(); } msg.op = this.event.getOperation(); msg.owner = this; msg.regionAllowsConflation = getRegion().getEnableAsyncConflation(); }
/** * Constructor to use when preparing to send putall data out */ public RemoveAllEntryData(EntryEventImpl event) { this.key = event.getKey(); Object oldValue = event.getRawOldValue(); if (oldValue == Token.NOT_AVAILABLE || Token.isRemoved(oldValue)) { this.oldValue = null; } else { this.oldValue = oldValue; } this.op = event.getOperation(); this.eventID = event.getEventId(); this.tailKey = event.getTailKey(); this.versionTag = event.getVersionTag(); setNotifyOnly(!event.getInvokePRCallbacks()); setCallbacksInvoked(event.callbacksInvoked()); setPossibleDuplicate(event.isPossibleDuplicate()); setInhibitDistribution(event.getInhibitDistribution()); setRedestroyedEntry(event.getIsRedestroyedEntry()); }
this.versionTag = other.versionTag; this.setPossibleDuplicate(other.isPossibleDuplicate());