Architecture

// Client creates workflow stub and calls methods
val client = InfiniticClient.fromYamlResource("/config.yml")
val workflow = client.newWorkflow(OrderWorkflow::class.java)
val result = workflow.processOrder(orderId)

class PaymentServiceImpl : PaymentService {
    override fun charge(orderId: String, amount: Double): PaymentResult {
        // Execute actual payment logic
        return paymentGateway.process(orderId, amount)
    }
}

class OrderWorkflowImpl : Workflow(), OrderWorkflow {
    private val paymentService = newService(PaymentService::class.java)
    
    override fun processOrder(orderId: String): OrderResult {
        // Workflow orchestration logic
        val payment = paymentService.charge(orderId, 99.99)
        return OrderResult(payment.transactionId)
    }
}

infinitic/dev/service-executor/PaymentService
infinitic/dev/service-tag-engine/PaymentService
infinitic/dev/workflow-executor/OrderWorkflow
infinitic/dev/workflow-state-engine/OrderWorkflow
infinitic/dev/workflow-state-cmd/OrderWorkflow
infinitic/dev/workflow-tag-engine/OrderWorkflow

// Workflow state is stored as binary
interface WorkflowStateStorage {
    suspend fun getState(workflowId: WorkflowId): WorkflowState?
    suspend fun updateState(workflowId: WorkflowId, state: WorkflowState)
    suspend fun deleteState(workflowId: WorkflowId)
}

# Scale to 3 workers
kubectl scale deployment infinitic-worker --replicas=3

workflows:
  - name: OrderWorkflow
    concurrency: 50              # Parallel workflow tasks
    stateEngine:
      concurrency: 20            # State engine concurrency

services:
  - name: EmailService
    batch:
      maxMessages: 100           # Batch up to 100 messages
      maxSeconds: 1              # Or every 1 second

# All-in-one worker
services:
  - name: PaymentService
    class: com.example.PaymentServiceImpl
    concurrency: 10
    tagEngine:
      concurrency: 5

workflows:
  - name: OrderWorkflow
    class: com.example.OrderWorkflowImpl
    concurrency: 5
    stateEngine:
      concurrency: 10
    tagEngine:
      concurrency: 5

# Worker 1: Service executors only
services:
  - name: PaymentService
    class: com.example.PaymentServiceImpl
    concurrency: 50

# Worker 2: Workflow executors only
workflows:
  - name: OrderWorkflow
    class: com.example.OrderWorkflowImpl
    concurrency: 20

# Worker 3: Engines only
services:
  - name: PaymentService
    tagEngine:
      concurrency: 10

workflows:
  - name: OrderWorkflow
    stateEngine:
      concurrency: 20
    tagEngine:
      concurrency: 10

apiVersion: apps/v1
kind: Deployment
metadata:
  name: infinitic-worker
spec:
  replicas: 3
  selector:
    matchLabels:
      app: infinitic-worker
  template:
    metadata:
      labels:
        app: infinitic-worker
    spec:
      containers:
      - name: worker
        image: myorg/infinitic-worker:latest
        env:
        - name: INFINITIC_CONFIG
          value: /config/infinitic.yml
        volumeMounts:
        - name: config
          mountPath: /config
      volumes:
      - name: config
        configMap:
          name: infinitic-config

class MyEventListener : CloudEventListener {
    override fun onEvent(event: CloudEvent) {
        when (event.type) {
            "task.started" -> metricsClient.increment("task.started")
            "task.completed" -> {
                metricsClient.increment("task.completed")
                val duration = event.extensionNames.get("duration")
                metricsClient.recordDuration("task.duration", duration)
            }
            "workflow.completed" -> {
                alertingClient.sendSuccess(event.source, event.id)
            }
        }
    }
}

In Flight Messages:
* TaskExecutor: 5 remaining (1000 received)
* WorkflowStateEngine: 2 remaining (500 received)