Drools Introduction and General User Guide

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:drools="http://drools.org/schema/drools-spring"       

       xmlns:camel="http://camel.apache.org/schema/spring"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd

                           http://drools.org/schema/drools-spring http://anonsvn.jboss.org/repos/labs/labs/jbossrules/trunk/drools-container/drools-spring/src/main/resources/org/drools/container/spring/drools-spring-1.0.0.xsd

                           http://camel.apache.org/schema/spring http://camel.apache.org/schema/spring/camel-spring.xsd">

  <drools:resource id="resource1" type="DRL" source="classpath:org/drools/container/spring/testSpring.drl"/>



  <drools:kbase id="kbase1">

    <drools:resources>

      <drools:resource type="DRL" source="classpath:org/drools/container/spring/testSpring.drl"/>

      <drools:resource ref="resource1"/>

      <drools:resource source="classpath:org/drools/container/spring/IntegrationExampleTest.xls" type="DTABLE">

        <drools:decisiontable-conf input-type="XLS" worksheet-name="Tables_2" />

      </drools:resource>

    </drools:resources>



    <drools:configuration>

      <drools:mbeans enabled="true" />

      <drools:event-processing-mode mode="STREAM" />

    </drools:configuration>

  </drools:kbase>

</beans>

<drools:ksession id="ksession1" type="stateless" name="stateless1" kbase="kbase1" />



<drools:ksession id="ksession2" type="stateful" kbase="kbase1" />

<drools:ksession id="ksession1" type="stateful"  kbase="kbase1" >

  <drools:configuration>

    <drools:work-item-handlers>

      <drools:work-item-handler name="handlername" ref="handlerid" />

    </drools:work-item-handlers>

    <drools:keep-reference enabled="true" />

    <drools:clock-type type="REALTIME"  /> 

  </drools:configuration>

</drools:ksession>

<bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">

  <property name="driverClassName" value="org.h2.Driver" />

  <property name="url" value="jdbc:h2:tcp://localhost/DroolsFlow" />

  <property name="username" value="sa" />

  <property name="password" value="" />

</bean>



<bean id="myEmf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

  <property name="dataSource" ref="ds" />

  <property name="persistenceUnitName" value="org.drools.persistence.jpa.local" />

</bean>



<bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">

  <property name="entityManagerFactory" ref="myEmf" />

</bean>



<drools:ksession id="jpaSingleSessionCommandService" type="stateful" kbase="kbase1">

  <drools:configuration>

    <drools:jpa-persistence>

      <drools:transaction-manager ref="txManager" />

      <drools:entity-manager-factory ref="myEmf" />

      <drools:variable-persisters>

         <drools:persister for-class="javax.persistence.Entity" implementation="org.drools.persistence.processinstance.persisters.JPAVariablePersister"/>

         <drools:persister for-class="java.lang.String" implementation="org.drools.container.spring.beans.persistence.StringVariablePersister"/>

         <drools:persister for-class="java.io.Serializable" implementation="org.drools.persistence.processinstance.persisters.SerializableVariablePersister"/>

      </drools:variable-persisters>  

    </drools:jpa-persistence>

  </drools:configuration>    

</drools:ksession>

<drools:ksession id="jpaSingleSessionCommandService" type="stateful" kbase="kbase1">

  <drools:script>

     <drools:insert-object ref="person1" />

     <drools:start-process process-id="proc name">

       <drools:parameter identifier="varName" ref="varRef" />

     </drools:start-process>

     <drools:fire-all-rules />

  </drools:script>    

</drools:ksession>

<execution-node id="node1" />



<drools:ksession id="ksession1" type="stateless" name="stateless1" kbase="kbase1" node="node1"/>



<drools:ksession id="ksession2" type="stateful" kbase="kbase1" node="node1"/>

<cxf:rsServer id="rsServer"  

              address="/kservice/rest"

              serviceClass="org.drools.jax.rs.CommandExecutorImpl">

   <cxf:providers>

      <bean class="org.drools.jax.rs.CommandMessageBodyReader"/>

   </cxf:providers>

</cxf:rsServer> 

<bean id="droolsPolicy" class="org.drools.camel.component.DroolsPolicy" />  

    

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">        

   <route>

      <from uri="cxfrs://bean://rsServer"/>

      <policy ref="droolsPolicy">

         <unmarshal ref="xstream" />       

         <to uri="drools://node/ksession1" />

         <marshal ref="xstream" />

      </policy>

   </route>           

</camelContext>

StatefulKnowledgeSession ksession = ...

 

// ... insert facts, fire rules, etc

 

SessionInspector inspector = new SessionInspector( ksession );

StatefulKnowledgeSessionInfo info = inspector.getSessionInfo();

String report = SessionReporter.generateReport( "simple", info, null );

final List updated = new ArrayList();

final List removed = new ArrayList();

final List added = new ArrayList();

 

