/** * To reduce the number of times we need to call calculateNow, you can call this method to set now * in a thread local. When the run returns the thread local is cleared. */ static void doWithNowSet(LocalRegion lr, Runnable runnable) { now.set(calculateNow(lr.getCache())); try { runnable.run(); } finally { now.remove(); } }
private void setupLocalRegion() { when(owner.getCachePerfStats()).thenReturn(cachePerfStats); when(owner.getCache()).thenReturn(mock(InternalCache.class)); when(owner.getMyId()).thenReturn(myId); when(owner.getKeyInfo(any(), any(), any())).thenReturn(keyInfo); }
private void checkCCRegionTombstoneCount(String msg, int expected) { int actual = CCRegion.getTombstoneCount(); if (expected != actual) { assertThat(actual) .describedAs(msg + " region tombstone count was " + actual + " expected=" + expected + " TombstoneService=" + CCRegion.getCache().getTombstoneService()) .isEqualTo(expected); } }
private boolean isJTAPaused() { TXManagerImpl txMgr = (TXManagerImpl) getCache().getCacheTransactionManager(); return txMgr.isJTAPaused(); }
private boolean isTransactionPaused() { TXManagerImpl txMgr = (TXManagerImpl) getCache().getCacheTransactionManager(); return txMgr.isTransactionPaused(); }
public long calculateNow() { return calculateNow(getLocalRegion().getCache()); }
protected boolean isCacheClosing() { return getLocalRegion().getCache().isClosed(); }
boolean isParallelWanEnabled() { Set<String> regionGatewaySenderIds = this.getAllGatewaySenderIds(); if (regionGatewaySenderIds.isEmpty()) { return false; } Set<GatewaySender> cacheGatewaySenders = getCache().getAllGatewaySenders(); for (GatewaySender sender : cacheGatewaySenders) { if (regionGatewaySenderIds.contains(sender.getId()) && sender.isParallel()) { return true; } } return false; }
@SuppressWarnings({"rawtypes", "unchecked"}) protected Object callCacheLoader(CacheLoader loader, final Object key, final Object aCallbackArgument, boolean preferCD) { LoaderHelper loaderHelper = this.loaderHelperFactory.createLoaderHelper(key, aCallbackArgument, false /* netSearchAllowed */, true /* netloadAllowed */, null /* searcher */); Object result = loader.load(loaderHelper); result = this.getCache().convertPdxInstanceIfNeeded(result, preferCD); return result; }
@Override public String cancelInProgress() { // This grossness is necessary because there are instances where the // region can exist without having a cache (XML creation) checkFailure(); Cache cache = LocalRegion.this.getCache(); if (cache == null) { return "The cache is not available"; } return cache.getCancelCriterion().cancelInProgress(); }
public RegionEventImpl(Region region, Operation op, Object callbackArgument, boolean originRemote, DistributedMember distributedMember, boolean generateEventID) { this.region = (LocalRegion) region; this.regionPath = region.getFullPath(); this.op = op; this.callbackArgument = callbackArgument; this.originRemote = originRemote; this.distributedMember = distributedMember; DistributedSystem sys = ((LocalRegion) region).getCache().getDistributedSystem(); if (generateEventID) { this.eventId = new EventID(sys); } }
@Override public RuntimeException generateCancelledException(Throwable e) { // This grossness is necessary because there are instances where the // region can exist without having a cache (XML creation) checkFailure(); Cache cache = LocalRegion.this.getCache(); if (cache == null) { return new CacheClosedException("No cache", e); } return cache.getCancelCriterion().generateCancelledException(e); }
boolean bridgePutIfAbsentResultHasSameValue(byte[] valueToBePut, boolean isValueToBePutObject, Object result) { if (Token.isInvalid(result) || result == null) { return valueToBePut == null; } boolean isCompressedOffHeap = getAttributes().getOffHeap() && getAttributes().getCompressor() != null; if (isValueToBePutObject) { return ValueComparisonHelper.checkEquals(EntryEventImpl.deserialize(valueToBePut), result, isCompressedOffHeap, getCache()); } return ValueComparisonHelper.checkEquals(valueToBePut, result, isCompressedOffHeap, getCache()); }
@Test public void startAndStopAddAndRemoveTrackerFromExpiryTask() { EventTrackerExpiryTask task = mock(EventTrackerExpiryTask.class); InternalCache cache = mock(InternalCache.class); when(region.getCache()).thenReturn(cache); when(cache.getEventTrackerTask()).thenReturn(task); eventTracker = new DistributedEventTracker(region.getCache(), mock(CancelCriterion.class), region.getName()); eventTracker.start(); verify(task, times(1)).addTracker(eventTracker); eventTracker.stop(); verify(task, times(1)).removeTracker(eventTracker); }
private void sendPendingRegionDestroyEvents(Set regionEvents) { for (Object regionEvent : regionEvents) { RegionEventImpl regionEventImpl = (RegionEventImpl) regionEvent; regionEventImpl.region.dispatchListenerEvent(EnumListenerEvent.AFTER_REGION_DESTROY, regionEventImpl); if (!this.cache.forcedDisconnect()) { SystemMemberCacheEventProcessor.send(getCache(), regionEventImpl.getRegion(), regionEventImpl.getOperation()); } } }
@Before public void setup() { region = mock(LocalRegion.class); regionAttributes = mock(RegionAttributes.class); when(region.createStopper()).thenCallRealMethod(); memberId = mock(ClientProxyMembershipID.class); when(region.getAttributes()).thenReturn(regionAttributes); when(regionAttributes.getDataPolicy()).thenReturn(mock(DataPolicy.class)); when(region.getConcurrencyChecksEnabled()).thenReturn(true); member = mock(DistributedMember.class); eventTracker = new DistributedEventTracker(region.getCache(), mock(CancelCriterion.class), region.getName()); }
boolean putIfAbsentResultHasSameValue(boolean isClient, Object valueToBePut, Object result) { if (Token.isInvalid(result) || result == null) { return valueToBePut == null; } boolean isCompressedOffHeap = isClient ? false : getAttributes().getOffHeap() && getAttributes().getCompressor() != null; return ValueComparisonHelper.checkEquals(valueToBePut, result, isCompressedOffHeap, getCache()); }
private void waitForAllTombstonesToExpire(int initialTombstoneCount) { try { await() .until(() -> CCRegion.getTombstoneCount() == 0); } catch (ConditionTimeoutException timeout) { fail("Timed out waiting for all tombstones to expire. There are now " + CCRegion.getTombstoneCount() + " tombstones left out of " + initialTombstoneCount + " initial tombstones. " + CCRegion.getCache().getTombstoneService(), timeout); } }
@Test public void returnsCorrectNameOfCache() { String testName = "testing"; when(region.getName()).thenReturn(testName); eventTracker = new DistributedEventTracker(region.getCache(), mock(CancelCriterion.class), region.getName()); assertEquals("Event Tracker for " + testName, eventTracker.getName()); }
private boolean mustEvict() { LocalRegion owner = _getOwner(); InternalResourceManager resourceManager = owner.getCache().getInternalResourceManager(); boolean offheap = owner.getAttributes().getOffHeap(); return resourceManager.getMemoryMonitor(offheap).getState().isEviction() && this.sizeInVM() > 0; }