Examples with CacheProfile org.apache.geode.internal.cache.CacheDistributionAdvisor.CacheProfile used on opensource projects

Example 6 with CacheProfile

use of org.apache.geode.internal.cache.CacheDistributionAdvisor.CacheProfile in project geode by apache.

the class PartitionedRegion method fillInProfile.

public void fillInProfile(Profile p) {
    CacheProfile profile = (CacheProfile) p;
    // set fields on CacheProfile...
    profile.isPartitioned = true;
    profile.isPersistent = dataPolicy.withPersistence();
    profile.dataPolicy = getDataPolicy();
    profile.hasCacheLoader = basicGetLoader() != null;
    profile.hasCacheWriter = basicGetWriter() != null;
    profile.hasCacheListener = hasListener();
    Assert.assertTrue(getScope().isDistributed());
    profile.scope = getScope();
    profile.setSubscriptionAttributes(getSubscriptionAttributes());
    // fillInProfile MUST set serialNumber
    profile.serialNumber = getSerialNumber();
    // TODO - prpersist - this is a bit of a hack, but we're
    // reusing this boolean to indicate that this member has finished disk recovery.
    profile.regionInitialized = recoveredFromDisk;
    profile.hasCacheServer = ((this.cache.getCacheServers().size() > 0) ? true : false);
    profile.filterProfile = getFilterProfile();
    profile.gatewaySenderIds = getGatewaySenderIds();
    profile.asyncEventQueueIds = getVisibleAsyncEventQueueIds();
    if (dataPolicy.withPersistence()) {
        profile.persistentID = getDiskStore().generatePersistentID(null);
    }
    fillInProfile((PartitionProfile) profile);
    if (cacheServiceProfiles != null) {
        for (CacheServiceProfile csp : cacheServiceProfiles.values()) {
            profile.addCacheServiceProfile(csp);
        }
    }
    profile.isOffHeap = getOffHeap();
}

Example 7 with CacheProfile

use of org.apache.geode.internal.cache.CacheDistributionAdvisor.CacheProfile in project geode by apache.

the class DistributionAdvisor method syncForCrashedMember.

/** perform a delta-GII for the given lost member */
public void syncForCrashedMember(final InternalDistributedMember id, final Profile profile) {
    final DistributedRegion dr = getRegionForDeltaGII();
    if (dr == null) {
        return;
    }
    final boolean isDebugEnabled = logger.isDebugEnabled();
    if (isDebugEnabled) {
        logger.debug("da.syncForCrashedMember will sync region in waiting thread pool: {}", dr);
    }
    dr.getDistributionManager().getWaitingThreadPool().execute(new Runnable() {

        // bug #49601 - don't synchronize until GII has been performed
        public void run() {
            while (!dr.isInitialized()) {
                if (dr.isDestroyed()) {
                    return;
                } else {
                    try {
                        if (isDebugEnabled) {
                            logger.debug("da.syncForCrashedMember waiting for region to finish initializing: {}", dr);
                        }
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        return;
                    }
                }
            }
            CacheProfile cp = (CacheProfile) profile;
            PersistentMemberID persistentId = cp.persistentID;
            if (dr.getDataPolicy().withPersistence() && persistentId == null) {
                // a persistent member.
                if (isDebugEnabled) {
                    logger.debug("da.syncForCrashedMember skipping sync because crashed member is not persistent: {}", id);
                }
                return;
            }
            VersionSource lostVersionID;
            if (persistentId != null) {
                lostVersionID = persistentId.getVersionMember();
            } else {
                lostVersionID = id;
            }
            dr.synchronizeForLostMember(id, lostVersionID);
        }
    });
}

Example 8 with CacheProfile

use of org.apache.geode.internal.cache.CacheDistributionAdvisor.CacheProfile in project geode by apache.

the class CqServiceImpl method processEntryEvent.

