when
	<conditions>
then
	<actions>

Example 1: Single rule, no sharing

Figure 3.2. Example for a Single rule with no sharing

Example 2: Two rules with sharing

Figure 3.3. Example for two rules with sharing

Example 3: Three rules with sharing

Figure 3.4. Example for Three rules with sharing

Example 4: Single rule, with sub-network and no sharing

Figure 3.5. Example for a Single rule with sub-network and no sharing

Example 5: Two rules: one with a sub-network and sharing

Figure 3.6. Example for Two rules, one with a sub-network and sharing

Switching Using System Properties

drools.ruleEngine=phreak

drools.ruleEngine=reteoo

<dependency>
  <groupId>org.drools</groupId>
  <artifactId>drools-reteoo</artifactId>
  <version>${drools.version}</version>
</dependency>

Switching in KieBaseConfiguration

import org.kie.api.KieBase;
import org.kie.api.KieBaseConfiguration;
import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
...

KieServices kservices = KieServices.Factory.get();
KieBaseConfiguration kconfig = kieServices.Factory.get().newKieBaseConfiguration();

// you can either specify phreak (default)
kconfig.setOption(RuleEngineOption.PHREAK);

// or legacy ReteOO
kconfig.setOption(RuleEngineOption.RETEOO);

// and then create a KieBase for the selected algorithm (getKieClasspathContainer() is just an example)
KieContainer container = kservices.getKieClasspathContainer();
KieBase kbase = container.newKieBase(kieBaseName, kconfig);

rule
when
    Cheese( $cheddar : name == "cheddar" )
    $person: Person( favouriteCheese == $cheddar )
then
    System.out.println( $person.getName() + " likes cheddar" );
end

rule
when
    Cheese( $cheddar : name == "cheddar" )
    $person : Person( favouriteCheese != $cheddar )
then
    System.out.println( $person.getName() + " does not like cheddar" );
end

Figure 3.8. Node Sharing

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.jboss.app</groupId>
  <artifactId>my-app</artifactId>
  <version>1</version>
</project>

<metadata>
  <groupId>com.foo</groupId>
  <artifactId>my-foo</artifactId>
  <version>2.0.0</version>
  <versioning>
    <release>1.1.1</release>
    <versions>
      <version>1.0</version>
      <version>1.0.1</version>
      <version>1.1</version>
      <version>1.1.1</version>
      <version>2.0.0</version>
    </versions>
    <lastUpdated>20090722140000</lastUpdated>
  </versioning>
</metadata>

<version>[1.0.1]</version>

<version>1.0.1</version>

<version>[1.0.0,2.0.0)</version>

<version>[1.0.0,)</version>

<version>LATEST</version>

<version>RELEASE</version>

<profiles>
  <profile>
    <id>profile-1</id>
    <activation>
      <activeByDefault>true</activeByDefault>
    </activation>
    ...
  </profile>
</profiles>

global java.util.List list

List list = new ArrayList();
ksession.setGlobal("list", list);

rule "Testing Comments"
when
    // this is a single line comment
    eval( true ) // this is a comment in the same line of a pattern
then
    // this is a comment inside a semantic code block
end

rule "Test Multi-line Comments"
when
    /* this is a multi-line comment
       in the left hand side of a rule */
    eval( true )
then
    /* and this is a multi-line comment
       in the right hand side of a rule */
end

# Comment: DSL examples

#/ debug: display result and usage

# keyword definition: replaces "regula" by "rule"
[keyword][]regula=rule

# conditional element: "T" or "t", "a" or "an", convert matched word
[when][][Tt]here is an? {entity:\w+}=
        ${entity!lc}: {entity!ucfirst} ()

# consequence statement: convert matched word, literal braces
[then][]update {entity:\w+}=modify( ${entity!lc} )\{ \}

StockTick() over window:time( 2m )

rule "Sound the alarm in case temperature rises above threshold"
when
    TemperatureThreshold( $max : max )
    Number( doubleValue > $max ) from accumulate(
        SensorReading( $temp : temperature ) over window:time( 10m ),
        average( $temp ) )
then
    // sound the alarm
end

