@Override public void setValueWithTombstoneCheck(@Unretained Object v, EntryEvent e) throws RegionClearedException { if (v == Token.TOMBSTONE) { makeTombstone((InternalRegion) e.getRegion(), ((InternalCacheEvent) e).getVersionTag()); } else { setValue((RegionEntryContext) e.getRegion(), v, (EntryEventImpl) e); } }
private void log(EntryEvent event) { StringBuilder builder = new StringBuilder(); builder.append("DebugCacheListener: Received ").append(event.getOperation()).append(" for key=") .append(event.getKey()); if (event.getNewValue() != null) { builder.append("; value=").append(event.getNewValue()); } event.getRegion().getCache().getLogger().info(builder.toString()); }
@Override public void afterCreate(EntryEvent<String, Object> event) { if (!readyForEvents) { return; } ObjectName objectName = null; try { objectName = ObjectName.getInstance(event.getKey()); Object newObject = event.getNewValue(); proxyHelper.createProxy(event.getDistributedMember(), objectName, event.getRegion(), newObject); } catch (Exception e) { if (logger.isDebugEnabled()) { logger.debug("Proxy Create failed for {} with exception {}", objectName, e.getMessage(), e); } } }
@Override public void afterDestroy(EntryEvent event) { logger.debug("BucketListener: o={}, r={}, k={}, dm={}", event.getOperation(), event.getRegion().getFullPath(), event.getKey(), event.getDistributedMember()); }
@Override public void enqueueEvent(EnumListenerEvent operation, EntryEvent event, Object substituteValue) throws IOException, CacheException { Region region = event.getRegion(); // int bucketId = PartitionedRegionHelper.getHashKey((EntryOperation)event); int bucketId = ((EntryEventImpl) event).getEventId().getBucketID(); if (bucketId < 0) { return; } int pId = bucketId % this.nDispatcher; this.processors[pId].enqueueEvent(operation, event, substituteValue); }
@Override public void afterInvalidate(EntryEvent event) { logger.debug("BucketListener: o={}, r={}, k={}, dm={}", event.getOperation(), event.getRegion().getFullPath(), event.getKey(), event.getDistributedMember()); }
private void verifyMirrorRegionEventsMatch(EntryEvent<String, String> event, Region region, String expectedValue) { assertThat(event.getRegion()).isSameAs(region); assertThat(event.getKey()).isEqualTo("key"); assertThat(event.getNewValue()).isEqualTo(expectedValue); assertThat(event.getOldValue()).isNull(); assertThat(event.getOperation().isLocalLoad()).isFalse(); assertThat(event.getOperation().isNetLoad()).isFalse(); assertThat(event.getOperation().isLoad()).isFalse(); assertThat(event.getOperation().isNetSearch()).isFalse(); assertThat(event.getOperation().isExpiration()).isFalse(); assertThat(event.getCallbackArgument()).isNull(); assertThat(event.isCallbackArgumentAvailable()).isTrue(); assertThat(event.isOriginRemote()).isTrue(); assertThat(event.getOperation().isDistributed()).isTrue(); }
@Override public void afterCreate(EntryEvent event) { EntryEventImpl ee = (EntryEventImpl) event; logger.debug("BucketListener: o={}, r={}, k={}, nv={}, dm={}", event.getOperation(), event.getRegion().getFullPath(), event.getKey(), ee.getRawNewValue(), event.getDistributedMember()); }
@Override public void afterUpdate(EntryEvent event) { EntryEventImpl ee = (EntryEventImpl) event; logger.debug("BucketListener: o={}, r={}, k={}, ov={}, nv={}, dm={}", event.getOperation(), event.getRegion().getFullPath(), event.getKey(), ee.getRawOldValue(), ee.getRawNewValue(), event.getDistributedMember()); }
@Override public void enqueueEvent(EnumListenerEvent operation, EntryEvent event, Object substituteValue) throws IOException, CacheException { GatewaySenderEventImpl gatewayQueueEvent = null; Region region = event.getRegion(); if (!(region instanceof DistributedRegion) && ((EntryEventImpl) event).getTailKey() == -1) { // In case of parallel sender, we don't expect the key to be not set. // If it is the case then the event must be coming from notificationOnly message. // Don't enqueue the event and return from here only. // Fix for #49081 and EntryDestroyedException in #49367. if (logger.isDebugEnabled()) { logger.debug( "ParallelGatewaySenderEventProcessor not enqueing the following event since tailKey is not set. {}", event); } return; } // TODO: Looks like for PDX region bucket id is set to -1. EventID eventID = ((EntryEventImpl) event).getEventId(); // while merging 42004, kept substituteValue as it is(it is barry's // change 42466). bucketID is merged with eventID.getBucketID gatewayQueueEvent = new GatewaySenderEventImpl(operation, event, substituteValue, true, eventID.getBucketID()); enqueueEvent(gatewayQueueEvent); }
@Override public void afterDestroy(EntryEvent<String, GatewayDelta> event) { // If the event is from the local site, create a 'destroy' event and send it to the // gateway delta region if (event.getCallbackArgument() != null) { if (this.cache.getLogger().fineEnabled()) { StringBuilder builder = new StringBuilder(); builder.append("GatewayDeltaForwarderCacheListener: Received destroy event for ") .append(event.getKey()).append("->").append(event.getNewValue()) .append(" that originated in the local site. Sending it to the remote site."); this.cache.getLogger().fine(builder.toString()); } // Distribute the destroy event to the gateway hub(s) String sessionId = event.getKey(); getGatewayDeltaRegion().put(sessionId, new GatewayDeltaDestroyEvent(event.getRegion().getFullPath(), sessionId)); } else { if (this.cache.getLogger().fineEnabled()) { StringBuilder builder = new StringBuilder(); builder.append("GatewayDeltaForwarderCacheListener: Received destroy event for session ") .append(event.getKey()) .append(" that either expired or originated in the remote site."); this.cache.getLogger().fine(builder.toString()); } } }
@Before public void setUp() { entryEvent = mock(EntryEvent.class); pdxInstance = mock(PdxInstance.class); sqlHandler = mock(SqlHandler.class); region = mock(InternalRegion.class); serializedNewValue = mock(SerializedCacheValue.class); regionEvent = mock(RegionEvent.class); cache = Fakes.cache(); key = "key"; when(entryEvent.getRegion()).thenReturn(region); when(entryEvent.getKey()).thenReturn(key); when(entryEvent.getRegion().getRegionService()).thenReturn(cache); when(entryEvent.getSerializedNewValue()).thenReturn(serializedNewValue); when(entryEvent.getOperation()).thenReturn(Operation.CREATE); when(serializedNewValue.getDeserializedValue()).thenReturn(pdxInstance); writer = new JdbcWriter<>(sqlHandler, cache); }
assertThat(listenEvent).describedAs( "Cannot assert TX CacheListener Events with a null Entry Event").isNotNull(); assertThat(listenEvent.getRegion()).isEqualTo(re); assertThat(listenEvent.getTransactionId()).isEqualTo(txId); assertThat(listenEvent.getKey()).isEqualTo(key);
@Override public void beforeUpdate(EntryEvent<Object, Object> event) throws CacheWriterException { if (!event.getRegion().get(event.getKey()).equals(event.getNewValue())) { PdxRegistryMismatchException ex = new PdxRegistryMismatchException( "Trying to add a PDXType with the same id as an existing PDX type. id=" + event.getKey() + ", existing pdx type " + event.getOldValue() + ", new type " + event.getNewValue()); throw new CacheWriterException(ex); } }
private void writeEvent(EntryEvent<K, V> event) { if (eventCanBeIgnored(event.getOperation())) { return; } checkInitialized((InternalCache) event.getRegion().getRegionService()); totalEvents.add(1); try { getSqlHandler().write(event.getRegion(), event.getOperation(), event.getKey(), getPdxNewValue(event)); } catch (SQLException e) { throw JdbcConnectorException.createException(e); } }
String regionName = event.getRegion().getFullPath(); String sessionId = event.getKey(); SerializedCacheValue scv = event.getSerializedNewValue();
/** * Process a version tag. This overrides AbtractRegionEntry so we can check to see if the old * value was recovered from disk. If so, we don't check for conflicts. */ @Override public void processVersionTag(EntryEvent cacheEvent) { DiskId did = getDiskId(); boolean checkConflicts = true; if (did != null) { InternalRegion lr = (InternalRegion) cacheEvent.getRegion(); if (lr != null && lr.getDiskRegion().isReadyForRecovery()) { synchronized (did) { checkConflicts = !EntryBits.isRecoveredFromDisk(did.getUserBits()); } } } processVersionTag(cacheEvent, checkConflicts); }
assertThat(rgn).isSameAs(ev.getRegion()); assertThat(ev.getKey()).isEqualTo("key"); assertThat(ev.getNewValue()).isEqualTo("value2");
EntryEvent<String, String> ev = events.iterator().next(); assertThat(rgn).isSameAs(ev.getRegion()); assertThat(ev.getKey()).isEqualTo("key"); assertThat(ev.getNewValue()).isEqualTo("value3");
assertThat(rgn1).isSameAs(ev.getRegion()); assertThat(ev.getKey()).isEqualTo("key"); assertThat(ev.getNewValue()).isNull();