Examples with RuleFlowGroupDeactivatedEvent org.kie.api.event.rule.RuleFlowGroupDeactivatedEvent used on opensource projects

Example 1 with RuleFlowGroupDeactivatedEvent

use of org.kie.api.event.rule.RuleFlowGroupDeactivatedEvent in project drools by kiegroup.

the class DeclarativeAgendaTest method testCancelActivation.

@Test(timeout = 10000)
public void testCancelActivation() {
    String str = "";
    str += "package org.domain.test \n";
    str += "import " + Match.class.getName() + "\n";
    str += "global java.util.List list \n";
    str += "dialect 'mvel' \n";
    str += "rule rule1 @department(sales) \n";
    str += "when \n";
    str += "     $s : String( this == 'go1' ) \n";
    str += "then \n";
    str += "    list.add( kcontext.rule.name + ':' + $s ); \n";
    str += "end \n";
    str += "rule blockerAllSalesRules @activationListener('direct') \n";
    str += "when \n";
    str += "     $s : String( this == 'go2' ) \n";
    str += "     $i : Match( department == 'sales' ) \n";
    str += "then \n";
    str += "    kcontext.cancelMatch( $i ); \n";
    str += "end \n";
    KieBaseConfiguration kconf = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();
    kconf.setOption(DeclarativeAgendaOption.ENABLED);
    KieBase kbase = loadKnowledgeBaseFromString(kconf, str);
    KieSession ksession = createKnowledgeSession(kbase);
    final List cancelled = new ArrayList();
    ksession.addEventListener(new AgendaEventListener() {

        public void beforeMatchFired(BeforeMatchFiredEvent event) {
        }

        public void agendaGroupPushed(AgendaGroupPushedEvent event) {
        }

        public void agendaGroupPopped(AgendaGroupPoppedEvent event) {
        }

        public void afterMatchFired(AfterMatchFiredEvent event) {
        }

        public void matchCreated(MatchCreatedEvent event) {
        }

        public void beforeRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
        }

        public void afterRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
        }

        public void beforeRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
        }

        public void afterRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
        }

        public void matchCancelled(MatchCancelledEvent event) {
            cancelled.add(event);
        }
    });
    List list = new ArrayList();
    ksession.setGlobal("list", list);
    ksession.insert("go1");
    FactHandle go2 = ksession.insert("go2");
    ksession.fireAllRules();
    assertEquals(0, list.size());
    assertEquals(1, cancelled.size());
    assertEquals("rule1", ((MatchCancelledEvent) cancelled.get(0)).getMatch().getRule().getName());
    ksession.dispose();
}

Example 2 with RuleFlowGroupDeactivatedEvent

use of org.kie.api.event.rule.RuleFlowGroupDeactivatedEvent in project drools by kiegroup.

the class AgendaEventSupportTest method testAgendaEventListener.