StockTick( company == "RHT" ) over window:length( 10 )

rule "Sound the alarm in case temperature rises above threshold"
when
    TemperatureThreshold( $max : max )
    Number( doubleValue > $max ) from accumulate(
        SensorReading( $temp : temperature ) over window:length( 100 ),
        average( $temp ) )
then
    // sound the alarm
end

import org.kie.api.runtime.KieSession;
import org.kie.api.task.TaskService;
import org.kie.api.runtime.process.ProcessInstance;
import org.kie.services.client.api.RemoteRestRuntimeEngineFactory;
import org.kie.services.client.api.RemoteRestRuntimeEngineFactoryBuilderImpl;
import org.kie.services.client.api.command.RemoteRuntimeEngine;


public void javaRemoteApiRestExample(String deploymentId, URL baseUrl, String user, String password) {
  // The serverRestUrl should contain a URL similar to "http://localhost:8080/business-central/"

  RemoteRestRuntimeEngineFactory remoteRestRuntimeEngineFactory = RemoteRestRuntimeEngineFactory.newBuilder()
	  .addDeploymentId(deploymentId)
		.addUrl(url)
		.addUserName(userName)
		.addPassword(passWord)
		.addTimeout(timeOut)
		.build();
				
	RemoteRuntimeEngine engine = remoteRestRuntimeEngineFactory.newRuntimeEngine();		

  // Create KieSession and TaskService instances and use them
   KieSession ksession = engine.getKieSession();
   TaskService taskService = engine.getTaskService();
   
  // Each opertion on a KieSession, TaskService or AuditLogService (client) instance
  // sends a request for the operation to the server side and waits for the response
  // If something goes wrong on the server side, the client will throw an exception.
   ProcessInstance processInstance
       = ksession.startProcess("com.burns.reactor.maintenance.cycle");
   long procId = processInstance.getId();
   
   String taskUserId = user;
   taskService = engine.getTaskService();
   List<TaskSummary> tasks = taskService.getTasksAssignedAsPotentialOwner(user, "en-UK");
   
   long taskId = -1;
   for (TaskSummary task : tasks) {
        if (task.getProcessInstanceId() == procId) {
          taskId = task.getId();
        }
    }
    
    if (taskId == -1) {
      throw new IllegalStateException("Unable to find task for " + user + " in process instance " + procId);
    }
		
    taskService.start(taskId, taskUserId);
  }
}

Example Usage

import org.kie.api.runtime.KieSession;
import org.kie.api.task.TaskService;
import org.kie.api.runtime.process.ProcessInstance;
import org.kie.services.client.api.RemoteJmsRuntimeEngineFactory;
import org.kie.services.client.api.command.RemoteRuntimeEngine;


public void javaRemoteApiJmsExample(String deploymentId, Long processInstanceId, String user, String password) {

  // create a factory class with all the values
  RemoteJmsRuntimeEngineFactory jmsRuntimeFactory = 
          RemoteJmsRuntimeEngineFactory.newBuilder()
          .addDeploymentId(deploymentId)
          .addProcessInstanceId(processInstanceId)
          .addUserName(user)
          .addPassword(password)
          .addRemoteInitialContext(remoteInitialContext)
          .addTimeout(3)
          .addExtraJaxbClasses(MyType.class)
          .useSsl(false)
          .build();

	RemoteRuntimeEngine engine = jmsRuntimeFactory.newRuntimeEngine();		

  // Create KieSession and TaskService instances and use them
   KieSession ksession = engine.getKieSession();
   TaskService taskService = engine.getTaskService();
   
  // Each opertion on a KieSession, TaskService or AuditLogService (client) instance
  // sends a request for the operation to the server side and waits for the response
  // If something goes wrong on the server side, the client will throw an exception.
   ProcessInstance processInstance
       = ksession.startProcess("com.burns.reactor.maintenance.cycle");
   long procId = processInstance.getId();
   
   String taskUserId = user;
   taskService = engine.getTaskService();
   List<TaskSummary> tasks = taskService.getTasksAssignedAsPotentialOwner(user, "en-UK");
   
   long taskId = -1;
   for (TaskSummary task : tasks) {
        if (task.getProcessInstanceId() == procId) {
          taskId = task.getId();
        }
    }
    
    if (taskId == -1) {
      throw new IllegalStateException("Unable to find task for " + user + " in process instance " + procId);
    }
		
    taskService.start(taskId, taskUserId);
  }
}

