Java tutorial
/* * ************************************************************************************* * Copyright (C) 2008 EsperTech, Inc. All rights reserved. * * http://esper.codehaus.org * * http://www.espertech.com * * ---------------------------------------------------------------------------------- * * The software in this package is published under the terms of the GPL license * * a copy of which has been included with this distribution in the license.txt file. * * ************************************************************************************* */ package com.espertech.esper.core.context.mgr; import com.espertech.esper.client.EventBean; import com.espertech.esper.client.EventType; import com.espertech.esper.client.SafeIterator; import com.espertech.esper.client.context.*; import com.espertech.esper.core.context.factory.StatementAgentInstanceFactoryResult; import com.espertech.esper.core.context.stmt.AIRegistryAggregationMap; import com.espertech.esper.core.context.stmt.AIRegistryExprMap; import com.espertech.esper.core.context.stmt.StatementAIResourceRegistry; import com.espertech.esper.core.context.stmt.StatementAIResourceRegistryFactory; import com.espertech.esper.core.context.util.ContextControllerSelectorUtil; import com.espertech.esper.core.context.util.ContextDescriptor; import com.espertech.esper.core.context.util.ContextIteratorHandler; import com.espertech.esper.core.context.util.StatementAgentInstanceUtil; import com.espertech.esper.client.context.ContextPartitionDescriptor; import com.espertech.esper.client.context.ContextPartitionState; import com.espertech.esper.core.service.EPServicesContext; import com.espertech.esper.epl.expression.ExprValidationException; import com.espertech.esper.epl.spec.ContextDetailPartitionItem; import com.espertech.esper.event.MappedEventBean; import com.espertech.esper.filter.FilterFaultHandler; import com.espertech.esper.filter.FilterSpecCompiled; import com.espertech.esper.filter.FilterSpecLookupable; import com.espertech.esper.filter.FilterValueSetParam; import com.espertech.esper.type.NumberSetParameter; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.util.*; public class ContextManagerNested implements ContextManager, ContextControllerLifecycleCallback, ContextIteratorHandler, FilterFaultHandler { private static final Log log = LogFactory.getLog(ContextManagerNested.class); private final String contextName; private final EPServicesContext servicesContext; private final ContextControllerFactory[] nestedContextFactories; private final Map<String, ContextControllerStatementDesc> statements = new LinkedHashMap<String, ContextControllerStatementDesc>(); // retain order of statement creation private final ContextDescriptor contextDescriptor; /** * The single root context. * This represents the context declared first. */ private ContextController rootContext; /** * Double-linked tree of sub-contexts. * An entry exists for all branches including the root. For example with 2 contexts declared this map has entries representing the root and all second-level sub-contexts. * For example with 3 contexts declared this map has entries for the root, second and third-level contexts. */ private final Map<ContextController, ContextControllerTreeEntry> subcontexts = new HashMap<ContextController, ContextControllerTreeEntry>(); private final ContextPartitionIdManager contextPartitionIdManager; public ContextManagerNested(ContextControllerFactoryServiceContext factoryServiceContext) throws ExprValidationException { this.contextName = factoryServiceContext.getContextName(); this.servicesContext = factoryServiceContext.getServicesContext(); this.contextPartitionIdManager = factoryServiceContext.getAgentInstanceContextCreate().getStatementContext() .getContextControllerFactoryService().allocatePartitionIdMgr(contextName, factoryServiceContext .getAgentInstanceContextCreate().getStatementContext().getStatementId()); nestedContextFactories = factoryServiceContext.getAgentInstanceContextCreate().getStatementContext() .getContextControllerFactoryService().getFactory(factoryServiceContext); StatementAIResourceRegistryFactory resourceRegistryFactory = new StatementAIResourceRegistryFactory() { public StatementAIResourceRegistry make() { return new StatementAIResourceRegistry(new AIRegistryAggregationMap(), new AIRegistryExprMap()); } }; Map<String, Object> contextProps = ContextPropertyEventType.getNestedTypeBase(); for (ContextControllerFactory factory : nestedContextFactories) { contextProps.put(factory.getFactoryContext().getContextName(), factory.getContextBuiltinProps()); } EventType contextPropsType = servicesContext.getEventAdapterService().createAnonymousMapType(contextName, contextProps); ContextPropertyRegistryImpl registry = new ContextPropertyRegistryImpl( Collections.<ContextDetailPartitionItem>emptyList(), contextPropsType); contextDescriptor = new ContextDescriptor(contextName, false, registry, resourceRegistryFactory, this, factoryServiceContext.getDetail()); } public Map<String, ContextControllerStatementDesc> getStatements() { return statements; } public ContextDescriptor getContextDescriptor() { return contextDescriptor; } public int getNumNestingLevels() { return nestedContextFactories.length; } public synchronized Iterator<EventBean> iterator(String statementId, ContextPartitionSelector selector) { AgentInstance[] instances = getAgentInstancesForStmt(statementId, selector); return new AgentInstanceArrayIterator(instances); } public synchronized SafeIterator<EventBean> safeIterator(String statementId, ContextPartitionSelector selector) { AgentInstance[] instances = getAgentInstancesForStmt(statementId, selector); return new AgentInstanceArraySafeIterator(instances); } public Collection<Integer> getAgentInstanceIds(ContextPartitionSelector contextPartitionSelector) { return getAgentInstancesForSelector(contextPartitionSelector); } public void importStartPaths(ContextControllerState state, AgentInstanceSelector agentInstanceSelector) { rootContext.importContextPartitions(state, 0, null, agentInstanceSelector); } protected static ContextPartitionIdentifier[] getTreeCompositeKey( ContextControllerFactory[] nestedContextFactories, Object initPartitionKey, ContextControllerTreeEntry treeEntry, Map<ContextController, ContextControllerTreeEntry> subcontexts) { int length = nestedContextFactories.length; ContextPartitionIdentifier[] keys = new ContextPartitionIdentifier[length]; keys[length - 1] = nestedContextFactories[length - 1].keyPayloadToIdentifier(initPartitionKey); keys[length - 2] = nestedContextFactories[length - 2] .keyPayloadToIdentifier(treeEntry.getInitPartitionKey()); // get parent's parent if (length > 2) { ContextController parent = treeEntry.getParent(); ContextControllerTreeEntry parentEntry = subcontexts.get(parent); for (int i = 0; i < length - 2; i++) { keys[length - 2 - i] = nestedContextFactories[length - 2 - i] .keyPayloadToIdentifier(parentEntry.getInitPartitionKey()); parent = parentEntry.getParent(); parentEntry = subcontexts.get(parent); } } return keys; } public ContextStatePathDescriptor extractPaths(ContextPartitionSelector selector) { ContextPartitionVisitorStateWithPath visitor = getContextPartitionPathsInternal(selector); return new ContextStatePathDescriptor(visitor.getStates(), visitor.getAgentInstanceInfo()); } public ContextStatePathDescriptor extractStopPaths(ContextPartitionSelector selector) { ContextPartitionVisitorStateWithPath visitor = getContextPartitionPathsInternal(selector); for (Map.Entry<ContextController, List<ContextPartitionVisitorStateWithPath.LeafDesc>> entry : visitor .getControllerAgentInstances().entrySet()) { ContextControllerTreeEntry treeEntry = subcontexts.get(entry.getKey()); for (ContextPartitionVisitorStateWithPath.LeafDesc leaf : entry.getValue()) { int agentInstanceId = leaf.getValue().getOptionalContextPartitionId(); ContextControllerTreeAgentInstanceList list = treeEntry.getAgentInstances().get(agentInstanceId); list.setState(ContextPartitionState.STOPPED); StatementAgentInstanceUtil.stopAgentInstances(list.getAgentInstances(), null, servicesContext, false); list.clearAgentInstances(); leaf.getValue().setState(ContextPartitionState.STOPPED); rootContext.getFactory().getStateCache().updateContextPath(contextName, leaf.getKey(), leaf.getValue()); } } return new ContextStatePathDescriptor(visitor.getStates(), visitor.getAgentInstanceInfo()); } public ContextStatePathDescriptor extractDestroyPaths(ContextPartitionSelector selector) { ContextPartitionVisitorStateWithPath visitor = getContextPartitionPathsInternal(selector); for (Map.Entry<ContextController, List<ContextPartitionVisitorStateWithPath.LeafDesc>> entry : visitor .getControllerAgentInstances().entrySet()) { ContextControllerTreeEntry treeEntry = subcontexts.get(entry.getKey()); for (ContextPartitionVisitorStateWithPath.LeafDesc leaf : entry.getValue()) { int agentInstanceId = leaf.getValue().getOptionalContextPartitionId(); ContextControllerTreeAgentInstanceList list = treeEntry.getAgentInstances().get(agentInstanceId); StatementAgentInstanceUtil.stopAgentInstances(list.getAgentInstances(), null, servicesContext, false); rootContext.getFactory().getStateCache().removeContextPath(contextName, leaf.getKey().getLevel(), leaf.getKey().getParentPath(), leaf.getKey().getSubPath()); ContextPartitionDescriptor descriptor = visitor.getAgentInstanceInfo().get(agentInstanceId); ContextPartitionIdentifierNested nestedIdent = (ContextPartitionIdentifierNested) descriptor .getIdentifier(); entry.getKey().deletePath(nestedIdent.getIdentifiers()[nestedContextFactories.length - 1]); } } return new ContextStatePathDescriptor(visitor.getStates(), visitor.getAgentInstanceInfo()); } public Map<Integer, ContextPartitionDescriptor> startPaths(ContextPartitionSelector selector) { ContextPartitionVisitorStateWithPath visitor = getContextPartitionPathsInternal(selector); for (Map.Entry<ContextController, List<ContextPartitionVisitorStateWithPath.LeafDesc>> entry : visitor .getControllerAgentInstances().entrySet()) { ContextControllerTreeEntry treeEntry = subcontexts.get(entry.getKey()); for (ContextPartitionVisitorStateWithPath.LeafDesc leaf : entry.getValue()) { int agentInstanceId = leaf.getValue().getOptionalContextPartitionId(); ContextControllerTreeAgentInstanceList list = treeEntry.getAgentInstances().get(agentInstanceId); if (list.getState() == ContextPartitionState.STARTED) { continue; } for (Map.Entry<String, ContextControllerStatementDesc> statement : statements.entrySet()) { AgentInstance instance = startStatement(agentInstanceId, statement.getValue(), rootContext, list.getInitPartitionKey(), list.getInitContextProperties(), false); list.getAgentInstances().add(instance); } list.setState(ContextPartitionState.STARTED); leaf.getValue().setState(ContextPartitionState.STARTED); rootContext.getFactory().getStateCache().updateContextPath(contextName, leaf.getKey(), leaf.getValue()); } } ContextManagerImpl.setState(visitor.getAgentInstanceInfo(), ContextPartitionState.STARTED); return visitor.getAgentInstanceInfo(); } public ContextPartitionVisitorStateWithPath getContextPartitionPathsInternal( ContextPartitionSelector selector) { ContextPartitionVisitorStateWithPath visitor = new ContextPartitionVisitorStateWithPath( nestedContextFactories, subcontexts); ContextPartitionSelectorNested nested = (ContextPartitionSelectorNested) selector; for (ContextPartitionSelector[] item : nested.getSelectors()) { recursivePopulateSelector(rootContext, 1, item, visitor); } return visitor; } public void addStatement(ContextControllerStatementBase statement, boolean isRecoveringResilient) throws ExprValidationException { // validation down the hierarchy ContextControllerStatementCtxCache[] caches = new ContextControllerStatementCtxCache[nestedContextFactories.length]; for (int i = 0; i < nestedContextFactories.length; i++) { ContextControllerFactory nested = nestedContextFactories[i]; caches[i] = nested.validateStatement(statement); } // save statement ContextControllerStatementDesc desc = new ContextControllerStatementDesc(statement, caches); statements.put(statement.getStatementContext().getStatementId(), desc); // activate if this is the first statement if (statements.size() == 1) { activate(); // this may itself trigger a callback } // activate statement in respect to existing context partitions else { for (Map.Entry<ContextController, ContextControllerTreeEntry> subcontext : subcontexts.entrySet()) { if (subcontext.getKey().getFactory().getFactoryContext() .getNestingLevel() != nestedContextFactories.length) { continue; } if (subcontext.getValue().getAgentInstances() == null || subcontext.getValue().getAgentInstances().isEmpty()) { continue; } for (Map.Entry<Integer, ContextControllerTreeAgentInstanceList> entry : subcontext.getValue() .getAgentInstances().entrySet()) { if (entry.getValue().getState() == ContextPartitionState.STARTED) { AgentInstance agentInstance = startStatement(entry.getKey(), desc, subcontext.getKey(), entry.getValue().getInitPartitionKey(), entry.getValue().getInitContextProperties(), isRecoveringResilient); entry.getValue().getAgentInstances().add(agentInstance); } } } } } public synchronized void stopStatement(String statementName, String statementId) { destroyStatement(statementName, statementId); } public synchronized void destroyStatement(String statementName, String statementId) { if (!statements.containsKey(statementId)) { return; } if (statements.size() == 1) { safeDestroy(); } else { removeStatement(statementId); } } public void safeDestroy() { if (rootContext != null) { recursiveDeactivateStop(rootContext); nestedContextFactories[0].getStateCache().removeContext(contextName); rootContext = null; statements.clear(); subcontexts.clear(); contextPartitionIdManager.clear(); } } public void setContextPartitionRange(List<NumberSetParameter> partitionRanges) { throw new UnsupportedOperationException(); } public FilterSpecLookupable getFilterLookupable(EventType eventType) { throw new UnsupportedOperationException(); } public void contextPartitionNavigate(ContextControllerInstanceHandle existingHandle, ContextController originator, ContextControllerState controllerState, int exportedCPOrPathId, ContextInternalFilterAddendum filterAddendum, AgentInstanceSelector agentInstanceSelector, byte[] payload) { ContextManagerNestedInstanceHandle nestedHandle = (ContextManagerNestedInstanceHandle) existingHandle; // detect non-leaf int nestingLevel = originator.getFactory().getFactoryContext().getNestingLevel(); // starts at 1 for root if (nestingLevel < nestedContextFactories.length) { nestedHandle.getController().importContextPartitions(controllerState, exportedCPOrPathId, filterAddendum, agentInstanceSelector); return; } ContextControllerTreeEntry entry = subcontexts.get(originator); if (entry == null) { return; } for (Map.Entry<Integer, ContextControllerTreeAgentInstanceList> cpEntry : entry.getAgentInstances() .entrySet()) { if (cpEntry.getValue().getState() == ContextPartitionState.STOPPED) { cpEntry.getValue().setState(ContextPartitionState.STARTED); entry.getAgentInstances().clear(); for (Map.Entry<String, ContextControllerStatementDesc> statement : statements.entrySet()) { AgentInstance instance = startStatement(existingHandle.getContextPartitionOrPathId(), statement.getValue(), originator, cpEntry.getValue().getInitPartitionKey(), entry.getInitContextProperties(), false); cpEntry.getValue().getAgentInstances().add(instance); } ContextStatePathKey key = new ContextStatePathKey(nestedContextFactories.length, originator.getPathId(), existingHandle.getSubPathId()); ContextStatePathValue value = new ContextStatePathValue( existingHandle.getContextPartitionOrPathId(), payload, ContextPartitionState.STARTED); originator.getFactory().getStateCache().updateContextPath(contextName, key, value); } else { List<AgentInstance> removed = new ArrayList<AgentInstance>(2); List<AgentInstance> added = new ArrayList<AgentInstance>(2); List<AgentInstance> current = cpEntry.getValue().getAgentInstances(); for (AgentInstance agentInstance : current) { if (!agentInstanceSelector.select(agentInstance)) { continue; } // remove StatementAgentInstanceUtil.stopAgentInstance(agentInstance, null, servicesContext, false); removed.add(agentInstance); // start ContextControllerStatementDesc statementDesc = statements .get(agentInstance.getAgentInstanceContext().getStatementId()); AgentInstance instance = startStatement(cpEntry.getKey(), statementDesc, originator, cpEntry.getValue().getInitPartitionKey(), entry.getInitContextProperties(), false); added.add(instance); if (controllerState.getPartitionImportCallback() != null) { controllerState.getPartitionImportCallback() .existing(existingHandle.getContextPartitionOrPathId(), exportedCPOrPathId); } } current.removeAll(removed); current.addAll(added); } } } public synchronized ContextControllerInstanceHandle contextPartitionInstantiate( Integer optionalContextPartitionId, int subPathId, Integer importSubpathId, ContextController originator, EventBean optionalTriggeringEvent, Map<String, Object> optionalTriggeringPattern, Object partitionKey, Map<String, Object> contextProperties, ContextControllerState states, ContextInternalFilterAddendum filterAddendum, boolean isRecoveringResilient, ContextPartitionState state) { // detect non-leaf int nestingLevel = originator.getFactory().getFactoryContext().getNestingLevel(); // starts at 1 for root if (nestingLevel < nestedContextFactories.length) { // next sub-sontext ContextControllerFactory nextFactory = nestedContextFactories[originator.getFactory() .getFactoryContext().getNestingLevel()]; ContextController nextContext = nextFactory.createNoCallback(subPathId, this); // link current context to sub-context ContextControllerTreeEntry branch = subcontexts.get(originator); if (branch.getChildContexts() == null) { branch.setChildContexts(new HashMap<Integer, ContextController>()); } branch.getChildContexts().put(subPathId, nextContext); // save child branch, linking sub-context to its parent ContextControllerTreeEntry entry = new ContextControllerTreeEntry(originator, null, partitionKey, contextProperties); subcontexts.put(nextContext, entry); // now post-initialize, this may actually call back nextContext.activate(optionalTriggeringEvent, optionalTriggeringPattern, states, filterAddendum, importSubpathId); if (log.isDebugEnabled()) { log.debug("Instantiating branch context path for " + contextName + " from level " + originator.getFactory().getFactoryContext().getNestingLevel() + "(" + originator.getFactory().getFactoryContext().getContextName() + ")" + " parentPath " + originator.getPathId() + " for level " + nextContext.getFactory().getFactoryContext().getNestingLevel() + "(" + nextContext.getFactory().getFactoryContext().getContextName() + ")" + " childPath " + subPathId); } return new ContextManagerNestedInstanceHandle(subPathId, nextContext, subPathId, true, null); } // assign context id int assignedContextId; if (optionalContextPartitionId != null && !states.isImported()) { assignedContextId = optionalContextPartitionId; contextPartitionIdManager.addExisting(optionalContextPartitionId); } else { assignedContextId = contextPartitionIdManager.allocateId(); if (states != null && states.getPartitionImportCallback() != null && optionalContextPartitionId != null) { states.getPartitionImportCallback().allocated(assignedContextId, optionalContextPartitionId); } } if (log.isDebugEnabled()) { log.debug("Instantiating agent instance for " + contextName + " from level " + originator.getFactory().getFactoryContext().getNestingLevel() + "(" + originator.getFactory().getFactoryContext().getContextName() + ")" + " parentPath " + originator.getPathId() + " contextPartId " + assignedContextId); } // handle leaf creation List<AgentInstance> newInstances = new ArrayList<AgentInstance>(); if (state == ContextPartitionState.STARTED) { for (Map.Entry<String, ContextControllerStatementDesc> statementEntry : statements.entrySet()) { ContextControllerStatementDesc statementDesc = statementEntry.getValue(); AgentInstance instance = startStatement(assignedContextId, statementDesc, originator, partitionKey, contextProperties, isRecoveringResilient); newInstances.add(instance); } } // for all new contexts: evaluate this event for this statement if (optionalTriggeringEvent != null) { StatementAgentInstanceUtil.evaluateEventForStatement(servicesContext, optionalTriggeringEvent, optionalTriggeringPattern, newInstances); } // save leaf ContextControllerTreeEntry entry = subcontexts.get(originator); if (entry.getAgentInstances() == null) { entry.setAgentInstances(new LinkedHashMap<Integer, ContextControllerTreeAgentInstanceList>()); } long filterVersion = servicesContext.getFilterService().getFiltersVersion(); ContextControllerTreeAgentInstanceList agentInstanceList = new ContextControllerTreeAgentInstanceList( filterVersion, partitionKey, contextProperties, newInstances, state); entry.getAgentInstances().put(assignedContextId, agentInstanceList); return new ContextManagerNestedInstanceHandle(subPathId, originator, assignedContextId, false, agentInstanceList); } public synchronized void handleFilterFault(EventBean theEvent, long version) { for (Map.Entry<ContextController, ContextControllerTreeEntry> entry : subcontexts.entrySet()) { if (entry.getValue().getAgentInstances() != null) { StatementAgentInstanceUtil.handleFilterFault(theEvent, version, servicesContext, entry.getValue().getAgentInstances()); } } } /** * Provides the sub-context that ends. */ public synchronized void contextPartitionTerminate(ContextControllerInstanceHandle contextNestedHandle, Map<String, Object> terminationProperties) { ContextManagerNestedInstanceHandle handle = (ContextManagerNestedInstanceHandle) contextNestedHandle; if (handle.isBranch()) { ContextManagerNestedInstanceHandle branchHandle = handle; ContextController branch = branchHandle.getController(); recursiveDeactivateStop(branch); if (log.isDebugEnabled()) { log.debug("Terminated context branch for " + contextName + " from level " + branch.getFactory().getFactoryContext().getNestingLevel() + "(" + branch.getFactory().getFactoryContext().getContextName() + ")" + " parentPath " + branch.getPathId()); } } else { ContextManagerNestedInstanceHandle leafHandle = handle; ContextController leaf = leafHandle.getController(); ContextControllerTreeEntry leafEntry = subcontexts.get(leaf); if (leafEntry != null) { // could be terminated earlier ContextControllerTreeAgentInstanceList ailist = leafEntry.getAgentInstances() .get(leafHandle.getContextPartitionOrPathId()); if (ailist != null) { StatementAgentInstanceUtil.stopAgentInstances(ailist.getAgentInstances(), null, servicesContext, false); contextPartitionIdManager.removeId(leafHandle.getContextPartitionOrPathId()); ailist.getAgentInstances().clear(); } if (log.isDebugEnabled()) { log.debug("Terminated context leaf for " + contextName + " from level " + leaf.getFactory().getFactoryContext().getNestingLevel() + "(" + leaf.getFactory().getFactoryContext().getContextName() + ")" + " parentPath " + leaf.getPathId() + " contextPartId " + leafHandle.getContextPartitionOrPathId()); } } } } public synchronized Iterator<EventBean> iterator(String statementId) { AgentInstance[] instances = getAgentInstancesForStmt(statementId); return new AgentInstanceArrayIterator(instances); } public synchronized SafeIterator<EventBean> safeIterator(String statementId) { AgentInstance[] instances = getAgentInstancesForStmt(statementId); return new AgentInstanceArraySafeIterator(instances); } private AgentInstance startStatement(int contextId, ContextControllerStatementDesc statementDesc, ContextController originator, Object partitionKey, Map<String, Object> contextProperties, boolean isRecoveringResilient) { // build filters AgentInstanceFilterProxy proxy = getMergedFilterAddendums(statementDesc, originator, partitionKey, contextId); // build built-in context properties Map<String, Object> properties = ContextPropertyEventType.getNestedBeanBase(contextName, contextId); properties.put( nestedContextFactories[nestedContextFactories.length - 1].getFactoryContext().getContextName(), contextProperties); recursivePopulateBuiltinProps(originator, properties); properties.put(ContextPropertyEventType.PROP_CTX_NAME, contextName); properties.put(ContextPropertyEventType.PROP_CTX_ID, contextId); MappedEventBean contextBean = (MappedEventBean) servicesContext.getEventAdapterService().adapterForTypedMap( properties, contextDescriptor.getContextPropertyRegistry().getContextEventType()); // activate StatementAgentInstanceFactoryResult result = StatementAgentInstanceUtil.start(servicesContext, statementDesc.getStatement(), false, contextId, contextBean, proxy, isRecoveringResilient); return new AgentInstance(result.getStopCallback(), result.getAgentInstanceContext(), result.getFinalView()); } private void recursivePopulateBuiltinProps(ContextController originator, Map<String, Object> properties) { ContextControllerTreeEntry entry = subcontexts.get(originator); if (entry.getInitContextProperties() != null) { properties.put(entry.getParent().getFactory().getFactoryContext().getContextName(), entry.getInitContextProperties()); } if (entry.getParent() != null && entry.getParent().getFactory().getFactoryContext().getNestingLevel() > 1) { recursivePopulateBuiltinProps(entry.getParent(), properties); } } private AgentInstanceFilterProxy getMergedFilterAddendums(ContextControllerStatementDesc statement, ContextController originator, Object partitionKey, int contextId) { IdentityHashMap<FilterSpecCompiled, FilterValueSetParam[]> result = new IdentityHashMap<FilterSpecCompiled, FilterValueSetParam[]>(); originator.getFactory().populateFilterAddendums(result, statement, partitionKey, contextId); ContextControllerTreeEntry originatorEntry = subcontexts.get(originator); if (originatorEntry != null) { recursivePopulateFilterAddendum(statement, originatorEntry, contextId, result); } return new AgentInstanceFilterProxyImpl(result); } private void recursivePopulateFilterAddendum(ContextControllerStatementDesc statement, ContextControllerTreeEntry originatorEntry, int contextId, IdentityHashMap<FilterSpecCompiled, FilterValueSetParam[]> result) { if (originatorEntry.getParent() == null) { return; } originatorEntry.getParent().getFactory().populateFilterAddendums(result, statement, originatorEntry.getInitPartitionKey(), contextId); ContextControllerTreeEntry parentEntry = subcontexts.get(originatorEntry.getParent()); if (parentEntry != null) { recursivePopulateFilterAddendum(statement, parentEntry, contextId, result); } } private void activate() { rootContext = nestedContextFactories[0].createNoCallback(0, this); subcontexts.put(rootContext, new ContextControllerTreeEntry(null, null, null, null)); rootContext.activate(null, null, null, null, null); } private void removeStatement(String statementId) { ContextControllerStatementDesc statementDesc = statements.get(statementId); if (statementDesc == null) { return; } for (Map.Entry<ContextController, ContextControllerTreeEntry> entry : subcontexts.entrySet()) { // ignore branches if (entry.getKey().getFactory().getFactoryContext().getNestingLevel() < nestedContextFactories.length) { continue; } if (entry.getValue().getAgentInstances() == null || entry.getValue().getAgentInstances().isEmpty()) { continue; } for (Map.Entry<Integer, ContextControllerTreeAgentInstanceList> contextPartitionEntry : entry.getValue() .getAgentInstances().entrySet()) { Iterator<AgentInstance> instanceIt = contextPartitionEntry.getValue().getAgentInstances() .iterator(); for (; instanceIt.hasNext();) { AgentInstance instance = instanceIt.next(); if (!instance.getAgentInstanceContext().getStatementContext().getStatementId() .equals(statementId)) { continue; } StatementAgentInstanceUtil.stop(instance.getStopCallback(), instance.getAgentInstanceContext(), instance.getFinalView(), servicesContext, true); instanceIt.remove(); } } } statements.remove(statementId); } private void recursiveDeactivateStop(ContextController currentContext) { // deactivate currentContext.deactivate(); // remove state ContextControllerTreeEntry entry = subcontexts.remove(currentContext); if (entry == null) { return; } // remove from parent ContextControllerTreeEntry parent = subcontexts.get(entry.getParent()); if (parent != null) { parent.getChildContexts().remove(currentContext.getPathId()); } // stop instances if (entry.getAgentInstances() != null) { for (Map.Entry<Integer, ContextControllerTreeAgentInstanceList> entryCP : entry.getAgentInstances() .entrySet()) { StatementAgentInstanceUtil.stopAgentInstances(entryCP.getValue().getAgentInstances(), null, servicesContext, false); contextPartitionIdManager.removeId(entryCP.getKey()); } } // deactivate child contexts if (entry.getChildContexts() == null || entry.getChildContexts().isEmpty()) { return; } for (ContextController inner : entry.getChildContexts().values()) { recursiveDeactivateStop(inner); } } private AgentInstance[] getAgentInstancesForStmt(String statementId) { List<AgentInstance> instances = new ArrayList<AgentInstance>(); for (Map.Entry<ContextController, ContextControllerTreeEntry> subcontext : subcontexts.entrySet()) { if (subcontext.getKey().getFactory().getFactoryContext() .getNestingLevel() != nestedContextFactories.length) { continue; } if (subcontext.getValue().getAgentInstances() == null || subcontext.getValue().getAgentInstances().isEmpty()) { continue; } for (Map.Entry<Integer, ContextControllerTreeAgentInstanceList> entry : subcontext.getValue() .getAgentInstances().entrySet()) { for (AgentInstance ai : entry.getValue().getAgentInstances()) { if (ai.getAgentInstanceContext().getStatementContext().getStatementId().equals(statementId)) { instances.add(ai); } } } } return instances.toArray(new AgentInstance[instances.size()]); } private AgentInstance[] getAgentInstancesForStmt(String statementId, ContextPartitionSelector selector) { Collection<Integer> agentInstanceIds = getAgentInstancesForSelector(selector); if (agentInstanceIds == null || agentInstanceIds.isEmpty()) { return new AgentInstance[0]; } List<AgentInstance> instances = new ArrayList<AgentInstance>(agentInstanceIds.size()); for (Map.Entry<ContextController, ContextControllerTreeEntry> subcontext : subcontexts.entrySet()) { if (subcontext.getKey().getFactory().getFactoryContext() .getNestingLevel() != nestedContextFactories.length) { continue; } if (subcontext.getValue().getAgentInstances() == null || subcontext.getValue().getAgentInstances().isEmpty()) { continue; } for (Integer agentInstanceId : agentInstanceIds) { ContextControllerTreeAgentInstanceList instancesList = subcontext.getValue().getAgentInstances() .get(agentInstanceId); if (instancesList != null) { Iterator<AgentInstance> instanceIt = instancesList.getAgentInstances().iterator(); for (; instanceIt.hasNext();) { AgentInstance instance = instanceIt.next(); if (instance.getAgentInstanceContext().getStatementContext().getStatementId() .equals(statementId)) { instances.add(instance); } } } } } return instances.toArray(new AgentInstance[instances.size()]); } private Collection<Integer> getAgentInstancesForSelector(ContextPartitionSelector selector) { if (selector instanceof ContextPartitionSelectorById) { ContextPartitionSelectorById byId = (ContextPartitionSelectorById) selector; Set<Integer> ids = byId.getContextPartitionIds(); if (ids == null || ids.isEmpty()) { return Collections.emptyList(); } ArrayList agentInstanceIds = new ArrayList<Integer>(ids); agentInstanceIds.retainAll(contextPartitionIdManager.getIds()); return agentInstanceIds; } else if (selector instanceof ContextPartitionSelectorAll) { return new ArrayList<Integer>(contextPartitionIdManager.getIds()); } else if (selector instanceof ContextPartitionSelectorNested) { ContextPartitionSelectorNested nested = (ContextPartitionSelectorNested) selector; ContextPartitionVisitorAgentInstanceIdWPath visitor = new ContextPartitionVisitorAgentInstanceIdWPath( nestedContextFactories.length); for (ContextPartitionSelector[] item : nested.getSelectors()) { recursivePopulateSelector(rootContext, 1, item, visitor); } return visitor.getAgentInstanceIds(); } throw ContextControllerSelectorUtil.getInvalidSelector(new Class[] { ContextPartitionSelectorNested.class }, selector, true); } private void recursivePopulateSelector(ContextController currentContext, int level, ContextPartitionSelector[] selectorStack, ContextPartitionVisitorWithPath visitor) { ContextControllerTreeEntry entry = subcontexts.get(currentContext); if (entry == null) { return; } ContextPartitionSelector selector = selectorStack[level - 1]; // handle branch if (level < nestedContextFactories.length) { visitor.resetSubPaths(); currentContext.visitSelectedPartitions(selector, visitor); Collection<Integer> selectedPaths = new ArrayList<Integer>(visitor.getSubpaths()); for (Integer path : selectedPaths) { ContextController controller = entry.getChildContexts().get(path); if (controller != null) { recursivePopulateSelector(controller, level + 1, selectorStack, visitor); } } } // handle leaf else { currentContext.visitSelectedPartitions(selector, visitor); } } }