use of org.apache.geode.distributed.internal.ReplyProcessor21 in project geode by apache.
the class LuceneIndexForPartitionedRegion method destroyOnRemoteMembers.
private void destroyOnRemoteMembers() {
PartitionedRegion pr = (PartitionedRegion) getDataRegion();
DM dm = pr.getDistributionManager();
Set<InternalDistributedMember> recipients = pr.getRegionAdvisor().adviseAllPRNodes();
if (!recipients.isEmpty()) {
if (logger.isDebugEnabled()) {
logger.debug("LuceneIndexForPartitionedRegion: About to send destroy message recipients=" + recipients);
}
ReplyProcessor21 processor = new ReplyProcessor21(dm, recipients);
DestroyLuceneIndexMessage message = new DestroyLuceneIndexMessage(recipients, processor.getProcessorId(), regionPath, indexName);
dm.putOutgoing(message);
if (logger.isDebugEnabled()) {
logger.debug("LuceneIndexForPartitionedRegion: Sent message recipients=" + recipients);
}
try {
processor.waitForReplies();
} catch (ReplyException e) {
if (!(e.getCause() instanceof CancelException)) {
throw e;
}
} catch (InterruptedException e) {
dm.getCancelCriterion().checkCancelInProgress(e);
Thread.currentThread().interrupt();
}
}
}
use of org.apache.geode.distributed.internal.ReplyProcessor21 in project geode by apache.
the class GMSMembershipManagerJUnitTest method testReplyProcessorInitiatesSuspicion.
@Test
public void testReplyProcessorInitiatesSuspicion() throws Exception {
DM dm = mock(DM.class);
DMStats stats = mock(DMStats.class);
InternalDistributedSystem system = InternalDistributedSystem.newInstanceForTesting(dm, distProperties);
when(dm.getStats()).thenReturn(stats);
when(dm.getSystem()).thenReturn(system);
when(dm.getCancelCriterion()).thenReturn(stopper);
when(dm.getMembershipManager()).thenReturn(manager);
when(dm.getViewMembers()).thenReturn(members);
when(dm.getDistributionManagerIds()).thenReturn(new HashSet(members));
when(dm.addMembershipListenerAndGetDistributionManagerIds(any(MembershipListener.class))).thenReturn(new HashSet(members));
manager.start();
manager.started();
manager.isJoining = true;
List<InternalDistributedMember> viewmembers = Arrays.asList(new InternalDistributedMember[] { mockMembers[0], mockMembers[1], myMemberId });
manager.installView(new NetView(myMemberId, 2, viewmembers));
List<InternalDistributedMember> mbrs = new ArrayList<>(1);
mbrs.add(mockMembers[0]);
ReplyProcessor21 rp = new ReplyProcessor21(dm, mbrs);
rp.enableSevereAlertProcessing();
boolean result = rp.waitForReplies(WAIT_FOR_REPLIES_MILLIS);
// the wait should have timed out
assertFalse(result);
verify(healthMonitor, atLeastOnce()).checkIfAvailable(isA(InternalDistributedMember.class), isA(String.class), isA(Boolean.class));
}
use of org.apache.geode.distributed.internal.ReplyProcessor21 in project geode by apache.
the class AdminWaiters method sendResponse.
/**
* Call to send a {@link AdminResponse} and notify the thread waiting for it.
*/
public static void sendResponse(AdminResponse msg) {
int id = msg.getMsgId();
ReplyProcessor21 processor = (ReplyProcessor21) ReplyProcessor21.getProcessor(id);
if (processor == null) {
// must've been cancelled
return;
} else {
processor.process(msg);
}
}
use of org.apache.geode.distributed.internal.ReplyProcessor21 in project geode by apache.
the class GemFireCacheImpl method close.
public void close(String reason, Throwable systemFailureCause, boolean keepAlive, boolean keepDS) {
this.securityService.close();
if (isClosed()) {
return;
}
final boolean isDebugEnabled = logger.isDebugEnabled();
synchronized (GemFireCacheImpl.class) {
// static synchronization is necessary due to static resources
if (isClosed()) {
return;
}
/*
* First close the ManagementService as it uses a lot of infra which will be closed by
* cache.close()
*/
this.system.handleResourceEvent(ResourceEvent.CACHE_REMOVE, this);
if (this.resourceEventsListener != null) {
this.system.removeResourceListener(this.resourceEventsListener);
this.resourceEventsListener = null;
}
if (systemFailureCause != null) {
this.forcedDisconnect = systemFailureCause instanceof ForcedDisconnectException;
if (this.forcedDisconnect) {
this.disconnectCause = new ForcedDisconnectException(reason);
} else {
this.disconnectCause = systemFailureCause;
}
}
this.keepAlive = keepAlive;
this.isClosing = true;
logger.info(LocalizedMessage.create(LocalizedStrings.GemFireCache_0_NOW_CLOSING, this));
// available to anyone "fishing" for a cache...
if (GemFireCacheImpl.instance == this) {
GemFireCacheImpl.instance = null;
}
// threads may be hung trying to communicate with the map locked
if (systemFailureCause == null) {
PartitionedRegion.clearPRIdMap();
}
TXStateProxy tx = null;
try {
if (this.transactionManager != null) {
tx = this.transactionManager.internalSuspend();
}
// do this before closing regions
this.resourceManager.close();
try {
this.resourceAdvisor.close();
} catch (CancelException ignore) {
// ignore
}
try {
this.jmxAdvisor.close();
} catch (CancelException ignore) {
// ignore
}
for (GatewaySender sender : this.allGatewaySenders) {
try {
sender.stop();
GatewaySenderAdvisor advisor = ((AbstractGatewaySender) sender).getSenderAdvisor();
if (advisor != null) {
if (isDebugEnabled) {
logger.debug("Stopping the GatewaySender advisor");
}
advisor.close();
}
} catch (CancelException ignore) {
}
}
destroyGatewaySenderLockService();
if (this.eventThreadPool != null) {
if (isDebugEnabled) {
logger.debug("{}: stopping event thread pool...", this);
}
this.eventThreadPool.shutdown();
}
/*
* IMPORTANT: any operation during shut down that can time out (create a CancelException)
* must be inside of this try block. If all else fails, we *must* ensure that the cache gets
* closed!
*/
try {
this.stopServers();
stopMemcachedServer();
stopRedisServer();
stopRestAgentServer();
// cacheServers or gatewayHubs
if (this.partitionedRegions != null) {
if (isDebugEnabled) {
logger.debug("{}: clearing partitioned regions...", this);
}
synchronized (this.partitionedRegions) {
int prSize = -this.partitionedRegions.size();
this.partitionedRegions.clear();
getCachePerfStats().incPartitionedRegions(prSize);
}
}
prepareDiskStoresForClose();
if (GemFireCacheImpl.pdxInstance == this) {
GemFireCacheImpl.pdxInstance = null;
}
List<LocalRegion> rootRegionValues;
synchronized (this.rootRegions) {
rootRegionValues = new ArrayList<>(this.rootRegions.values());
}
{
final Operation op;
if (this.forcedDisconnect) {
op = Operation.FORCED_DISCONNECT;
} else if (isReconnecting()) {
op = Operation.CACHE_RECONNECT;
} else {
op = Operation.CACHE_CLOSE;
}
LocalRegion prRoot = null;
for (LocalRegion lr : rootRegionValues) {
if (isDebugEnabled) {
logger.debug("{}: processing region {}", this, lr.getFullPath());
}
if (PartitionedRegionHelper.PR_ROOT_REGION_NAME.equals(lr.getName())) {
prRoot = lr;
} else {
if (lr.getName().contains(ParallelGatewaySenderQueue.QSTRING)) {
// this region will be closed internally by parent region
continue;
}
if (isDebugEnabled) {
logger.debug("{}: closing region {}...", this, lr.getFullPath());
}
try {
lr.handleCacheClose(op);
} catch (RuntimeException e) {
if (isDebugEnabled || !this.forcedDisconnect) {
logger.warn(LocalizedMessage.create(LocalizedStrings.GemFireCache_0_ERROR_CLOSING_REGION_1, new Object[] { this, lr.getFullPath() }), e);
}
}
}
}
try {
if (isDebugEnabled) {
logger.debug("{}: finishing partitioned region close...", this);
}
PartitionedRegion.afterRegionsClosedByCacheClose(this);
if (prRoot != null) {
// do the PR meta root region last
prRoot.handleCacheClose(op);
}
} catch (CancelException e) {
logger.warn(LocalizedMessage.create(LocalizedStrings.GemFireCache_0_ERROR_IN_LAST_STAGE_OF_PARTITIONEDREGION_CACHE_CLOSE, this), e);
}
destroyPartitionedRegionLockService();
}
closeDiskStores();
this.diskMonitor.close();
// Close the CqService Handle.
try {
if (isDebugEnabled) {
logger.debug("{}: closing CQ service...", this);
}
this.cqService.close();
} catch (RuntimeException ignore) {
logger.info(LocalizedMessage.create(LocalizedStrings.GemFireCache_FAILED_TO_GET_THE_CQSERVICE_TO_CLOSE_DURING_CACHE_CLOSE_1));
}
PoolManager.close(keepAlive);
if (isDebugEnabled) {
logger.debug("{}: notifying admins of close...", this);
}
try {
SystemMemberCacheEventProcessor.send(this, Operation.CACHE_CLOSE);
} catch (CancelException ignore) {
if (logger.isDebugEnabled()) {
logger.debug("Ignored cancellation while notifying admins");
}
}
if (isDebugEnabled) {
logger.debug("{}: stopping destroyed entries processor...", this);
}
this.tombstoneService.stop();
// NOTICE: the CloseCache message is the *last* message you can send!
DM distributionManager = null;
try {
distributionManager = this.system.getDistributionManager();
distributionManager.removeMembershipListener(this.transactionManager);
} catch (CancelException ignore) {
// distributionManager = null;
}
if (distributionManager != null) {
// Send CacheClosedMessage (and NOTHING ELSE) here
if (isDebugEnabled) {
logger.debug("{}: sending CloseCache to peers...", this);
}
Set otherMembers = distributionManager.getOtherDistributionManagerIds();
ReplyProcessor21 processor = new ReplyProcessor21(this.system, otherMembers);
CloseCacheMessage msg = new CloseCacheMessage();
msg.setRecipients(otherMembers);
msg.setProcessorId(processor.getProcessorId());
distributionManager.putOutgoing(msg);
try {
processor.waitForReplies();
} catch (InterruptedException ignore) {
// Thread.currentThread().interrupt(); // TODO ??? should we reset this bit later?
// Keep going, make best effort to shut down.
} catch (ReplyException ignore) {
// keep going
}
// set closed state after telling others and getting responses
// to avoid complications with others still in the process of
// sending messages
}
// NO MORE Distributed Messaging AFTER THIS POINT!!!!
ClientMetadataService cms = this.clientMetadataService;
if (cms != null) {
cms.close();
}
closeHeapEvictor();
closeOffHeapEvictor();
} catch (CancelException ignore) {
// make sure the disk stores get closed
closeDiskStores();
// NO DISTRIBUTED MESSAGING CAN BE DONE HERE!
}
// Close the CqService Handle.
try {
this.cqService.close();
} catch (RuntimeException ignore) {
logger.info(LocalizedMessage.create(LocalizedStrings.GemFireCache_FAILED_TO_GET_THE_CQSERVICE_TO_CLOSE_DURING_CACHE_CLOSE_2));
}
this.cachePerfStats.close();
TXLockService.destroyServices();
EventTracker.stopTrackerServices(this);
synchronized (this.ccpTimerMutex) {
if (this.ccpTimer != null) {
this.ccpTimer.cancel();
}
}
this.expirationScheduler.cancel();
// Stop QueryMonitor if running.
if (this.queryMonitor != null) {
this.queryMonitor.stopMonitoring();
}
stopDiskStoreTaskPool();
} finally {
// NO DISTRIBUTED MESSAGING CAN BE DONE HERE!
if (this.transactionManager != null) {
this.transactionManager.close();
}
((DynamicRegionFactoryImpl) DynamicRegionFactory.get()).close();
if (this.transactionManager != null) {
this.transactionManager.internalResume(tx);
}
TXCommitMessage.getTracker().clearForCacheClose();
}
// Added to close the TransactionManager's cleanup thread
TransactionManagerImpl.refresh();
if (!keepDS) {
// keepDS is used by ShutdownAll. It will override DISABLE_DISCONNECT_DS_ON_CACHE_CLOSE
if (!this.DISABLE_DISCONNECT_DS_ON_CACHE_CLOSE) {
this.system.disconnect();
}
}
TypeRegistry.close();
// do this late to prevent 43412
TypeRegistry.setPdxSerializer(null);
for (CacheLifecycleListener listener : cacheLifecycleListeners) {
listener.cacheClosed(this);
}
// Fix for #49856
SequenceLoggerImpl.signalCacheClose();
SystemFailure.signalCacheClose();
}
// static synchronization on GemFireCache.class
}
use of org.apache.geode.distributed.internal.ReplyProcessor21 in project geode by apache.
the class MembershipFlushRequest method send.
public static void send(Set<InternalDistributedMember> recipients, DM dm, String regionPath) throws ReplyException {
ReplyProcessor21 processor = new ReplyProcessor21(dm, recipients);
MembershipFlushRequest msg = new MembershipFlushRequest(regionPath, processor.getProcessorId());
msg.setRecipients(recipients);
dm.putOutgoing(msg);
processor.waitForRepliesUninterruptibly();
}
Aggregations