/** * Serialize an object into a <code>byte[]</code> * * @throws IllegalArgumentException If <code>obj</code> should not be serialized */ public static byte[] serialize(Object obj) { return serialize(obj, null); }
this.expectedOldValue = expectedOldValue; this.useOriginRemote = useOriginRemote; this.key = event.getKey(); this.possibleDuplicate = possibleDuplicate; event.setOriginRemote(useOriginRemote); if (event.hasNewValue()) { this.deserializationPolicy = DistributedCacheOperation.DESERIALIZATION_POLICY_LAZY; event.exportNewValue(this); } else { if (event.hasOldValue()) { this.hasOldValue = true; event.exportOldValue(this); this.cbArg = event.getRawCallbackArgument(); this.lastModified = lastModified; this.op = event.getOperation(); this.bridgeContext = event.getContext(); this.eventId = event.getEventId(); Assert.assertTrue(this.eventId != null); this.ifNew = ifNew; this.ifOld = ifOld; this.versionTag = event.getVersionTag();
@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; }
protected DestroyMessage(Set recipients, boolean notifyOnly, int regionId, DirectReplyProcessor processor, EntryEventImpl event, Object expectedOldValue) { super(recipients, regionId, processor, event); this.expectedOldValue = expectedOldValue; this.key = event.getKey(); this.cbArg = event.getRawCallbackArgument(); this.op = event.getOperation(); this.notificationOnly = notifyOnly; this.bridgeContext = event.getContext(); this.eventId = event.getEventId(); this.versionTag = event.getVersionTag(); }
public PRUpdateEntryVersionMessage(Set recipients, int regionId, DirectReplyProcessor processor, EntryEventImpl event) { super(recipients, regionId, processor, event); this.key = event.getKey(); this.op = event.getOperation(); this.eventId = event.getEventId(); this.versionTag = event.getVersionTag(); }
/** 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(); } }
/** * 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()); }
/** * 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()); }
protected RemoteDestroyMessage(DistributedMember recipient, String regionPath, DirectReplyProcessor processor, EntryEventImpl event, Object expectedOldValue, boolean useOriginRemote, boolean possibleDuplicate) { super((InternalDistributedMember) recipient, regionPath, processor); this.expectedOldValue = expectedOldValue; this.key = event.getKey(); this.cbArg = event.getRawCallbackArgument(); this.op = event.getOperation(); this.bridgeContext = event.getContext(); this.eventId = event.getEventId(); this.useOriginRemote = useOriginRemote; this.possibleDuplicate = possibleDuplicate; this.versionTag = event.getVersionTag(); Assert.assertTrue(this.eventId != null); // added for old value if available sent over the wire for cache servers. if (event.hasOldValue()) { this.hasOldValue = true; event.exportOldValue(this); } }
PutMessage(Set recipients, boolean notifyOnly, int regionId, DirectReplyProcessor processor, EntryEventImpl event, final long lastModified, boolean ifNew, boolean ifOld, Object expectedOldValue, boolean requireOldValue) { super(recipients, regionId, processor, event); this.processor = processor; this.notificationOnly = notifyOnly; this.requireOldValue = requireOldValue; this.expectedOldValue = expectedOldValue; this.key = event.getKey(); if (event.hasNewValue()) { this.deserializationPolicy = DistributedCacheOperation.DESERIALIZATION_POLICY_LAZY; event.exportNewValue(this); } else { // assert that if !event.hasNewValue, then deserialization policy is NONE assert this.deserializationPolicy == DistributedCacheOperation.DESERIALIZATION_POLICY_NONE : this.deserializationPolicy; } this.event = event; this.cbArg = event.getRawCallbackArgument(); this.lastModified = lastModified; this.op = event.getOperation(); this.bridgeContext = event.getContext(); this.eventId = event.getEventId(); this.versionTag = event.getVersionTag(); Assert.assertTrue(this.eventId != null); this.ifNew = ifNew; this.ifOld = ifOld; }
@Retained({ENTRY_EVENT_NEW_VALUE, ENTRY_EVENT_OLD_VALUE}) EntryEventImpl other, boolean setOldValue) { setRegion(other.getRegion()); basicSetNewValue(other.basicGetNewValue(), false); this.newValueBytes = other.newValueBytes; this.cachedSerializedNewValue = other.cachedSerializedNewValue; this.re = other.re; if (setOldValue) { retainAndSetOldValue(other.basicGetOldValue()); this.oldValueBytes = other.oldValueBytes; setEventFlag(EventFlags.FLAG_CALLBACKS_INVOKED, false); txId = other.txId; op = other.op; this.keyInfo = other.keyInfo.isDistKeyInfo() ? new DistTxKeyInfo((DistTxKeyInfo) other.keyInfo) : new KeyInfo(other.keyInfo); if (other.getRawCallbackArgument() instanceof GatewaySenderEventCallbackArgument) { this.keyInfo.setCallbackArg((new GatewaySenderEventCallbackArgument( (GatewaySenderEventCallbackArgument) other.getRawCallbackArgument()))); this.versionTag = other.versionTag; this.setPossibleDuplicate(other.isPossibleDuplicate());
@Retained protected static EntryEventImpl createRemoveAllEvent(DistributedRemoveAllOperation op, InternalRegion region, Object entryKey) { @Retained EntryEventImpl e; final Operation entryOp = Operation.REMOVEALL_DESTROY; if (op != null) { EntryEventImpl event = op.getBaseEvent(); if (event.isBridgeEvent()) { e = EntryEventImpl.create(region, entryOp, entryKey, null, event.getRawCallbackArgument(), false, event.distributedMember, event.isGenerateCallbacks()); e.setContext(event.getContext()); } else { e = EntryEventImpl.create(region, entryOp, entryKey, null, event.getCallbackArgument(), false, region.getMyId(), event.isGenerateCallbacks()); } } else { e = EntryEventImpl.create(region, entryOp, entryKey, null, null, false, region.getMyId(), true); } e.removeAllOp = op; return e; }
if (event.getOperation().isDistributed() && !event.isFromServer()) { ServerRegionProxy mySRP = getServerProxy(); if (mySRP != null) { if (event.isBulkOpInProgress()) { Operation op = event.getOperation(); Object key = event.getKey(); Object value = event.getRawNewValue(); Object callbackArg = event.getRawCallbackArgument(); boolean isCreate = event.isCreate(); Object result = mySRP.put(key, value, event.getDeltaBytes(), event, op, requireOldValue, expectedOldValue, callbackArg, isCreate); event.setConcurrentMapOldValue(result);
@Test public void setOldValueForcedWithRemoveTokenChangesOldValueToNull() { LocalRegion region = mock(LocalRegion.class); EntryEventImpl e = createEntryEvent(region, null); String UNINITIALIZED = "Uninitialized"; e.basicSetOldValue(UNINITIALIZED); e.setOldValue(Token.REMOVED_PHASE1, true); assertEquals(null, e.basicGetOldValue()); }
@Override public void postPutAll(DistributedPutAllOperation putallOp, VersionedObjectList successfulPuts, InternalRegion reg) { super.postPutAll(putallOp, successfulPuts, reg); // TODO DISTTX: event is never released EntryEventImpl event = EntryEventImpl.createPutAllEvent(putallOp, reg, Operation.PUTALL_CREATE, putallOp.getBaseEvent().getKey(), putallOp.getBaseEvent().getValue()); event.setEventId(putallOp.getBaseEvent().getEventId()); DistTxEntryEvent dtop = new DistTxEntryEvent(event); dtop.setPutAllOperation(putallOp); this.primaryTransactionalOperations.add(dtop); }
/** * create a new EntryEvent to be used in notifying listeners, cache servers, etc. Caller must * release result if it is != to sourceEvent */ @Retained EntryEventImpl createListenerEvent(EntryEventImpl sourceEvent, PartitionedRegion r, InternalDistributedMember member) { final EntryEventImpl e2; if (this.notificationOnly && this.bridgeContext == null) { e2 = sourceEvent; } else { e2 = new EntryEventImpl(sourceEvent); if (this.bridgeContext != null) { e2.setContext(this.bridgeContext); } } e2.setRegion(r); e2.setOriginRemote(true); e2.setInvokePRCallbacks(!notificationOnly); if (this.filterInfo != null) { e2.setLocalFilterInfo(this.filterInfo.getFilterInfo(member)); } if (this.versionTag != null) { this.versionTag.replaceNullIDs(getSender()); e2.setVersionTag(this.versionTag); } return e2; }
@Override public void postRemoveAll(DistributedRemoveAllOperation removeAllOp, VersionedObjectList successfulOps, InternalRegion reg) { super.postRemoveAll(removeAllOp, successfulOps, reg); // TODO DISTTX: event is never released EntryEventImpl event = EntryEventImpl.createRemoveAllEvent(removeAllOp, reg, removeAllOp.getBaseEvent().getKey()); event.setEventId(removeAllOp.getBaseEvent().getEventId()); DistTxEntryEvent dtop = new DistTxEntryEvent(event); dtop.setRemoveAllOperation(removeAllOp); this.primaryTransactionalOperations.add(dtop); }
@Retained EntryEventImpl createEventForPR(EntryEventImpl sourceEvent) { EntryEventImpl e2 = new EntryEventImpl(sourceEvent); boolean returned = false; try { e2.setRegion(this.partitionedRegion); if (FORCE_LOCAL_LISTENERS_INVOCATION) { e2.setInvokePRCallbacks(true); } else { e2.setInvokePRCallbacks(sourceEvent.getInvokePRCallbacks()); } DistributedMember dm = this.getDistributionManager().getDistributionManagerId(); e2.setOriginRemote(!e2.getDistributedMember().equals(dm)); returned = true; return e2; } finally { if (!returned) { e2.release(); } } }
/** * 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; }
@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())); } }