Sending and receiving JMS messages

import org.kie.api.runtime.process.ProcessInstance;
import org.kie.api.task.model.TaskSummary;
	
public void sendAndReceiveJmsMessage() {
	
    String USER = "charlie";
    String PASSWORD = "ch0c0licious";
    
    String DEPLOYMENT_ID = "test-project";
    String PROCESS_ID_1 = "oompa-processing";
    URL serverUrl;
    try {
        serverUrl = new URL("http://localhost:8080/business-central/");
    } catch (MalformedURLException murle) {
        logger.error("Malformed URL for the server instance!", murle);
        return;
    }
    
// Create JaxbCommandsRequest instance and add commands
    Command<?> cmd = new StartProcessCommand(PROCESS_ID_1);
    int oompaProcessingResultIndex = 0;
    JaxbCommandsRequest req = new JaxbCommandsRequest(DEPLOYMENT_ID, cmd);
    req.getCommands().add(new GetTaskAssignedAsPotentialOwnerCommand(USER));
    int loompaMonitoringResultIndex = 1;
    
// Get JNDI context from server
    InitialContext context = getRemoteJbossInitialContext(serverUrl, USER, PASSWORD);
    
// Create JMS connection
    ConnectionFactory connectionFactory;
    try {
        connectionFactory = (ConnectionFactory) context.lookup("jms/RemoteConnectionFactory");
    } catch (NamingException ne) {
        throw new RuntimeException("Unable to lookup JMS connection factory.", ne);
    }
    
// Setup queues
    Queue sendQueue, responseQueue;
    try {
        sendQueue = (Queue) context.lookup("jms/queue/KIE.SESSION");
        responseQueue = (Queue) context.lookup("jms/queue/KIE.RESPONSE");
    } catch (NamingException ne) {
        throw new RuntimeException("Unable to lookup send or response queue", ne);
    }
    
// Send command request
    Long processInstanceId = null; // needed if you're doing an operation on a PER_PROCESS_INSTANCE deployment
    String humanTaskUser = USER;
    JaxbCommandsResponse cmdResponse = sendJmsCommands(
          DEPLOYMENT_ID, processInstanceId, humanTaskUser, req,
          connectionFactory, sendQueue, responseQueue,
          USER, PASSWORD, 5);
        
// Retrieve results
    ProcessInstance oompaProcInst = null;
    List<TaskSummary> charliesTasks = null;
    for (JaxbCommandResponse<?> response : cmdResponse.getResponses()) {
        if (response instanceof JaxbExceptionResponse) {

          // something went wrong on the server side
          JaxbExceptionResponse exceptionResponse = (JaxbExceptionResponse) response;
          throw new RuntimeException(exceptionResponse.getMessage());
        }
        if (response.getIndex() == oompaProcessingResultIndex) {
          oompaProcInst = (ProcessInstance) response.getResult();
        } else if (response.getIndex() == loompaMonitoringResultIndex) {
          charliesTasks = (List<TaskSummary>) response.getResult();
        }
    }
}

Sending JMS commands

