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();
}