// public void testIsSerializable() {
// assertTrue( Serializable.class.isAssignableFrom( AgendaEventSupport.class ) );
// }
@Test
@Ignore
public void testAgendaEventListener() throws Exception {
    InternalKnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
    // create a simple package with one rule to test the events
    InternalKnowledgePackage pkg = new KnowledgePackageImpl("org.drools.test");
    final RuleImpl rule = new RuleImpl("test1");
    rule.setEager(true);
    rule.setAgendaGroup("test group");
    final ClassObjectType cheeseObjectType = new ClassObjectType(Cheese.class);
    final Pattern pattern = new Pattern(0, cheeseObjectType);
    pkg.setClassFieldAccessorCache(new ClassFieldAccessorCache(Thread.currentThread().getContextClassLoader()));
    pkg.getClassFieldAccessorStore().setEagerWire(true);
    final ClassFieldReader extractor = pkg.getClassFieldAccessorStore().getReader(Cheese.class, "type");
    final FieldValue field = FieldFactory.getInstance().getFieldValue("cheddar");
    final MvelConstraint constraint = new MvelConstraintTestUtil("type == \"cheddar\"", field, extractor);
    pattern.addConstraint(constraint);
    rule.addPattern(pattern);
    rule.setConsequence(new Consequence() {

        public void evaluate(final KnowledgeHelper knowledgeHelper, final WorkingMemory workingMemory) throws Exception {
        }

        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        }

        public void writeExternal(ObjectOutput out) throws IOException {
        }

        public String getName() {
            // TODO Auto-generated method stub
            return null;
        }
    });
    pkg.addRule(rule);
    kbase.addPackages(Collections.singleton(pkg));
    // create a new working memory and add an AgendaEventListener
    KieSession ksession = kbase.newKieSession();
    final List agendaList = new ArrayList();
    final AgendaEventListener agendaEventListener = new AgendaEventListener() {

        public void matchCancelled(MatchCancelledEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void matchCreated(MatchCreatedEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void afterMatchFired(AfterMatchFiredEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void agendaGroupPopped(AgendaGroupPoppedEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void agendaGroupPushed(AgendaGroupPushedEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void beforeMatchFired(BeforeMatchFiredEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void beforeRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void afterRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void beforeRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }

        public void afterRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            agendaList.add(event);
        }
    };
    ksession.addEventListener(agendaEventListener);
    assertEquals(1, ksession.getAgendaEventListeners().size());
    // assert the cheese fact
    final Cheese cheddar = new Cheese("cheddar", 15);
    FactHandle cheddarHandle = ksession.insert(cheddar);
    InternalAgenda agenda = (InternalAgenda) ksession.getAgenda();
    agenda.evaluateEagerList();
    // should be one MatchCreatedEvent
    assertEquals(1, agendaList.size());
    MatchCreatedEvent createdEvent = (MatchCreatedEvent) agendaList.get(0);
    assertSame(cheddarHandle, createdEvent.getMatch().getFactHandles().toArray()[0]);
    // clear the agenda to check CLEAR events occur
    ksession.getAgenda().clear();
    MatchCancelledEvent cancelledEvent = (MatchCancelledEvent) agendaList.get(1);
    assertEquals(MatchCancelledCause.CLEAR, cancelledEvent.getCause());
    agendaList.clear();
    // update results in an MatchCreatedEvent
    cheddar.setPrice(14);
    ksession.update(cheddarHandle, cheddar);
    agenda.evaluateEagerList();
    assertEquals(1, agendaList.size());
    createdEvent = (MatchCreatedEvent) agendaList.get(0);
    assertSame(cheddarHandle, createdEvent.getMatch().getFactHandles().toArray()[0]);
    agendaList.clear();
    // update should not result in cancelation+activation events
    cheddar.setPrice(14);
    ksession.update(cheddarHandle, cheddar);
    assertEquals(0, agendaList.size());
    // cancelledEvent = (ActivationCancelledEvent) agendaList.get( 0 );
    // assertEquals( ActivationCancelledCause.WME_MODIFY, cancelledEvent.getCause() );
    // assertSame( cheddarHandle,
    // cancelledEvent.getActivation().toFactHandles().toArray()[0] );
    // createdEvent = (ActivationCreatedEvent) agendaList.get( 1 );
    // assertSame( cheddarHandle,
    // createdEvent.getActivation().toFactHandles().toArray()[0] );
    // agendaList.clear();
    // retract results in a ActivationCancelledEvent, note the object is not resolveable now as it no longer exists
    ksession.retract(cheddarHandle);
    assertEquals(1, agendaList.size());
    cancelledEvent = (MatchCancelledEvent) agendaList.get(0);
    // invalidated handles no longer set the object to null
    assertNotNull(((InternalFactHandle) cancelledEvent.getMatch().getFactHandles().toArray()[0]).getObject());
    // re-assert the fact so we can test the agenda group events
    cheddarHandle = ksession.insert(cheddar);
    agendaList.clear();
    // setFocus results in an AgendaGroupPushedEvent
    ksession.getAgenda().getAgendaGroup("test group").setFocus();
    assertEquals(1, agendaList.size());
    final AgendaGroupPushedEvent pushedEvent = (AgendaGroupPushedEvent) agendaList.get(0);
    assertEquals("test group", pushedEvent.getAgendaGroup().getName());
    agendaList.clear();
    // fireAllRules results in a BeforeActivationFiredEvent and an AfterActivationFiredEvent
    // the AgendaGroup becomes empty, which results in a popped event.
    ksession.fireAllRules();
    assertEquals(3, agendaList.size());
    final BeforeMatchFiredEvent beforeEvent = (BeforeMatchFiredEvent) agendaList.get(0);
    assertSame(cheddarHandle, beforeEvent.getMatch().getFactHandles().toArray()[0]);
    final AfterMatchFiredEvent afterEvent = (AfterMatchFiredEvent) agendaList.get(1);
    assertSame(cheddarHandle, afterEvent.getMatch().getFactHandles().toArray()[0]);
    final AgendaGroupPoppedEvent poppedEvent = (AgendaGroupPoppedEvent) agendaList.get(2);
    assertEquals("test group", poppedEvent.getAgendaGroup().getName());
}

Example 3 with RuleFlowGroupDeactivatedEvent

use of org.kie.api.event.rule.RuleFlowGroupDeactivatedEvent in project drools by kiegroup.

the class SequentialTest method testEvents.

@Test
public void testEvents() throws Exception {
    String str = "";
    str += "package org.drools.compiler.test\n";
    str += "import org.drools.compiler.Message\n";
    str += "rule \"Hello World\"\n";
    str += "when\n";
    str += "    Message( )\n";
    str += "then\n";
    str += "    System.out.println( drools.getKieRuntime() );\n";
    str += "end\n";
    KieBase kbase = loadKnowledgeBaseFromString(kconf, str);
    StatelessKieSession ksession = createStatelessKnowledgeSession(kbase);
    final List list = new ArrayList();
    ksession.addEventListener(new AgendaEventListener() {

        public void matchCancelled(MatchCancelledEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void matchCreated(MatchCreatedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void afterMatchFired(AfterMatchFiredEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void agendaGroupPopped(AgendaGroupPoppedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void agendaGroupPushed(AgendaGroupPushedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void beforeMatchFired(BeforeMatchFiredEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void beforeRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void afterRuleFlowGroupActivated(RuleFlowGroupActivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void beforeRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void afterRuleFlowGroupDeactivated(RuleFlowGroupDeactivatedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }
    });
    ksession.addEventListener(new RuleRuntimeEventListener() {

        public void objectInserted(ObjectInsertedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void objectDeleted(ObjectDeletedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }

        public void objectUpdated(ObjectUpdatedEvent event) {
            assertNotNull(event.getKieRuntime());
            list.add(event);
        }
    });
    ksession.execute(new Message("help"));
    assertEquals(4, list.size());
}

Example 4 with RuleFlowGroupDeactivatedEvent

use of org.kie.api.event.rule.RuleFlowGroupDeactivatedEvent in project jbpm by kiegroup.

the class ProcessRuntimeImpl method initProcessActivationListener.

private void initProcessActivationListener() {
    kruntime.addEventListener(new DefaultAgendaEventListener() {

        public void matchCreated(MatchCreatedEvent event) {
            String ruleFlowGroup = ((RuleImpl) event.getMatch().getRule()).getRuleFlowGroup();
            if ("DROOLS_SYSTEM".equals(ruleFlowGroup)) {
                // new activations of the rule associate with a state node
                // signal process instances of that state node
                String ruleName = event.getMatch().getRule().getName();
                if (ruleName.startsWith("RuleFlowStateNode-")) {
                    int index = ruleName.indexOf('-', 18);
                    index = ruleName.indexOf('-', index + 1);
                    String eventType = ruleName.substring(0, index);
                    kruntime.queueWorkingMemoryAction(new SignalManagerSignalAction(eventType, event));
                } else if (ruleName.startsWith("RuleFlowStateEventSubProcess-") || ruleName.startsWith("RuleFlowStateEvent-") || ruleName.startsWith("RuleFlow-Milestone-") || ruleName.startsWith("RuleFlow-AdHocComplete-") || ruleName.startsWith("RuleFlow-AdHocActivate-")) {
                    kruntime.queueWorkingMemoryAction(new SignalManagerSignalAction(ruleName, event));
                }
            }
        }
    });
    kruntime.addEventListener(new DefaultAgendaEventListener() {

        public void afterRuleFlowGroupDeactivated(final RuleFlowGroupDeactivatedEvent event) {
            if (kruntime instanceof StatefulKnowledgeSession) {
                signalManager.signalEvent("RuleFlowGroup_" + event.getRuleFlowGroup().getName() + "_" + ((StatefulKnowledgeSession) kruntime).getIdentifier(), null);
            } else {
                signalManager.signalEvent("RuleFlowGroup_" + event.getRuleFlowGroup().getName(), null);
            }
        }
    });
}