X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=engine-d%2Fsrc%2Fmain%2Fjava%2Forg%2Fonap%2Fholmes%2Fengine%2Fmanager%2FDroolsEngine.java;h=bb3795d40dece8f45687401c519085d84332ad45;hb=d70f48853bf9ab690f3019b1682c422a6854fd8b;hp=5ccf29b7acf8f24c56255c71c841e2cfbfab078d;hpb=a779cb1587f67a3fedd945445f5abfbb05a1d4a3;p=holmes%2Fengine-management.git diff --git a/engine-d/src/main/java/org/onap/holmes/engine/manager/DroolsEngine.java b/engine-d/src/main/java/org/onap/holmes/engine/manager/DroolsEngine.java index 5ccf29b..bb3795d 100644 --- a/engine-d/src/main/java/org/onap/holmes/engine/manager/DroolsEngine.java +++ b/engine-d/src/main/java/org/onap/holmes/engine/manager/DroolsEngine.java @@ -14,9 +14,8 @@ * limitations under the License. */ package org.onap.holmes.engine.manager; - - import java.io.StringReader; +import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Locale; @@ -24,20 +23,36 @@ import java.util.Set; import javax.annotation.PostConstruct; import javax.inject.Inject; import lombok.extern.slf4j.Slf4j; -import org.drools.KnowledgeBase; -import org.drools.KnowledgeBaseConfiguration; -import org.drools.KnowledgeBaseFactory; -import org.drools.builder.KnowledgeBuilder; -import org.drools.builder.KnowledgeBuilderFactory; -import org.drools.builder.ResourceType; -import org.drools.conf.EventProcessingOption; -import org.drools.definition.KnowledgePackage; -import org.drools.io.Resource; -import org.drools.io.ResourceFactory; -import org.drools.runtime.StatefulKnowledgeSession; -import org.drools.runtime.rule.FactHandle; +import org.drools.compiler.kie.builder.impl.InternalKieModule; import org.jvnet.hk2.annotations.Service; + +import org.kie.api.KieBase; +import org.kie.api.KieServices; +import org.kie.api.builder.KieBuilder; +import org.kie.api.builder.KieFileSystem; +import org.kie.api.builder.KieRepository; +import org.kie.api.builder.Message; +import org.kie.api.builder.Message.Level; +import org.kie.api.builder.model.KieBaseModel; +import org.kie.api.builder.model.KieModuleModel; +import org.kie.api.builder.model.KieSessionModel; +import org.kie.api.conf.EqualityBehaviorOption; +import org.kie.api.conf.EventProcessingOption; +import org.kie.api.definition.KiePackage; +import org.kie.api.io.KieResources; +import org.kie.api.io.ResourceType; +import org.kie.api.runtime.KieContainer; +import org.kie.api.runtime.KieSession; +import org.kie.api.runtime.conf.ClockTypeOption; +import org.kie.api.runtime.rule.FactHandle; + +import org.onap.holmes.common.api.entity.AlarmInfo; + import org.onap.holmes.common.api.stat.VesAlarm; +import org.onap.holmes.common.dmaap.DmaapService; +import org.onap.holmes.common.exception.AlarmInfoException; +import org.onap.holmes.common.utils.DbDaoUtil; +import org.onap.holmes.engine.db.AlarmInfoDao; import org.onap.holmes.engine.request.DeployRuleRequest; import org.onap.holmes.common.api.entity.CorrelationRule; import org.onap.holmes.common.exception.CorrelationException; @@ -48,16 +63,33 @@ import org.onap.holmes.engine.wrapper.RuleMgtWrapper; @Service public class DroolsEngine { - private final static int ENABLE = 1; + private static final int ENABLE = 1; + public static final String UTF_8 = "UTF-8"; + public static final String K_BASE = "KBase"; + private static final String RULES_FILE_NAME = "src/main/resources/rules/rule.drl"; private final Set packageNames = new HashSet(); + @Inject private RuleMgtWrapper ruleMgtWrapper; - private KnowledgeBase kbase; - private KnowledgeBaseConfiguration kconf; - private StatefulKnowledgeSession ksession; + + + private KieBase kieBase; + private KieSession kieSession; + private KieContainer kieContainer; + private KieFileSystem kfs; + private KieServices ks; + private KieBuilder kieBuilder; + private KieResources resources; + private KieRepository kieRepository; + + private AlarmInfoDao alarmInfoDao; + @Inject + private DbDaoUtil daoUtil; + @PostConstruct private void init() { + alarmInfoDao = daoUtil.getJdbiDaoByOnDemand(AlarmInfoDao.class); try { // start engine start(); @@ -67,29 +99,31 @@ public class DroolsEngine { } } - private void start() throws CorrelationException { + private void start() throws AlarmInfoException { log.info("Drools Engine Initialize Beginning..."); initEngineParameter(); - initDeployRule(); + alarmSynchronization(); +// initDeployRule(); - log.info("Business Rule Engine Initialize Successfully."); + log.info("Alarm synchronization Successfully."); } public void stop() { - this.ksession.dispose(); + this.kieSession.dispose(); } - private void initEngineParameter() { - this.kconf = KnowledgeBaseFactory.newKnowledgeBaseConfiguration(); - - this.kconf.setOption(EventProcessingOption.STREAM); + public void initEngineParameter() { + this.ks = KieServices.Factory.get(); + this.resources = ks.getResources(); + this.kieRepository = ks.getRepository(); + this.kfs = createKieFileSystemWithKProject(ks); - this.kconf.setProperty("drools.assertBehaviour", "equality"); + this.kieBuilder = ks.newKieBuilder(kfs).buildAll(); + this.kieContainer = ks.newKieContainer(kieRepository.getDefaultReleaseId()); - this.kbase = KnowledgeBaseFactory.newKnowledgeBase("D-ENGINE", this.kconf); - - this.ksession = kbase.newStatefulKnowledgeSession(); + this.kieBase = kieContainer.getKieBase(); + this.kieSession = kieContainer.newKieSession(); } private void initDeployRule() throws CorrelationException { @@ -101,105 +135,187 @@ public class DroolsEngine { for (CorrelationRule rule : rules) { if (rule.getContent() != null) { deployRuleFromDB(rule.getContent()); + DmaapService.loopControlNames.put(rule.getPackageName(), rule.getClosedControlLoopName()); } } } private void deployRuleFromDB(String ruleContent) throws CorrelationException { + avoidDeployBug(); StringReader reader = new StringReader(ruleContent); - Resource res = ResourceFactory.newReaderResource(reader); - - KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder(); - - kbuilder.add(res, ResourceType.DRL); - + kfs.write(RULES_FILE_NAME, + this.resources.newReaderResource(reader, UTF_8).setResourceType(ResourceType.DRL)); + kieBuilder = ks.newKieBuilder(kfs).buildAll(); try { - - kbase.addKnowledgePackages(kbuilder.getKnowledgePackages()); + InternalKieModule internalKieModule = (InternalKieModule)kieBuilder.getKieModule(); + kieContainer.updateToVersion(internalKieModule.getReleaseId()); } catch (Exception e) { throw new CorrelationException(e.getMessage(), e); } - ksession.fireAllRules(); + kieSession.fireAllRules(); } public synchronized String deployRule(DeployRuleRequest rule, Locale locale) throws CorrelationException { + avoidDeployBug(); StringReader reader = new StringReader(rule.getContent()); - Resource res = ResourceFactory.newReaderResource(reader); - - KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder(); + kfs.write(RULES_FILE_NAME, + this.resources.newReaderResource(reader, UTF_8).setResourceType(ResourceType.DRL)); + kieBuilder = ks.newKieBuilder(kfs).buildAll(); - kbuilder.add(res, ResourceType.DRL); + judgeRuleContent(locale, kieBuilder, true); - judgeRuleContent(locale, kbuilder, true); - - String packageName = kbuilder.getKnowledgePackages().iterator().next().getName(); + InternalKieModule internalKieModule = (InternalKieModule)kieBuilder.getKieModule();; + String packageName = internalKieModule.getKnowledgePackagesForKieBase(K_BASE).iterator().next().getName(); try { - packageNames.add(packageName); - kbase.addKnowledgePackages(kbuilder.getKnowledgePackages()); + kieContainer.updateToVersion(internalKieModule.getReleaseId()); } catch (Exception e) { throw new CorrelationException("Failed to deploy the rule.", e); } - - ksession.fireAllRules(); + packageNames.add(packageName); + kieSession.fireAllRules(); return packageName; } public synchronized void undeployRule(String packageName, Locale locale) throws CorrelationException { - - KnowledgePackage pkg = kbase.getKnowledgePackage(packageName); - - if (null == pkg) { + KiePackage kiePackage = kieBase.getKiePackage(packageName); + if (null == kiePackage) { throw new CorrelationException("The rule " + packageName + " does not exist!"); } - try { - kbase.removeKnowledgePackage(pkg.getName()); + kieBase.removeKiePackage(kiePackage.getName()); } catch (Exception e) { throw new CorrelationException("Failed to delete the rule: " + packageName, e); } - packageNames.remove(pkg.getName()); + packageNames.remove(kiePackage.getName()); } public void compileRule(String content, Locale locale) throws CorrelationException { StringReader reader = new StringReader(content); - Resource res = ResourceFactory.newReaderResource(reader); - KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder(); + kfs.write(RULES_FILE_NAME, + this.resources.newReaderResource(reader, UTF_8).setResourceType(ResourceType.DRL)); - kbuilder.add(res, ResourceType.DRL); + kieBuilder = ks.newKieBuilder(kfs).buildAll(); - judgeRuleContent(locale, kbuilder, false); + judgeRuleContent(locale, kieBuilder, false); } - private void judgeRuleContent(Locale locale, KnowledgeBuilder kbuilder, boolean judgePackageName) + private void judgeRuleContent(Locale locale, KieBuilder kbuilder, boolean judgePackageName) throws CorrelationException { - if (kbuilder.hasErrors()) { - String errorMsg = "There are errors in the rule: " + kbuilder.getErrors().toString(); + if (kbuilder.getResults().hasMessages(Message.Level.ERROR)) { + String errorMsg = "There are errors in the rule: " + kbuilder.getResults() + .getMessages(Level.ERROR).toString(); log.error(errorMsg); throw new CorrelationException(errorMsg); } + InternalKieModule internalKieModule = null; + try { + internalKieModule = (InternalKieModule) kbuilder.getKieModule(); + } catch (Exception e) { + throw new CorrelationException("There are errors in the rule!" + e.getMessage(), e); + } + if (internalKieModule == null) { + throw new CorrelationException("There are errors in the rule!"); + } + String packageName = internalKieModule.getKnowledgePackagesForKieBase(K_BASE).iterator().next().getName(); - String packageName = kbuilder.getKnowledgePackages().iterator().next().getName(); - - if (packageNames.contains(packageName) && judgePackageName) { + if (queryAllPackage().contains(packageName) && judgePackageName) { throw new CorrelationException("The rule " + packageName + " already exists in the drools engine."); } } - public void putRaisedIntoStream(VesAlarm raiseAlarm) { - FactHandle factHandle = this.ksession.getFactHandle(raiseAlarm); + public void putRaisedIntoStream(VesAlarm alarm) { + FactHandle factHandle = this.kieSession.getFactHandle(alarm); if (factHandle != null) { - Object obj = this.ksession.getObject(factHandle); + Object obj = this.kieSession.getObject(factHandle); if (obj != null && obj instanceof VesAlarm) { - raiseAlarm.setRootFlag(((VesAlarm) obj).getRootFlag()); + alarm.setRootFlag(((VesAlarm) obj).getRootFlag()); + } + this.kieSession.delete(factHandle); + + if (alarm.getAlarmIsCleared() == 1) { + alarmInfoDao.deleteClearedAlarm(convertVesAlarm2AlarmInfo(alarm)); } - this.ksession.retract(factHandle); + } else { + this.kieSession.insert(alarm); + } + + this.kieSession.fireAllRules(); + + } + + public List queryAllPackage() { + List kiePackages = (List)kieBase.getKiePackages(); + List list = new ArrayList<>(); + for(KiePackage kiePackage : kiePackages) { + list.add(kiePackage.getName()); } - this.ksession.insert(raiseAlarm); - this.ksession.fireAllRules(); + return list; + } + + private KieFileSystem createKieFileSystemWithKProject(KieServices ks) { + KieModuleModel kieModuleModel = ks.newKieModuleModel(); + KieBaseModel kieBaseModel = kieModuleModel.newKieBaseModel(K_BASE) + .addPackage("rules") + .setDefault(true) + .setEqualsBehavior(EqualityBehaviorOption.EQUALITY) + .setEventProcessingMode(EventProcessingOption.STREAM); + KieSessionModel kieSessionModel = kieBaseModel.newKieSessionModel("KSession") + .setDefault( true ) + .setType( KieSessionModel.KieSessionType.STATEFUL ) + .setClockType( ClockTypeOption.get("realtime") ); + KieFileSystem kfs = ks.newKieFileSystem(); + kfs.writeKModuleXML(kieModuleModel.toXML()); + return kfs; + } + + private void avoidDeployBug() { + String tmp = Math.random() + ""; + String rule = "package justInOrderToAvoidDeployBug" + tmp.substring(2); + kfs.write(RULES_FILE_NAME, rule); + kieBuilder = ks.newKieBuilder(kfs).buildAll(); + InternalKieModule internalKieModule = (InternalKieModule)kieBuilder.getKieModule(); + String packageName = internalKieModule.getKnowledgePackagesForKieBase(K_BASE).iterator().next().getName(); + kieRepository.addKieModule(internalKieModule); + kieContainer.updateToVersion(internalKieModule.getReleaseId()); + + KiePackage kiePackage = kieBase.getKiePackage(packageName); + kieBase.removeKiePackage(kiePackage.getName()); + } + + public void alarmSynchronization() throws AlarmInfoException { + alarmInfoDao.queryAllAlarm().forEach(alarmInfo -> alarmInfoDao.deleteClearedAlarm(alarmInfo)); + alarmInfoDao.queryAllAlarm().forEach(alarmInfo -> putRaisedIntoStream(convertAlarmInfo2VesAlarm(alarmInfo))); + } + + private VesAlarm convertAlarmInfo2VesAlarm(AlarmInfo alarmInfo) { + VesAlarm vesAlarm = new VesAlarm(); + vesAlarm.setEventId(alarmInfo.getEventId()); + vesAlarm.setEventName(alarmInfo.getEventName()); + vesAlarm.setStartEpochMicrosec(alarmInfo.getStartEpochMicroSec()); + vesAlarm.setSourceId(alarmInfo.getSourceId()); + vesAlarm.setSourceName(alarmInfo.getSourceName()); + vesAlarm.setRootFlag(alarmInfo.getRootFlag()); + vesAlarm.setAlarmIsCleared(alarmInfo.getAlarmIsCleared()); + vesAlarm.setLastEpochMicrosec(alarmInfo.getLastEpochMicroSec()); + return vesAlarm; + } + + private AlarmInfo convertVesAlarm2AlarmInfo(VesAlarm vesAlarm){ + AlarmInfo alarmInfo = new AlarmInfo(); + alarmInfo.setEventId(vesAlarm.getEventId()); + alarmInfo.setEventName(vesAlarm.getEventName()); + alarmInfo.setStartEpochMicroSec(vesAlarm.getStartEpochMicrosec()); + alarmInfo.setLastEpochMicroSec(vesAlarm.getLastEpochMicrosec()); + alarmInfo.setSourceId(vesAlarm.getSourceId()); + alarmInfo.setSourceName(vesAlarm.getSourceName()); + alarmInfo.setAlarmIsCleared(vesAlarm.getAlarmIsCleared()); + alarmInfo.setRootFlag(vesAlarm.getRootFlag()); + + return alarmInfo; } }