private void processEntryEvent(CacheEvent event, Profile localProfile, Profile[] profiles, FilterRoutingInfo frInfo) throws CqException {
    final boolean isDebugEnabled = logger.isDebugEnabled();
    HashSet<Object> cqUnfilteredEventsSet_newValue = new HashSet<>();
    HashSet<Object> cqUnfilteredEventsSet_oldValue = new HashSet<>();
    boolean b_cqResults_newValue;
    boolean b_cqResults_oldValue;
    boolean queryOldValue;
    EntryEvent entryEvent = (EntryEvent) event;
    Object eventKey = entryEvent.getKey();
    boolean isDupEvent = ((EntryEventImpl) event).isPossibleDuplicate();
    // The CQ query needs to be applied when the op is update, destroy
    // invalidate and in case when op is create and its an duplicate
    // event, the reason for this is when peer sends a duplicate event
    // it marks it as create and sends it, so that the receiving node
    // applies it (see DR.virtualPut()).
    boolean opRequiringQueryOnOldValue = (event.getOperation().isUpdate() || event.getOperation().isDestroy() || event.getOperation().isInvalidate() || (event.getOperation().isCreate() && isDupEvent));
    HashMap<String, Integer> matchedCqs = new HashMap<>();
    long executionStartTime;
    for (int i = -1; i < profiles.length; i++) {
        CacheProfile cf;
        if (i < 0) {
            cf = (CacheProfile) localProfile;
            if (cf == null)
                continue;
        } else {
            cf = (CacheProfile) profiles[i];
        }
        FilterProfile pf = cf.filterProfile;
        if (pf == null || pf.getCqMap().isEmpty()) {
            continue;
        }
        Map cqs = pf.getCqMap();
        if (isDebugEnabled) {
            logger.debug("Profile for {} processing {} CQs", cf.peerMemberId, cqs.size());
        }
        if (cqs.isEmpty()) {
            continue;
        }
        // Get new value. If its not retrieved.
        if (cqUnfilteredEventsSet_newValue.isEmpty() && (event.getOperation().isCreate() || event.getOperation().isUpdate())) {
            Object newValue = entryEvent.getNewValue();
            if (newValue != null) {
                // We have a new value to run the query on
                cqUnfilteredEventsSet_newValue.add(newValue);
            }
        }
        HashMap<Long, Integer> cqInfo = new HashMap<>();
        Iterator cqIter = cqs.entrySet().iterator();
        while (cqIter.hasNext()) {
            Map.Entry cqEntry = (Map.Entry) cqIter.next();
            ServerCQImpl cQuery = (ServerCQImpl) cqEntry.getValue();
            b_cqResults_newValue = false;
            b_cqResults_oldValue = false;
            queryOldValue = false;
            if (cQuery == null) {
                continue;
            }
            String cqName = cQuery.getServerCqName();
            Long filterID = cQuery.getFilterID();
            if (isDebugEnabled) {
                logger.debug("Processing CQ : {} Key: {}", cqName, eventKey);
            }
            Integer cqEvent = null;
            if (matchedCqs.containsKey(cqName)) {
                cqEvent = matchedCqs.get(cqName);
                if (isDebugEnabled) {
                    logger.debug("query {} has already been processed and returned {}", cqName, cqEvent);
                }
                if (cqEvent == null) {
                    continue;
                }
                // Update the Cache Results for this CQ.
                if (cqEvent.intValue() == MessageType.LOCAL_CREATE || cqEvent.intValue() == MessageType.LOCAL_UPDATE) {
                    cQuery.addToCqResultKeys(eventKey);
                } else if (cqEvent.intValue() == MessageType.LOCAL_DESTROY) {
                    cQuery.markAsDestroyedInCqResultKeys(eventKey);
                }
            } else {
                boolean error = false;
                {
                    try {
                        synchronized (cQuery) {
                            // Apply query on new value.
                            if (!cqUnfilteredEventsSet_newValue.isEmpty()) {
                                executionStartTime = this.stats.startCqQueryExecution();
                                b_cqResults_newValue = evaluateQuery(cQuery, new Object[] { cqUnfilteredEventsSet_newValue });
                                this.stats.endCqQueryExecution(executionStartTime);
                            }
                        }
                        // Apply query on oldValue.
                        if (opRequiringQueryOnOldValue) {
                            // with PR region.
                            if (cQuery.cqResultKeysInitialized) {
                                b_cqResults_oldValue = cQuery.isPartOfCqResult(eventKey);
                                // Also apply if the query was not executed during cq execute
                                if ((cQuery.isPR || !CqServiceImpl.EXECUTE_QUERY_DURING_INIT) && b_cqResults_oldValue == false) {
                                    queryOldValue = true;
                                }
                                if (isDebugEnabled && !cQuery.isPR && !b_cqResults_oldValue) {
                                    logger.debug("Event Key not found in the CQ Result Queue. EventKey : {} CQ Name : {}", eventKey, cqName);
                                }
                            } else {
                                queryOldValue = true;
                            }
                            if (queryOldValue) {
                                if (cqUnfilteredEventsSet_oldValue.isEmpty()) {
                                    Object oldValue = entryEvent.getOldValue();
                                    if (oldValue != null) {
                                        cqUnfilteredEventsSet_oldValue.add(oldValue);
                                    }
                                }
                                synchronized (cQuery) {
                                    // Apply query on old value.
                                    if (!cqUnfilteredEventsSet_oldValue.isEmpty()) {
                                        executionStartTime = this.stats.startCqQueryExecution();
                                        b_cqResults_oldValue = evaluateQuery(cQuery, new Object[] { cqUnfilteredEventsSet_oldValue });
                                        this.stats.endCqQueryExecution(executionStartTime);
                                    } else {
                                        if (isDebugEnabled) {
                                            logger.debug("old value for event with key {} is null - query execution not performed", eventKey);
                                        }
                                    }
                                }
                            }
                        // Query oldValue
                        }
                    } catch (Exception ex) {
                        // Any exception in running the query should be caught here and
                        // buried because this code is running in-line with the message
                        // processing code and we don't want to kill that thread
                        error = true;
                        // CHANGE LOG MESSAGE:
                        logger.info(LocalizedMessage.create(LocalizedStrings.CqService_ERROR_WHILE_PROCESSING_CQ_ON_THE_EVENT_KEY_0_CQNAME_1_ERROR_2, new Object[] { ((EntryEvent) event).getKey(), cQuery.getName(), ex.getLocalizedMessage() }));
                    }
                    if (error) {
                        cqEvent = MESSAGE_TYPE_EXCEPTION;
                    } else {
                        if (b_cqResults_newValue) {
                            if (b_cqResults_oldValue) {
                                cqEvent = MESSAGE_TYPE_LOCAL_UPDATE;
                            } else {
                                cqEvent = MESSAGE_TYPE_LOCAL_CREATE;
                            }
                            // If its create and caching is enabled, cache the key
                            // for this CQ.
                            cQuery.addToCqResultKeys(eventKey);
                        } else if (b_cqResults_oldValue) {
                            // Base invalidate operation is treated as destroy.
                            // When the invalidate comes through, the entry will no longer
                            // satisfy the query and will need to be deleted.
                            cqEvent = MESSAGE_TYPE_LOCAL_DESTROY;
                            // If caching is enabled, mark this event's key as removed
                            // from the CQ cache.
                            cQuery.markAsDestroyedInCqResultKeys(eventKey);
                        }
                    }
                }
                // Get the matching CQs if any.
                // synchronized (this.matchingCqMap){
                String query = cQuery.getQueryString();
                Set matchingCqs = (Set) matchingCqMap.get(query);
                if (matchingCqs != null) {
                    Iterator iter = matchingCqs.iterator();
                    while (iter.hasNext()) {
                        String matchingCqName = (String) iter.next();
                        if (!matchingCqName.equals(cqName)) {
                            matchedCqs.put(matchingCqName, cqEvent);
                            if (isDebugEnabled) {
                                logger.debug("Adding CQ into Matching CQ Map: {} Event is: {}", matchingCqName, cqEvent);
                            }
                        }
                    }
                }
            }
            if (cqEvent != null && cQuery.isRunning()) {
                if (isDebugEnabled) {
                    logger.debug("Added event to CQ with client-side name: {} key: {} operation : {}", cQuery.cqName, eventKey, cqEvent);
                }
                cqInfo.put(filterID, cqEvent);
                CqQueryVsdStats stats = cQuery.getVsdStats();
                if (stats != null) {
                    stats.updateStats(cqEvent);
                }
            }
        }
        if (cqInfo.size() > 0) {
            if (pf.isLocalProfile()) {
                if (isDebugEnabled) {
                    logger.debug("Setting local CQ matches to {}", cqInfo);
                }
                frInfo.setLocalCqInfo(cqInfo);
            } else {
                if (isDebugEnabled) {
                    logger.debug("Setting CQ matches for {} to {}", cf.getDistributedMember(), cqInfo);
                }
                frInfo.setCqRoutingInfo(cf.getDistributedMember(), cqInfo);
            }
        }
    }
// iteration over Profiles.
}