synchronized StatelessSession getSession(final RulesData rules, final File folder) throws Exception { // if (!MiscUtil.equals(rules.getModified(), timestamp)) { // session = null; // } if (session != null) { return session; } ClassLoader oldCl = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(RuleEngine.class.getClassLoader()); PackageBuilder builder = new PackageBuilder(); StringBuilder script = new StringBuilder(); rules.buildScript(script); if (LOG.isDebugEnabled()) { LOG.debug("compiling rules script:\r\n" + script); } builder.addPackageFromDrl(new StringReader(script.toString())); RuleBase ruleBase = RuleBaseFactory.newRuleBase(); ruleBase.addPackage(builder.getPackage()); session = ruleBase.newStatelessSession(); LOG.debug("(re-)built rules for " + rules.getUid()); timestamp = rules.getModified(); } finally { Thread.currentThread().setContextClassLoader(oldCl); } save(folder); return session; }
public void test5() throws Exception { String process = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n" + " xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n" + " xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n" + " type=\"RuleFlow\" name=\"ruleflow\" id=\"com.sample.ruleflow\" package-name=\"com.sample\" >\n" + "\n" + " <header>\n" + " </header>\n" + "\n" + " <nodes>\n" + " <start id=\"1\" name=\"Start\" />\n" + " <timerNode id=\"4\" name=\"Timer\" delay=\"200\" />\n" + " <end id=\"3\" name=\"End\" />\n" + " </nodes>\n" + "\n" + " <connections>\n" + " <connection from=\"1\" to=\"4\" />\n" + " <connection from=\"4\" to=\"3\" />\n" + " </connections>\n" + "\n" + "</process>\n"; final PackageBuilder builder = new PackageBuilder(); builder.addProcessFromXml(new StringReader(process)); final Package pkg = builder.getPackage(); final RuleBase ruleBase = RuleBaseFactory.newRuleBase(); ruleBase.addPackage(pkg); final StatefulSession session = ruleBase.newStatefulSession(); new Thread( new Runnable() { public void run() { session.fireUntilHalt(); } }) .start(); session.startProcess("com.sample.ruleflow", null); assertEquals(1, session.getProcessInstances().size()); session.halt(); final StatefulSession session2 = getSerialisedStatefulSession(session); new Thread( new Runnable() { public void run() { session2.fireUntilHalt(); } }) .start(); Thread.sleep(400); assertEquals(0, session2.getProcessInstances().size()); session2.halt(); }
@SuppressWarnings("unchecked") public void test1() throws Exception { String rule = "package org.test;\n"; rule += "import org.jbpm.Person\n"; rule += "global java.util.List list\n"; rule += "rule \"Rule 1\"\n"; rule += " ruleflow-group \"hello\"\n"; rule += "when\n"; rule += " $p : Person( ) \n"; rule += "then\n"; rule += " list.add( $p );\n"; rule += "end"; final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl(new StringReader(rule)); String process = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + "<process xmlns=\"http://drools.org/drools-5.0/process\"\n" + " xmlns:xs=\"http://www.w3.org/2001/XMLSchema-instance\"\n" + " xs:schemaLocation=\"http://drools.org/drools-5.0/process drools-processes-5.0.xsd\"\n" + " type=\"RuleFlow\" name=\"ruleflow\" id=\"org.test.ruleflow\" package-name=\"org.test\" >\n" + " <header>\n" + " </header>\n" + " <nodes>\n" + " <start id=\"1\" name=\"Start\" />\n" + " <ruleSet id=\"2\" name=\"Hello\" ruleFlowGroup=\"hello\" />\n" + " <end id=\"3\" name=\"End\" />\n" + " </nodes>\n" + " <connections>\n" + " <connection from=\"1\" to=\"2\"/>\n" + " <connection from=\"2\" to=\"3\"/>\n" + " </connections>\n" + "</process>"; builder.addProcessFromXml(new StringReader(process)); final Package pkg = builder.getPackage(); final RuleBase ruleBase = RuleBaseFactory.newRuleBase(); ruleBase.addPackage(pkg); StatefulSession session = ruleBase.newStatefulSession(); List<Object> list = new ArrayList<Object>(); session.setGlobal("list", list); Person p = new Person("bobba fet", 32); session.insert(p); session.startProcess("org.test.ruleflow"); assertEquals(1, session.getProcessInstances().size()); session = getSerialisedStatefulSession(session); assertEquals(1, session.getProcessInstances().size()); session.fireAllRules(); assertEquals(1, ((List<Object>) session.getGlobal("list")).size()); assertEquals(p, ((List<Object>) session.getGlobal("list")).get(0)); assertEquals(0, session.getProcessInstances().size()); }
public RuleEngine(String rulesFile) throws RuleEngineException { try { Reader source = new InputStreamReader(new BufferedInputStream(new FileInputStream(rulesFile))); // switch to JANINO compiler Properties properties = new Properties(); properties.setProperty("drools.dialect.java.compiler", "JANINO"); PackageBuilderConfiguration cfg = new PackageBuilderConfiguration(properties); // build a rule package PackageBuilder builder = new PackageBuilder(cfg); // parse and compile rules builder.addPackageFromDrl(source); Package pkg = builder.getPackage(); rules = RuleBaseFactory.newRuleBase(); rules.addPackage(pkg); } catch (Exception e) { throw new RuleEngineException( "Could not load/compile rules from file: '" + rulesFile + "' ", e); } }
@Test public void testLogicalInsertionsNoLoop() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("test_LogicalInsertionsNoLoop.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); final WorkingMemory workingMemory = ruleBase.newStatefulSession(); List list; final List l = new ArrayList(); final Person a = new Person("a"); workingMemory.setGlobal("a", a); workingMemory.setGlobal("l", l); workingMemory.fireAllRules(); list = IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(a.getClass()))); assertEquals("a still in WM", 0, list.size()); assertEquals("Rule should not loop", 1, l.size()); }
/** Please note that this is the "low level" rule assembly API. */ private RuleBase readRule() throws Exception, DroolsParserException, RuleIntegrationException, PackageIntegrationException, InvalidPatternException { // read in the source final Reader reader = new InputStreamReader(Waltz.class.getResourceAsStream("waltz.drl")); final DrlParser parser = new DrlParser(LanguageLevelOption.DRL5); final PackageDescr packageDescr = parser.parse(reader); if (parser.hasErrors()) { for (DroolsError error : parser.getErrors()) { System.out.println(error); } assertFalse(parser.getErrors().toString(), parser.hasErrors()); } // pre build the package final PackageBuilder builder = new PackageBuilder(); builder.addPackage(packageDescr); final Package pkg = builder.getPackage(); // add the package to a rulebase final RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); return ruleBase; // return SerializationHelper.serializeObject(ruleBase); }
@Test @Ignore public void testStatefulSessionsCreation() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("test_OutOfMemoryError.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); int i = 0; SessionConfiguration conf = new SessionConfiguration(); conf.setKeepReference( true); // this is just for documentation purposes, since the default value is "true" try { for (i = 0; i < 300000; i++) { final StatefulSession session = ruleBase.newStatefulSession(conf, null); session.dispose(); } } catch (Throwable e) { System.out.println("Error at: " + i); e.printStackTrace(); fail("Should not raise any error or exception."); } }
private static void loadRuleFile() { try { ClassLoader classLoader = Steward.class.getClassLoader(); PackageBuilderConfiguration configuration = new PackageBuilderConfiguration(classLoader); PackageBuilder builder = new PackageBuilder(configuration); Reader rulesFile = new InputStreamReader(Steward.class.getResourceAsStream("../Steward.drl")); builder.addPackageFromDrl(rulesFile); Reader ruleFlowFile1 = new InputStreamReader(Steward.class.getResourceAsStream("../ActionGeneration.rfm")); Reader ruleFlowFile2 = new InputStreamReader(Steward.class.getResourceAsStream("../ActionSelection.rfm")); builder.addRuleFlow(ruleFlowFile1); builder.addRuleFlow(ruleFlowFile2); if (builder.hasErrors()) { System.out.println(builder.getErrors().toString()); throw new RuntimeException("Unable to compile rule file."); } RuleBaseConfiguration ruleBaseConfiguration = new RuleBaseConfiguration(classLoader); ruleBase = RuleBaseFactory.newRuleBase(ruleBaseConfiguration); ruleBase.addPackage(builder.getPackage()); } catch (Exception e) { e.printStackTrace(); throw new RuntimeException(e); } }
private Collection<KnowledgePackage> getProcessWorkItems() { RuleFlowProcess process = new RuleFlowProcess(); process.setId("org.drools.test.TestProcess"); process.setName("TestProcess"); process.setPackageName("org.drools.test"); StartNode start = new StartNode(); start.setId(1); start.setName("Start"); process.addNode(start); ActionNode actionNode = new ActionNode(); actionNode.setId(2); actionNode.setName("Action"); DroolsConsequenceAction action = new DroolsConsequenceAction(); action.setDialect("java"); action.setConsequence("System.out.println(\"Executed action\");"); actionNode.setAction(action); process.addNode(actionNode); new ConnectionImpl( start, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE); WorkItemNode workItemNode = new WorkItemNode(); workItemNode.setId(3); workItemNode.setName("WorkItem1"); Work work = new WorkImpl(); work.setName("MyWork"); workItemNode.setWork(work); process.addNode(workItemNode); new ConnectionImpl( actionNode, Node.CONNECTION_DEFAULT_TYPE, workItemNode, Node.CONNECTION_DEFAULT_TYPE); WorkItemNode workItemNode2 = new WorkItemNode(); workItemNode2.setId(4); workItemNode2.setName("WorkItem2"); work = new WorkImpl(); work.setName("MyWork"); workItemNode2.setWork(work); process.addNode(workItemNode2); new ConnectionImpl( workItemNode, Node.CONNECTION_DEFAULT_TYPE, workItemNode2, Node.CONNECTION_DEFAULT_TYPE); WorkItemNode workItemNode3 = new WorkItemNode(); workItemNode3.setId(5); workItemNode3.setName("WorkItem3"); work = new WorkImpl(); work.setName("MyWork"); workItemNode3.setWork(work); process.addNode(workItemNode3); new ConnectionImpl( workItemNode2, Node.CONNECTION_DEFAULT_TYPE, workItemNode3, Node.CONNECTION_DEFAULT_TYPE); EndNode end = new EndNode(); end.setId(6); end.setName("End"); process.addNode(end); new ConnectionImpl( workItemNode3, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE); PackageBuilder packageBuilder = new PackageBuilder(); ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder); processBuilder.buildProcess(process, null); List<KnowledgePackage> list = new ArrayList<KnowledgePackage>(); list.add(new KnowledgePackageImp(packageBuilder.getPackage())); return list; }
@Test public void testLocalVariableMVELConsequence() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream("test_LocalVariableMVELConsequence.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); final WorkingMemory workingMemory = ruleBase.newStatefulSession(); final List list = new ArrayList(); workingMemory.setGlobal("results", list); workingMemory.insert(new Person("bob", "stilton")); workingMemory.insert(new Person("mark", "brie")); try { workingMemory.fireAllRules(); assertEquals("should have fired twice", 2, list.size()); } catch (Exception e) { e.printStackTrace(); fail("Should not raise any exception"); } }
@Test public void testLogicalInsertionsNotPingPong() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream("test_LogicalInsertionsNotPingPong.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); final WorkingMemory workingMemory = ruleBase.newStatefulSession(); // workingMemory.addEventListener(new DebugAgendaEventListener()); // workingMemory.addEventListener(new // DebugWorkingMemoryEventListener()); final List list = new ArrayList(); final Person person = new Person("person"); final Cheese cheese = new Cheese("cheese", 0); workingMemory.setGlobal("cheese", cheese); workingMemory.setGlobal("person", person); workingMemory.setGlobal("list", list); workingMemory.fireAllRules(); // not sure about desired state of working memory. assertEquals("Rules have not fired (looped) expected number of times", 10, list.size()); }
/** * Compiles the given xml stream into a rulebase * * @param xmlReader * @return * @throws Exception */ public static RuleBase compileXml(Reader xmlReader) throws Exception { PackageBuilder builder = new PackageBuilder(); builder.addPackageFromXml(xmlReader); org.drools.rule.Package pkg = builder.getPackage(); RuleBase ruleBase = RuleBaseFactory.newRuleBase(); ruleBase.addPackage(pkg); return ruleBase; }
private Package compileRule(String drl) throws Exception { PackageBuilder builder = new PackageBuilder(new PackageBuilderConfiguration()); builder.addPackageFromDrl(new StringReader(drl)); Package pkg = builder.getPackage(); if (!pkg.isValid()) { throw new DroolsParserException(pkg.getErrorSummary()); } return pkg; }
public void testRemoveIdentitiesSubNetwork() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream("test_removeIdentitiesSubNetwork.drl"))); final Package pkg = builder.getPackage(); final RuleBaseConfiguration config = new RuleBaseConfiguration(); config.setRemoveIdentities(true); RuleBase ruleBase = getRuleBase(config); ruleBase.addPackage(pkg); ruleBase = serializeRuleBase(ruleBase); StatefulSession workingMemory = ruleBase.newStatefulSession(); List list = new ArrayList(); workingMemory.setGlobal("results", list); final Person bob = new Person("bob", "stilton"); workingMemory.insert(bob); final Person mark = new Person("mark", "stilton"); workingMemory.insert(mark); final Cheese stilton1 = new Cheese("stilton", 6); FactHandle stilton1Handle = workingMemory.insert(stilton1); final Cheese stilton2 = new Cheese("stilton", 7); FactHandle stilton2Handle = workingMemory.insert(stilton2); ruleBase = serializeRuleBase(ruleBase); workingMemory = serializeWorkingMemory(ruleBase, workingMemory); list = (List) workingMemory.getGlobal("results"); stilton1Handle = updateHandle(workingMemory, stilton1Handle); stilton2Handle = updateHandle(workingMemory, stilton2Handle); workingMemory.fireAllRules(); assertEquals(0, list.size()); workingMemory.retract(stilton1Handle); workingMemory.fireAllRules(); assertEquals(1, list.size()); assertEquals(mark, list.get(0)); workingMemory.retract(stilton2Handle); workingMemory.fireAllRules(); assertEquals(2, list.size()); assertEquals(bob, list.get(1)); }
@Test public void testLogicalInsertions3() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("test_logicalInsertions3.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); StatefulSession workingMemory = ruleBase.newStatefulSession(); final List list = new ArrayList(); workingMemory.setGlobal("events", list); // asserting the sensor object final Sensor sensor = new Sensor(150, 100); FactHandle sensorHandle = workingMemory.insert(sensor); workingMemory.fireAllRules(); workingMemory = getSerialisedStatefulSession(workingMemory); // alarm must sound assertEquals(2, list.size()); assertEquals(2, IteratorToList.convert(workingMemory.iterateObjects()).size()); // modifying sensor sensor.setTemperature(125); sensorHandle = getFactHandle(sensorHandle, workingMemory); workingMemory.update(sensorHandle, sensor); workingMemory = getSerialisedStatefulSession(workingMemory); workingMemory.fireAllRules(); workingMemory = getSerialisedStatefulSession(workingMemory); // alarm must continue to sound assertEquals(3, list.size()); assertEquals(2, IteratorToList.convert(workingMemory.iterateObjects()).size()); // modifying sensor sensor.setTemperature(80); sensorHandle = getFactHandle(sensorHandle, workingMemory); workingMemory.update(sensorHandle, sensor); workingMemory = getSerialisedStatefulSession(workingMemory); workingMemory.fireAllRules(); // no alarms anymore assertEquals(3, list.size()); assertEquals(1, IteratorToList.convert(workingMemory.iterateObjects()).size()); }
public StatelessSession getStatelessSession(InputStream stream) throws Exception { // read in the source Reader source = new InputStreamReader(stream); PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl(source); Package pkg = builder.getPackage(); RuleBase ruleBase = RuleBaseFactory.newRuleBase(); ruleBase.addPackage(pkg); return ruleBase.newStatelessSession(); }
@Test public void testLogicalInsertions2() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("test_LogicalInsertions2.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); StatefulSession workingMemory = ruleBase.newStatefulSession(); // final WorkingMemoryFileLogger logger = new WorkingMemoryFileLogger( workingMemory ); // logger.setFileName( "logical" ); final List events = new ArrayList(); workingMemory.setGlobal("events", events); final Sensor sensor = new Sensor(80, 80); FactHandle handle = workingMemory.insert(sensor); // everything should be normal workingMemory = getSerialisedStatefulSession(workingMemory); workingMemory.fireAllRules(); final List list = IteratorToList.convert(workingMemory.iterateObjects()); assertEquals("Only sensor is there", 1, list.size()); assertEquals("Only one event", 1, events.size()); // problems should be detected sensor.setPressure(200); sensor.setTemperature(200); handle = getFactHandle(handle, workingMemory); workingMemory.update(handle, sensor); workingMemory = getSerialisedStatefulSession(workingMemory); workingMemory.fireAllRules(); // logger.writeToDisk(); assertEquals("Only sensor is there", 1, list.size()); assertEquals("Exactly seven events", 7, events.size()); }
@Test public void testLogicalInsertionsNot() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("test_LogicalInsertionsNot.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); StatefulSession workingMemory = ruleBase.newStatefulSession(); List list; final Person a = new Person("a"); final Cheese cheese = new Cheese("brie", 1); workingMemory.setGlobal("cheese", cheese); workingMemory.fireAllRules(); workingMemory = getSerialisedStatefulSession(workingMemory); list = IteratorToList.convert(workingMemory.iterateObjects()); assertEquals("i was not asserted by not a => i.", 1, list.size()); assertEquals("i was not asserted by not a => i.", cheese, list.get(0)); FactHandle h = workingMemory.insert(a); workingMemory = getSerialisedStatefulSession(workingMemory); // no need to fire rules, assertion alone removes justification for i, // so it should be retracted. // workingMemory.fireAllRules(); list = IteratorToList.convert(workingMemory.iterateObjects()); assertEquals("a was not asserted or i not retracted.", 1, list.size()); assertEquals("a was asserted.", a, list.get(0)); assertFalse("i was not rectracted.", list.contains(cheese)); // no rules should fire, but nevertheless... // workingMemory.fireAllRules(); assertEquals("agenda should be empty.", 0, workingMemory.getAgenda().agendaSize()); h = getFactHandle(h, workingMemory); workingMemory.retract(h); workingMemory = getSerialisedStatefulSession(workingMemory); workingMemory.fireAllRules(); workingMemory = getSerialisedStatefulSession(workingMemory); list = IteratorToList.convert(workingMemory.iterateObjects()); assertEquals("i was not asserted by not a => i.", 1, list.size()); assertEquals("i was not asserted by not a => i.", cheese, list.get(0)); }
@Test public void testLogicalInsertionsWithModify() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream("test_LogicalInsertionsWithUpdate.drl"))); if (builder.hasErrors()) { fail(builder.getErrors().toString()); } final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); StatefulSession workingMemory = ruleBase.newStatefulSession(); List l; final Person p = new Person("person"); p.setAge(2); FactHandle h = workingMemory.insert(p); assertEquals(1, IteratorToList.convert(workingMemory.iterateObjects()).size()); workingMemory.fireAllRules(); workingMemory = getSerialisedStatefulSession(workingMemory); assertEquals(2, IteratorToList.convert(workingMemory.iterateObjects()).size()); l = IteratorToList.convert( workingMemory.iterateObjects(new ClassObjectFilter(CheeseEqual.class))); assertEquals(1, l.size()); assertEquals(2, ((CheeseEqual) l.get(0)).getPrice()); h = getFactHandle(h, workingMemory); workingMemory.retract(h); workingMemory = getSerialisedStatefulSession(workingMemory); assertEquals(0, IteratorToList.convert(workingMemory.iterateObjects()).size()); TruthMaintenanceSystem tms = ((InternalWorkingMemory) workingMemory).getTruthMaintenanceSystem(); final java.lang.reflect.Field field = tms.getClass().getDeclaredField("assertMap"); field.setAccessible(true); final ObjectHashMap m = (ObjectHashMap) field.get(tms); field.setAccessible(false); assertEquals("assertMap should be empty", 0, m.size()); }
/** * @return * @throws Exception * @throws Exception */ public static RuleBase readRule(final Reader source) throws Exception { // Use package builder to build up a rule package. // An alternative lower level class called "DrlParser" can also be used... final PackageBuilder builder = new PackageBuilder(); // this wil parse and compile in one step // NOTE: There are 2 methods here, the one argument one is for normal DRL. builder.addPackageFromDrl(source); // get the compiled package (which is serializable) final org.drools.rule.Package pkg = builder.getPackage(); // add the package to a rulebase (deploy the rule package). final RuleBase ruleBase = RuleBaseFactory.newRuleBase(); ruleBase.addPackage(pkg); return ruleBase; }
private StatelessSession getSession() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("literal_rule_test.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); StatelessSession session = ruleBase.newStatelessSession(); session = SerializationHelper.serializeObject(session); session.setGlobalResolver(this.globalResolver); session.setGlobal("list", this.list); session.setGlobal("cheesery", this.cheesery); return session; }
public AgendaGroupDelegate() { final Reader drl = new InputStreamReader( AgendaGroupDelegate.class.getResourceAsStream( "/org/drools/examples/conway/conway-agendagroup.drl")); try { PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl(drl); RuleBase ruleBase = RuleBaseFactory.newRuleBase(); ruleBase.addPackage(builder.getPackage()); this.session = ruleBase.newStatefulSession(); } catch (Exception e) { throw new RuntimeException(e); } }
@SuppressWarnings("unused") private List<KnowledgePackage> getProcessTimer2() { final RuleFlowProcess process = new RuleFlowProcess(); process.setId("org.drools.test.TestProcess"); process.setName("TestProcess"); process.setPackageName("org.drools.test"); final StartNode start = new StartNode(); start.setId(1); start.setName("Start"); process.addNode(start); final TimerNode timerNode = new TimerNode(); timerNode.setId(2); timerNode.setName("Timer"); final Timer timer = new Timer(); timer.setDelay("0"); timerNode.setTimer(timer); process.addNode(timerNode); new ConnectionImpl( start, Node.CONNECTION_DEFAULT_TYPE, timerNode, Node.CONNECTION_DEFAULT_TYPE); final ActionNode actionNode = new ActionNode(); actionNode.setId(3); actionNode.setName("Action"); final DroolsConsequenceAction action = new DroolsConsequenceAction(); action.setDialect("java"); action.setConsequence( "try { Thread.sleep(1000); } catch (Throwable t) {} System.out.println(\"Executed action\");"); actionNode.setAction(action); process.addNode(actionNode); new ConnectionImpl( timerNode, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE); final EndNode end = new EndNode(); end.setId(6); end.setName("End"); process.addNode(end); new ConnectionImpl(actionNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE); final PackageBuilder packageBuilder = new PackageBuilder(); final ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder); processBuilder.buildProcess(process, null); final List<KnowledgePackage> list = new ArrayList<KnowledgePackage>(); list.add(new KnowledgePackageImp(packageBuilder.getPackage())); return list; }
public void testNotWithBindings() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("not_with_bindings_rule_test.drl"))); final Package pkg = builder.getPackage(); final Rule rule = pkg.getRules()[0]; assertTrue(rule.isValid()); assertEquals(0, builder.getErrors().getErrors().length); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = serializeRuleBase(ruleBase); StatefulSession workingMemory = ruleBase.newStatefulSession(); List list = new ArrayList(); workingMemory.setGlobal("list", list); final Cheese stilton = new Cheese("stilton", 5); FactHandle stiltonHandle = workingMemory.insert(stilton); final Cheese cheddar = new Cheese("cheddar", 7); FactHandle cheddarHandle = workingMemory.insert(cheddar); final PersonInterface paul = new Person("paul", "stilton", 12); workingMemory.insert(paul); ruleBase = serializeRuleBase(ruleBase); workingMemory = serializeWorkingMemory(ruleBase, workingMemory); list = (List) workingMemory.getGlobal("list"); stiltonHandle = updateHandle(workingMemory, stiltonHandle); cheddarHandle = updateHandle(workingMemory, cheddarHandle); workingMemory.fireAllRules(); assertEquals(0, list.size()); workingMemory.retract(stiltonHandle); workingMemory.fireAllRules(); assertEquals(1, list.size()); }
@Test public void testMVELUsingGlobalsInDebugMode() throws Exception { MVELDebugHandler.setDebugMode(true); try { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("test_MVELGlobalDebug.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); final StatefulSession session = ruleBase.newStatefulSession(); session.dispose(); MVELDebugHandler.setDebugMode(false); } catch (Exception e) { MVELDebugHandler.setDebugMode(false); e.printStackTrace(); fail("Should not raise exceptions"); } }
private RuleBase loadRuleBase(final Reader reader) throws IOException, DroolsParserException, Exception { final DrlParser parser = new DrlParser(); final PackageDescr packageDescr = parser.parse(reader); if (parser.hasErrors()) { System.out.println(parser.getErrors()); Assert.fail( "Error messages in parser, need to sort this our (or else collect error messages)"); } // pre build the package final PackageBuilder builder = new PackageBuilder(); builder.addPackage(packageDescr); final Package pkg = builder.getPackage(); // add the package to a rulebase final RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); // load up the rulebase return serializeRuleBase(ruleBase); }
@Test @Ignore public void testAgendaLoop() throws Exception { final PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader(getClass().getResourceAsStream("test_OutOfMemory.drl"))); final Package pkg = builder.getPackage(); RuleBase ruleBase = getRuleBase(); ruleBase.addPackage(pkg); ruleBase = SerializationHelper.serializeObject(ruleBase); final WorkingMemory workingMemory = ruleBase.newStatefulSession(); workingMemory.insert(new Cheese("stilton", 1)); workingMemory.fireAllRules(3000000); // just for profiling // Thread.currentThread().wait(); }
private List<KnowledgePackage> getProcessTimer() { RuleFlowProcess process = new RuleFlowProcess(); process.setId("org.drools.test.TestProcess"); process.setName("TestProcess"); process.setPackageName("org.drools.test"); StartNode start = new StartNode(); start.setId(1); start.setName("Start"); process.addNode(start); TimerNode timerNode = new TimerNode(); timerNode.setId(2); timerNode.setName("Timer"); Timer timer = new Timer(); timer.setDelay("2000"); timerNode.setTimer(timer); process.addNode(timerNode); new ConnectionImpl( start, Node.CONNECTION_DEFAULT_TYPE, timerNode, Node.CONNECTION_DEFAULT_TYPE); ActionNode actionNode = new ActionNode(); actionNode.setId(3); actionNode.setName("Action"); DroolsConsequenceAction action = new DroolsConsequenceAction(); action.setDialect("java"); action.setConsequence("System.out.println(\"Executed action\");"); actionNode.setAction(action); process.addNode(actionNode); new ConnectionImpl( timerNode, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE); EndNode end = new EndNode(); end.setId(6); end.setName("End"); process.addNode(end); new ConnectionImpl(actionNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE); PackageBuilder packageBuilder = new PackageBuilder(); ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder); processBuilder.buildProcess(process, null); List<KnowledgePackage> list = new ArrayList<KnowledgePackage>(); list.add(new KnowledgePackageImp(packageBuilder.getPackage())); return list; }
/** * Compiles the given rule strings into a single rulebase * * @param rules * @return * @throws Exception */ public static RuleBase compile(List<String> rules) throws Exception { Properties properties = new Properties(); properties.setProperty("drools.dialect.java.compiler", "JANINO"); properties.setProperty("drools.dialect.default", "java"); properties.setProperty("drools.dialect.java.compiler.lnglevel", "1.5"); // properties.setProperty("drools.dump.dir", "/tmp"); // log.debug("drools.dump.dir value is set to " + dumpDir); PackageBuilderConfiguration conf = new PackageBuilderConfiguration(properties); PackageBuilder builder = new PackageBuilder(conf); RuleBase ruleBase = RuleBaseFactory.newRuleBase(); for (String rule : rules) { StringReader drl = new StringReader(rule); builder.addPackageFromDrl(drl); PackageBuilderErrors errors = builder.getErrors(); for (DroolsError error : errors.getErrors()) { log.warn(error); } } ruleBase.addPackage(builder.getPackage()); return ruleBase; }
private Package getProcessSubProcess() { RuleFlowProcess process = new RuleFlowProcess(); process.setId("org.drools.test.TestProcess"); process.setName("TestProcess"); process.setPackageName("org.drools.test"); StartNode start = new StartNode(); start.setId(1); start.setName("Start"); process.addNode(start); ActionNode actionNode = new ActionNode(); actionNode.setId(2); actionNode.setName("Action"); DroolsConsequenceAction action = new DroolsConsequenceAction(); action.setDialect("java"); action.setConsequence("System.out.println(\"Executed action\");"); actionNode.setAction(action); process.addNode(actionNode); new ConnectionImpl( start, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE); SubProcessNode subProcessNode = new SubProcessNode(); subProcessNode.setId(3); subProcessNode.setName("SubProcess"); subProcessNode.setProcessId("org.drools.test.SubProcess"); process.addNode(subProcessNode); new ConnectionImpl( actionNode, Node.CONNECTION_DEFAULT_TYPE, subProcessNode, Node.CONNECTION_DEFAULT_TYPE); EndNode end = new EndNode(); end.setId(4); end.setName("End"); process.addNode(end); new ConnectionImpl( subProcessNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE); PackageBuilder packageBuilder = new PackageBuilder(); ProcessBuilderImpl processBuilder = new ProcessBuilderImpl(packageBuilder); processBuilder.buildProcess(process, null); process = new RuleFlowProcess(); process.setId("org.drools.test.SubProcess"); process.setName("SubProcess"); process.setPackageName("org.drools.test"); start = new StartNode(); start.setId(1); start.setName("Start"); process.addNode(start); actionNode = new ActionNode(); actionNode.setId(2); actionNode.setName("Action"); action = new DroolsConsequenceAction(); action.setDialect("java"); action.setConsequence("System.out.println(\"Executed action\");"); actionNode.setAction(action); process.addNode(actionNode); new ConnectionImpl( start, Node.CONNECTION_DEFAULT_TYPE, actionNode, Node.CONNECTION_DEFAULT_TYPE); WorkItemNode workItemNode = new WorkItemNode(); workItemNode.setId(3); workItemNode.setName("WorkItem1"); Work work = new WorkImpl(); work.setName("MyWork"); workItemNode.setWork(work); process.addNode(workItemNode); new ConnectionImpl( actionNode, Node.CONNECTION_DEFAULT_TYPE, workItemNode, Node.CONNECTION_DEFAULT_TYPE); end = new EndNode(); end.setId(6); end.setName("End"); process.addNode(end); new ConnectionImpl( workItemNode, Node.CONNECTION_DEFAULT_TYPE, end, Node.CONNECTION_DEFAULT_TYPE); processBuilder.buildProcess(process, null); return packageBuilder.getPackage(); }