@Override public Object getTargetObjectInVM(RegionEntry entry) { if (indexOnValues) { Object o = entry.getValueInVM((LocalRegion) region); if (o instanceof CachedDeserializable) { return ((CachedDeserializable) o).getDeserializedValue(region, entry); } return o; } else if (indexOnRegionKeys) { return entry.getKey(); } return ((LocalRegion) region).new NonTXEntry(entry); }
@Override public Object getTargetObjectInVM(RegionEntry entry) { if (indexOnValues) { Object o = entry.getValueInVM((LocalRegion) this.region); try { if (o == Token.INVALID) { return null; } if (o instanceof CachedDeserializable) { return ((CachedDeserializable) o).getDeserializedValue(this.region, entry); } } catch (EntryDestroyedException ede) { return null; } return o; } else if (indexOnRegionKeys) { return entry.getKey(); } return ((LocalRegion) this.region).new NonTXEntry(entry); }
@Test public void localUpdateSetsOldValueOnEvent() { Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); createInstance(Operation.UPDATE, false, null, localTxEntryState); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(event, times(1)).setOldValue(oldValue); verify(existingEntry, never()).txDidDestroy(anyLong()); }
@Test public void remoteUpdateWithOnlyExistingSucceeds() throws Exception { when(internalRegion.isAllEvents()).thenReturn(true); when(internalRegion.isInitialized()).thenReturn(true); Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(existingEntry.prepareValueForCache(any(), eq(newValue), eq(event), eq(true))) .thenReturn(newValue); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(existingEntry, times(1)).setValue(eq(internalRegion), eq(newValue)); }
@Test public void remoteUpdateWithInvalidateWithOnlyExistingSucceeds() throws Exception { when(internalRegion.isAllEvents()).thenReturn(true); when(internalRegion.isInitialized()).thenReturn(true); Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(event.getRawNewValueAsHeapObject()).thenReturn(null); when(existingEntry.prepareValueForCache(any(), eq(Token.INVALID), eq(event), eq(true))) .thenReturn(Token.INVALID); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(existingEntry, times(1)).setValue(eq(internalRegion), eq(Token.INVALID)); }
@Test public void localUpdateThatAlsoDidDestroyCallsTxDidDestroy() { Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); final long lastModifiedTime = 123L; when(internalRegion.cacheTimeMillis()).thenReturn(lastModifiedTime); createInstance(Operation.UPDATE, true, null, localTxEntryState); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(event, times(1)).setOldValue(oldValue); verify(existingEntry, times(1)).txDidDestroy(lastModifiedTime); }
@Test public void remoteUpdateWithOnlyExistingOnRemovedEntryFails() { when(transactionId.getMemberId()).thenReturn(remoteId); when(internalRegion.isAllEvents()).thenReturn(true); when(internalRegion.isInitialized()).thenReturn(true); Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(existingEntry.isDestroyedOrRemoved()).thenReturn(false).thenReturn(true); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isNull(); }
@Test public void remoteUpdateWithLocalInvalidateWithOnlyExistingSucceeds() throws Exception { when(internalRegion.isAllEvents()).thenReturn(true); when(internalRegion.isInitialized()).thenReturn(true); Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(event.getRawNewValueAsHeapObject()).thenReturn(null); when(event.isLocalInvalid()).thenReturn(true); when(existingEntry.prepareValueForCache(any(), eq(Token.LOCAL_INVALID), eq(event), eq(true))) .thenReturn(Token.LOCAL_INVALID); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(existingEntry, times(1)).setValue(eq(internalRegion), eq(Token.LOCAL_INVALID)); }
@Test public void remoteUpdateWithOnlyExistingCallsAddPut() throws Exception { when(internalRegion.isAllEvents()).thenReturn(true); when(internalRegion.isInitialized()).thenReturn(true); Object oldValue = new Object(); RegionEntry existingEntry = mock(RegionEntry.class); when(existingEntry.getValueInVM(any())).thenReturn(oldValue); when(focusedRegionMap.getEntry(eq(event))).thenReturn(existingEntry); when(existingEntry.prepareValueForCache(any(), eq(newValue), eq(event), eq(true))) .thenReturn(newValue); final Object callbackArgument = "callbackArgument"; when(event.getCallbackArgument()).thenReturn(callbackArgument); createInstance(Operation.UPDATE, false, txRmtEvent, null); RegionEntry result = instance.put(); assertThat(result).isSameAs(existingEntry); verify(txRmtEvent, times(1)).addPut(eq(Operation.UPDATE), eq(internalRegion), eq(existingEntry), eq(key), eq(newValue), eq(callbackArgument)); }
@Test public void txApplyDestroyCallsUnscheduleTombstone_givenExistingRegionEntryThatIsTombstoneWithInTokenMode() { givenLocalRegion(); givenConcurrencyChecks(); givenExistingRegionEntry(); inTokenMode = true; when(existingRegionEntry.getValueInVM(owner)).thenReturn(Token.TOMBSTONE); doTxApplyDestroy(); verify(owner, times(1)).unscheduleTombstone(same(existingRegionEntry)); }
@Test public void setsRegionEntryOnEvent_ifExistingRegionEntryIsValid() throws Exception { givenLocalRegion(); givenConcurrencyChecks(); givenExistingRegionEntry(); Object oldValue = "oldValue"; when(existingRegionEntry.getValueInVM(owner)).thenReturn(oldValue); doTxApplyDestroy(); assertThat(pendingCallbacks).size().isEqualTo(1); EntryEventImpl event = pendingCallbacks.get(0); assertThat(event.getRegionEntry()).isSameAs(existingRegionEntry); assertThat(event.getOldValue()).isSameAs(oldValue); verify(owner).generateAndSetVersionTag(any(EntryEventImpl.class), same(existingRegionEntry)); verify(existingRegionEntry, never()).makeTombstone(any(), any()); verify(txEntryState).setVersionTag(event.getVersionTag()); }
@Retained Object nonTXbasicGetValueInVM(KeyInfo keyInfo) { RegionEntry regionEntry = this.entries.getEntry(keyInfo.getKey()); if (regionEntry == null) { checkEntryNotFound(keyInfo.getKey()); } // OFFHEAP returned to callers Object value = regionEntry.getValueInVM(this); if (Token.isRemoved(value)) { checkEntryNotFound(keyInfo.getKey()); } if (value == Token.NOT_AVAILABLE) { return null; } return value; }
@Retained private EntryEventImpl createEvent(InternalRegion r, Operation op, RegionEntry re, Object key, Object newValue, Object aCallbackArgument) { DistributedMember originator = ((TXId) this.txId).getMemberId(); // TODO:ASIF :EventID will not be generated with this constructor . Check if // this is correct InternalRegion eventRegion = r; if (r.isUsedForPartitionedRegionBucket()) { eventRegion = r.getPartitionedRegion(); } @Retained EntryEventImpl event = EntryEventImpl.create(eventRegion, op, key, newValue, aCallbackArgument, // callbackArg true, // originRemote originator); event.setOldValue(re.getValueInVM(r)); // OFFHEAP: copy into heap cd event.setTransactionId(getTransactionId()); return event; }
RegionEntryContext regionEntryContext = context.getPartitionedRegion() != null ? context.getPartitionedRegion() : (RegionEntryContext) region; Object val = re.getValueInVM(regionEntryContext); if (val instanceof CachedDeserializable) { val = ((CachedDeserializable) val).getDeserializedValue(getRegion(), re);
Object v = mapEntry.getValueInVM(rgn); // OFFHEAP: noop if (v instanceof Conflatable) { if (((Conflatable) v).getEventId() == null) {
synchronized (regionEntry) { if (!regionEntry.isRemoved()) { Object value = regionEntry.getValueInVM(this); if (value == Token.NOT_AVAILABLE || regionEntry.isEvicted()) {
@Override protected void setOldValueInEvent() { if (isCreate()) { makePutOpCreate(); } else { if (!getRegionEntry().isDestroyedOrRemoved()) { makePutOpUpdate(); } else { makePutOpCreate(); } } if (isPutOpCreate()) { getEvent().makeCreate(); getEvent().setOldValue(null); } else { getEvent().makeUpdate(); Object oldValue = getRegionEntry().getValueInVM(getOwner()); getEvent().setOldValue(oldValue); } }
final boolean oldWasTombstone = oldRe.isTombstone(); final int oldSize = owner.calculateRegionEntryValueSize(oldRe); Object oldValue = oldRe.getValueInVM(owner); // OFFHEAP eei Object oldValue = re.getValueInVM(owner); // OFFHEAP eei
synchronized (re) { if (!re.isRemoved() || re.isTombstone()) { Object oldValue = re.getValueInVM(owner); final int oldSize = owner.calculateRegionEntryValueSize(re); final boolean wasDestroyedOrRemoved = re.isDestroyedOrRemoved();
oldRe.setValue(owner, oldRe.getValueInVM(owner)); // OFFHEAP noop setting if (!oldRe.isRemoved() && (fp != null && fp.getCqCount() > 0)) { Object oldValue = oldRe.getValueInVM(owner); // OFFHEAP EntryEventImpl event.setOldValue(re.getValueOnDiskOrBuffer(owner)); } else { Object v = re.getValueInVM(owner);