基于Siddhi规则引擎的通用规则接口与规则持久化方案咨询

Great question! I've worked with Siddhi in production scenarios that required exactly these two capabilities, so let me break down practical solutions for both requirements:

Siddhi doesn’t handle user-created rule persistence out of the box, but you have two robust approaches to solve this:

• Leverage Siddhi's Built-in State Persistence
  Siddhi supports state persistence via its State Store abstraction, which lets you persist both rule execution state and the rules themselves. Configure a persistent store (like RDBMS, Redis, or Cassandra) instead of the default in-memory store. For example, a PostgreSQL state store configuration would look like this:

  stateStores:
    - name: persistentStore
      type: rdbms
      properties:
        datasource: postgres-datasource
        tablePrefix: siddhi_state_
  

  Bind your streams/queries to this store using the @Store annotation:

  @Store(type="persistentStore")
  define stream TemperatureReading(deviceId string, temperature double);
  

  This ensures that if the node restarts, Siddhi automatically reloads state and rules from the persistent store.

• Implement a Custom Rule Persistence Layer
  For full control, build a separate persistence layer (using PostgreSQL, MongoDB, etc.) to store raw user-defined rules (either your simplified DSL or converted SiddhiQL). On node startup:

  1. Fetch all persisted rules from your database.
  2. Convert them to valid SiddhiQL (if using a custom DSL).
  3. Deploy each rule to the Siddhi engine programmatically via the Siddhi Manager API.
  4. Add transaction support to rule CRUD operations to avoid partial persistence during failures.

  Pro tip: Add versioning to stored rules so you can roll back to previous versions if a new rule causes issues.

The key is to abstract Siddhi’s complex query language into a user-friendly, business-aligned DSL (Domain-Specific Language). Here’s how to implement this:

• Design a Simplified DSL
  Create a JSON/YAML format using natural, business-oriented terms. For example, a high-temperature alert rule might look like this:

  {
    "ruleId": "temp_alert_001",
    "name": "High Temperature Alert",
    "eventSource": "DeviceTelemetry",
    "conditions": [
      {
        "field": "temperature",
        "operator": ">",
        "value": 30
      }
    ],
    "window": {
      "type": "time",
      "duration": "5m"
    },
    "action": {
      "type": "SEND_ALERT",
      "parameters": {
        "message": "Device {{deviceId}} has reached {{temperature}}°C for 5 minutes",
        "recipient": "maintenance-team@example.com"
      }
    }
  }
  

• Build a DSL-to-SiddhiQL Converter
  Write a service that translates your simplified DSL to valid SiddhiQL. For the example above, the converter would generate:

  @App:name('HighTemperatureAlert')
  define stream DeviceTelemetry(deviceId string, temperature double, timestamp long);
  
  @info(name='TempCheckQuery')
  from DeviceTelemetry[temperature > 30]#window.time(5m)
  select deviceId, temperature
  insert into AlertStream;
  
  @info(name='AlertAction')
  from AlertStream
  select concat('Device ', deviceId, ' has reached ', temperature, '°C for 5 minutes') as message, 'maintenance-team@example.com' as recipient
  insert into SendAlertStream;
  

  Add validation logic to catch invalid rules (e.g., non-existent fields, invalid operators) before they reach Siddhi.

• Expose a REST API for Rule Management
  Wrap the converter and persistence layer in a REST API with CRUD endpoints:

  • POST /api/rules: Submit a new rule in your DSL format.
  • GET /api/rules: List all existing rules.
  • PUT /api/rules/{ruleId}: Update an existing rule.
  • DELETE /api/rules/{ruleId}: Remove a rule.
    This lets users manage rules without ever interacting with SiddhiQL directly.

• Add a Visual Rule Editor (Optional)
  For even better usability, build a drag-and-drop UI that lets users construct rules visually (e.g., select event sources, add conditions, choose actions). The UI generates your DSL format behind the scenes, which then converts to SiddhiQL.

• Test rule persistence thoroughly: Simulate node restarts and failures to ensure rules are correctly restored.
• Use asynchronous rule deployment: Don’t block user requests while deploying rules to Siddhi.
• Log conversion and deployment events: This helps debug issues when rules don’t behave as expected.

内容的提问来源于stack exchange，提问作者Yogesh BG