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

Example 36 with CancelException

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

the class InternalDataSerializer method writePdx.

public static boolean writePdx(DataOutput out, InternalCache internalCache, Object pdx, PdxSerializer pdxSerializer) throws IOException {
    TypeRegistry tr = null;
    if (internalCache != null) {
        tr = internalCache.getPdxRegistry();
    }
    PdxOutputStream os;
    if (out instanceof HeapDataOutputStream) {
        os = new PdxOutputStream((HeapDataOutputStream) out);
    } else {
        os = new PdxOutputStream();
    }
    PdxWriterImpl writer = new PdxWriterImpl(tr, pdx, os);
    try {
        if (pdxSerializer != null) {
            // serializer
            if (isGemfireObject(pdx)) {
                return false;
            }
            if (is662SerializationEnabled()) {
                boolean alreadyInProgress = isPdxSerializationInProgress();
                if (!alreadyInProgress) {
                    setPdxSerializationInProgress(true);
                    try {
                        if (!pdxSerializer.toData(pdx, writer)) {
                            return false;
                        }
                    } finally {
                        setPdxSerializationInProgress(false);
                    }
                } else {
                    if (!pdxSerializer.toData(pdx, writer)) {
                        return false;
                    }
                }
            } else {
                if (!pdxSerializer.toData(pdx, writer)) {
                    return false;
                }
            }
        } else {
            if (is662SerializationEnabled()) {
                boolean alreadyInProgress = isPdxSerializationInProgress();
                if (!alreadyInProgress) {
                    setPdxSerializationInProgress(true);
                    try {
                        ((PdxSerializable) pdx).toData(writer);
                    } finally {
                        setPdxSerializationInProgress(false);
                    }
                } else {
                    ((PdxSerializable) pdx).toData(writer);
                }
            } else {
                ((PdxSerializable) pdx).toData(writer);
            }
        }
    } catch (ToDataException | CancelException | NonPortableClassException | GemFireRethrowable ex) {
        throw ex;
    } catch (VirtualMachineError err) {
        SystemFailure.initiateFailure(err);
        // now, so don't let this thread continue.
        throw err;
    } catch (Throwable t) {
        // Whenever you catch Error or Throwable, you must also
        // catch VirtualMachineError (see above). However, there is
        // _still_ a possibility that you are dealing with a cascading
        // error condition, so you also need to check to see if the JVM
        // is still usable:
        SystemFailure.checkFailure();
        if (pdxSerializer != null) {
            throw new ToDataException("PdxSerializer failed when calling toData on " + pdx.getClass(), t);
        } else {
            throw new ToDataException("toData failed on PdxSerializable " + pdx.getClass(), t);
        }
    }
    int bytesWritten = writer.completeByteStreamGeneration();
    getDMStats(internalCache).incPdxSerialization(bytesWritten);
    if (!(out instanceof HeapDataOutputStream)) {
        writer.sendTo(out);
    }
    return true;
}

Example 37 with CancelException

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

the class InternalDataSerializer method autoSerialized.

public static boolean autoSerialized(Object o, DataOutput out) throws IOException {
    AutoSerializableManager asm = TypeRegistry.getAutoSerializableManager();
    if (asm != null) {
        AutoClassInfo aci = asm.getExistingClassInfo(o.getClass());
        if (aci != null) {
            InternalCache internalCache = GemFireCacheImpl.getForPdx("PDX registry is unavailable because the Cache has been closed.");
            TypeRegistry tr = internalCache.getPdxRegistry();
            PdxOutputStream os;
            if (out instanceof HeapDataOutputStream) {
                os = new PdxOutputStream((HeapDataOutputStream) out);
            } else {
                os = new PdxOutputStream();
            }
            PdxWriterImpl writer = new PdxWriterImpl(tr, o, aci, os);
            try {
                if (is662SerializationEnabled()) {
                    boolean alreadyInProgress = isPdxSerializationInProgress();
                    if (!alreadyInProgress) {
                        setPdxSerializationInProgress(true);
                        try {
                            asm.writeData(writer, o, aci);
                        } finally {
                            setPdxSerializationInProgress(false);
                        }
                    } else {
                        asm.writeData(writer, o, aci);
                    }
                } else {
                    asm.writeData(writer, o, aci);
                }
            } catch (ToDataException | CancelException | NonPortableClassException | GemFireRethrowable ex) {
                throw ex;
            } catch (VirtualMachineError err) {
                SystemFailure.initiateFailure(err);
                // now, so don't let this thread continue.
                throw err;
            } catch (Throwable t) {
                // Whenever you catch Error or Throwable, you must also
                // catch VirtualMachineError (see above). However, there is
                // _still_ a possibility that you are dealing with a cascading
                // error condition, so you also need to check to see if the JVM
                // is still usable:
                SystemFailure.checkFailure();
                throw new ToDataException("PdxSerializer failed when calling toData on " + o.getClass(), t);
            }
            int bytesWritten = writer.completeByteStreamGeneration();
            getDMStats(internalCache).incPdxSerialization(bytesWritten);
            if (!(out instanceof HeapDataOutputStream)) {
                writer.sendTo(out);
            }
            return true;
        }
    }
    return false;
}

