final void initializeEvent(LocalRegion rgn, EventID eventId, DistributedMember member) { this.event = EntryEventImpl.create(rgn, getOperation(), null, null, null, true, member); this.event.setEventId(eventId); // OFFHEAP: callers make sure event only has on heap values. }
private void initialize(boolean notifyOnly, EntryEventImpl event, Object expectedOldValue, boolean cacheWrite) { this.expectedOldValue = expectedOldValue; this.cacheWrite = cacheWrite; 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(); }
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(); } } }
@Override boolean cacheWriteBeforeDestroy(EntryEventImpl event, Object expectedOldValue) throws CacheWriterException, EntryNotFoundException, TimeoutException { boolean origRemoteState = false; boolean ret = false; try { if (event.getPartitionMessage() != null || event.hasClientOrigin()) { origRemoteState=event.isOriginRemote(); event.setOriginRemote(true); } event.setRegion(this.partitionedRegion); ret = this.partitionedRegion.cacheWriteBeforeDestroy(event, expectedOldValue); } finally { if (event.getPartitionMessage() != null || event.hasClientOrigin()) { event.setOriginRemote(origRemoteState); } event.setRegion(this); } return ret; // return super.cacheWriteBeforeDestroy(event); }
private EntryEventImpl createNewEvent(LocalRegion region, VersionTag tag, Object key, Object value) { EntryEventImpl updateEvent = EntryEventImpl.createVersionTagHolder(tag); updateEvent.setOperation(Operation.UPDATE); updateEvent.setRegion(region); if (region instanceof PartitionedRegion) { updateEvent.setKeyInfo(((PartitionedRegion)region).getKeyInfo(key)); } else { updateEvent.setKeyInfo(new KeyInfo(key, value, null)); } updateEvent.setNewValue(value); updateEvent.setGenerateCallbacks(true); updateEvent.distributedMember = region.getSystem().getDistributedMember(); updateEvent.setNewEventId(region.getSystem()); return updateEvent; }
@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.eventTracker.isInitialImageProvider(event.getDistributedMember())) { callThem = false; } super.invokeDestroyCallbacks(eventType, event, callThem, notifyGateways); } final EntryEventImpl prevent = createEventForPR(event); try { this.partitionedRegion.invokeDestroyCallbacks(eventType, prevent, this.partitionedRegion.isInitialized() ? callDispatchListenerEvent : false, false); } finally { prevent.release(); } }
public void postPutAll(DistributedPutAllOperation putallOp, VersionedObjectList successfulPuts, LocalRegion region) { super.postPutAll(putallOp, successfulPuts, region); EntryEventImpl event = EntryEventImpl.createPutAllEvent(putallOp, region, 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); }
@Override public void toData(final DataOutput out) throws IOException { super.toData(out); try { // Write EventID DataSerializer.writeObject(this.event.getEventId(), out); ((InternalDistributedMember)event.getDistributedMember()).toData(out); // Write Region name DataSerializer.writeString(this.event.getRegion().getFullPath(), out); } catch (Exception e) { throw new IOException(e); } }
public void postRemoveAll(DistributedRemoveAllOperation removeAllOp, VersionedObjectList successfulOps, LocalRegion region) { super.postRemoveAll(removeAllOp, successfulOps, region); EntryEventImpl event = EntryEventImpl.createRemoveAllEvent(removeAllOp, region, removeAllOp.getBaseEvent().getKey()); event.setEventId(removeAllOp.getBaseEvent().getEventId()); DistTxEntryEvent dtop = new DistTxEntryEvent(event); dtop.setRemoveAllOperation(removeAllOp); this.primaryTransactionalOperations.add(dtop); }
@Override protected InternalCacheEvent createEvent(DistributedRegion rgn) throws EntryNotFoundException { if (rgn.keyRequiresRegionContext()) { ((KeyWithRegionContext)this.key).setRegionContext(rgn); } EntryEventImpl ev = EntryEventImpl.create(rgn, getOperation(), this.key, null /* newValue */, this.callbackArg /*callbackArg*/, true /* originRemote*/ , getSender(), false /*generateCallbacks*/); ev.setEventId(this.eventId); ev.setVersionTag(this.versionTag); ev.setTailKey(this.tailKey); return ev; }
@Override protected byte[] getRawBytes() { // TODO:Asif: Optimize the serialization of byte[][], by identifying the // size of total bytes needed and avoiding using // EntryEventImpl which uses HeapDataOutput // we need to serialize the byte[][] return EntryEventImpl.serialize(this); }
@Override protected void initMessage(CacheOperationMessage msg, DirectReplyProcessor processor) { super.initMessage(msg, processor); DestroyMessage m = (DestroyMessage)msg; EntryEventImpl event = getEvent(); m.key = event.getKey(); m.eventId = event.getEventId(); }
public void updateEntryVersionLocally(Integer bucketId, EntryEventImpl event) throws ForceReattemptException { if (logger.isDebugEnabled()) { logger.debug("updateEntryVersionLocally: bucketId={}{}{} for key={}", this.partitionedRegion.getPRId(), PartitionedRegion.BUCKET_ID_SEPARATOR, bucketId, event.getKey()); } final BucketRegion bucketRegion = getInitializedBucketForId(event.getKey(), bucketId); try { event.setRegion(bucketRegion); bucketRegion.basicUpdateEntryVersion(event); // bug 34361: don't send a reply if bucket was destroyed during the op bucketRegion.checkReadiness(); } catch(RegionDestroyedException rde){ checkRegionDestroyedOnBucket(bucketRegion, event.isOriginRemote(), rde); } } }
void cleanUpOnIncompleteOp(EntryEventImpl event, RegionEntry re, boolean eventRecorded, boolean updateStats, boolean isReplace) { //TODO:Asif: This is incorrect implementation for replicated region in case of //sql fabric, as sqlf index would already be updated, if eventRecorded //flag is true.So if entry is being removed , //then the sqlfindex also needs to be corrected IndexUpdater iu = this.getIndexUpdater(); // sqlf system if(!eventRecorded || iu ==null || isReplace) { //Ok to remove entry whether sqlfabric or gfe as index has not been modified yet by the operation this.entries.removeEntry(event.getKey(), re, updateStats) ; }else { // a sqlf system, with event recorded as true. we need to update index. //Use the current event to indicate destroy.should be ok Operation oldOp = event.getOperation(); event.setOperation(Operation.DESTROY); this.entries.removeEntry(event.getKey(), re, updateStats, event, this, iu); event.setOperation(oldOp); } }
@Override protected InternalCacheEvent createEvent(DistributedRegion rgn) throws EntryNotFoundException { if (rgn.keyRequiresRegionContext()) { ((KeyWithRegionContext)this.key).setRegionContext(rgn); } EntryEventImpl ev = EntryEventImpl.create( rgn, getOperation(), this.key, null, this.callbackArg, true, getSender()); ev.setEventId(this.eventId); setOldValueInEvent(ev); ev.setVersionTag(this.versionTag); if (this.filterRouting != null) { ev.setLocalFilterInfo(this.filterRouting .getFilterInfo(rgn.getMyId())); } ev.setInhibitAllNotifications(this.inhibitAllNotifications); return ev; }
public void release() { if (LocalRegion.this.enableOffHeapMemory && this.event instanceof EntryEventImpl) { ((EntryEventImpl)this.event).release(); } } }
/** * Switch the event's region from BucketRegion to owning PR and set originRemote to the given value */ static EntryEventImpl switchEventOwnerAndOriginRemote(EntryEventImpl event, boolean originRemote) { assert event != null; if (event.getRegion().isUsedForPartitionedRegionBucket()) { LocalRegion pr = event.getRegion().getPartitionedRegion(); event.setRegion(pr); } event.setOriginRemote(originRemote); return event; }
public void destroyRecoveredEntry(Object key) { EntryEventImpl event = EntryEventImpl.create( this, Operation.LOCAL_DESTROY, key, null, null, false, getMyId(), false); try { event.inhibitCacheListenerNotification(true); mapDestroy(event, true, false, null, false, true); } finally { event.release(); } } public boolean lruLimitExceeded() {
@Override protected void initMessage(CacheOperationMessage msg, DirectReplyProcessor p) { super.initMessage(msg, p); UpdateEntryVersionMessage imsg = (UpdateEntryVersionMessage)msg; EntryEventImpl eei = getEvent(); imsg.key = eei.getKey(); imsg.eventId = eei.getEventId(); imsg.versionTag = eei.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); } } } }