Chapter 3. Project deployment without Business Central
As an alternative to developing and deploying projects in the Business Central interface, you can use independent Maven projects or your own Java applications to develop Red Hat Decision Manager projects and deploy them in KIE containers (deployment units) to a configured KIE Server. You can then use the KIE Server REST API to start, stop, or remove the KIE containers that contain the services and their project versions that you have built and deployed. This flexibility enables you to continue to use your existing application workflow to develop business assets using Red Hat Decision Manager features.
Projects in Business Central are packaged automatically when you build and deploy the projects. For projects outside of Business Central, such as independent Maven projects or projects within a Java application, you must configure the KIE module descriptor settings in an appended kmodule.xml
file or directly in your Java application in order to build and deploy the projects.
3.1. Configuring a KIE module descriptor file
A KIE module is a Maven project or module with an additional metadata file META-INF/kmodule.xml
. All Red Hat Decision Manager projects require a kmodule.xml
file in order to be properly packaged and deployed. This kmodule.xml
file is a KIE module descriptor that defines the KIE base and KIE session configurations for the assets in a project. A KIE base is a repository that contains all rules and other business assets in Red Hat Decision Manager but does not contain any runtime data. A KIE session stores and executes runtime data and is created from a KIE base or directly from a KIE container if you have defined the KIE session in the kmodule.xml
file.
If you create projects outside of Business Central, such as independent Maven projects or projects within a Java application, you must configure the KIE module descriptor settings in an appended kmodule.xml
file or directly in your Java application in order to build and deploy the projects.
Procedure
In the
~/resources/META-INF
directory of your project, create akmodule.xml
metadata file with at least the following content:<?xml version="1.0" encoding="UTF-8"?> <kmodule xmlns="http://www.drools.org/xsd/kmodule"> </kmodule>
This empty
kmodule.xml
file is sufficient to produce a single default KIE base that includes all files found under your projectresources
path. The default KIE base also includes a single default KIE session that is triggered when you create a KIE container in your application at build time.The following example is a more advanced
kmodule.xml
file:<?xml version="1.0" encoding="UTF-8"?> <kmodule xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.drools.org/xsd/kmodule"> <configuration> <property key="drools.evaluator.supersetOf" value="org.mycompany.SupersetOfEvaluatorDefinition"/> </configuration> <kbase name="KBase1" default="true" eventProcessingMode="cloud" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg1"> <ksession name="KSession1_1" type="stateful" default="true" /> <ksession name="KSession1_2" type="stateful" default="true" beliefSystem="jtms" /> </kbase> <kbase name="KBase2" default="false" eventProcessingMode="stream" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg2, org.domain.pkg3" includes="KBase1"> <ksession name="KSession2_1" type="stateless" default="true" clockType="realtime"> <fileLogger file="debugInfo" threaded="true" interval="10" /> <workItemHandlers> <workItemHandler name="name" type="new org.domain.WorkItemHandler()" /> </workItemHandlers> <listeners> <ruleRuntimeEventListener type="org.domain.RuleRuntimeListener" /> <agendaEventListener type="org.domain.FirstAgendaListener" /> <agendaEventListener type="org.domain.SecondAgendaListener" /> <processEventListener type="org.domain.ProcessListener" /> </listeners> </ksession> </kbase> </kmodule>
This example defines two KIE bases. Specific
packages
of rule assets are included with both KIE bases. When you specify packages in this way, you must organize your rule files in a folder structure that reflects the specified packages. Two KIE sessions are instantiated from theKBase1
KIE base, and one KIE session fromKBase2
. The KIE session fromKBase2
is astateless
KIE session, which means that data from a previous invocation of the KIE session (the previous session state) is discarded between session invocations. That KIE session also specifies a file (or a console) logger, aWorkItemHandler
, and listeners of the three supported types shown:ruleRuntimeEventListener
,agendaEventListener
andprocessEventListener
. The<configuration>
element defines optional properties that you can use to further customize yourkmodule.xml
file.As an alternative to manually appending a
kmodule.xml
file to your project, you can use aKieModuleModel
instance within your Java application to programmatically create akmodule.xml
file that defines the KIE base and a KIE session, and then add all resources in your project to the KIE virtual file systemKieFileSystem
.Creating
kmodule.xml
programmatically and adding it toKieFileSystem
import org.kie.api.KieServices; import org.kie.api.builder.model.KieModuleModel; import org.kie.api.builder.model.KieBaseModel; import org.kie.api.builder.model.KieSessionModel; import org.kie.api.builder.KieFileSystem; KieServices kieServices = KieServices.Factory.get(); KieModuleModel kieModuleModel = kieServices.newKieModuleModel(); KieBaseModel kieBaseModel1 = kieModuleModel.newKieBaseModel("KBase1") .setDefault(true) .setEqualsBehavior(EqualityBehaviorOption.EQUALITY) .setEventProcessingMode(EventProcessingOption.STREAM); KieSessionModel ksessionModel1 = kieBaseModel1.newKieSessionModel("KSession1_1") .setDefault(true) .setType(KieSessionModel.KieSessionType.STATEFUL) .setClockType(ClockTypeOption.get("realtime")); KieFileSystem kfs = kieServices.newKieFileSystem(); kfs.writeKModuleXML(kieModuleModel.toXML());
After you configure the
kmodule.xml
file either manually or programmatically in your project, retrieve the KIE bases and KIE sessions from the KIE container to verify the configurations:KieServices kieServices = KieServices.Factory.get(); KieContainer kContainer = kieServices.getKieClasspathContainer(); KieBase kBase1 = kContainer.getKieBase("KBase1"); KieSession kieSession1 = kContainer.newKieSession("KSession1_1"), kieSession2 = kContainer.newKieSession("KSession1_2"); KieBase kBase2 = kContainer.getKieBase("KBase2"); StatelessKieSession kieSession3 = kContainer.newStatelessKieSession("KSession2_1");
If
KieBase
orKieSession
have been configured asdefault="true"
in thekmodule.xml
file, as in the previouskmodule.xml
example, you can retrieve them from the KIE container without passing any names:KieContainer kContainer = ... KieBase kBase1 = kContainer.getKieBase(); KieSession kieSession1 = kContainer.newKieSession(), kieSession2 = kContainer.newKieSession(); KieBase kBase2 = kContainer.getKieBase(); StatelessKieSession kieSession3 = kContainer.newStatelessKieSession();
To increase or decrease the maximum number of KIE modules or artifact versions that are cached in the decision engine, you can modify the values of the following system properties in your Red Hat Decision Manager distribution:
-
kie.repository.project.cache.size
: Maximum number of KIE modules that are cached in the decision engine. Default value:100
-
kie.repository.project.versions.cache.size
: Maximum number of versions of the same artifact that are cached in the decision engine. Default value:10
For the full list of KIE repository configurations, download the Red Hat Process Automation Manager 7.13.5 Source Distribution ZIP file from the Red Hat Customer Portal and navigate to
~/rhpam-7.13.5-sources/src/drools-$VERSION/drools-compiler/src/main/java/org/drools/compiler/kie/builder/impl/KieRepositoryImpl.java
.-
For more information about the kmodule.xml
file, download the Red Hat Process Automation Manager 7.13.5 Source Distribution ZIP file from the Red Hat Customer Portal (if not downloaded already) and see the kmodule.xsd
XML schema located at $FILE_HOME/rhpam-$VERSION-sources/kie-api-parent-$VERSION/kie-api/src/main/resources/org/kie/api/
.
KieBase
or KiePackage
serialization is not supported in Red Hat Decision Manager 7.13. For more information, see Is serialization of kbase/package supported in BRMS 6/BPM Suite 6/RHDM 7?.
3.1.1. KIE module configuration properties
The optional <configuration>
element in the KIE module descriptor file (kmodule.xml
) of your project defines property key
and value
pairs that you can use to further customize your kmodule.xml
file.
Example configuration property in a kmodule.xml
file
<kmodule> ... <configuration> <property key="drools.dialect.default" value="java"/> ... </configuration> ... </kmodule>
The following are the <configuration>
property keys and values supported in the KIE module descriptor file (kmodule.xml
) for your project:
- drools.dialect.default
Sets the default Drools dialect.
Supported values:
java
,mvel
<property key="drools.dialect.default" value="java"/>
- drools.accumulate.function.$FUNCTION
Links a class that implements an accumulate function to a specified function name, which allows you to add custom accumulate functions into the decision engine.
<property key="drools.accumulate.function.hyperMax" value="org.drools.custom.HyperMaxAccumulate"/>
- drools.evaluator.$EVALUATION
Links a class that implements an evaluator definition to a specified evaluator name so that you can add custom evaluators into the decision engine. An evaluator is similar to a custom operator.
<property key="drools.evaluator.soundslike" value="org.drools.core.base.evaluators.SoundslikeEvaluatorsDefinition"/>
- drools.dump.dir
Sets a path to the Red Hat Decision Manager
dump/log
directory.<property key="drools.dump.dir" value="$DIR_PATH/dump/log"/>
- drools.defaultPackageName
Sets a default package for the business assets in your project.
<property key="drools.defaultPackageName" value="org.domain.pkg1"/>
- drools.parser.processStringEscapes
Sets the String escape function. If this property is set to
false
, the\n
character will not be interpreted as the newline character.Supported values:
true
(default),false
<property key="drools.parser.processStringEscapes" value="true"/>
- drools.kbuilder.severity.$DUPLICATE
Sets a severity for instances of duplicate rules, processes, or functions reported when a KIE base is built. For example, if you set
duplicateRule
toERROR
, then an error is generated for any duplicated rules detected when the KIE base is built.Supported key suffixes:
duplicateRule
,duplicateProcess
,duplicateFunction
Supported values:
INFO
,WARNING
,ERROR
<property key="drools.kbuilder.severity.duplicateRule" value="ERROR"/>
- drools.propertySpecific
Sets the property reactivity of the decision engine.
Supported values:
DISABLED
,ALLOWED
,ALWAYS
<property key="drools.propertySpecific" value="ALLOWED"/>
- drools.lang.level
Sets the DRL language level.
Supported values:
DRL5
,DRL6
,DRL6_STRICT
(default)<property key="drools.lang.level" value="DRL_STRICT"/>
3.1.2. KIE base attributes supported in KIE modules
A KIE base is a repository that you define in the KIE module descriptor file (kmodule.xml
) for your project and contains all rules and other business assets in Red Hat Decision Manager. When you define KIE bases in the kmodule.xml
file, you can specify certain attributes and values to further customize your KIE base configuration.
Example KIE base configuration in a kmodule.xml
file
<kmodule> ... <kbase name="KBase2" default="false" eventProcessingMode="stream" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg2, org.domain.pkg3" includes="KBase1" sequential="false"> ... </kbase> ... </kmodule>
The following are the kbase
attributes and values supported in the KIE module descriptor file (kmodule.xml
) for your project:
Attribute | Supported values | Description |
---|---|---|
| Any name |
Defines the name that retrieves |
| Comma-separated list of other KIE base objects in the KIE module |
Defines other KIE base objects and artifacts to be included in this KIE base. A KIE base can be contained in multiple KIE modules if you declare it as a dependency in the |
| Comma-separated list of packages to include in the KIE base
Default: |
Defines packages of artifacts (such as rules and processes) to be included in this KIE base. By default, all artifacts in the |
|
Default: | Determines whether a KIE base is the default KIE base for a module so that it can be created from the KIE container without passing any name. Each module can have only one default KIE base. |
|
Default: |
Defines the behavior of Red Hat Decision Manager when a new fact is inserted into the working memory. If set to |
|
Default: |
Determines how events are processed in the KIE base. If this property is set to |
|
Default: | Determines whether the declarative agenda is enabled or not. |
|
Default: | Determines whether sequential mode is enabled or not. In sequential mode, the decision engine evaluates rules one time in the order that they are listed in the decision engine agenda without regard to changes in the working memory. Enable this property if you use stateless KIE sessions and you do not want the execution of rules to influence subsequent rules in the agenda. |
3.1.3. KIE session attributes supported in KIE modules
A KIE session stores and executes runtime data and is created from a KIE base or directly from a KIE container if you have defined the KIE session in the KIE module descriptor file (kmodule.xml
) for your project. When you define KIE bases and KIE sessions in the kmodule.xml
file, you can specify certain attributes and values to further customize your KIE session configuration.
Example KIE session configuration in a kmodule.xml
file
<kmodule> ... <kbase> ... <ksession name="KSession2_1" type="stateless" default="true" clockType="realtime"> ... </kbase> ... </kmodule>
The following are the ksession
attributes and values supported in the KIE module descriptor file (kmodule.xml
) for your project:
Attribute | Supported values | Description |
---|---|---|
| Any name |
Defines the name that retrieves |
|
Default: |
Determines whether data is retained ( |
|
Default: | Determines whether a KIE session is the default session for a module so that it can be created from the KIE container without passing any name. Each module can have only one default KIE session. |
|
Default: | Determines whether event time stamps are assigned by the system clock or by a pseudo clock controlled by the application. This clock is especially useful for unit testing on temporal rules. |
|
Default: | Defines the type of belief system used by the KIE session. A belief system deduces the truth from knowledge (facts). For example, if a new fact is inserted based on another fact which is later removed from the decision engine, the system can determine that the newly inserted fact should be removed as well. |
3.2. Packaging and deploying a Red Hat Decision Manager project in Maven
If you want to deploy a Maven project outside of Business Central to a configured KIE Server, you can edit the project pom.xml
file to package your project as a KJAR file and add a kmodule.xml
file with the KIE base and KIE session configurations for the assets in your project.
Prerequisites
- You have a Maven project that contains Red Hat Decision Manager business assets.
-
KIE Server is installed and
kie-server
user access is configured. For installation options, see Planning a Red Hat Decision Manager installation.
Procedure
In the
pom.xml
file of your Maven project, set the packaging type tokjar
and add thekie-maven-plugin
build component:<packaging>kjar</packaging> ... <build> <plugins> <plugin> <groupId>org.kie</groupId> <artifactId>kie-maven-plugin</artifactId> <version>${rhpam.version}</version> <extensions>true</extensions> </plugin> </plugins> </build>
The
kjar
packaging type activates thekie-maven-plugin
component to validate and pre-compile artifact resources. The<version>
is the Maven artifact version for Red Hat Decision Manager currently used in your project (for example, 7.67.0.Final-redhat-00024). These settings are required to properly package the Maven project for deployment.NoteInstead of specifying a Red Hat Decision Manager
<version>
for individual dependencies, consider adding the Red Hat Business Automation bill of materials (BOM) dependency to your projectpom.xml
file. The Red Hat Business Automation BOM applies to both Red Hat Decision Manager and Red Hat Process Automation Manager. When you add the BOM files, the correct versions of transitive dependencies from the provided Maven repositories are included in the project.Example BOM dependency:
<dependency> <groupId>com.redhat.ba</groupId> <artifactId>ba-platform-bom</artifactId> <version>7.13.5.redhat-00002</version> <scope>import</scope> <type>pom</type> </dependency>
For more information about the Red Hat Business Automation BOM, see What is the mapping between Red Hat Process Automation Manager and the Maven library version?.
Optional: If your project contains Decision Model and Notation (DMN) assets, also add the following dependency in the
pom.xml
file to enable DMN executable models. DMN executable models enable DMN decision table logic in DMN projects to be evaluated more efficiently.<dependency> <groupId>org.kie</groupId> <artifactId>kie-dmn-core</artifactId> <scope>provided</scope> <version>${rhpam.version}</version> </dependency>
In the
~/resources
directory of your Maven project, create aMETA-INF/kmodule.xml
metadata file with at least the following content:<?xml version="1.0" encoding="UTF-8"?> <kmodule xmlns="http://www.drools.org/xsd/kmodule"> </kmodule>
This
kmodule.xml
file is a KIE module descriptor that is required for all Red Hat Decision Manager projects. You can use the KIE module to define one or more KIE bases and one or more KIE sessions from each KIE base.For more information about
kmodule.xml
configuration, see Section 3.1, “Configuring a KIE module descriptor file”.In the relevant resource in your Maven project, configure a
.java
class to create a KIE container and a KIE session to load the KIE base:import org.kie.api.KieServices; import org.kie.api.runtime.KieContainer; import org.kie.api.runtime.KieSession; public void testApp() { // Load the KIE base: KieServices ks = KieServices.Factory.get(); KieContainer kContainer = ks.getKieClasspathContainer(); KieSession kSession = kContainer.newKieSession(); }
In this example, the KIE container reads the files to be built from the class path for a
testApp
project. TheKieServices
API enables you to access all KIE building and runtime configurations.You can also create the KIE container by passing the project
ReleaseId
to theKieServices
API. TheReleaseId
is generated from theGroupId
,ArtifactId
, andVersion
(GAV) values in the projectpom.xml
file.import org.kie.api.KieServices; import org.kie.api.builder.ReleaseId; import org.kie.api.runtime.KieContainer; import org.kie.api.runtime.KieSession; import org.drools.compiler.kproject.ReleaseIdImpl; public void testApp() { // Identify the project in the local repository: ReleaseId rid = new ReleaseIdImpl("com.sample", "my-app", "1.0.0"); // Load the KIE base: KieServices ks = KieServices.Factory.get(); KieContainer kContainer = ks.newKieContainer(rid); KieSession kSession = kContainer.newKieSession(); }
In a command terminal, navigate to your Maven project directory and run the following command to build the project:
mvn clean install
For DMN executable models, run the following command:
mvn clean install -DgenerateDMNModel=YES
If the build fails, address any problems described in the command line error messages and try again to validate the files until the build is successful.
NoteIf the rule assets in your Maven project are not built from an executable rule model by default, verify that the following dependency is in the
pom.xml
file of your project and rebuild the project:<dependency> <groupId>org.drools</groupId> <artifactId>drools-model-compiler</artifactId> <version>${rhpam.version}</version> </dependency>
This dependency is required for rule assets in Red Hat Decision Manager to be built from executable rule models by default. This dependency is included as part of the Red Hat Decision Manager core packaging, but depending on your Red Hat Decision Manager upgrade history, you may need to manually add this dependency to enable the executable rule model behavior.
For more information about executable rule models, see Section 3.4, “Executable rule models”.
After you successfully build and test the project locally, deploy the project to the remote Maven repository:
mvn deploy
3.3. Packaging and deploying a Red Hat Decision Manager project in a Java application
If you want to deploy a project from within your own Java application to a configured KIE Server, you can use a KieModuleModel
instance to programmatically create a kmodule.xml
file that defines the KIE base and a KIE session, and then add all resources in your project to the KIE virtual file system KieFileSystem
.
Prerequisites
- You have a Java application that contains Red Hat Decision Manager business assets.
-
KIE Server is installed and
kie-server
user access is configured. For installation options, see Planning a Red Hat Decision Manager installation.
Procedure
Optional: If your project contains Decision Model and Notation (DMN) assets, add the following dependency to the relevant class path of your Java project to enable DMN executable models. DMN executable models enable DMN decision table logic in DMN projects to be evaluated more efficiently.
<dependency> <groupId>org.kie</groupId> <artifactId>kie-dmn-core</artifactId> <scope>provided</scope> <version>${rhpam.version}</version> </dependency>
The
<version>
is the Maven artifact version for Red Hat Decision Manager currently used in your project (for example, 7.67.0.Final-redhat-00024).NoteInstead of specifying a Red Hat Decision Manager
<version>
for individual dependencies, consider adding the Red Hat Business Automation bill of materials (BOM) dependency to your projectpom.xml
file. The Red Hat Business Automation BOM applies to both Red Hat Decision Manager and Red Hat Process Automation Manager. When you add the BOM files, the correct versions of transitive dependencies from the provided Maven repositories are included in the project.Example BOM dependency:
<dependency> <groupId>com.redhat.ba</groupId> <artifactId>ba-platform-bom</artifactId> <version>7.13.5.redhat-00002</version> <scope>import</scope> <type>pom</type> </dependency>
For more information about the Red Hat Business Automation BOM, see What is the mapping between Red Hat Process Automation Manager and the Maven library version?.
Use the
KieServices
API to create aKieModuleModel
instance with the desired KIE base and KIE session. TheKieServices
API enables you to access all KIE building and runtime configurations. TheKieModuleModel
instance generates thekmodule.xml
file for your project.For more information about
kmodule.xml
configuration, see Section 3.1, “Configuring a KIE module descriptor file”.Convert your
KieModuleModel
instance into XML and add the XML toKieFileSystem
.Creating
kmodule.xml
programmatically and adding it toKieFileSystem
import org.kie.api.KieServices; import org.kie.api.builder.model.KieModuleModel; import org.kie.api.builder.model.KieBaseModel; import org.kie.api.builder.model.KieSessionModel; import org.kie.api.builder.KieFileSystem; KieServices kieServices = KieServices.Factory.get(); KieModuleModel kieModuleModel = kieServices.newKieModuleModel(); KieBaseModel kieBaseModel1 = kieModuleModel.newKieBaseModel("KBase1") .setDefault(true) .setEqualsBehavior(EqualityBehaviorOption.EQUALITY) .setEventProcessingMode(EventProcessingOption.STREAM); KieSessionModel ksessionModel1 = kieBaseModel1.newKieSessionModel("KSession1") .setDefault(true) .setType(KieSessionModel.KieSessionType.STATEFUL) .setClockType(ClockTypeOption.get("realtime")); KieFileSystem kfs = kieServices.newKieFileSystem(); kfs.writeKModuleXML(kieModuleModel.toXML());
Add any remaining Red Hat Decision Manager assets that you use in your project to your
KieFileSystem
instance. The artifacts must be in a Maven project file structure.import org.kie.api.builder.KieFileSystem; KieFileSystem kfs = ... kfs.write("src/main/resources/KBase1/ruleSet1.drl", stringContainingAValidDRL) .write("src/main/resources/dtable.xls", kieServices.getResources().newInputStreamResource(dtableFileStream));
In this example, the project assets are added both as a
String
variable and as aResource
instance. You can create theResource
instance using theKieResources
factory, also provided by theKieServices
instance. TheKieResources
class provides factory methods to convertInputStream
,URL
, andFile
objects, or aString
representing a path of your file system to aResource
instance that theKieFileSystem
can manage.You can also explicitly assign a
ResourceType
property to aResource
object when you add project artifacts toKieFileSystem
:import org.kie.api.builder.KieFileSystem; KieFileSystem kfs = ... kfs.write("src/main/resources/myDrl.txt", kieServices.getResources().newInputStreamResource(drlStream) .setResourceType(ResourceType.DRL));
Use
KieBuilder
with thebuildAll()
method to build the content ofKieFileSystem
, and create a KIE container to deploy it:import org.kie.api.KieServices; import org.kie.api.KieServices.Factory; import org.kie.api.builder.KieFileSystem; import org.kie.api.builder.KieBuilder; import org.kie.api.runtime.KieContainer; KieServices kieServices = KieServices.Factory.get(); KieFileSystem kfs = ... KieBuilder kieBuilder = ks.newKieBuilder( kfs ); kieBuilder.buildAll() assertEquals(0, kieBuilder.getResults().getMessages(Message.Level.ERROR).size()); KieContainer kieContainer = kieServices .newKieContainer(kieServices.getRepository().getDefaultReleaseId());
A build
ERROR
indicates that the project compilation failed, noKieModule
was produced, and nothing was added to theKieRepository
singleton. AWARNING
or anINFO
result indicates that the compilation of the project was successful, with information about the build process.NoteTo build the rule assets in your Java application project from an executable rule model, verify that the following dependency is in the
pom.xml
file of your project:<dependency> <groupId>org.drools</groupId> <artifactId>drools-model-compiler</artifactId> <version>${rhpam.version}</version> </dependency>
This dependency is required for rule assets in Red Hat Decision Manager to be built from executable rule models. This dependency is included as part of the Red Hat Decision Manager core packaging, but depending on your Red Hat Decision Manager upgrade history, you may need to manually add this dependency to enable the executable rule model behavior.
After you verify the dependency, use the following modified
buildAll()
option to enable the executable model:kieBuilder.buildAll(ExecutableModelProject.class)
For more information about executable rule models, see Section 3.4, “Executable rule models”.
3.4. Executable rule models
Rule assets in Red Hat Decision Manager are built from executable rule models by default with the standard kie-maven-plugin
plugin. Executable rule models are embedded models that provide a Java-based representation of a rule set for execution at build time. The executable model is a more efficient alternative to the standard asset packaging in previous versions of Red Hat Decision Manager and enables KIE containers and KIE bases to be created more quickly, especially when you have large lists of DRL (Drools Rule Language) files and other Red Hat Decision Manager assets.
If you do not use the kie-maven-plugin
plugin or if the required drools-model-compiler
dependency is missing from your project, then rule assets are built without executable models. Therefore, to generate the executable model during build time, ensure that the kie-maven-plugin
plugin and drools-model-compiler
dependency are added in your project pom.xml
file.
Executable rule models provide the following specific advantages for your projects:
-
Compile time: Traditionally, a packaged Red Hat Decision Manager project (KJAR) contains a list of DRL files and other Red Hat Decision Manager artifacts that define the rule base together with some pre-generated classes implementing the constraints and the consequences. Those DRL files must be parsed and compiled when the KJAR is downloaded from the Maven repository and installed in a KIE container. This process can be slow, especially for large rule sets. With an executable model, you can package within the project KJAR the Java classes that implement the executable model of the project rule base and re-create the KIE container and its KIE bases out of it in a much faster way. In Maven projects, you use the
kie-maven-plugin
plugin to automatically generate the executable model sources from the DRL files during the compilation process. -
Run time: In an executable model, all constraints are defined as Java lambda expressions. The same lambda expressions are also used for constraints evaluation, so you no longer need to use
mvel
expressions for interpreted evaluation nor the just-in-time (JIT) process to transform themvel
-based constraints into bytecode. This creates a quicker and more efficient run time. - Development time: An executable model enables you to develop and experiment with new features of the decision engine without needing to encode elements directly in the DRL format or modify the DRL parser to support them.
For query definitions in executable rule models, you can use up to 10 arguments only.
For variables within rule consequences in executable rule models, you can use up to 24 bound variables only (including the built-in drools
variable). For example, the following rule consequence uses more than 24 bound variables and creates a compilation error:
... then $input.setNo25Count(functions.sumOf(new Object[]{$no1Count_1, $no2Count_1, $no3Count_1, ..., $no25Count_1}).intValue()); $input.getFirings().add("fired"); update($input);
3.4.1. Modifying or disabling executable rule models in a Red Hat Decision Manager project
Rule assets in Red Hat Decision Manager are built from executable rule models by default with the standard kie-maven-plugin
plugin. The executable model is a more efficient alternative to the standard asset packaging in previous versions of Red Hat Decision Manager. However, if needed, you can modify or disable executable rule models to build a Red Hat Decision Manager project as a DRL-based KJAR instead of the default model-based KJAR.
Procedure
Build your Red Hat Decision Manager project in the usual way, but provide an alternate build option, depending on the type of project:
For a Maven project, navigate to your Maven project directory in a command terminal and run the following command:
mvn clean install -DgenerateModel=<VALUE>
Replace
<VALUE>
with one of three values:-
YES_WITHDRL
: (Default) Generates the executable model corresponding to the DRL files in the original project and also adds the DRL files to the generated KJAR for documentation purposes (the KIE base is built from the executable model regardless). -
YES
: Generates the executable model corresponding to the DRL files in the original project and excludes the DRL files from the generated KJAR. -
NO
: Does not generate the executable model.
Example build command to disable the default executable model behavior:
mvn clean install -DgenerateModel=NO
-
For a Java application configured programmatically, the executable model is disabled by default. Add rule assets to the KIE virtual file system
KieFileSystem
and useKieBuilder
with one of the followingbuildAll()
methods:-
buildAll()
(Default) orbuildAll(DrlProject.class)
: Does not generate the executable model. -
buildAll(ExecutableModelProject.class)
: Generates the executable model corresponding to the DRL files in the original project.
Example code to enable executable model behavior:
import org.kie.api.KieServices; import org.kie.api.builder.KieFileSystem; import org.kie.api.builder.KieBuilder; KieServices ks = KieServices.Factory.get(); KieFileSystem kfs = ks.newKieFileSystem() kfs.write("src/main/resources/KBase1/ruleSet1.drl", stringContainingAValidDRL) .write("src/main/resources/dtable.xls", kieServices.getResources().newInputStreamResource(dtableFileStream)); KieBuilder kieBuilder = ks.newKieBuilder( kfs ); // Enable executable model kieBuilder.buildAll(ExecutableModelProject.class) assertEquals(0, kieBuilder.getResults().getMessages(Message.Level.ERROR).size());
-
3.5. Using a KIE scanner to monitor and update KIE containers
The KIE scanner in Red Hat Decision Manager monitors your Maven repository for new SNAPSHOT
versions of your Red Hat Decision Manager project and then deploys the latest version of the project to a specified KIE container. You can use a KIE scanner in a development environment to maintain your Red Hat Decision Manager project deployments more efficiently as new versions become available.
For production environments, do not use a KIE scanner with SNAPSHOT
project versions to avoid accidental or unexpected project updates. The KIE scanner is intended for development environments that use SNAPSHOT
project versions.
Prerequisites
-
The
kie-ci.jar
file is available on the class path of your Red Hat Decision Manager project.
Procedure
In the relevant
.java
class in your project, register and start the KIE scanner as shown in the following example code:Registering and starting a KIE scanner for a KIE container
import org.kie.api.KieServices; import org.kie.api.builder.ReleaseId; import org.kie.api.runtime.KieContainer; import org.kie.api.builder.KieScanner; ... KieServices kieServices = KieServices.Factory.get(); ReleaseId releaseId = kieServices .newReleaseId("com.sample", "my-app", "1.0-SNAPSHOT"); KieContainer kContainer = kieServices.newKieContainer(releaseId); KieScanner kScanner = kieServices.newKieScanner(kContainer); // Start KIE scanner for polling the Maven repository every 10 seconds (10000 ms) kScanner.start(10000L);
In this example, the KIE scanner is configured to run with a fixed time interval. The minimum KIE scanner polling interval is 1 millisecond (ms) and the maximum polling interval is the maximum value of the data type
long
. A polling interval of 0 or less results in ajava.lang.IllegalArgumentException: pollingInterval must be positive
error. You can also configure the KIE scanner to run on demand by invoking thescanNow()
method.The project group ID, artifact ID, and version (GAV) settings in the example are defined as
com.sample:my-app:1.0-SNAPSHOT
. The project version must contain the-SNAPSHOT
suffix to enable the KIE scanner to retrieve the latest build of the specified artifact version. If you change the snapshot project version number, such as increasing to1.0.1-SNAPSHOT
, then you must also update the version in the GAV definition in your KIE scanner configuration. The KIE scanner does not retrieve updates for projects with static versions, such ascom.sample:my-app:1.0
.In the
settings.xml
file of your Maven repository, set theupdatePolicy
configuration toalways
to enable the KIE scanner to function properly:<profile> <id>guvnor-m2-repo</id> <repositories> <repository> <id>guvnor-m2-repo</id> <name>BA Repository</name> <url>http://localhost:8080/business-central/maven2/</url> <layout>default</layout> <releases> <enabled>true</enabled> <updatePolicy>always</updatePolicy> </releases> <snapshots> <enabled>true</enabled> <updatePolicy>always</updatePolicy> </snapshots> </repository> </repositories> </profile>
After the KIE scanner starts polling, if the KIE scanner detects an updated version of the
SNAPSHOT
project in the specified KIE container, the KIE scanner automatically downloads the new project version and triggers an incremental build of the new project. From that moment, all of the newKieBase
andKieSession
objects that were created from the KIE container use the new project version.For information about starting or stopping a KIE scanner using KIE Server APIs, see Interacting with Red Hat Decision Manager using KIE APIs.
3.6. Starting a service in KIE Server
If you have deployed Red Hat Decision Manager assets from a Maven or Java project outside of Business Central, you use a KIE Server REST API call to start the KIE container (deployment unit) and the services in it. You can use the KIE Server REST API to start services regardless of your deployment type, including deployment from Business Central, but projects deployed from Business Central either are started automatically or can be started within the Business Central interface.
Prerequisites
-
KIE Server is installed and
kie-server
user access is configured. For installation options, see Planning a Red Hat Decision Manager installation.
Procedure
In your command terminal, run the following API request to load a service into a KIE container in KIE Server and to start it:
$ curl --user "<username>:<password>" -H "Content-Type: application/json" -X PUT -d '{"container-id" : "<containerID>","release-id" : {"group-id" : "<groupID>","artifact-id" : "<artifactID>","version" : "<version>"}}' http://<serverhost>:<serverport>/kie-server/services/rest/server/containers/<containerID>
Replace the following values:
-
<username>, <password>: The user name and password of a user with the
kie-server
role. - <containerID>: The identifier for the KIE container (deployment unit). You can use any random identifier but it must be the same in both places in the command (the URL and the data).
- <groupID>, <artifactID>, <version>: The project GAV values.
-
<serverhost>: The host name for KIE Server, or
localhost
if you are running the command on the same host as KIE Server. - <serverport>: The port number for KIE Server.
Example:
curl --user "rhpamAdmin:password@1" -H "Content-Type: application/json" -X PUT -d '{"container-id" : "kie1","release-id" : {"group-id" : "org.kie.server.testing","artifact-id" : "container-crud-tests1","version" : "2.1.0.GA"}}' http://localhost:39043/kie-server/services/rest/server/containers/kie1
3.7. Stopping and removing a service in KIE Server
If you have started Red Hat Decision Manager services from a Maven or Java project outside of Business Central, you use a KIE Server REST API call to stop and remove the KIE container (deployment unit) containing the services. You can use the KIE Server REST API to stop services regardless of your deployment type, including deployment from Business Central, but services from Business Central can also be stopped within the Business Central interface.
Prerequisites
-
KIE Server is installed and
kie-server
user access is configured. For installation options, see Planning a Red Hat Decision Manager installation.
Procedure
In your command terminal, run the following API request to stop and remove a KIE container with services on KIE Server:
$ curl --user "<username>:<password>" -X DELETE http://<serverhost>:<serverport>/kie-server/services/rest/server/containers/<containerID>
Replace the following values:
-
<username>, <password>: The user name and password of a user with the
kie-server
role. - <containerID>: The identifier for the KIE container (deployment unit). You can use any random identifier but it must be the same in both places in the command (the URL and the data).
-
<serverhost>: The host name for KIE Server, or
localhost
if you are running the command on the same host as KIE Server. - <serverport>: The port number for KIE Server.
Example:
curl --user "rhpamAdmin:password@1" -X DELETE http://localhost:39043/kie-server/services/rest/server/containers/kie1