Example 38 with CancelException

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

the class DistributedCacheOperation method _distribute.

/**
   * About to distribute a cache operation to other members of the distributed system. This method
   * determines who the recipients are and handles careful delivery of the operation to those
   * members. This method should wrapped by startOperation() and endOperation() in try/finally
   * block.
   */
private void _distribute() {
    DistributedRegion region = getRegion();
    DM mgr = region.getDistributionManager();
    boolean reliableOp = isOperationReliable() && region.requiresReliabilityCheck();
    if (SLOW_DISTRIBUTION_MS > 0) {
        // test hook
        try {
            Thread.sleep(SLOW_DISTRIBUTION_MS);
        } catch (InterruptedException ignore) {
            Thread.currentThread().interrupt();
        }
        SLOW_DISTRIBUTION_MS = 0;
    }
    boolean isPutAll = (this instanceof DistributedPutAllOperation);
    boolean isRemoveAll = (this instanceof DistributedRemoveAllOperation);
    try {
        // Recipients with CacheOp
        Set<InternalDistributedMember> recipients = getRecipients();
        Map<InternalDistributedMember, PersistentMemberID> persistentIds = null;
        if (region.getDataPolicy().withPersistence()) {
            persistentIds = region.getDistributionAdvisor().adviseInitializedPersistentMembers();
        }
        // some members requiring old value are also in the cache op recipients set
        Set needsOldValueInCacheOp = Collections.emptySet();
        // set client routing information into the event
        boolean routingComputed = false;
        FilterRoutingInfo filterRouting = null;
        // recipients that will get a cacheop msg and also a PR message
        Set twoMessages = Collections.emptySet();
        if (region.isUsedForPartitionedRegionBucket()) {
            twoMessages = ((Bucket) region).getBucketAdvisor().adviseRequiresTwoMessages();
            routingComputed = true;
            filterRouting = getRecipientFilterRouting(recipients);
            if (filterRouting != null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Computed this filter routing: {}", filterRouting);
                }
            }
        }
        // some members need PR notification of the change for client/wan
        // notification
        Set adjunctRecipients = Collections.emptySet();
        // the operation's message
        if (this.supportsAdjunctMessaging() && region.isUsedForPartitionedRegionBucket()) {
            BucketRegion br = (BucketRegion) region;
            adjunctRecipients = getAdjunctReceivers(br, recipients, twoMessages, filterRouting);
        }
        EntryEventImpl entryEvent = event.getOperation().isEntry() ? getEvent() : null;
        if (entryEvent != null && entryEvent.hasOldValue()) {
            if (testSendingOldValues) {
                needsOldValueInCacheOp = new HashSet(recipients);
            } else {
                needsOldValueInCacheOp = region.getCacheDistributionAdvisor().adviseRequiresOldValueInCacheOp();
            }
            recipients.removeAll(needsOldValueInCacheOp);
        }
        Set cachelessNodes = Collections.emptySet();
        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);
                for (Object member : cachelessNodes) {
                    if (!recipients.contains(member) || adjunctRecipients.contains(member)) {
                        // Don't include those originally excluded.
                        list.remove(member);
                    }
                }
                cachelessNodes.clear();
                recipients.removeAll(list);
                cachelessNodes.addAll(list);
            }
            cachelessNodesWithNoCacheServer.addAll(cachelessNodes);
            adviseCacheServers = region.getCacheDistributionAdvisor().adviseCacheServers();
            cachelessNodesWithNoCacheServer.removeAll(adviseCacheServers);
        }
        if (recipients.isEmpty() && adjunctRecipients.isEmpty() && needsOldValueInCacheOp.isEmpty() && cachelessNodes.isEmpty()) {
            if (region.isInternalRegion()) {
                if (mgr.getNormalDistributionManagerIds().size() > 1) {
                    // suppress this msg if we are the only member.
                    if (logger.isTraceEnabled()) {
                        logger.trace("<No Recipients> {}", this);
                    }
                } else {
                    // suppress this msg if we are the only member.
                    if (logger.isDebugEnabled()) {
                        logger.debug("<No Recipients> {}", this);
                    }
                }
            }
            if (!reliableOp || region.isNoDistributionOk()) {
            // nothing needs be done in this case
            } else {
                region.handleReliableDistribution(Collections.emptySet());
            }
            // compute local client routing before waiting for an ack only for a bucket
            if (region.isUsedForPartitionedRegionBucket()) {
                FilterInfo filterInfo = getLocalFilterRouting(filterRouting);
                this.event.setLocalFilterInfo(filterInfo);
            }
        } else {
            boolean directAck = false;
            boolean useMulticast = region.getMulticastEnabled() && region.getSystem().getConfig().getMcastPort() != 0 && this.supportsMulticast();
            boolean shouldAck = shouldAck();
            if (shouldAck) {
                if (this.supportsDirectAck() && adjunctRecipients.isEmpty()) {
                    if (region.getSystem().threadOwnsResources()) {
                        directAck = true;
                    }
                }
            }
            // their own response. fixes bug #45973
            if (entryEvent != null) {
                RemoteOperationMessage rmsg = entryEvent.getRemoteOperationMessage();
                if (rmsg != null) {
                    recipients.remove(rmsg.getSender());
                    // bug #45106: can't mcast or the sender of the one-hop op will
                    useMulticast = false;
                // get it
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("recipients for {}: {} with adjunct messages to: {}", this, recipients, adjunctRecipients);
            }
            if (shouldAck) {
                // adjunct messages are sent using the same reply processor, so
                // add them to the processor's membership set
                Collection waitForMembers = null;
                if (recipients.size() > 0 && adjunctRecipients.size() == 0 && cachelessNodes.isEmpty()) {
                    // the
                    // common
                    // case
                    waitForMembers = recipients;
                } else if (!cachelessNodes.isEmpty()) {
                    waitForMembers = new HashSet(recipients);
                    waitForMembers.addAll(cachelessNodes);
                } else {
                    // note that we use a Vector instead of a Set for the responders
                    // collection
                    // because partitioned regions sometimes send both a regular cache
                    // operation and a partitioned-region notification message to the
                    // same recipient
                    waitForMembers = new Vector(recipients);
                    waitForMembers.addAll(adjunctRecipients);
                    waitForMembers.addAll(needsOldValueInCacheOp);
                    waitForMembers.addAll(cachelessNodes);
                }
                if (DistributedCacheOperation.LOSS_SIMULATION_RATIO != 0.0) {
                    if (LOSS_SIMULATION_GENERATOR == null) {
                        LOSS_SIMULATION_GENERATOR = new Random(this.hashCode());
                    }
                    if ((LOSS_SIMULATION_GENERATOR.nextInt(100) * 1.0 / 100.0) < LOSS_SIMULATION_RATIO) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("loss simulation is inhibiting message transmission to {}", recipients);
                        }
                        waitForMembers.removeAll(recipients);
                        recipients = Collections.emptySet();
                    }
                }
                if (reliableOp) {
                    this.departedMembers = new HashSet();
                    this.processor = new ReliableCacheReplyProcessor(region.getSystem(), waitForMembers, this.departedMembers);
                } else {
                    this.processor = new CacheOperationReplyProcessor(region.getSystem(), waitForMembers);
                }
            }
            Set failures = null;
            CacheOperationMessage msg = createMessage();
            initMessage(msg, this.processor);
            if (DistributedCacheOperation.internalBeforePutOutgoing != null) {
                DistributedCacheOperation.internalBeforePutOutgoing.run();
            }
            if (processor != null && msg.isSevereAlertCompatible()) {
                this.processor.enableSevereAlertProcessing();
                // if this message is distributing for a partitioned region message,
                // we can't wait as long as the full ack-severe-alert-threshold or
                // the sender might kick us out of the system before we can get an ack
                // back
                DistributedRegion r = getRegion();
                if (r.isUsedForPartitionedRegionBucket() && event.getOperation().isEntry()) {
                    PartitionMessage pm = ((EntryEventImpl) event).getPartitionMessage();
                    if (pm != null && pm.getSender() != null && !pm.getSender().equals(r.getDistributionManager().getDistributionManagerId())) {
                        // PR message sent by another member
                        ReplyProcessor21.setShortSevereAlertProcessing(true);
                    }
                }
            }
            msg.setMulticast(useMulticast);
            msg.directAck = directAck;
            if (region.isUsedForPartitionedRegionBucket()) {
                if (!isPutAll && !isRemoveAll && filterRouting != null && filterRouting.hasMemberWithFilterInfo()) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Setting filter information for message to {}", filterRouting);
                    }
                    msg.filterRouting = filterRouting;
                }
            } else if (!routingComputed) {
                msg.needsRouting = true;
            }
            initProcessor(processor, msg);
            if (region.cache.isClosed() && !canBeSentDuringShutdown()) {
                throw region.cache.getCacheClosedException(LocalizedStrings.DistributedCacheOperation_THE_CACHE_HAS_BEEN_CLOSED.toLocalizedString(), null);
            }
            msg.setRecipients(recipients);
            failures = mgr.putOutgoing(msg);
            // distribute to members needing the old value now
            if (needsOldValueInCacheOp.size() > 0) {
                msg.appendOldValueToMessage((EntryEventImpl) this.event);
                msg.resetRecipients();
                msg.setRecipients(needsOldValueInCacheOp);
                Set newFailures = mgr.putOutgoing(msg);
                if (newFailures != null) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Failed sending ({}) to {}", msg, newFailures);
                    }
                    if (failures != null && failures.size() > 0) {
                        failures.addAll(newFailures);
                    } else {
                        failures = newFailures;
                    }
                }
            }
            if (cachelessNodes.size() > 0) {
                cachelessNodes.removeAll(cachelessNodesWithNoCacheServer);
                if (cachelessNodes.size() > 0) {
                    msg.resetRecipients();
                    msg.setRecipients(cachelessNodes);
                    msg.setSendDelta(false);
                    Set newFailures = mgr.putOutgoing(msg);
                    if (newFailures != null) {
                        if (failures != null && failures.size() > 0) {
                            failures.addAll(newFailures);
                        } else {
                            failures = newFailures;
                        }
                    }
                }
                if (cachelessNodesWithNoCacheServer.size() > 0) {
                    msg.resetRecipients();
                    msg.setRecipients(cachelessNodesWithNoCacheServer);
                    msg.setSendDelta(false);
                    ((UpdateMessage) msg).setSendDeltaWithFullValue(false);
                    Set newFailures = mgr.putOutgoing(msg);
                    if (newFailures != null) {
                        if (failures != null && failures.size() > 0) {
                            failures.addAll(newFailures);
                        } else {
                            failures = newFailures;
                        }
                    }
                }
                // Add it back for size calculation ahead
                cachelessNodes.addAll(cachelessNodesWithNoCacheServer);
            }
            if (failures != null && !failures.isEmpty() && logger.isDebugEnabled()) {
                logger.debug("Failed sending ({}) to {} while processing event:{}", msg, failures, event);
            }
            Set<InternalDistributedMember> adjunctRecipientsWithNoCacheServer = new HashSet<InternalDistributedMember>();
            // send partitioned region listener notification messages now
            if (!adjunctRecipients.isEmpty()) {
                if (cachelessNodes.size() > 0) {
                    // calculations
                    if (recipients.isEmpty()) {
                        recipients = cachelessNodes;
                    } else {
                        recipients.addAll(cachelessNodes);
                    }
                }
                adjunctRecipientsWithNoCacheServer.addAll(adjunctRecipients);
                adviseCacheServers = ((Bucket) region).getPartitionedRegion().getCacheDistributionAdvisor().adviseCacheServers();
                adjunctRecipientsWithNoCacheServer.removeAll(adviseCacheServers);
                if (isPutAll) {
                    ((BucketRegion) region).performPutAllAdjunctMessaging((DistributedPutAllOperation) this, recipients, adjunctRecipients, filterRouting, this.processor);
                } else if (isRemoveAll) {
                    ((BucketRegion) region).performRemoveAllAdjunctMessaging((DistributedRemoveAllOperation) this, recipients, adjunctRecipients, filterRouting, this.processor);
                } else {
                    boolean calculateDelta = adjunctRecipientsWithNoCacheServer.size() < adjunctRecipients.size();
                    adjunctRecipients.removeAll(adjunctRecipientsWithNoCacheServer);
                    if (!adjunctRecipients.isEmpty()) {
                        ((BucketRegion) region).performAdjunctMessaging(getEvent(), recipients, adjunctRecipients, filterRouting, this.processor, calculateDelta, true);
                    }
                    if (!adjunctRecipientsWithNoCacheServer.isEmpty()) {
                        ((BucketRegion) region).performAdjunctMessaging(getEvent(), recipients, adjunctRecipientsWithNoCacheServer, filterRouting, this.processor, calculateDelta, false);
                    }
                }
            }
            // compute local client routing before waiting for an ack only for a bucket
            if (region.isUsedForPartitionedRegionBucket()) {
                FilterInfo filterInfo = getLocalFilterRouting(filterRouting);
                event.setLocalFilterInfo(filterInfo);
            }
            waitForAckIfNeeded(msg, persistentIds);
            if (/* msg != null && */
            reliableOp) {
                Set successfulRecips = new HashSet(recipients);
                successfulRecips.addAll(cachelessNodes);
                successfulRecips.addAll(needsOldValueInCacheOp);
                if (failures != null && !failures.isEmpty()) {
                    successfulRecips.removeAll(failures);
                }
                if (departedMembers != null) {
                    successfulRecips.removeAll(departedMembers);
                }
                region.handleReliableDistribution(successfulRecips);
            }
        }
        if (region.isUsedForPartitionedRegionBucket() && filterRouting != null) {
            removeDestroyTokensFromCqResultKeys(filterRouting);
        }
    } catch (CancelException e) {
        if (logger.isDebugEnabled()) {
            logger.debug("distribution of message aborted by shutdown: {}", this);
        }
        throw e;
    } catch (RuntimeException e) {
        logger.info(LocalizedMessage.create(LocalizedStrings.DistributedCacheOperation_EXCEPTION_OCCURRED_WHILE_PROCESSING__0, this), e);
        throw e;
    } finally {
        ReplyProcessor21.setShortSevereAlertProcessing(false);
    }
}

