Examples with ForcedDisconnectException org.apache.geode.ForcedDisconnectException used on opensource projects

Example 1 with ForcedDisconnectException

use of org.apache.geode.ForcedDisconnectException 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
}

Example 2 with ForcedDisconnectException

use of org.apache.geode.ForcedDisconnectException in project geode by apache.

the class JGroupsMessengerJUnitTest method testChannelStillConnectedStopAfterForcedDisconnectWithoutAutoReconnect.

@Test
public void testChannelStillConnectedStopAfterForcedDisconnectWithoutAutoReconnect() throws Exception {
    initMocks(false);
    doCallRealMethod().when(services).setShutdownCause(any(ForcedDisconnectException.class));
    doCallRealMethod().when(services).getShutdownCause();
    doCallRealMethod().when(services).emergencyClose();
    doReturn(true).when(services).isShutdownDueToForcedDisconnect();
    doReturn(false).when(services).isAutoReconnectEnabled();
    doReturn(false).when(manager).isReconnectingDS();
    services.setShutdownCause(new ForcedDisconnectException("Test Forced Disconnect"));
    assertTrue(messenger.myChannel.isConnected());
    messenger.stop();
    assertFalse(messenger.myChannel.isConnected());
}

Example 3 with ForcedDisconnectException

use of org.apache.geode.ForcedDisconnectException in project geode by apache.

the class JGroupsMessengerJUnitTest method testChannelStillConnectedStopNotForcedDisconnectWithAutoReconnect.

@Test
public void testChannelStillConnectedStopNotForcedDisconnectWithAutoReconnect() throws Exception {
    initMocks(false);
    doCallRealMethod().when(services).setShutdownCause(any(ForcedDisconnectException.class));
    doCallRealMethod().when(services).getShutdownCause();
    doCallRealMethod().when(services).emergencyClose();
    doReturn(false).when(services).isShutdownDueToForcedDisconnect();
    doReturn(true).when(services).isAutoReconnectEnabled();
    doReturn(false).when(manager).isReconnectingDS();
    services.setShutdownCause(new ForcedDisconnectException("Test Forced Disconnect"));
    assertTrue(messenger.myChannel.isConnected());
    messenger.stop();
    assertFalse(messenger.myChannel.isConnected());
}

Example 4 with ForcedDisconnectException

use of org.apache.geode.ForcedDisconnectException in project geode by apache.

the class JGroupsMessengerJUnitTest method testChannelStillConnectedAfterEmergencyCloseAfterForcedDisconnectWithAutoReconnect.

@Test
public void testChannelStillConnectedAfterEmergencyCloseAfterForcedDisconnectWithAutoReconnect() throws Exception {
    initMocks(false);
    doCallRealMethod().when(services).setShutdownCause(any(ForcedDisconnectException.class));
    doCallRealMethod().when(services).getShutdownCause();
    doCallRealMethod().when(services).emergencyClose();
    doCallRealMethod().when(services).isShutdownDueToForcedDisconnect();
    doCallRealMethod().when(services).isAutoReconnectEnabled();
    services.setShutdownCause(new ForcedDisconnectException("Test Forced Disconnect"));
    assertTrue(messenger.myChannel.isConnected());
    messenger.emergencyClose();
    assertTrue(messenger.myChannel.isConnected());
}

Example 5 with ForcedDisconnectException

use of org.apache.geode.ForcedDisconnectException in project geode by apache.

the class JGroupsMessengerJUnitTest method testChannelStillConnectedAfterStopAfterForcedDisconnectWithAutoReconnect.

@Test
public void testChannelStillConnectedAfterStopAfterForcedDisconnectWithAutoReconnect() throws Exception {
    initMocks(false);
    doCallRealMethod().when(services).setShutdownCause(any(ForcedDisconnectException.class));
    doCallRealMethod().when(services).getShutdownCause();
    doCallRealMethod().when(services).emergencyClose();
    doCallRealMethod().when(services).isShutdownDueToForcedDisconnect();
    doCallRealMethod().when(services).isAutoReconnectEnabled();
    services.setShutdownCause(new ForcedDisconnectException("Test Forced Disconnect"));
    assertTrue(messenger.myChannel.isConnected());
    messenger.stop();
    assertTrue(messenger.myChannel.isConnected());
}