process-timer-quarkus

Process timers

Description

A quickstart project shows use of timer based activities within the process to allow a flexible delays before continuing process execution. There are two types of timers used in this quick start

• intermediate timer event - used as part of the regular process flow to introduce delays
• boundary timer event - used as an option to move process flow through alternative path after expiration time

This example shows

• working with timers (both intermediate and boundary)

• optionally use Job Service that allows to externalize time tracking to separate service and by that offload the runtime service

• Intermediate timer event (timers.bpmn)

• Intermediate timer Diagram Properties (top)

• Intermediate timer Diagram Properties (bottom)

• Intermediate timer Before Timer

• Intermediate timer Timer

• Intermediate timer After Timer

• Boundary timer event (timer-on-task.bpmn)

• Boundary timer Diagram Properties (top)

• Boundary timer Diagram Properties (bottom)

• Boundary timer Before Timer

• Boundary timer User Task (top)

• Boundary timer User Task (bottom)

• Boundary timer Timer

• Boundary timer After Timer

• Cycle timer event (timerCycle.bpmn)

• Cycle timer Diagram Properties (top)

• Cycle timer Diagram Properties (bottom)

• Cycle timer Before Timer

• Cycle timer Timer

• Cycle timer AfterTimer

Timer expression is expected to be given in ISO-8601 format e.g. PT30S - wait 30 seconds before expiring. This needs to be given when starting process instance as delay attribute of type string.

Build and run

Prerequisites

You will need:

• Java 11+ installed
• Environment variable JAVA_HOME set accordingly
• Maven 3.8.6+ installed

When using native image compilation, you will also need:

• GraalVM 19.3+ installed
• Environment variable GRAALVM_HOME set accordingly
• GraalVM native image needs as well native-image extension: https://www.graalvm.org/reference-manual/native-image/
• Note that GraalVM native image compilation typically requires other packages (glibc-devel, zlib-devel and gcc) to be installed too, please refer to GraalVM installation documentation for more details.

Start Kogito Job Service

You need to download the job service and start it locally

You can download it from [Select Latest Version] https://repo.maven.apache.org/maven2/org/kie/kogito/jobs-service/

java -Dquarkus.http.port=8085 -jar jobs-service-common/target/jobs-service-common-{version}-runner.jar

• After Starting Kogito Web Service you should see a similar Log as follows

In case you'd like to run the job service with enabled persistence then start Infinispan server before and then run the job service with following command

Download Infinispan Server from https://infinispan.org/download/

Start Infinispan Server [Infinispan Directory]/bin/sh server.sh

java -Dquarkus.http.port=8085 -jar jobs-service-infinispan/target/jobs-service-infinispan-{version}-runner.jar

• After Starting Infinispan you should see a similar Log as follows

If you'd like to use PostgresSQL or MongoDB as persistence, start the PostgreSQL or MongoDB server, then start job service with following command

For PostgreSQL:

java -Dquarkus.http.port=8085 -Dquarkus.datasource.username={username} -Dquarkus.datasource.password={password} -Dquarkus.datasource.reactive.url=postgresql://{host}:{port}/{db} -Dquarkus.datasource.jdbc.url=jdbc:postgresql://{host}:{port}/{db}  -jar jobs-service-postgresql/target/jobs-service-postgresql-{version}-runner.jar

For MongoDB:

java -Dquarkus.http.port=8085 -Dquarkus.mongodb.connection-string=mongodb://{username}:{password}@{host}:{port} -Dquarkus.mongodb.database={db} -jar jobs-service-mongodb/target/jobs-service-mongodb-{version}-runner.jar

In all cases replace {version} with actual Kogito version to be used (Job Service is available from 0.6.0)

After that you can redo the timer queries described above.

Kogito Jobs Service configuration into the application

To be able to use Kogito Job Service as timer service , an additional dependency is needed into the pom.xml file:

<dependency>
  <groupId>org.kie.kogito</groupId>
  <artifactId>kogito-addons-quarkus-jobs-management</artifactId>
</dependency>