ViewChangedEventListener listener = new ViewChangedEventListener() {           

 public void rowUpdated(Row row) {

  updated.add( row.get( "$price" ) );

 }

  

 public void rowRemoved(Row row) {

  removed.add( row.get( "$price" ) );

 }

  

 public void rowAdded(Row row) {

  added.add( row.get( "$price" ) );

 }

};       

 

// Open the LiveQuery

LiveQuery query = ksession.openLiveQuery( "cheeses",

                                          new Object[] { "cheddar", "stilton" },

                                          listener );

...

...

query.dispose() // make sure you call dispose when you want the query to close

timer ( int: <initial delay> <repeat interval>? )

timer ( int: 30s )

timer ( int: 30s 5m )

 

timer ( cron: <cron expression> )

timer ( cron:* 0/15 * * * ? )

rule "Send SMS every 15 minutes"

    timer (cron:* 0/15 * * * ?)

when

    $a : Alarm( on == true )

then

    channels[ "sms" ].insert( new Sms( $a.mobileNumber, "The alarm is still on" );

end

Calendar weekDayCal = QuartzHelper.quartzCalendarAdapter(org.quartz.Calendar quartzCal)

ksession.getCalendars().set( "week day", weekDayCal );

rule "weekdays are high priority"

   calendars "weekday"

   timer (int:0 1h)

when 

    Alarm()

then

    send( "priority high - we have an alarm );

end 


rule "weekend are low priority"

   calendars "weekend"

   timer (int:0 4h)

when 

    Alarm()

then

    send( "priority low - we have an alarm );

end

Package[] packages = pkgBuilder.getPackages();

RuleBase ruleBase = RuleBaseFactory.newRuleBase();

PackageBuilder pkgBuilder = new PackageBuilder( ruleBase, null );

declare StockTick
  @role( event )
  @timestamp( timestampAttr )

  companySymbol : String
  stockPrice : double
  timestampAttr : long
end

declare StockTick
  @role( event )
end

declare Person
  name : String
  age : int
end

KnowledgeBaseConfiguration config = KnowledgeBaseFactory.newKnowledgeBaseConfiguration();

config.setOption( AssertBehaviorOption.EQUALITY );

config.setOption( RemoveIdentitiesOption.YES );

config.setOption( AlphaThresholdOption.get(5) );

# collect the set of unique names in the working memory
$names : Set() from accumulate( Person( $n : name, $s : surname ),
                        collectSet( $n + " " + $s ) )

# collect the list of alarm codes from the alarms in the working memory
$codes : List() from accumulate( Alarm( $c : code, $s : severity ),
                         collectList( $c + $s ) )

declare Person
	@propertyChangeSupport
end

ksession.execute( CommandFactory.newInsert( person ) ); 

List<Command> cmds = new ArrayList<Command>();

cmds.add( CommandFactory.newSetGlobal( "list1", new ArrayList(), true ) );

cmds.add( CommandFactory.newInsert( new Person( "jon", 102 ), "person" ) );

cmds.add( CommandFactory.newQuery( "Get People" "getPeople" );


BatchExecutionResults results = ksession.execute( CommandFactory.newBatchExecution( cmds ) );

results.getValue( "list1" ); // returns the ArrayList

results.getValue( "person" ); // returns the inserted fact Person

results.getValue( "Get People" );// returns the query as a QueryResults instance.

end

Action executeResultHandler = PipelineFactory.newExecuteResultHandler();

Action assignResult = PipelineFactory.newAssignObjectAsResult();

assignResult.setReceiver( executeResultHandler );

Transformer outTransformer = PipelineFactory.newXStreamToXmlTransformer( BatchExecutionHelper.newXStreamMarshaller() );

outTransformer.setReceiver( assignResult );

KnowledgeRuntimeCommand batchExecution = PipelineFactory.newBatchExecutor();

batchExecution.setReceiver( outTransformer );

Transformer inTransformer = PipelineFactory.newXStreamFromXmlTransformer( BatchExecutionHelper.newXStreamMarshaller() );

inTransformer.setReceiver( batchExecution );

Pipeline pipeline = PipelineFactory.newStatelessKnowledgeSessionPipeline( ksession );

pipeline.setReceiver( inTransformer ); 

<batch-execution>

<insert out-identifier='outStilton'>

  <org.drools.Cheese>

    <type>stilton</type>

    <price>25</price>

    <oldPrice>0</oldPrice>

  </org.drools.Cheese>

</insert>

</batch-execution>

<batch-execution-results>

 <result identifier='outStilton'>

   <org.drools.Cheese>

     <type>stilton</type>

     <oldPrice>0</oldPrice>       

     <price>30</price>

   </org.drools.Cheese>

 </result>

</batch-execution-results>

// ksession is the StatefulKnowledgeSession

// kbase is the KnowledgeBase

ByteArrayOutputStream baos = new ByteArrayOutputStream();

Marshaller marshaller = MarshallerFactory.newMarshaller( kbase );

marshaller.marshall( baos, ksession );

baos.close();

ByteArrayOutputStream baos = new ByteArrayOutputStream();

Marshaller marshaller = MarshallerFactory.newMarshaller( kbase, new ObjectMarshallingStrategy[] { MarshallerFactory.newIdentityMarshallingStrategy() } );

marshaller.marshall( baos, ksession );

baos.close(); 

ByteArrayOutputStream baos = new ByteArrayOutputStream();

ObjectMarshallingStrategyAcceptor identityAceceptor = MarshallerFactory.newClassFilterAcceptor( new String[] { "org.domain.pkg1.*" } );

ObjectMarshallingStrategy identityStratetgy = MarshallerFactory.newIdentityMarshallingStrategy( identityAceceptor );

Marshaller marshaller = MarshallerFactory.newMarshaller( kbase, new ObjectMarshallingStrategy[] { identityStratetgy, MarshallerFactory.newSerializeMarshallingStrategy() } );

marshaller.marshall( baos, ksession );

baos.close();

// Set the interval on the ResourceChangeScannerService if you are to use it and default of 60s is not desirable.

ResourceChangeScannerConfiguration sconf = ResourceFactory.getResourceChangeScannerService().newResourceChangeScannerConfiguration();

sconf.setProperty( "drools.resource.scanner.interval",

                  "30" ); // set the disk scanning interval to 30s, default is 60s

ResourceFactory.getResourceChangeScannerService().configure( sconf );

KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();

KnowledgeAgentConfiguration aconf = KnowledgeAgentFactory.newKnowledgeAgentConfiguration();

aconf.setProperty( "drools.agent.scanDirectories",

                  "true" ); // we want to scan directories, not just files, turning this on turns on file scanning

aconf.setProperty( "drools.agent.newInstance",

                  "true" ); // resource changes results in a new instance of the KnowledgeBase being built,

                            // this cannot currently be set to false for incremental building

    

KnowledgeAgent kagent = KnowledgeAgentFactory.newKnowledgeAgent( "test agent", // the name of the agent

                                                                kbase, // the KnowledgeBase to use, the Agent will also monitor any exist knowledge definitions

                                                                aconf );

kagent.applyChangeSet( ResourceFactory.newUrlResource( url ) ); // resource to the change-set xml for the resources to add

<process  name="process name" id="process name" package-name="org.domain"

xmlns="http://drools.org/drools-4.0/process"

xmlns:mydsl="http://domain/org/mydsl"

xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"

xs:schemaLocation="http://drools.org/drools-4.0/process drools-processes-4.0.xsd" >

<nodes>

  <start id="0" />



  <action id="1" dialect="java">

      list.add( "action node was here" ); 

  </action>



    <mydsl:logger id="2" type="warn">

        This is my message         

    <mydsl:logger>



  <end id="3" />

</nodes>



<connections>

  <connection from="0 to="1" />

  <connection from="1" to="2" />

  <connection from="2" to="3" />

</connections>



</process>

// create a new JPA-based session and specify the JPA entity manager factory

Environment env = KnowledgeBaseFactory.newEnvironment();

env.set( EnvironmentName.ENTITY_MANAGER_FACTORY, Persistence.createEntityManagerFactory( "emf-name" ) );

env.set( EnvironmentName.TRANSACTION_MANAGER, TransactionManagerServices.getTransactionManager() );

        

StatefulKnowledgeSession ksession = JPAKnowledgeService.newStatefulKnowledgeSession( kbase, null, env ); // KnowledgeSessionConfiguration may be null, and a default will be used

int sessionId = ksession.getId();


// if no transaction boundary is specified, the method invocation is executed in a new transaction automatically

ProcessInstance processInstance = ksession.startProcess( "org.drools.test.TestProcess" );


// the users can also specify the transaction boundary themselves

UserTransaction ut = (UserTransaction) new InitialContext().lookup( "java:comp/UserTransaction" );

ut.begin();

ksession.insert( new Person( "John Doe" ) );

ksession.startProcess( "org.drools.test.TestProcess" );

ksession.fireAllRules();

ut.commit();

    * [Java code constraint] return person.getAge() > 20;
    * [MVEL action] System.out.println(person.name);

# existing bean assuming an event role
import org.drools.test.StockTick
declare StockTick
  @role( event )
end

# generated bean assuming an event role
declare Alarm
  @role( event )
  type : String
  timestamp : long
end

WorkingMemoryEntryPoint entry = wm.getWorkingMemoryEntryPoint( "stock stream" );

entry.insert( ticker );

SessionConfiguration conf = new SessionConfiguration();

conf.setClockType( ClockType.PSEUDO_CLOCK );

StatefulSession session = ruleBase.newStatefulSession( conf );

rule "Allow access"
when
WorkHours( $s : start, $e : end )
LogIn( time after $s, time before $e )
then
// allow access
end

WorkingMemory wm = rulebase.newWorkingMemory();

StatefulSession wm = rulebase.newStatefulSession();

rule "Primitive int manual unbox"
when
    $c : Cheese( $price : price )
then
    $c.setPrice( $price.intValue() * 2 )
end

rule "Primitive support"
when
    $c : Cheese( $price : price )
then
    $c.setPrice( $price * 2 )
end