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
@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.");
}
}
@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());
}
@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");
}
}
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);
}
}
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;
}
@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());
}
@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 DRL into a rulebase
*
* @param drlReader
* @return
* @throws Exception
*/
public static RuleBase compileDrl(Reader drlReader) throws Exception {
PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(drlReader);
org.drools.rule.Package pkg = builder.getPackage();
RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage(pkg);
return ruleBase;
}
@Test
public void testDuplicateLocalVariableMVELConsequence() throws Exception {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(
new InputStreamReader(
getClass().getResourceAsStream("test_DuplicateLocalVariableMVELConsequence.drl")));
assertTrue(builder.hasErrors());
}
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 testPackageWithRuleflow() throws Exception {
RulesRepository repo = getRepo();
PackageItem pkg = repo.createPackage("testPackageWithRuleFlow", "");
AssetItem model = pkg.addAsset("model", "qed");
model.updateFormat(AssetFormats.MODEL);
model.updateBinaryContentAttachment(this.getClass().getResourceAsStream("/billasurf.jar"));
model.checkin("");
ServiceImplementation.updateDroolsHeader(
"import com.billasurf.Board\n global com.billasurf.Person customer", pkg);
AssetItem rule1 = pkg.addAsset("rule_1", "");
rule1.updateFormat(AssetFormats.DRL);
rule1.updateContent("rule 'rule1' \n when Board() \n then customer.setAge(42); \n end");
rule1.checkin("");
AssetItem ruleFlow = pkg.addAsset("ruleFlow", "");
ruleFlow.updateFormat(AssetFormats.RULE_FLOW_RF);
ruleFlow.updateBinaryContentAttachment(this.getClass().getResourceAsStream("/ruleflow.rfm"));
ruleFlow.checkin("");
ContentPackageAssembler asm = new ContentPackageAssembler(pkg);
assertFalse(asm.hasErrors());
Map flows = asm.getBinaryPackage().getRuleFlows();
assertNotNull(flows);
assertEquals(1, flows.size());
Object flow = flows.values().iterator().next();
assertNotNull(flow);
assertTrue(flow instanceof RuleFlowProcess);
// now check we can do some MVEL stuff from the classloader...
List<JarInputStream> jars = BRMSPackageBuilder.getJars(pkg);
PackageBuilder builder = BRMSPackageBuilder.getInstance(jars);
ClassLoader newCL = builder.getPackageBuilderConfiguration().getClassLoader();
ClassLoader oldCL = Thread.currentThread().getContextClassLoader();
// set the CL for the current thread so MVEL can find it
Thread.currentThread().setContextClassLoader(newCL);
Object o = MVEL.eval("new com.billasurf.Board()");
assertEquals("com.billasurf.Board", o.getClass().getName());
System.err.println(o.toString());
Thread.currentThread().setContextClassLoader(oldCL);
builder.addPackageFromDrl(new StringReader("package foo\n import com.billasurf.Board"));
Object o2 = builder.getPackageRegistry("foo").getTypeResolver().resolveType("Board");
assertNotNull(o2);
assertEquals("com.billasurf.Board", ((Class) o2).getName());
}
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 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 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 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);
}
}
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");
}
}
@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();
}
/**
* 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;
}
public void execute() throws MojoExecutionException {
// find all the rules items and load them into a package
try {
// Need to load the build classpath
@SuppressWarnings("unchecked")
List<Dependency> dependencies = project.getDependencies();
List<URL> url = new ArrayList<URL>();
url.add(outputDirectory.toURI().toURL());
for (Dependency d : dependencies) {
String scope = d.getScope();
if (!Artifact.SCOPE_TEST.equals(scope)) {
Artifact artifact =
getArtifact(
d.getGroupId(),
d.getArtifactId(),
d.getVersion(),
d.getType(),
d.getClassifier());
url.add(artifact.getFile().toURI().toURL());
}
}
URL[] classpath = url.toArray(new URL[url.size()]);
URLClassLoader uc =
new URLClassLoader(classpath, this.getClass().getClassLoader()) {
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
getLog().debug("Loading Class for compile [" + name + "]");
Class<?> c = super.loadClass(name);
getLog().debug("Loading Class for compile [" + name + "] found [" + c + "]");
return c;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
getLog().debug("Finding Class for compile [" + name + "]");
Class<?> c = super.findClass(name);
getLog().debug("Finding Class for compile [" + name + "] found [" + c + "]");
return c;
}
};
URLClassLoader uc2 =
new URLClassLoader(classpath, this.getClass().getClassLoader()) {
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
getLog().debug("Loading Class for runtime [" + name + "]");
Class<?> c = super.loadClass(name);
getLog().debug("Loading Class for runtime [" + name + "] found [" + c + "]");
return c;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
getLog().debug("Finding Class for runtime [" + name + "]");
Class<?> c = super.findClass(name);
getLog().debug("Finding Class for runtime [" + name + "] found [" + c + "]");
return c;
}
};
getLog().info("Package Class loader is using classpath " + Arrays.toString(uc.getURLs()));
listClassloader(" ", uc);
PackageBuilderConfiguration packageBuilderConfiguration = new PackageBuilderConfiguration(uc);
PackageBuilder pb = new PackageBuilder(packageBuilderConfiguration);
DirectoryScanner ds = new DirectoryScanner();
ds.setIncludes(includes);
ds.setExcludes(excludes);
ds.setBasedir(rulesdir);
ds.setCaseSensitive(true);
ds.scan();
String[] files = ds.getIncludedFiles();
for (String file : files) {
File f = new File(rulesdir, file);
Reader reader = new FileReader(f);
try {
if (file.endsWith(".drl")) {
getLog().info("Adding Rules " + f);
pb.addPackageFromDrl(reader);
} else if (file.endsWith(".xml")) {
getLog().info("Adding Package definition " + f);
pb.addPackageFromXml(reader);
} else if (file.endsWith(".rf")) {
getLog().info("Adding Rule Flow " + f);
pb.addRuleFlow(reader);
} else {
getLog().info("Ignored Resource " + f);
}
} finally {
reader.close();
}
}
pb.compileAll();
PackageBuilderErrors errors = pb.getErrors();
if (errors.size() > 0) {
for (KnowledgeBuilderError kberr : errors) {
getLog().error(kberr.toString());
}
throw new MojoExecutionException("Package is not valid");
}
org.drools.rule.Package p = pb.getPackage();
if (!p.isValid()) {
getLog().error("Package is not valid ");
throw new MojoExecutionException("Package is not valid");
}
File outputFile = getOutputFile();
getLog().info("Saving compiled package to " + outputFile.getPath());
outputFile.getParentFile().mkdirs();
FileOutputStream fout = new FileOutputStream(outputFile);
DroolsStreamUtils.streamOut(fout, p);
fout.close();
getLog().info("Testing Compiled package " + outputFile.getPath());
File inputFile = getOutputFile();
FileInputStream fin = new FileInputStream(inputFile);
RuleBaseConfiguration config = new RuleBaseConfiguration(uc2);
RuleBase ruleBase = RuleBaseFactory.newRuleBase(config);
Object o = DroolsStreamUtils.streamIn(fin, uc);
ruleBase.addPackage((Package) o);
KnowledgeBase kb = new KnowledgeBaseImpl(ruleBase);
@SuppressWarnings("unused")
StatelessKnowledgeSession session = kb.newStatelessKnowledgeSession();
getLog().info("Testing passed ");
} catch (Exception e) {
getLog().error(e);
throw new MojoExecutionException(e.getMessage());
}
}
@Test
public void testLogicalInsertionsWithExists() throws Exception {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl(
new InputStreamReader(
getClass().getResourceAsStream("test_LogicalInsertionWithExists.drl")));
final Package pkg = builder.getPackage();
RuleBase ruleBase = getRuleBase();
ruleBase.addPackage(pkg);
ruleBase = SerializationHelper.serializeObject(ruleBase);
StatefulSession workingMemory = ruleBase.newStatefulSession();
final Person p1 = new Person("p1", "stilton", 20);
p1.setStatus("europe");
FactHandle c1FactHandle = workingMemory.insert(p1);
final Person p2 = new Person("p2", "stilton", 30);
p2.setStatus("europe");
FactHandle c2FactHandle = workingMemory.insert(p2);
final Person p3 = new Person("p3", "stilton", 40);
p3.setStatus("europe");
FactHandle c3FactHandle = workingMemory.insert(p3);
workingMemory.fireAllRules();
workingMemory = getSerialisedStatefulSession(workingMemory);
// all 3 in europe, so, 2 cheese
List cheeseList =
IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(Cheese.class)));
assertEquals(2, cheeseList.size());
// europe=[ 1, 2 ], america=[ 3 ]
p3.setStatus("america");
c3FactHandle = getFactHandle(c3FactHandle, workingMemory);
workingMemory.update(c3FactHandle, p3);
workingMemory = getSerialisedStatefulSession(workingMemory);
workingMemory.fireAllRules();
workingMemory = getSerialisedStatefulSession(workingMemory);
cheeseList =
IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(Cheese.class)));
assertEquals(1, cheeseList.size());
// europe=[ 1 ], america=[ 2, 3 ]
p2.setStatus("america");
c2FactHandle = getFactHandle(c2FactHandle, workingMemory);
workingMemory.update(c2FactHandle, p2);
workingMemory = getSerialisedStatefulSession(workingMemory);
workingMemory.fireAllRules();
workingMemory = getSerialisedStatefulSession(workingMemory);
cheeseList =
IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(Cheese.class)));
assertEquals(1, cheeseList.size());
// europe=[ ], america=[ 1, 2, 3 ]
p1.setStatus("america");
c1FactHandle = getFactHandle(c1FactHandle, workingMemory);
workingMemory.update(c1FactHandle, p1);
workingMemory = getSerialisedStatefulSession(workingMemory);
workingMemory.fireAllRules();
workingMemory = getSerialisedStatefulSession(workingMemory);
cheeseList =
IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(Cheese.class)));
assertEquals(2, cheeseList.size());
// europe=[ 2 ], america=[ 1, 3 ]
p2.setStatus("europe");
c2FactHandle = getFactHandle(c2FactHandle, workingMemory);
workingMemory.update(c2FactHandle, p2);
workingMemory = getSerialisedStatefulSession(workingMemory);
workingMemory.fireAllRules();
workingMemory = getSerialisedStatefulSession(workingMemory);
cheeseList =
IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(Cheese.class)));
assertEquals(1, cheeseList.size());
// europe=[ 1, 2 ], america=[ 3 ]
p1.setStatus("europe");
c1FactHandle = getFactHandle(c1FactHandle, workingMemory);
workingMemory.update(c1FactHandle, p1);
workingMemory = getSerialisedStatefulSession(workingMemory);
workingMemory.fireAllRules();
workingMemory = getSerialisedStatefulSession(workingMemory);
cheeseList =
IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(Cheese.class)));
assertEquals(1, cheeseList.size());
// europe=[ 1, 2, 3 ], america=[ ]
p3.setStatus("europe");
c3FactHandle = getFactHandle(c3FactHandle, workingMemory);
workingMemory.update(c3FactHandle, p3);
workingMemory = getSerialisedStatefulSession(workingMemory);
workingMemory.fireAllRules();
workingMemory = getSerialisedStatefulSession(workingMemory);
cheeseList =
IteratorToList.convert(workingMemory.iterateObjects(new ClassObjectFilter(Cheese.class)));
assertEquals(2, cheeseList.size());
}
public void test3() throws Exception {
String process1 =
"<?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"
+ " <imports>\n"
+ " <import name=\"org.jbpm.Person\" />\n"
+ " </imports>\n"
+ " <swimlanes>\n"
+ " <swimlane name=\"swimlane\" />\n"
+ " </swimlanes>\n"
+ " </header>\n"
+ "\n"
+ " <nodes>\n"
+ " <start id=\"1\" name=\"Start\" />\n"
+ " <end id=\"4\" name=\"End\" />\n"
+ " <split id=\"5\" name=\"AND\" type=\"1\" />\n"
+ " <subProcess id=\"6\" name=\"SubProcess\" processId=\"com.sample.subflow\" />\n"
+ " <actionNode id=\"7\" name=\"Action\" >\n"
+ " <action type=\"expression\" dialect=\"mvel\" >System.out.println(\"Executing action 1\");</action>\n"
+ " </actionNode>\n"
+ " <join id=\"8\" name=\"AND\" type=\"1\" />\n"
+ " <actionNode id=\"9\" name=\"Action\" >\n"
+ " <action type=\"expression\" dialect=\"mvel\" >System.out.println(\"Executing action 2\");</action>\n"
+ " </actionNode>\n"
+ " <ruleSet id=\"10\" name=\"RuleSet\" ruleFlowGroup=\"flowgroup\" />\n"
+ " <milestone id=\"11\" name=\"Event Wait\" >\n"
+ " <constraint type=\"rule\" dialect=\"mvel\" >Person( )</constraint>\n"
+ " </milestone>\n"
+ " <workItem id=\"12\" name=\"Log\" >\n"
+ " <work name=\"Log\" >\n"
+ " <parameter name=\"Message\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " <value>This is a log message</value>\n"
+ " </parameter>\n"
+ " </work>\n"
+ " </workItem>\n"
+ " <composite id=\"13\" name=\"CompositeNode\" >\n"
+ " <variables>\n"
+ " <variable name=\"x\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " <value>x-value</value>\n"
+ " </variable>\n"
+ " </variables>\n"
+ " <nodes>\n"
+ " <humanTask id=\"1\" name=\"Human Task\" swimlane=\"swimlane\" >\n"
+ " <work name=\"Human Task\" >\n"
+ " <parameter name=\"ActorId\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " <value>John Doe</value>\n"
+ " </parameter>\n"
+ " <parameter name=\"Priority\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " </parameter>\n"
+ " <parameter name=\"TaskName\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " <value>Do something !</value>\n"
+ " </parameter>\n"
+ " <parameter name=\"Comment\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " </parameter>\n"
+ " </work>\n"
+ " </humanTask>\n"
+ " <humanTask id=\"2\" name=\"Human Task\" swimlane=\"swimlane\" >\n"
+ " <work name=\"Human Task\" >\n"
+ " <parameter name=\"ActorId\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " </parameter>\n"
+ " <parameter name=\"Priority\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " </parameter>\n"
+ " <parameter name=\"TaskName\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " <value>Do something else !</value>\n"
+ " </parameter>\n"
+ " <parameter name=\"Comment\" >\n"
+ " <type name=\"org.drools.process.core.datatype.impl.type.StringDataType\" />\n"
+ " </parameter>\n"
+ " </work>\n"
+ " <mapping type=\"in\" from=\"x\" to=\"Priority\" />\n"
+ " </humanTask>\n"
+ " </nodes>\n"
+ " <connections>\n"
+ " <connection from=\"1\" to=\"2\" />\n"
+ " </connections>\n"
+ " <in-ports>\n"
+ " <in-port type=\"DROOLS_DEFAULT\" nodeId=\"1\" nodeInType=\"DROOLS_DEFAULT\" />\n"
+ " </in-ports>\n"
+ " <out-ports>\n"
+ " <out-port type=\"DROOLS_DEFAULT\" nodeId=\"2\" nodeOutType=\"DROOLS_DEFAULT\" />\n"
+ " </out-ports>\n"
+ " </composite>\n"
+ " </nodes>\n"
+ "\n"
+ " <connections>\n"
+ " <connection from=\"9\" to=\"4\" />\n"
+ " <connection from=\"1\" to=\"5\" />\n"
+ " <connection from=\"5\" to=\"6\" />\n"
+ " <connection from=\"5\" to=\"7\" />\n"
+ " <connection from=\"7\" to=\"8\" />\n"
+ " <connection from=\"6\" to=\"8\" />\n"
+ " <connection from=\"10\" to=\"8\" />\n"
+ " <connection from=\"11\" to=\"8\" />\n"
+ " <connection from=\"12\" to=\"8\" />\n"
+ " <connection from=\"13\" to=\"8\" />\n"
+ " <connection from=\"8\" to=\"9\" />\n"
+ " <connection from=\"5\" to=\"10\" />\n"
+ " <connection from=\"5\" to=\"11\" />\n"
+ " <connection from=\"5\" to=\"12\" />\n"
+ " <connection from=\"5\" to=\"13\" />\n"
+ " </connections>\n"
+ "\n"
+ "</process>\n";
final PackageBuilder builder = new PackageBuilder();
builder.addProcessFromXml(new StringReader(process1));
String process2 =
"<?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=\"flow\" id=\"com.sample.subflow\" package-name=\"com.sample\" >\n"
+ "\n"
+ " <header>\n"
+ " <imports>\n"
+ " <import name=\"org.jbpm.Person\" />\n"
+ " </imports>\n"
+ " </header>\n"
+ "\n"
+ " <nodes>\n"
+ " <start id=\"1\" name=\"Start\" />\n"
+ " <milestone id=\"2\" name=\"Event Wait\" >\n"
+ " <constraint type=\"rule\" dialect=\"mvel\" >Person( )</constraint>\n"
+ " </milestone>\n"
+ " <end id=\"3\" name=\"End\" />\n"
+ " </nodes>\n"
+ "\n"
+ " <connections>\n"
+ " <connection from=\"1\" to=\"2\" />\n"
+ " <connection from=\"2\" to=\"3\" />\n"
+ " </connections>\n"
+ "\n"
+ "</process>\n";
builder.addProcessFromXml(new StringReader(process2));
String rule =
"package com.sample\n"
+ "import org.jbpm.Person;\n"
+ "rule \"Hello\" ruleflow-group \"flowgroup\"\n"
+ " when\n"
+ " then\n"
+ " System.out.println( \"Hello\" );\n"
+ "end";
builder.addPackageFromDrl(new StringReader(rule));
final Package pkg = builder.getPackage();
final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage(pkg);
StatefulSession session = ruleBase.newStatefulSession();
TestWorkItemHandler handler1 = new TestWorkItemHandler();
session.getWorkItemManager().registerWorkItemHandler("Log", handler1);
TestWorkItemHandler handler2 = new TestWorkItemHandler();
session.getWorkItemManager().registerWorkItemHandler("Human Task", handler2);
session.startProcess("com.sample.ruleflow");
assertEquals(2, session.getProcessInstances().size());
assertTrue(handler1.getWorkItem() != null);
long workItemId = handler2.getWorkItem().getId();
assertTrue(workItemId != -1);
session = getSerialisedStatefulSession(session);
session.getWorkItemManager().registerWorkItemHandler("Human Task", handler2);
assertEquals(2, session.getProcessInstances().size());
handler2.reset();
session.getWorkItemManager().completeWorkItem(workItemId, null);
assertTrue(handler2.getWorkItem() != null);
assertEquals("John Doe", handler2.getWorkItem().getParameter("ActorId"));
assertEquals("x-value", handler2.getWorkItem().getParameter("Priority"));
session.getWorkItemManager().completeWorkItem(handler1.getWorkItem().getId(), null);
session.getWorkItemManager().completeWorkItem(handler2.getWorkItem().getId(), null);
session.insert(new Person());
session.fireAllRules();
assertEquals(0, session.getProcessInstances().size());
}