Example 39 with CancelException

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

the class DistributedRegion method basicClear.

@Override
void basicClear(RegionEventImpl regionEvent, boolean cacheWrite) {
    if (this.concurrencyChecksEnabled && !this.dataPolicy.withReplication()) {
        boolean retry = false;
        do {
            // non-replicate regions must defer to a replicate for clear/invalidate of region
            Set<InternalDistributedMember> repls = this.distAdvisor.adviseReplicates();
            if (!repls.isEmpty()) {
                InternalDistributedMember mbr = repls.iterator().next();
                RemoteRegionOperation op = RemoteRegionOperation.clear(mbr, this);
                try {
                    op.distribute();
                    return;
                } catch (CancelException e) {
                    this.stopper.checkCancelInProgress(e);
                    retry = true;
                } catch (RemoteOperationException e) {
                    this.stopper.checkCancelInProgress(e);
                    retry = true;
                }
            }
        } while (retry);
    }
    // if no version vector or if no replicates are around, use the default mechanism
    super.basicClear(regionEvent, cacheWrite);
}

Example 40 with CancelException

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

the class DistributedRegion method initMembershipRoles.

private void initMembershipRoles() {
    synchronized (this.advisorListener) {
        // hold sync to prevent listener from changing initial members
        Set others = this.distAdvisor.addMembershipListenerAndAdviseGeneric(this.advisorListener);
        this.advisorListener.addMembers(others);
        // initialize missing required roles with initial member info
        if (getMembershipAttributes().hasRequiredRoles()) {
            // AdvisorListener will also sync on missingRequiredRoles
            synchronized (this.missingRequiredRoles) {
                this.missingRequiredRoles.addAll(getMembershipAttributes().getRequiredRoles());
                // remove all the roles we are playing since they will never be
                // missing
                this.missingRequiredRoles.removeAll(getSystem().getDistributedMember().getRoles());
                for (Object other1 : others) {
                    DistributedMember other = (DistributedMember) other1;
                    this.missingRequiredRoles.removeAll(other.getRoles());
                }
            }
        }
    }
    if (getMembershipAttributes().hasRequiredRoles()) {
        // wait up to memberTimeout for required roles...
        // boolean requiredRolesAreMissing = false;
        int memberTimeout = getSystem().getConfig().getMemberTimeout();
        if (logger.isDebugEnabled()) {
            logger.debug("Waiting up to {} for required roles.", memberTimeout);
        }
        try {
            if (this.giiMissingRequiredRoles) {
                // force reliability loss and possibly resumption
                this.isInitializingThread = true;
                synchronized (this.advisorListener) {
                    synchronized (this.missingRequiredRoles) {
                        // forcing state of loss because of bad GII
                        this.isMissingRequiredRoles = true;
                        getCachePerfStats().incReliableRegionsMissing(1);
                        if (getMembershipAttributes().getLossAction().isAllAccess())
                            // rahul
                            getCachePerfStats().incReliableRegionsMissingFullAccess(1);
                        else if (getMembershipAttributes().getLossAction().isLimitedAccess())
                            getCachePerfStats().incReliableRegionsMissingLimitedAccess(1);
                        else if (getMembershipAttributes().getLossAction().isNoAccess())
                            getCachePerfStats().incReliableRegionsMissingNoAccess(1);
                        // pur code to increment the stats.
                        if (logger.isDebugEnabled()) {
                            logger.debug("GetInitialImage had missing required roles.");
                        }
                        // TODO: will this work with RECONNECT and REINITIALIZE?
                        this.isInitializingThread = true;
                        lostReliability(null, null);
                        if (this.missingRequiredRoles.isEmpty()) {
                            // all required roles are present so force resumption
                            this.isMissingRequiredRoles = false;
                            getCachePerfStats().incReliableRegionsMissing(-1);
                            if (getMembershipAttributes().getLossAction().isAllAccess())
                                // rahul
                                getCachePerfStats().incReliableRegionsMissingFullAccess(-1);
                            else if (getMembershipAttributes().getLossAction().isLimitedAccess())
                                getCachePerfStats().incReliableRegionsMissingLimitedAccess(-1);
                            else if (getMembershipAttributes().getLossAction().isNoAccess())
                                getCachePerfStats().incReliableRegionsMissingNoAccess(-1);
                            // pur code to increment the stats.
                            boolean async = resumeReliability(null, null);
                            if (async) {
                                this.advisorListener.destroyed = true;
                            }
                        }
                    }
                }
            } else {
                if (!getSystem().isLoner()) {
                    waitForRequiredRoles(memberTimeout);
                }
                synchronized (this.advisorListener) {
                    synchronized (this.missingRequiredRoles) {
                        if (this.missingRequiredRoles.isEmpty()) {
                            Assert.assertTrue(!this.isMissingRequiredRoles);
                            if (logger.isDebugEnabled()) {
                                logger.debug("Initialization completed with all required roles present.");
                            }
                        } else {
                            // starting in state of loss...
                            this.isMissingRequiredRoles = true;
                            getCachePerfStats().incReliableRegionsMissing(1);
                            if (getMembershipAttributes().getLossAction().isAllAccess())
                                // rahul
                                getCachePerfStats().incReliableRegionsMissingFullAccess(1);
                            else if (getMembershipAttributes().getLossAction().isLimitedAccess())
                                getCachePerfStats().incReliableRegionsMissingLimitedAccess(1);
                            else if (getMembershipAttributes().getLossAction().isNoAccess())
                                getCachePerfStats().incReliableRegionsMissingNoAccess(1);
                            if (logger.isDebugEnabled()) {
                                logger.debug("Initialization completed with missing required roles: {}", this.missingRequiredRoles);
                            }
                            this.isInitializingThread = true;
                            lostReliability(null, null);
                        }
                    }
                }
            }
        } catch (RegionDestroyedException ignore) {
        // ignore to fix bug 34639 may be thrown by waitForRequiredRoles
        } catch (CancelException e) {
            // ignore to fix bug 34639 may be thrown by waitForRequiredRoles
            if (this.isInitializingThread) {
                throw e;
            }
        } catch (Exception e) {
            logger.fatal(LocalizedMessage.create(LocalizedStrings.DistributedRegion_UNEXPECTED_EXCEPTION), e);
        }
    }
    // open latch which will allow any threads in lostReliability to proceed
    this.initializationLatchAfterMemberTimeout.countDown();
}