private JaxbCommandsResponse sendJmsCommands(String deploymentId, Long processInstanceId, String user,
  JaxbCommandsRequest req, ConnectionFactory factory, Queue sendQueue, Queue responseQueue, String jmsUser,
  String jmsPassword, int timeout) {
    req.setProcessInstanceId(processInstanceId);
    req.setUser(user);

    Connection connection = null;
    Session session = null;
    String corrId = UUID.randomUUID().toString();
    String selector = "JMSCorrelationID = '" + corrId + "'";
    JaxbCommandsResponse cmdResponses = null;
    try {
    
        // setup
        MessageProducer producer;
        MessageConsumer consumer;
        try {
          if (jmsPassword != null) {
            connection = factory.createConnection(jmsUser, jmsPassword);
          } else {
            connection = factory.createConnection();
          }
          session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
          
          producer = session.createProducer(sendQueue);
          consumer = session.createConsumer(responseQueue, selector);
          
          connection.start();
        } catch (JMSException jmse) {
            throw new RemoteCommunicationException("Unable to setup a JMS connection.", jmse);
        }

        JaxbSerializationProvider serializationProvider = new JaxbSerializationProvider();
        // if necessary, add user-created classes here:
        // xmlSerializer.addJaxbClasses(MyType.class, AnotherJaxbAnnotatedType.class);

        // Create msg
        BytesMessage msg;
        try {
          msg = session.createBytesMessage();

          // serialize request
          String xmlStr = serializationProvider.serialize(req);
          msg.writeUTF(xmlStr);
          
          // set properties
         msg.setJMSCorrelationID(corrId);
         msg.setIntProperty(SerializationConstants.SERIALIZATION_TYPE_PROPERTY_NAME, JaxbSerializationProvider.JMS_SERIALIZATION_TYPE);
         Collection<Class<?>> extraJaxbClasses = serializationProvider.getExtraJaxbClasses();
         if (!extraJaxbClasses.isEmpty()) {
           String extraJaxbClassesPropertyValue = JaxbSerializationProvider
             .classSetToCommaSeperatedString(extraJaxbClasses);
           msg.setStringProperty(SerializationConstants.EXTRA_JAXB_CLASSES_PROPERTY_NAME, extraJaxbClassesPropertyValue);
           msg.setStringProperty(SerializationConstants.DEPLOYMENT_ID_PROPERTY_NAME, deploymentId);
         }
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to create and fill a JMS message.", jmse);
       } catch (SerializationException se) {
         throw new RemoteCommunicationException("Unable to deserialze JMS message.", se.getCause());
       }
       
       // send
       try {
         producer.send(msg);
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to send a JMS message.", jmse);
       }
       
       // receive
       Message response;
       try {
         response = consumer.receive(timeout);
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to receive or retrieve the JMS response.", jmse);
       }
       
       if (response == null) {
         logger.warn("Response is empty, leaving");
         return null;
       }
       // extract response
       assert response != null : "Response is empty.";
       try {
         String xmlStr = ((BytesMessage) response).readUTF();
         cmdResponses = (JaxbCommandsResponse) serializationProvider.deserialize(xmlStr);
       } catch (JMSException jmse) {
         throw new RemoteCommunicationException("Unable to extract " + JaxbCommandsResponse.class.getSimpleName()
           + " instance from JMS response.", jmse);
       } catch (SerializationException se) {
         throw new RemoteCommunicationException("Unable to extract " + JaxbCommandsResponse.class.getSimpleName()
           + " instance from JMS response.", se.getCause());
       }
       assert cmdResponses != null : "Jaxb Cmd Response was null!";
       } finally {
         if (connection != null) {
           try {
             connection.close();
             if( session != null ) {
               session.close();
             }
          } catch (JMSException jmse) {
             logger.warn("Unable to close connection or session!", jmse);
          }
       }
    }
    return cmdResponses;
}

Configuration using an InitialContext instance

private InitialContext getRemoteJbossInitialContext(URL url, String user, String password) {
    Properties initialProps = new Properties();
    initialProps.setProperty(InitialContext.INITIAL_CONTEXT_FACTORY, "org.jboss.naming.remote.client.InitialContextFactory");
    String jbossServerHostName = url.getHost();
    initialProps.setProperty(InitialContext.PROVIDER_URL, "remote://"+ jbossServerHostName + ":4447");
    initialProps.setProperty(InitialContext.SECURITY_PRINCIPAL, user);
    initialProps.setProperty(InitialContext.SECURITY_CREDENTIALS, password);
    
    for (Object keyObj : initialProps.keySet()) {
        String key = (String) keyObj;
        System.setProperty(key, (String) initialProps.get(key));
    }
    try {
        return new InitialContext(initialProps);
    } catch (NamingException e) {
        throw new RemoteCommunicationException("Unable to create " + InitialContext.class.getSimpleName(), e);
    }
}