@Test
public void testLiaNodeInitialisation() {
setUp(JOIN_NODE);
// Initialise from lian
KieBaseConfiguration kconf = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
kconf.setOption(RuleEngineOption.PHREAK);
AbstractWorkingMemory wm =
new AbstractWorkingMemory(
1, (ReteooRuleBase) RuleBaseFactory.newRuleBase((RuleBaseConfiguration) kconf));
SegmentUtilities.createSegmentMemory(liaNode, wm);
liaNode.assertObject((InternalFactHandle) wm.insert("str"), context, wm);
LiaNodeMemory liaMem = (LiaNodeMemory) wm.getNodeMemory(liaNode);
assertEquals(1, liaMem.getNodePosMaskBit());
assertEquals(3, liaMem.getSegmentMemory().getAllLinkedMaskTest());
BetaMemory bm1 = (BetaMemory) wm.getNodeMemory(n1);
assertEquals(2, bm1.getNodePosMaskBit());
assertEquals(3, bm1.getSegmentMemory().getAllLinkedMaskTest());
// Initialise from n1
wm =
new AbstractWorkingMemory(
1, (ReteooRuleBase) RuleBaseFactory.newRuleBase((RuleBaseConfiguration) kconf));
n1.assertObject((InternalFactHandle) wm.insert("str"), context, wm);
liaMem = (LiaNodeMemory) wm.getNodeMemory(liaNode);
assertEquals(1, liaMem.getNodePosMaskBit());
assertEquals(3, liaMem.getSegmentMemory().getAllLinkedMaskTest());
bm1 = (BetaMemory) wm.getNodeMemory(n1);
assertEquals(2, bm1.getNodePosMaskBit());
assertEquals(3, bm1.getSegmentMemory().getAllLinkedMaskTest());
}
public void closeLiveQuery(final InternalFactHandle factHandle) {
try {
startOperation();
this.ruleBase.readLock();
this.lock.lock();
final PropagationContext pCtx =
new PropagationContextImpl(
getNextPropagationIdCounter(),
PropagationContext.INSERTION,
null,
null,
factHandle,
getEntryPoint());
if (this.ruleBase.getConfiguration().isPhreakEnabled()) {
LeftInputAdapterNode lian =
(LeftInputAdapterNode)
factHandle.getFirstLeftTuple().getLeftTupleSink().getLeftTupleSource();
LiaNodeMemory lmem = (LiaNodeMemory) getNodeMemory((MemoryFactory) lian);
SegmentMemory lsmem = lmem.getSegmentMemory();
LeftTuple childLeftTuple =
factHandle.getFirstLeftTuple(); // there is only one, all other LTs are peers
LeftInputAdapterNode.doDeleteObject(
childLeftTuple, childLeftTuple.getPropagationContext(), lsmem, this, lian, false, lmem);
List<PathMemory> rmems = lmem.getSegmentMemory().getPathMemories();
for (int i = 0, length = rmems.size(); i < length; i++) {
PathMemory rm = rmems.get(i);
RuleNetworkEvaluatorActivation evaluator =
agenda.createRuleNetworkEvaluatorActivation(
Integer.MAX_VALUE, rm, (TerminalNode) rm.getNetworkNode());
evaluator.evaluateNetwork(this, 0, -1);
}
} else {
getEntryPointNode().retractQuery(factHandle, pCtx, this);
pCtx.evaluateActionQueue(this);
}
getFactHandleFactory().destroyFactHandle(factHandle);
} finally {
this.lock.unlock();
this.ruleBase.readUnlock();
endOperation();
}
}
@Test
public void testPopulatedSingleRuleNoSharing() throws Exception {
KieBaseConfiguration kconf =
(KieBaseConfiguration) KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
kconf.setOption(RuleEngineOption.PHREAK);
KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase(kconf);
InternalWorkingMemory wm = ((InternalWorkingMemory) kbase.newStatefulKnowledgeSession());
wm.insert(new A(1));
wm.insert(new B(1));
wm.insert(new C(1));
wm.insert(new C(2));
wm.insert(new D(1));
wm.insert(new E(1));
wm.fireAllRules();
kbase.addKnowledgePackages(buildKnowledgePackage("r1", " A() B() C(object == 2) D() E()\n"));
List list = new ArrayList();
wm.setGlobal("list", list);
ObjectTypeNode aotn = getObjectTypeNode(kbase, A.class);
LeftInputAdapterNode liaNode = (LeftInputAdapterNode) aotn.getSinkPropagator().getSinks()[0];
LiaNodeMemory lm = (LiaNodeMemory) wm.getNodeMemory(liaNode);
SegmentMemory sm = lm.getSegmentMemory();
assertNotNull(sm.getStagedLeftTuples().getInsertFirst());
wm.fireAllRules();
assertNull(sm.getStagedLeftTuples().getInsertFirst());
assertEquals(1, list.size());
assertEquals("r1", ((Match) list.get(0)).getRule().getName());
}
private BaseNode[] evalQuery(
String queryName,
DroolsQuery queryObject,
InternalFactHandle handle,
PropagationContext pCtx) {
BaseNode[] tnodes = (BaseNode[]) ruleBase.getReteooBuilder().getTerminalNodes(queryName);
if (this.ruleBase.getConfiguration().isPhreakEnabled()) {
if (tnodes == null) {
throw new RuntimeException("Query '" + queryName + "' does not exist");
}
QueryTerminalNode tnode = (QueryTerminalNode) tnodes[0];
LeftTupleSource lts = tnode.getLeftTupleSource();
while (lts.getType() != NodeTypeEnums.LeftInputAdapterNode) {
lts = lts.getLeftTupleSource();
}
LeftInputAdapterNode lian = (LeftInputAdapterNode) lts;
LiaNodeMemory lmem = (LiaNodeMemory) getNodeMemory((MemoryFactory) lts);
SegmentMemory lsmem = lmem.getSegmentMemory();
if (lsmem == null) {
lsmem = SegmentUtilities.createSegmentMemory(lts, this);
}
LeftInputAdapterNode.doInsertObject(
handle, pCtx, lian, this, lmem, false, queryObject.isOpen());
List<PathMemory> rmems = lmem.getSegmentMemory().getPathMemories();
for (int i = 0, length = rmems.size(); i < length; i++) {
PathMemory rm = rmems.get(i);
RuleNetworkEvaluatorActivation evaluator =
agenda.createRuleNetworkEvaluatorActivation(
Integer.MAX_VALUE, rm, (TerminalNode) rm.getNetworkNode());
evaluator.evaluateNetwork(this, 0, -1);
}
} else {
// no need to call retract, as no leftmemory used.
getEntryPointNode().assertQuery(handle, pCtx, this);
pCtx.evaluateActionQueue(this);
}
return tnodes;
}
@Test
public void testLiaNodeLinking() {
setUp(JOIN_NODE);
// Initialise from lian
KieBaseConfiguration kconf = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
kconf.setOption(RuleEngineOption.PHREAK);
AbstractWorkingMemory wm =
new AbstractWorkingMemory(
1, (ReteooRuleBase) RuleBaseFactory.newRuleBase((RuleBaseConfiguration) kconf));
SegmentUtilities.createSegmentMemory(liaNode, wm);
InternalFactHandle fh1 = (InternalFactHandle) wm.insert("str1");
n1.assertObject(fh1, context, wm);
LiaNodeMemory liaMem = (LiaNodeMemory) wm.getNodeMemory(liaNode);
assertEquals(1, liaMem.getNodePosMaskBit());
assertEquals(3, liaMem.getSegmentMemory().getAllLinkedMaskTest());
BetaMemory bm1 = (BetaMemory) wm.getNodeMemory(n1);
assertEquals(2, bm1.getNodePosMaskBit());
assertEquals(3, bm1.getSegmentMemory().getAllLinkedMaskTest());
// still unlinked
assertFalse(liaMem.getSegmentMemory().isSegmentLinked());
// now linked
InternalFactHandle fh2 = (InternalFactHandle) wm.insert("str2");
liaNode.assertObject(fh2, context, wm);
assertTrue(liaMem.getSegmentMemory().isSegmentLinked());
// test unlink after one retract
liaNode.retractLeftTuple(fh2.getFirstLeftTuple(), context, wm);
assertFalse(liaMem.getSegmentMemory().isSegmentLinked());
// check counter, after multiple asserts
InternalFactHandle fh3 = (InternalFactHandle) wm.insert("str3");
InternalFactHandle fh4 = (InternalFactHandle) wm.insert("str4");
liaNode.assertObject(fh3, context, wm);
liaNode.assertObject(fh4, context, wm);
assertTrue(liaMem.getSegmentMemory().isSegmentLinked());
liaNode.retractLeftTuple(fh3.getFirstLeftTuple(), context, wm);
assertTrue(liaMem.getSegmentMemory().isSegmentLinked());
liaNode.retractLeftTuple(fh4.getFirstLeftTuple(), context, wm);
assertFalse(liaMem.getSegmentMemory().isSegmentLinked());
}
@Test
public void testPopulatedRuleWithEvals() throws Exception {
KnowledgeBase kbase1 = buildKnowledgeBase("r1", " a:A() B() eval(1==1) eval(1==1) C(1;) \n");
InternalWorkingMemory wm = ((InternalWorkingMemory) kbase1.newStatefulKnowledgeSession());
List list = new ArrayList();
wm.setGlobal("list", list);
wm.insert(new A(1));
wm.insert(new A(2));
wm.insert(new A(3));
wm.insert(new B(1));
wm.insert(new C(1));
wm.insert(new C(2));
wm.fireAllRules();
assertEquals(3, list.size());
kbase1.addKnowledgePackages(
buildKnowledgePackage("r2", " a:A() B() eval(1==1) eval(1==1) C(2;) \n"));
ObjectTypeNode aotn = getObjectTypeNode(kbase1, A.class);
LeftInputAdapterNode liaNode = (LeftInputAdapterNode) aotn.getSinkPropagator().getSinks()[0];
JoinNode bNode = (JoinNode) liaNode.getSinkPropagator().getFirstLeftTupleSink();
EvalConditionNode e1 = (EvalConditionNode) bNode.getSinkPropagator().getFirstLeftTupleSink();
EvalConditionNode e2 = (EvalConditionNode) e1.getSinkPropagator().getFirstLeftTupleSink();
JoinNode c1Node = (JoinNode) e2.getSinkPropagator().getFirstLeftTupleSink();
JoinNode c2Node = (JoinNode) e2.getSinkPropagator().getLastLeftTupleSink();
LiaNodeMemory lm = (LiaNodeMemory) wm.getNodeMemory(liaNode);
SegmentMemory sm = lm.getSegmentMemory();
BetaMemory c1Mem = (BetaMemory) wm.getNodeMemory(c1Node);
assertSame(sm.getFirst(), c1Mem.getSegmentMemory());
assertEquals(3, c1Mem.getLeftTupleMemory().size());
assertEquals(1, c1Mem.getRightTupleMemory().size());
BetaMemory c2Mem = (BetaMemory) wm.getNodeMemory(c2Node);
SegmentMemory c2Smem = sm.getFirst().getNext();
assertSame(c2Smem, c2Mem.getSegmentMemory());
assertEquals(0, c2Mem.getLeftTupleMemory().size());
assertEquals(0, c2Mem.getRightTupleMemory().size());
assertNotNull(c2Smem.getStagedLeftTuples().getInsertFirst());
assertNotNull(c2Smem.getStagedLeftTuples().getInsertFirst().getStagedNext());
assertNotNull(c2Smem.getStagedLeftTuples().getInsertFirst().getStagedNext().getStagedNext());
assertNull(
c2Smem
.getStagedLeftTuples()
.getInsertFirst()
.getStagedNext()
.getStagedNext()
.getStagedNext());
wm.fireAllRules();
assertEquals(3, c2Mem.getLeftTupleMemory().size());
assertEquals(1, c2Mem.getRightTupleMemory().size());
assertNull(c2Smem.getStagedLeftTuples().getInsertFirst());
assertEquals(6, list.size());
assertEquals("r1", ((Match) list.get(0)).getRule().getName());
assertEquals("r1", ((Match) list.get(1)).getRule().getName());
assertEquals("r1", ((Match) list.get(2)).getRule().getName());
assertEquals("r2", ((Match) list.get(3)).getRule().getName());
assertEquals(3, ((A) ((Match) list.get(3)).getDeclarationValue("a")).getObject());
assertEquals("r2", ((Match) list.get(4)).getRule().getName());
assertEquals(2, ((A) ((Match) list.get(4)).getDeclarationValue("a")).getObject());
assertEquals("r2", ((Match) list.get(5)).getRule().getName());
assertEquals(1, ((A) ((Match) list.get(5)).getDeclarationValue("a")).getObject());
}
public void modifyObject(
final InternalFactHandle handle,
final PropagationContext context,
final ObjectTypeConf objectTypeConf,
final InternalWorkingMemory wm) {
if (log.isTraceEnabled()) {
log.trace("Update {}", handle.toString());
}
// checks if shadow is enabled
if (objectTypeConf.isShadowEnabled()) {
// the user has implemented the ShadowProxy interface, let their implementation
// know it is safe to update the information the engine can see.
((ShadowProxy) handle.getObject()).updateProxy();
}
ObjectTypeNode[] cachedNodes = objectTypeConf.getObjectTypeNodes();
// make a reference to the previous tuples, then null then on the handle
ModifyPreviousTuples modifyPreviousTuples =
new ModifyPreviousTuples(
handle.getFirstLeftTuple(), handle.getFirstRightTuple(), unlinkingEnabled);
handle.clearLeftTuples();
handle.clearRightTuples();
for (int i = 0, length = cachedNodes.length; i < length; i++) {
cachedNodes[i].modifyObject(handle, modifyPreviousTuples, context, wm);
// remove any right tuples that matches the current OTN before continue the modify on the next
// OTN cache entry
if (i < cachedNodes.length - 1) {
RightTuple rightTuple = modifyPreviousTuples.peekRightTuple();
while (rightTuple != null
&& ((BetaNode) rightTuple.getRightTupleSink()).getObjectTypeNode() == cachedNodes[i]) {
modifyPreviousTuples.removeRightTuple();
if (unlinkingEnabled) {
BetaMemory bm = BetaNode.getBetaMemory((BetaNode) rightTuple.getRightTupleSink(), wm);
BetaNode.doDeleteRightTuple(rightTuple, wm, bm);
} else {
((BetaNode) rightTuple.getRightTupleSink()).retractRightTuple(rightTuple, context, wm);
}
rightTuple = modifyPreviousTuples.peekRightTuple();
}
LeftTuple leftTuple;
ObjectTypeNode otn;
while (true) {
leftTuple = modifyPreviousTuples.peekLeftTuple();
otn = null;
if (leftTuple != null) {
LeftTupleSink leftTupleSink = leftTuple.getLeftTupleSink();
if (leftTupleSink instanceof LeftTupleSource) {
otn = ((LeftTupleSource) leftTupleSink).getLeftTupleSource().getObjectTypeNode();
} else if (leftTupleSink instanceof RuleTerminalNode) {
otn = ((RuleTerminalNode) leftTupleSink).getObjectTypeNode();
}
}
if (otn == null || otn == cachedNodes[i + 1]) break;
modifyPreviousTuples.removeLeftTuple();
if (unlinkingEnabled) {
LeftInputAdapterNode liaNode =
(LeftInputAdapterNode) leftTuple.getLeftTupleSink().getLeftTupleSource();
LiaNodeMemory lm = (LiaNodeMemory) wm.getNodeMemory(liaNode);
LeftInputAdapterNode.doDeleteObject(
leftTuple, context, lm.getSegmentMemory(), wm, liaNode, true, lm);
} else {
leftTuple.getLeftTupleSink().retractLeftTuple(leftTuple, context, wm);
}
}
}
}
modifyPreviousTuples.retractTuples(context, wm);
}