/** * This method is used to obtain a {@link ModuleHandler} for the specified {@link ModuleImpl}. * * @param m the {@link ModuleImpl} which is looking for a handler. * @param ruleUID UID of the {@link Rule} that the specified {@link ModuleImpl} belongs to. * @return handler that processing this module. Could be {@code null} if the {@link ModuleHandlerFactory} is not * available. */ private @Nullable ModuleHandler getModuleHandler(Module m, String ruleUID) { String moduleTypeId = m.getTypeUID(); ModuleHandlerFactory mhf = getModuleHandlerFactory(moduleTypeId); if (mhf == null || mtRegistry.get(moduleTypeId) == null) { return null; } return mhf.getHandler(m, ruleUID); }
/** * Unbind the {@link ModuleHandlerFactory} service - called from DS. * * @param moduleHandlerFactory a {@link ModuleHandlerFactory} service. */ protected void removeModuleHandlerFactory(ModuleHandlerFactory moduleHandlerFactory) { if (moduleHandlerFactory instanceof CompositeModuleHandlerFactory) { compositeFactory.deactivate(); compositeFactory = null; } allModuleHandlerFactories.remove(moduleHandlerFactory); Collection<String> moduleTypes = moduleHandlerFactory.getTypes(); removeMissingModuleTypes(moduleTypes); for (Iterator<String> it = moduleTypes.iterator(); it.hasNext();) { String moduleTypeName = it.next(); moduleHandlerFactories.remove(moduleTypeName); } }
@SuppressWarnings({ "unchecked" }) @Override public void ungetHandler(Module module, String childModulePrefix, ModuleHandler handler) { ModuleHandler handlerOfModule = getHandlers().get(childModulePrefix + module.getId()); if (handlerOfModule instanceof AbstractCompositeModuleHandler) { AbstractCompositeModuleHandler<ModuleImpl, ?, ?> h = (AbstractCompositeModuleHandler<ModuleImpl, ?, ?>) handlerOfModule; Set<ModuleImpl> modules = h.moduleHandlerMap.keySet(); if (modules != null) { for (ModuleImpl child : modules) { ModuleHandler childHandler = h.moduleHandlerMap.get(child); ModuleHandlerFactory mhf = ruleEngine.getModuleHandlerFactory(child.getTypeUID()); mhf.ungetHandler(child, childModulePrefix + ":" + module.getId(), childHandler); } } } String ruleId = getRuleId(childModulePrefix); super.ungetHandler(module, ruleId, handler); }
/** * Unlink module handlers from their modules. The method is called when the rule containing these modules goes into * {@link RuleStatus#UNINITIALIZED} state. * * @param modules list of modules which should be disconnected. */ private <T extends WrappedModule<?, ?>> void removeModuleHandlers(List<T> modules, String ruleUID) { for (T mm : modules) { final Module m = mm.unwrap(); ModuleHandler handler = mm.getModuleHandler(); if (handler != null) { ModuleHandlerFactory factory = getModuleHandlerFactory(m.getTypeUID()); if (factory != null) { factory.ungetHandler(m, ruleUID, handler); } mm.setModuleHandler(null); } } }
logger.debug("ModuleHandlerFactory added {}", moduleHandlerFactory.getClass().getSimpleName()); allModuleHandlerFactories.add(moduleHandlerFactory); Collection<String> moduleTypes = moduleHandlerFactory.getTypes(); Set<String> notInitializedRules = null; for (Iterator<String> it = moduleTypes.iterator(); it.hasNext();) {
MT childHandler = (MT) childMhf.getHandler(child, childModulePrefix + ":" + compositeModuleId);
@Override public void added(ModuleType moduleType) { String moduleTypeName = moduleType.getUID(); for (ModuleHandlerFactory moduleHandlerFactory : allModuleHandlerFactories) { Collection<String> moduleTypes = moduleHandlerFactory.getTypes(); if (moduleTypes.contains(moduleTypeName)) { synchronized (this) { this.moduleHandlerFactories.put(moduleTypeName, moduleHandlerFactory); } break; } } Set<String> rules = null; synchronized (this) { Set<String> rulesPerModule = mapModuleTypeToRules.get(moduleTypeName); if (rulesPerModule != null) { rules = new HashSet<String>(); rules.addAll(rulesPerModule); } } if (rules != null) { for (String rUID : rules) { RuleStatus ruleStatus = getRuleStatus(rUID); if (ruleStatus == RuleStatus.UNINITIALIZED) { scheduleRuleInitialization(rUID); } } } }