Skip to main content

Business Rules

The Rules Engine is a dedicated microservice within the SureInk Platform responsible for managing and executing business rules. It leverages the Drools Rule Engine (part of KIE - Knowledge Is Everything) to provide a flexible and centralized way to define and apply complex business logic across various domains such as licensing, payments, cart operations, and user/product/subscription management.

This service integrates with the broader SureInk ecosystem, including service discovery via Eureka, security via Keycloak, messaging via Kafka, and persistence via PostgreSQL.

Technology Stack​

  • Core Framework: Java, Spring Boot
    • Spring Web (for REST APIs)
    • Spring Data JPA (for database interaction)
    • Spring Security
  • Rules Engine:
    • Drools Core (org.drools:drools-core)
    • KIE Spring Integration (org.kie:kie-spring)
  • Database:
    • PostgreSQL
    • Liquibase (for schema migrations)
  • Spring Cloud:
    • Spring Cloud Netflix Eureka Client (for service discovery)
  • Messaging: Apache Kafka (spring-kafka)
  • Security: Keycloak (integrated via keycloak-spring-boot-starter)
  • Monitoring & Metrics:
    • Spring Boot Actuator
    • JavaMelody
    • Micrometer Prometheus
  • Internal Libraries:
    • sureink-common
    • sureink-common-model
    • sureink-model (providing core domain entities like Customer, Product, License)

Key Functionalities​

  • Business Rule Execution: Evaluates business rules defined in Drools DRL files based on input data (facts).
  • Centralized Rule Management: Provides a central point for defining, updating, and managing business logic related to:
    • Licensing (e.g., entitlement checks, activation rules) - see license-rule.drl
    • Payment processing (e.g., fraud detection, fee calculations) - see payment-rule.drl
    • Shopping cart operations (e.g., promotions, validations) - see cart-rule.drl
    • User and device management (e.g., device limits, access rules) - see user-device-rule.drl
    • Product, subscription, and user-specific logic (see product/, subscription/, user/ subdirectories in src/main/resources/rules/)
  • API Endpoints: Exposes REST APIs (via controller/ package) for other services to:
    • Submit data (facts) for rule evaluation.
    • Potentially manage or query rule sets (if supported).
  • Event-Driven Rule Evaluation: Listens to Kafka topics (via listener/ package) to trigger rule evaluations based on platform events.
  • Data Persistence: May store rule definitions, rule execution history, or related metadata in its PostgreSQL database (via repository/ package).

Project Structure​

  • RulesEngineApplication.java: The main Spring Boot application class.
  • com.sureink.RuleConfiguration.java: Configures the Drools KIE services (e.g., KieContainer, KieSession), likely by scanning for DRL files in src/main/resources/rules/.
  • com.sureink.cloudmsa.rules/: The core package for the rules engine logic.
    • controller/: Spring MVC controllers defining REST APIs.
    • service/: Business logic layer that interacts with the Drools engine (e.g., loading facts, firing rules, processing results).
    • listener/: Kafka consumers that trigger rule evaluations.
    • repository/: JPA repositories for data persistence.
    • model/: DTOs and internal models for rule inputs/outputs.
    • client/: Feign clients for interacting with other services.
  • src/main/resources/rules/: Contains the Drools DRL files and subdirectories with further rule definitions. This is where the business logic is encoded.
    • cart-rule.drl
    • license-rule.drl
    • payment-rule.drl
    • user-device-rule.drl
    • product/ (subdirectory for product-related rules)
    • subscription/ (subdirectory for subscription-related rules)
    • user/ (subdirectory for user-related rules)
  • src/main/resources/db/changelog/: Liquibase changelogs for managing the service's database schema.

API Endpoints & Kafka Topics​

  • REST APIs: Defined in controllers within com.sureink.cloudmsa.rules.controller. These APIs allow other services to trigger rule evaluations and retrieve results.
  • Kafka Topics: The service consumes messages from specific Kafka topics (configured in com.sureink.KafkaConsumerConfig.java and handled by listeners in com.sureink.cloudmsa.rules.listener) to initiate rule processing based on platform events. It may also produce events to other topics (via com.sureink.KafkaProducerConfig.java).

(Refer to the specific classes for exact API endpoint details, DTOs, Kafka topic names, and consumed/produced event structures.)

Configuration​

Key configuration areas (typically in application.properties or application.yml, or provided by a Spring Cloud Config server if used):

  • Database Connection: PostgreSQL connection details.
  • Eureka Client: Eureka server address.
  • Keycloak: Keycloak server URL, realm, client ID, and credentials.
  • Apache Kafka: Broker addresses, consumer group IDs, and relevant topic names.
  • Drools Configuration: The RuleConfiguration.java handles the setup of KIE services, pointing to the DRL files in src/main/resources/rules/.

Prerequisites​

  • JDK 11 or later
  • Apache Maven
  • Access to a running PostgreSQL instance
  • Access to a running Keycloak instance
  • Access to a running Apache Kafka cluster
  • Access to a running Eureka server

Build Instructions​

cd path/to/sureink-rules-engine
mvn clean install

Running the Application​

java -jar target/sureink-rules-engine-1.0-SNAPSHOT.jar

Ensure all prerequisite services (Database, Eureka, Keycloak, Kafka) are running and configurations are correctly set up.

Dockerization​

The pom.xml includes profiles for building Docker images using docker-maven-plugin, indicating that this service is intended to be containerized.