Examples with Bucket org.apache.geode.internal.cache.partitioned.Bucket used on opensource projects

Example 11 with Bucket

use of org.apache.geode.internal.cache.partitioned.Bucket in project geode by apache.

the class BucketAdvisor method removePrimary.

/**
   * Marks member as not primary. Initiates volunteerForPrimary if this member is hosting a real
   * bucket.
   * 
   * @param member the member who is not primary
   */
public void removePrimary(InternalDistributedMember member) {
    boolean needToVolunteerForPrimary = false;
    if (!isClosed()) {
        // hole: requestPrimaryState not hosting
        initializationGate();
    }
    boolean lostPrimary = false;
    try {
        synchronized (this) {
            boolean wasPrimary = isPrimary() && this.getDistributionManager().getId().equals(member);
            final InternalDistributedMember currentPrimary = (InternalDistributedMember) this.primaryMember.get();
            if (currentPrimary != null && currentPrimary.equals(member)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("[BucketAdvisor.notPrimary] {} for {}", member, this);
                }
                this.primaryMember.set(null);
            } else {
                return;
            }
            if (isClosed()) {
                // return quietly
                return;
            }
            // member is primary... need to change state to NO_PRIMARY_xxx
            if (isHosting()) {
                requestPrimaryState(NO_PRIMARY_HOSTING);
                if (this.pRegion.isFixedPartitionedRegion()) {
                    InternalDistributedMember primaryMember = this.regionAdvisor.adviseFixedPrimaryPartitionDataStore(this.getBucket().getId());
                    if (primaryMember == null || primaryMember.equals(member)) {
                        needToVolunteerForPrimary = true;
                    } else {
                        needToVolunteerForPrimary = false;
                    }
                } else {
                    needToVolunteerForPrimary = true;
                }
            } else {
                requestPrimaryState(NO_PRIMARY_NOT_HOSTING);
            }
            if (wasPrimary) {
                lostPrimary = true;
            }
            // try to fix yet another cause of bug 36881
            findAndSetPrimaryMember();
        }
    } finally {
        if (lostPrimary) {
            invokeAfterSecondaryInPartitionListeners();
            Bucket br = this.regionAdvisor.getBucket(getBucket().getId());
            if (br != null && br instanceof BucketRegion) {
                ((BucketRegion) br).beforeReleasingPrimaryLockDuringDemotion();
            }
            releasePrimaryLock();
            // this was a deposePrimary call so we need to depose children as well
            deposePrimaryForColocatedChildren();
            if (this.pRegion.isFixedPartitionedRegion()) {
                deposeOtherPrimaryBucketForFixedPartition();
            }
        }
    }
    if (needToVolunteerForPrimary) {
        volunteerForPrimary();
    }
}

Example 12 with Bucket

use of org.apache.geode.internal.cache.partitioned.Bucket in project geode by apache.

the class BucketAdvisor method deposePrimaryForColocatedChildren.

/**
   * This calls deposePrimary on every colocated child that is directly colocated to this bucket's
   * PR. Those each in turn do the same to their child buckets and so on before returning. Each
   * depose will send a dlock release message to the grantor, wait for reply, and then also send a
   * profile update.
   * <p>
   * Caller must synchronize on this BucketAdvisor.
   * 
   * @return true if children were all deposed as primaries
   * @guarded.By this
   */
private boolean deposePrimaryForColocatedChildren() {
    boolean deposedChildPrimaries = true;
    // getColocatedChildRegions returns only the child PRs directly colocated
    // with thisPR...
    List<PartitionedRegion> colocatedChildPRs = ColocationHelper.getColocatedChildRegions(this.pRegion);
    if (colocatedChildPRs != null) {
        for (PartitionedRegion pr : colocatedChildPRs) {
            Bucket b = pr.getRegionAdvisor().getBucket(getBucket().getId());
            if (b != null) {
                BucketAdvisor ba = b.getBucketAdvisor();
                deposedChildPrimaries = ba.deposePrimary() && deposedChildPrimaries;
            }
        }
    }
    return deposedChildPrimaries;
}

Example 13 with Bucket

use of org.apache.geode.internal.cache.partitioned.Bucket in project geode by apache.

the class BucketAdvisor method acquirePrimaryRecursivelyForColocated.

protected void acquirePrimaryRecursivelyForColocated() {
    final List<PartitionedRegion> colocatedWithList = ColocationHelper.getColocatedChildRegions(regionAdvisor.getPartitionedRegion());
    if (colocatedWithList != null) {
        for (PartitionedRegion childPR : colocatedWithList) {
            Bucket b = childPR.getRegionAdvisor().getBucket(getBucket().getId());
            BucketAdvisor childBA = b.getBucketAdvisor();
            Assert.assertHoldsLock(childBA, false);
            boolean acquireForChild = false;
            if (logger.isDebugEnabled()) {
                logger.debug("BucketAdvisor.acquirePrimaryRecursivelyForColocated: about to take lock for bucket: {} of PR: {} with isHosting={}", getBucket().getId(), childPR.getFullPath(), childBA.isHosting());
            }
            childBA.activePrimaryMoveLock.lock();
            try {
                if (childBA.isHosting()) {
                    if (isPrimary()) {
                        if (!childBA.isPrimary()) {
                            childBA.setVolunteering();
                            boolean acquired = childBA.acquiredPrimaryLock();
                            acquireForChild = true;
                            if (acquired && this.pRegion.isFixedPartitionedRegion()) {
                                childBA.acquirePrimaryForRestOfTheBucket();
                            }
                        } else {
                            acquireForChild = true;
                        }
                    }
                }
                // if isHosting
                if (acquireForChild) {
                    childBA.acquirePrimaryRecursivelyForColocated();
                }
            } finally {
                childBA.activePrimaryMoveLock.unlock();
            }
        }
    }
}

Example 14 with Bucket

use of org.apache.geode.internal.cache.partitioned.Bucket 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 15 with Bucket

use of org.apache.geode.internal.cache.partitioned.Bucket in project geode by apache.

the class BucketAdvisor method deposeOtherPrimaryBucketForFixedPartition.

private boolean deposeOtherPrimaryBucketForFixedPartition() {
    boolean deposedOtherPrimaries = true;
    int bucketId = getBucket().getId();
    List<FixedPartitionAttributesImpl> fpas = this.pRegion.getFixedPartitionAttributesImpl();
    if (fpas != null) {
        for (FixedPartitionAttributesImpl fpa : fpas) {
            if (fpa.getStartingBucketID() == bucketId) {
                for (int i = (bucketId + 1); i <= fpa.getLastBucketID(); i++) {
                    Bucket b = regionAdvisor.getBucket(i);
                    if (b != null) {
                        BucketAdvisor ba = b.getBucketAdvisor();
                        deposedOtherPrimaries = ba.deposePrimary() && deposedOtherPrimaries;
                    }
                }
            } else {
                continue;
            }
        }
    }
    return deposedOtherPrimaries;
}