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

Example 1 with PartitionMessage

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

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

the class EntryEventImpl method setOperation.

public void setOperation(Operation op) {
    this.op = op;
    PartitionMessage prm = getPartitionMessage();
    if (prm != null) {
        prm.setOperation(this.op);
    }
}

Example 3 with PartitionMessage

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

the class BucketRegion method performAdjunctMessaging.

/**
   * perform adjunct messaging for the given operation and return a set of members that should be
   * attached to the operation's reply processor (if any)
   * 
   * @param event the event causing this messaging
   * @param cacheOpRecipients set of receiver which got cacheUpdateOperation.
   * @param adjunctRecipients recipients that must unconditionally get the event
   * @param filterRoutingInfo routing information for all members having the region
   * @param processor the reply processor, or null if there isn't one
   * @return the set of failed recipients
   */
protected Set performAdjunctMessaging(EntryEventImpl event, Set cacheOpRecipients, Set adjunctRecipients, FilterRoutingInfo filterRoutingInfo, DirectReplyProcessor processor, boolean calculateDelta, boolean sendDeltaWithFullValue) {
    Set failures = Collections.EMPTY_SET;
    PartitionMessage msg = event.getPartitionMessage();
    if (calculateDelta) {
        setDeltaIfNeeded(event);
    }
    if (msg != null) {
        // The primary bucket member which is being modified remotely by a
        // thread via a received PartitionedMessage
        msg = msg.getMessageForRelayToListeners(event, adjunctRecipients);
        msg.setSender(this.partitionedRegion.getDistributionManager().getDistributionManagerId());
        msg.setSendDeltaWithFullValue(sendDeltaWithFullValue);
        failures = msg.relayToListeners(cacheOpRecipients, adjunctRecipients, filterRoutingInfo, event, this.partitionedRegion, processor);
    } else {
        // The primary bucket is being modified locally by an application thread locally
        Operation op = event.getOperation();
        if (op.isCreate() || op.isUpdate()) {
            // note that at this point ifNew/ifOld have been used to update the
            // local store, and the event operation should be correct
            failures = PutMessage.notifyListeners(cacheOpRecipients, adjunctRecipients, filterRoutingInfo, this.partitionedRegion, event, op.isCreate(), !op.isCreate(), processor, sendDeltaWithFullValue);
        } else if (op.isDestroy()) {
            failures = DestroyMessage.notifyListeners(cacheOpRecipients, adjunctRecipients, filterRoutingInfo, this.partitionedRegion, event, processor);
        } else if (op.isInvalidate()) {
            failures = InvalidateMessage.notifyListeners(cacheOpRecipients, adjunctRecipients, filterRoutingInfo, this.partitionedRegion, event, processor);
        } else {
            failures = adjunctRecipients;
        }
    }
    return failures;
}