Then, to allow to use Job Service as timer service there is a need to specify some properties in the src/main/application.properties file:

kogito.jobs-service.url=http://localhost:8085
kogito.service.url=http://localhost:8080

First one is used to direct the Kogito runtime to let it know where is the Kogito Job Service - it needs to match the location of the Kogito Job Service when starting it - see below.
Second one is used by Kogito Job Service to callback when the timer expires and needs to be pointing to the service host and port

Compile and Run in Local Dev Mode

mvn clean compile quarkus:dev

NOTE: With dev mode of Quarkus you can take advantage of hot reload for business assets like processes, rules, decision tables and java code. No need to redeploy or restart your running application.

Package and Run in JVM mode

mvn clean package
java -jar target/quarkus-app/quarkus-run.jar

or on windows

mvn clean package 
java -jar target\quarkus-app\quarkus-run.jar 

Package and Run using Local Native Image

Note that this requires GRAALVM_HOME to point to a valid GraalVM installation

mvn clean package -Pnative

To run the generated native executable, generated in target/, execute

./target/process-timer-quarkus-runner

OpenAPI (Swagger) documentation

Specification at swagger.io

You can take a look at the OpenAPI definition - automatically generated and included in this service - to determine all available operations exposed by this service. For easy readability you can visualize the OpenAPI definition file using a UI tool like for example available Swagger UI.

In addition, various clients to interact with this service can be easily generated using this OpenAPI definition.

When running in either Quarkus Development or Native mode, we also leverage the Quarkus OpenAPI extension that exposes Swagger UI that you can use to look at available REST endpoints and send test requests.

Submit a request to start new timers process

To make use of this application it is as simple as putting a sending request to http://localhost:8080/timers with following content

{
    "delay" : "PT30S"
}

Complete curl command can be found below:

curl -X POST -H 'Content-Type:application/json' -H 'Accept:application/json' -d '{"delay" : "PT30S"}' http://localhost:8080/timers

Show active timer instances

curl -H 'Content-Type:application/json' -H 'Accept:application/json' http://localhost:8080/timers

Cancel timer instance

curl -X DELETE 'http://localhost:8080/timers/{uuid}'

where {uuid} is the id of the given timer instance

Submit a request to start new timers cycle process

To make use of this application it is as simple as putting a sending request to http://localhost:8080/timerscycle with following content

{
    "delay" : "R2/PT1S"
}

Complete curl command can be found below:

curl -X POST -H 'Content-Type:application/json' -H 'Accept:application/json' -d '{"delay" : "R2/PT1S"}' http://localhost:8080/timerscycle

Show active timer instances

curl -H 'Content-Type:application/json' -H 'Accept:application/json' http://localhost:8080/timerscycle

Cancel timer cycle instance

curl -X DELETE 'http://localhost:8080/timerscycle/{uuid}'

where {uuid} is the id of the given timer cycle instance

Submit a request to start new boundary timers process

To make use of this application it is as simple as putting a sending request to http://localhost:8080/timersOnTask with following content

{
    "delay" : "PT30S"
}

Complete curl command can be found below:

curl -X POST -H 'Content-Type:application/json' -H 'Accept:application/json' -d '{"delay" : "PT30S"}' http://localhost:8080/timersOnTask

Show active boundary timer instances

curl -H 'Content-Type:application/json' -H 'Accept:application/json' http://localhost:8080/timersOnTask

Cancel boundary timer instance

curl -X DELETE 'http://localhost:8080/timersOnTask/{uuid}'

where {uuid} is the id of the given timer instance

After executing the above commands you should see a log similar to

• Quarkus Log

Before timer... waiting for  PT30S
After Timer
Before timer, waiting for task to be complete or expires in PT30S
After Timer
Before timer... waiting for  R2/PT1S
After Timer
After Timer

Deploy on OpenShift

This example can run on OpenShift 4 instance. Use Kogito operator to deploy this example and instantiate also the Jobs service. Kogito operator will take care of configuring this example to successfully connect to the Jobs service.

In the operator directory you'll find the custom resources needed to deploy this example on OpenShift with the Kogito Operator.