logger.debug( "Received batch destroyed message with key {} tail key {} this size of the region is {} they keys are {}", key, tailKey, rgn.size(), rgn.keys()); for (GatewayEventFilter filter : rgn.getSerialGatewaySender() .getGatewayEventFilters()) { GatewayQueueEvent eventForFilter = (GatewayQueueEvent) rgn.get(k); try { if (eventForFilter != null) { rgn.localDestroy(k, RegionQueue.WAN_QUEUE_TOKEN); } catch (EntryNotFoundException e) { if (isDebugEnabled) { if (index == -1) { ep = (SerialGatewaySenderEventProcessor) rgn.getSerialGatewaySender() .getEventProcessor(); } else { ConcurrentSerialGatewaySenderEventProcessor csgep = (ConcurrentSerialGatewaySenderEventProcessor) rgn.getSerialGatewaySender() .getEventProcessor(); if (csgep != null && csgep.processors != null) {
/** * pause local operations so that a clear() can be performed and flush comm channels to the given * member */ void lockLocallyForClear(DistributionManager dm, InternalDistributedMember locker, CacheEvent event) { RegionVersionVector rvv = getVersionVector(); ARMLockTestHook armLockTestHook = getRegionMap().getARMLockTestHook(); if (armLockTestHook != null) { armLockTestHook.beforeLock(this, event); } if (rvv != null) { // block new operations from being applied to the region map rvv.lockForClear(getFullPath(), dm, locker); // Check for region destroyed after we have locked, to make sure // we don't continue a clear if the region has been destroyed. checkReadiness(); // Only need to flush if NOACK at this point if (this.getAttributes().getScope().isDistributedNoAck()) { Set<InternalDistributedMember> members = getDistributionAdvisor().adviseCacheOp(); StateFlushOperation.flushTo(members, this); } } if (armLockTestHook != null) { armLockTestHook.afterLock(this, null); } }
protected DistributedRegion createAndDefineRegion(boolean isConcurrencyChecksEnabled, RegionAttributes ra, InternalRegionArguments ira, GemFireCacheImpl cache) { DistributedRegion region = new DistributedRegion("testRegion", ra, null, cache, ira); if (isConcurrencyChecksEnabled) { region.enableConcurrencyChecks(); } // since it is a real region object, we need to tell mockito to monitor it region = spy(region); doNothing().when(region).distributeUpdate(any(), anyLong(), anyBoolean(), anyBoolean(), any(), anyBoolean()); doNothing().when(region).distributeDestroy(any(), any()); doNothing().when(region).distributeInvalidate(any()); doNothing().when(region).distributeUpdateEntryVersion(any()); return region; }
@Override public void initialCriticalMembers(boolean localMemoryIsCritical, Set<InternalDistributedMember> criticalMembers) { Set<InternalDistributedMember> others = getCacheDistributionAdvisor().adviseGeneric(); for (InternalDistributedMember idm : criticalMembers) { if (others.contains(idm)) { addCriticalMember(idm); } } }
@Override public void performRemoveAllEntry(EntryEventImpl event) { // force shared data view so that we just do the virtual op, accruing things in the bulk // operation for later if (isTX()) { event.getRemoveAllOperation().addEntry(event); } else { basicDestroy(event, true, null); } }
@Override protected boolean operateOnRegion(CacheEvent event, ClusterDistributionManager dm) throws EntryNotFoundException { EntryEventImpl ev = (EntryEventImpl) event; DistributedRegion rgn = (DistributedRegion) ev.getRegion(); try { if (!rgn.isCacheContentProxy()) { if (logger.isTraceEnabled()) { logger.trace("InvalidateMessage.operationOnRegion; key={}", ev.getKey()); } // if this is a mirrored region and we're still initializing, or // concurrency conflict detection is enabled (requiring version # // retention) then force new entry creation boolean forceNewEntry = rgn.getDataPolicy().withReplication() && (!rgn.isInitialized() || rgn.getConcurrencyChecksEnabled()); boolean invokeCallbacks = rgn.isInitialized(); rgn.basicInvalidate(ev, invokeCallbacks, forceNewEntry); } this.appliedOperation = true; return true; } catch (ConcurrentCacheModificationException e) { dispatchElidedEvent(rgn, ev); return true; // concurrent modification problems are not reported to senders } }
if (this.region.isUsedForSerialGatewaySenderQueue()) { AbstractGatewaySender sender = this.region.getSerialGatewaySender(); if (sender != null) { InternalDistributedMember primary = sender.getSenderAdvisor().advisePrimaryGatewaySender(); long giiStart = this.region.getCachePerfStats().startGetInitialImage(); InternalDistributedMember provider = null; PersistenceAdvisor persistenceAdvisor = this.region.getPersistenceAdvisor(); if (persistenceAdvisor != null) { try { persistenceAdvisor.updateMembershipView(recipient, targetReinitialized); persistenceAdvisor.setInitializing(this.region.getPersistentID()); } catch (ReplyException e) { if (isDebugEnabled) { (ClusterDistributionManager) this.region.getDistributionManager(); boolean allowDeltaGII = true; if (FORCE_FULL_GII || recipient.getVersionObject().compareTo(Version.GFE_80) < 0) { RegionVersionVector received_rvv = null; RegionVersionVector remote_rvv = null; if (this.region.getConcurrencyChecksEnabled() && recipient.getVersionObject().compareTo(Version.GFE_80) >= 0) { if (internalBeforeRequestRVV != null && internalBeforeRequestRVV.getRegionName().equals(this.region.getName())) { internalBeforeRequestRVV.run(); keysOfUnfinishedOps = processReceivedRVV(remote_rvv, recoveredRVV);
boolean recoverFromDisk, PersistentMemberID persistentId) throws TimeoutException { logger.info("Initializing region {}", this.getName()); ImageState imgState = getImageState(); imgState.init(); boolean targetRecreated = internalRegionArgs.getRecreateFlag(); if (this.getDataPolicy().withPersistence()) { targetProvider = new CreatePersistentRegionProcessor(this, getPersistenceAdvisor(), recoverFromDisk); } else { if (this.getDataPolicy().withPersistence()) { recovered_rvv = this.getVersionVector() == null ? null : this.getVersionVector().getCloneForTransmission(); if (!isInternalRegion()) { if (!this.isDestroyed) { this.cache.getInternalResourceManager().addResourceListener(ResourceType.MEMORY, this); releaseBeforeGetInitialImageLatch(); logger.debug( "DistributedRegion.getInitialImageAndRecovery: About to load snapshot, isInitialized={}; {}", isInitialized(), getFullPath()); loadSnapshotDuringInitialization(snapshotInputStream); } catch (IOException e) {
DistributionManager mgr = region.getDistributionManager(); boolean reliableOp = isOperationReliable() && region.requiresReliabilityCheck(); if (region.getDataPolicy().withPersistence()) { persistentIds = region.getDistributionAdvisor().adviseInitializedPersistentMembers(); if (region.isUsedForPartitionedRegionBucket()) { twoMessages = ((Bucket) region).getBucketAdvisor().adviseRequiresTwoMessages(); routingComputed = true; if (this.supportsAdjunctMessaging() && region.isUsedForPartitionedRegionBucket()) { BucketRegion br = (BucketRegion) region; adjunctRecipients = getAdjunctReceivers(br, recipients, twoMessages, filterRouting); } else { needsOldValueInCacheOp = region.getCacheDistributionAdvisor().adviseRequiresOldValueInCacheOp(); Set adviseCacheServers; Set<InternalDistributedMember> cachelessNodesWithNoCacheServer = new HashSet<>(); if (region.getDistributionConfig().getDeltaPropagation() && this.supportsDeltaPropagation()) { cachelessNodes = region.getCacheDistributionAdvisor().adviseEmptys(); if (!cachelessNodes.isEmpty()) { List list = new ArrayList(cachelessNodes); adviseCacheServers = region.getCacheDistributionAdvisor().adviseCacheServers(); cachelessNodesWithNoCacheServer.removeAll(adviseCacheServers); if (region.isInternalRegion()) {
DiskRegion dskRgn = getDiskRegion(); if (!getRegionMap().isEmpty()) { lockFailedInitialImageWriteLock(); try { closeEntries(); if (getDiskRegion() != null) { getDiskRegion().clear(this, null); getImageState().getLeftMembers(); getImageState().getVersionTags(); unlockFailedInitialImageWriteLock();
@Test public void cleanUpAfterFailedInitialImageHoldsLockForClear() { DistributedRegion distributedRegion = mock(DistributedRegion.class, RETURNS_DEEP_STUBS); RegionMap regionMap = mock(RegionMap.class); doCallRealMethod().when(distributedRegion).cleanUpAfterFailedGII(false); when(distributedRegion.getRegionMap()).thenReturn(regionMap); when(regionMap.isEmpty()).thenReturn(false); distributedRegion.cleanUpAfterFailedGII(false); verify(distributedRegion).lockFailedInitialImageWriteLock(); verify(distributedRegion).closeEntries(); verify(distributedRegion).unlockFailedInitialImageWriteLock(); }
DistributionManager dm = region.getDistributionManager(); boolean initialized = region.isInitialized(); if (initialized) { region.getDistributionAdvisor().forceNewMembershipVersion(); try { region.getDistributionAdvisor().waitForCurrentOperations(); } catch (RegionDestroyedException ignore) { return; if (region.getRegionMap().getARMLockTestHook() != null) { region.getRegionMap().getARMLockTestHook().beforeStateFlushWait();
@Override protected void removeSenderFromAdvisor(InternalDistributedMember sender, int serial, boolean regionDestroyed) { getDistributionAdvisor().removeIdWithSerial(sender, serial, regionDestroyed); }
private void putNewValueInRegion(boolean isCreate, EntryEventImpl clientEvent, long lastModified, EntryEventImpl event) { RegionEntry re = null; // Set eventId. Required for interested clients. event.setNewEventId(cache.getDistributedSystem()); long startPut = CachePerfStats.getStatTime(); validateKey(event.getKey()); // this next step also distributes the object to other processes, if necessary try { re = basicPutEntry(event, lastModified); // Update client event with latest version tag from re. if (re != null && clientEvent != null) { clientEvent.setVersionTag(event.getVersionTag()); } if (!isTX()) { getCachePerfStats().endPut(startPut, event.isOriginRemote()); } } catch (ConcurrentCacheModificationException e) { // the cache was modified while we were searching for this entry and // the netsearch result was elided. Return the current value from the cache updateEventWithCurrentRegionEntry(event, clientEvent); } catch (CacheWriterException cwe) { if (logger.isDebugEnabled()) { logger.debug("findObjectInSystem: writer exception putting entry {} : {}", event, cwe); } } if (isCreate) { recordMiss(re, event.getKey()); } }
@Test public void testClientEventIsUpdatedWithCurrentEntryVersionTagAfterSearchConcurrencyException() { DistributedRegion region = prepare(true); EntryEventImpl event = createDummyEvent(region); region.basicInvalidate(event); VersionTag tag = createVersionTag(true); RegionEntry re = mock(RegionEntry.class); VersionStamp stamp = mock(VersionStamp.class); doReturn(re).when(region).getRegionEntry(any()); when(re.getVersionStamp()).thenReturn(stamp); when(stamp.asVersionTag()).thenReturn(tag); createSearchLoad(); doThrow(new ConcurrentCacheModificationException()).when(region) .basicPutEntry(any(EntryEventImpl.class), anyLong()); KeyInfo ki = new KeyInfo(event.getKey(), null, null); region.findObjectInSystem(ki, false, null, false, null, false, false, null, event, false); assertNotNull("ClientEvent version tag is not set with region version tag.", event.getVersionTag()); }
when(prRoot.getDistributionAdvisor()).thenReturn(cda); doNothing().when(cda).addMembershipListener(any()); when(cache.createVMRegion(eq(PR_ROOT_REGION_NAME), any(), any())).thenReturn(prRoot); when(prRoot.get("rid")).thenReturn(prConfig); repoManager = new PartitionedRepositoryManager(indexForPR, serializer, Executors.newSingleThreadExecutor());
protected void waitForCurrentOperations() { // Fix for #48066 - make sure that region operations are completely // distributed to peers before destroying the region. boolean flushOnClose = !Boolean.getBoolean(DistributionConfig.GEMFIRE_PREFIX + "no-flush-on-close"); // test hook if (!this.cache.forcedDisconnect() && flushOnClose && this.getDistributionManager().getMembershipManager() != null && this.getDistributionManager().getMembershipManager().isConnected()) { getDistributionAdvisor().forceNewMembershipVersion(); try { getDistributionAdvisor().waitForCurrentOperations(); } catch (Exception e) { // log this but try to close the region so that listeners are invoked logger.warn(String.format("%s: error closing region %s", new Object[] {this, getFullPath()}), e); } } }
@Test public void cleanUpAfterFailedInitialImageDoesNotCloseEntriesIfIsPersistentRegionAndRecoveredFromDisk() { DistributedRegion distributedRegion = mock(DistributedRegion.class); DiskRegion diskRegion = mock(DiskRegion.class); doCallRealMethod().when(distributedRegion).cleanUpAfterFailedGII(true); when(distributedRegion.getDiskRegion()).thenReturn(diskRegion); when(diskRegion.isBackup()).thenReturn(true); distributedRegion.cleanUpAfterFailedGII(true); verify(diskRegion).resetRecoveredEntries(eq(distributedRegion)); verify(distributedRegion, never()).closeEntries(); }
@Test public void testThatMemoryThresholdInfoRelectsStateOfRegion() { InternalDistributedMember internalDM = mock(InternalDistributedMember.class); DistributedRegion distRegion = prepare(true, false); distRegion.addCriticalMember(internalDM); MemoryThresholdInfo info = distRegion.getAtomicThresholdInfo(); assertThat(distRegion.isMemoryThresholdReached()).isTrue(); assertThat(distRegion.getAtomicThresholdInfo().getMembersThatReachedThreshold()) .containsExactly(internalDM); assertThat(info.isMemoryThresholdReached()).isTrue(); assertThat(info.getMembersThatReachedThreshold()).containsExactly(internalDM); }